persyst-mcp 1.0.1 → 2.0.0

package/src/git.js

@@ -1,37 +1,38 @@
 /**
- * git.js — Git Commit Ingestion
+ * git.js — Git Commit Ingestion & Analysis
  * 
  * Reads git log from a repository and converts commits into memories.
- * Useful for giving coding agents context about a project's history.
+ * Performs commit categorization, file diff analysis, and imports notes.
  * 
- * Each commit becomes a memory like:
- *   "[abc1234] Fix login bug — by John on 2024-01-15"
- * 
- * Deduplicates by commit hash so you can ingest safely multiple times.
+ * IMPORTANT: Uses async execFile instead of execSync to avoid blocking
+ * the Node.js event loop during git operations (Bug 4 fix).
  */
 
-import { execSync } from 'child_process';
+import { execFile } from 'child_process';
+import { promisify } from 'util';
+
+const execFileAsync = promisify(execFile);
 
 /**
  * Read the N most recent git commits from a repository.
  * 
  * @param {string} repoPath - Absolute path to the git repo
  * @param {number} count - Number of commits to read (default: 20)
- * @returns {Array<{hash: string, message: string, author: string, date: string, fullText: string}>}
+ * @returns {Promise<Array<{hash: string, message: string, author: string, date: string, fullText: string, files: string[], importance: number}>>}
  */
-export function getRecentCommits(repoPath, count = 20) {
+export async function getRecentCommits(repoPath, count = 20) {
   try {
     // Use a delimiter to split commits reliably
     const DELIM = '---PERSYST-COMMIT---';
     const format = `${DELIM}%n%H%n%an%n%ai%n%s%n%b`;
 
-    const output = execSync(
-      `git log -n ${count} --pretty=format:"${format}"`,
+    const { stdout: output } = await execFileAsync(
+      'git',
+      ['log', `-n`, `${count}`, `--pretty=format:${format}`],
       {
         cwd: repoPath,
         encoding: 'utf-8',
         timeout: 10000,      // 10s timeout
-        stdio: ['pipe', 'pipe', 'pipe']  // Suppress stderr
       }
     );
 
@@ -49,17 +50,37 @@ export function getRecentCommits(repoPath, count = 20) {
       const subject = lines[3].trim();
       const body = lines.slice(4).join(' ').trim();
 
+      // Fetch git notes if available (represents PR metadata)
+      const notes = await getGitNotes(repoPath, hash);
+
       // Build a readable memory string
-      const fullText = body
+      let fullText = body
         ? `[${hash.slice(0, 7)}] ${subject} — by ${author} on ${date}. ${body}`
         : `[${hash.slice(0, 7)}] ${subject} — by ${author} on ${date}`;
 
-      commits.push({ hash, message: subject, author, date, fullText });
+      if (notes) {
+        fullText += ` [PR Notes] ${notes}`;
+      }
+
+      // Fetch files touched
+      const files = await getCommitFiles(repoPath, hash);
+
+      // Classify importance based on message
+      const classification = classifyCommit(subject);
+
+      commits.push({
+        hash,
+        message: subject,
+        author,
+        date,
+        fullText,
+        files,
+        importance: classification.importance
+      });
     }
 
     return commits;
   } catch (err) {
-    // Not a git repo, or git not installed
     const message = err.message || String(err);
     if (message.includes('not a git repository')) {
       throw new Error(`Not a git repository: ${repoPath}`);
@@ -77,17 +98,17 @@ export function getRecentCommits(repoPath, count = 20) {
  * 
  * @param {string} repoPath - Absolute path to the git repo
  * @param {string} hash - Full commit hash
- * @returns {string[]} List of changed file paths
+ * @returns {Promise<string[]>} List of changed file paths
  */
-export function getCommitFiles(repoPath, hash) {
+export async function getCommitFiles(repoPath, hash) {
   try {
-    const output = execSync(
-      `git diff-tree --no-commit-id --name-only -r ${hash}`,
+    const { stdout: output } = await execFileAsync(
+      'git',
+      ['diff-tree', '--no-commit-id', '--name-only', '-r', hash],
       {
         cwd: repoPath,
         encoding: 'utf-8',
         timeout: 5000,
-        stdio: ['pipe', 'pipe', 'pipe']
       }
     );
     return output.trim().split('\n').filter(Boolean);
@@ -95,3 +116,49 @@ export function getCommitFiles(repoPath, hash) {
     return [];
   }
 }
+
+/**
+ * Fetch git notes (representing PR metadata or additional annotations).
+ */
+export async function getGitNotes(repoPath, hash) {
+  try {
+    const { stdout: output } = await execFileAsync(
+      'git',
+      ['notes', 'show', hash],
+      {
+        cwd: repoPath,
+        encoding: 'utf-8',
+        timeout: 3000,
+      }
+    );
+    return output.trim();
+  } catch {
+    return '';
+  }
+}
+
+/**
+ * Categorize commit and assign importance.
+ */
+export function classifyCommit(subject) {
+  const s = subject.toLowerCase().trim();
+  if (
+    s.startsWith('feat:') ||
+    s.startsWith('fix:') ||
+    s.startsWith('refactor:') ||
+    s.startsWith('breaking:') ||
+    s.startsWith('decision:')
+  ) {
+    return { type: 'architectural', importance: 0.9 };
+  }
+  if (
+    s.startsWith('chore:') ||
+    s.startsWith('docs:') ||
+    s.startsWith('test:') ||
+    s.startsWith('style:') ||
+    s.startsWith('ci:')
+  ) {
+    return { type: 'chore', importance: 0.4 };
+  }
+  return { type: 'other', importance: 0.6 };
+}

package/src/search.js

@@ -1,49 +1,43 @@
 /**
- * search.js — Hybrid Search Engine
+ * search.js — Hybrid Search & Context Optimization Engine
  * 
- * Combines two search strategies for best results:
- * 
- *   1. KEYWORD SEARCH (FTS5 + BM25)
- *      → Finds exact word matches. Fast. "React" finds "React".
- * 
- *   2. SEMANTIC SEARCH (sqlite-vec + embeddings)
- *      → Finds by meaning. "dark mode" matches "night theme".
- * 
- *   3. HYBRID = keyword + semantic merged
- *      → Keyword matches get a +0.2 score boost on top of semantic score.
- *      → Best of both worlds.
+ * Combines keyword and semantic searches, integrates temporal decay,
+ * applies agent reputation scores, generates cryptographic search attestations,
+ * builds graph-hopped optimized LLM context prompts, and applies MMR
+ * for diverse result retrieval.
  */
 
-import { generateEmbedding } from './embeddings.js';
-import {
+import db, {
   searchKeyword,
   searchVector,
   getMemoryById,
-  boostMemory
+  boostMemory,
+  getProvenance,
+  getMemoriesByEntity
 } from './database.js';
-
-// ============================================================
-// HYBRID SEARCH (the main export)
-// ============================================================
+import { generateEmbedding } from './embeddings.js';
+import { createAttestation } from './attestation.js';
+import { searchCache, LRUCache } from './cache.js';
 
 /**
  * Search memories using both keyword and semantic strategies.
- * 
- * How it works:
- *   1. Run FTS5 keyword search → get matching memory IDs
- *   2. Run vector semantic search → get memories ranked by meaning
- *   3. If a memory appears in BOTH, boost its score by +0.2
- *   4. Sort by combined score, return top N
+ * Results are cached in the LRU cache for repeated queries.
  * 
  * @param {string} queryText - What to search for
  * @param {number} limit - Max results to return (default: 5)
- * @returns {Promise<Array>} Ranked search results with scores
- * 
- * @example
- *   const results = await searchHybrid("night theme", 5);
- *   // Will find memories about "dark mode" via semantic match
+ * @param {string|null} agentId - Identifying string for the querying agent
+ * @param {string|null} sessionId - Session identifier
+ * @returns {Promise<Array>} Ranked search results (with .attestation property attached)
  */
-export async function searchHybrid(queryText, limit = 5) {
+export async function searchHybrid(queryText, limit = 5, agentId = null, sessionId = null) {
+  // --- Check LRU cache first (Feature 1) ---
+  const cacheKey = LRUCache.key(queryText, limit);
+  const cached = searchCache.get(cacheKey);
+  if (cached) {
+    console.error(`[persyst-cache] Cache HIT for query: "${queryText.slice(0, 50)}..."`);
+    return cached;
+  }
+
   // --- Step 1: Keyword search (fast, exact matches) ---
   const keywordHits = searchKeyword(queryText, limit * 2);
   const keywordIds = new Set(keywordHits.map(r => r.id));
@@ -56,17 +50,22 @@ export async function searchHybrid(queryText, limit = 5) {
     id: r.rowid,
     distance: r.distance,
     // Convert L2 distance to 0-1 similarity score
-    // For normalized vectors: cosine_sim = 1 - (L2_distance² / 2)
     similarity: Math.max(0, 1 - (r.distance * r.distance) / 2)
   }));
 
   // --- Step 3: Merge results with keyword boost ---
-  const combined = semanticResults.map(r => ({
-    id: r.id,
-    similarity: r.similarity,
-    hybrid_score: r.similarity + (keywordIds.has(r.id) ? 0.2 : 0),
-    keyword_match: keywordIds.has(r.id)
-  }));
+  const combined = semanticResults
+    .map(r => {
+      const isKeywordMatch = keywordIds.has(r.id);
+      return {
+        id: r.id,
+        similarity: r.similarity,
+        hybrid_score: r.similarity + (isKeywordMatch ? 0.2 : 0),
+        keyword_match: isKeywordMatch
+      };
+    })
+    // Filter out low similarity semantic matches if they have no keyword match (threshold 0.35)
+    .filter(r => r.keyword_match || r.similarity >= 0.35);
 
   // Add keyword-only hits that semantic search missed
   const semanticIds = new Set(semanticResults.map(r => r.id));
@@ -81,29 +80,356 @@ export async function searchHybrid(queryText, limit = 5) {
     }
   }
 
-  // --- Step 4: Sort by score, fetch full data, return top N ---
-  combined.sort((a, b) => b.hybrid_score - a.hybrid_score);
-  const topResults = combined.slice(0, limit);
-
-  const results = topResults
+  // --- Step 4: Fetch full details, apply reputation adjust, sort and return top N ---
+  const finalResults = combined
     .map(r => {
       const memory = getMemoryById(r.id);
-      if (!memory) return null;  // Memory was deleted between search and fetch
+      if (!memory) return null; // Memory was archived or deleted
 
-      // Boost importance since this memory was useful
+      // Boost memory access metrics
       boostMemory(r.id);
 
+      // Fetch reputation stats for weighting
+      let reputationScore = 1.0;
+      let reputationWarning = false;
+      const prov = memory.provenance;
+      if (prov && prov.source_type === 'agent' && prov.source_id) {
+        const agentRow = db.prepare('SELECT reputation_score FROM agent_stats WHERE agent_id = ?').get(prov.source_id);
+        if (agentRow) {
+          reputationScore = agentRow.reputation_score;
+          if (reputationScore < 0.5) {
+            reputationWarning = true;
+          }
+        }
+      }
+
+      // Final score formula: base_score * agent_reputation
+      const finalScore = r.hybrid_score * reputationScore;
+
       return {
         id: memory.id,
         content: memory.content,
         importance_score: memory.importance_score,
         created_at: memory.created_at,
+        last_accessed: memory.last_accessed,
         similarity: r.similarity.toFixed(4),
-        hybrid_score: r.hybrid_score.toFixed(4),
-        keyword_match: r.keyword_match
+        hybrid_score: finalScore.toFixed(4),
+        keyword_match: r.keyword_match,
+        reputation_warning: reputationWarning,
+        provenance: prov
       };
     })
-    .filter(Boolean);  // Remove nulls from deleted memories
+    .filter(Boolean);
+
+  // Sort by final score descending
+  finalResults.sort((a, b) => parseFloat(b.hybrid_score) - parseFloat(a.hybrid_score));
+
+  // --- Step 5: Apply MMR for diverse retrieval (Feature 3) ---
+  const mmrResults = applyMMR(finalResults, limit);
+
+  // Generate cryptographic attestation for audit trails
+  const attestation = createAttestation(queryText, mmrResults, agentId, sessionId);
+
+  // Attach attestation object directly to the array to preserve compatibility with existing tests
+  mmrResults.attestation = attestation;
+
+  // --- Store in LRU cache (Feature 1) ---
+  searchCache.set(cacheKey, mmrResults);
+
+  return mmrResults;
+}
+
+/**
+ * Apply Maximal Marginal Relevance (MMR) re-ranking for diverse results.
+ * 
+ * MMR balances relevance with diversity by penalizing candidates that
+ * are too similar to already-selected results.
+ * 
+ * @param {Array} candidates - Scored search results
+ * @param {number} limit - Max results to return
+ * @param {number} lambda - Trade-off parameter (0.7 = 70% relevance, 30% diversity)
+ * @returns {Array} MMR-reranked results
+ */
+function applyMMR(candidates, limit, lambda = 0.7) {
+  if (candidates.length <= limit) return candidates;
+
+  const selected = [];
+  const remaining = [...candidates];
+
+  // Always pick the top-scored result first
+  selected.push(remaining.shift());
+
+  while (selected.length < limit && remaining.length > 0) {
+    let bestIdx = -1;
+    let bestMMRScore = -Infinity;
+
+    for (let i = 0; i < remaining.length; i++) {
+      const candidate = remaining[i];
+      const relevance = parseFloat(candidate.hybrid_score);
+
+      // Calculate max similarity to any already-selected result
+      // Using content-based Jaccard similarity as a proxy
+      let maxSimToSelected = 0;
+      for (const sel of selected) {
+        const sim = jaccardSimilarity(candidate.content, sel.content);
+        if (sim > maxSimToSelected) maxSimToSelected = sim;
+      }
+
+      // MMR score = λ * relevance - (1 - λ) * max_similarity_to_selected
+      const mmrScore = lambda * relevance - (1 - lambda) * maxSimToSelected;
+
+      if (mmrScore > bestMMRScore) {
+        bestMMRScore = mmrScore;
+        bestIdx = i;
+      }
+    }
+
+    if (bestIdx >= 0) {
+      selected.push(remaining.splice(bestIdx, 1)[0]);
+    } else {
+      break;
+    }
+  }
+
+  return selected;
+}
+
+/**
+ * Compute Jaccard similarity between two text strings.
+ * Uses word-level tokenization for efficiency.
+ * 
+ * @param {string} a - First text
+ * @param {string} b - Second text
+ * @returns {number} Similarity score between 0 and 1
+ */
+function jaccardSimilarity(a, b) {
+  const wordsA = new Set(a.toLowerCase().split(/\s+/));
+  const wordsB = new Set(b.toLowerCase().split(/\s+/));
+  
+  let intersection = 0;
+  for (const word of wordsA) {
+    if (wordsB.has(word)) intersection++;
+  }
+  
+  const union = wordsA.size + wordsB.size - intersection;
+  return union === 0 ? 0 : intersection / union;
+}
+
+/**
+ * Optimizes the retrieved context by walking the knowledge graph and compressing content to fit max_tokens.
+ * 
+ * @param {string} queryText - User's query
+ * @param {number} maxTokens - Hard limit of tokens for context prompt
+ * @param {string|null} agentId - Querying agent identifier
+ * @param {string|null} sessionId - Current session ID
+ */
+export async function getOptimizedContext(queryText, maxTokens, agentId = null, sessionId = null) {
+  // 1. Run hybrid search to fetch top 20 memories
+  const searchHits = await searchHybrid(queryText, 20, agentId, sessionId);
+  const candidates = new Map();
+
+  for (const hit of searchHits) {
+    candidates.set(hit.id, {
+      id: hit.id,
+      content: hit.content,
+      importance_score: hit.importance_score,
+      created_at: hit.created_at,
+      last_accessed: hit.last_accessed,
+      score: parseFloat(hit.hybrid_score),
+      provenance: hit.provenance,
+      source: 'search'
+    });
+
+    // 2. Perform Graph Hop
+    const edges = db.prepare(`
+      SELECT * FROM edges 
+      WHERE (source_id = ? AND source_type = 'memory')
+         OR (target_id = ? AND target_type = 'memory')
+    `).all(hit.id, hit.id);
+
+    const entityIds = [];
+    for (const edge of edges) {
+      if (edge.source_type === 'entity') entityIds.push(edge.source_id);
+      if (edge.target_type === 'entity') entityIds.push(edge.target_id);
+    }
+
+    for (const entId of entityIds) {
+      const otherMemories = getMemoriesByEntity(entId);
+      for (const other of otherMemories) {
+        if (other.id === hit.id) continue;
+        if (candidates.has(other.id)) continue;
+
+        const otherProv = getProvenance(other.id);
+        candidates.set(other.id, {
+          id: other.id,
+          content: other.content,
+          importance_score: other.importance_score,
+          created_at: other.created_at,
+          last_accessed: other.last_accessed,
+          score: parseFloat(hit.hybrid_score) * 0.5, // 50% graph-hop penalty
+          provenance: otherProv,
+          source: 'hop'
+        });
+      }
+    }
+  }
+
+  // 3. Apply Scoring Adjustments
+  const now = Math.floor(Date.now() / 1000);
+  const list = Array.from(candidates.values());
+
+  for (const c of list) {
+    // 3a. Temporal decay: score *= exp(-0.01 * hours_since_accessed)
+    const hours = Math.max(0, (now - c.last_accessed) / 3600);
+    c.score *= Math.exp(-0.01 * hours);
+
+    // 3b. Agent reputation weighting
+    let reputationScore = 1.0;
+    if (c.provenance && c.provenance.source_type === 'agent' && c.provenance.source_id) {
+      const agentRow = db.prepare('SELECT reputation_score FROM agent_stats WHERE agent_id = ?').get(c.provenance.source_id);
+      if (agentRow) {
+        reputationScore = agentRow.reputation_score;
+      }
+    }
+    c.score *= reputationScore;
+  }
+
+  // 4. Sort candidates
+  list.sort((a, b) => b.score - a.score);
+
+  // 5. Compress context to fit maxTokens
+  let currentTokens = 0;
+  const accepted = [];
+
+  for (const c of list) {
+    // Heuristic: ~4 characters per token + format headers (~15 tokens)
+    const estimatedTokens = Math.max(1, Math.ceil(c.content.length / 4) + 15);
+    if (currentTokens + estimatedTokens > maxTokens) {
+      continue;
+    }
+    currentTokens += estimatedTokens;
+    accepted.push(c);
+  }
+
+  // 6. Format LLM injection context string
+  let context = '=== RETRIEVED AGENT MEMORY CONTEXT ===\n';
+  if (accepted.length === 0) {
+    context += 'No relevant memories retrieved.\n';
+  } else {
+    for (const a of accepted) {
+      let sourceTag = 'Source: manual';
+      if (a.provenance) {
+        sourceTag = `Source: ${a.provenance.source_type}${a.provenance.source_id ? ` (${a.provenance.source_id})` : ''}`;
+      }
+      context += `[Memory #${a.id}] (Score: ${a.score.toFixed(4)}, ${sourceTag})\n${a.content}\n---\n`;
+    }
+  }
+  context += '=== END OF CONTEXT ===';
+
+  // Bug 8 fix: Skip attestation when no results to avoid audit noise
+  let attestation = null;
+  if (accepted.length > 0) {
+    attestation = createAttestation(queryText, accepted, agentId, sessionId);
+  }
+
+  return {
+    context,
+    memories: accepted,
+    attestation
+  };
+}
+
+/**
+ * Performs memory consolidation by merging highly similar memories.
+ * Bug 6 fix: DB mutations are wrapped in a transaction for atomicity.
+ */
+export async function consolidateMemories() {
+  const activeMemories = db.prepare('SELECT * FROM memories WHERE valid_until IS NULL').all();
+  const consolidated = [];
+  const visited = new Set();
+
+  // Pre-compile the transaction for atomic DB operations (Bug 6 fix)
+  const archiveAndMerge = db.transaction((canonicalId, mergedContent, dupIds) => {
+    // Update canonical memory with merged content
+    db.prepare('UPDATE memories SET content = ?, last_accessed = unixepoch() WHERE id = ?').run(mergedContent, canonicalId);
+
+    // Archive duplicates
+    for (const dupId of dupIds) {
+      db.prepare('UPDATE memories SET valid_until = unixepoch() WHERE id = ?').run(dupId);
+      db.prepare('INSERT INTO contradictions (old_memory_id, new_memory_id, resolution_reason) VALUES (?, ?, ?)')
+        .run(dupId, canonicalId, `Consolidated into canonical memory #${canonicalId}`);
+    }
+  });
+
+  for (const mem of activeMemories) {
+    if (visited.has(mem.id)) continue;
+
+    // Search for similar memories
+    const embedding = db.prepare('SELECT embedding FROM memories_vec WHERE rowid = ?').get(mem.id);
+    if (!embedding) continue;
+
+    // sqlite-vec similarity search
+    const hits = db.prepare(`
+      SELECT rowid AS id, distance
+      FROM memories_vec
+      WHERE embedding MATCH ?
+      AND k = 10
+    `).all(embedding.embedding);
+
+    const duplicates = [];
+    for (const hit of hits) {
+      if (Number(hit.id) === mem.id) continue;
+      if (visited.has(Number(hit.id))) continue;
+
+      const sim = Math.max(0, 1 - (hit.distance * hit.distance) / 2);
+      if (sim > 0.85) {
+        const dupMemory = db.prepare('SELECT * FROM memories WHERE id = ? AND valid_until IS NULL').get(Number(hit.id));
+        if (dupMemory) {
+          duplicates.push(dupMemory);
+        }
+      }
+    }
+
+    if (duplicates.length > 0) {
+      // Group found! Merge them.
+      const allMemoriesInGroup = [mem, ...duplicates];
+
+      // Sort by importance to pick canonical
+      allMemoriesInGroup.sort((a, b) => b.importance_score - a.importance_score);
+      const canonical = allMemoriesInGroup[0];
+      const dupesToArchive = allMemoriesInGroup.slice(1);
+
+      // Merge contents (unique sentences or concatenated text)
+      const contents = allMemoriesInGroup.map(m => m.content.trim());
+      const uniqueContents = Array.from(new Set(contents));
+      const mergedContent = uniqueContents.join('. ').replace(/\.\./g, '.');
+
+      // Generate new embedding OUTSIDE the transaction (async operation)
+      const newEmbedding = await generateEmbedding(mergedContent);
+
+      // Run atomic DB transaction for all mutations (Bug 6 fix)
+      archiveAndMerge(canonical.id, mergedContent, dupesToArchive.map(d => d.id));
+
+      // Update vector embedding (also outside transaction since vec0 tables have their own handling)
+      db.prepare('DELETE FROM memories_vec WHERE rowid = ?').run(canonical.id);
+      db.prepare('INSERT INTO memories_vec (rowid, embedding) VALUES (?, ?)').run(BigInt(canonical.id), Buffer.from(newEmbedding.buffer));
+
+      for (const dup of dupesToArchive) {
+        visited.add(dup.id);
+      }
+
+      visited.add(canonical.id);
+      consolidated.push({
+        canonical_id: canonical.id,
+        merged_content: mergedContent,
+        archived_ids: dupesToArchive.map(d => d.id)
+      });
+    }
+  }
 
-  return results;
+  return {
+    success: true,
+    consolidated_groups: consolidated.length,
+    details: consolidated
+  };
 }

package/src/server.js

@@ -3,6 +3,7 @@
  * 
  * Creates the MCP server, registers all tools, and connects
  * via stdio transport (the standard MCP communication method).
+ * Sets up hourly temporal decay and daily consolidation background tasks.
  * 
  * IMPORTANT: Never write to stdout — it's reserved for MCP protocol.
  * All logging goes to stderr via console.error().
@@ -10,8 +11,9 @@
 
 import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
-import { registerTools } from './tools.js';
+import { registerTools, cleanupWatchers } from './tools.js';
 import { applyTemporalDecay, closeDatabase } from './database.js';
+import { consolidateMemories } from './search.js';
 
 /**
  * Start the Persyst MCP server.
@@ -21,7 +23,7 @@ export async function startServer() {
   // --- Create MCP server ---
   const server = new McpServer({
     name: 'persyst',
-    version: '1.0.1'
+    version: '2.0.0'
   });
 
   // --- Register all tools ---
@@ -32,10 +34,24 @@ export async function startServer() {
   // Runs every hour: reduces importance of memories not accessed in 7+ days
   const decayTimer = setInterval(applyTemporalDecay, 3600000);
 
-  // --- Graceful shutdown ---
+  // --- Start daily consolidation sweep ---
+  // Runs every 24 hours: merges similar memories (similarity > 0.85)
+  const consolidationTimer = setInterval(async () => {
+    console.error('[persyst] Running scheduled daily memory consolidation sweep...');
+    try {
+      const report = await consolidateMemories();
+      console.error(`[persyst] Consolidation sweep completed: consolidated ${report.consolidated_groups} duplicate groups.`);
+    } catch (err) {
+      console.error('[persyst] Daily consolidation sweep failed:', err.message);
+    }
+  }, 86400000);
+
+  // --- Graceful shutdown (Bug 3 fix: also cleans up git watchers) ---
   const shutdown = () => {
     console.error('[persyst] Shutting down...');
     clearInterval(decayTimer);
+    clearInterval(consolidationTimer);
+    cleanupWatchers();  // Bug 3 fix: stop all git repo watchers
     closeDatabase();
     process.exit(0);
   };
@@ -43,7 +59,6 @@ export async function startServer() {
   process.on('SIGTERM', shutdown);
 
   // --- Connect via stdio ---
-  // This is how Claude Code, Cursor, and Aider communicate with us
   const transport = new StdioServerTransport();
   await server.connect(transport);