shieldcortex 4.31.2 → 4.32.1

package/dist/memory/embedding.js

@@ -115,8 +115,24 @@ export function clearQueryEmbeddingCache() {
     queryEmbeddingCache.clear();
 }
 /**
- * Embed the query, compute similarity against all memory embeddings,
- * return top K (default 10) sorted by score desc.
+ * Embed the query, compute similarity against the candidate memories' PERSISTED
+ * embeddings, return top K (default 10) sorted by score desc.
+ *
+ * Candidate embeddings are read from the canonical `memories.embedding` column —
+ * the same vector addMemory persists on write and vectorSearch scores against —
+ * in ONE batched `WHERE id IN (...)` query, decoded with the shared
+ * `decodeEmbeddingBlob`. This is a reuse, not a recompute: previously every
+ * candidate was routed through `getOrComputeEmbedding`, which checked a SEPARATE,
+ * perpetually-cold `memory_embeddings` cache and re-embedded each candidate's text
+ * through the worker on the (near-universal) miss — up to 200 sequential worker
+ * round-trips per cold recall, all redundant.
+ *
+ * Candidates that genuinely lack a persisted embedding (rare — writes populate it;
+ * only possible when the model was unavailable at write time, or for legacy rows)
+ * are skipped, not re-embedded: re-embedding here would reintroduce exactly the
+ * per-candidate worker storm this change removed, and `addMemory` already
+ * (re)populates the column out of band. They simply don't contribute to the
+ * vector-similarity fallback this turn; FTS and the next write still cover them.
  *
  * Non-throwing: returns empty array on failure.
  */
@@ -125,17 +141,22 @@ export async function findSimilarMemories(query, memories, topK = 10, queryEmbed
         const activeQueryEmbedding = queryEmbedding ?? await getCachedQueryEmbedding(query);
         if (!activeQueryEmbedding)
             return [];
-        // We need embeddings for each memory — caller should provide pre-computed
-        // embeddings via the cache. For memories without cached embeddings, we
-        // compute on the fly (text = title + content).
-        const { getOrComputeEmbedding } = await import('./embedding-cache.js');
+        if (memories.length === 0)
+            return [];
+        const { getDatabase } = await import('../database/init.js');
+        const { decodeEmbeddingBlob } = await import('./search.js');
+        const db = getDatabase();
+        // ONE batched read of the persisted embeddings for the candidate set.
+        const ids = memories.map((m) => m.id);
+        const placeholders = ids.map(() => '?').join(',');
+        const rows = db.prepare(`SELECT id, embedding FROM memories WHERE id IN (${placeholders}) AND embedding IS NOT NULL`).all(...ids);
         const scored = [];
-        for (const mem of memories) {
-            const memEmbedding = await getOrComputeEmbedding(mem.id, `${mem.title}\n${mem.content}`);
-            if (!memEmbedding)
-                continue;
+        for (const row of rows) {
+            const memEmbedding = decodeEmbeddingBlob(row.embedding);
+            // Dimension guard: a vector from a different model version won't match the
+            // query's dimensionality. cosineSimilarity returns 0 on length mismatch.
             const score = cosineSimilarity(activeQueryEmbedding, memEmbedding);
-            scored.push({ id: mem.id, score });
+            scored.push({ id: row.id, score });
         }
         scored.sort((a, b) => b.score - a.score);
         return scored.slice(0, topK);

package/dist/memory/expiry.js

@@ -38,7 +38,7 @@ export function applyExpiryRules() {
     for (const rule of expiryRules) {
         const cutoffDate = new Date(Date.now() - rule.maxAgeDays * 24 * 60 * 60 * 1000).toISOString();
         // Build WHERE clause for this rule
-        let where = 'WHERE createdAt < ?';
+        let where = 'WHERE created_at < ?';
         const params = [cutoffDate];
         if (rule.category) {
             where += ' AND category = ?';

package/dist/memory/search-recall.js

@@ -55,9 +55,9 @@ async function searchMemoriesInternal(options, config, source, execution) {
             if (!queryEmbedding) {
                 throw new Error('query embedding unavailable');
             }
-            const vectorHits = vectorSearch(db, rowToMemory, queryEmbedding, limit * 2, options.project, includeGlobal);
+            const vectorHits = vectorSearch(db, queryEmbedding, limit * 2, options.project, includeGlobal);
             for (const hit of vectorHits) {
-                vectorResults.set(hit.memory.id, hit.similarity);
+                vectorResults.set(hit.id, hit.similarity);
             }
         }
         catch {
@@ -116,7 +116,13 @@ async function searchMemoriesInternal(options, config, source, execution) {
     )`;
         params.push(...options.tags);
     }
-    sql += ' ORDER BY m.salience DESC, m.last_accessed DESC LIMIT ?';
+    // Prefilter on the persisted decayed-score index (CLAUDE.md: "Persisted decay
+    // scores for efficient sorting", idx_memories_decayed_score). decayed_score is
+    // NULL until updateDecayScores() persists it (addMemory leaves it unset), so
+    // COALESCE back to raw salience for un-scored rows — identical to rowToMemory's
+    // `decayed_score ?? salience`. Without the COALESCE, NULL sorts last under DESC
+    // and would bury freshly-written high-salience memories out of the prefilter.
+    sql += ' ORDER BY COALESCE(m.decayed_score, m.salience) DESC, m.last_accessed DESC LIMIT ?';
     params.push(limit);
     const rows = db.prepare(sql).all(...params);
     const scoringContext = {
@@ -171,29 +177,15 @@ async function searchMemoriesInternal(options, config, source, execution) {
         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);
-                            }
-                        }
-                    }
-                }
-            }
-        }
+        // NOTE (Phase 17 B2): the automatic all-pairs "co-access" linking that used
+        // to run here was removed. It linked every pair of the top-K results as
+        // `related` (strength 0.2), creating C(K,2) ≈ K² spurious graph edges and
+        // running one `SELECT existing` + INSERT/UPDATE per pair on every recall.
+        // Co-appearing in a single search is not a genuine relationship — these
+        // edges polluted the knowledge graph and drove an N² per-pair query storm.
+        // Genuine links are still created elsewhere (addMemory similarity links,
+        // explicit contradiction/relationship links); recall now only reinforces
+        // individual results above.
         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));
@@ -210,6 +202,12 @@ async function searchMemoriesInternal(options, config, source, execution) {
         }
     }
     const finalResults = sortedResults.slice(0, limit);
+    // Per-result contradiction links, then their counterpart titles. The title
+    // lookup was an N+1-within-N+1 (one SELECT title per contradiction per
+    // result); collect every counterpart id first and resolve all titles with a
+    // single `WHERE id IN (...)`, then read from the id→title map below.
+    const contradictionsByResult = new Map();
+    const counterpartIds = new Set();
     for (const result of finalResults) {
         const contradictions = db.prepare(`
       SELECT ml.strength,
@@ -219,10 +217,27 @@ async function searchMemoriesInternal(options, config, source, execution) {
         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 };
-            });
+            contradictionsByResult.set(result.memory.id, contradictions);
+            for (const c of contradictions)
+                counterpartIds.add(c.other_id);
+        }
+    }
+    const counterpartTitles = new Map();
+    if (counterpartIds.size > 0) {
+        const ids = [...counterpartIds];
+        const placeholders = ids.map(() => '?').join(',');
+        const titleRows = db.prepare(`SELECT id, title FROM memories WHERE id IN (${placeholders})`).all(...ids);
+        for (const tr of titleRows)
+            counterpartTitles.set(tr.id, tr.title);
+    }
+    for (const result of finalResults) {
+        const contradictions = contradictionsByResult.get(result.memory.id);
+        if (contradictions && contradictions.length > 0) {
+            result.contradictions = contradictions.map((contradiction) => ({
+                memoryId: contradiction.other_id,
+                title: counterpartTitles.get(contradiction.other_id) || 'Unknown',
+                score: contradiction.strength,
+            }));
             if (result.explanation) {
                 result.explanation.reasons.push(`${contradictions.length} contradiction link${contradictions.length === 1 ? '' : 's'} attached`);
             }
@@ -230,8 +245,20 @@ async function searchMemoriesInternal(options, config, source, execution) {
     }
     if (source) {
         const db2 = getDatabase();
+        // ACL lookup was an N+1 (one `SELECT source, sensitivity_level WHERE id = ?`
+        // per result); fetch all result rows in one `WHERE id IN (...)` and read the
+        // per-result source/sensitivity from the map. checkAccess/logAccessDenial
+        // logic and filter order are unchanged.
+        const aclIds = finalResults.map((result) => result.memory.id);
+        const aclRows = new Map();
+        if (aclIds.length > 0) {
+            const placeholders = aclIds.map(() => '?').join(',');
+            const fetched = db2.prepare(`SELECT id, source, sensitivity_level FROM memories WHERE id IN (${placeholders})`).all(...aclIds);
+            for (const row of fetched)
+                aclRows.set(row.id, row);
+        }
         return finalResults.filter(result => {
-            const row = db2.prepare('SELECT source, sensitivity_level FROM memories WHERE id = ?').get(result.memory.id);
+            const row = aclRows.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);
@@ -334,10 +361,37 @@ function scoreWithRrf(input) {
     }
     // Vector and graph rank lists may contain ids the FTS WHERE would have
     // filtered out — fetch + filter to enforce the same constraints.
+    const sortedVectorIds = Array.from(vectorResults.entries())
+        .sort((a, b) => b[1] - a[1])
+        .map(([id]) => id);
+    const graphLimit = Math.max(limit * 3, 50);
+    const graphResults = query && query.trim()
+        ? graphRankFromQuery(query, db, { project: options.project, limit: graphLimit })
+        : [];
+    const candidateGraphIds = graphResults.map((r) => r.memoryId);
+    // Batch-hydrate every candidate not already covered by the FTS rows in ONE
+    // query (was an N+1: one `SELECT * WHERE id = ?` per vector/graph candidate).
+    // considerCandidate then reads from this prefetched map, keeping the exact
+    // per-id filter semantics, list order, and memoryMap side effect.
+    const candidateIdsToFetch = new Set();
+    for (const id of sortedVectorIds)
+        if (!memoryMap.has(id))
+            candidateIdsToFetch.add(id);
+    for (const id of candidateGraphIds)
+        if (!memoryMap.has(id))
+            candidateIdsToFetch.add(id);
+    const prefetchedRows = new Map();
+    if (candidateIdsToFetch.size > 0) {
+        const ids = [...candidateIdsToFetch];
+        const placeholders = ids.map(() => '?').join(',');
+        const fetched = db.prepare(`SELECT * FROM memories WHERE id IN (${placeholders})`).all(...ids);
+        for (const row of fetched)
+            prefetchedRows.set(row.id, row);
+    }
     const considerCandidate = (id) => {
         if (memoryMap.has(id))
             return true;
-        const row = db.prepare('SELECT * FROM memories WHERE id = ?').get(id);
+        const row = prefetchedRows.get(id);
         if (!row)
             return false;
         const memory = rowToMemory(row);
@@ -346,15 +400,8 @@ function scoreWithRrf(input) {
         memoryMap.set(memory.id, memory);
         return true;
     };
-    const vectorIds = Array.from(vectorResults.entries())
-        .sort((a, b) => b[1] - a[1])
-        .map(([id]) => id)
-        .filter(considerCandidate);
-    const graphLimit = Math.max(limit * 3, 50);
-    const graphResults = query && query.trim()
-        ? graphRankFromQuery(query, db, { project: options.project, limit: graphLimit })
-        : [];
-    const graphIds = graphResults.map((r) => r.memoryId).filter(considerCandidate);
+    const vectorIds = sortedVectorIds.filter(considerCandidate);
+    const graphIds = candidateGraphIds.filter(considerCandidate);
     return runHybridRanker({
         rankLists: [
             { name: 'fts', ids: ftsIds, weight: rankerConfig.weights.fts },
@@ -462,7 +509,10 @@ export async function recallWithEmbeddings(query, options) {
             sql += ` AND (project = ? OR scope = 'global')`;
             params.push(options.project);
         }
-        sql += ' ORDER BY salience DESC, last_accessed DESC LIMIT 200';
+        // Prefilter the embedding-fallback candidate pool on the persisted decayed
+        // score (COALESCE to raw salience for rows not yet scored — see the FTS
+        // prefilter above for the NULL rationale).
+        sql += ' ORDER BY COALESCE(decayed_score, 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));
@@ -476,14 +526,22 @@ export async function recallWithEmbeddings(query, options) {
         // 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
+        // Filter by threshold, then hydrate the survivors in ONE query. Was an N+1
+        // (one `SELECT * WHERE id = ?` per hit); now a single `WHERE id IN (...)`
+        // with an id→row map, mapping the threshold-passing ids through it so the
+        // original similarity order (and the skip-missing-row behaviour) is kept.
+        const hitIds = similar.filter((hit) => hit.score >= threshold).map((hit) => hit.id);
         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));
+        if (hitIds.length > 0) {
+            const placeholders = hitIds.map(() => '?').join(',');
+            const rowsById = new Map();
+            const fetched = db.prepare(`SELECT * FROM memories WHERE id IN (${placeholders})`).all(...hitIds);
+            for (const row of fetched)
+                rowsById.set(row.id, row);
+            for (const id of hitIds) {
+                const row = rowsById.get(id);
+                if (row)
+                    embeddingMemories.push(rowToMemory(row));
             }
         }
         // Step 4: Merge — FTS results first, then embedding results

package/dist/memory/search.d.ts

@@ -26,13 +26,29 @@ export interface SearchScoreValues {
     contradictionPenalty: number;
     finalScore: number;
 }
-export type MemoryRowConverter = (row: Record<string, unknown>) => Memory;
 export declare function detectQueryCategory(query: string): MemoryCategory | null;
 export declare function calculateLinkBoost(memoryId: number, db: Database.Database): number;
 export declare function calculateTagScore(queryTags: string[], memoryTags: string[]): number;
 export declare function extractQueryTags(query: string): string[];
-export declare function vectorSearch(db: Database.Database, rowToMemory: MemoryRowConverter, queryEmbedding: Float32Array, limit: number, project?: string, includeGlobal?: boolean): Array<{
-    memory: Memory;
+/**
+ * Decode a persisted `memories.embedding` BLOB into a Float32Array view.
+ *
+ * The embedding column is written as the raw little-endian bytes of a 384-dim
+ * Float32Array (addMemory: `Buffer.from(embedding.buffer)`). better-sqlite3 hands
+ * it back as a Node Buffer; this returns a zero-copy Float32Array view over those
+ * bytes. Shared by `vectorSearch` and the recall reuse path (`findSimilarMemories`)
+ * so the BLOB→vector decode lives in exactly one place.
+ */
+export declare function decodeEmbeddingBlob(buf: Buffer): Float32Array;
+/**
+ * Score embedded memories against a query embedding and return the top-k by
+ * cosine similarity. Selects ONLY `id, embedding` and returns lean
+ * `{ id, similarity }` pairs — the sole caller (search-recall) needs nothing
+ * more, so per-row Memory hydration (rowToMemory: 2 JSON parses + several
+ * `new Date()` per row) is deferred to whoever actually loads the survivors.
+ */
+export declare function vectorSearch(db: Database.Database, queryEmbedding: Float32Array, limit: number, project?: string, includeGlobal?: boolean): Array<{
+    id: number;
     similarity: number;
 }>;
 export declare function buildSearchExplanation(memory: Memory, context: SearchScoringContext, values: SearchScoreValues): SearchResult['explanation'];

package/dist/memory/search.js

@@ -63,9 +63,28 @@ export function extractQueryTags(query) {
         /^[a-z][a-z0-9-]*$/.test(word) &&
         !['the', 'and', 'for', 'with', 'how', 'what', 'when', 'where', 'why'].includes(word));
 }
-export function vectorSearch(db, rowToMemory, queryEmbedding, limit, project, includeGlobal = true) {
+/**
+ * Decode a persisted `memories.embedding` BLOB into a Float32Array view.
+ *
+ * The embedding column is written as the raw little-endian bytes of a 384-dim
+ * Float32Array (addMemory: `Buffer.from(embedding.buffer)`). better-sqlite3 hands
+ * it back as a Node Buffer; this returns a zero-copy Float32Array view over those
+ * bytes. Shared by `vectorSearch` and the recall reuse path (`findSimilarMemories`)
+ * so the BLOB→vector decode lives in exactly one place.
+ */
+export function decodeEmbeddingBlob(buf) {
+    return new Float32Array(buf.buffer, buf.byteOffset, buf.length / 4);
+}
+/**
+ * Score embedded memories against a query embedding and return the top-k by
+ * cosine similarity. Selects ONLY `id, embedding` and returns lean
+ * `{ id, similarity }` pairs — the sole caller (search-recall) needs nothing
+ * more, so per-row Memory hydration (rowToMemory: 2 JSON parses + several
+ * `new Date()` per row) is deferred to whoever actually loads the survivors.
+ */
+export function vectorSearch(db, queryEmbedding, limit, project, includeGlobal = true) {
     let query = `
-    SELECT * FROM memories
+    SELECT id, embedding FROM memories
     WHERE embedding IS NOT NULL
   `;
     const params = [];
@@ -79,14 +98,10 @@ export function vectorSearch(db, rowToMemory, queryEmbedding, limit, project, in
     }
     const rows = db.prepare(query).all(...params);
     return rows
-        .map((row) => {
-        const embeddingBuffer = row.embedding;
-        const embedding = new Float32Array(embeddingBuffer.buffer, embeddingBuffer.byteOffset, embeddingBuffer.length / 4);
-        return {
-            memory: rowToMemory(row),
-            similarity: cosineSimilarity(queryEmbedding, embedding),
-        };
-    })
+        .map((row) => ({
+        id: row.id,
+        similarity: cosineSimilarity(queryEmbedding, decodeEmbeddingBlob(row.embedding)),
+    }))
         .filter((result) => result.similarity > 0.3)
         .sort((a, b) => b.similarity - a.similarity)
         .slice(0, limit);

package/dist/memory/store.d.ts

@@ -58,7 +58,16 @@ export declare function getProjectMemories(project: string, config?: MemoryConfi
 /**
  * Get recent memories
  */
-export declare function getRecentMemories(limit?: number, project?: string, source?: DefenceSource): Memory[];
+export interface MemoryListFilters {
+    type?: string;
+    category?: string;
+}
+/**
+ * Count memories matching the project + type/category filters. Used by the
+ * dashboard memories route so `total`/`hasMore` reflect the filtered set.
+ */
+export declare function countMemories(project?: string, filters?: MemoryListFilters): number;
+export declare function getRecentMemories(limit?: number, project?: string, source?: DefenceSource, filters?: MemoryListFilters): Memory[];
 /**
  * Get memories by type
  */
@@ -66,7 +75,9 @@ 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[];
+export declare function getHighPriorityMemories(limit?: number, project?: string, source?: DefenceSource, filters?: MemoryListFilters): Memory[];
+/** Count high-priority (salience >= 0.6) memories matching the filters. */
+export declare function countHighPriorityMemories(project?: string, filters?: MemoryListFilters): number;
 /**
  * Get memory statistics
  */

package/dist/memory/store.js

@@ -350,6 +350,8 @@ export function addMemory(input, config = DEFAULT_CONFIG, source) {
                         threat_indicators: indicators,
                         anomaly_score: defenceResult.firewall.anomalyScore,
                         firewall_result: defenceResult.firewall.result,
+                        project: input.project ?? null,
+                        sensitivity_level: defenceResult.sensitivity.level,
                     });
                 }
                 catch {
@@ -539,6 +541,39 @@ export function getMemoryById(id, source) {
     }
     return rowToMemory(row);
 }
+/**
+ * Recompute and persist the `memories.embedding` vector for a memory whose
+ * embedded text (title/content) just changed. Fire-and-forget, mirroring
+ * addMemory's write: the caller is expected to have already cleared the column
+ * (`embedding = NULL`) synchronously so no stale vector is readable in the gap
+ * before this lands. No-ops cleanly when embeddings are disabled/unavailable.
+ */
+function refreshEmbeddingAsync(memoryId, title, content) {
+    const db = getDatabase();
+    generateEmbedding(title + ' ' + content)
+        .then((embedding) => {
+        try {
+            if (embedding && embedding.buffer) {
+                db.prepare('UPDATE memories SET embedding = ? WHERE id = ?')
+                    .run(Buffer.from(embedding.buffer), memoryId);
+            }
+        }
+        catch (e) {
+            const errMsg = e instanceof Error ? e.message : String(e);
+            if (/database connection is not open/i.test(errMsg))
+                return;
+            console.error('[shieldcortex] Failed to store refreshed embedding:', e);
+        }
+    })
+        .catch((e) => {
+        if (e instanceof Error &&
+            (e.message.includes('Embedding worker unavailable') ||
+                e.message.includes('Embeddings disabled via SHIELDCORTEX_SKIP_EMBEDDINGS=1'))) {
+            return;
+        }
+        console.error('[shieldcortex] Failed to regenerate embedding:', e);
+    });
+}
 /**
  * Update a memory
  */
@@ -635,11 +670,26 @@ export function updateMemory(id, updates) {
         fields.push('memory_scope = ?');
         values.push(updates.memoryScope);
     }
+    // STALENESS: if the embedded text (title/content) changes, the persisted
+    // `memories.embedding` no longer reflects the current content. The recall reuse
+    // path (findSimilarMemories) scores candidates straight off this column, so a
+    // stale vector would let recall match on outdated content. Clear it in the SAME
+    // UPDATE — no window where the old vector is readable — then recompute below,
+    // mirroring addMemory's fire-and-forget embedding write. Cleared-but-not-yet-
+    // recomputed rows are simply absent from vector recall until the recompute
+    // lands (FTS still covers them); a stale match is the unacceptable outcome.
+    const embeddedTextChanged = updates.title !== undefined || updates.content !== undefined;
+    if (embeddedTextChanged) {
+        fields.push('embedding = NULL');
+    }
     if (fields.length === 0)
         return existing;
     values.push(id);
     db.prepare(`UPDATE memories SET ${fields.join(', ')}, updated_at = CURRENT_TIMESTAMP WHERE id = ?`).run(...values);
     const updatedMemory = getMemoryById(id);
+    if (embeddedTextChanged) {
+        refreshEmbeddingAsync(updatedMemory.id, updatedMemory.title, updatedMemory.content);
+    }
     const shouldRefreshGraph = updates.title !== undefined ||
         updates.content !== undefined ||
         updates.category !== undefined;
@@ -750,6 +800,7 @@ export function mergeMemories(keptId, removedId, options, source = { type: 'cli'
           cloud_excluded = ?,
           access_count = ?,
           last_accessed = ?,
+          embedding = NULL,
           updated_at = CURRENT_TIMESTAMP
       WHERE id = ?
     `).run(mergedContent, JSON.stringify(mergedTags), mergedSalience, mergedProject, JSON.stringify(mergedMetadata), mergedScope, mergedTransferable ? 1 : 0, mergedStatus, mergedPinned ? 1 : 0, mergedReviewedBy, new Date().toISOString(), mergedTrustScore, mergedSensitivity, mergedCloudExcluded ? 1 : 0, mergedAccessCount, mergedLastAccessed, kept.id);
@@ -761,6 +812,10 @@ export function mergeMemories(keptId, removedId, options, source = { type: 'cli'
         catch (e) {
             console.error('[shieldcortex] Entity extraction refresh failed after merge:', e);
         }
+        // The merge UPDATE cleared `embedding` (the merged content differs from the
+        // pre-merge vector); recompute it for the new canonical content so the recall
+        // reuse path never scores against a stale pre-merge vector.
+        refreshEmbeddingAsync(updatedMemory.id, updatedMemory.title, updatedMemory.content);
         emitMemoryUpdated(updatedMemory);
         persistEvent('memory_updated', { memory: updatedMemory, mergedFromId: removed.id });
         if (isFeatureEnabled('cloud_sync')) {
@@ -827,18 +882,43 @@ export function getProjectMemories(project, config = DEFAULT_CONFIG) {
     });
 }
 /**
- * Get recent memories
+ * Build the shared `WHERE` fragment for project + type + category filters.
+ * Returned `clause` is the full `WHERE ...` string (empty when no filters),
+ * so the SAME predicate drives both the page query and its COUNT(*) — keeping
+ * pagination `total`/`hasMore` honest under filters (Phase 17 A3).
  */
-export function getRecentMemories(limit = 10, project, source) {
-    const db = getDatabase();
-    let sql = 'SELECT * FROM memories';
+function buildMemoryFilterClause(project, filters) {
+    const conds = [];
     const params = [];
     if (project) {
-        sql += ' WHERE project = ?';
+        conds.push('project = ?');
         params.push(project);
     }
+    if (filters?.type) {
+        conds.push('type = ?');
+        params.push(filters.type);
+    }
+    if (filters?.category) {
+        conds.push('category = ?');
+        params.push(filters.category);
+    }
+    return { clause: conds.length ? `WHERE ${conds.join(' AND ')}` : '', params };
+}
+/**
+ * Count memories matching the project + type/category filters. Used by the
+ * dashboard memories route so `total`/`hasMore` reflect the filtered set.
+ */
+export function countMemories(project, filters) {
+    const db = getDatabase();
+    const { clause, params } = buildMemoryFilterClause(project, filters);
+    return db.prepare(`SELECT COUNT(*) as count FROM memories ${clause}`).get(...params).count;
+}
+export function getRecentMemories(limit = 10, project, source, filters) {
+    const db = getDatabase();
+    const { clause, params } = buildMemoryFilterClause(project, filters);
+    let sql = `SELECT * FROM memories ${clause}`;
     sql += ' ORDER BY last_accessed DESC LIMIT ?';
-    params.push(source ? limit * 2 : limit); // over-fetch when filtering
+    params.push(source ? limit * 2 : limit); // over-fetch when access-filtering
     let rows = db.prepare(sql).all(...params);
     if (source)
         rows = filterRowsByAccess(rows, source);
@@ -860,17 +940,22 @@ export function getMemoriesByType(type, limit = 50) {
 /**
  * Get high-priority memories (for context injection)
  */
-export function getHighPriorityMemories(limit = 10, project, source) {
+export function getHighPriorityMemories(limit = 10, project, source, filters) {
     const db = getDatabase();
-    let sql = `
-    SELECT * FROM memories
-    WHERE salience >= 0.6
-  `;
+    let sql = `SELECT * FROM memories WHERE salience >= 0.6`;
     const params = [];
     if (project) {
         sql += ' AND project = ?';
         params.push(project);
     }
+    if (filters?.type) {
+        sql += ' AND type = ?';
+        params.push(filters.type);
+    }
+    if (filters?.category) {
+        sql += ' AND category = ?';
+        params.push(filters.category);
+    }
     sql += ' ORDER BY salience DESC, last_accessed DESC LIMIT ?';
     params.push(source ? limit * 2 : limit);
     let rows = db.prepare(sql).all(...params);
@@ -878,6 +963,25 @@ export function getHighPriorityMemories(limit = 10, project, source) {
         rows = filterRowsByAccess(rows, source);
     return rows.slice(0, limit).map(rowToMemory);
 }
+/** Count high-priority (salience >= 0.6) memories matching the filters. */
+export function countHighPriorityMemories(project, filters) {
+    const db = getDatabase();
+    let sql = `SELECT COUNT(*) as count FROM memories WHERE salience >= 0.6`;
+    const params = [];
+    if (project) {
+        sql += ' AND project = ?';
+        params.push(project);
+    }
+    if (filters?.type) {
+        sql += ' AND type = ?';
+        params.push(filters.type);
+    }
+    if (filters?.category) {
+        sql += ' AND category = ?';
+        params.push(filters.category);
+    }
+    return db.prepare(sql).get(...params).count;
+}
 /**
  * Get memory statistics
  */