shieldcortex 4.12.13 → 4.13.0

package/dist/memory/prune.js

@@ -0,0 +1,76 @@
+import { getDatabase } from '../database/init.js';
+import { deleteMemory } from './store.js';
+import { backupMemoriesDb } from './backup.js';
+const DEFAULTS = {
+    salienceLte: 0.2,
+    ageDaysGte: 30,
+    excludePinned: true,
+    dryRun: true,
+};
+const SAMPLE_LIMIT = 10;
+function buildWhereClause(options) {
+    const where = [
+        'salience <= ?',
+        "(julianday('now') - julianday(created_at)) >= ?",
+        "COALESCE(status, 'active') NOT IN ('archived', 'suppressed')",
+    ];
+    const params = [options.salienceLte, options.ageDaysGte];
+    if (options.project !== null) {
+        where.push('project = ?');
+        params.push(options.project);
+    }
+    if (options.excludePinned) {
+        where.push('COALESCE(pinned, 0) = 0');
+    }
+    return { where: where.join(' AND '), params };
+}
+/**
+ * Find + optionally delete memories below a salience threshold older than N
+ * days. Always backs up the live DB before any delete; the backup path is
+ * returned in the result so the caller can surface it to the user.
+ */
+export async function pruneMemories(rawOptions = {}) {
+    const options = {
+        salienceLte: rawOptions.salienceLte ?? DEFAULTS.salienceLte,
+        ageDaysGte: rawOptions.ageDaysGte ?? DEFAULTS.ageDaysGte,
+        project: rawOptions.project ?? null,
+        excludePinned: rawOptions.excludePinned ?? DEFAULTS.excludePinned,
+        dryRun: rawOptions.dryRun ?? DEFAULTS.dryRun,
+    };
+    if (options.salienceLte < 0 || options.salienceLte > 1) {
+        throw new Error('salienceLte must be between 0 and 1');
+    }
+    if (options.ageDaysGte < 0) {
+        throw new Error('ageDaysGte must be >= 0');
+    }
+    const { where, params } = buildWhereClause(options);
+    const db = getDatabase();
+    const countRow = db.prepare(`SELECT COUNT(*) AS n FROM memories WHERE ${where}`).get(...params);
+    const matched = countRow.n;
+    const sampleRows = db
+        .prepare(`SELECT id, title, project, salience,
+              CAST(julianday('now') - julianday(created_at) AS INTEGER) AS age_days
+       FROM memories WHERE ${where}
+       ORDER BY salience ASC, created_at ASC
+       LIMIT ?`)
+        .all(...params, SAMPLE_LIMIT);
+    const sample = sampleRows.map((r) => ({
+        id: r.id,
+        title: r.title,
+        project: r.project,
+        salience: r.salience,
+        ageDays: r.age_days,
+    }));
+    const result = { options, matched, sample };
+    if (options.dryRun || matched === 0)
+        return result;
+    result.backupPath = await backupMemoriesDb('pre-prune');
+    const idRows = db.prepare(`SELECT id FROM memories WHERE ${where}`).all(...params);
+    let deleted = 0;
+    for (const row of idRows) {
+        if (deleteMemory(row.id, { type: 'cli', identifier: 'maintenance:prune' }))
+            deleted++;
+    }
+    result.deleted = deleted;
+    return result;
+}

package/dist/memory/search-recall.d.ts

@@ -0,0 +1,48 @@
+/**
+ * Memory search and recall.
+ *
+ * Phase 3 of the audit-recommended store.ts split. The "search/recall"
+ * group is the hybrid FTS5 + vector pipeline (`searchMemoriesInternal`)
+ * and its three public entry points (`searchMemories`,
+ * `searchMemoriesExplained`, `recallWithEmbeddings`). Lifted out of
+ * store.ts (1,564 lines after phase 2) so the search pipeline can be
+ * read on its own without scrolling past every CRUD helper. No
+ * behaviour change vs the original implementation — exports re-emerge
+ * from store.ts via a barrel re-export so existing import paths keep
+ * working.
+ *
+ * Imports from store.ts (`rowToMemory`, `logAccessDenial`) form a
+ * module cycle, but both are only invoked inside function bodies —
+ * never at module load. ESM live bindings handle this correctly at
+ * runtime. `logAccessDenial` is exported from store.ts purely as a
+ * cycle artifact; it is not intended as public API (same precedent
+ * as `MAX_CONTENT_SIZE` in phase 2).
+ *
+ * Imports from lifecycle.ts (`reinforceFromSearch`, `enrichMemory`)
+ * are not cyclic — phase 2 added them to store.ts specifically for
+ * the search pipeline; in phase 3 they move with the consumer.
+ */
+import { Memory, MemoryConfig, SearchOptions, SearchResult } from './types.js';
+import type { DefenceSource } from '../defence/types.js';
+/**
+ * Search memories using full-text search, vector similarity, and filters
+ * Now uses hybrid search combining FTS5 keywords with semantic vector matching
+ */
+export declare function searchMemories(options: SearchOptions, config?: MemoryConfig, source?: DefenceSource): Promise<SearchResult[]>;
+export declare function searchMemoriesExplained(options: SearchOptions, config?: MemoryConfig, source?: DefenceSource): Promise<SearchResult[]>;
+/**
+ * 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 declare function recallWithEmbeddings(query: string, options?: {
+    limit?: number;
+    project?: string;
+    threshold?: number;
+    existingResults?: SearchResult[];
+    queryEmbedding?: Float32Array | null;
+}): Promise<Memory[]>;

package/dist/memory/search-recall.js

@@ -0,0 +1,367 @@
+/**
+ * Memory search and recall.
+ *
+ * Phase 3 of the audit-recommended store.ts split. The "search/recall"
+ * group is the hybrid FTS5 + vector pipeline (`searchMemoriesInternal`)
+ * and its three public entry points (`searchMemories`,
+ * `searchMemoriesExplained`, `recallWithEmbeddings`). Lifted out of
+ * store.ts (1,564 lines after phase 2) so the search pipeline can be
+ * read on its own without scrolling past every CRUD helper. No
+ * behaviour change vs the original implementation — exports re-emerge
+ * from store.ts via a barrel re-export so existing import paths keep
+ * working.
+ *
+ * Imports from store.ts (`rowToMemory`, `logAccessDenial`) form a
+ * module cycle, but both are only invoked inside function bodies —
+ * never at module load. ESM live bindings handle this correctly at
+ * runtime. `logAccessDenial` is exported from store.ts purely as a
+ * cycle artifact; it is not intended as public API (same precedent
+ * as `MAX_CONTENT_SIZE` in phase 2).
+ *
+ * Imports from lifecycle.ts (`reinforceFromSearch`, `enrichMemory`)
+ * are not cyclic — phase 2 added them to store.ts specifically for
+ * the search pipeline; in phase 3 they move with the consumer.
+ */
+import { getDatabase } from '../database/init.js';
+import { DEFAULT_CONFIG, } from './types.js';
+import { calculateDecayedScore, calculatePriority, } from './decay.js';
+import { getActivationBoost, pruneActivationCache, } from './activation.js';
+import { getCachedQueryEmbedding, findSimilarMemories } from './embedding.js';
+import { buildSearchExplanation, calculateLinkBoost, calculateTagScore, detectQueryCategory, extractQueryTags, vectorSearch, } from './search.js';
+import { escapeFts5Query } from './fts.js';
+import { checkAccess } from '../defence/trust/access-control.js';
+import { reinforceFromSearch, enrichMemory } from './lifecycle.js';
+// Cyclic import — see header. rowToMemory and logAccessDenial live in store.ts;
+// both are only invoked inside function bodies below, never at module load.
+import { rowToMemory, logAccessDenial } from './store.js';
+let searchCount = 0;
+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
+ */
+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);
+    }
+}

package/dist/memory/store.d.ts

@@ -4,8 +4,9 @@
  * Core CRUD operations for the memory database.
  * Handles storage, retrieval, and management of memories.
  */
-import { Memory, MemoryInput, MemoryType, SearchOptions, SearchResult, MemoryConfig } from './types.js';
+import { Memory, MemoryInput, MemoryType, MemoryConfig } from './types.js';
 import type { DefenceSource } from '../defence/types.js';
+export declare const MAX_CONTENT_SIZE: number;
 /**
  * Get truncation info from the last addMemory call
  */
@@ -18,6 +19,7 @@ export declare function getLastTruncationInfo(): {
  * Convert database row to Memory object
  */
 export declare function rowToMemory(row: Record<string, unknown>): Memory;
+export declare function logAccessDenial(memoryId: number, source: DefenceSource, reason: string): void;
 /**
  * Error thrown when memory creation is paused
  */
@@ -49,76 +51,6 @@ export declare function mergeMemories(keptId: number, removedId: number, options
  * Delete a memory
  */
 export declare function deleteMemory(id: number, source?: DefenceSource): boolean;
-/**
- * Access a memory (updates access count and timestamp, returns reinforced memory)
- */
-export declare function accessMemory(id: number, config?: MemoryConfig, source?: DefenceSource): Memory | null;
-/**
- * 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 declare function reinforceFromSearch(memoryId: number): void;
-/**
- * Enrichment result indicating what happened
- */
-export interface EnrichmentResult {
-    enriched: boolean;
-    reason: string;
-}
-/**
- * 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 declare function enrichMemory(memoryId: number, newContext: string, contextType?: 'search' | 'access' | 'related'): EnrichmentResult;
-/**
- * Clear enrichment cooldown for a memory (for testing)
- */
-export declare function clearEnrichmentCooldown(memoryId: number): void;
-/**
- * Get enrichment cooldown status for a memory
- */
-export declare function getEnrichmentCooldownStatus(memoryId: number): {
-    onCooldown: boolean;
-    remainingMs: number;
-};
-/**
- * Update persisted decay scores for all memories
- * Called during consolidation and periodically by the API server
- * Returns the number of memories updated
- */
-export declare function updateDecayScores(): number;
-export declare function searchMemories(options: SearchOptions, config?: MemoryConfig, source?: DefenceSource): Promise<SearchResult[]>;
-export declare function searchMemoriesExplained(options: SearchOptions, config?: MemoryConfig, source?: DefenceSource): Promise<SearchResult[]>;
-/**
- * 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 declare function recallWithEmbeddings(query: string, options?: {
-    limit?: number;
-    project?: string;
-    threshold?: number;
-    existingResults?: SearchResult[];
-    queryEmbedding?: Float32Array | null;
-}): Promise<Memory[]>;
 /**
  * Get all memories for a project
  */
@@ -135,14 +67,6 @@ export declare function getMemoriesByType(type: MemoryType, limit?: number): Mem
  * Get high-priority memories (for context injection)
  */
 export declare function getHighPriorityMemories(limit?: number, project?: string, source?: DefenceSource): Memory[];
-/**
- * Promote a memory from short-term to long-term
- */
-export declare function promoteMemory(id: number): Memory | null;
-/**
- * Bulk delete decayed memories
- */
-export declare function cleanupDecayedMemories(config?: MemoryConfig): number;
 /**
  * Get memory statistics
  */
@@ -154,45 +78,6 @@ export declare function getMemoryStats(project?: string): {
     byCategory: Record<string, number>;
     averageSalience: number;
 };
-export type RelationshipType = 'references' | 'extends' | 'contradicts' | 'related';
-export interface MemoryLink {
-    id: number;
-    sourceId: number;
-    targetId: number;
-    relationship: RelationshipType;
-    strength: number;
-    createdAt: Date;
-}
-/**
- * Create a link between two memories
- */
-export declare function createMemoryLink(sourceId: number, targetId: number, relationship: RelationshipType, strength?: number): MemoryLink | null;
-/**
- * Get all memories related to a given memory
- */
-export declare function getRelatedMemories(memoryId: number): {
-    memory: Memory;
-    relationship: RelationshipType;
-    strength: number;
-    direction: 'outgoing' | 'incoming';
-}[];
-/**
- * Delete a memory link
- */
-export declare function deleteMemoryLink(sourceId: number, targetId: number): boolean;
-/**
- * Get all memory links
- */
-export declare function getAllMemoryLinks(): MemoryLink[];
-/**
- * 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 declare function detectRelationships(memory: Memory, maxResults?: number): {
-    targetId: number;
-    relationship: RelationshipType;
-    strength: number;
-}[];
+export { createMemoryLink, getRelatedMemories, deleteMemoryLink, getAllMemoryLinks, detectRelationships, type RelationshipType, type MemoryLink, } from './links.js';
+export { accessMemory, reinforceFromSearch, enrichMemory, clearEnrichmentCooldown, getEnrichmentCooldownStatus, updateDecayScores, promoteMemory, cleanupDecayedMemories, type EnrichmentResult, } from './lifecycle.js';
+export { searchMemories, searchMemoriesExplained, recallWithEmbeddings, } from './search-recall.js';