libre-webui 0.21.3 → 0.22.0

package/backend/dist/services/memoryService.js

@@ -1,28 +1,85 @@
 /*
  * Libre WebUI
  * Copyright (C) 2025 Kroonen AI, Inc.
- *
  * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at:
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
  */
-import { getDatabaseSafe } from '../db.js';
-import embeddingService from './embeddingService.js';
+import crypto from 'node:crypto';
 import { v4 as uuidv4 } from 'uuid';
+import { getPlatformStorageRuntime } from '../platform/storage/index.js';
+import { assertPersonaMemoryStillReferenced } from '../platform/storage/personaMemoryIndexing.js';
 import { createLogger } from '../utils/logger.js';
-import { applyMemoryDecay, calculateEnhancedImportance, classifyMemoryType, cosineSimilarity, createConsolidatedContent, embeddingArrayToBuffer, embeddingBufferToArray, getMemoryColumnType, toPersonaMemoryEntry, } from './memoryUtils.js';
+import embeddingService from './embeddingService.js';
+import { applyMemoryDecay, calculateEnhancedImportance, classifyMemoryType, createConsolidatedContent, } from './memoryUtils.js';
 const logger = createLogger('memory');
+const MEMORY_VECTOR_NAMESPACE = 'persona-memory';
+const MEMORY_VECTOR_VERSION = 'v1';
+const entryFromRecord = (record) => ({
+    id: record.id,
+    user_id: record.userId,
+    persona_id: record.personaId,
+    content: record.content,
+    timestamp: record.timestamp,
+    ...(record.context ? { context: record.context } : {}),
+    importance_score: record.importanceScore,
+    memory_type: record.memoryType,
+    access_count: record.accessCount,
+    ...(record.lastAccessed ? { last_accessed: record.lastAccessed } : {}),
+    decay_factor: record.decayFactor,
+    ...(record.consolidatedFrom
+        ? { consolidated_from: record.consolidatedFrom }
+        : {}),
+});
+const sourceRevision = (content) => crypto.createHash('sha256').update(content, 'utf8').digest('hex');
+const deterministicMemoryId = (input) => {
+    const digest = crypto
+        .createHash('sha256')
+        .update(JSON.stringify([
+        'libre-persona-memory-v1',
+        input.userId,
+        input.personaId,
+        input.content,
+        input.context ?? null,
+        input.importanceScore,
+        input.memoryType,
+    ]), 'utf8')
+        .digest()
+        .subarray(0, 16);
+    // RFC 9562 UUIDv8 reserves this version for application-defined hashes.
+    digest[6] = (digest[6] & 0x0f) | 0x80;
+    digest[8] = (digest[8] & 0x3f) | 0x80;
+    const hex = digest.toString('hex');
+    return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-${hex.slice(12, 16)}-${hex.slice(16, 20)}-${hex.slice(20)}`;
+};
+const sameMemoryIntent = (persisted, requested) => persisted.id === requested.id &&
+    persisted.userId === requested.userId &&
+    persisted.personaId === requested.personaId &&
+    persisted.content === requested.content &&
+    persisted.context === requested.context &&
+    persisted.memoryType === requested.memoryType;
+const retainedOutcomeError = (message, cause) => {
+    const error = new Error(message);
+    Object.defineProperty(error, 'cause', {
+        value: cause,
+        enumerable: false,
+    });
+    return error;
+};
+const combinedOutcomeCause = (message, cause, relatedError) => {
+    const error = retainedOutcomeError(message, cause);
+    Object.defineProperty(error, 'relatedError', {
+        value: relatedError,
+        enumerable: false,
+    });
+    return error;
+};
+const validateImportance = (value) => {
+    if (!Number.isFinite(value) || value < 0 || value > 1) {
+        throw new Error('Memory importance must be between 0 and 1');
+    }
+    return value;
+};
 export class MemoryService {
     constructor() {
-        this.db = getDatabaseSafe();
         this.embeddingModels = [
             {
                 id: 'nomic-embed-text',
@@ -48,7 +105,7 @@ export class MemoryService {
             {
                 id: 'text-embedding-3-small',
                 name: 'OpenAI Text Embedding 3 Small',
-                description: "OpenAI's smaller, faster text embedding model",
+                description: "OpenAI's smaller, faster embedding model",
                 provider: 'openai',
                 dimensions: 1536,
             },
@@ -60,127 +117,22 @@ export class MemoryService {
                 dimensions: 1024,
             },
         ];
-        this.initializeTables();
-    }
-    /**
-     * Ensure database is available
-     */
-    ensureDatabase() {
-        if (!this.db) {
-            throw new Error('Database not available');
-        }
-        return this.db;
     }
-    initializeTables() {
-        if (!this.db) {
-            logger.warn('MemoryService: Database not available, skipping table initialization');
-            return;
-        }
-        // Persona memories table - create with basic schema first
-        this.db.exec(`
-      CREATE TABLE IF NOT EXISTS persona_memories (
-        id TEXT PRIMARY KEY,
-        user_id TEXT NOT NULL,
-        persona_id TEXT NOT NULL,
-        content TEXT NOT NULL,
-        embedding BLOB, -- Stored as binary for efficiency
-        timestamp INTEGER NOT NULL,
-        context TEXT,
-        importance_score REAL DEFAULT 0.5,
-        FOREIGN KEY (user_id) REFERENCES users(id) ON DELETE CASCADE,
-        FOREIGN KEY (persona_id) REFERENCES personas(id) ON DELETE CASCADE
-      )
-    `);
-        // Create basic indexes first (on columns that always exist)
-        this.db.exec(`
-      CREATE INDEX IF NOT EXISTS idx_persona_memories_user_persona ON persona_memories(user_id, persona_id);
-      CREATE INDEX IF NOT EXISTS idx_persona_memories_timestamp ON persona_memories(timestamp);
-      CREATE INDEX IF NOT EXISTS idx_persona_memories_importance ON persona_memories(importance_score);
-    `);
-        // Add new columns if they don't exist (migration for existing databases)
-        // This MUST happen before creating indexes on new columns
-        this.migrateDatabase();
-        // Now create indexes on the new columns (after migration ensures they exist)
-        try {
-            this.db.exec(`
-        CREATE INDEX IF NOT EXISTS idx_persona_memories_type ON persona_memories(memory_type);
-        CREATE INDEX IF NOT EXISTS idx_persona_memories_last_accessed ON persona_memories(last_accessed);
-      `);
-        }
-        catch (error) {
-            // Indexes may already exist, ignore
-            logger.warn('[MemoryService] Index creation:', error);
-        }
-    }
-    /**
-     * Migrate database to add new columns for existing tables
-     */
-    migrateDatabase() {
-        if (!this.db)
-            return;
-        try {
-            // Check if new columns exist and add them if not
-            const columns = [
-                'memory_type',
-                'access_count',
-                'last_accessed',
-                'decay_factor',
-                'consolidated_from',
-            ];
-            const defaults = {
-                memory_type: "'general'",
-                access_count: '0',
-                last_accessed: 'NULL',
-                decay_factor: '1.0',
-                consolidated_from: 'NULL',
-            };
-            for (const column of columns) {
-                try {
-                    this.db.exec(`ALTER TABLE persona_memories ADD COLUMN ${column} ${getMemoryColumnType(column)} DEFAULT ${defaults[column]}`);
-                    logger.debug(`[MemoryService] Added column ${column} to persona_memories`);
-                }
-                catch {
-                    // Column likely already exists, ignore
-                }
-            }
-        }
-        catch (error) {
-            logger.warn('[MemoryService] Migration check:', error);
-        }
-    }
-    /**
-     * Classify memory content into a type
-     */
     classifyMemoryType(content) {
         return classifyMemoryType(content);
     }
-    /**
-     * Calculate enhanced importance score based on multiple factors
-     */
     calculateEnhancedImportance(content, memoryType, _context) {
         return calculateEnhancedImportance(content, memoryType);
     }
-    /**
-     * Apply time-based decay to importance score
-     */
     applyDecay(originalImportance, timestamp, accessCount = 0, lastAccessed) {
         return applyMemoryDecay(originalImportance, timestamp, accessCount, lastAccessed);
     }
-    /**
-     * Get available embedding models
-     */
     getEmbeddingModels() {
-        return this.embeddingModels;
+        return [...this.embeddingModels];
     }
-    /**
-     * Generate embedding for text using specified model
-     */
     async generateEmbedding(text, model, userId) {
         try {
-            const response = await embeddingService.generateEmbeddings({
-                model,
-                input: text,
-            }, userId);
+            const response = await embeddingService.generateEmbeddings({ model, input: text }, userId);
             return response.embeddings[0] || null;
         }
         catch (error) {
@@ -188,513 +140,416 @@ export class MemoryService {
             return null;
         }
     }
-    /**
-     * Store a memory entry with embedding and automatic classification
-     */
+    async indexRecord(record, embeddingModel, embedding) {
+        if (!embedding?.length)
+            return;
+        const platform = getPlatformStorageRuntime();
+        await platform.vectorStore.upsert({
+            actor: { userId: record.userId },
+            records: [
+                {
+                    namespace: MEMORY_VECTOR_NAMESPACE,
+                    id: record.id,
+                    ownerUserId: record.userId,
+                    resourceId: record.personaId,
+                    model: embeddingModel,
+                    dimensions: embedding.length,
+                    version: MEMORY_VECTOR_VERSION,
+                    sourceRevision: sourceRevision(record.content),
+                    embedding,
+                    attributes: { memoryType: record.memoryType },
+                },
+            ],
+        });
+        // Relational persona deletion and vector persistence cannot share one
+        // transaction. Recheck the authoritative memory row after the upsert so a
+        // delete that wins either side of that boundary cannot leave (or recreate)
+        // an orphan vector after resource.delete.v1 has already cleaned the
+        // persona namespace.
+        await assertPersonaMemoryStillReferenced(platform, record, MEMORY_VECTOR_NAMESPACE);
+    }
+    async hasAuthoritativeVector(record, embeddingModel, embedding) {
+        const hits = await getPlatformStorageRuntime().vectorStore.query({
+            actor: { userId: record.userId },
+            namespace: MEMORY_VECTOR_NAMESPACE,
+            model: embeddingModel,
+            dimensions: embedding.length,
+            version: MEMORY_VECTOR_VERSION,
+            embedding,
+            limit: 100,
+            minScore: 1 - 1e-6,
+            resourceIds: [record.personaId],
+            attributes: { memoryType: record.memoryType },
+        });
+        const expectedRevision = sourceRevision(record.content);
+        return hits.some(hit => hit.id === record.id &&
+            hit.ownerUserId === record.userId &&
+            hit.resourceId === record.personaId &&
+            hit.model === embeddingModel &&
+            hit.dimensions === embedding.length &&
+            hit.version === MEMORY_VECTOR_VERSION &&
+            hit.sourceRevision === expectedRevision &&
+            hit.attributes.memoryType === record.memoryType);
+    }
+    async backfillLegacy(records, embeddingModel) {
+        for (const record of records) {
+            if (!record.legacyEmbedding?.length)
+                continue;
+            await this.indexRecord(record, embeddingModel, record.legacyEmbedding);
+        }
+    }
     async storeMemory(userId, personaId, content, embeddingModel, context, importanceScore, memoryType) {
-        const id = uuidv4();
-        const timestamp = Date.now();
-        // Auto-classify memory type if not provided
         const classifiedType = memoryType || this.classifyMemoryType(content);
-        // Calculate enhanced importance if not provided
-        const calculatedImportance = importanceScore !== undefined
-            ? importanceScore
-            : this.calculateEnhancedImportance(content, classifiedType, context);
-        // Check for similar existing memories before storing
-        const existingSimilar = await this.findSimilarMemories(userId, personaId, content, embeddingModel, 0.85 // High similarity threshold for deduplication
-        );
-        // If very similar memory exists, reinforce it instead of creating new
-        if (existingSimilar.length > 0) {
-            const mostSimilar = existingSimilar[0];
-            logger.debug(`[MEMORY] Found similar memory (${(mostSimilar.similarity_score * 100).toFixed(1)}% similar), reinforcing instead of creating new`);
-            await this.reinforceMemory(mostSimilar.entry.id);
-            return mostSimilar.entry;
-        }
-        // Generate embedding
+        const calculatedImportance = validateImportance(importanceScore ??
+            this.calculateEnhancedImportance(content, classifiedType, context));
+        const normalizedContext = context || undefined;
         const embedding = await this.generateEmbedding(content, embeddingModel, userId);
-        const db = this.ensureDatabase();
-        const stmt = db.prepare(`
-      INSERT INTO persona_memories (
-        id, user_id, persona_id, content, embedding, timestamp, context, importance_score,
-        memory_type, access_count, last_accessed, decay_factor
-      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
-    `);
-        stmt.run(id, userId, personaId, content, embedding ? embeddingArrayToBuffer(embedding) : null, timestamp, context || null, calculatedImportance, classifiedType, 0, // access_count
-        null, // last_accessed
-        1.0 // decay_factor
-        );
-        logger.debug(`[MEMORY] Stored: type=${classifiedType}, importance=${calculatedImportance.toFixed(2)}, id=${id}, content="${content.substring(0, 50)}..."`);
-        return {
-            id,
-            user_id: userId,
-            persona_id: personaId,
+        if (embedding) {
+            const existing = await this.findSimilarMemories(userId, personaId, embedding, embeddingModel, 0.85);
+            if (existing[0]) {
+                await this.reinforceMemory(existing[0].entry.id, userId, personaId);
+                return existing[0].entry;
+            }
+        }
+        const requestedRecord = {
+            id: deterministicMemoryId({
+                userId,
+                personaId,
+                content,
+                ...(normalizedContext ? { context: normalizedContext } : {}),
+                importanceScore: calculatedImportance,
+                memoryType: classifiedType,
+            }),
+            userId,
+            personaId,
             content,
-            embedding: embedding || undefined,
-            timestamp,
-            context,
-            importance_score: calculatedImportance,
-            memory_type: classifiedType,
-            access_count: 0,
-            decay_factor: 1.0,
+            timestamp: Date.now(),
+            ...(normalizedContext ? { context: normalizedContext } : {}),
+            importanceScore: calculatedImportance,
+            memoryType: classifiedType,
+            accessCount: 0,
+            decayFactor: 1,
         };
-    }
-    /**
-     * Find similar memories (for deduplication)
-     */
-    async findSimilarMemories(userId, personaId, content, embeddingModel, minSimilarity) {
-        const queryEmbedding = await this.generateEmbedding(content, embeddingModel, userId);
-        if (!queryEmbedding)
-            return [];
-        const db = this.ensureDatabase();
-        const stmt = db.prepare(`
-      SELECT id, user_id, persona_id, content, embedding, timestamp, context, importance_score,
-             memory_type, access_count, last_accessed, decay_factor
-      FROM persona_memories
-      WHERE user_id = ? AND persona_id = ? AND embedding IS NOT NULL
-      ORDER BY timestamp DESC
-      LIMIT 50
-    `);
-        const memories = stmt.all(userId, personaId);
-        const results = [];
-        for (const memory of memories) {
-            if (!memory.embedding)
-                continue;
-            const embeddingArray = embeddingBufferToArray(memory.embedding);
-            const similarity = cosineSimilarity(queryEmbedding, embeddingArray);
-            if (similarity >= minSimilarity) {
-                results.push({
-                    entry: {
-                        id: memory.id,
-                        user_id: memory.user_id,
-                        persona_id: memory.persona_id,
-                        content: memory.content,
-                        embedding: embeddingArray,
-                        timestamp: memory.timestamp,
-                        context: memory.context || undefined,
-                        importance_score: memory.importance_score,
-                    },
-                    similarity_score: similarity,
-                    relevance_rank: 0,
-                });
+        const repository = getPlatformStorageRuntime().domains.memories;
+        let record = requestedRecord;
+        try {
+            await repository.insert(requestedRecord);
+        }
+        catch (insertError) {
+            let persisted;
+            try {
+                persisted = await repository.findByOwner(requestedRecord.id, userId, personaId);
+            }
+            catch (resolutionError) {
+                throw retainedOutcomeError('Could not resolve the persona memory insert outcome; retry with the same payload', combinedOutcomeCause('Persona memory insert and outcome resolution both failed', insertError, resolutionError));
+            }
+            if (!persisted)
+                throw insertError;
+            if (!sameMemoryIntent(persisted, requestedRecord)) {
+                throw retainedOutcomeError('The deterministic persona memory identifier belongs to another payload', insertError);
+            }
+            record = persisted;
+        }
+        if (embedding?.length) {
+            try {
+                await this.indexRecord(record, embeddingModel, embedding);
+            }
+            catch (indexError) {
+                let persisted;
+                try {
+                    persisted = await repository.findByOwner(record.id, userId, personaId);
+                }
+                catch (resolutionError) {
+                    throw retainedOutcomeError('Could not resolve the persona memory vector outcome; the relational memory was retained for idempotent retry', combinedOutcomeCause('Persona memory vector publication and outcome resolution both failed', indexError, resolutionError));
+                }
+                if (!persisted) {
+                    try {
+                        await getPlatformStorageRuntime().vectorStore.delete({
+                            actor: { userId },
+                            namespace: MEMORY_VECTOR_NAMESPACE,
+                            ids: [record.id],
+                        });
+                    }
+                    catch (cleanupError) {
+                        throw retainedOutcomeError('Persona memory disappeared during indexing and vector cleanup failed', combinedOutcomeCause('Persona memory vector publication and cleanup both failed', indexError, cleanupError));
+                    }
+                    throw indexError;
+                }
+                if (!sameMemoryIntent(persisted, requestedRecord)) {
+                    throw retainedOutcomeError('The persona memory changed while its vector outcome was being resolved', indexError);
+                }
+                let committed = false;
+                try {
+                    committed = await this.hasAuthoritativeVector(persisted, embeddingModel, embedding);
+                }
+                catch (resolutionError) {
+                    throw retainedOutcomeError('Could not resolve the persona memory vector outcome; the relational memory was retained for idempotent retry', combinedOutcomeCause('Persona memory vector publication and outcome resolution both failed', indexError, resolutionError));
+                }
+                if (!committed) {
+                    throw retainedOutcomeError('Persona memory vector publication was not confirmed; the relational memory was retained for idempotent retry', indexError);
+                }
+                // The vector may have committed after its acknowledgement was lost.
+                // Recheck the SQL row once more so a concurrent persona deletion still
+                // wins and compensates the vector before this call reports success.
+                await assertPersonaMemoryStillReferenced(getPlatformStorageRuntime(), persisted, MEMORY_VECTOR_NAMESPACE);
+                record = persisted;
             }
         }
-        return results.sort((a, b) => b.similarity_score - a.similarity_score);
+        return entryFromRecord(record);
     }
-    /**
-     * Reinforce a memory (increases importance and access count)
-     */
-    async reinforceMemory(memoryId) {
-        const db = this.ensureDatabase();
-        const stmt = db.prepare(`
-      UPDATE persona_memories
-      SET access_count = COALESCE(access_count, 0) + 1,
-          last_accessed = ?,
-          importance_score = MIN(1.0, COALESCE(importance_score, 0.5) + 0.05)
-      WHERE id = ?
-    `);
-        const result = stmt.run(Date.now(), memoryId);
-        return result.changes > 0;
+    async findSimilarMemories(userId, personaId, embedding, embeddingModel, minSimilarity) {
+        const repository = getPlatformStorageRuntime().domains.memories;
+        const records = await repository.listByOwner(userId, personaId, {
+            limit: 100,
+        });
+        await this.backfillLegacy(records, embeddingModel);
+        const byId = new Map(records.map(record => [record.id, record]));
+        const hits = await getPlatformStorageRuntime().vectorStore.query({
+            actor: { userId },
+            namespace: MEMORY_VECTOR_NAMESPACE,
+            model: embeddingModel,
+            dimensions: embedding.length,
+            version: MEMORY_VECTOR_VERSION,
+            embedding,
+            limit: 50,
+            minScore: minSimilarity,
+            resourceIds: [personaId],
+        });
+        return hits.flatMap((hit, index) => {
+            const record = byId.get(hit.id);
+            return record
+                ? [
+                    {
+                        entry: entryFromRecord(record),
+                        similarity_score: hit.score,
+                        relevance_rank: index + 1,
+                    },
+                ]
+                : [];
+        });
+    }
+    async reinforceMemory(memoryId, userId, personaId) {
+        return getPlatformStorageRuntime().domains.memories.reinforce(memoryId, userId, personaId, Date.now());
     }
-    /**
-     * Search memories using semantic similarity with enhanced relevance scoring
-     */
-    async searchMemories(userId, personaId, query, embeddingModel, topK = 5, minSimilarity = 0.3, memoryTypes // Optional filter by memory types
-    ) {
-        // Generate embedding for query
-        const queryEmbedding = await this.generateEmbedding(query, embeddingModel, userId);
-        if (!queryEmbedding) {
+    async searchMemories(userId, personaId, query, embeddingModel, topK = 5, minSimilarity = 0.3, memoryTypes) {
+        const requestedTopK = Number.isFinite(topK) ? Math.trunc(topK) : 5;
+        const normalizedTopK = Math.min(Math.max(requestedTopK, 1), 100);
+        const embedding = await this.generateEmbedding(query, embeddingModel, userId);
+        if (!embedding)
             return [];
-        }
-        // Get all memories for this user/persona with embeddings
-        const db = this.ensureDatabase();
-        let sql = `
-      SELECT id, user_id, persona_id, content, embedding, timestamp, context, importance_score,
-             memory_type, access_count, last_accessed, decay_factor
-      FROM persona_memories
-      WHERE user_id = ? AND persona_id = ? AND embedding IS NOT NULL
-    `;
-        // Add memory type filter if specified
-        if (memoryTypes && memoryTypes.length > 0) {
-            sql += ` AND memory_type IN (${memoryTypes.map(() => '?').join(',')})`;
-        }
-        sql += ` ORDER BY timestamp DESC`;
-        const stmt = db.prepare(sql);
-        const params = memoryTypes
-            ? [userId, personaId, ...memoryTypes]
-            : [userId, personaId];
-        const memories = stmt.all(...params);
-        // Calculate enhanced relevance scores
-        const results = [];
-        for (const memory of memories) {
-            // Convert buffer back to float array
-            if (!memory.embedding)
-                continue;
-            const embeddingArray = embeddingBufferToArray(memory.embedding);
-            const similarity = cosineSimilarity(queryEmbedding, embeddingArray);
-            if (similarity >= minSimilarity) {
-                // Calculate decayed importance
-                const decayedImportance = this.applyDecay(memory.importance_score, memory.timestamp, memory.access_count || 0, memory.last_accessed || undefined);
-                results.push({
-                    entry: {
-                        id: memory.id,
-                        user_id: memory.user_id,
-                        persona_id: memory.persona_id,
-                        content: memory.content,
-                        embedding: embeddingArray,
-                        timestamp: memory.timestamp,
-                        context: memory.context || undefined,
-                        importance_score: decayedImportance,
-                    },
-                    similarity_score: similarity,
-                    relevance_rank: 0, // Will be set after sorting
-                });
-            }
-        }
-        // Sort by composite relevance score
-        results.sort((a, b) => {
-            const now = Date.now();
-            const ageA = (now - a.entry.timestamp) / (1000 * 60 * 60);
-            const ageB = (now - b.entry.timestamp) / (1000 * 60 * 60);
-            const recencyA = ageA < 24 ? 0.1 : ageA < 168 ? 0.05 : 0;
-            const recencyB = ageB < 24 ? 0.1 : ageB < 168 ? 0.05 : 0;
-            const scoreA = a.similarity_score * 0.5 +
-                (a.entry.importance_score || 0.5) * 0.25 +
-                recencyA;
-            const scoreB = b.similarity_score * 0.5 +
-                (b.entry.importance_score || 0.5) * 0.25 +
-                recencyB;
-            return scoreB - scoreA;
+        const records = await getPlatformStorageRuntime().domains.memories.listByOwner(userId, personaId, {
+            limit: 10000,
+            ...(memoryTypes?.length ? { types: memoryTypes } : {}),
         });
-        // Update access count for returned memories
-        const topResults = results.slice(0, topK);
-        for (const result of topResults) {
-            await this.updateMemoryAccess(result.entry.id);
-        }
-        // Set relevance ranks and return top-k
-        return topResults.map((result, index) => ({
+        await this.backfillLegacy(records, embeddingModel);
+        const byId = new Map(records.map(record => [record.id, record]));
+        const hits = await getPlatformStorageRuntime().vectorStore.query({
+            actor: { userId },
+            namespace: MEMORY_VECTOR_NAMESPACE,
+            model: embeddingModel,
+            dimensions: embedding.length,
+            version: MEMORY_VECTOR_VERSION,
+            embedding,
+            limit: Math.min(normalizedTopK * 10, 100),
+            minScore: minSimilarity,
+            resourceIds: [personaId],
+        });
+        const now = Date.now();
+        const results = hits.flatMap(hit => {
+            const record = byId.get(hit.id);
+            if (!record)
+                return [];
+            const decayed = this.applyDecay(record.importanceScore, record.timestamp, record.accessCount, record.lastAccessed);
+            const ageHours = (now - record.timestamp) / (1000 * 60 * 60);
+            const recency = ageHours < 24 ? 0.1 : ageHours < 168 ? 0.05 : 0;
+            return [
+                {
+                    entry: { ...entryFromRecord(record), importance_score: decayed },
+                    similarity_score: hit.score,
+                    relevance_rank: 0,
+                    composite: hit.score * 0.5 + decayed * 0.25 + recency,
+                },
+            ];
+        });
+        results.sort((left, right) => right.composite - left.composite);
+        const top = results.slice(0, normalizedTopK);
+        await getPlatformStorageRuntime().domains.memories.markAccessed(top.map(item => item.entry.id), userId, personaId, now);
+        return top.map(({ composite: _composite, ...result }, index) => ({
             ...result,
             relevance_rank: index + 1,
         }));
     }
-    /**
-     * Update memory access tracking
-     */
-    async updateMemoryAccess(memoryId) {
-        try {
-            const db = this.ensureDatabase();
-            const stmt = db.prepare(`
-        UPDATE persona_memories
-        SET access_count = COALESCE(access_count, 0) + 1,
-            last_accessed = ?
-        WHERE id = ?
-      `);
-            stmt.run(Date.now(), memoryId);
-        }
-        catch (error) {
-            logger.warn('[MemoryService] Failed to update memory access:', error);
-        }
-    }
-    /**
-     * Get all memories for a persona
-     */
     async getMemories(userId, personaId, limit = 100, offset = 0) {
-        const db = this.ensureDatabase();
-        const stmt = db.prepare(`
-      SELECT id, user_id, persona_id, content, embedding, timestamp, context, importance_score
-      FROM persona_memories
-      WHERE user_id = ? AND persona_id = ?
-      ORDER BY timestamp DESC
-      LIMIT ? OFFSET ?
-    `);
-        const memories = stmt.all(userId, personaId, limit, offset);
-        return memories.map(toPersonaMemoryEntry);
+        const records = await getPlatformStorageRuntime().domains.memories.listByOwner(userId, personaId, { limit, offset });
+        return records.map(entryFromRecord);
     }
-    /**
-     * Get memory count for a persona
-     */
     async getMemoryCount(userId, personaId) {
-        const db = this.ensureDatabase();
-        const stmt = db.prepare(`
-      SELECT COUNT(*) as count
-      FROM persona_memories
-      WHERE user_id = ? AND persona_id = ?
-    `);
-        const result = stmt.get(userId, personaId);
-        return result.count;
+        return getPlatformStorageRuntime().domains.memories.countByOwner(userId, personaId);
     }
-    /**
-     * Get memory status for a persona
-     */
     async getMemoryStatus(userId, personaId) {
-        try {
-            const memoryCount = await this.getMemoryCount(userId, personaId);
-            // Calculate approximate memory size (rough estimate)
-            const avgMemorySize = 1024; // Average bytes per memory entry
-            const sizeMb = (memoryCount * avgMemorySize) / (1024 * 1024);
-            return {
-                memory_count: memoryCount,
-                last_backup: undefined, // Could be implemented later
-                size_mb: Math.round(sizeMb * 100) / 100, // Round to 2 decimal places
-            };
-        }
-        catch (error) {
-            logger.error('Error getting memory status:', error);
-            throw new Error('Failed to get memory status');
-        }
+        const count = await this.getMemoryCount(userId, personaId);
+        return {
+            memory_count: count,
+            last_backup: undefined,
+            size_mb: Math.round(((count * 1024) / (1024 * 1024)) * 100) / 100,
+        };
     }
-    /**
-     * Delete all memories for a persona (wipe)
-     */
     async wipeMemories(userId, personaId) {
-        const db = this.ensureDatabase();
-        const stmt = db.prepare(`
-      DELETE FROM persona_memories
-      WHERE user_id = ? AND persona_id = ?
-    `);
-        const result = stmt.run(userId, personaId);
-        return result.changes;
+        await getPlatformStorageRuntime().vectorStore.delete({
+            actor: { userId },
+            namespace: MEMORY_VECTOR_NAMESPACE,
+            resourceId: personaId,
+        });
+        return getPlatformStorageRuntime().domains.memories.deleteAllByOwner(userId, personaId);
     }
-    /**
-     * Export memories for backup
-     */
     async exportMemories(userId, personaId) {
-        return this.getMemories(userId, personaId, 10000); // Export all
+        return this.getMemories(userId, personaId, 10000, 0);
     }
-    /**
-     * Import memories from backup
-     */
     async importMemories(memories, targetUserId) {
         let imported = 0;
-        const db = this.ensureDatabase();
-        const stmt = db.prepare(`
-      INSERT INTO persona_memories (
-        id, user_id, persona_id, content, embedding, timestamp, context, importance_score
-      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?)
-    `);
+        const repository = getPlatformStorageRuntime().domains.memories;
         for (const memory of memories) {
+            const record = {
+                id: memory.id,
+                userId: targetUserId,
+                personaId: memory.persona_id,
+                content: memory.content,
+                timestamp: memory.timestamp,
+                ...(memory.context ? { context: memory.context } : {}),
+                importanceScore: validateImportance(memory.importance_score ?? 0.5),
+                memoryType: classifyMemoryType(memory.content),
+                accessCount: 0,
+                decayFactor: 1,
+            };
             try {
-                stmt.run(memory.id, targetUserId, // Use target user ID
-                memory.persona_id, memory.content, memory.embedding ? embeddingArrayToBuffer(memory.embedding) : null, memory.timestamp, memory.context || null, memory.importance_score || 0.5);
-                imported++;
+                await repository.insert(record);
+                if (memory.embedding?.length) {
+                    await this.indexRecord(record, 'legacy-import', memory.embedding);
+                }
+                imported += 1;
             }
             catch (error) {
                 logger.error('Failed to import memory:', error);
-                // Continue with next memory
             }
         }
         return imported;
     }
-    /**
-     * Update memory importance score
-     */
-    async updateMemoryImportance(memoryId, importanceScore) {
-        const db = this.ensureDatabase();
-        const stmt = db.prepare(`
-      UPDATE persona_memories
-      SET importance_score = ?
-      WHERE id = ?
-    `);
-        const result = stmt.run(importanceScore, memoryId);
-        return result.changes > 0;
+    async updateMemoryImportance(memoryId, userId, personaId, importanceScore) {
+        return getPlatformStorageRuntime().domains.memories.updateImportance(memoryId, userId, personaId, validateImportance(importanceScore));
     }
-    /**
-     * Delete old memories based on retention policy
-     */
     async cleanupOldMemories(userId, personaId, retentionDays) {
-        const cutoffTimestamp = Date.now() - retentionDays * 24 * 60 * 60 * 1000;
-        const db = this.ensureDatabase();
-        const stmt = db.prepare(`
-      DELETE FROM persona_memories
-      WHERE user_id = ? AND persona_id = ? AND timestamp < ?
-      AND importance_score < 0.7
-    `);
-        const result = stmt.run(userId, personaId, cutoffTimestamp);
-        return result.changes;
+        const repository = getPlatformStorageRuntime().domains.memories;
+        const ids = await repository.findOldLowImportanceIds(userId, personaId, Date.now() - retentionDays * 24 * 60 * 60 * 1000, 0.7);
+        if (ids.length) {
+            await getPlatformStorageRuntime().vectorStore.delete({
+                actor: { userId },
+                namespace: MEMORY_VECTOR_NAMESPACE,
+                ids,
+            });
+            await repository.deleteIds(ids, userId, personaId);
+        }
+        return ids.length;
     }
-    /**
-     * Consolidate similar memories to reduce redundancy and save space
-     * This merges memories with high similarity into a single, more comprehensive memory
-     */
     async consolidateMemories(userId, personaId, embeddingModel, similarityThreshold = 0.8) {
-        const db = this.ensureDatabase();
+        const repository = getPlatformStorageRuntime().domains.memories;
+        const records = await repository.listByOwner(userId, personaId, {
+            limit: 10000,
+        });
+        const remaining = new Map(records.map(record => [record.id, record]));
         let consolidated = 0;
         let deleted = 0;
-        try {
-            // Get all memories with embeddings
-            const stmt = db.prepare(`
-        SELECT id, content, embedding, timestamp, importance_score, memory_type, access_count
-        FROM persona_memories
-        WHERE user_id = ? AND persona_id = ? AND embedding IS NOT NULL
-        ORDER BY importance_score DESC, timestamp DESC
-      `);
-            const memories = stmt.all(userId, personaId);
-            const processedIds = new Set();
-            const toDelete = [];
-            for (let i = 0; i < memories.length; i++) {
-                const memory = memories[i];
-                if (processedIds.has(memory.id))
-                    continue;
-                const embeddingA = embeddingBufferToArray(memory.embedding);
-                const similarMemories = [];
-                // Find similar memories
-                for (let j = i + 1; j < memories.length; j++) {
-                    const other = memories[j];
-                    if (processedIds.has(other.id))
-                        continue;
-                    const embeddingB = embeddingBufferToArray(other.embedding);
-                    const similarity = cosineSimilarity(embeddingA, embeddingB);
-                    if (similarity >= similarityThreshold) {
-                        similarMemories.push(other);
-                        processedIds.add(other.id);
-                    }
-                }
-                // If we found similar memories, consolidate them
-                if (similarMemories.length > 0) {
-                    processedIds.add(memory.id);
-                    // Create consolidated content
-                    const allContent = [
-                        memory.content,
-                        ...similarMemories.map(m => m.content),
-                    ];
-                    const consolidatedContent = createConsolidatedContent(allContent);
-                    // Calculate combined importance (weighted average with boost)
-                    const allImportances = [
-                        memory.importance_score,
-                        ...similarMemories.map(m => m.importance_score),
-                    ];
-                    const avgImportance = allImportances.reduce((a, b) => a + b, 0) / allImportances.length;
-                    const consolidatedImportance = Math.min(1.0, avgImportance * 1.1); // 10% boost for consolidation
-                    // Use the most common memory type
-                    const types = [
-                        memory.memory_type,
-                        ...similarMemories.map(m => m.memory_type),
-                    ].filter(Boolean);
-                    const typeCount = {};
-                    types.forEach(t => {
-                        if (t)
-                            typeCount[t] = (typeCount[t] || 0) + 1;
-                    });
-                    const consolidatedType = Object.entries(typeCount).sort((a, b) => b[1] - a[1])[0]?.[0] ||
-                        'general';
-                    // Generate new embedding for consolidated content
-                    const newEmbedding = await this.generateEmbedding(consolidatedContent, embeddingModel, userId);
-                    // Store consolidated memory
-                    const consolidatedFromIds = [
-                        memory.id,
-                        ...similarMemories.map(m => m.id),
-                    ];
-                    const insertStmt = db.prepare(`
-            INSERT INTO persona_memories (
-              id, user_id, persona_id, content, embedding, timestamp, context, importance_score,
-              memory_type, access_count, last_accessed, decay_factor, consolidated_from
-            ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
-          `);
-                    insertStmt.run(uuidv4(), userId, personaId, consolidatedContent, newEmbedding ? embeddingArrayToBuffer(newEmbedding) : null, Date.now(), `Consolidated from ${consolidatedFromIds.length} memories`, consolidatedImportance, consolidatedType, similarMemories.reduce((sum, m) => sum + (m.access_count || 0), memory.access_count || 0), Date.now(), 1.0, JSON.stringify(consolidatedFromIds));
-                    // Mark original memories for deletion
-                    toDelete.push(...consolidatedFromIds);
-                    consolidated++;
-                }
+        for (const record of records) {
+            if (!remaining.has(record.id))
+                continue;
+            const embedding = await this.generateEmbedding(record.content, embeddingModel, userId);
+            if (!embedding)
+                continue;
+            await this.indexRecord(record, embeddingModel, embedding);
+            const similar = await this.findSimilarMemories(userId, personaId, embedding, embeddingModel, similarityThreshold);
+            const matches = similar
+                .map(item => remaining.get(item.entry.id))
+                .filter((item) => Boolean(item && item.id !== record.id));
+            if (matches.length === 0)
+                continue;
+            const group = [record, ...matches];
+            const content = createConsolidatedContent(group.map(item => item.content));
+            const importance = Math.min(1, (group.reduce((sum, item) => sum + item.importanceScore, 0) /
+                group.length) *
+                1.1);
+            const combinedEmbedding = await this.generateEmbedding(content, embeddingModel, userId);
+            const combinedRecord = {
+                id: uuidv4(),
+                userId,
+                personaId,
+                content,
+                timestamp: Date.now(),
+                context: `Consolidated from ${group.length} memories`,
+                importanceScore: importance,
+                memoryType: record.memoryType,
+                accessCount: 0,
+                decayFactor: 1,
+                consolidatedFrom: group.map(item => item.id),
+            };
+            await repository.insert(combinedRecord);
+            try {
+                await this.indexRecord(combinedRecord, embeddingModel, combinedEmbedding || undefined);
             }
-            // Delete original memories that were consolidated
-            if (toDelete.length > 0) {
-                const deleteStmt = db.prepare(`
-          DELETE FROM persona_memories WHERE id IN (${toDelete.map(() => '?').join(',')})
-        `);
-                deleteStmt.run(...toDelete);
-                deleted = toDelete.length;
+            catch (error) {
+                await repository.deleteIds([combinedRecord.id], userId, personaId);
+                throw error;
             }
-            logger.debug(`[MEMORY] Consolidation complete: ${consolidated} groups merged, ${deleted} memories deleted`);
-        }
-        catch (error) {
-            logger.error('[MEMORY] Consolidation error:', error);
+            const ids = group.map(item => item.id);
+            await getPlatformStorageRuntime().vectorStore.delete({
+                actor: { userId },
+                namespace: MEMORY_VECTOR_NAMESPACE,
+                ids,
+            });
+            await repository.deleteIds(ids, userId, personaId);
+            for (const id of ids)
+                remaining.delete(id);
+            remaining.set(combinedRecord.id, combinedRecord);
+            consolidated += 1;
+            deleted += ids.length;
         }
         return { consolidated, deleted };
     }
-    /**
-     * Get memory statistics for a persona
-     */
     async getMemoryStats(userId, personaId) {
-        const db = this.ensureDatabase();
-        // Get counts by type
-        const typeStmt = db.prepare(`
-      SELECT memory_type, COUNT(*) as count
-      FROM persona_memories
-      WHERE user_id = ? AND persona_id = ?
-      GROUP BY memory_type
-    `);
-        const typeCounts = typeStmt.all(userId, personaId);
-        // Get aggregate stats
-        const statsStmt = db.prepare(`
-      SELECT
-        COUNT(*) as total_count,
-        AVG(importance_score) as avg_importance,
-        MIN(timestamp) as oldest_memory,
-        MAX(timestamp) as newest_memory,
-        SUM(COALESCE(access_count, 0)) as total_accesses
-      FROM persona_memories
-      WHERE user_id = ? AND persona_id = ?
-    `);
-        const stats = statsStmt.get(userId, personaId);
-        const byType = {};
-        typeCounts.forEach(({ memory_type, count }) => {
-            byType[memory_type || 'general'] = count;
-        });
+        const stats = await getPlatformStorageRuntime().domains.memories.statistics(userId, personaId);
         return {
-            total_count: stats.total_count,
-            by_type: byType,
-            avg_importance: stats.avg_importance || 0.5,
-            oldest_memory: stats.oldest_memory,
-            newest_memory: stats.newest_memory,
-            total_accesses: stats.total_accesses || 0,
+            total_count: stats.totalCount,
+            by_type: stats.byType,
+            avg_importance: stats.averageImportance,
+            oldest_memory: stats.oldestMemory,
+            newest_memory: stats.newestMemory,
+            total_accesses: stats.totalAccesses,
         };
     }
-    /**
-     * Apply decay to all memories (should be called periodically)
-     */
     async applyGlobalDecay(userId, personaId) {
-        const db = this.ensureDatabase();
-        // Get all memories
-        const selectStmt = db.prepare(`
-      SELECT id, importance_score, timestamp, access_count, last_accessed
-      FROM persona_memories
-      WHERE user_id = ? AND persona_id = ?
-    `);
-        const memories = selectStmt.all(userId, personaId);
+        const repository = getPlatformStorageRuntime().domains.memories;
+        const records = await repository.listByOwner(userId, personaId, {
+            limit: 10000,
+        });
         let updated = 0;
-        const updateStmt = db.prepare(`
-      UPDATE persona_memories
-      SET importance_score = ?, decay_factor = ?
-      WHERE id = ?
-    `);
-        for (const memory of memories) {
-            const newImportance = this.applyDecay(memory.importance_score, memory.timestamp, memory.access_count || 0, memory.last_accessed || undefined);
-            // Only update if importance changed significantly
-            if (Math.abs(newImportance - memory.importance_score) > 0.01) {
-                const decayFactor = newImportance / memory.importance_score;
-                updateStmt.run(newImportance, decayFactor, memory.id);
-                updated++;
-            }
+        for (const record of records) {
+            const importance = this.applyDecay(record.importanceScore, record.timestamp, record.accessCount, record.lastAccessed);
+            if (Math.abs(importance - record.importanceScore) <= 0.01)
+                continue;
+            await repository.updateImportance(record.id, userId, personaId, importance, record.importanceScore === 0 ? 1 : importance / record.importanceScore);
+            updated += 1;
         }
-        logger.debug(`[MEMORY] Applied decay to ${updated} memories`);
         return updated;
     }
-    /**
-     * Get important memories (facts, preferences, instructions) that should always be included
-     */
     async getCoreMemories(userId, personaId, limit = 5) {
-        const db = this.ensureDatabase();
-        const stmt = db.prepare(`
-      SELECT id, user_id, persona_id, content, embedding, timestamp, context, importance_score,
-             memory_type, access_count, last_accessed
-      FROM persona_memories
-      WHERE user_id = ? AND persona_id = ?
-        AND memory_type IN ('fact', 'preference', 'instruction')
-        AND importance_score >= 0.7
-      ORDER BY importance_score DESC, access_count DESC
-      LIMIT ?
-    `);
-        const memories = stmt.all(userId, personaId, limit);
-        return memories.map(toPersonaMemoryEntry);
+        const records = await getPlatformStorageRuntime().domains.memories.listByOwner(userId, personaId, {
+            limit: Math.min(Math.max(limit, 1), 100),
+            types: ['fact', 'preference', 'instruction'],
+            minimumImportance: 0.7,
+        });
+        return records
+            .sort((left, right) => right.importanceScore - left.importanceScore ||
+            right.accessCount - left.accessCount)
+            .slice(0, limit)
+            .map(entryFromRecord);
     }
 }
 export const memoryService = new MemoryService();