agentdb 3.0.0-alpha.2 → 3.0.0-alpha.4

package/dist/src/controllers/ReflexionMemory.js

@@ -7,33 +7,25 @@
  * Based on: "Reflexion: Language Agents with Verbal Reinforcement Learning"
  * https://arxiv.org/abs/2303.11366
  */
-import { normalizeRowId } from '../types/database.types.js';
 import { NodeIdMapper } from '../utils/NodeIdMapper.js';
-import { QueryCache } from '../core/QueryCache.js';
-import { cosineSimilarity } from '../utils/similarity.js';
+import { cosineSimilarity } from '../utils/vector-math.js';
 export class ReflexionMemory {
     db;
     embedder;
     vectorBackend;
     learningBackend;
     graphBackend;
-    queryCache;
-    constructor(db, embedder, vectorBackend, learningBackend, graphBackend, cacheConfig) {
+    constructor(db, embedder, vectorBackend, learningBackend, graphBackend) {
         this.db = db;
         this.embedder = embedder;
         this.vectorBackend = vectorBackend;
         this.learningBackend = learningBackend;
         this.graphBackend = graphBackend;
-        this.queryCache = new QueryCache(cacheConfig);
     }
     /**
      * Store a new episode with its critique and outcome
-     * Invalidates relevant cache entries
      */
     async storeEpisode(episode) {
-        // Invalidate episode caches on write
-        this.queryCache.invalidateCategory('episodes');
-        this.queryCache.invalidateCategory('task-stats');
         // Use GraphDatabaseAdapter if available (AgentDB v2)
         if (this.graphBackend && 'storeEpisode' in this.graphBackend) {
             // GraphDatabaseAdapter has specialized storeEpisode method
@@ -52,7 +44,7 @@ export class ReflexionMemory {
                 critique: episode.critique,
                 createdAt: episode.ts ? episode.ts * 1000 : Date.now(),
                 tokensUsed: episode.tokensUsed,
-                latencyMs: episode.latencyMs,
+                latencyMs: episode.latencyMs
             }, taskEmbedding);
             // Return a numeric ID (parse from string ID)
             const numericId = parseInt(nodeId.split('-').pop() || '0', 36);
@@ -77,14 +69,17 @@ export class ReflexionMemory {
                 tokensUsed: episode.tokensUsed || 0,
                 tags: episode.tags ? JSON.stringify(episode.tags) : '[]',
                 metadata: episode.metadata ? JSON.stringify(episode.metadata) : '{}',
-                createdAt: Date.now(),
+                createdAt: Date.now()
             });
             // Store embedding using vectorBackend if available
             if (this.vectorBackend && taskEmbedding) {
-                this.vectorBackend.insert(nodeId, taskEmbedding, {
-                    type: 'episode',
-                    sessionId: episode.sessionId,
-                });
+                try {
+                    this.vectorBackend.insert(nodeId, taskEmbedding, {
+                        type: 'episode',
+                        sessionId: episode.sessionId
+                    });
+                }
+                catch { /* vectorBackend insert failed — graph node still created */ }
             }
             // Return a numeric ID (parse from string ID)
             const numericId = parseInt(nodeId.split('-').pop() || '0', 36);
@@ -102,13 +97,16 @@ export class ReflexionMemory {
         const tags = episode.tags ? JSON.stringify(episode.tags) : null;
         const metadata = episode.metadata ? JSON.stringify(episode.metadata) : null;
         const result = stmt.run(episode.sessionId, episode.task, episode.input || null, episode.output || null, episode.critique || null, episode.reward, episode.success ? 1 : 0, episode.latencyMs || null, episode.tokensUsed || null, tags, metadata);
-        const episodeId = normalizeRowId(result.lastInsertRowid);
+        const episodeId = result.lastInsertRowid;
         // Generate and store embedding
         const text = this.buildEpisodeText(episode);
         const embedding = await this.embedder.embed(text);
         // Use vector backend if available (150x faster retrieval)
         if (this.vectorBackend) {
-            this.vectorBackend.insert(episodeId.toString(), embedding);
+            try {
+                this.vectorBackend.insert(episodeId.toString(), embedding);
+            }
+            catch { /* vectorBackend insert failed — SQL fallback used */ }
         }
         // Also store in SQL for fallback
         this.storeEmbedding(episodeId, embedding);
@@ -126,199 +124,155 @@ export class ReflexionMemory {
                     task: episode.task,
                     sessionId: episode.sessionId,
                     latencyMs: episode.latencyMs,
-                    tokensUsed: episode.tokensUsed,
-                },
+                    tokensUsed: episode.tokensUsed
+                }
             });
         }
         return episodeId;
     }
     /**
      * Retrieve relevant past episodes for a new task attempt
-     * Results are cached for improved performance
      */
     async retrieveRelevant(query) {
-        const { task, currentState = '', k = 5, minReward, onlyFailures = false, onlySuccesses = false, timeWindowDays, } = query;
-        // Check cache first
-        const cacheKey = this.queryCache.generateKey('retrieveRelevant', [task, currentState, k, minReward, onlyFailures, onlySuccesses, timeWindowDays], 'episodes');
-        const cached = this.queryCache.get(cacheKey);
-        if (cached) {
-            return cached;
-        }
-        // Generate and enhance query embedding
-        const queryEmbedding = await this.prepareQueryEmbedding(task, currentState, k);
-        // Try different retrieval strategies in order of preference
-        let episodes = [];
-        if (this.graphBackend && 'searchSimilarEpisodes' in this.graphBackend) {
-            episodes = await this.retrieveFromGraphAdapter(queryEmbedding, query);
-        }
-        else if (this.graphBackend && 'execute' in this.graphBackend) {
-            episodes = await this.retrieveFromGenericGraph(query);
-        }
-        else if (this.vectorBackend) {
-            episodes = await this.retrieveFromVectorBackend(queryEmbedding, query);
-        }
-        else {
-            episodes = await this.retrieveFromSQLFallback(queryEmbedding, query);
-        }
-        // Cache and return results
-        this.queryCache.set(cacheKey, episodes);
-        return episodes;
-    }
-    /**
-     * Prepare and enhance query embedding for search
-     */
-    async prepareQueryEmbedding(task, currentState, k) {
+        const { task, currentState = '', k = 5, minReward, onlyFailures = false, onlySuccesses = false, timeWindowDays } = query;
+        // Generate query embedding
         const queryText = currentState ? `${task}\n${currentState}` : task;
         let queryEmbedding = await this.embedder.embed(queryText);
         // Enhance query with GNN if learning backend available
         if (this.learningBackend) {
             queryEmbedding = await this.enhanceQueryWithGNN(queryEmbedding, k);
         }
-        return queryEmbedding;
-    }
-    /**
-     * Retrieve episodes using GraphDatabaseAdapter (AgentDB v2)
-     */
-    async retrieveFromGraphAdapter(queryEmbedding, query) {
-        const { k = 5, minReward, onlyFailures, onlySuccesses, timeWindowDays } = query;
-        const graphAdapter = this.graphBackend;
-        // Search using vector similarity
-        const results = await graphAdapter.searchSimilarEpisodes(queryEmbedding, k * 3);
-        // Apply filters (cast from graph results to typed format)
-        const typedResults = results;
-        const filtered = this.applyEpisodeFilters(typedResults, {
-            minReward,
-            onlyFailures,
-            onlySuccesses,
-            timeWindowDays,
-        });
-        // Convert to EpisodeWithEmbedding format
-        return filtered.slice(0, k).map((ep) => this.convertGraphEpisode(ep));
-    }
-    /**
-     * Retrieve episodes using generic GraphBackend
-     */
-    async retrieveFromGenericGraph(query) {
-        const { k = 5 } = query;
-        const cypherQuery = this.buildCypherQuery(query);
-        const result = await this.graphBackend.execute(cypherQuery);
-        // Convert to EpisodeWithEmbedding format
-        const episodes = result.rows.map((row) => this.convertCypherEpisode(row.e));
-        return episodes.slice(0, k);
-    }
-    /**
-     * Retrieve episodes using VectorBackend (150x faster)
-     */
-    async retrieveFromVectorBackend(queryEmbedding, query) {
-        const { k = 5, minReward, onlyFailures, onlySuccesses, timeWindowDays } = query;
-        // Get candidates from vector backend
-        const searchResults = this.vectorBackend.search(queryEmbedding, k * 3, {
-            threshold: 0.0,
-        });
-        // Fetch full episode data from DB
-        const episodeIds = searchResults.map((r) => parseInt(r.id));
-        if (episodeIds.length === 0) {
-            return [];
-        }
-        const rows = this.fetchEpisodesByIds(episodeIds);
-        const episodeMap = new Map(rows.map((r) => [r.id.toString(), r]));
-        // Map results with similarity scores and apply filters
-        const episodes = [];
-        for (const result of searchResults) {
-            const row = episodeMap.get(result.id);
-            if (!row)
-                continue;
+        // Use GraphDatabaseAdapter if available (AgentDB v2)
+        if (this.graphBackend && 'searchSimilarEpisodes' in this.graphBackend) {
+            const graphAdapter = this.graphBackend;
+            // Search using vector similarity
+            const results = await graphAdapter.searchSimilarEpisodes(queryEmbedding, k * 3);
             // Apply filters
-            if (!this.passesEpisodeFilters(row, { minReward, onlyFailures, onlySuccesses, timeWindowDays })) {
-                continue;
-            }
-            episodes.push(this.convertDatabaseEpisode(row, result.similarity));
-            if (episodes.length >= k)
-                break;
-        }
-        return episodes;
-    }
-    /**
-     * Retrieve episodes using SQL-based similarity search (fallback)
-     */
-    async retrieveFromSQLFallback(queryEmbedding, query) {
-        const { k = 5 } = query;
-        const { whereClause, params } = this.buildSQLFilters(query);
-        const stmt = this.db.prepare(`
-      SELECT e.*, ee.embedding
-      FROM episodes e
-      JOIN episode_embeddings ee ON e.id = ee.episode_id
-      ${whereClause}
-      ORDER BY e.reward DESC
-    `);
-        const rows = stmt.all(...params);
-        // Calculate similarities and convert
-        const episodes = rows.map((row) => {
-            const embedding = this.deserializeEmbedding(row.embedding);
-            const similarity = this.cosineSimilarity(queryEmbedding, embedding);
-            return this.convertDatabaseEpisode(row, similarity, embedding);
-        });
-        // Sort by similarity and return top-k
-        episodes.sort((a, b) => (b.similarity || 0) - (a.similarity || 0));
-        return episodes.slice(0, k);
-    }
-    /**
-     * Apply episode filters to search results
-     */
-    applyEpisodeFilters(episodes, filters) {
-        return episodes.filter((ep) => {
-            if (filters.minReward !== undefined && ep.reward < filters.minReward)
-                return false;
-            if (filters.onlyFailures && ep.success)
-                return false;
-            if (filters.onlySuccesses && !ep.success)
-                return false;
-            if (filters.timeWindowDays && ep.createdAt < Date.now() - filters.timeWindowDays * 86400000)
-                return false;
-            return true;
-        });
-    }
-    /**
-     * Check if database row passes episode filters
-     */
-    passesEpisodeFilters(row, filters) {
-        if (filters.minReward !== undefined && row.reward < filters.minReward)
-            return false;
-        if (filters.onlyFailures && row.success === 1)
-            return false;
-        if (filters.onlySuccesses && row.success === 0)
-            return false;
-        if (filters.timeWindowDays && row.ts < Date.now() / 1000 - filters.timeWindowDays * 86400)
-            return false;
-        return true;
-    }
-    /**
-     * Build Cypher query with filters
-     */
-    buildCypherQuery(query) {
-        const { k = 5, minReward, onlyFailures, onlySuccesses, timeWindowDays } = query;
-        let cypherQuery = 'MATCH (e:Episode) WHERE 1=1';
-        if (minReward !== undefined) {
-            cypherQuery += ` AND e.reward >= ${minReward}`;
-        }
-        if (onlyFailures) {
-            cypherQuery += ` AND e.success = false`;
+            const filtered = results.filter((ep) => {
+                if (minReward !== undefined && ep.reward < minReward)
+                    return false;
+                if (onlyFailures && ep.success)
+                    return false;
+                if (onlySuccesses && !ep.success)
+                    return false;
+                if (timeWindowDays && ep.createdAt < (Date.now() - timeWindowDays * 86400000))
+                    return false;
+                return true;
+            });
+            // Convert to EpisodeWithEmbedding format
+            const episodes = filtered.slice(0, k).map((ep) => ({
+                id: parseInt(ep.id.split('-').pop() || '0', 36),
+                sessionId: ep.sessionId,
+                task: ep.task,
+                input: ep.input,
+                output: ep.output,
+                critique: ep.critique,
+                reward: ep.reward,
+                success: ep.success,
+                latencyMs: ep.latencyMs,
+                tokensUsed: ep.tokensUsed,
+                ts: Math.floor(ep.createdAt / 1000)
+            }));
+            return episodes;
         }
-        if (onlySuccesses) {
-            cypherQuery += ` AND e.success = true`;
+        // Use generic GraphBackend if available
+        if (this.graphBackend && 'execute' in this.graphBackend) {
+            // Build Cypher query with filters
+            let cypherQuery = 'MATCH (e:Episode) WHERE 1=1';
+            if (minReward !== undefined) {
+                cypherQuery += ` AND e.reward >= ${minReward}`;
+            }
+            if (onlyFailures) {
+                cypherQuery += ` AND e.success = false`;
+            }
+            if (onlySuccesses) {
+                cypherQuery += ` AND e.success = true`;
+            }
+            if (timeWindowDays) {
+                const cutoff = Date.now() - timeWindowDays * 86400000;
+                cypherQuery += ` AND e.createdAt >= ${cutoff}`;
+            }
+            cypherQuery += ` RETURN e LIMIT ${k * 3}`;
+            const result = await this.graphBackend.execute(cypherQuery);
+            // Convert to EpisodeWithEmbedding format
+            const episodes = result.rows.map((row) => {
+                const node = row.e;
+                return {
+                    id: parseInt(node.id.split('-').pop() || '0', 36),
+                    sessionId: node.properties.sessionId,
+                    task: node.properties.task,
+                    input: node.properties.input,
+                    output: node.properties.output,
+                    critique: node.properties.critique,
+                    reward: typeof node.properties.reward === 'string' ? parseFloat(node.properties.reward) : node.properties.reward,
+                    success: typeof node.properties.success === 'string' ? node.properties.success === 'true' : node.properties.success,
+                    latencyMs: node.properties.latencyMs,
+                    tokensUsed: node.properties.tokensUsed,
+                    tags: node.properties.tags ? JSON.parse(node.properties.tags) : [],
+                    metadata: node.properties.metadata ? JSON.parse(node.properties.metadata) : {},
+                    ts: Math.floor(node.properties.createdAt / 1000)
+                };
+            });
+            return episodes.slice(0, k);
         }
-        if (timeWindowDays) {
-            const cutoff = Date.now() - timeWindowDays * 86400000;
-            cypherQuery += ` AND e.createdAt >= ${cutoff}`;
+        // Use optimized vector backend if available (150x faster)
+        if (this.vectorBackend) {
+            try {
+                // Get candidates from vector backend
+                const searchResults = this.vectorBackend.search(queryEmbedding, k * 3, {
+                    threshold: 0.0
+                });
+                // Fetch full episode data from DB
+                const episodeIds = searchResults.map(r => parseInt(r.id));
+                if (episodeIds.length === 0) {
+                    return [];
+                }
+                const placeholders = episodeIds.map(() => '?').join(',');
+                const stmt = this.db.prepare(`
+        SELECT * FROM episodes
+        WHERE id IN (${placeholders})
+      `);
+                const rows = stmt.all(...episodeIds);
+                const episodeMap = new Map(rows.map(r => [r.id.toString(), r]));
+                // Map results back with similarity scores and apply filters
+                const episodes = [];
+                for (const result of searchResults) {
+                    const row = episodeMap.get(result.id);
+                    if (!row)
+                        continue;
+                    // Apply additional filters
+                    if (minReward !== undefined && row.reward < minReward)
+                        continue;
+                    if (onlyFailures && row.success === 1)
+                        continue;
+                    if (onlySuccesses && row.success === 0)
+                        continue;
+                    if (timeWindowDays && row.ts < (Date.now() / 1000 - timeWindowDays * 86400))
+                        continue;
+                    episodes.push({
+                        id: row.id,
+                        ts: row.ts,
+                        sessionId: row.session_id,
+                        task: row.task,
+                        input: row.input,
+                        output: row.output,
+                        critique: row.critique,
+                        reward: row.reward,
+                        success: row.success === 1,
+                        latencyMs: row.latency_ms,
+                        tokensUsed: row.tokens_used,
+                        tags: row.tags ? JSON.parse(row.tags) : undefined,
+                        metadata: row.metadata ? JSON.parse(row.metadata) : undefined,
+                        similarity: result.similarity
+                    });
+                    if (episodes.length >= k)
+                        break;
+                }
+                return episodes;
+            }
+            catch { /* vectorBackend search failed — fall through to SQL */ }
         }
-        cypherQuery += ` RETURN e LIMIT ${k * 3}`;
-        return cypherQuery;
-    }
-    /**
-     * Build SQL WHERE clause and parameters for filters
-     */
-    buildSQLFilters(query) {
-        const { minReward, onlyFailures, onlySuccesses, timeWindowDays } = query;
+        // Fallback to SQL-based similarity search
         const filters = [];
         const params = [];
         if (minReward !== undefined) {
@@ -336,94 +290,46 @@ export class ReflexionMemory {
             params.push(timeWindowDays * 86400);
         }
         const whereClause = filters.length > 0 ? `WHERE ${filters.join(' AND ')}` : '';
-        return { whereClause, params };
-    }
-    /**
-     * Fetch episodes by IDs from database
-     */
-    fetchEpisodesByIds(episodeIds) {
-        const placeholders = episodeIds.map(() => '?').join(',');
         const stmt = this.db.prepare(`
-      SELECT * FROM episodes
-      WHERE id IN (${placeholders})
+      SELECT
+        e.*,
+        ee.embedding
+      FROM episodes e
+      JOIN episode_embeddings ee ON e.id = ee.episode_id
+      ${whereClause}
+      ORDER BY e.reward DESC
     `);
-        return stmt.all(...episodeIds);
-    }
-    /**
-     * Convert GraphDatabaseAdapter episode to EpisodeWithEmbedding
-     */
-    convertGraphEpisode(ep) {
-        return {
-            id: parseInt(ep.id.split('-').pop() || '0', 36),
-            sessionId: ep.sessionId,
-            task: ep.task,
-            input: ep.input,
-            output: ep.output,
-            critique: ep.critique,
-            reward: ep.reward,
-            success: ep.success,
-            latencyMs: ep.latencyMs,
-            tokensUsed: ep.tokensUsed,
-            ts: Math.floor(ep.createdAt / 1000),
-        };
-    }
-    /**
-     * Convert Cypher query result to EpisodeWithEmbedding
-     */
-    convertCypherEpisode(node) {
-        const props = node.properties;
-        return {
-            id: parseInt(node.id.split('-').pop() || '0', 36),
-            sessionId: props.sessionId,
-            task: props.task,
-            input: props.input,
-            output: props.output,
-            critique: props.critique,
-            reward: typeof props.reward === 'string'
-                ? parseFloat(props.reward)
-                : props.reward,
-            success: typeof props.success === 'string'
-                ? props.success === 'true'
-                : props.success,
-            latencyMs: props.latencyMs,
-            tokensUsed: props.tokensUsed,
-            tags: props.tags ? JSON.parse(props.tags) : [],
-            metadata: props.metadata ? JSON.parse(props.metadata) : {},
-            ts: Math.floor(props.createdAt / 1000),
-        };
-    }
-    /**
-     * Convert database row to EpisodeWithEmbedding
-     */
-    convertDatabaseEpisode(row, similarity, embedding) {
-        return {
-            id: row.id,
-            ts: row.ts,
-            sessionId: row.session_id,
-            task: row.task,
-            input: row.input ?? undefined,
-            output: row.output ?? undefined,
-            critique: row.critique ?? undefined,
-            reward: row.reward,
-            success: row.success === 1,
-            latencyMs: row.latency_ms ?? undefined,
-            tokensUsed: row.tokens_used ?? undefined,
-            tags: row.tags ? JSON.parse(row.tags) : undefined,
-            metadata: row.metadata ? JSON.parse(row.metadata) : undefined,
-            embedding,
-            similarity,
-        };
+        const rows = stmt.all(...params);
+        // Calculate similarities manually
+        const episodes = rows.map(row => {
+            const embedding = this.deserializeEmbedding(row.embedding);
+            const similarity = cosineSimilarity(queryEmbedding, embedding);
+            return {
+                id: row.id,
+                ts: row.ts,
+                sessionId: row.session_id,
+                task: row.task,
+                input: row.input,
+                output: row.output,
+                critique: row.critique,
+                reward: row.reward,
+                success: row.success === 1,
+                latencyMs: row.latency_ms,
+                tokensUsed: row.tokens_used,
+                tags: row.tags ? JSON.parse(row.tags) : undefined,
+                metadata: row.metadata ? JSON.parse(row.metadata) : undefined,
+                embedding,
+                similarity
+            };
+        });
+        // Sort by similarity and return top-k
+        episodes.sort((a, b) => (b.similarity || 0) - (a.similarity || 0));
+        return episodes.slice(0, k);
     }
     /**
-     * Get statistics for a task (cached)
+     * Get statistics for a task
      */
     getTaskStats(task, timeWindowDays) {
-        // Check cache first
-        const cacheKey = this.queryCache.generateKey('getTaskStats', [task, timeWindowDays], 'task-stats');
-        const cached = this.queryCache.get(cacheKey);
-        if (cached) {
-            return cached;
-        }
         const windowFilter = timeWindowDays
             ? `AND ts > strftime('%s', 'now') - ${timeWindowDays * 86400}`
             : '';
@@ -450,62 +356,44 @@ export class ReflexionMemory {
       WHERE task = ? ${windowFilter}
     `);
         const trend = trendStmt.get(task);
-        const improvementTrend = trend?.recent_reward && trend?.older_reward
+        const improvementTrend = trend.recent_reward && trend.older_reward
             ? (trend.recent_reward - trend.older_reward) / trend.older_reward
             : 0;
-        const results = {
-            totalAttempts: stats?.total ?? 0,
-            successRate: stats?.success_rate ?? 0,
-            avgReward: stats?.avg_reward ?? 0,
-            avgLatency: stats?.avg_latency ?? 0,
-            improvementTrend,
+        return {
+            totalAttempts: stats.total || 0,
+            successRate: stats.success_rate || 0,
+            avgReward: stats.avg_reward || 0,
+            avgLatency: stats.avg_latency || 0,
+            improvementTrend
         };
-        // Cache the results
-        this.queryCache.set(cacheKey, results);
-        return results;
     }
     /**
-     * Build critique summary from similar failed episodes (cached)
+     * Build critique summary from similar failed episodes
      */
     async getCritiqueSummary(query) {
-        // Check cache first
-        const cacheKey = this.queryCache.generateKey('getCritiqueSummary', [query.task, query.k], 'episodes');
-        const cached = this.queryCache.get(cacheKey);
-        if (cached) {
-            return cached;
-        }
         const failures = await this.retrieveRelevant({
             ...query,
             onlyFailures: true,
-            k: 3,
+            k: 3
         });
         if (failures.length === 0) {
             return 'No prior failures found for this task.';
         }
         const critiques = failures
-            .filter((ep) => ep.critique)
+            .filter(ep => ep.critique)
             .map((ep, i) => `${i + 1}. ${ep.critique} (reward: ${ep.reward.toFixed(2)})`)
             .join('\n');
-        const result = `Prior failures and lessons learned:\n${critiques}`;
-        // Cache the result
-        this.queryCache.set(cacheKey, result);
-        return result;
+        return `Prior failures and lessons learned:\n${critiques}`;
     }
     /**
-     * Get successful strategies for a task (cached)
+     * Get successful strategies for a task
      */
     async getSuccessStrategies(query) {
-        // Check cache first
-        const cacheKey = this.queryCache.generateKey('getSuccessStrategies', [query.task, query.k], 'episodes');
-        const cached = this.queryCache.get(cacheKey);
-        if (cached) {
-            return cached;
-        }
         const successes = await this.retrieveRelevant({
             ...query,
             onlySuccesses: true,
             minReward: 0.7,
-            k: 3,
+            k: 3
         });
         if (successes.length === 0) {
             return 'No successful strategies found for this task.';
@@ -516,10 +404,7 @@ export class ReflexionMemory {
             return `${i + 1}. Approach (reward ${ep.reward.toFixed(2)}): ${approach}...`;
         })
             .join('\n');
-        const result = `Successful strategies:\n${strategies}`;
-        // Cache the result
-        this.queryCache.set(cacheKey, result);
-        return result;
+        return `Successful strategies:\n${strategies}`;
     }
     /**
      * Get recent episodes for a session
@@ -532,25 +417,24 @@ export class ReflexionMemory {
       LIMIT ?
     `);
         const rows = stmt.all(sessionId, limit);
-        return rows.map((row) => ({
+        return rows.map(row => ({
             id: row.id,
             ts: row.ts,
             sessionId: row.session_id,
             task: row.task,
-            input: row.input ?? undefined,
-            output: row.output ?? undefined,
-            critique: row.critique ?? undefined,
+            input: row.input,
+            output: row.output,
+            critique: row.critique,
             reward: row.reward,
             success: row.success === 1,
-            latencyMs: row.latency_ms ?? undefined,
-            tokensUsed: row.tokens_used ?? undefined,
+            latencyMs: row.latency_ms,
+            tokensUsed: row.tokens_used,
             tags: row.tags ? JSON.parse(row.tags) : undefined,
-            metadata: row.metadata ? JSON.parse(row.metadata) : undefined,
+            metadata: row.metadata ? JSON.parse(row.metadata) : undefined
         }));
     }
     /**
      * Prune low-quality episodes based on TTL and quality threshold
-     * Invalidates cache on completion
      */
     pruneEpisodes(config) {
         const { minReward = 0.3, maxAgeDays = 30, keepMinPerTask = 5 } = config;
@@ -571,11 +455,6 @@ export class ReflexionMemory {
       )
     `);
         const result = stmt.run(minReward, maxAgeDays * 86400, keepMinPerTask);
-        // Invalidate caches after pruning
-        if (result.changes > 0) {
-            this.queryCache.invalidateCategory('episodes');
-            this.queryCache.invalidateCategory('task-stats');
-        }
         return result.changes;
     }
     // ========================================================================
@@ -606,9 +485,6 @@ export class ReflexionMemory {
     deserializeEmbedding(buffer) {
         return new Float32Array(buffer.buffer, buffer.byteOffset, buffer.length / 4);
     }
-    cosineSimilarity(a, b) {
-        return cosineSimilarity(a, b);
-    }
     // ========================================================================
     // GNN and Graph Integration Methods
     // ========================================================================
@@ -627,7 +503,7 @@ export class ReflexionMemory {
             success: episode.success,
             timestamp: episode.ts || Date.now(),
             latencyMs: episode.latencyMs,
-            tokensUsed: episode.tokensUsed,
+            tokensUsed: episode.tokensUsed
         });
         // Find similar episodes using graph vector search
         const similarEpisodes = await this.graphBackend.vectorSearch(embedding, 5, nodeId);
@@ -635,8 +511,8 @@ export class ReflexionMemory {
         for (const similar of similarEpisodes) {
             if (similar.id !== nodeId && similar.properties.episodeId !== episodeId) {
                 await this.graphBackend.createRelationship(nodeId, similar.id, 'SIMILAR_TO', {
-                    similarity: this.cosineSimilarity(embedding, similar.embedding || new Float32Array()),
-                    createdAt: Date.now(),
+                    similarity: cosineSimilarity(embedding, similar.embedding || new Float32Array()),
+                    createdAt: Date.now()
                 });
             }
         }
@@ -647,15 +523,13 @@ export class ReflexionMemory {
             // Create session node if doesn't exist
             sessionNodeId = await this.graphBackend.createNode(['Session'], {
                 sessionId: episode.sessionId,
-                startTime: episode.ts || Date.now(),
+                startTime: episode.ts || Date.now()
             });
         }
         else {
             sessionNodeId = sessionNodes.rows[0].s.id;
         }
-        await this.graphBackend.createRelationship(nodeId, sessionNodeId, 'BELONGS_TO_SESSION', {
-            timestamp: episode.ts || Date.now(),
-        });
+        await this.graphBackend.createRelationship(nodeId, sessionNodeId, 'BELONGS_TO_SESSION', { timestamp: episode.ts || Date.now() });
         // If episode has critique, create causal relationship to previous failures
         if (episode.critique && !episode.success) {
             const previousFailures = await this.graphBackend.execute(`MATCH (e:Episode:Failure {sessionId: $sessionId})
@@ -666,7 +540,7 @@ export class ReflexionMemory {
             for (const prevFailure of previousFailures.rows) {
                 await this.graphBackend.createRelationship(nodeId, prevFailure.e.id, 'LEARNED_FROM', {
                     critique: episode.critique,
-                    improvementAttempt: true,
+                    improvementAttempt: true
                 });
             }
         }
@@ -681,7 +555,7 @@ export class ReflexionMemory {
         try {
             // Get initial neighbors
             const initialResults = this.vectorBackend.search(queryEmbedding, k * 2, {
-                threshold: 0.0,
+                threshold: 0.0
             });
             if (initialResults.length === 0) {
                 return queryEmbedding;
@@ -689,16 +563,14 @@ export class ReflexionMemory {
             // Fetch neighbor embeddings
             const neighborEmbeddings = [];
             const weights = [];
-            const episodeIds = initialResults.map((r) => r.id);
+            const episodeIds = initialResults.map(r => r.id);
             const placeholders = episodeIds.map(() => '?').join(',');
-            const episodes = this.db
-                .prepare(`
+            const episodes = this.db.prepare(`
         SELECT ee.embedding, e.reward
         FROM episode_embeddings ee
         JOIN episodes e ON e.id = ee.episode_id
         WHERE ee.episode_id IN (${placeholders})
-      `)
-                .all(...episodeIds);
+      `).all(...episodeIds);
             for (const ep of episodes) {
                 const embedding = this.deserializeEmbedding(ep.embedding);
                 neighborEmbeddings.push(embedding);
@@ -735,7 +607,7 @@ export class ReflexionMemory {
         return {
             similar: (row.similar || []).filter((id) => id != null),
             session: row.session || '',
-            learnedFrom: (row.learnedFrom || []).filter((id) => id != null),
+            learnedFrom: (row.learnedFrom || []).filter((id) => id != null)
         };
     }
     /**
@@ -756,7 +628,7 @@ export class ReflexionMemory {
             epochs: result.epochs,
             finalLoss: result.finalLoss.toFixed(4),
             improvement: `${(result.improvement * 100).toFixed(1)}%`,
-            duration: `${result.duration}ms`,
+            duration: `${result.duration}ms`
         });
     }
     /**
@@ -777,35 +649,5 @@ export class ReflexionMemory {
         }
         return this.graphBackend.getStats();
     }
-    /**
-     * Get query cache statistics
-     */
-    getCacheStats() {
-        return this.queryCache.getStatistics();
-    }
-    /**
-     * Clear query cache
-     */
-    clearCache() {
-        this.queryCache.clear();
-    }
-    /**
-     * Prune expired cache entries
-     */
-    pruneCache() {
-        return this.queryCache.pruneExpired();
-    }
-    /**
-     * Warm cache with common queries
-     */
-    async warmCache(sessionId) {
-        await this.queryCache.warm(async (_cache) => {
-            // Warm cache with recent sessions if sessionId provided
-            if (sessionId) {
-                await this.getRecentEpisodes(sessionId, 10);
-                // Episodes are already loaded, cache will be populated on next access
-            }
-        });
-    }
 }
 //# sourceMappingURL=ReflexionMemory.js.map