persyst-mcp 2.2.0 → 2.2.2

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 (?, ?)'
@@ -283,7 +288,7 @@ const stmts = {
     "SELECT * FROM memories WHERE (namespace = ? OR namespace = 'shared') AND valid_until IS NULL ORDER BY importance_score DESC LIMIT ?"
   ),
   getProvenance: db.prepare(
-    'SELECT * FROM provenance WHERE memory_id = ?'
+    'SELECT * FROM provenance WHERE memory_id = ? ORDER BY id DESC'
   ),
   getAllAgentStats: db.prepare(
     'SELECT * FROM agent_stats ORDER BY reputation_score DESC'
@@ -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);
@@ -533,6 +544,12 @@ export function deleteVec(id) {
 export function deleteMemory(id) {
   stmts.deleteEdgesByMemory.run(id, id);
   deleteVec(id);  // Remove vector first (no cascades on virtual tables)
+  try {
+    db.prepare('DELETE FROM provenance WHERE memory_id = ?').run(id);
+    db.prepare('DELETE FROM contradictions WHERE old_memory_id = ? OR new_memory_id = ?').run(id, id);
+  } catch (e) {
+    console.error(`[persyst] Clean up provenance/contradictions error: ${e.message}`);
+  }
   const result = stmts.deleteMemory.run(id);
   return result.changes > 0;
 }
@@ -758,14 +775,23 @@ 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 (always newer pointing to older)
+  try {
+    const parentId = Math.min(oldMemoryId, newMemoryId);
+    const childId = Math.max(oldMemoryId, newMemoryId);
+    db.prepare('UPDATE memories SET parent_id = ? WHERE id = ?').run(parentId, childId);
+  } 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 +808,30 @@ 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();
+  if (normalizedAgentId === 'antigravity-worker' || normalizedAgentId === 'user-dialogue') {
+    return; // Ignore internal/system identities from reputation penalties
+  }
+  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 +891,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);
@@ -875,13 +921,27 @@ export function getMemoryHistoryChain(memoryId) {
 
   const placeholders = ids.map(() => '?').join(',');
   const rows = db.prepare(`
-    SELECT m.*, p.source_type, p.source_id, p.confidence 
-    FROM memories m
-    LEFT JOIN provenance p ON m.id = p.memory_id
-    WHERE m.id IN (${placeholders})
-    ORDER BY m.created_at ASC
+    SELECT * FROM memories
+    WHERE id IN (${placeholders})
+    ORDER BY created_at ASC
   `).all(...ids);
 
+  for (const row of rows) {
+    const prov = getProvenance(row.id);
+    if (prov) {
+      row.source_type = prov.source_type;
+      row.source_id = prov.source_id;
+      row.confidence = prov.confidence;
+    } else {
+      row.source_type = 'manual';
+      row.source_id = null;
+      row.confidence = 1.0;
+    }
+    if (row.source_type === 'agent' && row.source_id) {
+      row.source_id = row.source_id.toLowerCase();
+    }
+  }
+
   return rows;
 }
 

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,117 @@ export async function getOptimizedContext(queryText, maxTokens, agentId = null,
       provenance: hit.provenance,
       source: 'search'
     });
+  }
+
+  // 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 });
+    }
+  }
+
+  // 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 6
+  while (hopQueue.length > 0) {
+    const { id, type, depth } = hopQueue.shift();
+    if (depth >= 6) continue;
 
-    // 2. Perform Graph Hop (multi-hop traversal)
-    // Find all entities directly connected to this search hit memory
-    const hitEdges = db.prepare(`
+    // --- 2a. Explicit Graph Edges (from edges table) ---
+    const connectedEdges = 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);
+      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 });
+      }
     }
 
-    // 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 });
+    // --- 2b. Implicit Name-Based Edges (for robustness when explicit edges are missing) ---
+    if (type === 'memory') {
+      const memoryRow = db.prepare('SELECT content FROM memories WHERE id = ?').get(id);
+      if (memoryRow && memoryRow.content) {
+        const contentLower = memoryRow.content.toLowerCase();
+        for (const ent of entities) {
+          if (contentLower.includes(ent.name.toLowerCase())) {
+            const nextKey = `entity:${ent.id}`;
+            if (!visitedNodes.has(nextKey)) {
+              visitedNodes.add(nextKey);
+              hopQueue.push({ id: ent.id, type: 'entity', depth: depth + 1 });
+            }
+          }
+        }
+      }
+    } else if (type === 'entity') {
+      const ent = entities.find(e => e.id === id);
+      if (ent && ent.name) {
+        const matchingMemories = db.prepare('SELECT id FROM memories WHERE content LIKE ? AND valid_until IS NULL').all(`%${ent.name}%`);
+        for (const row of matchingMemories) {
+          const nextKey = `memory:${row.id}`;
+          if (!visitedNodes.has(nextKey)) {
+            visitedNodes.add(nextKey);
+            hopQueue.push({ id: row.id, type: 'memory', 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'
+      });
     }
   }
 
@@ -408,7 +474,7 @@ function checkRelationship(a, b) {
   }
 
   // Contradiction: similar topic, differing key terms
-  if (jaccard > 0.15 && jaccard < 0.5) {
+  if (jaccard > 0.15 && jaccard < 0.65) {
     return { type: 'contradiction' };
   }
 
@@ -453,14 +519,14 @@ export async function consolidateMemories(namespace = null) {
       SELECT rowid AS id, distance
       FROM memories_vec
       WHERE embedding MATCH ?
-      AND k = 10
+      AND k = 30
     `).all(embedding.embedding);
 
     const group = [];
     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 +547,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/server.js

@@ -1,30 +1,30 @@
 /**
- * server.js — MCP Server Setup
+ * server.js — MCP Server & Local HTTP Gateway Setup
  * 
- * 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.
+ * Creates the MCP server, registers all tools, and connects via stdio.
+ * Also spins up a local HTTP/JSON Gateway on port 4321 to support low-latency
+ * prompt hooks and local agent swarms without subprocess overhead.
  * 
- * IMPORTANT: Never write to stdout — it's reserved for MCP protocol.
  * All logging goes to stderr via console.error().
  */
 
+import http from 'http';
 import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
-import { registerTools, cleanupWatchers } from './tools.js';
+import { registerTools, cleanupWatchers, addMemoryInternal, executeToolInternal } from './tools.js';
 import { applyTemporalDecay, closeDatabase } from './database.js';
-import { consolidateMemories } from './search.js';
+import { consolidateMemories, searchHybrid, getOptimizedContext } from './search.js';
 import { startWatcher, stopWatcher } from './watcher.js';
+import { verifyChainIntegrity } from './attestation.js';
 
 /**
- * Start the Persyst MCP server.
- * This is called from index.js (the entry point).
+ * Start the Persyst MCP server & HTTP Gateway.
  */
 export async function startServer() {
   // --- Create MCP server ---
   const server = new McpServer({
     name: 'persyst',
-    version: '2.1.3'
+    version: '2.2.1'
   });
 
   // --- Register all tools ---
@@ -34,12 +34,114 @@ export async function startServer() {
   // --- Start background log watcher daemon ---
   startWatcher();
 
+  // --- Start local HTTP Gateway (port 4321) ---
+  const httpPort = 4321;
+  const httpServer = http.createServer((req, res) => {
+    // CORS headers for local swarms and browser testing
+    res.setHeader('Access-Control-Allow-Origin', '*');
+    res.setHeader('Access-Control-Allow-Methods', 'POST, GET, OPTIONS');
+    res.setHeader('Access-Control-Allow-Headers', 'Content-Type');
+
+    if (req.method === 'OPTIONS') {
+      res.writeHead(204);
+      res.end();
+      return;
+    }
+
+    if (req.method !== 'POST') {
+      res.writeHead(405, { 'Content-Type': 'application/json' });
+      res.end(JSON.stringify({ error: 'Method Not Allowed. Use POST.' }));
+      return;
+    }
+
+    let body = '';
+    req.on('data', chunk => { body += chunk; });
+    req.on('end', async () => {
+      try {
+        const payload = JSON.parse(body || '{}');
+
+        if (req.url === '/search') {
+          const { query, limit = 5, agent_id, session_id } = payload;
+          if (!query) {
+            res.writeHead(400, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({ error: 'Missing required field: query' }));
+            return;
+          }
+          const results = await searchHybrid(query, limit, agent_id, session_id, agent_id || null);
+          res.writeHead(200, { 'Content-Type': 'application/json' });
+          res.end(JSON.stringify({ success: true, results }));
+          return;
+        }
+
+        if (req.url === '/add') {
+          const { content, importance = 1.0, agent_id, session_id, shared = true } = payload;
+          if (!content) {
+            res.writeHead(400, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({ error: 'Missing required field: content' }));
+            return;
+          }
+          const result = await addMemoryInternal({ content, importance, agent_id, session_id, shared });
+          if (result.error) {
+            res.writeHead(400, { 'Content-Type': 'application/json' });
+          } else {
+            res.writeHead(200, { 'Content-Type': 'application/json' });
+          }
+          res.end(JSON.stringify(result));
+          return;
+        }
+
+        if (req.url === '/context') {
+          const { query, max_tokens = 2000, agent_id, session_id } = payload;
+          if (!query) {
+            res.writeHead(400, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({ error: 'Missing required field: query' }));
+            return;
+          }
+          const context = await getOptimizedContext(query, max_tokens, agent_id, session_id);
+          res.writeHead(200, { 'Content-Type': 'application/json' });
+          res.end(JSON.stringify(context));
+          return;
+        }
+
+        if (req.url === '/tool') {
+          const { name, arguments: args } = payload;
+          if (!name) {
+            res.writeHead(400, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({ error: 'Missing required field: name' }));
+            return;
+          }
+          const result = await executeToolInternal(name, args || {});
+          res.writeHead(200, { 'Content-Type': 'application/json' });
+          res.end(JSON.stringify(result));
+          return;
+        }
+
+        if (req.url === '/verify') {
+          const result = await verifyChainIntegrity();
+          res.writeHead(200, { 'Content-Type': 'application/json' });
+          res.end(JSON.stringify(result));
+          return;
+        }
+
+        res.writeHead(404, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify({ error: 'Endpoint Not Found' }));
+      } catch (err) {
+        res.writeHead(500, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify({ error: err.message }));
+      }
+    });
+  });
+
+  httpServer.listen(httpPort, '127.0.0.1', () => {
+    console.error(`[persyst] HTTP Gateway listening on http://127.0.0.1:${httpPort} ✓`);
+  });
+
   // --- Start temporal decay timer ---
   // Runs every hour: reduces importance of memories not accessed in 7+ days
   const decayTimer = setInterval(applyTemporalDecay, 3600000);
 
   // --- Start daily consolidation sweep ---
-  // Runs every 24 hours: merges similar memories (similarity > 0.85)
+  // Runs every 24 hours: merges similar memories
   const consolidationTimer = setInterval(async () => {
     console.error('[persyst] Running scheduled daily memory consolidation sweep...');
     try {
@@ -50,13 +152,14 @@ export async function startServer() {
     }
   }, 86400000);
 
-  // --- Graceful shutdown (Bug 3 fix: also cleans up git watchers) ---
+  // --- Graceful shutdown ---
   const shutdown = () => {
     console.error('[persyst] Shutting down...');
     clearInterval(decayTimer);
     clearInterval(consolidationTimer);
     stopWatcher();      // Stop background log watcher
-    cleanupWatchers();  // Bug 3 fix: stop all git repo watchers
+    cleanupWatchers();  // Stop all git repo watchers
+    httpServer.close(); // Close HTTP gateway
     closeDatabase();
     process.exit(0);
   };