persyst-mcp 2.2.0 → 2.2.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "persyst-mcp",
-  "version": "2.2.0",
+  "version": "2.2.1",
   "description": "Local-first MCP memory server with hybrid keyword + semantic search for coding agents",
   "type": "module",
   "main": "index.js",

package/src/attestation.js

@@ -60,10 +60,16 @@ export function createAttestation(query, memories, agentId = null, sessionId = n
   // Map memories to {id, content_hash, score}
   const memoriesRetrieved = memories.map(m => {
     const contentHash = crypto.createHash('sha256').update(m.content).digest('hex');
+    let scoreVal = 0;
+    if (m.hybrid_score !== undefined && m.hybrid_score !== null) {
+      scoreVal = m.hybrid_score;
+    } else if (m.score !== undefined && m.score !== null) {
+      scoreVal = m.score;
+    }
     return {
       id: m.id,
       content_hash: contentHash,
-      score: parseFloat(m.hybrid_score || 0)
+      score: parseFloat(scoreVal)
     };
   });
 

package/src/database.js

@@ -77,6 +77,11 @@ try {
   db.exec("ALTER TABLE memories ADD COLUMN namespace TEXT DEFAULT 'shared'");
 } catch (e) { /* Column already exists */ }
 
+// --- Migration: add parent_id column for history tracing ---
+try {
+  db.exec('ALTER TABLE memories ADD COLUMN parent_id INTEGER DEFAULT NULL');
+} catch (e) { /* Column already exists */ }
+
 // --- Index on namespace for fast filtered queries ---
 try {
   db.exec('CREATE INDEX IF NOT EXISTS idx_memories_namespace ON memories (namespace)');
@@ -226,7 +231,7 @@ console.error('[persyst] Schema initialized ✓');
 const stmts = {
   // -- Insert --
   insertMemory: db.prepare(
-    'INSERT INTO memories (content, importance_score, namespace) VALUES (?, ?, ?)'
+    'INSERT INTO memories (content, importance_score, namespace, parent_id) VALUES (?, ?, ?, ?)'
   ),
   insertVec: db.prepare(
     'INSERT INTO memories_vec (rowid, embedding) VALUES (?, ?)'
@@ -434,13 +439,19 @@ const stmts = {
  * @param {string} namespace - Namespace for agent isolation (default: 'shared')
  * @returns {number} The new memory's ID
  */
-export function insertMemory(content, importance = 1.0, provenanceInfo = null, namespace = 'shared') {
-  const result = stmts.insertMemory.run(content, importance, namespace || 'shared');
+export function insertMemory(content, importance = 1.0, provenanceInfo = null, namespace = 'shared', parentId = null) {
+  if (content && content.length > 10000) {
+    throw new Error('Memory content exceeds maximum length of 10000 characters.');
+  }
+  const result = stmts.insertMemory.run(content, importance, namespace || 'shared', parentId);
   const id = Number(result.lastInsertRowid);
 
   // Provenance Info handling
   const source_type = provenanceInfo?.source_type || 'manual';
-  const source_id = provenanceInfo?.source_id || null;
+  let source_id = provenanceInfo?.source_id || null;
+  if (source_type === 'agent' && source_id) {
+    source_id = source_id.toLowerCase();
+  }
   const confidence = provenanceInfo?.confidence !== undefined ? provenanceInfo.confidence : 1.0;
 
   stmts.insertProvenance.run(id, source_type, source_id, confidence);
@@ -758,14 +769,21 @@ export function logContradiction(oldMemoryId, newMemoryId, reason = '') {
   stmts.archiveMemory.run(oldMemoryId);
   stmts.insertContradiction.run(oldMemoryId, newMemoryId, reason);
 
+  // Set parent_id to link memories for bidirectional history tracing
+  try {
+    db.prepare('UPDATE memories SET parent_id = ? WHERE id = ?').run(oldMemoryId, newMemoryId);
+  } catch (e) {
+    console.error(`[persyst] Failed to set parent_id on contradiction: ${e.message}`);
+  }
+
   // Retrieve provenance of both versions for game-theoretic reputation calculation
   const oldProvenance = getProvenance(oldMemoryId);
   const newProvenance = getProvenance(newMemoryId);
 
   if (oldProvenance && oldProvenance.source_type === 'agent' && oldProvenance.source_id) {
-    const isSelfCorrection = newProvenance &&
-                             newProvenance.source_type === 'agent' &&
-                             newProvenance.source_id === oldProvenance.source_id;
+    const isSelfCorrection = (newProvenance && newProvenance.source_id &&
+                              newProvenance.source_id.toLowerCase() === oldProvenance.source_id.toLowerCase()) ||
+                             reason.includes('update_memory');
     if (!isSelfCorrection) {
       // Different agent/manual source contradicts the old memory
       incrementAgentStat(oldProvenance.source_id, 'contradicted');
@@ -782,22 +800,27 @@ export function logContradiction(oldMemoryId, newMemoryId, reason = '') {
  * Get provenance for a memory.
  */
 export function getProvenance(memoryId) {
-  return stmts.getProvenance.get(memoryId) || null;
+  const prov = stmts.getProvenance.get(memoryId) || null;
+  if (prov && prov.source_type === 'agent' && prov.source_id) {
+    prov.source_id = prov.source_id.toLowerCase();
+  }
+  return prov;
 }
 
 /**
  * Update agent reputation counters.
  */
 export function incrementAgentStat(agentId, action) {
-  stmts.upsertAgent.run(agentId);
+  const normalizedAgentId = agentId.toLowerCase();
+  stmts.upsertAgent.run(normalizedAgentId);
   if (action === 'created') {
-    stmts.incrementCreated.run(agentId);
+    stmts.incrementCreated.run(normalizedAgentId);
   } else if (action === 'confirmed') {
-    stmts.incrementConfirmed.run(agentId);
+    stmts.incrementConfirmed.run(normalizedAgentId);
   } else if (action === 'contradicted') {
-    stmts.incrementContradicted.run(agentId);
+    stmts.incrementContradicted.run(normalizedAgentId);
   }
-  stmts.recalculateReputation.run(agentId);
+  stmts.recalculateReputation.run(normalizedAgentId);
 }
 
 /**
@@ -857,13 +880,25 @@ export function getMemoryHistoryChain(memoryId) {
     if (versions.has(currentId)) continue;
     versions.add(currentId);
 
-    // Find ancestors (replaced by current) — using prepared statement
+    // 1. Find parent (ancestor) from memories table
+    const row = db.prepare('SELECT parent_id FROM memories WHERE id = ?').get(currentId);
+    if (row && row.parent_id !== null) {
+      if (!versions.has(row.parent_id)) queue.push(row.parent_id);
+    }
+
+    // 2. Find children (descendants) from memories table
+    const children = db.prepare('SELECT id FROM memories WHERE parent_id = ?').all(currentId);
+    for (const child of children) {
+      if (!versions.has(child.id)) queue.push(child.id);
+    }
+
+    // 3. Fallback: Find ancestors (replaced by current) from contradictions table
     const ancestors = stmts.getContradictionAncestors.all(currentId);
     ancestors.forEach(a => {
       if (!versions.has(a.old_memory_id)) queue.push(a.old_memory_id);
     });
 
-    // Find descendants (replaces current) — using prepared statement
+    // 4. Fallback: Find descendants (replaces current) from contradictions table
     const descendants = stmts.getContradictionDescendants.all(currentId);
     descendants.forEach(d => {
       if (!versions.has(d.new_memory_id)) queue.push(d.new_memory_id);
@@ -882,7 +917,19 @@ export function getMemoryHistoryChain(memoryId) {
     ORDER BY m.created_at ASC
   `).all(...ids);
 
-  return rows;
+  const uniqueRows = [];
+  const seenIds = new Set();
+  for (const row of rows) {
+    if (row && !seenIds.has(row.id)) {
+      seenIds.add(row.id);
+      if (row.source_type === 'agent' && row.source_id) {
+        row.source_id = row.source_id.toLowerCase();
+      }
+      uniqueRows.push(row);
+    }
+  }
+
+  return uniqueRows;
 }
 
 /**

package/src/search.js

@@ -13,7 +13,8 @@ import db, {
   getMemoryById,
   boostMemory,
   getProvenance,
-  getMemoriesByEntity
+  getMemoriesByEntity,
+  getAllEntities
 } from './database.js';
 import { generateEmbedding } from './embeddings.js';
 import { createAttestation } from './attestation.js';
@@ -31,7 +32,7 @@ let lastDataVersion = 0;
  * @param {string|null} sessionId - Session identifier
  * @returns {Promise<Array>} Ranked search results (with .attestation property attached)
  */
-export async function searchHybrid(queryText, limit = 5, agentId = null, sessionId = null, namespace = null) {
+export async function searchHybrid(queryText, limit = 5, agentId = null, sessionId = null, namespace = null, skipAttestation = false) {
   // Sync in-memory cache with external DB changes using sqlite data_version
   try {
     const currentDataVersion = db.pragma('data_version', { simple: true });
@@ -142,11 +143,12 @@ export async function searchHybrid(queryText, limit = 5, agentId = null, session
   // --- 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;
+  // Generate cryptographic attestation for audit trails (skip if called internally)
+  let attestation = null;
+  if (!skipAttestation) {
+    attestation = createAttestation(queryText, mmrResults, agentId, sessionId);
+    mmrResults.attestation = attestation;
+  }
 
   // --- Store in LRU cache (Feature 1) ---
   searchCache.set(cacheKey, mmrResults);
@@ -239,8 +241,18 @@ function jaccardSimilarity(a, b) {
  * @param {string|null} sessionId - Current session ID
  */
 export async function getOptimizedContext(queryText, maxTokens, agentId = null, sessionId = null, namespace = null) {
-  // 1. Run hybrid search to fetch top 20 memories (namespace-aware)
-  const searchHits = await searchHybrid(queryText, 20, agentId, sessionId, namespace);
+  // Extract entities mentioned in the query text to seed the graph search directly
+  const entities = getAllEntities(100);
+  const matchedEntityIds = new Set();
+  for (const ent of entities) {
+    const entNameLower = ent.name.toLowerCase();
+    if (queryText.toLowerCase().includes(entNameLower)) {
+      matchedEntityIds.add(ent.id);
+    }
+  }
+
+  // 1. Run hybrid search to fetch top 5 memories as seeds (skip attestation to avoid double-write)
+  const searchHits = await searchHybrid(queryText, 5, agentId, sessionId, namespace, true);
   const candidates = new Map();
 
   for (const hit of searchHits) {
@@ -254,63 +266,87 @@ export async function getOptimizedContext(queryText, maxTokens, agentId = null,
       provenance: hit.provenance,
       source: 'search'
     });
+  }
 
-    // 2. Perform Graph Hop (multi-hop traversal)
-    // Find all entities directly connected to this search hit memory
-    const hitEdges = db.prepare(`
-      SELECT * FROM edges 
-      WHERE (source_id = ? AND source_type = 'memory' AND target_type = 'entity')
-         OR (target_id = ? AND target_type = 'memory' AND source_type = 'entity')
-    `).all(hit.id, hit.id);
-
-    const startEntityIds = new Set();
-    for (const edge of hitEdges) {
-      if (edge.source_type === 'entity') startEntityIds.add(edge.source_id);
-      if (edge.target_type === 'entity') startEntityIds.add(edge.target_id);
+  // 2. Perform Graph Hop (multi-hop traversal) globally
+  const hopQueue = [];
+  const visitedNodes = new Set(); // Stores "type:id" keys
+
+  // Seed with matched entities from query text
+  for (const entId of matchedEntityIds) {
+    const key = `entity:${entId}`;
+    if (!visitedNodes.has(key)) {
+      visitedNodes.add(key);
+      hopQueue.push({ id: entId, type: 'entity', depth: 0 });
     }
+  }
 
-    // BFS to find connected entities up to depth 2 (entity -> entity -> entity)
-    const visitedEntities = new Set(startEntityIds);
-    const queue = Array.from(startEntityIds).map(id => ({ id, depth: 0 }));
-
-    while (queue.length > 0) {
-      const { id, depth } = queue.shift();
-      if (depth >= 2) continue;
-
-      const connectedEdges = db.prepare(`
-        SELECT * FROM edges 
-        WHERE (source_id = ? AND source_type = 'entity' AND target_type = 'entity')
-           OR (target_id = ? AND target_type = 'entity' AND source_type = 'entity')
-      `).all(id, id);
-
-      for (const edge of connectedEdges) {
-        const nextId = edge.source_id === id ? edge.target_id : edge.source_id;
-        if (!visitedEntities.has(nextId)) {
-          visitedEntities.add(nextId);
-          queue.push({ id: nextId, depth: depth + 1 });
-        }
+  // Seed with search hit memories
+  for (const hit of searchHits) {
+    const key = `memory:${hit.id}`;
+    if (!visitedNodes.has(key)) {
+      visitedNodes.add(key);
+      hopQueue.push({ id: hit.id, type: 'memory', depth: 0 });
+    }
+  }
+
+  // BFS to traverse memories and entities uniformly up to depth 4
+  while (hopQueue.length > 0) {
+    const { id, type, depth } = hopQueue.shift();
+    if (depth >= 4) continue;
+
+    const connectedEdges = db.prepare(`
+      SELECT * FROM edges 
+      WHERE (source_id = ? AND source_type = ?)
+         OR (target_id = ? AND target_type = ?)
+    `).all(id, type, id, type);
+
+    for (const edge of connectedEdges) {
+      let nextId, nextType;
+      if (edge.source_id === id && edge.source_type === type) {
+        nextId = edge.target_id;
+        nextType = edge.target_type;
+      } else {
+        nextId = edge.source_id;
+        nextType = edge.source_type;
+      }
+
+      const key = `${nextType}:${nextId}`;
+      if (!visitedNodes.has(key)) {
+        visitedNodes.add(key);
+        hopQueue.push({ id: nextId, type: nextType, depth: depth + 1 });
       }
     }
+  }
 
-    // Now collect all memories connected to any of the traversed entities
-    for (const entId of visitedEntities) {
-      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'
-        });
+  // Now collect all hopped memories from the visited nodes
+  for (const key of visitedNodes) {
+    const [type, idStr] = key.split(':');
+    if (type === 'memory') {
+      const memId = Number(idStr);
+      if (candidates.has(memId)) continue; // Keep search hit info
+
+      // Check namespace filter if present
+      const other = getMemoryById(memId, namespace);
+      if (!other) continue;
+
+      let baseScore = 0.4;
+      if (searchHits.length > 0) {
+        const maxSearchScore = Math.max(...searchHits.map(h => parseFloat(h.hybrid_score)));
+        baseScore = maxSearchScore * 0.5;
       }
+
+      const otherProv = getProvenance(memId);
+      candidates.set(memId, {
+        id: other.id,
+        content: other.content,
+        importance_score: other.importance_score,
+        created_at: other.created_at,
+        last_accessed: other.last_accessed,
+        score: baseScore,
+        provenance: otherProv,
+        source: 'hop'
+      });
     }
   }
 
@@ -460,7 +496,7 @@ export async function consolidateMemories(namespace = null) {
     for (const hit of hits) {
       if (visited.has(Number(hit.id))) continue;
       const sim = Math.max(0, 1 - (hit.distance * hit.distance) / 2);
-      if (sim > 0.85) {
+      if (sim > 0.80) {
         const other = db.prepare('SELECT * FROM memories WHERE id = ? AND valid_until IS NULL').get(Number(hit.id));
         if (other) {
           group.push(other);
@@ -481,7 +517,7 @@ export async function consolidateMemories(namespace = null) {
       };
 
       const groupWithTrust = group.map(m => ({ ...m, trust: getTrust(m) }));
-      groupWithTrust.sort((a, b) => b.trust - a.trust || b.importance_score - a.importance_score || b.id - a.id);
+      groupWithTrust.sort((a, b) => b.trust - a.trust || b.importance_score - a.importance_score || a.id - b.id);
 
       // Resolve the group sequentially
       let canonical = groupWithTrust[0];

package/src/tools.js

@@ -52,8 +52,8 @@ import { searchCache } from './cache.js';
 // CONSTANTS
 // ============================================================
 
-/** Maximum allowed memory content length (50,000 characters) */
-const MAX_MEMORY_CONTENT_LENGTH = 50000;
+/** Maximum allowed memory content length (10,000 characters) */
+const MAX_MEMORY_CONTENT_LENGTH = 10000;
 
 /** Minimum content length (must have actual content) */
 const MIN_MEMORY_CONTENT_LENGTH = 1;
@@ -304,12 +304,22 @@ export function registerTools(server) {
         const oldMemory = getMemory(id);
         if (!oldMemory) return text({ error: `Memory #${id} not found` });
 
+        // Retrieve old agent_id from provenance
+        const oldProv = getProvenance(id);
+        const resolvedAgentId = agent_id || (oldProv && oldProv.source_type === 'agent' ? oldProv.source_id : null);
+
         // Insert new version
-        const newId = insertMemory(content, oldMemory.importance_score, {
-          source_type: agent_id ? 'agent' : 'manual',
-          source_id: agent_id || null,
-          confidence: 1.0
-        });
+        const newId = insertMemory(
+          content,
+          oldMemory.importance_score,
+          {
+            source_type: resolvedAgentId ? 'agent' : 'manual',
+            source_id: resolvedAgentId,
+            confidence: 1.0
+          },
+          oldMemory.namespace || 'shared',
+          id
+        );
 
         const embedding = await generateEmbedding(content);
         insertVector(newId, embedding);
@@ -545,13 +555,29 @@ export function registerTools(server) {
           hits = searchAllMemoriesFts(query, 5);
         }
 
+        // Fallback to LIKE query on memories content if FTS is empty or fails
+        if (hits.length === 0) {
+          try {
+            const likeRows = db.prepare("SELECT id FROM memories WHERE content LIKE ? LIMIT 5").all(`%${query}%`);
+            hits = likeRows;
+          } catch (_) {}
+        }
+
         if (hits.length === 0) {
           return text({ message: 'No memories matching query found.' });
         }
 
         const histories = {};
+        const seenChainKeys = new Set();
         for (const hit of hits) {
           const chain = getMemoryHistoryChain(hit.id);
+          if (chain.length === 0) continue;
+
+          // Deduplicate chains to prevent duplicate entries in history response
+          const chainKey = chain.map(c => c.id).sort((a, b) => a - b).join(',');
+          if (seenChainKeys.has(chainKey)) continue;
+          seenChainKeys.add(chainKey);
+
           // Decorate chain versions with semantic diffs from the previous version
           for (let idx = 0; idx < chain.length; idx++) {
             if (idx > 0) {