claude-cortex 1.0.0

package/dist/memory/activation.js

@@ -0,0 +1,168 @@
+/**
+ * Spreading Activation System
+ *
+ * Implements brain-like spreading activation where accessing a memory
+ * "primes" related memories, making them easier to recall.
+ *
+ * EPHEMERAL: This cache is session-only and does not persist to disk.
+ * Each MCP server restart starts with a fresh activation state.
+ *
+ * Based on spreading activation theory in cognitive psychology:
+ * - Collins & Loftus (1975) semantic network model
+ * - Activation spreads through associative links
+ * - Activation decays over time (exponential decay)
+ */
+import { getRelatedMemories } from './store.js';
+/**
+ * In-memory activation cache
+ * Ephemeral - cleared on process restart
+ */
+const activationCache = new Map();
+// Configuration
+const DECAY_HALF_LIFE_MINUTES = 30; // Activation halves every 30 minutes
+const SPREAD_FACTOR = 0.5; // How much activation spreads (50% of link strength)
+const MAX_SPREAD_DEPTH = 1; // Only spread to direct neighbors (not neighbors of neighbors)
+const MAX_ACTIVATION_BOOST = 0.2; // Cap search boost at 20%
+/**
+ * Activate a memory and spread activation to linked memories
+ *
+ * When a memory is accessed, it becomes fully activated (1.0).
+ * Linked memories receive partial activation based on link strength.
+ *
+ * @param memoryId - The ID of the memory being accessed
+ */
+export function activateMemory(memoryId) {
+    const now = Date.now();
+    // Fully activate the accessed memory
+    activationCache.set(memoryId, {
+        memoryId,
+        activationLevel: 1.0,
+        timestamp: now,
+    });
+    // Spread activation to linked memories
+    try {
+        const related = getRelatedMemories(memoryId);
+        for (const link of related) {
+            // Calculate spread amount: link strength * spread factor
+            const spreadAmount = link.strength * SPREAD_FACTOR;
+            // Get existing activation (if any)
+            const existing = activationCache.get(link.memory.id);
+            const existingLevel = existing
+                ? getDecayedActivation(existing, now)
+                : 0;
+            // Add activation (cap at 1.0)
+            const newLevel = Math.min(1.0, existingLevel + spreadAmount);
+            activationCache.set(link.memory.id, {
+                memoryId: link.memory.id,
+                activationLevel: newLevel,
+                timestamp: now,
+            });
+        }
+    }
+    catch (e) {
+        // Don't fail memory access if spreading fails
+        console.error('[claude-cortex] Activation spreading failed:', e);
+    }
+}
+/**
+ * Calculate decayed activation level
+ *
+ * Uses exponential decay: level * 0.5^(minutes / half_life)
+ */
+function getDecayedActivation(entry, now) {
+    const ageMinutes = (now - entry.timestamp) / (1000 * 60);
+    const decayFactor = Math.pow(0.5, ageMinutes / DECAY_HALF_LIFE_MINUTES);
+    return entry.activationLevel * decayFactor;
+}
+/**
+ * Get the activation boost for a memory in search scoring
+ *
+ * Returns 0 if memory is not activated or activation has fully decayed.
+ * Returns up to MAX_ACTIVATION_BOOST for fully activated memories.
+ *
+ * @param memoryId - The ID of the memory to check
+ * @returns Activation boost (0 to MAX_ACTIVATION_BOOST)
+ */
+export function getActivationBoost(memoryId) {
+    const entry = activationCache.get(memoryId);
+    if (!entry)
+        return 0;
+    const now = Date.now();
+    const decayedLevel = getDecayedActivation(entry, now);
+    // If activation is negligible, clean up the entry
+    if (decayedLevel < 0.01) {
+        activationCache.delete(memoryId);
+        return 0;
+    }
+    // Scale to max boost (e.g., 1.0 activation -> 0.2 boost)
+    return decayedLevel * MAX_ACTIVATION_BOOST;
+}
+/**
+ * Get current activation level for a memory (for debugging/dashboard)
+ *
+ * @param memoryId - The ID of the memory to check
+ * @returns Current activation level (0-1) or null if not activated
+ */
+export function getActivationLevel(memoryId) {
+    const entry = activationCache.get(memoryId);
+    if (!entry)
+        return null;
+    const decayedLevel = getDecayedActivation(entry, Date.now());
+    if (decayedLevel < 0.01)
+        return null;
+    return decayedLevel;
+}
+/**
+ * Get all currently activated memories with their levels
+ * Useful for dashboard visualization
+ *
+ * @returns Array of {memoryId, activationLevel} for all activated memories
+ */
+export function getActiveMemories() {
+    const now = Date.now();
+    const active = [];
+    for (const entry of activationCache.values()) {
+        const level = getDecayedActivation(entry, now);
+        if (level >= 0.01) {
+            active.push({ memoryId: entry.memoryId, activationLevel: level });
+        }
+    }
+    return active.sort((a, b) => b.activationLevel - a.activationLevel);
+}
+/**
+ * Clear the activation cache
+ * Useful for testing or manual reset
+ */
+export function clearActivationCache() {
+    activationCache.clear();
+}
+/**
+ * Prune stale entries from the activation cache
+ * Call periodically to prevent memory bloat
+ */
+export function pruneActivationCache() {
+    const now = Date.now();
+    let pruned = 0;
+    for (const [memoryId, entry] of activationCache) {
+        if (getDecayedActivation(entry, now) < 0.01) {
+            activationCache.delete(memoryId);
+            pruned++;
+        }
+    }
+    return pruned;
+}
+/**
+ * Get activation cache statistics
+ */
+export function getActivationStats() {
+    const active = getActiveMemories();
+    const avgActivation = active.length > 0
+        ? active.reduce((sum, a) => sum + a.activationLevel, 0) / active.length
+        : 0;
+    return {
+        totalEntries: activationCache.size,
+        activeEntries: active.length,
+        averageActivation: avgActivation,
+    };
+}
+//# sourceMappingURL=activation.js.map

package/dist/memory/activation.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"activation.js","sourceRoot":"","sources":["../../src/memory/activation.ts"],"names":[],"mappings":"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"}

package/dist/memory/consolidate.d.ts

@@ -0,0 +1,96 @@
+/**
+ * Memory Consolidation System
+ *
+ * Like sleep consolidation in human brains, this system:
+ * - Moves worthy short-term memories to long-term storage
+ * - Strengthens frequently accessed memories
+ * - Cleans up decayed/irrelevant memories
+ * - Merges similar memories to reduce redundancy
+ */
+import { Memory, MemoryConfig, ConsolidationResult, ContextSummary } from './types.js';
+/**
+ * Run full consolidation process
+ * This is like the brain's sleep consolidation - should be run periodically
+ */
+export declare function consolidate(config?: MemoryConfig): ConsolidationResult;
+/**
+ * Enforce maximum memory limits
+ * Removes lowest-priority memories when limits are exceeded
+ */
+export declare function enforceMemoryLimits(config?: MemoryConfig): number;
+/**
+ * Find and merge similar memories
+ * Reduces redundancy while preserving important information
+ */
+export declare function mergeSimilarMemories(project?: string, similarityThreshold?: number): number;
+/**
+ * Generate a context summary for session start
+ * Provides a high-level view of relevant memories
+ */
+export declare function generateContextSummary(project?: string, config?: MemoryConfig): Promise<ContextSummary>;
+/**
+ * Format context summary as a readable string
+ */
+export declare function formatContextSummary(summary: ContextSummary): string;
+/**
+ * Start a new session
+ * Creates a session record and returns relevant context
+ */
+export declare function startSession(project?: string): Promise<{
+    sessionId: number;
+    context: ContextSummary;
+}>;
+/**
+ * End a session
+ * Updates session record with summary
+ */
+export declare function endSession(sessionId: number, summary?: string): void;
+/**
+ * Get suggested context for the current query
+ * Returns memories that might be relevant to what the user is working on
+ */
+export declare function getSuggestedContext(currentContext: string, project?: string, limit?: number): Promise<Memory[]>;
+/**
+ * Export memories as JSON (for backup/transfer)
+ */
+export declare function exportMemories(project?: string): string;
+/**
+ * Import memories from JSON
+ */
+export declare function importMemories(json: string): number;
+/**
+ * Vacuum database to reclaim space after deletions
+ * Run periodically or after major cleanup operations
+ */
+export declare function vacuumDatabase(): {
+    success: boolean;
+    message: string;
+};
+/**
+ * Preview what consolidation would do without actually doing it
+ * Useful for dry-run mode
+ */
+export declare function previewConsolidation(config?: MemoryConfig): {
+    toPromote: Memory[];
+    toDelete: Memory[];
+    totalShortTerm: number;
+    totalLongTerm: number;
+};
+/**
+ * Check if consolidation should be triggered based on memory state
+ * Returns true if consolidation is recommended
+ */
+export declare function shouldTriggerConsolidation(config?: MemoryConfig): {
+    shouldRun: boolean;
+    reason: string;
+};
+/**
+ * Full cleanup: consolidate + vacuum
+ * Best run periodically to keep database healthy
+ */
+export declare function fullCleanup(config?: MemoryConfig): {
+    consolidation: ConsolidationResult;
+    vacuumed: boolean;
+    merged: number;
+};
+//# sourceMappingURL=consolidate.d.ts.map

package/dist/memory/consolidate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"consolidate.d.ts","sourceRoot":"","sources":["../../src/memory/consolidate.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAGH,OAAO,EACL,MAAM,EACN,YAAY,EAEZ,mBAAmB,EACnB,cAAc,EACf,MAAM,YAAY,CAAC;AAuBpB;;;GAGG;AACH,wBAAgB,WAAW,CACzB,MAAM,GAAE,YAA6B,GACpC,mBAAmB,CA0DrB;AAED;;;GAGG;AACH,wBAAgB,mBAAmB,CAAC,MAAM,GAAE,YAA6B,GAAG,MAAM,CA+CjF;AAED;;;GAGG;AACH,wBAAgB,oBAAoB,CAClC,OAAO,CAAC,EAAE,MAAM,EAChB,mBAAmB,GAAE,MAAY,GAChC,MAAM,CA6CR;AAED;;;GAGG;AACH,wBAAsB,sBAAsB,CAC1C,OAAO,CAAC,EAAE,MAAM,EAChB,MAAM,GAAE,YAA6B,GACpC,OAAO,CAAC,cAAc,CAAC,CAqCzB;AAED;;GAEG;AACH,wBAAgB,oBAAoB,CAAC,OAAO,EAAE,cAAc,GAAG,MAAM,CAuCpE;AAED;;;GAGG;AACH,wBAAsB,YAAY,CAAC,OAAO,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC;IAC5D,SAAS,EAAE,MAAM,CAAC;IAClB,OAAO,EAAE,cAAc,CAAC;CACzB,CAAC,CAcD;AAED;;;GAGG;AACH,wBAAgB,UAAU,CACxB,SAAS,EAAE,MAAM,EACjB,OAAO,CAAC,EAAE,MAAM,GACf,IAAI,CAwBN;AAED;;;GAGG;AACH,wBAAsB,mBAAmB,CACvC,cAAc,EAAE,MAAM,EACtB,OAAO,CAAC,EAAE,MAAM,EAChB,KAAK,GAAE,MAAU,GAChB,OAAO,CAAC,MAAM,EAAE,CAAC,CAWnB;AAED;;GAEG;AACH,wBAAgB,cAAc,CAAC,OAAO,CAAC,EAAE,MAAM,GAAG,MAAM,CAavD;AAED;;GAEG;AACH,wBAAgB,cAAc,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAgCnD;AAED;;;GAGG;AACH,wBAAgB,cAAc,IAAI;IAAE,OAAO,EAAE,OAAO,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAE,CAQtE;AAED;;;GAGG;AACH,wBAAgB,oBAAoB,CAClC,MAAM,GAAE,YAA6B,GACpC;IACD,SAAS,EAAE,MAAM,EAAE,CAAC;IACpB,QAAQ,EAAE,MAAM,EAAE,CAAC;IACnB,cAAc,EAAE,MAAM,CAAC;IACvB,aAAa,EAAE,MAAM,CAAC;CACvB,CA8BA;AAED;;;GAGG;AACH,wBAAgB,0BAA0B,CACxC,MAAM,GAAE,YAA6B,GACpC;IAAE,SAAS,EAAE,OAAO,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,CA2BxC;AAED;;;GAGG;AACH,wBAAgB,WAAW,CACzB,MAAM,GAAE,YAA6B,GACpC;IAAE,aAAa,EAAE,mBAAmB,CAAC;IAAC,QAAQ,EAAE,OAAO,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,CAe3E"}

package/dist/memory/consolidate.js

@@ -0,0 +1,400 @@
+/**
+ * Memory Consolidation System
+ *
+ * Like sleep consolidation in human brains, this system:
+ * - Moves worthy short-term memories to long-term storage
+ * - Strengthens frequently accessed memories
+ * - Cleans up decayed/irrelevant memories
+ * - Merges similar memories to reduce redundancy
+ */
+import { getDatabase, withTransaction } from '../database/init.js';
+import { DEFAULT_CONFIG, } from './types.js';
+import { getMemoriesByType, getRecentMemories, promoteMemory, deleteMemory, searchMemories, getMemoryStats, updateDecayScores, } from './store.js';
+import { processDecay, } from './decay.js';
+import { detectContradictions, linkContradictions, } from './contradiction.js';
+/**
+ * Run full consolidation process
+ * This is like the brain's sleep consolidation - should be run periodically
+ */
+export function consolidate(config = DEFAULT_CONFIG) {
+    // Wrap entire consolidation in a transaction for atomicity
+    return withTransaction(() => {
+        const db = getDatabase();
+        let consolidated = 0;
+        let decayed = 0;
+        let deleted = 0;
+        // Get all short-term memories
+        const shortTermMemories = getMemoriesByType('short_term', config.maxShortTermMemories * 2);
+        // Process decay for all memories
+        const { toDelete, toPromote, updated } = processDecay(shortTermMemories, config);
+        // Promote worthy memories
+        for (const id of toPromote) {
+            promoteMemory(id);
+            consolidated++;
+        }
+        // Delete decayed memories (excluding those just promoted)
+        for (const id of toDelete) {
+            if (!toPromote.includes(id)) {
+                deleteMemory(id);
+                deleted++;
+            }
+        }
+        // Update decayed scores in database
+        const updateStmt = db.prepare('UPDATE memories SET salience = ? WHERE id = ?');
+        for (const [id, score] of updated) {
+            if (!toDelete.includes(id)) {
+                updateStmt.run(score, id);
+                decayed++;
+            }
+        }
+        // Enforce memory limits
+        deleted += enforceMemoryLimits(config);
+        // Persist updated decay scores for efficient sorting
+        updateDecayScores();
+        // ORGANIC FEATURE: Contradiction Detection (Phase 3)
+        // Detect and link contradicting memories during consolidation
+        let contradictionsFound = 0;
+        let contradictionsLinked = 0;
+        try {
+            const contradictions = detectContradictions({ minScore: 0.5, limit: 50 });
+            contradictionsFound = contradictions.length;
+            contradictionsLinked = linkContradictions(contradictions);
+        }
+        catch (e) {
+            console.error('[claude-cortex] Contradiction detection failed:', e);
+        }
+        return { consolidated, decayed, deleted, contradictionsFound, contradictionsLinked };
+    });
+}
+/**
+ * Enforce maximum memory limits
+ * Removes lowest-priority memories when limits are exceeded
+ */
+export function enforceMemoryLimits(config = DEFAULT_CONFIG) {
+    // Note: If called within consolidate(), this is already in a transaction
+    // If called standalone, we wrap it for safety
+    const db = getDatabase();
+    let deleted = 0;
+    // Check short-term memory limit
+    const shortTermCount = db.prepare("SELECT COUNT(*) as count FROM memories WHERE type = 'short_term'").get().count;
+    if (shortTermCount > config.maxShortTermMemories) {
+        const toRemove = shortTermCount - config.maxShortTermMemories;
+        const lowPriority = db.prepare(`
+      SELECT id FROM memories
+      WHERE type = 'short_term'
+      ORDER BY salience ASC, last_accessed ASC
+      LIMIT ?
+    `).all(toRemove);
+        for (const { id } of lowPriority) {
+            deleteMemory(id);
+            deleted++;
+        }
+    }
+    // Check long-term memory limit (more lenient)
+    const longTermCount = db.prepare("SELECT COUNT(*) as count FROM memories WHERE type = 'long_term'").get().count;
+    if (longTermCount > config.maxLongTermMemories) {
+        const toRemove = longTermCount - config.maxLongTermMemories;
+        const lowPriority = db.prepare(`
+      SELECT id FROM memories
+      WHERE type = 'long_term'
+      ORDER BY salience ASC, access_count ASC, last_accessed ASC
+      LIMIT ?
+    `).all(toRemove);
+        for (const { id } of lowPriority) {
+            deleteMemory(id);
+            deleted++;
+        }
+    }
+    return deleted;
+}
+/**
+ * Find and merge similar memories
+ * Reduces redundancy while preserving important information
+ */
+export function mergeSimilarMemories(project, similarityThreshold = 0.8) {
+    // Wrap in transaction for atomic merge operations
+    return withTransaction(() => {
+        const db = getDatabase();
+        let merged = 0;
+        // Get all memories (optionally filtered by project)
+        let sql = 'SELECT * FROM memories';
+        const params = [];
+        if (project) {
+            sql += ' WHERE project = ?';
+            params.push(project);
+        }
+        sql += ' ORDER BY created_at ASC';
+        const memories = db.prepare(sql).all(...params);
+        // Simple similarity check based on title and first 100 chars of content
+        const seen = new Map(); // key -> id of primary memory
+        for (const row of memories) {
+            const key = `${row.title.toLowerCase().trim()}|${row.content.slice(0, 100).toLowerCase()}`;
+            if (seen.has(key)) {
+                // This is a duplicate, merge into the primary
+                const primaryId = seen.get(key);
+                // Boost the primary memory's salience
+                db.prepare(`
+          UPDATE memories
+          SET salience = MIN(1.0, salience + 0.1),
+              access_count = access_count + 1
+          WHERE id = ?
+        `).run(primaryId);
+                // Delete the duplicate
+                deleteMemory(row.id);
+                merged++;
+            }
+            else {
+                seen.set(key, row.id);
+            }
+        }
+        return merged;
+    });
+}
+/**
+ * Generate a context summary for session start
+ * Provides a high-level view of relevant memories
+ */
+export async function generateContextSummary(project, config = DEFAULT_CONFIG) {
+    // Get recent memories
+    const recentMemories = getRecentMemories(10, project);
+    // Get key architecture decisions
+    const keyDecisions = (await searchMemories({
+        query: '',
+        project,
+        category: 'architecture',
+        minSalience: 0.6,
+        limit: 5,
+    }, config)).map(r => r.memory);
+    // Get active patterns
+    const activePatterns = (await searchMemories({
+        query: '',
+        project,
+        category: 'pattern',
+        minSalience: 0.5,
+        limit: 5,
+    }, config)).map(r => r.memory);
+    // Get pending items
+    const pendingItems = (await searchMemories({
+        query: '',
+        project,
+        category: 'todo',
+        limit: 10,
+    }, config)).map(r => r.memory);
+    return {
+        project,
+        recentMemories,
+        keyDecisions,
+        activePatterns,
+        pendingItems,
+    };
+}
+/**
+ * Format context summary as a readable string
+ */
+export function formatContextSummary(summary) {
+    const lines = [];
+    if (summary.project) {
+        lines.push(`## Project: ${summary.project}\n`);
+    }
+    if (summary.keyDecisions.length > 0) {
+        lines.push('### Key Decisions');
+        for (const memory of summary.keyDecisions) {
+            lines.push(`- **${memory.title}**: ${memory.content.slice(0, 100)}${memory.content.length > 100 ? '...' : ''}`);
+        }
+        lines.push('');
+    }
+    if (summary.activePatterns.length > 0) {
+        lines.push('### Active Patterns');
+        for (const memory of summary.activePatterns) {
+            lines.push(`- **${memory.title}**: ${memory.content.slice(0, 100)}${memory.content.length > 100 ? '...' : ''}`);
+        }
+        lines.push('');
+    }
+    if (summary.pendingItems.length > 0) {
+        lines.push('### Pending Items');
+        for (const memory of summary.pendingItems) {
+            lines.push(`- [ ] ${memory.title}`);
+        }
+        lines.push('');
+    }
+    if (summary.recentMemories.length > 0) {
+        lines.push('### Recent Context');
+        for (const memory of summary.recentMemories.slice(0, 5)) {
+            lines.push(`- ${memory.title} (${memory.category})`);
+        }
+    }
+    return lines.join('\n');
+}
+/**
+ * Start a new session
+ * Creates a session record and returns relevant context
+ */
+export async function startSession(project) {
+    const db = getDatabase();
+    // Create session record
+    const result = db.prepare(`
+    INSERT INTO sessions (project) VALUES (?)
+  `).run(project || null);
+    const sessionId = result.lastInsertRowid;
+    // Generate context summary
+    const context = await generateContextSummary(project);
+    return { sessionId, context };
+}
+/**
+ * End a session
+ * Updates session record with summary
+ */
+export function endSession(sessionId, summary) {
+    const db = getDatabase();
+    // Get counts from this session
+    const stats = db.prepare(`
+    SELECT
+      (SELECT COUNT(*) FROM memories WHERE created_at >= s.started_at) as created,
+      (SELECT COUNT(*) FROM memories WHERE last_accessed >= s.started_at) as accessed
+    FROM sessions s WHERE s.id = ?
+  `).get(sessionId);
+    db.prepare(`
+    UPDATE sessions
+    SET ended_at = CURRENT_TIMESTAMP,
+        summary = ?,
+        memories_created = ?,
+        memories_accessed = ?
+    WHERE id = ?
+  `).run(summary || null, stats?.created || 0, stats?.accessed || 0, sessionId);
+}
+/**
+ * Get suggested context for the current query
+ * Returns memories that might be relevant to what the user is working on
+ */
+export async function getSuggestedContext(currentContext, project, limit = 5) {
+    // Search for relevant memories based on current context
+    const results = await searchMemories({
+        query: currentContext,
+        project,
+        minSalience: 0.4,
+        limit,
+        includeDecayed: false,
+    });
+    return results.map(r => r.memory);
+}
+/**
+ * Export memories as JSON (for backup/transfer)
+ */
+export function exportMemories(project) {
+    const db = getDatabase();
+    let sql = 'SELECT * FROM memories';
+    const params = [];
+    if (project) {
+        sql += ' WHERE project = ?';
+        params.push(project);
+    }
+    sql += ' ORDER BY created_at ASC';
+    const rows = db.prepare(sql).all(...params);
+    return JSON.stringify(rows, null, 2);
+}
+/**
+ * Import memories from JSON
+ */
+export function importMemories(json) {
+    // Wrap in transaction for atomic import
+    return withTransaction(() => {
+        const db = getDatabase();
+        const memories = JSON.parse(json);
+        const stmt = db.prepare(`
+      INSERT INTO memories (type, category, title, content, project, tags, salience, metadata)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+    `);
+        let imported = 0;
+        for (const memory of memories) {
+            try {
+                stmt.run(memory.type, memory.category, memory.title, memory.content, memory.project || null, memory.tags || '[]', memory.salience || 0.5, memory.metadata || '{}');
+                imported++;
+            }
+            catch {
+                // Skip duplicates or invalid entries
+            }
+        }
+        return imported;
+    });
+}
+/**
+ * Vacuum database to reclaim space after deletions
+ * Run periodically or after major cleanup operations
+ */
+export function vacuumDatabase() {
+    try {
+        const db = getDatabase();
+        db.exec('VACUUM');
+        return { success: true, message: 'Database vacuumed successfully' };
+    }
+    catch (error) {
+        return { success: false, message: `Vacuum failed: ${error}` };
+    }
+}
+/**
+ * Preview what consolidation would do without actually doing it
+ * Useful for dry-run mode
+ */
+export function previewConsolidation(config = DEFAULT_CONFIG) {
+    const db = getDatabase();
+    // Get all short-term memories
+    const shortTermMemories = getMemoriesByType('short_term', config.maxShortTermMemories * 2);
+    // Get episodic memories too
+    const episodicMemories = getMemoriesByType('episodic', 100);
+    // Process decay to see what would happen
+    const { toDelete: deleteIds, toPromote: promoteIds } = processDecay([...shortTermMemories, ...episodicMemories], config);
+    // Map IDs back to memories
+    const allMemories = [...shortTermMemories, ...episodicMemories];
+    const toPromote = allMemories.filter(m => promoteIds.includes(m.id));
+    const toDelete = allMemories.filter(m => deleteIds.includes(m.id) && !promoteIds.includes(m.id));
+    // Get counts
+    const totalShortTerm = db.prepare("SELECT COUNT(*) as count FROM memories WHERE type = 'short_term'").get().count;
+    const totalLongTerm = db.prepare("SELECT COUNT(*) as count FROM memories WHERE type = 'long_term'").get().count;
+    return { toPromote, toDelete, totalShortTerm, totalLongTerm };
+}
+/**
+ * Check if consolidation should be triggered based on memory state
+ * Returns true if consolidation is recommended
+ */
+export function shouldTriggerConsolidation(config = DEFAULT_CONFIG) {
+    const stats = getMemoryStats();
+    const stmFullness = stats.shortTerm / config.maxShortTermMemories;
+    // Trigger early when approaching capacity
+    if (stmFullness > 0.8) {
+        return {
+            shouldRun: true,
+            reason: `Short-term memory at ${Math.round(stmFullness * 100)}% capacity`,
+        };
+    }
+    // Check if many memories are below threshold
+    const db = getDatabase();
+    const lowScoreCount = db.prepare(`
+    SELECT COUNT(*) as count FROM memories
+    WHERE type = 'short_term' AND decayed_score < ?
+  `).get(config.salienceThreshold).count;
+    if (lowScoreCount > 10) {
+        return {
+            shouldRun: true,
+            reason: `${lowScoreCount} memories below salience threshold`,
+        };
+    }
+    return { shouldRun: false, reason: 'No consolidation needed' };
+}
+/**
+ * Full cleanup: consolidate + vacuum
+ * Best run periodically to keep database healthy
+ */
+export function fullCleanup(config = DEFAULT_CONFIG) {
+    // Run consolidation
+    const consolidation = consolidate(config);
+    // Merge similar memories
+    const merged = mergeSimilarMemories();
+    // Vacuum if we deleted anything
+    let vacuumed = false;
+    if (consolidation.deleted > 0 || merged > 0) {
+        const vacResult = vacuumDatabase();
+        vacuumed = vacResult.success;
+    }
+    return { consolidation, vacuumed, merged };
+}
+//# sourceMappingURL=consolidate.js.map