@mem-weave/server 0.2.0

package/dist/rest/routes/stats.js

@@ -0,0 +1,15 @@
+import { openDatabase } from '../../db/database.js';
+import { StatsRepo } from '../../db/repositories/stats-repo.js';
+const TENANT_DEFAULT = 'tenant_default';
+export function registerStatsRoute(app, dbPath) {
+    app.get('/api/v1/stats', async (_request, reply) => {
+        const db = openDatabase(dbPath);
+        try {
+            const stats = new StatsRepo(db).getStats(TENANT_DEFAULT);
+            return reply.code(200).send(stats);
+        }
+        finally {
+            db.close();
+        }
+    });
+}

package/dist/retrieval/bm25-search.js

@@ -0,0 +1,91 @@
+import { logger } from '../server/logger.js';
+export function bm25Search(db, tenantId, query, limit, scopes) {
+    try {
+        if (!query.trim() || limit <= 0)
+            return [];
+        // FTS5 escaping: strip special chars, split into tokens, wrap each in double-quotes for literal matching
+        const tokens = query.replace(/[^\w\s\u4e00-\u9fff]/g, ' ')
+            .split(/\s+/)
+            .filter(w => w.length > 0)
+            .map(w => `"${w}"`);
+        if (tokens.length === 0)
+            return [];
+        const safe = tokens.join(' ');
+        // Build query dynamically — scope filter uses EXISTS to avoid row duplication
+        let sql = `
+      SELECT m.*, bm25(memory_fts) AS bm25_score
+      FROM memory_fts
+      JOIN memories m ON m.rowid = memory_fts.rowid
+      WHERE memory_fts MATCH ?
+        AND m.tenant_id = ?
+        AND m.deleted_at IS NULL
+    `;
+        const params = [safe, tenantId];
+        if (scopes && scopes.length > 0) {
+            for (const scope of scopes) {
+                sql += ` AND EXISTS (SELECT 1 FROM memory_scopes ms WHERE ms.memory_id = m.id AND ms.key = ? AND ms.value = ?)`;
+                params.push(scope.key, scope.value);
+            }
+        }
+        sql += ` ORDER BY bm25_score DESC LIMIT ?`;
+        params.push(limit);
+        const rows = db.prepare(sql).all(...params);
+        // Batch query scopes for all returned memory IDs (populate mapRow correctly)
+        const memoryIds = rows.map(r => r.id);
+        const scopeMap = new Map();
+        if (memoryIds.length > 0) {
+            const placeholders = memoryIds.map(() => '?').join(',');
+            const scopeRows = db.prepare(`
+        SELECT memory_id, key, value FROM memory_scopes
+        WHERE tenant_id = ? AND memory_id IN (${placeholders})
+        ORDER BY key, value
+      `).all(tenantId, ...memoryIds);
+            for (const sr of scopeRows) {
+                if (!scopeMap.has(sr.memory_id))
+                    scopeMap.set(sr.memory_id, []);
+                scopeMap.get(sr.memory_id).push({ key: sr.key, value: sr.value });
+            }
+        }
+        return rows.map(row => ({
+            memory: mapRow(row, scopeMap.get(row.id) ?? []),
+            bm25Score: row.bm25_score
+        }));
+    }
+    catch (err) {
+        logger.error({ err }, 'bm25 search failed');
+        return [];
+    }
+}
+function mapRow(row, scopes) {
+    return {
+        id: row.id,
+        tenantId: row.tenant_id,
+        tier: row.tier,
+        type: row.type,
+        title: row.title,
+        content: row.content,
+        summary: row.summary,
+        concepts: JSON.parse(row.concepts_json),
+        files: JSON.parse(row.files_json),
+        importance: row.importance,
+        confidence: row.confidence,
+        strength: row.strength,
+        source: row.source,
+        scopeLevel: row.scope_level,
+        scopes,
+        sourceClient: row.source_client,
+        sourceDeviceId: row.source_device_id,
+        sourceSessionId: row.source_session_id,
+        tau: row.tau,
+        accessCount: row.access_count,
+        lastAccessedAt: row.last_accessed_at,
+        lastReinforcedAt: row.last_reinforced_at,
+        lastDecayAt: row.last_decay_at,
+        reinforcementScore: row.reinforcement_score,
+        promotedAt: row.promoted_at,
+        createdAt: row.created_at,
+        updatedAt: row.updated_at,
+        deletedAt: row.deleted_at,
+        evictionReason: row.eviction_reason
+    };
+}

package/dist/retrieval/causal-chain.js

@@ -0,0 +1,197 @@
+const CAUSAL_EDGE_TYPES = ['causes', 'before', 'after', 'refines', 'supersedes'];
+const STRONG_CAUSAL = ['causes', 'refines'];
+/**
+ * Causal-chain detection (design spec §4.6).
+ *
+ * Starting from a set of seed memories, walk along causal edges in both
+ * directions to extract linear chains. Each chain is scored by:
+ *
+ *   chainScore = average(memory.strength)
+ *              * average(edge.strength)
+ *              * completeness
+ *
+ * where `completeness` is the fraction of edges in the chain that are
+ * strong causal relations ('causes' or 'refines') — chains dominated by
+ * 'before'/'after' temporal links score lower.
+ *
+ * The implementation is bounded: each chain explores at most `maxLength` edges
+ * and we return at most `maxChains` chains total (ranked by chainScore).
+ */
+export function detectCausalChains(db, options) {
+    const maxLength = Math.max(1, Math.min(10, options.maxLength ?? 5));
+    const maxChains = Math.max(1, options.maxChains ?? 10);
+    const edgeTypes = options.edgeTypes ?? CAUSAL_EDGE_TYPES;
+    const bidirectional = options.bidirectional ?? true;
+    const allChains = [];
+    for (const seedId of options.seedMemoryIds) {
+        if (allChains.length >= maxChains)
+            break;
+        // Forward chain: from seed outward via outgoing edges
+        const forward = walkChain(db, options.tenantId, seedId, 'out', edgeTypes, maxLength);
+        for (const c of forward) {
+            allChains.push(c);
+            if (allChains.length >= maxChains)
+                break;
+        }
+        // Backward chain: from seed via incoming edges
+        if (bidirectional) {
+            const backward = walkChain(db, options.tenantId, seedId, 'in', edgeTypes, maxLength);
+            for (const c of backward) {
+                allChains.push(c);
+                if (allChains.length >= maxChains)
+                    break;
+            }
+        }
+    }
+    // Rank by chain score, descending
+    allChains.sort((a, b) => b.chainScore - a.chainScore);
+    return allChains.slice(0, maxChains);
+}
+function walkChain(db, tenantId, seedId, direction, edgeTypes, maxLength) {
+    // Greedy chain extension: at each step, pick the highest-strength edge
+    // to extend the chain. Returns one chain per "branch" up to maxLength.
+    const chains = [[]];
+    // The seed starts every chain
+    for (const c of chains)
+        c.push({ memoryId: seedId, edgeId: null });
+    for (let step = 1; step <= maxLength; step++) {
+        const newChains = [];
+        for (const chain of chains) {
+            const last = chain[chain.length - 1];
+            const nextEdges = pullNextCausalEdges(db, tenantId, last.memoryId, direction, edgeTypes);
+            if (nextEdges.length === 0) {
+                // Dead end — keep this chain as-is
+                newChains.push([...chain]);
+                continue;
+            }
+            for (const e of nextEdges) {
+                if (chain.some((s) => s.memoryId === e.toMemoryId))
+                    continue; // avoid cycles
+                newChains.push([...chain, { memoryId: e.toMemoryId, edgeId: e.id }]);
+            }
+        }
+        chains.length = 0;
+        chains.push(...newChains);
+    }
+    // Hydrate and score each chain
+    const allIds = new Set();
+    for (const c of chains)
+        for (const s of c)
+            allIds.add(s.memoryId);
+    if (allIds.size === 0)
+        return [];
+    const placeholders = [...allIds].map(() => '?').join(',');
+    const rows = db.prepare(`
+    SELECT * FROM memories
+    WHERE tenant_id = ? AND id IN (${placeholders}) AND deleted_at IS NULL
+  `).all(tenantId, ...allIds);
+    const byId = new Map();
+    for (const row of rows)
+        byId.set(row.id, rowToMemory(row));
+    const edgeIdSet = new Set();
+    for (const c of chains)
+        for (const s of c)
+            if (s.edgeId)
+                edgeIdSet.add(s.edgeId);
+    const edgeStrengthById = new Map();
+    if (edgeIdSet.size > 0) {
+        const edgePlaceholders = [...edgeIdSet].map(() => '?').join(',');
+        const edgeRows = db.prepare(`
+      SELECT id, strength, type FROM edges
+      WHERE id IN (${edgePlaceholders})
+    `).all(...edgeIdSet);
+        for (const r of edgeRows)
+            edgeStrengthById.set(r.id, { strength: r.strength, type: r.type });
+    }
+    const candidates = [];
+    for (const chain of chains) {
+        if (chain.length < 2)
+            continue; // need at least one edge
+        const memories = [];
+        for (const s of chain) {
+            const m = byId.get(s.memoryId);
+            if (m)
+                memories.push(m);
+        }
+        if (memories.length !== chain.length)
+            continue; // hydration failed for some node
+        let edgeStrengthSum = 0;
+        let edgeCount = 0;
+        let strongCausalCount = 0;
+        const edgeIds = [];
+        for (const s of chain) {
+            if (s.edgeId) {
+                const e = edgeStrengthById.get(s.edgeId);
+                if (e) {
+                    edgeStrengthSum += e.strength;
+                    edgeCount++;
+                    if (STRONG_CAUSAL.includes(e.type))
+                        strongCausalCount++;
+                    edgeIds.push(s.edgeId);
+                }
+            }
+        }
+        const avgEdgeStrength = edgeCount > 0 ? edgeStrengthSum / edgeCount : 1;
+        const avgMemStrength = memories.reduce((s, m) => s + m.strength, 0) / memories.length;
+        const completeness = edgeCount > 0 ? strongCausalCount / edgeCount : 0;
+        const chainScore = avgMemStrength * avgEdgeStrength * completeness;
+        candidates.push({
+            memoryIds: chain.map((s) => s.memoryId),
+            edgeIds,
+            memories,
+            chainScore,
+            completeness
+        });
+    }
+    return candidates;
+}
+function pullNextCausalEdges(db, tenantId, fromMemoryId, direction, edgeTypes) {
+    const placeholders = edgeTypes.map(() => '?').join(',');
+    const sql = direction === 'out'
+        ? `SELECT id, to_memory_id, strength, type FROM edges
+       WHERE tenant_id = ? AND from_memory_id = ? AND type IN (${placeholders})
+       ORDER BY strength DESC LIMIT 5`
+        : `SELECT id, from_memory_id AS to_memory_id, strength, type FROM edges
+       WHERE tenant_id = ? AND to_memory_id = ? AND type IN (${placeholders})
+       ORDER BY strength DESC LIMIT 5`;
+    const rows = db.prepare(sql).all(tenantId, fromMemoryId, ...edgeTypes);
+    return rows.map((r) => ({
+        id: r.id,
+        toMemoryId: r.to_memory_id,
+        strength: r.strength,
+        type: r.type
+    }));
+}
+function rowToMemory(row) {
+    return {
+        id: row.id,
+        tenantId: row.tenant_id,
+        tier: row.tier,
+        type: row.type,
+        title: row.title,
+        content: row.content,
+        summary: row.summary,
+        concepts: JSON.parse(row.concepts_json),
+        files: JSON.parse(row.files_json),
+        importance: row.importance,
+        confidence: row.confidence,
+        strength: row.strength,
+        source: row.source,
+        scopeLevel: row.scope_level,
+        scopes: [],
+        sourceClient: row.source_client,
+        sourceDeviceId: row.source_device_id,
+        sourceSessionId: row.source_session_id,
+        tau: row.tau,
+        accessCount: row.access_count,
+        lastAccessedAt: row.last_accessed_at,
+        lastReinforcedAt: row.last_reinforced_at,
+        lastDecayAt: row.last_decay_at,
+        reinforcementScore: row.reinforcement_score,
+        promotedAt: row.promoted_at,
+        createdAt: row.created_at,
+        updatedAt: row.updated_at,
+        deletedAt: row.deleted_at,
+        evictionReason: row.eviction_reason
+    };
+}

package/dist/retrieval/fusion.js

@@ -0,0 +1,48 @@
+const TIER_WEIGHTS = {
+    long: 1.15,
+    medium: 1.0,
+    short: 0.85
+};
+const DEFAULT_RRF_K = 60;
+export function fuseResults(streams, rrfK = DEFAULT_RRF_K) {
+    const byMemoryId = new Map();
+    for (const stream of streams) {
+        for (const ranked of stream) {
+            if (ranked.rank < 0)
+                continue;
+            const id = ranked.candidate.memory.id;
+            const rrfContribution = 1 / (rrfK + ranked.rank);
+            const existing = byMemoryId.get(id);
+            if (existing) {
+                existing.rrfScore += rrfContribution;
+                existing.candidate.sources.add(ranked.source);
+            }
+            else {
+                byMemoryId.set(id, {
+                    ...ranked,
+                    rrfScore: rrfContribution,
+                    candidate: {
+                        ...ranked.candidate,
+                        sources: new Set(ranked.candidate.sources)
+                    }
+                });
+            }
+        }
+    }
+    const results = [];
+    for (const entry of byMemoryId.values()) {
+        const tierWeight = TIER_WEIGHTS[entry.candidate.memory.tier] ?? 1.0;
+        const safeStrength = Number.isFinite(entry.candidate.memory.strength) ? Math.max(0, Math.min(1, entry.candidate.memory.strength)) : 0;
+        const strengthWeight = 0.5 + safeStrength;
+        const finalScore = entry.rrfScore * tierWeight * strengthWeight;
+        results.push({
+            candidate: entry.candidate,
+            finalScore,
+            rrfScore: entry.rrfScore,
+            tierWeight,
+            strengthWeight
+        });
+    }
+    results.sort((a, b) => b.finalScore - a.finalScore);
+    return results;
+}

package/dist/retrieval/graph-traversal.js

@@ -0,0 +1,144 @@
+const DEFAULT_EDGE_TYPES = [
+    'causes', 'enables', 'supersedes', 'references', 'refines', 'contradicts'
+];
+/**
+ * Graph expansion: starting from `startMemoryId`, BFS outward through edges
+ * of the specified types and return the discovered memory nodes ranked by
+ * their `distance` from the start. Implements design spec §4.4.
+ *
+ * Notes:
+ * - The starting memory itself is NOT returned (only its neighbors).
+ * - `related_to` and `duplicates` are NOT followed by default (too noisy).
+ * - `before`/`after` are deferred to the causal-chain layer.
+ */
+export function graphExpand(db, options) {
+    const depth = Math.max(1, Math.min(3, options.depth ?? 1));
+    const maxNodes = options.maxNodes ?? 30;
+    const edgeTypes = options.edgeTypes ?? DEFAULT_EDGE_TYPES;
+    const direction = options.direction ?? 'both';
+    const visited = new Set([options.startMemoryId]);
+    const allDiscovered = [];
+    let frontier = [{
+            memoryId: options.startMemoryId,
+            distance: 0,
+            edgePath: [],
+            memoryPath: [options.startMemoryId],
+            pathStrength: 1
+        }];
+    for (let d = 1; d <= depth; d++) {
+        const nextFrontier = [];
+        for (const node of frontier) {
+            // Pull outgoing edges
+            if (direction === 'out' || direction === 'both') {
+                const outRows = db.prepare(`
+          SELECT id, to_memory_id, strength
+          FROM edges
+          WHERE tenant_id = ? AND from_memory_id = ? AND type IN (${edgeTypes.map(() => '?').join(',')})
+        `).all(options.tenantId, node.memoryId, ...edgeTypes);
+                for (const r of outRows) {
+                    if (visited.has(r.to_memory_id))
+                        continue;
+                    visited.add(r.to_memory_id);
+                    nextFrontier.push({
+                        memoryId: r.to_memory_id,
+                        distance: d,
+                        edgePath: [...node.edgePath, r.id],
+                        memoryPath: [...node.memoryPath, r.to_memory_id],
+                        pathStrength: Math.min(node.pathStrength, r.strength)
+                    });
+                }
+            }
+            // Pull incoming edges
+            if (direction === 'in' || direction === 'both') {
+                const inRows = db.prepare(`
+          SELECT id, from_memory_id, strength
+          FROM edges
+          WHERE tenant_id = ? AND to_memory_id = ? AND type IN (${edgeTypes.map(() => '?').join(',')})
+        `).all(options.tenantId, node.memoryId, ...edgeTypes);
+                for (const r of inRows) {
+                    if (visited.has(r.from_memory_id))
+                        continue;
+                    visited.add(r.from_memory_id);
+                    nextFrontier.push({
+                        memoryId: r.from_memory_id,
+                        distance: d,
+                        edgePath: [...node.edgePath, r.id],
+                        memoryPath: [...node.memoryPath, r.from_memory_id],
+                        pathStrength: Math.min(node.pathStrength, r.strength)
+                    });
+                }
+            }
+        }
+        frontier = nextFrontier;
+        // Accumulate every discovered node, not just the final frontier.
+        for (const node of nextFrontier)
+            allDiscovered.push(node);
+        if (allDiscovered.length >= maxNodes)
+            break;
+    }
+    // Collect all discovered nodes
+    const visitedIds = [];
+    for (const node of allDiscovered)
+        visitedIds.push(node.memoryId);
+    if (visitedIds.length > maxNodes)
+        visitedIds.length = maxNodes;
+    // Hydrate memory records
+    if (visitedIds.length === 0)
+        return [];
+    const placeholders = visitedIds.map(() => '?').join(',');
+    const rows = db.prepare(`
+    SELECT * FROM memories
+    WHERE tenant_id = ? AND id IN (${placeholders}) AND deleted_at IS NULL
+  `).all(options.tenantId, ...visitedIds);
+    const byId = new Map();
+    for (const row of rows)
+        byId.set(row.id, rowToMemory(row));
+    return allDiscovered
+        .slice(0, maxNodes)
+        .map((node) => {
+        const memory = byId.get(node.memoryId);
+        return memory
+            ? {
+                memory,
+                distance: node.distance,
+                edgePath: node.edgePath,
+                memoryPath: node.memoryPath,
+                pathStrength: node.pathStrength
+            }
+            : null;
+    })
+        .filter((c) => c !== null);
+}
+function rowToMemory(row) {
+    return {
+        id: row.id,
+        tenantId: row.tenant_id,
+        tier: row.tier,
+        type: row.type,
+        title: row.title,
+        content: row.content,
+        summary: row.summary,
+        concepts: JSON.parse(row.concepts_json),
+        files: JSON.parse(row.files_json),
+        importance: row.importance,
+        confidence: row.confidence,
+        strength: row.strength,
+        source: row.source,
+        scopeLevel: row.scope_level,
+        scopes: [],
+        sourceClient: row.source_client,
+        sourceDeviceId: row.source_device_id,
+        sourceSessionId: row.source_session_id,
+        tau: row.tau,
+        accessCount: row.access_count,
+        lastAccessedAt: row.last_accessed_at,
+        lastReinforcedAt: row.last_reinforced_at,
+        lastDecayAt: row.last_decay_at,
+        reinforcementScore: row.reinforcement_score,
+        promotedAt: row.promoted_at,
+        createdAt: row.created_at,
+        updatedAt: row.updated_at,
+        deletedAt: row.deleted_at,
+        evictionReason: row.eviction_reason
+    };
+}

package/dist/retrieval/search-engine.js

@@ -0,0 +1,150 @@
+import { bm25Search } from './bm25-search.js';
+import { vectorSearch } from './vector-search.js';
+import { graphExpand } from './graph-traversal.js';
+import { detectCausalChains } from './causal-chain.js';
+import { fuseResults } from './fusion.js';
+/**
+ * Multi-layer search (design spec §4.13):
+ *
+ *   1. BM25 keyword recall (FTS5)
+ *   2. Vector recall (sqlite-vec; skipped when `queryEmbedding` is not provided)
+ *   3. Graph expansion (BFS from BM25/vector seeds, depth 1)
+ *   4. Causal chain detection (from BM25/vector seeds, length ≤ 3)
+ *   5. RRF fusion of all 4 streams
+ *   6. Tier / strength / scope / freshness weighting
+ *   7. Return top-K
+ *
+ * When `bm25Only` is true, layers 2-4 are skipped.
+ */
+export async function searchMemories(db, tenantId, options) {
+    const limit = options.limit ?? 8;
+    const query = options.query.trim();
+    const bm25Only = options.bm25Only ?? false;
+    const rrfK = options.rrfK ?? 60;
+    const bm25Limit = options.bm25Limit ?? 50;
+    const vectorLimit = options.vectorLimit ?? 50;
+    const graphLimit = options.graphLimit ?? 30;
+    const causalLimit = options.causalLimit ?? 30;
+    const vectorMinSimilarity = options.vectorMinSimilarity ?? 0;
+    const vectorDimensions = options.vectorDimensions ?? 768;
+    const layerStats = { bm25: 0, vector: 0, graph: 0, causal: 0 };
+    if (!query && !options.queryEmbedding) {
+        return { query, results: [], totalCandidates: 0, layerStats };
+    }
+    // --- Layer 1: BM25 ---
+    let bm25Rows = query ? bm25Search(db, tenantId, query, bm25Limit) : [];
+    layerStats.bm25 = bm25Rows.length;
+    if (options.scope || options.types) {
+        bm25Rows = bm25Rows.filter((row) => {
+            if (options.scope && !matchesScope(row.memory, options.scope))
+                return false;
+            if (options.types && !options.types.includes(row.memory.type))
+                return false;
+            return true;
+        });
+    }
+    // --- Layer 2: Vector (optional) ---
+    let vectorRows = [];
+    if (!bm25Only && options.queryEmbedding && options.queryEmbedding.length === vectorDimensions) {
+        vectorRows = vectorSearch(db, tenantId, options.queryEmbedding, vectorLimit, vectorDimensions)
+            .filter((r) => r.similarity >= vectorMinSimilarity);
+        layerStats.vector = vectorRows.length;
+        if (options.scope || options.types) {
+            vectorRows = vectorRows.filter((row) => {
+                if (options.scope && !matchesScope(row.memory, options.scope))
+                    return false;
+                if (options.types && !options.types.includes(row.memory.type))
+                    return false;
+                return true;
+            });
+        }
+    }
+    // Build streams
+    const streams = [];
+    if (bm25Rows.length > 0) {
+        streams.push(bm25Rows.map((r, idx) => ({
+            candidate: { memory: r.memory, sources: new Set(['bm25']) },
+            rank: idx,
+            source: 'bm25'
+        })));
+    }
+    if (vectorRows.length > 0) {
+        streams.push(vectorRows.map((r, idx) => ({
+            candidate: { memory: r.memory, sources: new Set(['vector']) },
+            rank: idx,
+            source: 'vector'
+        })));
+    }
+    // --- Layer 3: Graph expansion ---
+    if (!bm25Only) {
+        const seeds = [...bm25Rows, ...vectorRows].slice(0, 5).map((r) => r.memory.id);
+        const allGraph = [];
+        for (const seed of seeds) {
+            const out = graphExpand(db, { startMemoryId: seed, tenantId, depth: 1, maxNodes: graphLimit });
+            for (const c of out) {
+                if (options.scope && !matchesScope(c.memory, options.scope))
+                    continue;
+                if (options.types && !options.types.includes(c.memory.type))
+                    continue;
+                allGraph.push(c);
+            }
+        }
+        layerStats.graph = allGraph.length;
+        if (allGraph.length > 0) {
+            streams.push(allGraph.map((c, idx) => ({
+                candidate: { memory: c.memory, sources: new Set(['graph']) },
+                rank: idx,
+                source: 'graph'
+            })));
+        }
+    }
+    // --- Layer 4: Causal chains ---
+    if (!bm25Only) {
+        const seeds = [...bm25Rows, ...vectorRows].slice(0, 5).map((r) => r.memory.id);
+        const allCausal = [];
+        for (const seed of seeds) {
+            const out = detectCausalChains(db, { seedMemoryIds: [seed], tenantId, maxLength: 3, maxChains: causalLimit });
+            for (const chain of out) {
+                for (const m of chain.memories) {
+                    if (m.id === seed)
+                        continue;
+                    if (options.scope && !matchesScope(m, options.scope))
+                        continue;
+                    if (options.types && !options.types.includes(m.type))
+                        continue;
+                    allCausal.push(chain);
+                    break;
+                }
+            }
+        }
+        layerStats.causal = allCausal.length;
+        if (allCausal.length > 0) {
+            streams.push(allCausal.map((c, idx) => {
+                const m = c.memories[0];
+                return {
+                    candidate: { memory: m, sources: new Set(['causal']) },
+                    rank: idx,
+                    source: 'causal'
+                };
+            }));
+        }
+    }
+    // --- RRF fusion ---
+    const fused = fuseResults(streams, rrfK);
+    return {
+        query,
+        results: fused.slice(0, limit),
+        totalCandidates: streams.reduce((s, x) => s + x.length, 0),
+        layerStats
+    };
+}
+function matchesScope(memory, scope) {
+    for (const [key, value] of Object.entries(scope)) {
+        if (!value)
+            continue;
+        const found = memory.scopes.some((s) => s.key === key && s.value === value);
+        if (!found)
+            return false;
+    }
+    return true;
+}