shieldcortex 4.12.13 → 4.13.0

package/dist/memory/store.js

@@ -8,11 +8,9 @@ import { randomUUID } from 'crypto';
 import { getDatabase, isDatabaseInitialized, withTransaction } from '../database/init.js';
 import { DEFAULT_CONFIG, } from './types.js';
 import { calculateSalience, suggestCategory, extractTags, } from './salience.js';
-import { calculateDecayedScore, calculateReinforcementBoost, calculatePriority, } from './decay.js';
-import { activateMemory as spreadActivation, getActivationBoost, pruneActivationCache, } from './activation.js';
-import { jaccardSimilarity } from './similarity.js';
-import { emitMemoryCreated, emitMemoryAccessed, emitMemoryDeleted, emitMemoryUpdated, persistEvent, } from '../api/events.js';
-import { generateEmbedding, cosineSimilarity } from '../embeddings/index.js';
+import { calculateDecayedScore } from './decay.js';
+import { emitMemoryCreated, emitMemoryDeleted, emitMemoryUpdated, persistEvent, } from '../api/events.js';
+import { generateEmbedding } from '../embeddings/index.js';
 import { isPaused } from '../api/control.js';
 import { extractFromMemory } from '../graph/extract.js';
 import { processExtractionResult, removeMemoryGraph, replaceMemoryGraph } from '../graph/resolve.js';
@@ -25,10 +23,15 @@ import { checkAccess } from '../defence/trust/access-control.js';
 import { scoreSource } from '../defence/trust/source-scorer.js';
 import { logAudit } from '../defence/audit/logger.js';
 import { dispatchWebhook } from '../events/webhooks.js';
-import { getCachedQueryEmbedding, findSimilarMemories } from './embedding.js';
-import { buildSearchExplanation, calculateLinkBoost, calculateTagScore, detectQueryCategory, extractQueryTags, vectorSearch, } from './search.js';
-// Anti-bloat: Maximum content size per memory (10KB)
-const MAX_CONTENT_SIZE = 10 * 1024;
+import { safeJsonParse } from './fts.js';
+// Internal use of the link API. links.ts also imports from store.ts (getMemoryById,
+// rowToMemory) — the cycle is safe because both directions only invoke the imported
+// symbols inside function bodies, never at module load. ESM live bindings handle it.
+// Same function-body-only cycle pattern applies to lifecycle.ts and search-recall.ts.
+import { createMemoryLink, detectRelationships } from './links.js';
+// Anti-bloat: Maximum content size per memory (10KB).
+// Exported because lifecycle.ts also enforces this budget inside enrichMemory.
+export const MAX_CONTENT_SIZE = 10 * 1024;
 // Track truncation info globally for the last addMemory call
 let lastTruncationInfo = null;
 /**
@@ -67,61 +70,6 @@ function truncateContent(content) {
 export function getLastTruncationInfo() {
     return lastTruncationInfo;
 }
-/**
- * Escape FTS5 query to prevent syntax errors
- * FTS5 interprets:
- * - "word-word" as "column:value" syntax
- * - AND, OR, NOT as boolean operators
- * - &, | as boolean operators
- * We quote individual terms to search them literally
- */
-function escapeFts5Query(query) {
-    // Split on whitespace, process each term, filter empty, rejoin
-    return query
-        .split(/\s+/)
-        .filter(term => term.length > 0)
-        .map(term => {
-        // Replace apostrophes with spaces — FTS5 porter unicode61 tokenizer treats
-        // apostrophes as word separators during indexing ("don't" → "don" + "t").
-        // We must split the same way so queries match the indexed tokens.
-        if (term.includes("'")) {
-            const parts = term.split("'").filter(p => p.length > 0);
-            // Recursively escape each part and join with spaces
-            return parts.map(p => {
-                if (/[^a-zA-Z0-9_]/.test(p))
-                    return `"${p.replace(/"/g, '""')}"`;
-                return p;
-            }).join(' ');
-        }
-        // FTS5 boolean operators - quote them to search literally
-        const upperTerm = term.toUpperCase();
-        if (upperTerm === 'AND' || upperTerm === 'OR' || upperTerm === 'NOT') {
-            return `"${term}"`;
-        }
-        // If term contains special FTS5 characters, quote it
-        // Including: - : * ^ ( ) & | . , ; ! ? and quotes
-        if (/[^a-zA-Z0-9_]/.test(term)) {
-            // Escape existing quotes and wrap in quotes
-            return `"${term.replace(/"/g, '""')}"`;
-        }
-        return term;
-    })
-        .filter(Boolean)
-        .join(' ');
-}
-/**
- * Safely parse JSON with fallback — prevents corrupted DB values from crashing queries
- */
-function safeJsonParse(value, fallback) {
-    if (!value)
-        return fallback;
-    try {
-        return JSON.parse(value);
-    }
-    catch {
-        return fallback;
-    }
-}
 function inferSourceDetails(input, source) {
     const tags = (input.tags ?? []).map((tag) => tag.toLowerCase());
     const metadata = input.metadata ?? {};
@@ -260,7 +208,9 @@ function checkRateLimit(source) {
     }
 }
 // ── Read-Time Access Control ──
-function logAccessDenial(memoryId, source, reason) {
+// Exported because search-recall.ts also calls logAccessDenial inside its
+// post-search ACL filter (cycle artifact, not intended public API).
+export function logAccessDenial(memoryId, source, reason) {
     const trust = scoreSource(source).score;
     logAudit({
         memory_id: memoryId,
@@ -826,547 +776,6 @@ export function deleteMemory(id, source) {
     }
     return result.changes > 0;
 }
-/**
- * Access a memory (updates access count and timestamp, returns reinforced memory)
- */
-export function accessMemory(id, config = DEFAULT_CONFIG, source) {
-    const db = getDatabase();
-    const memory = getMemoryById(id, source);
-    if (!memory)
-        return null;
-    // Calculate new salience with reinforcement
-    const newSalience = calculateReinforcementBoost(memory, config);
-    db.prepare(`
-    UPDATE memories
-    SET access_count = access_count + 1,
-        last_accessed = CURRENT_TIMESTAMP,
-        salience = ?
-    WHERE id = ?
-  `).run(newSalience, id);
-    const updatedMemory = getMemoryById(id);
-    // Emit event for real-time dashboard (in-process)
-    emitMemoryAccessed(updatedMemory, newSalience);
-    // Persist event for cross-process IPC (MCP → Dashboard)
-    persistEvent('memory_accessed', { memoryId: id, memory: updatedMemory, newSalience });
-    // ORGANIC FEATURE: Link strengthening on co-access
-    // If memory A and B are both accessed within 5 minutes, strengthen their link
-    // This mimics Hebbian learning: "neurons that fire together, wire together"
-    try {
-        const recentlyAccessed = db.prepare(`
-      SELECT id FROM memories
-      WHERE last_accessed > datetime('now', '-5 minutes')
-        AND id != ?
-      LIMIT 10
-    `).all(id);
-        for (const recent of recentlyAccessed) {
-            // Check if link exists in either direction
-            const existingLink = db.prepare(`
-        SELECT id, strength FROM memory_links
-        WHERE (source_id = ? AND target_id = ?) OR (source_id = ? AND target_id = ?)
-      `).get(id, recent.id, recent.id, id);
-            if (existingLink) {
-                // Strengthen existing link (cap at 1.0)
-                const newStrength = Math.min(1.0, existingLink.strength + 0.05);
-                db.prepare('UPDATE memory_links SET strength = ? WHERE id = ?')
-                    .run(newStrength, existingLink.id);
-            }
-            else {
-                // Create new weak link for co-accessed memories
-                createMemoryLink(id, recent.id, 'related', 0.2);
-            }
-        }
-    }
-    catch (e) {
-        // Don't fail memory access if link strengthening fails
-        console.error('[shieldcortex] Link strengthening failed:', e);
-    }
-    // ORGANIC FEATURE: Spreading Activation (Phase 2)
-    // Activate this memory and spread activation to linked memories
-    // This makes related memories easier to recall in subsequent searches
-    spreadActivation(id);
-    return updatedMemory;
-}
-/**
- * Reinforce a memory that appeared in search results
- * Gives a small salience boost with diminishing returns based on access count.
- * ORGANIC FEATURE: Searched memories get reinforced, closing the feedback loop
- * so frequently-found memories grow stronger over time.
- */
-export function reinforceFromSearch(memoryId) {
-    const db = getDatabase();
-    const memory = db.prepare('SELECT salience, access_count FROM memories WHERE id = ?').get(memoryId);
-    if (!memory)
-        return;
-    // Small salience boost per search appearance (diminishing returns)
-    const boost = Math.max(0.005, 0.02 / (1 + memory.access_count * 0.1));
-    const newSalience = Math.min(1.0, memory.salience + boost);
-    db.prepare(`
-    UPDATE memories
-    SET last_accessed = CURRENT_TIMESTAMP,
-        access_count = access_count + 1,
-        salience = ?
-    WHERE id = ?
-  `).run(newSalience, memoryId);
-}
-// ============================================
-// ORGANIC FEATURE: Memory Enrichment (Phase 3)
-// ============================================
-// Enrichment configuration
-const ENRICHMENT_SIMILARITY_THRESHOLD = 0.3; // Min similarity to trigger enrichment
-const ENRICHMENT_COOLDOWN_HOURS = 1; // Don't enrich same memory within 1 hour
-const MAX_ENRICHMENT_SIZE = 2000; // Max chars to add per enrichment
-// Track last enrichment times (in-memory, ephemeral like activation cache)
-const enrichmentTimestamps = new Map();
-let enrichmentCallCount = 0;
-function pruneEnrichmentTimestamps() {
-    const now = Date.now();
-    const cooldownMs = ENRICHMENT_COOLDOWN_HOURS * 60 * 60 * 1000;
-    for (const [memoryId, timestamp] of enrichmentTimestamps) {
-        if (now - timestamp > cooldownMs) {
-            enrichmentTimestamps.delete(memoryId);
-        }
-    }
-}
-/**
- * Enrich a memory with additional context
- *
- * This adds timestamped context to a memory when:
- * 1. The new context is sufficiently related but different (new information)
- * 2. The memory hasn't been enriched recently (cooldown)
- * 3. The content won't exceed the size limit
- *
- * ORGANIC FEATURE: Memories grow with new context over time,
- * mimicking how human memories are reconsolidated with new information
- *
- * @param memoryId - ID of the memory to enrich
- * @param newContext - New context to add
- * @param contextType - Type of context ('search' | 'access' | 'related')
- * @returns EnrichmentResult indicating success or failure with reason
- */
-export function enrichMemory(memoryId, newContext, contextType = 'access') {
-    // Prune stale cooldown entries every 100 calls
-    if (++enrichmentCallCount % 100 === 0) {
-        pruneEnrichmentTimestamps();
-    }
-    const db = getDatabase();
-    const memory = getMemoryById(memoryId);
-    if (!memory) {
-        return { enriched: false, reason: 'Memory not found' };
-    }
-    // Check cooldown
-    const lastEnrichment = enrichmentTimestamps.get(memoryId);
-    const now = Date.now();
-    if (lastEnrichment && (now - lastEnrichment) < ENRICHMENT_COOLDOWN_HOURS * 60 * 60 * 1000) {
-        return { enriched: false, reason: 'Enrichment cooldown active' };
-    }
-    // Check similarity - should be related but not too similar (new info)
-    const similarity = jaccardSimilarity(memory.content, newContext);
-    if (similarity > 0.8) {
-        return { enriched: false, reason: 'Context too similar (no new information)' };
-    }
-    if (similarity < ENRICHMENT_SIMILARITY_THRESHOLD) {
-        return { enriched: false, reason: 'Context not sufficiently related' };
-    }
-    // Truncate context if needed
-    const truncatedContext = newContext.slice(0, MAX_ENRICHMENT_SIZE);
-    // Build enrichment block with timestamp
-    const timestamp = new Date().toISOString().split('T')[0]; // YYYY-MM-DD
-    const enrichmentBlock = `\n\n---\n[${timestamp}] ${contextType}: ${truncatedContext}`;
-    // Check size limit (leave 500 char buffer for future enrichments)
-    const newContent = memory.content + enrichmentBlock;
-    if (newContent.length > MAX_CONTENT_SIZE - 500) {
-        return { enriched: false, reason: 'Content size limit reached' };
-    }
-    // Update memory
-    db.prepare(`
-    UPDATE memories
-    SET content = ?,
-        last_accessed = CURRENT_TIMESTAMP
-    WHERE id = ?
-  `).run(newContent, memoryId);
-    // Update cooldown timestamp
-    enrichmentTimestamps.set(memoryId, now);
-    // Emit update event for dashboard
-    const updatedMemory = getMemoryById(memoryId);
-    emitMemoryUpdated(updatedMemory);
-    return { enriched: true, reason: `Added ${contextType} context (${truncatedContext.length} chars)` };
-}
-/**
- * Clear enrichment cooldown for a memory (for testing)
- */
-export function clearEnrichmentCooldown(memoryId) {
-    enrichmentTimestamps.delete(memoryId);
-}
-/**
- * Get enrichment cooldown status for a memory
- */
-export function getEnrichmentCooldownStatus(memoryId) {
-    const lastEnrichment = enrichmentTimestamps.get(memoryId);
-    if (!lastEnrichment) {
-        return { onCooldown: false, remainingMs: 0 };
-    }
-    const cooldownMs = ENRICHMENT_COOLDOWN_HOURS * 60 * 60 * 1000;
-    const elapsed = Date.now() - lastEnrichment;
-    const remaining = Math.max(0, cooldownMs - elapsed);
-    return {
-        onCooldown: remaining > 0,
-        remainingMs: remaining,
-    };
-}
-/**
- * Update persisted decay scores for all memories
- * Called during consolidation and periodically by the API server
- * Returns the number of memories updated
- */
-export function updateDecayScores() {
-    const db = getDatabase();
-    // Get all memories
-    const memories = db.prepare('SELECT * FROM memories').all();
-    let updated = 0;
-    const updateStmt = db.prepare('UPDATE memories SET decayed_score = ? WHERE id = ?');
-    for (const row of memories) {
-        const memory = rowToMemory(row);
-        const decayedScore = calculateDecayedScore(memory);
-        // Only update if score has changed significantly (saves writes)
-        const currentScore = row.decayed_score;
-        if (currentScore === null || Math.abs(currentScore - decayedScore) > 0.01) {
-            updateStmt.run(decayedScore, memory.id);
-            updated++;
-        }
-    }
-    return updated;
-}
-async function searchMemoriesInternal(options, config, source, execution) {
-    if (++searchCount % 100 === 0) {
-        pruneActivationCache();
-    }
-    const db = getDatabase();
-    const limit = options.limit || 20;
-    const includeGlobal = options.includeGlobal ?? true;
-    const detectedCategory = options.query ? detectQueryCategory(options.query) : null;
-    const queryTags = options.query ? extractQueryTags(options.query) : [];
-    let queryEmbedding = null;
-    const vectorResults = new Map();
-    if (options.query && options.query.trim()) {
-        try {
-            queryEmbedding = await getCachedQueryEmbedding(options.query);
-            if (!queryEmbedding) {
-                throw new Error('query embedding unavailable');
-            }
-            const vectorHits = vectorSearch(db, rowToMemory, queryEmbedding, limit * 2, options.project, includeGlobal);
-            for (const hit of vectorHits) {
-                vectorResults.set(hit.memory.id, hit.similarity);
-            }
-        }
-        catch {
-            if (process.env.SHIELDCORTEX_SKIP_EMBEDDINGS !== '1') {
-                console.log('[shieldcortex] Vector search unavailable, using FTS only');
-            }
-        }
-    }
-    let sql;
-    const params = [];
-    if (options.query && options.query.trim()) {
-        const escapedQuery = escapeFts5Query(options.query.trim());
-        sql = `
-      SELECT m.*, fts.rank
-      FROM memories m
-      JOIN memories_fts fts ON m.id = fts.rowid
-      WHERE memories_fts MATCH ?
-    `;
-        params.push(escapedQuery);
-    }
-    else {
-        sql = `SELECT *, 0 as rank FROM memories m WHERE 1=1`;
-    }
-    if (options.project) {
-        if (includeGlobal) {
-            sql += ` AND (m.project = ? OR m.scope = 'global')`;
-        }
-        else {
-            sql += ' AND m.project = ?';
-        }
-        params.push(options.project);
-    }
-    if (options.category) {
-        sql += ' AND m.category = ?';
-        params.push(options.category);
-    }
-    if (options.type) {
-        sql += ' AND m.type = ?';
-        params.push(options.type);
-    }
-    if (!options.includeArchived) {
-        sql += ` AND m.status != 'archived'`;
-    }
-    if (!options.includeSuppressed) {
-        sql += ` AND m.status != 'suppressed'`;
-    }
-    if (options.minSalience) {
-        sql += ' AND m.salience >= ?';
-        params.push(options.minSalience);
-    }
-    if (options.tags && options.tags.length > 0) {
-        const tagPlaceholders = options.tags.map(() => '?').join(',');
-        sql += ` AND EXISTS (
-      SELECT 1 FROM json_each(m.tags)
-      WHERE json_each.value IN (${tagPlaceholders})
-    )`;
-        params.push(...options.tags);
-    }
-    sql += ' ORDER BY m.salience DESC, m.last_accessed DESC LIMIT ?';
-    params.push(limit);
-    const rows = db.prepare(sql).all(...params);
-    const scoringContext = {
-        db,
-        config,
-        detectedCategory,
-        queryTags,
-        vectorResults,
-        query: options.query,
-    };
-    const results = rows.map((row) => {
-        const memory = rowToMemory(row);
-        const decayedScore = calculateDecayedScore(memory, config);
-        memory.decayedScore = decayedScore;
-        const rawRank = row.rank;
-        const ftsScore = rawRank ? 1 / (1 + Math.abs(rawRank)) : 0.3;
-        const hoursSinceAccess = (Date.now() - new Date(memory.lastAccessed).getTime()) / (1000 * 60 * 60);
-        const recencyBoost = hoursSinceAccess < 1 ? 0.1 : (hoursSinceAccess < 24 ? 0.05 : 0);
-        const categoryBoost = detectedCategory && memory.category === detectedCategory ? 0.1 : 0;
-        const linkBoost = calculateLinkBoost(memory.id, db);
-        const tagBoost = calculateTagScore(queryTags, memory.tags);
-        const activationBoost = getActivationBoost(memory.id);
-        const vectorSimilarity = vectorResults.get(memory.id) || 0;
-        const vectorBoost = vectorSimilarity * 0.3;
-        const priorityBoost = calculatePriority(memory) * 0.05;
-        const contradictionCount = db.prepare(`SELECT COUNT(*) as count FROM memory_links WHERE relationship = 'contradicts' AND (source_id = ? OR target_id = ?)`).get(memory.id, memory.id).count;
-        const contradictionPenalty = Math.min(0.12, contradictionCount * 0.03);
-        const eligibilityReasons = [];
-        if (memory.status === 'archived')
-            eligibilityReasons.push('Archived memories are excluded from normal recall');
-        if (memory.status === 'suppressed')
-            eligibilityReasons.push('Suppressed memories are excluded from normal recall');
-        if (memory.cloudExcluded)
-            eligibilityReasons.push('Excluded from cloud sync');
-        if (memory.trustScore < 0.7)
-            eligibilityReasons.push(`Low trust source (${memory.trustScore.toFixed(2)})`);
-        if (contradictionCount > 0)
-            eligibilityReasons.push(`${contradictionCount} contradiction link${contradictionCount === 1 ? '' : 's'} attached`);
-        const relevanceScore = (ftsScore * 0.25 +
-            vectorBoost +
-            decayedScore * 0.2 +
-            priorityBoost +
-            recencyBoost + categoryBoost + linkBoost + tagBoost + activationBoost -
-            contradictionPenalty);
-        const result = {
-            memory,
-            relevanceScore,
-            recallEligibility: {
-                eligible: eligibilityReasons.length === 0,
-                reasons: eligibilityReasons,
-            },
-        };
-        if (execution.includeExplanation) {
-            result.explanation = buildSearchExplanation(memory, scoringContext, {
-                ftsScore,
-                vectorSimilarity,
-                vectorBoost,
-                decayedScore,
-                priorityBoost,
-                recencyBoost,
-                categoryBoost,
-                linkBoost,
-                tagBoost,
-                activationBoost,
-                contradictionPenalty,
-                finalScore: relevanceScore,
-            });
-            if (result.explanation) {
-                result.explanation.eligibility = result.recallEligibility;
-            }
-        }
-        return result;
-    });
-    const sortedResults = results
-        .filter((result) => options.includeDecayed || result.memory.decayedScore >= config.salienceThreshold)
-        .sort((a, b) => b.relevanceScore - a.relevanceScore);
-    if (execution.enableSideEffects) {
-        const topResults = sortedResults.slice(0, 5);
-        for (const result of topResults) {
-            reinforceFromSearch(result.memory.id);
-        }
-        if (topResults.length >= 2) {
-            for (let i = 0; i < topResults.length; i++) {
-                for (let j = i + 1; j < topResults.length; j++) {
-                    const idA = topResults[i].memory.id;
-                    const idB = topResults[j].memory.id;
-                    const existing = db.prepare('SELECT strength FROM memory_links WHERE (source_id = ? AND target_id = ?) OR (source_id = ? AND target_id = ?)').get(idA, idB, idB, idA);
-                    if (existing) {
-                        const newStrength = Math.min(1.0, existing.strength + 0.03);
-                        db.prepare('UPDATE memory_links SET strength = ? WHERE (source_id = ? AND target_id = ?) OR (source_id = ? AND target_id = ?)').run(newStrength, idA, idB, idB, idA);
-                    }
-                    else {
-                        try {
-                            db.prepare('INSERT INTO memory_links (source_id, target_id, relationship, strength) VALUES (?, ?, ?, ?)').run(idA, idB, 'related', 0.2);
-                        }
-                        catch (e) {
-                            if (!(e instanceof Error && e.message.includes('UNIQUE constraint'))) {
-                                console.warn('[shieldcortex] Unexpected error linking co-returned memories:', e);
-                            }
-                        }
-                    }
-                }
-            }
-        }
-        if (sortedResults.length > 0 && options.query && options.query.length > 30) {
-            const topResult = sortedResults[0];
-            const queryWords = new Set(options.query.toLowerCase().split(/\s+/).filter(w => w.length > 3));
-            const contentWords = new Set(topResult.memory.content.toLowerCase().split(/\s+/));
-            const newWords = [...queryWords].filter(w => !contentWords.has(w));
-            if (newWords.length > queryWords.size * 0.3 && options.query.length > 50) {
-                try {
-                    enrichMemory(topResult.memory.id, options.query, 'search');
-                }
-                catch {
-                    // enrichment is best-effort
-                }
-            }
-        }
-    }
-    const finalResults = sortedResults.slice(0, limit);
-    for (const result of finalResults) {
-        const contradictions = db.prepare(`
-      SELECT ml.strength,
-        CASE WHEN ml.source_id = ? THEN ml.target_id ELSE ml.source_id END as other_id
-      FROM memory_links ml
-      WHERE ml.relationship = 'contradicts'
-        AND (ml.source_id = ? OR ml.target_id = ?)
-    `).all(result.memory.id, result.memory.id, result.memory.id);
-        if (contradictions.length > 0) {
-            result.contradictions = contradictions.map((contradiction) => {
-                const other = db.prepare('SELECT title FROM memories WHERE id = ?').get(contradiction.other_id);
-                return { memoryId: contradiction.other_id, title: other?.title || 'Unknown', score: contradiction.strength };
-            });
-            if (result.explanation) {
-                result.explanation.reasons.push(`${contradictions.length} contradiction link${contradictions.length === 1 ? '' : 's'} attached`);
-            }
-        }
-    }
-    if (source) {
-        const db2 = getDatabase();
-        return finalResults.filter(result => {
-            const row = db2.prepare('SELECT source, sensitivity_level FROM memories WHERE id = ?').get(result.memory.id);
-            const policy = checkAccess({ id: result.memory.id, source: row?.source, sensitivity_level: row?.sensitivity_level }, source, 'read');
-            if (!policy.canRead) {
-                logAccessDenial(result.memory.id, source, policy.reason);
-                return false;
-            }
-            return true;
-        });
-    }
-    return finalResults;
-}
-/**
- * Search memories using full-text search, vector similarity, and filters
- * Now uses hybrid search combining FTS5 keywords with semantic vector matching
- */
-let searchCount = 0;
-export async function searchMemories(options, config = DEFAULT_CONFIG, source) {
-    return searchMemoriesInternal(options, config, source, {
-        enableSideEffects: true,
-        includeExplanation: false,
-    });
-}
-export async function searchMemoriesExplained(options, config = DEFAULT_CONFIG, source) {
-    return searchMemoriesInternal(options, config, source, {
-        enableSideEffects: false,
-        includeExplanation: true,
-    });
-}
-/**
- * Recall with embedding-based vector similarity fallback.
- *
- * 1. First tries FTS5 search (existing searchMemories)
- * 2. If FTS5 returns < 3 results, also runs embedding similarity search
- * 3. Merges results (FTS5 first, then embedding results not already in FTS5 set)
- * 4. Caps at `limit` (default 15)
- * 5. The `threshold` (default 0.3) filters out low-similarity embedding results
- */
-export async function recallWithEmbeddings(query, options) {
-    const limit = options?.limit ?? 15;
-    const threshold = options?.threshold ?? 0.3;
-    // Step 1: Try FTS5 search first
-    let ftsResults = options?.existingResults ?? [];
-    if (ftsResults.length === 0) {
-        try {
-            ftsResults = await searchMemories({
-                query,
-                project: options?.project,
-                limit,
-                includeGlobal: true,
-            });
-        }
-        catch (e) {
-            // FTS search failed — continue to embedding fallback
-            console.warn('[shieldcortex] FTS search failed in recallWithEmbeddings:', e.message);
-        }
-    }
-    const ftsMemories = ftsResults.map(r => r.memory);
-    // Step 2: If FTS5 returns >= 3 results, no need for embedding fallback
-    if (ftsMemories.length >= 3) {
-        return ftsMemories.slice(0, limit);
-    }
-    // Step 3: Run embedding similarity search as fallback
-    try {
-        const { initEmbeddings } = await import('./embedding.js');
-        const ready = await initEmbeddings();
-        if (!ready) {
-            return ftsMemories.slice(0, limit);
-        }
-        // Get candidate memories from the database (not already in FTS results)
-        const ftsIds = new Set(ftsMemories.map(m => m.id));
-        const db = getDatabase();
-        let sql = 'SELECT id, title, content FROM memories WHERE 1=1';
-        const params = [];
-        if (options?.project) {
-            sql += ` AND (project = ? OR scope = 'global')`;
-            params.push(options.project);
-        }
-        sql += ' ORDER BY salience DESC, last_accessed DESC LIMIT 200';
-        const candidates = db.prepare(sql).all(...params);
-        // Filter out memories already returned by FTS
-        const newCandidates = candidates.filter(c => !ftsIds.has(c.id));
-        if (newCandidates.length === 0) {
-            return ftsMemories.slice(0, limit);
-        }
-        const queryEmbedding = options?.queryEmbedding ?? await getCachedQueryEmbedding(query);
-        if (!queryEmbedding) {
-            return ftsMemories.slice(0, limit);
-        }
-        // Find similar memories using embeddings
-        const remainingSlots = limit - ftsMemories.length;
-        const similar = await findSimilarMemories(query, newCandidates, remainingSlots, queryEmbedding);
-        // Filter by threshold and fetch full Memory objects
-        const embeddingMemories = [];
-        for (const hit of similar) {
-            if (hit.score < threshold)
-                continue;
-            const row = db.prepare('SELECT * FROM memories WHERE id = ?').get(hit.id);
-            if (row) {
-                embeddingMemories.push(rowToMemory(row));
-            }
-        }
-        // Step 4: Merge — FTS results first, then embedding results
-        const merged = [...ftsMemories, ...embeddingMemories];
-        return merged.slice(0, limit);
-    }
-    catch (e) {
-        // Embedding fallback failed — return whatever FTS found
-        console.warn('[shieldcortex] Embedding fallback failed:', e.message);
-        return ftsMemories.slice(0, limit);
-    }
-}
 /**
  * Get all memories for a project
  */
@@ -1435,38 +844,6 @@ export function getHighPriorityMemories(limit = 10, project, source) {
         rows = filterRowsByAccess(rows, source);
     return rows.slice(0, limit).map(rowToMemory);
 }
-/**
- * Promote a memory from short-term to long-term
- */
-export function promoteMemory(id) {
-    const db = getDatabase();
-    db.prepare(`
-    UPDATE memories
-    SET type = 'long_term'
-    WHERE id = ? AND type = 'short_term'
-  `).run(id);
-    return getMemoryById(id);
-}
-/**
- * Bulk delete decayed memories
- */
-export function cleanupDecayedMemories(config = DEFAULT_CONFIG) {
-    const db = getDatabase();
-    // Get all short-term memories and check decay
-    const shortTerm = getMemoriesByType('short_term', 1000);
-    const toDelete = [];
-    for (const memory of shortTerm) {
-        const decayedScore = calculateDecayedScore(memory, config);
-        if (decayedScore < config.salienceThreshold) {
-            toDelete.push(memory.id);
-        }
-    }
-    if (toDelete.length > 0) {
-        const placeholders = toDelete.map(() => '?').join(',');
-        db.prepare(`DELETE FROM memories WHERE id IN (${placeholders})`).run(...toDelete);
-    }
-    return toDelete.length;
-}
 /**
  * Get memory statistics
  */
@@ -1503,219 +880,33 @@ export function getMemoryStats(project) {
         averageSalience,
     };
 }
-/**
- * Create a link between two memories
- */
-export function createMemoryLink(sourceId, targetId, relationship, strength = 0.5) {
-    const db = getDatabase();
-    // Verify both memories exist
-    const source = getMemoryById(sourceId);
-    const target = getMemoryById(targetId);
-    if (!source || !target)
-        return null;
-    // Prevent self-links
-    if (sourceId === targetId)
-        return null;
-    try {
-        const result = db.prepare(`
-      INSERT INTO memory_links (source_id, target_id, relationship, strength)
-      VALUES (?, ?, ?, ?)
-    `).run(sourceId, targetId, relationship, strength);
-        return {
-            id: result.lastInsertRowid,
-            sourceId,
-            targetId,
-            relationship,
-            strength,
-            createdAt: new Date(),
-        };
-    }
-    catch {
-        // Link already exists (UNIQUE constraint)
-        return null;
-    }
-}
-/**
- * Get all memories related to a given memory
- */
-export function getRelatedMemories(memoryId) {
-    const db = getDatabase();
-    // Get outgoing links (this memory references others)
-    const outgoing = db.prepare(`
-    SELECT m.*, ml.relationship, ml.strength
-    FROM memory_links ml
-    JOIN memories m ON m.id = ml.target_id
-    WHERE ml.source_id = ?
-  `).all(memoryId);
-    // Get incoming links (other memories reference this one)
-    const incoming = db.prepare(`
-    SELECT m.*, ml.relationship, ml.strength
-    FROM memory_links ml
-    JOIN memories m ON m.id = ml.source_id
-    WHERE ml.target_id = ?
-  `).all(memoryId);
-    const results = [];
-    for (const row of outgoing) {
-        results.push({
-            memory: rowToMemory(row),
-            relationship: row.relationship,
-            strength: row.strength,
-            direction: 'outgoing',
-        });
-    }
-    for (const row of incoming) {
-        results.push({
-            memory: rowToMemory(row),
-            relationship: row.relationship,
-            strength: row.strength,
-            direction: 'incoming',
-        });
-    }
-    return results;
-}
-/**
- * Delete a memory link
- */
-export function deleteMemoryLink(sourceId, targetId) {
-    const db = getDatabase();
-    const result = db.prepare(`
-    DELETE FROM memory_links WHERE source_id = ? AND target_id = ?
-  `).run(sourceId, targetId);
-    return result.changes > 0;
-}
-/**
- * Get all memory links
- */
-export function getAllMemoryLinks() {
-    const db = getDatabase();
-    const rows = db.prepare(`SELECT * FROM memory_links ORDER BY created_at DESC`).all();
-    return rows.map(row => ({
-        id: row.id,
-        sourceId: row.source_id,
-        targetId: row.target_id,
-        relationship: row.relationship,
-        strength: row.strength,
-        createdAt: new Date(row.created_at),
-    }));
-}
-/**
- * Detect tag-based links for a memory.
- * Finds memories sharing tags and scores by overlap count.
- */
-function detectTagLinks(db, memory, maxResults) {
-    const results = [];
-    if (memory.tags.length > 0) {
-        const tagPlaceholders = memory.tags.map(() => '?').join(',');
-        const tagMatches = db.prepare(`
-      SELECT DISTINCT m.id, m.tags
-      FROM memories m, json_each(m.tags)
-      WHERE json_each.value IN (${tagPlaceholders})
-        AND m.id != ?
-      LIMIT ?
-    `).all(...memory.tags, memory.id, maxResults);
-        for (const match of tagMatches) {
-            const matchTags = JSON.parse(match.tags);
-            const sharedCount = memory.tags.filter(t => matchTags.includes(t)).length;
-            const strength = Math.min(0.9, 0.3 + (sharedCount * 0.2));
-            results.push({ targetId: match.id, relationship: 'related', strength });
-        }
-    }
-    return results;
-}
-/**
- * Detect embedding-based semantic links for a memory.
- * Computes cosine similarity against top memories that have embeddings.
- */
-function detectEmbeddingLinks(db, memory, maxResults) {
-    if (!memory.embedding)
-        return [];
-    const candidates = db.prepare(`
-    SELECT id, embedding FROM memories
-    WHERE embedding IS NOT NULL AND id != ?
-    ORDER BY decayed_score DESC
-    LIMIT 100
-  `).all(memory.id);
-    const results = [];
-    const sourceEmbedding = new Float32Array(memory.embedding.buffer, memory.embedding.byteOffset, memory.embedding.byteLength / 4);
-    for (const candidate of candidates) {
-        const candidateEmbedding = new Float32Array(candidate.embedding.buffer, candidate.embedding.byteOffset, candidate.embedding.byteLength / 4);
-        const similarity = cosineSimilarity(sourceEmbedding, candidateEmbedding);
-        if (similarity >= 0.6) {
-            results.push({
-                targetId: candidate.id,
-                relationship: 'related',
-                strength: Math.min(0.9, similarity),
-            });
-        }
-    }
-    return results;
-}
-/**
- * Detect content-based links using FTS5 and Jaccard similarity.
- * Fallback when embeddings are not available.
- */
-function detectFtsLinks(db, memory, maxResults) {
-    const queryText = `${memory.title} ${memory.content.slice(0, 200)}`;
-    const escapedQuery = escapeFts5Query(queryText);
-    if (!escapedQuery.trim())
-        return [];
-    let ftsMatches;
-    try {
-        ftsMatches = db.prepare(`
-      SELECT m.id, m.title, m.content
-      FROM memories_fts fts
-      JOIN memories m ON m.id = fts.rowid
-      WHERE memories_fts MATCH ?
-        AND m.id != ?
-      LIMIT ?
-    `).all(escapedQuery, memory.id, maxResults * 2);
-    }
-    catch {
-        return [];
-    }
-    const results = [];
-    for (const match of ftsMatches) {
-        const matchText = `${match.title} ${match.content.slice(0, 200)}`;
-        const sim = jaccardSimilarity(queryText, matchText);
-        if (sim >= 0.3) {
-            results.push({
-                targetId: match.id,
-                relationship: 'related',
-                strength: Math.min(0.7, sim + 0.2),
-            });
-        }
-    }
-    return results;
-}
-/**
- * Detect potential relationships for a new memory
- * Uses three strategies in priority order:
- * 1. Tag-based linking (shared tags)
- * 2. Embedding-based semantic linking (cosine similarity >= 0.6)
- * 3. FTS content similarity fallback (Jaccard similarity >= 0.3)
- */
-export function detectRelationships(memory, maxResults = 5) {
-    const db = getDatabase();
-    const seen = new Set();
-    const results = [];
-    function addResults(links) {
-        for (const link of links) {
-            if (!seen.has(link.targetId)) {
-                seen.add(link.targetId);
-                results.push(link);
-            }
-        }
-    }
-    // 1. Tag-based linking
-    addResults(detectTagLinks(db, memory, maxResults));
-    // 2. Embedding-based semantic linking
-    addResults(detectEmbeddingLinks(db, memory, maxResults));
-    // 3. FTS content similarity fallback (when no embeddings)
-    if (!memory.embedding) {
-        addResults(detectFtsLinks(db, memory, maxResults));
-    }
-    // Sort by strength descending and limit
-    return results
-        .sort((a, b) => b.strength - a.strength)
-        .slice(0, maxResults);
-}
+// ============================================================================
+// MEMORY RELATIONSHIPS (LINKS) — moved to ./links.ts
+// ============================================================================
+// The link API was extracted into src/memory/links.ts so the store module can
+// be read concern-by-concern instead of as one 2,100-line file. Re-exported
+// here so every existing `import { ... } from '.../store.js'` path keeps
+// working with zero behaviour change.
+export { createMemoryLink, getRelatedMemories, deleteMemoryLink, getAllMemoryLinks, detectRelationships, } from './links.js';
+// ============================================================================
+// MEMORY LIFECYCLE — moved to ./lifecycle.ts
+// ============================================================================
+// Phase 2 of the store.ts split. The lifecycle group (access reinforcement,
+// search reinforcement, enrichment, decay-score persistence, STM→LTM
+// promotion, decayed-memory cleanup) lives in src/memory/lifecycle.ts.
+// Re-exported here so every existing `import { ... } from '.../store.js'`
+// path keeps working with zero behaviour change.
+export { accessMemory, reinforceFromSearch, enrichMemory, clearEnrichmentCooldown, getEnrichmentCooldownStatus, updateDecayScores, promoteMemory, cleanupDecayedMemories, } from './lifecycle.js';
+// ============================================================================
+// MEMORY SEARCH / RECALL — moved to ./search-recall.ts
+// ============================================================================
+// Phase 3 of the store.ts split. The search/recall group (the public
+// `searchMemories`, `searchMemoriesExplained`, `recallWithEmbeddings`
+// entry points plus the internal `searchMemoriesInternal` pipeline and
+// the module-level `searchCount` activation-cache pruner) lives in
+// src/memory/search-recall.ts. Re-exported here so every existing
+// `import { ... } from '.../store.js'` path keeps working with zero
+// behaviour change. search-recall.ts imports `rowToMemory` and
+// `logAccessDenial` back from store.ts via the same function-body-only
+// cycle pattern used by links.ts and lifecycle.ts.
+export { searchMemories, searchMemoriesExplained, recallWithEmbeddings, } from './search-recall.js';