cogxai 2.8.0

package/dist/core/memory.js

@@ -0,0 +1,1432 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports._setOwnerWallet = _setOwnerWallet;
+exports.getOwnerWallet = getOwnerWallet;
+exports.scopeToOwner = scopeToOwner;
+exports.generateHashId = generateHashId;
+exports.isValidHashId = isValidHashId;
+exports.inferConcepts = inferConcepts;
+exports.storeMemory = storeMemory;
+exports.recallMemories = recallMemories;
+exports.scoreMemory = scoreMemory;
+exports.recallMemorySummaries = recallMemorySummaries;
+exports.hydrateMemories = hydrateMemories;
+exports.createMemoryLink = createMemoryLink;
+exports.decayMemories = decayMemories;
+exports.getMemoryStats = getMemoryStats;
+exports.getRecentMemories = getRecentMemories;
+exports.getSelfModel = getSelfModel;
+exports.storeDreamLog = storeDreamLog;
+exports.formatMemoryContext = formatMemoryContext;
+exports.calculateImportance = calculateImportance;
+exports.scoreImportanceWithLLM = scoreImportanceWithLLM;
+exports.moodToValence = moodToValence;
+const database_1 = require("./database");
+const logger_1 = require("./logger");
+const utils_1 = require("../utils");
+const claude_client_1 = require("./claude-client");
+const solana_client_1 = require("./solana-client");
+const embeddings_1 = require("./embeddings");
+const venice_client_1 = require("./venice-client");
+const encryption_1 = require("./encryption");
+const event_bus_1 = require("../events/event-bus");
+// ---- EMBEDDING CACHE ---- //
+const EMBED_CACHE_MAX = 200;
+const embeddingCache = new Map();
+function getCachedEmbedding(query) {
+    const entry = embeddingCache.get(query);
+    if (entry && Date.now() - entry.ts < 5 * 60 * 1000)
+        return entry.embedding; // 5 min TTL
+    return null;
+}
+function setCachedEmbedding(query, embedding) {
+    if (embeddingCache.size >= EMBED_CACHE_MAX) {
+        // Evict oldest
+        let oldest = Infinity, oldKey = '';
+        for (const [k, v] of embeddingCache) {
+            if (v.ts < oldest) {
+                oldest = v.ts;
+                oldKey = k;
+            }
+        }
+        if (oldKey)
+            embeddingCache.delete(oldKey);
+    }
+    embeddingCache.set(query, { embedding, ts: Date.now() });
+}
+const crypto_1 = require("crypto");
+const memory_graph_1 = require("./memory-graph");
+const owner_context_1 = require("./owner-context");
+// ---- OWNER WALLET ---- //
+let _ownerWallet = null;
+/** @internal Set the owner wallet address for tagging memories. */
+function _setOwnerWallet(wallet) {
+    _ownerWallet = wallet;
+}
+/** Get the configured owner wallet, if any. Checks async context first (hosted API), then module-level (SDK/bot). */
+function getOwnerWallet() {
+    // AsyncLocalStorage takes priority (request-scoped for hosted API)
+    const contextWallet = (0, owner_context_1.getContextOwnerWallet)();
+    if (contextWallet !== undefined)
+        return contextWallet;
+    // Fallback to module-level (SDK / main bot)
+    return _ownerWallet;
+}
+/**
+ * Apply owner_wallet scoping to a Supabase query builder.
+ * When an owner wallet is set, filters to only that wallet's memories.
+ * When null, no filter is applied (backward-compatible).
+ */
+function scopeToOwner(query) {
+    const wallet = getOwnerWallet();
+    if (wallet) {
+        return query.eq('owner_wallet', wallet);
+    }
+    return query;
+}
+// ============================================================
+// HASH-BASED IDs (Beads-inspired)
+//
+// Generate short, collision-resistant IDs like "cogxai-a1b2c3d4"
+// instead of sequential integers. Benefits:
+// - No merge conflicts when multiple agents create memories
+// - IDs remain stable across database migrations
+// - Human-readable and URL-safe
+// ============================================================
+const HASH_ID_PREFIX = 'cogxai';
+/**
+ * Generate a collision-resistant hash ID for a memory.
+ * Format: cogxai-xxxxxxxx (8 hex chars = 4 bytes = 4 billion possibilities)
+ */
+function generateHashId() {
+    return `${HASH_ID_PREFIX}-${(0, crypto_1.randomBytes)(4).toString('hex')}`;
+}
+/**
+ * Validate a hash ID format.
+ */
+function isValidHashId(id) {
+    return /^cogxai-[a-f0-9]{8}$/.test(id);
+}
+const log = (0, logger_1.createChildLogger)('memory');
+// ---- CONCEPT ONTOLOGY ---- //
+/**
+ * Auto-classify memories into structured concepts using keyword heuristics.
+ * Provides consistent cross-cutting knowledge labels without LLM cost.
+ * Concepts are additive to freeform tags, not a replacement.
+ */
+function inferConcepts(summary, source, tags) {
+    const concepts = [];
+    const lower = summary.toLowerCase();
+    const tagSet = new Set(tags.map(t => t.toLowerCase()));
+    if (source === 'market' || tagSet.has('price') || /price|pump|dump|ath|market|volume/.test(lower))
+        concepts.push('market_event');
+    if (/whale|holder|seller|buyer|exit|accumula/.test(lower))
+        concepts.push('holder_behavior');
+    if (source === 'reflection' || source === 'emergence' || /myself|i am|i feel|identity|who i/.test(lower))
+        concepts.push('self_insight');
+    if (source === 'mention' || /tweet|reply|said|asked|mentioned|dm/.test(lower))
+        concepts.push('social_interaction');
+    if (/pattern|trend|recurring|always|usually|community/.test(lower))
+        concepts.push('community_pattern');
+    if (/token|sol|mint|swap|transfer|liquidity|staking/.test(lower))
+        concepts.push('token_economics');
+    if (/mood|sentiment|feel|vibe|energy|atmosphere/.test(lower))
+        concepts.push('sentiment_shift');
+    if (tagSet.has('first_interaction') || /returning|regular|again|came back/.test(lower))
+        concepts.push('recurring_user');
+    if (/whale|large|massive|huge|big (buy|sell)/.test(lower))
+        concepts.push('whale_activity');
+    if (/price|chart|candle|volume|mcap|cap/.test(lower))
+        concepts.push('price_action');
+    if (/engagement|likes|retweet|viral|reach|impressions/.test(lower))
+        concepts.push('engagement_pattern');
+    if (source === 'emergence' || /becoming|evolving|changed|grew|identity/.test(lower))
+        concepts.push('identity_evolution');
+    return [...new Set(concepts)];
+}
+// ---- STORE ---- //
+async function storeMemory(opts) {
+    const db = (0, database_1.getDb)();
+    // Auto-classify concepts if not explicitly provided
+    const concepts = opts.concepts || inferConcepts(opts.summary, opts.source, opts.tags || []);
+    // Generate collision-resistant hash ID (Beads-inspired)
+    const hashId = generateHashId();
+    try {
+        // Encrypt content if encryption is enabled (content only — summary/tags/metadata stay plaintext)
+        const plaintextContent = opts.content.slice(0, utils_1.MEMORY_MAX_CONTENT_LENGTH);
+        const shouldEncrypt = (0, encryption_1.isEncryptionEnabled)();
+        const storedContent = shouldEncrypt ? (0, encryption_1.encryptContent)(plaintextContent) : plaintextContent;
+        const { data, error } = await db
+            .from('memories')
+            .insert({
+            hash_id: hashId,
+            memory_type: opts.type,
+            content: storedContent,
+            summary: opts.summary.slice(0, utils_1.MEMORY_MAX_SUMMARY_LENGTH),
+            tags: opts.tags || [],
+            concepts,
+            emotional_valence: (0, utils_1.clamp)(opts.emotionalValence ?? 0, -1, 1),
+            importance: (0, utils_1.clamp)(opts.importance ?? 0.5, 0, 1),
+            source: opts.source,
+            source_id: opts.sourceId || null,
+            related_user: opts.relatedUser || null,
+            related_wallet: opts.relatedWallet || null,
+            metadata: opts.metadata || {},
+            evidence_ids: opts.evidenceIds || [],
+            compacted: false,
+            encrypted: shouldEncrypt,
+            encryption_pubkey: shouldEncrypt ? (0, encryption_1.getEncryptionPubkey)() : null,
+            owner_wallet: getOwnerWallet() || null,
+        })
+            .select('id, hash_id')
+            .single();
+        if (error) {
+            log.error({ error: error.message }, 'Failed to store memory');
+            return null;
+        }
+        log.debug({
+            id: data.id,
+            hashId: data.hash_id,
+            type: opts.type,
+            summary: opts.summary.slice(0, 60),
+            importance: opts.importance,
+            concepts,
+        }, 'Memory stored');
+        // Notify reflection trigger system (Park et al. 2023 — event-driven reflection)
+        event_bus_1.eventBus.emit('memory:stored', {
+            importance: (0, utils_1.clamp)(opts.importance ?? 0.5, 0, 1),
+            memoryType: opts.type,
+        });
+        // Commit memory to Solana (fire-and-forget)
+        commitMemoryToChain(data.id, opts).catch(err => log.warn({ err }, 'On-chain memory commit failed'));
+        // Generate embeddings and store fragments (fire-and-forget)
+        embedMemory(data.id, opts).catch(err => log.warn({ err }, 'Embedding generation failed'));
+        // Auto-link to related memories (fire-and-forget, runs after embedding is available)
+        autoLinkMemory(data.id, opts).catch(err => log.warn({ err }, 'Auto-linking failed'));
+        // Extract entities and build knowledge graph (fire-and-forget)
+        extractAndLinkEntitiesForMemory(data.id, opts).catch(err => log.debug({ err }, 'Entity extraction failed'));
+        return data.id;
+    }
+    catch (err) {
+        log.error({ err }, 'Memory store failed');
+        return null;
+    }
+}
+// ---- ON-CHAIN COMMIT ---- //
+async function commitMemoryToChain(memoryId, opts) {
+    // Skip mainnet commits for demo memories (they use devnet instead)
+    if (opts.source === 'demo' || opts.source === 'demo-maas')
+        return;
+    const contentHashBuf = (0, crypto_1.createHash)('sha256').update(opts.content).digest();
+    let signature = null;
+    // Try on-chain registry first, fall back to memo
+    if ((0, solana_client_1.isRegistryEnabled)()) {
+        const encrypted = (0, encryption_1.isEncryptionEnabled)();
+        signature = await (0, solana_client_1.registerMemoryOnChain)(contentHashBuf, opts.type, opts.importance ?? 0.5, memoryId, encrypted);
+    }
+    // Fallback to memo if registry unavailable or failed
+    if (!signature) {
+        const contentHashHex = contentHashBuf.toString('hex');
+        const memo = `cogxai-memory | id: ${memoryId} | type: ${opts.type} | hash: ${contentHashHex.slice(0, 16)} | ${opts.summary.slice(0, 400)}`;
+        signature = await (0, solana_client_1.writeMemo)(memo);
+    }
+    if (!signature)
+        return;
+    const db = (0, database_1.getDb)();
+    await db
+        .from('memories')
+        .update({ solana_signature: signature })
+        .eq('id', memoryId);
+    log.debug({ memoryId, signature: signature.slice(0, 16) }, 'Memory committed on-chain');
+}
+// ---- EMBEDDING & GRANULAR DECOMPOSITION ---- //
+/**
+ * Generate vector embedding for a memory and decompose into semantic fragments.
+ * Each fragment gets its own embedding for precise sub-memory retrieval.
+ *
+ * Fragment types:
+ *   summary     — the memory's summary (always stored)
+ *   content_chunk — content split at natural boundaries
+ *   tag_context — tags + concepts as a descriptive sentence
+ */
+async function embedMemory(memoryId, opts) {
+    if (!(0, embeddings_1.isEmbeddingEnabled)())
+        return;
+    const db = (0, database_1.getDb)();
+    // Build fragment texts for granular decomposition
+    const fragments = [];
+    // Fragment 1: Summary (always)
+    fragments.push({ type: 'summary', text: opts.summary });
+    // Fragment 2+: Content chunks (split at sentence/paragraph boundaries)
+    const content = opts.content.slice(0, utils_1.MEMORY_MAX_CONTENT_LENGTH);
+    if (content.length > utils_1.EMBEDDING_FRAGMENT_MAX_LENGTH) {
+        const sentences = content.match(/[^.!?\n]+[.!?\n]+/g) || [content];
+        let chunk = '';
+        for (const sentence of sentences) {
+            if (chunk.length + sentence.length > utils_1.EMBEDDING_FRAGMENT_MAX_LENGTH && chunk.length > 0) {
+                fragments.push({ type: 'content_chunk', text: chunk.trim() });
+                chunk = '';
+            }
+            chunk += sentence;
+        }
+        if (chunk.trim())
+            fragments.push({ type: 'content_chunk', text: chunk.trim() });
+    }
+    else {
+        fragments.push({ type: 'content_chunk', text: content });
+    }
+    // Fragment 3: Tag/concept context as natural language
+    const allLabels = [...(opts.tags || []), ...(opts.concepts || inferConcepts(opts.summary, opts.source, opts.tags || []))];
+    if (allLabels.length > 0) {
+        fragments.push({ type: 'tag_context', text: `Context: ${allLabels.join(', ')}. ${opts.summary}` });
+    }
+    // Batch-generate all embeddings
+    const embeddings = await (0, embeddings_1.generateEmbeddings)(fragments.map(f => f.text));
+    // Store primary embedding on the memory itself (summary embedding)
+    const summaryEmbedding = embeddings[0];
+    if (summaryEmbedding) {
+        await db
+            .from('memories')
+            .update({ embedding: JSON.stringify(summaryEmbedding) })
+            .eq('id', memoryId);
+    }
+    // Store all fragments with their embeddings
+    const fragmentRows = fragments.map((f, i) => ({
+        memory_id: memoryId,
+        fragment_type: f.type,
+        content: f.text.slice(0, utils_1.EMBEDDING_FRAGMENT_MAX_LENGTH),
+        embedding: embeddings[i] ? JSON.stringify(embeddings[i]) : null,
+    })).filter(r => r.embedding !== null);
+    if (fragmentRows.length > 0) {
+        const { error } = await db.from('memory_fragments').insert(fragmentRows);
+        if (error) {
+            log.warn({ error: error.message, memoryId }, 'Failed to store memory fragments');
+        }
+    }
+    log.debug({ memoryId, fragments: fragmentRows.length }, 'Memory embedded with fragments');
+}
+// ---- RECALL ---- //
+/**
+ * Hybrid retrieval combining vector similarity, keyword matching, and structured scoring.
+ *
+ * When embeddings are available:
+ *   1. Generate query embedding
+ *   2. Run vector search (memory-level + fragment-level) for semantic candidates
+ *   3. Merge with metadata-filtered candidates from Supabase
+ *   4. Score all candidates with enhanced composite formula
+ *
+ * When embeddings are unavailable:
+ *   Falls back to existing keyword + tag + importance scoring.
+ *
+ * score = (w_recency * recency + w_relevance * relevance + w_importance * importance
+ *          + w_vector * vector_similarity) * decay_factor
+ */
+// ---- QUERY EXPANSION ---- //
+/**
+ * Expand a query into multiple search angles using a fast LLM.
+ * Returns the original query + 2-3 reformulations for broader vector coverage.
+ * Falls back to just the original query if LLM is unavailable or slow.
+ */
+async function expandQuery(query) {
+    if (!(0, venice_client_1.isVeniceEnabled)())
+        return [query];
+    try {
+        const response = await Promise.race([
+            (0, venice_client_1.generateVeniceResponse)({
+                systemPrompt: 'You are a search query expander. Given a question, output 3 alternative phrasings that would help find relevant information in a memory database. Output ONLY the 3 alternatives, one per line. No numbering, no explanations.',
+                messages: [{ role: 'user', content: query }],
+                model: 'llama-3.2-3b',
+                maxTokens: 150,
+                temperature: 0.3,
+                cognitiveFunction: 'entity', // Use fast model slot
+            }),
+            new Promise((_, reject) => setTimeout(() => reject(new Error('timeout')), 3000)),
+        ]);
+        const expansions = response
+            .split('\n')
+            .map(l => l.trim())
+            .filter(l => l.length > 5 && l.length < 200)
+            .slice(0, 3);
+        log.debug({ original: query, expansions: expansions.length }, 'Query expanded');
+        return [query, ...expansions];
+    }
+    catch (err) {
+        log.debug({ err }, 'Query expansion failed, using original');
+        return [query];
+    }
+}
+async function recallMemories(opts) {
+    const db = (0, database_1.getDb)();
+    const limit = opts.limit || 5;
+    const minDecay = opts.minDecay ?? 0.1;
+    try {
+        // Phase 0: Query expansion — generate alternative phrasings for broader recall
+        const queries = opts.query && !opts._vectorScores && !opts.skipExpansion
+            ? await expandQuery(opts.query)
+            : opts.query ? [opts.query] : [];
+        // Phase 1+2: Vector search + metadata query IN PARALLEL
+        let vectorScores = opts._vectorScores || new Map();
+        let primaryQueryEmbedding = null; // Shared for Phase 2b seed scoring
+        // Start embedding immediately (non-blocking)
+        const vectorSearchPromise = (queries.length > 0 && (0, embeddings_1.isEmbeddingEnabled)() && !opts._vectorScores)
+            ? (async () => {
+                // Embed all query variants (with cache)
+                const queryEmbeddings = await Promise.all(queries.map(async (q) => {
+                    const cached = getCachedEmbedding(q);
+                    if (cached)
+                        return cached;
+                    const emb = await (0, embeddings_1.generateQueryEmbedding)(q);
+                    if (emb)
+                        setCachedEmbedding(q, emb);
+                    return emb;
+                }));
+                const validEmbeddings = queryEmbeddings.filter((e) => e !== null);
+                if (validEmbeddings.length > 0)
+                    primaryQueryEmbedding = validEmbeddings[0];
+                if (validEmbeddings.length === 0) {
+                    log.debug('All query embeddings returned null, using keyword-only retrieval');
+                    return;
+                }
+                try {
+                    // Memory-level search only (skip fragments for speed when skipExpansion is set)
+                    const allSearches = validEmbeddings.flatMap(emb => {
+                        const searches = [
+                            Promise.resolve(db.rpc('match_memories', {
+                                query_embedding: JSON.stringify(emb),
+                                match_threshold: utils_1.VECTOR_MATCH_THRESHOLD,
+                                match_count: limit * (opts.skipExpansion ? 12 : 4),
+                                filter_types: opts.memoryTypes || null,
+                                filter_user: opts.relatedUser || null,
+                                min_decay: minDecay,
+                                filter_owner: getOwnerWallet() || null,
+                            })).then(r => r.data || []),
+                        ];
+                        // Only search fragments when not in fast mode
+                        if (!opts.skipExpansion) {
+                            searches.push(Promise.resolve(db.rpc('match_memory_fragments', {
+                                query_embedding: JSON.stringify(emb),
+                                match_threshold: utils_1.VECTOR_MATCH_THRESHOLD,
+                                match_count: limit * 2,
+                                filter_owner: getOwnerWallet() || null,
+                            })).then(r => r.data || []));
+                        }
+                        return searches;
+                    });
+                    const results = await Promise.all(allSearches);
+                    // Merge: take highest similarity per memory_id across ALL queries
+                    if (opts.skipExpansion) {
+                        // All results are memory-level matches (no fragments)
+                        for (const batch of results) {
+                            for (const m of batch) {
+                                const current = vectorScores.get(m.id) || 0;
+                                vectorScores.set(m.id, Math.max(current, m.similarity));
+                            }
+                        }
+                    }
+                    else {
+                        for (let i = 0; i < results.length; i++) {
+                            const hasFragments = validEmbeddings.length > 0;
+                            const step = hasFragments ? 2 : 1;
+                            if (i % step === 0) {
+                                for (const m of results[i]) {
+                                    const current = vectorScores.get(m.id) || 0;
+                                    vectorScores.set(m.id, Math.max(current, m.similarity));
+                                }
+                            }
+                            else {
+                                for (const f of results[i]) {
+                                    const current = vectorScores.get(f.memory_id) || 0;
+                                    vectorScores.set(f.memory_id, Math.max(current, f.max_similarity));
+                                }
+                            }
+                        }
+                    }
+                    log.debug({
+                        queryVariants: validEmbeddings.length,
+                        uniqueMemories: vectorScores.size,
+                        fastMode: !!opts.skipExpansion,
+                    }, 'Vector search completed');
+                }
+                catch (err) {
+                    log.warn({ err }, 'Vector search RPC failed, falling back to keyword retrieval');
+                }
+            })()
+            : Promise.resolve();
+        // Phase 2: Metadata-filtered candidates from Supabase (runs IN PARALLEL with vector search)
+        // Run two queries in parallel: importance-ranked + text-search for diversity
+        let importanceQuery = db
+            .from('memories')
+            .select('*')
+            .gte('decay_factor', minDecay)
+            .not('source', 'in', '("demo","demo-maas")')
+            .order('importance', { ascending: false })
+            .order('created_at', { ascending: false })
+            .limit(limit * 3);
+        importanceQuery = scopeToOwner(importanceQuery);
+        if (opts.memoryTypes && opts.memoryTypes.length > 0) {
+            importanceQuery = importanceQuery.in('memory_type', opts.memoryTypes);
+        }
+        if (opts.relatedUser) {
+            importanceQuery = importanceQuery.eq('related_user', opts.relatedUser);
+        }
+        if (opts.relatedWallet) {
+            importanceQuery = importanceQuery.eq('related_wallet', opts.relatedWallet);
+        }
+        if (opts.minImportance) {
+            importanceQuery = importanceQuery.gte('importance', opts.minImportance);
+        }
+        if (opts.tags && opts.tags.length > 0) {
+            importanceQuery = importanceQuery.overlaps('tags', opts.tags);
+        }
+        // Text search: find memories whose summary/tags contain query keywords
+        const textSearchPromise = (opts.query && opts.query.length > 3) ? (async () => {
+            try {
+                // Extract meaningful keywords (skip short/common words)
+                const stopWords = new Set(['the', 'a', 'an', 'is', 'are', 'was', 'were', 'be', 'been', 'and', 'or', 'but', 'in', 'on', 'at', 'to', 'for', 'of', 'with', 'by', 'from', 'how', 'what', 'who', 'why', 'when', 'where', 'does', 'do', 'did', 'can', 'will', 'about', 'that', 'this', 'it']);
+                const keywords = opts.query.toLowerCase().split(/\s+/)
+                    .filter(w => w.length > 2 && !stopWords.has(w))
+                    .slice(0, 4);
+                if (keywords.length === 0)
+                    return [];
+                // Search summary with ilike for each keyword
+                let textQuery = db
+                    .from('memories')
+                    .select('*')
+                    .gte('decay_factor', minDecay)
+                    .not('source', 'in', '("demo","demo-maas")')
+                    .or(keywords.map(k => `summary.ilike.%${k}%`).join(','))
+                    .order('importance', { ascending: false })
+                    .limit(limit * 2);
+                textQuery = scopeToOwner(textQuery);
+                if (opts.memoryTypes && opts.memoryTypes.length > 0) {
+                    textQuery = textQuery.in('memory_type', opts.memoryTypes);
+                }
+                const { data: textData } = await textQuery;
+                return textData || [];
+            }
+            catch {
+                return [];
+            }
+        })() : Promise.resolve([]);
+        // Phase 2b: Always fetch knowledge-seed memories (small fixed set, ~20 rows)
+        // These are curated factual memories that must compete in scoring regardless of vector pool
+        let knowledgeSeedQuery = db
+            .from('memories')
+            .select('*')
+            .eq('source', 'knowledge-seed')
+            .gte('decay_factor', minDecay);
+        knowledgeSeedQuery = scopeToOwner(knowledgeSeedQuery);
+        if (opts.memoryTypes && opts.memoryTypes.length > 0) {
+            knowledgeSeedQuery = knowledgeSeedQuery.in('memory_type', opts.memoryTypes);
+        }
+        const [importanceResult, textResults, knowledgeSeeds] = await Promise.all([
+            importanceQuery,
+            textSearchPromise,
+            (async () => { try {
+                const r = await knowledgeSeedQuery;
+                return r.data || [];
+            }
+            catch {
+                return [];
+            } })(),
+            vectorSearchPromise, // Ensure vector search completes before merge
+        ]);
+        const { data, error } = importanceResult;
+        // Merge text search results + knowledge seeds into data
+        if (data) {
+            const existingIds = new Set(data.map((m) => m.id));
+            if (Array.isArray(textResults) && textResults.length > 0) {
+                for (const m of textResults) {
+                    if (!existingIds.has(m.id)) {
+                        data.push(m);
+                        existingIds.add(m.id);
+                    }
+                }
+                log.debug({ textHits: textResults.length }, 'Text search added candidates');
+            }
+            if (Array.isArray(knowledgeSeeds) && knowledgeSeeds.length > 0) {
+                let seedsAdded = 0;
+                for (const m of knowledgeSeeds) {
+                    if (!existingIds.has(m.id)) {
+                        data.push(m);
+                        existingIds.add(m.id);
+                        seedsAdded++;
+                    }
+                    // Compute vector similarity for seeds that lack it (fetched via metadata, not vector search)
+                    const rawEmb = m.embedding;
+                    if (primaryQueryEmbedding && rawEmb && !vectorScores.has(m.id)) {
+                        // Supabase returns embeddings as JSON strings from select('*')
+                        const emb = typeof rawEmb === 'string' ? JSON.parse(rawEmb) : rawEmb;
+                        const qEmb = primaryQueryEmbedding;
+                        if (emb.length === qEmb.length) {
+                            let dot = 0, magA = 0, magB = 0;
+                            for (let i = 0; i < emb.length; i++) {
+                                dot += qEmb[i] * emb[i];
+                                magA += qEmb[i] * qEmb[i];
+                                magB += emb[i] * emb[i];
+                            }
+                            const sim = (magA > 0 && magB > 0) ? dot / (Math.sqrt(magA) * Math.sqrt(magB)) : 0;
+                            if (sim > 0)
+                                vectorScores.set(m.id, sim);
+                        }
+                    }
+                }
+                if (seedsAdded > 0)
+                    log.debug({ seedsAdded, seedsTotal: knowledgeSeeds.length }, 'Knowledge seeds added to candidates');
+            }
+        }
+        if (error) {
+            log.error({ error: error.message }, 'Memory recall query failed');
+            return [];
+        }
+        // Phase 3: Merge vector candidates with metadata candidates
+        let candidates = (0, encryption_1.decryptMemoryBatch)(data || []);
+        // If vector search found memories not in the metadata set, fetch them
+        if (vectorScores.size > 0) {
+            const metadataIds = new Set(candidates.map(m => m.id));
+            const missingIds = [...vectorScores.keys()].filter(id => !metadataIds.has(id));
+            if (missingIds.length > 0) {
+                let vectorQuery = db
+                    .from('memories')
+                    .select('*')
+                    .in('id', missingIds);
+                vectorQuery = scopeToOwner(vectorQuery);
+                // Respect memoryTypes filter even for vector-matched results
+                if (opts.memoryTypes && opts.memoryTypes.length > 0) {
+                    vectorQuery = vectorQuery.in('memory_type', opts.memoryTypes);
+                }
+                const { data: vectorOnly } = await vectorQuery;
+                if (vectorOnly)
+                    candidates = [...candidates, ...(0, encryption_1.decryptMemoryBatch)(vectorOnly)];
+            }
+        }
+        if (candidates.length === 0)
+            return [];
+        // Phase 4: Score and rank with enhanced composite formula
+        const scoredOpts = vectorScores.size > 0 ? { ...opts, _vectorScores: vectorScores } : opts;
+        const scored = candidates.map((mem) => ({
+            ...mem,
+            _score: scoreMemory(mem, scoredOpts),
+        }));
+        scored.sort((a, b) => b._score - a._score);
+        let results = scored.slice(0, limit);
+        // Phase 5: Entity-aware recall — find memories via entity graph + co-occurrence
+        if (opts.query && results.length > 0) {
+            try {
+                const entities = await (0, memory_graph_1.findSimilarEntities)(opts.query, { limit: 3 });
+                if (entities.length > 0) {
+                    const resultIdSet = new Set(results.map((m) => m.id));
+                    // Phase 5a: Direct entity memories
+                    for (const entity of entities) {
+                        const entityMemories = await (0, memory_graph_1.getMemoriesByEntity)(entity.id, {
+                            limit: Math.ceil(limit / 2),
+                            memoryTypes: opts.memoryTypes,
+                        });
+                        for (const mem of entityMemories) {
+                            if (!resultIdSet.has(mem.id)) {
+                                results.push({
+                                    ...mem,
+                                    _score: scoreMemory(mem, scoredOpts) + utils_1.RETRIEVAL_WEIGHT_GRAPH * 0.6,
+                                });
+                                resultIdSet.add(mem.id);
+                            }
+                        }
+                    }
+                    log.debug({ entities: entities.map(e => e.name) }, 'Entity-aware recall applied');
+                    // Phase 5b: Co-occurring entity memories
+                    let cooccurrenceAdded = 0;
+                    const cooccurrenceNames = [];
+                    for (const entity of entities) {
+                        const cooccurrences = await (0, memory_graph_1.getEntityCooccurrences)(entity.id, { minCooccurrence: 2, maxResults: 3 });
+                        for (const cooc of cooccurrences) {
+                            if (cooccurrenceAdded >= limit)
+                                break;
+                            const coMems = await (0, memory_graph_1.getMemoriesByEntity)(cooc.related_entity_id, {
+                                limit: 3,
+                                memoryTypes: opts.memoryTypes,
+                            });
+                            for (const mem of coMems) {
+                                if (cooccurrenceAdded >= limit)
+                                    break;
+                                if (!resultIdSet.has(mem.id)) {
+                                    const normalizedStrength = Math.min(cooc.cooccurrence_count / 5, 1);
+                                    results.push({
+                                        ...mem,
+                                        _score: scoreMemory(mem, scoredOpts) + utils_1.RETRIEVAL_WEIGHT_GRAPH * utils_1.RETRIEVAL_WEIGHT_COOCCURRENCE * normalizedStrength,
+                                    });
+                                    resultIdSet.add(mem.id);
+                                    cooccurrenceAdded++;
+                                }
+                            }
+                        }
+                        if (cooccurrences.length > 0) {
+                            cooccurrenceNames.push(...cooccurrences.map(c => String(c.related_entity_id)));
+                        }
+                    }
+                    if (cooccurrenceAdded > 0) {
+                        log.debug({ cooccurrenceAdded, cooccurrenceEntities: cooccurrenceNames.length }, 'Entity co-occurrence recall applied');
+                    }
+                }
+            }
+            catch (err) {
+                log.debug({ err }, 'Entity-aware recall skipped');
+            }
+        }
+        // Phase 6: Bond-typed graph traversal — follow strong bonds first
+        // Bond weight multipliers: causal/supports > elaborates > relates > follows
+        const BOND_TYPE_WEIGHTS = {
+            causes: 1.0,
+            supports: 0.9,
+            resolves: 0.8,
+            elaborates: 0.7,
+            contradicts: 0.6,
+            relates: 0.4,
+            follows: 0.3,
+        };
+        if (results.length > 0) {
+            try {
+                const seedIds = results.map((m) => m.id);
+                const { data: linked } = await db.rpc('get_linked_memories', {
+                    seed_ids: seedIds,
+                    min_strength: 0.2,
+                    max_results: limit,
+                    filter_owner: getOwnerWallet() || null,
+                });
+                if (linked && linked.length > 0) {
+                    const resultIdSet = new Set(seedIds);
+                    const graphCandidateIds = linked
+                        .filter((l) => !resultIdSet.has(l.memory_id))
+                        .map((l) => l.memory_id);
+                    if (graphCandidateIds.length > 0) {
+                        let graphQuery = db
+                            .from('memories')
+                            .select('*')
+                            .in('id', graphCandidateIds);
+                        graphQuery = scopeToOwner(graphQuery);
+                        const { data: graphMemories } = await graphQuery;
+                        if (graphMemories && graphMemories.length > 0) {
+                            (0, encryption_1.decryptMemoryBatch)(graphMemories);
+                            // Build link map with bond-type-weighted strength
+                            const linkBoostMap = new Map();
+                            for (const l of linked) {
+                                const bondWeight = BOND_TYPE_WEIGHTS[l.link_type] ?? 0.4;
+                                const weightedStrength = (l.strength || 0.5) * bondWeight;
+                                const current = linkBoostMap.get(l.memory_id) || 0;
+                                linkBoostMap.set(l.memory_id, Math.max(current, weightedStrength));
+                            }
+                            const graphScored = graphMemories.map(mem => ({
+                                ...mem,
+                                _score: scoreMemory(mem, scoredOpts) + utils_1.RETRIEVAL_WEIGHT_GRAPH * (linkBoostMap.get(mem.id) || 0),
+                            }));
+                            results = [...results, ...graphScored]
+                                .sort((a, b) => b._score - a._score)
+                                .slice(0, limit);
+                            log.debug({
+                                graphExpanded: graphMemories.length,
+                                linkedTotal: linked.length,
+                                bondTypes: [...new Set(linked.map((l) => l.link_type))],
+                            }, 'Bond-typed graph traversal applied');
+                        }
+                    }
+                }
+            }
+            catch (err) {
+                log.debug({ err }, 'Graph expansion skipped (RPC unavailable)');
+            }
+        }
+        // Phase 7: Type diversity — ensure results span multiple memory types
+        // If all results are one type, pull in top candidates from other types
+        if (results.length >= 3) {
+            const typeSet = new Set(results.map((m) => m.memory_type));
+            if (typeSet.size === 1) {
+                const dominantType = [...typeSet][0];
+                const otherTypes = ['episodic', 'semantic', 'procedural', 'self_model'].filter(t => t !== dominantType);
+                const resultIdSet = new Set(results.map((m) => m.id));
+                // Find scored candidates from other types that didn't make the cut
+                const diverseCandidates = scored
+                    .filter((m) => otherTypes.includes(m.memory_type) && !resultIdSet.has(m.id))
+                    .slice(0, Math.ceil(limit / 3));
+                if (diverseCandidates.length > 0) {
+                    // Replace lowest-scored same-type results with diverse candidates
+                    const replaceCount = Math.min(diverseCandidates.length, Math.ceil(results.length / 3));
+                    results = [
+                        ...results.slice(0, results.length - replaceCount),
+                        ...diverseCandidates.slice(0, replaceCount),
+                    ].sort((a, b) => b._score - a._score)
+                        .slice(0, limit);
+                    log.debug({ injectedTypes: diverseCandidates.map((m) => m.memory_type) }, 'Type diversity applied');
+                }
+            }
+        }
+        // Final owner_wallet guard: strip any memories that don't belong to the current owner
+        // This catches leaks from entity/graph/fragment paths that may not filter by owner
+        const finalOwner = getOwnerWallet();
+        if (finalOwner) {
+            const beforeCount = results.length;
+            results = results.filter((m) => m.owner_wallet === finalOwner);
+            if (results.length < beforeCount) {
+                log.warn({ stripped: beforeCount - results.length, owner: finalOwner }, 'Owner guard stripped foreign memories from recall results');
+            }
+        }
+        // Update access counts in parallel (skip for internal processing like dream cycles)
+        if (opts.trackAccess !== false) {
+            const ids = results.map((m) => m.id);
+            updateMemoryAccess(ids).catch(err => log.warn({ err }, 'Memory access tracking failed'));
+            // Hebbian: reinforce links between co-retrieved memories
+            reinforceCoRetrievedLinks(ids).catch(err => log.debug({ err }, 'Link reinforcement failed'));
+        }
+        log.debug({
+            recalled: results.length,
+            topScore: results[0]?._score?.toFixed(3),
+            query: opts.query?.slice(0, 40),
+            vectorAssisted: vectorScores.size > 0,
+            typeSpread: [...new Set(results.map((m) => m.memory_type))].join(','),
+        }, 'Memories recalled');
+        return results;
+    }
+    catch (err) {
+        log.error({ err }, 'Memory recall failed');
+        return [];
+    }
+}
+// Stopwords to exclude from keyword matching — common words that cause false positives
+const STOPWORDS = new Set([
+    'the', 'a', 'an', 'and', 'or', 'but', 'in', 'on', 'at', 'to', 'for',
+    'of', 'with', 'by', 'from', 'is', 'it', 'its', 'are', 'was', 'were',
+    'be', 'been', 'being', 'have', 'has', 'had', 'do', 'does', 'did',
+    'will', 'would', 'could', 'should', 'may', 'might', 'can', 'shall',
+    'not', 'no', 'nor', 'so', 'if', 'then', 'than', 'that', 'this',
+    'what', 'which', 'who', 'whom', 'how', 'when', 'where', 'why',
+    'all', 'each', 'every', 'both', 'few', 'more', 'most', 'some', 'any',
+    'about', 'into', 'through', 'just', 'also', 'very', 'much', 'like',
+    'get', 'got', 'your', 'you', 'my', 'me', 'his', 'her', 'our', 'their',
+]);
+/**
+ * Check if a word matches within text using word boundary logic.
+ * Avoids false positives like "sol" matching "solution".
+ */
+function wordBoundaryMatch(word, text) {
+    // Escape regex special chars, then wrap with word boundaries
+    const escaped = word.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+    const re = new RegExp(`\\b${escaped}\\b`, 'i');
+    return re.test(text);
+}
+/**
+ * Extract meaningful query terms: lowercase, filter stopwords and short words.
+ */
+function extractQueryTerms(query) {
+    return query
+        .toLowerCase()
+        .split(/\s+/)
+        .filter(w => w.length > 2 && !STOPWORDS.has(w));
+}
+/**
+ * Enhanced scoring function with optional vector similarity component.
+ *
+ * When vector similarity is available:
+ *   score = (w_recency * recency + w_relevance * keyword_relevance
+ *            + w_importance * importance + w_vector * vector_sim) * decay
+ *
+ * When not available (graceful fallback):
+ *   score = (w_recency * recency + w_relevance * keyword_relevance
+ *            + w_importance * importance) * decay
+ */
+function scoreMemory(mem, opts) {
+    const now = Date.now();
+    // Recency: exponential decay from last access (paper: 0.995^hours)
+    const hoursSinceAccess = (now - new Date(mem.last_accessed).getTime()) / (1000 * 60 * 60);
+    const recency = Math.pow(utils_1.RECENCY_DECAY_BASE, hoursSinceAccess);
+    // Text similarity (keyword overlap with word boundaries + stopword filtering)
+    let textScore = 0.5;
+    if (opts.query) {
+        const queryTerms = extractQueryTerms(opts.query);
+        if (queryTerms.length > 0) {
+            const summaryLower = mem.summary.toLowerCase();
+            // Summary matches are worth more than content matches
+            let summaryHits = 0;
+            let contentHits = 0;
+            for (const term of queryTerms) {
+                if (wordBoundaryMatch(term, summaryLower)) {
+                    summaryHits++;
+                }
+                else if (mem.content && wordBoundaryMatch(term, mem.content.toLowerCase())) {
+                    contentHits++;
+                }
+            }
+            // Summary matches count full, content matches count half
+            const effectiveMatches = summaryHits + contentHits * 0.5;
+            textScore = 0.3 + 0.7 * Math.min(effectiveMatches / queryTerms.length, 1);
+        }
+    }
+    // Tag + concept overlap score
+    let tagScore = 0.5;
+    if (opts.tags && opts.tags.length > 0) {
+        const memLabels = [...(mem.tags || []), ...(mem.concepts || [])];
+        const overlap = memLabels.filter(t => opts.tags.includes(t)).length;
+        tagScore = 0.5 + 0.5 * Math.min(overlap / opts.tags.length, 1);
+    }
+    // Relevance: average of text and tag similarity
+    const relevance = (textScore + tagScore) / 2;
+    // Vector similarity component (0 if not available)
+    const vectorSim = opts._vectorScores?.get(mem.id) || 0;
+    // Additive formula, normalized so vector vs non-vector scores are comparable
+    let rawScore = utils_1.RETRIEVAL_WEIGHT_RECENCY * recency +
+        utils_1.RETRIEVAL_WEIGHT_RELEVANCE * relevance +
+        utils_1.RETRIEVAL_WEIGHT_IMPORTANCE * mem.importance;
+    if (vectorSim > 0) {
+        rawScore += utils_1.RETRIEVAL_WEIGHT_VECTOR * vectorSim;
+        rawScore /= (utils_1.RETRIEVAL_WEIGHT_RECENCY + utils_1.RETRIEVAL_WEIGHT_RELEVANCE + utils_1.RETRIEVAL_WEIGHT_IMPORTANCE + utils_1.RETRIEVAL_WEIGHT_VECTOR);
+    }
+    else {
+        rawScore /= (utils_1.RETRIEVAL_WEIGHT_RECENCY + utils_1.RETRIEVAL_WEIGHT_RELEVANCE + utils_1.RETRIEVAL_WEIGHT_IMPORTANCE);
+    }
+    // Knowledge type boost: semantic/procedural/self_model rank above raw episodic
+    const typeBoost = utils_1.KNOWLEDGE_TYPE_BOOST[mem.memory_type] || 0;
+    rawScore += typeBoost;
+    // Knowledge-seed memories get boosted ONLY when vector-relevant to the query
+    // High vector sim = strong boost; no vector match = no boost (don't pollute unrelated queries)
+    if (mem.source === 'knowledge-seed' && vectorSim > 0.25) {
+        rawScore += 2.0 + vectorSim * 2.0; // ranges from +2.5 (sim=0.25) to +4.0 (sim=1.0)
+    }
+    else if (mem.source === 'knowledge-seed') {
+        rawScore += 0.5; // moderate boost for seeds without vector match
+    }
+    // Consolidation memories are dream-cycle meta-observations — strong penalty
+    // 2000+ consolidation memories flood results; only the most vector-relevant should surface
+    if (mem.source === 'consolidation') {
+        rawScore *= vectorSim > 0.5 ? 0.45 : 0.30;
+    }
+    return rawScore * mem.decay_factor;
+}
+// ---- PROGRESSIVE DISCLOSURE ---- //
+/**
+ * Lightweight recall that returns only summaries (~50 tokens each).
+ * Use for dream cycle focal point generation, overview scans, and
+ * anywhere full content isn't needed. 10x more token-efficient than full recall.
+ *
+ * Call hydrateMemories() to fetch full content for selected IDs.
+ */
+async function recallMemorySummaries(opts) {
+    const db = (0, database_1.getDb)();
+    const limit = opts.limit || 10;
+    const minDecay = opts.minDecay ?? 0.1;
+    try {
+        let query = db
+            .from('memories')
+            .select('id, memory_type, summary, tags, concepts, importance, decay_factor, created_at, source')
+            .gte('decay_factor', minDecay)
+            .not('source', 'in', '("demo","demo-maas")')
+            .order('importance', { ascending: false })
+            .order('created_at', { ascending: false })
+            .limit(limit);
+        query = scopeToOwner(query);
+        if (opts.memoryTypes && opts.memoryTypes.length > 0) {
+            query = query.in('memory_type', opts.memoryTypes);
+        }
+        if (opts.relatedUser) {
+            query = query.eq('related_user', opts.relatedUser);
+        }
+        if (opts.relatedWallet) {
+            query = query.eq('related_wallet', opts.relatedWallet);
+        }
+        if (opts.minImportance) {
+            query = query.gte('importance', opts.minImportance);
+        }
+        if (opts.tags && opts.tags.length > 0) {
+            query = query.overlaps('tags', opts.tags);
+        }
+        const { data, error } = await query;
+        if (error) {
+            log.error({ error: error.message }, 'Memory summary recall failed');
+            return [];
+        }
+        return (data || []);
+    }
+    catch (err) {
+        log.error({ err }, 'Memory summary recall failed');
+        return [];
+    }
+}
+/**
+ * Fetch full memory content for specific IDs (second stage of progressive disclosure).
+ * Use after recallMemorySummaries() to hydrate only the memories you actually need.
+ */
+async function hydrateMemories(ids) {
+    if (ids.length === 0)
+        return [];
+    const db = (0, database_1.getDb)();
+    try {
+        let query = db
+            .from('memories')
+            .select('*')
+            .in('id', ids);
+        query = scopeToOwner(query);
+        const { data, error } = await query;
+        if (error) {
+            log.error({ error: error.message }, 'Memory hydration failed');
+            return [];
+        }
+        return (0, encryption_1.decryptMemoryBatch)((data || []));
+    }
+    catch (err) {
+        log.error({ err }, 'Memory hydration failed');
+        return [];
+    }
+}
+// ---- ACCESS TRACKING ---- //
+async function updateMemoryAccess(ids) {
+    if (ids.length === 0)
+        return;
+    const db = (0, database_1.getDb)();
+    // Single batch query: increment access_count, refresh last_accessed, boost decay
+    const { error } = await db.rpc('batch_boost_memory_access', { memory_ids: ids });
+    if (error) {
+        log.warn({ error: error.message, ids }, 'Batch memory access update failed');
+    }
+    // Importance re-scoring: memories retrieved often become more important over time.
+    // Small boost per retrieval, capped at 1.0. Mirrors "rehearsal effect" in human memory.
+    try {
+        for (const id of ids) {
+            await db.rpc('boost_memory_importance', {
+                memory_id: id,
+                boost_amount: 0.02, // +2% per retrieval
+                max_importance: 1.0,
+            });
+        }
+    }
+    catch (err) {
+        // Non-critical — RPC may not exist yet, will be created in next migration
+        log.debug({ err }, 'Importance re-scoring skipped (RPC may not exist)');
+    }
+}
+// ---- ASSOCIATION GRAPH ---- //
+/**
+ * Create a typed, weighted link between two memories.
+ * Idempotent — upserts on (source_id, target_id, link_type).
+ */
+async function createMemoryLink(sourceId, targetId, linkType, strength = 0.5) {
+    if (sourceId === targetId)
+        return;
+    const db = (0, database_1.getDb)();
+    const { error } = await db
+        .from('memory_links')
+        .upsert({
+        source_id: sourceId,
+        target_id: targetId,
+        link_type: linkType,
+        strength: (0, utils_1.clamp)(strength, 0, 1),
+    }, { onConflict: 'source_id,target_id,link_type' });
+    if (error) {
+        log.debug({ error: error.message, sourceId, targetId, linkType }, 'Link creation failed');
+    }
+}
+/**
+ * Auto-link a new memory to related existing memories.
+ * Uses vector similarity, concept overlap, and user overlap to find candidates.
+ * Classifies link type via lightweight heuristics.
+ */
+async function autoLinkMemory(memoryId, opts) {
+    const db = (0, database_1.getDb)();
+    // 1. Link evidence_ids as 'supports' links
+    if (opts.evidenceIds && opts.evidenceIds.length > 0) {
+        for (const evidenceId of opts.evidenceIds) {
+            await createMemoryLink(memoryId, evidenceId, 'supports', 0.8);
+        }
+    }
+    // 2. Find candidates via vector similarity (if embeddings available)
+    const candidates = [];
+    if ((0, embeddings_1.isEmbeddingEnabled)()) {
+        const embedding = await (0, embeddings_1.generateEmbedding)(opts.summary);
+        if (embedding) {
+            const { data: similar } = await db.rpc('match_memories', {
+                query_embedding: JSON.stringify(embedding),
+                match_threshold: utils_1.LINK_SIMILARITY_THRESHOLD,
+                match_count: utils_1.MAX_AUTO_LINKS * 2,
+                filter_owner: getOwnerWallet() || null,
+            });
+            if (similar) {
+                // Fetch metadata for link classification
+                const similarIds = similar.map((s) => s.id).filter((id) => id !== memoryId);
+                if (similarIds.length > 0) {
+                    let metaQuery = db
+                        .from('memories')
+                        .select('id, memory_type, concepts, related_user, emotional_valence, created_at')
+                        .in('id', similarIds);
+                    metaQuery = scopeToOwner(metaQuery);
+                    const { data: metas } = await metaQuery;
+                    if (metas) {
+                        const simMap = new Map(similar.map((s) => [Number(s.id), Number(s.similarity)]));
+                        for (const m of metas) {
+                            const mid = Number(m.id);
+                            candidates.push({
+                                id: mid,
+                                similarity: simMap.get(mid) || 0,
+                                memory_type: String(m.memory_type),
+                                concepts: (m.concepts || []),
+                                related_user: m.related_user ? String(m.related_user) : null,
+                                emotional_valence: Number(m.emotional_valence || 0),
+                                created_at: String(m.created_at),
+                            });
+                        }
+                    }
+                }
+            }
+        }
+    }
+    // 3. Also find by concept overlap (fallback when no embeddings)
+    if (candidates.length < utils_1.MAX_AUTO_LINKS && opts.concepts && opts.concepts.length > 0) {
+        let conceptQuery = db
+            .from('memories')
+            .select('id, memory_type, concepts, related_user, emotional_valence, created_at')
+            .overlaps('concepts', opts.concepts)
+            .neq('id', memoryId)
+            .order('created_at', { ascending: false })
+            .limit(utils_1.MAX_AUTO_LINKS);
+        conceptQuery = scopeToOwner(conceptQuery);
+        const { data: conceptMatches } = await conceptQuery;
+        if (conceptMatches) {
+            const existingIds = new Set(candidates.map(c => c.id));
+            for (const m of conceptMatches) {
+                if (!existingIds.has(m.id)) {
+                    candidates.push({ ...m, similarity: 0.4 });
+                }
+            }
+        }
+    }
+    // 4. Classify link types and create links (limit to MAX_AUTO_LINKS)
+    const concepts = opts.concepts || [];
+    let linksCreated = 0;
+    for (const candidate of candidates.slice(0, utils_1.MAX_AUTO_LINKS)) {
+        if (candidate.id === memoryId)
+            continue;
+        const linkType = classifyLinkType(opts, candidate, concepts);
+        const strength = candidate.similarity > 0 ? (0, utils_1.clamp)(candidate.similarity, 0.3, 0.9) : 0.5;
+        await createMemoryLink(memoryId, candidate.id, linkType, strength);
+        linksCreated++;
+    }
+    if (linksCreated > 0) {
+        log.debug({ memoryId, linksCreated }, 'Auto-linked memory');
+    }
+}
+/**
+ * Classify the relationship type between a new memory and an existing candidate.
+ */
+function classifyLinkType(newMem, candidate, newConcepts) {
+    const sameUser = newMem.relatedUser && newMem.relatedUser === candidate.related_user;
+    const recentCandidate = (Date.now() - new Date(candidate.created_at).getTime()) < 6 * 60 * 60 * 1000; // within 6h
+    const conceptOverlap = (candidate.concepts || []).filter(c => newConcepts.includes(c)).length;
+    const valenceFlip = Math.abs((newMem.emotionalValence || 0) - candidate.emotional_valence) > 1.0;
+    // Same user + recent = temporal sequence
+    if (sameUser && recentCandidate)
+        return 'follows';
+    // Large emotional valence difference = potential contradiction
+    if (valenceFlip && conceptOverlap > 0)
+        return 'contradicts';
+    // Semantic memory building on episodic = elaboration
+    if (newMem.type === 'semantic' && candidate.memory_type === 'episodic')
+        return 'elaborates';
+    // High concept overlap = related
+    if (conceptOverlap >= 2)
+        return 'relates';
+    return 'relates';
+}
+/**
+ * Hebbian reinforcement: boost link strength between co-retrieved memories.
+ * "Memories that fire together wire together."
+ */
+async function reinforceCoRetrievedLinks(ids) {
+    if (ids.length < 2)
+        return;
+    const db = (0, database_1.getDb)();
+    const { data, error } = await db.rpc('boost_link_strength', {
+        memory_ids: ids,
+        boost_amount: utils_1.LINK_CO_RETRIEVAL_BOOST,
+    });
+    if (error) {
+        log.debug({ error: error.message }, 'Link reinforcement RPC failed');
+    }
+    else if (data && data > 0) {
+        log.debug({ boosted: data }, 'Co-retrieval link reinforcement applied');
+    }
+}
+// ---- ENTITY EXTRACTION ---- //
+/**
+ * Extract entities from a stored memory and link them to the knowledge graph.
+ * Called as fire-and-forget after storeMemory().
+ */
+async function extractAndLinkEntitiesForMemory(memoryId, opts) {
+    try {
+        await (0, memory_graph_1.extractAndLinkEntities)(memoryId, opts.content, opts.summary, opts.relatedUser);
+    }
+    catch (err) {
+        log.debug({ err, memoryId }, 'Entity extraction failed');
+    }
+}
+// ---- DECAY ---- //
+/**
+ * Apply type-specific memory decay.
+ * Episodic memories fade fastest (0.93/day), self-model slowest (0.99/day).
+ * This mirrors human cognition: events are forgotten but identity persists.
+ */
+async function decayMemories() {
+    const db = (0, database_1.getDb)();
+    const cutoff = new Date(Date.now() - 24 * 60 * 60 * 1000).toISOString();
+    try {
+        let totalDecayed = 0;
+        // Batch decay per memory type (4 queries instead of N)
+        for (const [memType, rate] of Object.entries(utils_1.DECAY_RATES)) {
+            const { data, error } = await db.rpc('batch_decay_memories', {
+                decay_type: memType,
+                decay_rate: rate,
+                min_decay: utils_1.MEMORY_MIN_DECAY,
+                cutoff,
+            });
+            if (error) {
+                log.warn({ error: error.message, memType }, 'Batch decay failed for type');
+                continue;
+            }
+            totalDecayed += data || 0;
+        }
+        if (totalDecayed > 0) {
+            log.info({ decayed: totalDecayed }, 'Type-specific memory decay applied');
+        }
+        return totalDecayed;
+    }
+    catch (err) {
+        log.error({ err }, 'Memory decay failed');
+        return 0;
+    }
+}
+async function getMemoryStats() {
+    const db = (0, database_1.getDb)();
+    const stats = {
+        total: 0,
+        byType: { episodic: 0, semantic: 0, procedural: 0, self_model: 0, introspective: 0 },
+        avgImportance: 0,
+        avgDecay: 0,
+        oldestMemory: null,
+        newestMemory: null,
+        totalDreamSessions: 0,
+        uniqueUsers: 0,
+        topTags: [],
+        topConcepts: [],
+        embeddedCount: 0,
+    };
+    try {
+        let statsQuery = db
+            .from('memories')
+            .select('memory_type, importance, decay_factor, created_at, related_user, tags, concepts, embedding')
+            .gt('decay_factor', utils_1.MEMORY_MIN_DECAY);
+        statsQuery = scopeToOwner(statsQuery);
+        const { data: memories } = await statsQuery;
+        if (memories && memories.length > 0) {
+            stats.total = memories.length;
+            let impSum = 0;
+            let decaySum = 0;
+            const tagCounts = {};
+            const conceptCounts = {};
+            const users = new Set();
+            for (const m of memories) {
+                const type = m.memory_type;
+                if (type in stats.byType)
+                    stats.byType[type]++;
+                impSum += m.importance;
+                decaySum += m.decay_factor;
+                if (m.related_user)
+                    users.add(m.related_user);
+                if (m.embedding)
+                    stats.embeddedCount++;
+                if (m.tags) {
+                    for (const tag of m.tags) {
+                        tagCounts[tag] = (tagCounts[tag] || 0) + 1;
+                    }
+                }
+                if (m.concepts) {
+                    for (const concept of m.concepts) {
+                        conceptCounts[concept] = (conceptCounts[concept] || 0) + 1;
+                    }
+                }
+            }
+            stats.avgImportance = impSum / memories.length;
+            stats.avgDecay = decaySum / memories.length;
+            stats.uniqueUsers = users.size;
+            stats.topTags = Object.entries(tagCounts)
+                .sort((a, b) => b[1] - a[1])
+                .slice(0, 10)
+                .map(([tag, count]) => ({ tag, count }));
+            stats.topConcepts = Object.entries(conceptCounts)
+                .sort((a, b) => b[1] - a[1])
+                .slice(0, 10)
+                .map(([concept, count]) => ({ concept, count }));
+            const sorted = memories.map(m => m.created_at).sort();
+            stats.oldestMemory = sorted[0] || null;
+            stats.newestMemory = sorted[sorted.length - 1] || null;
+        }
+        const { count, error: dreamError } = await db
+            .from('dream_logs')
+            .select('id', { count: 'exact', head: true });
+        if (dreamError) {
+            log.warn({ error: dreamError.message }, 'Failed to count dream logs');
+        }
+        stats.totalDreamSessions = count || 0;
+    }
+    catch (err) {
+        log.error({ err }, 'Failed to get memory stats');
+    }
+    return stats;
+}
+// ---- RECENT MEMORIES ---- //
+async function getRecentMemories(hours, types, limit) {
+    const db = (0, database_1.getDb)();
+    const since = new Date(Date.now() - hours * 60 * 60 * 1000).toISOString();
+    let query = db
+        .from('memories')
+        .select('*')
+        .gte('created_at', since)
+        .order('created_at', { ascending: false })
+        .limit(limit || 50);
+    query = scopeToOwner(query);
+    if (types && types.length > 0) {
+        query = query.in('memory_type', types);
+    }
+    const { data, error } = await query;
+    if (error) {
+        log.error({ error: error.message }, 'Failed to get recent memories');
+        return [];
+    }
+    return (0, encryption_1.decryptMemoryBatch)(data || []);
+}
+// ---- SELF-MODEL ---- //
+async function getSelfModel() {
+    const db = (0, database_1.getDb)();
+    let query = db
+        .from('memories')
+        .select('*')
+        .eq('memory_type', 'self_model')
+        .gt('decay_factor', 0.2)
+        .order('importance', { ascending: false })
+        .order('created_at', { ascending: false })
+        .limit(5);
+    query = scopeToOwner(query);
+    const { data, error } = await query;
+    if (error) {
+        log.error({ error: error.message }, 'Failed to get self model');
+        return [];
+    }
+    return (0, encryption_1.decryptMemoryBatch)(data || []);
+}
+// ---- STORE DREAM LOG ---- //
+async function storeDreamLog(sessionType, inputMemoryIds, output, newMemoryIds) {
+    const db = (0, database_1.getDb)();
+    const { error } = await db
+        .from('dream_logs')
+        .insert({
+        session_type: sessionType,
+        input_memory_ids: inputMemoryIds,
+        output: output.slice(0, utils_1.MEMORY_MAX_CONTENT_LENGTH),
+        new_memories_created: newMemoryIds,
+    });
+    if (error) {
+        log.error({ error: error.message }, 'Failed to store dream log');
+    }
+}
+// ---- HELPERS ---- //
+function formatMemoryContext(memories) {
+    if (memories.length === 0)
+        return '';
+    const lines = ['## Memory Recall'];
+    const episodic = memories.filter(m => m.memory_type === 'episodic');
+    const semantic = memories.filter(m => m.memory_type === 'semantic');
+    const procedural = memories.filter(m => m.memory_type === 'procedural');
+    const selfModel = memories.filter(m => m.memory_type === 'self_model');
+    const introspective = memories.filter(m => m.memory_type === 'introspective');
+    if (episodic.length > 0) {
+        lines.push('### Past Interactions');
+        for (const m of episodic) {
+            lines.push(`- [${(0, utils_1.timeAgo)(m.created_at)}] ${m.summary}`);
+        }
+    }
+    if (semantic.length > 0) {
+        lines.push('### Things You Know');
+        for (const m of semantic) {
+            lines.push(`- ${m.summary}`);
+        }
+    }
+    if (procedural.length > 0) {
+        lines.push('### Learned Strategies (from past outcomes)');
+        for (const m of procedural) {
+            const meta = m.metadata;
+            const confidence = meta?.positiveRate != null
+                ? ` [${Math.round(meta.positiveRate * 100)}% success rate, based on ${meta.basedOn || '?'} interactions]`
+                : '';
+            lines.push(`- ${m.summary}${confidence}`);
+        }
+    }
+    if (introspective.length > 0) {
+        lines.push('### Your Own Reflections');
+        for (const m of introspective) {
+            lines.push(`- [${(0, utils_1.timeAgo)(m.created_at)}] ${m.summary}`);
+        }
+    }
+    if (selfModel.length > 0) {
+        lines.push('### Self-Observations');
+        for (const m of selfModel) {
+            lines.push(`- ${m.summary}`);
+        }
+    }
+    lines.push('');
+    lines.push('You REMEMBER these interactions and facts. Reference them naturally if relevant.');
+    if (procedural.length > 0) {
+        lines.push('');
+        lines.push('IMPORTANT: You MUST follow the Learned Strategies above. They are behavioral rules you derived from analyzing your own past successes and failures. Apply them to this response.');
+    }
+    return lines.join('\n');
+}
+function calculateImportance(opts) {
+    let score = 0.4;
+    if (opts.tier === 'WHALE')
+        score += 0.3;
+    else if (opts.tier === 'SMALL')
+        score += 0.1;
+    else if (opts.tier === 'SELLER')
+        score += 0.2;
+    if (opts.feature === 'question')
+        score += 0.15;
+    if (opts.mood === 'PUMPING' || opts.mood === 'DUMPING')
+        score += 0.1;
+    if (opts.mood === 'NEW_ATH' || opts.mood === 'WHALE_SELL')
+        score += 0.15;
+    if (opts.isFirstInteraction)
+        score += 0.1;
+    return (0, utils_1.clamp)(score, 0, 1);
+}
+/**
+ * Score importance using LLM (Park et al. 2023).
+ * Falls back to rule-based calculateImportance() on failure.
+ */
+async function scoreImportanceWithLLM(description, fallbackOpts) {
+    try {
+        const response = await (0, claude_client_1.generateImportanceScore)(description);
+        const parsed = parseInt(response.trim(), 10);
+        if (!isNaN(parsed) && parsed >= 1 && parsed <= 10) {
+            return parsed / 10;
+        }
+        log.warn({ response }, 'LLM importance score unparseable, using fallback');
+        return calculateImportance(fallbackOpts || {});
+    }
+    catch (err) {
+        log.warn({ err }, 'LLM importance scoring failed, using fallback');
+        return calculateImportance(fallbackOpts || {});
+    }
+}
+function moodToValence(mood) {
+    switch (mood) {
+        case 'PUMPING': return 0.3;
+        case 'NEW_ATH': return 0.5;
+        case 'DUMPING': return -0.4;
+        case 'WHALE_SELL': return -0.6;
+        case 'SIDEWAYS': return -0.1;
+        default: return 0;
+    }
+}
+//# sourceMappingURL=memory.js.map