persyst-mcp 2.2.1 → 2.2.3

package/bin/extract-worker.js

@@ -30,6 +30,8 @@ import {
 } from 'fs';
 import { fileURLToPath } from 'url';
 import { dirname } from 'path';
+import http from 'http';
+import https from 'https';
 
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
@@ -58,6 +60,331 @@ const DEDUP_SIMILARITY_THRESHOLD = 0.80;
 const RECENT_MEMORY_WINDOW_S = 60; // Check last 60 seconds for agent race
 const MIN_CONFIDENCE = 0.65;
 
+// ============================================================
+// LLM EXTRACTION PIPELINE (Tiers 1 & 2)
+// ============================================================
+
+const EXTRACTION_SYSTEM_PROMPT = `You are a precise developer memory extraction assistant.
+Analyze the following developer conversation turn or transcript and extract any:
+1. Explicit user preferences (e.g. "I prefer HSL colors", "I like clean UI")
+2. Architectural decisions (e.g. "We decided to expose a gateway server on port 4321")
+3. Project stack choices (e.g. "Using Node.js for backend")
+4. Coding rules/styles (e.g. "Always use camelCase for variables")
+5. Project config/settings (e.g. "Port is set to 4321")
+
+Do not extract temporary tasks, questions, or vague conversational statements.
+Do not invent facts. Only extract facts that are clearly stated or implied by the developer.
+
+You MUST respond with a valid JSON array of objects, and absolutely NOTHING else. No markdown formatting, no explanation.
+Each object must have the following fields:
+- "content": A clean, concise statement of the preference/decision (e.g., "Preference: Use HSL tailwind colors"). Start the content with the prefix indicating the category: "Preference: ...", "Decision: ...", "Stack: ...", "Rule: ...", "Config: ...".
+- "category": One of "preference", "decision", "stack", "naming", "architecture", "rule", "config".
+- "confidence": A float value between 0.65 and 1.0 representing your confidence.
+
+Example output:
+[
+  {
+    "content": "Preference: Always use vanilla CSS for maximum control.",
+    "category": "preference",
+    "confidence": 0.95
+  }
+]`;
+
+function parseJsonArray(text) {
+  try {
+    let clean = text.trim();
+    if (clean.startsWith('```json')) {
+      clean = clean.slice(7);
+    } else if (clean.startsWith('```')) {
+      clean = clean.slice(3);
+    }
+    if (clean.endsWith('```')) {
+      clean = clean.slice(0, -3);
+    }
+    clean = clean.trim();
+    const arr = JSON.parse(clean);
+    if (Array.isArray(arr)) return arr;
+    return [];
+  } catch (err) {
+    try {
+      const start = text.indexOf('[');
+      const end = text.lastIndexOf(']');
+      if (start !== -1 && end !== -1) {
+        const substring = text.slice(start, end + 1);
+        const arr = JSON.parse(substring);
+        if (Array.isArray(arr)) return arr;
+      }
+    } catch (_) {}
+    return [];
+  }
+}
+
+function extractAnthropic(text, apiKey) {
+  return new Promise((resolve, reject) => {
+    const payload = JSON.stringify({
+      model: 'claude-3-5-sonnet-20241022',
+      max_tokens: 1000,
+      system: EXTRACTION_SYSTEM_PROMPT,
+      messages: [
+        { role: 'user', content: `Extract facts from this transcript:\n\n${text}` }
+      ]
+    });
+
+    const req = https.request({
+      hostname: 'api.anthropic.com',
+      port: 443,
+      path: '/v1/messages',
+      method: 'POST',
+      headers: {
+        'x-api-key': apiKey,
+        'anthropic-version': '2023-06-01',
+        'content-type': 'application/json',
+        'content-length': Buffer.byteLength(payload)
+      },
+      timeout: 8000
+    });
+
+    req.on('response', (res) => {
+      let data = '';
+      res.on('data', chunk => { data += chunk; });
+      res.on('end', () => {
+        try {
+          const parsed = JSON.parse(data);
+          if (res.statusCode !== 200) {
+            reject(new Error(`Anthropic error: ${parsed.error?.message || data}`));
+            return;
+          }
+          const contentText = parsed.content?.[0]?.text || '';
+          resolve(parseJsonArray(contentText));
+        } catch (e) {
+          reject(e);
+        }
+      });
+    });
+
+    req.on('error', reject);
+    req.on('timeout', () => { req.destroy(); reject(new Error('Anthropic timeout')); });
+    req.write(payload);
+    req.end();
+  });
+}
+
+function extractOpenAI(text, apiKey) {
+  return new Promise((resolve, reject) => {
+    const payload = JSON.stringify({
+      model: 'gpt-4o-mini',
+      messages: [
+        { role: 'system', content: EXTRACTION_SYSTEM_PROMPT },
+        { role: 'user', content: `Extract facts from this transcript:\n\n${text}` }
+      ],
+      response_format: { type: 'json_object' }
+    });
+
+    const req = https.request({
+      hostname: 'api.openai.com',
+      port: 443,
+      path: '/v1/chat/completions',
+      method: 'POST',
+      headers: {
+        'Authorization': `Bearer ${apiKey}`,
+        'Content-Type': 'application/json',
+        'Content-Length': Buffer.byteLength(payload)
+      },
+      timeout: 8000
+    });
+
+    req.on('response', (res) => {
+      let data = '';
+      res.on('data', chunk => { data += chunk; });
+      res.on('end', () => {
+        try {
+          const parsed = JSON.parse(data);
+          if (res.statusCode !== 200) {
+            reject(new Error(`OpenAI error: ${parsed.error?.message || data}`));
+            return;
+          }
+          const contentText = parsed.choices?.[0]?.message?.content || '';
+          let obj = JSON.parse(contentText);
+          if (Array.isArray(obj)) {
+            resolve(obj);
+          } else if (obj && typeof obj === 'object') {
+            const key = Object.keys(obj).find(k => Array.isArray(obj[k]));
+            if (key) {
+              resolve(obj[key]);
+            } else {
+              resolve([]);
+            }
+          } else {
+            resolve([]);
+          }
+        } catch (e) {
+          reject(e);
+        }
+      });
+    });
+
+    req.on('error', reject);
+    req.on('timeout', () => { req.destroy(); reject(new Error('OpenAI timeout')); });
+    req.write(payload);
+    req.end();
+  });
+}
+
+function extractOllama(text, model) {
+  return new Promise((resolve, reject) => {
+    const payload = JSON.stringify({
+      model: model,
+      messages: [
+        { role: 'system', content: EXTRACTION_SYSTEM_PROMPT },
+        { role: 'user', content: `Extract facts from this transcript:\n\n${text}` }
+      ],
+      stream: false,
+      format: 'json'
+    });
+
+    const req = http.request({
+      hostname: '127.0.0.1',
+      port: 11434,
+      path: '/api/chat',
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        'Content-Length': Buffer.byteLength(payload)
+      },
+      timeout: 12000
+    });
+
+    req.on('response', (res) => {
+      let data = '';
+      res.on('data', chunk => { data += chunk; });
+      res.on('end', () => {
+        try {
+          if (res.statusCode !== 200) {
+            reject(new Error(`Ollama error: status ${res.statusCode}`));
+            return;
+          }
+          const parsed = JSON.parse(data);
+          const contentText = parsed.message?.content || '';
+          let obj = JSON.parse(contentText);
+          if (Array.isArray(obj)) {
+            resolve(obj);
+          } else if (obj && typeof obj === 'object') {
+            const key = Object.keys(obj).find(k => Array.isArray(obj[k]));
+            if (key) {
+              resolve(obj[key]);
+            } else {
+              resolve([]);
+            }
+          } else {
+            resolve([]);
+          }
+        } catch (e) {
+          reject(e);
+        }
+      });
+    });
+
+    req.on('error', reject);
+    req.on('timeout', () => { req.destroy(); reject(new Error('Ollama timeout')); });
+    req.write(payload);
+    req.end();
+  });
+}
+
+function checkOllamaAlive() {
+  return new Promise((resolve) => {
+    const req = http.request({
+      hostname: '127.0.0.1',
+      port: 11434,
+      path: '/api/tags',
+      method: 'GET',
+      timeout: 1000
+    });
+
+    req.on('response', (res) => {
+      if (res.statusCode === 200) {
+        let data = '';
+        res.on('data', chunk => { data += chunk; });
+        res.on('end', () => {
+          try {
+            const parsed = JSON.parse(data);
+            const models = parsed.models || [];
+            resolve({ alive: true, models: models.map(m => m.name) });
+          } catch (_) {
+            resolve({ alive: true, models: [] });
+          }
+        });
+      } else {
+        resolve({ alive: false });
+      }
+    });
+
+    req.on('error', () => {
+      resolve({ alive: false });
+    });
+
+    req.on('timeout', () => {
+      req.destroy();
+      resolve({ alive: false });
+    });
+
+    req.end();
+  });
+}
+
+async function extractFacts(text) {
+  // Try Anthropic first
+  if (process.env.ANTHROPIC_API_KEY) {
+    try {
+      log('INFO', 'Attempting Anthropic fact extraction...');
+      const facts = await extractAnthropic(text, process.env.ANTHROPIC_API_KEY);
+      log('INFO', `Anthropic extraction succeeded: extracted ${facts.length} facts.`);
+      return { facts, tier: 'anthropic' };
+    } catch (err) {
+      log('WARN', `Anthropic extraction failed: ${err.message}`);
+    }
+  }
+
+  // Try OpenAI second
+  if (process.env.OPENAI_API_KEY) {
+    try {
+      log('INFO', 'Attempting OpenAI fact extraction...');
+      const facts = await extractOpenAI(text, process.env.OPENAI_API_KEY);
+      log('INFO', `OpenAI extraction succeeded: extracted ${facts.length} facts.`);
+      return { facts, tier: 'openai' };
+    } catch (err) {
+      log('WARN', `OpenAI extraction failed: ${err.message}`);
+    }
+  }
+
+  // Try Ollama third
+  try {
+    const ollamaStatus = await checkOllamaAlive();
+    if (ollamaStatus.alive && ollamaStatus.models && ollamaStatus.models.length > 0) {
+      const targetModel = ollamaStatus.models.find(m => m.includes('qwen') || m.includes('coder') || m.includes('llama')) || ollamaStatus.models[0];
+      if (targetModel) {
+        log('INFO', `Attempting Ollama extraction using model: ${targetModel}...`);
+        const facts = await extractOllama(text, targetModel);
+        log('INFO', `Ollama extraction succeeded: extracted ${facts.length} facts.`);
+        return { facts, tier: \`ollama:\${targetModel}\` };
+      }
+    }
+  } catch (err) {
+    log('WARN', `Ollama extraction failed: ${err.message}`);
+  }
+
+  // Fallback to Heuristic
+  log('INFO', 'All LLM extraction options unavailable/failed. Falling back to Heuristic extraction.');
+  try {
+    const { extractHeuristic } = await import('../src/extractor-heuristic.js');
+    const heuristicFacts = extractHeuristic(text);
+    return { facts: heuristicFacts, tier: 'heuristic' };
+  } catch (err) {
+    log('ERROR', `Heuristic extraction fallback failed: ${err.message}`);
+    return { facts: [], tier: 'failed' };
+  }
+}
+
 
 
 // ============================================================
@@ -285,21 +612,10 @@ async function main() {
       try {
         log('INFO', `Processing: ${filename} (retry: ${retryCount})`);
 
-        const facts = [];
-        let heuristicFacts = [];
-
-        // 1. Run Tier 2 Heuristic Extraction (always safe, zero cost)
-        try {
-          const { extractHeuristic } = await import('../src/extractor-heuristic.js');
-          heuristicFacts = extractHeuristic(data.text);
-          for (const f of heuristicFacts) {
-            facts.push({ ...f, tier: 'heuristic' });
-          }
-        } catch (heurErr) {
-          log('ERROR', `Heuristic extraction failed: ${heurErr.message}`);
-        }
+        const { facts: extractedFacts, tier } = await extractFacts(data.text);
+        const facts = extractedFacts.map(f => ({ ...f, tier }));
 
-        log('INFO', `Extracted ${facts.length} heuristic fact(s)`);
+        log('INFO', `Extracted ${facts.length} fact(s) using tier: ${tier}`);
 
         // Deduplicate facts within this run
         const uniqueFacts = [];

package/bin/setup.js

@@ -61,6 +61,12 @@ const HOOK_CONFIG = {
       matcher: '',
       hooks: [{ ...HOOK_ENTRY, timeout: 10 }]
     }
+  ],
+  Stop: [
+    {
+      matcher: '',
+      hooks: [{ ...HOOK_ENTRY }]
+    }
   ]
 };
 

package/hooks/persyst-hook.js

@@ -33,6 +33,7 @@ import { dirname, resolve, join } from 'path';
 import { spawn } from 'child_process';
 import { writeFileSync, readdirSync, mkdirSync, existsSync } from 'fs';
 import { homedir } from 'os';
+import http from 'http';
 
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
@@ -85,6 +86,59 @@ function readStdin() {
 // MCP CLIENT CONNECTION
 // ============================================================
 
+let isHttpAvailable = true;
+let stdioClient = null;
+
+async function getStdioClient() {
+  if (stdioClient) return stdioClient;
+  stdioClient = await connectToPersyst();
+  return stdioClient;
+}
+
+function callToolViaHttp(toolName, args, timeoutMs = 150) {
+  return new Promise((resolve, reject) => {
+    const payload = JSON.stringify({ name: toolName, arguments: args });
+    const req = http.request({
+      hostname: '127.0.0.1',
+      port: 4321,
+      path: '/tool',
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        'Content-Length': Buffer.byteLength(payload)
+      }
+    });
+
+    req.setTimeout(timeoutMs, () => {
+      req.destroy();
+      reject(new Error('HTTP timeout'));
+    });
+
+    req.on('response', (res) => {
+      if (res.statusCode !== 200) {
+        reject(new Error(`HTTP status ${res.statusCode}`));
+        return;
+      }
+      let data = '';
+      res.on('data', chunk => { data += chunk; });
+      res.on('end', () => {
+        try {
+          resolve(JSON.parse(data));
+        } catch (e) {
+          reject(e);
+        }
+      });
+    });
+
+    req.on('error', (err) => {
+      reject(err);
+    });
+
+    req.write(payload);
+    req.end();
+  });
+}
+
 /**
  * Connect to the Persyst MCP server as a client.
  * Uses StdioClientTransport to spawn and communicate with the server.
@@ -121,7 +175,20 @@ async function connectToPersyst() {
  * Call a Persyst MCP tool and parse the JSON result.
  */
 async function callTool(client, toolName, args) {
-  const result = await client.callTool({ name: toolName, arguments: args });
+  if (isHttpAvailable) {
+    try {
+      const httpResult = await callToolViaHttp(toolName, args, 150);
+      if (httpResult && httpResult.content && httpResult.content[0] && httpResult.content[0].text) {
+        return JSON.parse(httpResult.content[0].text);
+      }
+    } catch (err) {
+      isHttpAvailable = false;
+      process.stderr.write(`[persyst-hook] HTTP Gateway call failed (${err.message}). Falling back to stdio client.\n`);
+    }
+  }
+
+  const activeClient = await getStdioClient();
+  const result = await activeClient.callTool({ name: toolName, arguments: args });
   if (result.content && result.content[0] && result.content[0].text) {
     return JSON.parse(result.content[0].text);
   }
@@ -360,8 +427,6 @@ async function handleStop(input) {
 // ============================================================
 
 async function main() {
-  let client = null;
-
   try {
     const input = await readStdin();
     const eventName = input.hook_event_name;
@@ -379,17 +444,15 @@ async function main() {
       return;
     }
 
-    // Connect to Persyst with hard timeout
     const hookStart = Date.now();
-    client = await connectToPersyst();
 
     let response;
     if (eventName === 'SessionStart') {
-      response = await handleSessionStart(client, input);
+      response = await handleSessionStart(null, input);
     } else if (eventName === 'UserPromptSubmit') {
       // Apply hard timeout for prompt-time hook execution
       response = await Promise.race([
-        handleUserPromptSubmit(client, input),
+        handleUserPromptSubmit(null, input),
         new Promise((resolve) =>
           setTimeout(() => {
             process.stderr.write(`[persyst-hook] UserPromptSubmit hit ${MAX_HOOK_LATENCY_MS}ms timeout, returning partial.\n`);
@@ -409,8 +472,8 @@ async function main() {
     console.log(JSON.stringify({}));
   } finally {
     // Clean up MCP connection
-    if (client) {
-      try { await client.close(); } catch (_) {}
+    if (stdioClient) {
+      try { await stdioClient.close(); } catch (_) {}
     }
     process.exit(0);
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "persyst-mcp",
-  "version": "2.2.1",
+  "version": "2.2.3",
   "description": "Local-first MCP memory server with hybrid keyword + semantic search for coding agents",
   "type": "module",
   "main": "index.js",
@@ -27,7 +27,7 @@
   "scripts": {
     "start": "node index.js",
     "test": "cross-env NODE_ENV=test node test/smoke.js",
-    "test:heavy": "cross-env NODE_ENV=test node --test test/test_*.js",
+    "test:heavy": "cross-env NODE_ENV=test node --test --test-concurrency=1 test/test_*.js",
     "worker": "node bin/extract-worker.js",
     "extract": "node bin/extract.js"
   },

package/src/database.js

@@ -288,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'
@@ -544,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;
 }
@@ -769,9 +775,11 @@ 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
+  // Set parent_id to link memories for bidirectional history tracing (always newer pointing to older)
   try {
-    db.prepare('UPDATE memories SET parent_id = ? WHERE id = ?').run(oldMemoryId, newMemoryId);
+    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}`);
   }
@@ -812,6 +820,9 @@ export function getProvenance(memoryId) {
  */
 export function incrementAgentStat(agentId, action) {
   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(normalizedAgentId);
@@ -910,26 +921,28 @@ 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);
 
-  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);
+    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 uniqueRows;
+  return rows;
 }
 
 /**

package/src/search.js

@@ -290,11 +290,12 @@ export async function getOptimizedContext(queryText, maxTokens, agentId = null,
     }
   }
 
-  // BFS to traverse memories and entities uniformly up to depth 4
+  // BFS to traverse memories and entities uniformly up to depth 6
   while (hopQueue.length > 0) {
     const { id, type, depth } = hopQueue.shift();
-    if (depth >= 4) continue;
+    if (depth >= 6) continue;
 
+    // --- 2a. Explicit Graph Edges (from edges table) ---
     const connectedEdges = db.prepare(`
       SELECT * FROM edges 
       WHERE (source_id = ? AND source_type = ?)
@@ -317,6 +318,35 @@ export async function getOptimizedContext(queryText, maxTokens, agentId = null,
         hopQueue.push({ id: nextId, type: nextType, 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 hopped memories from the visited nodes
@@ -444,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' };
   }
 
@@ -489,7 +519,7 @@ 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 = [];

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,122 @@ 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.on('error', (err) => {
+    if (err.code === 'EADDRINUSE') {
+      console.error(`[persyst] HTTP Gateway port ${httpPort} is already in use. Stdio MCP server will continue running.`);
+    } else {
+      console.error('[persyst] HTTP Gateway 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 +160,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);
   };

package/src/tools.js

@@ -33,6 +33,7 @@ import db, {
   boostMemory,
   logContradiction,
   getProvenance,
+  incrementAgentStat,
   getAllAgentStats,
   getAttestationsByDateRange,
   getMemoryHistoryChain,
@@ -99,6 +100,148 @@ function validateMemoryContent(content) {
   return { valid: true };
 }
 
+/**
+ * Internal logic for storing a new memory (dedup, vector creation, contradiction detection).
+ * Shared by both the stdio MCP tool and the HTTP Gateway server.
+ */
+export async function addMemoryInternal({ content, importance = 1.0, agent_id, session_id, shared = true }) {
+  try {
+    const normalizedAgentId = agent_id ? agent_id.toLowerCase() : null;
+
+    // Bug 7 + Feature 4: Validate content size
+    const validation = validateMemoryContent(content);
+    if (!validation.valid) {
+      return { error: validation.error };
+    }
+
+    // Derive namespace from agent_id and shared flag
+    const namespace = (shared || !normalizedAgentId) ? 'shared' : normalizedAgentId;
+
+    // Deduplication check (namespace-aware)
+    const existing = getMemoryByContent(content, namespace);
+    if (existing) {
+      // Re-attribute provenance to the calling agent if it was previously auto-attributed to log-watcher
+      const prov = getProvenance(existing.id);
+      if (prov && (prov.source_id === 'antigravity-worker' || prov.source_id === 'user-dialogue') && normalizedAgentId) {
+        try {
+          db.prepare("UPDATE provenance SET source_type = 'agent', source_id = ?, confidence = 1.0 WHERE memory_id = ?")
+            .run(normalizedAgentId, existing.id);
+          incrementAgentStat(normalizedAgentId, 'created');
+        } catch (e) {
+          console.error(`[persyst] Re-attribute provenance error: ${e.message}`);
+        }
+      }
+      boostMemory(existing.id);
+      return {
+        success: true,
+        id: existing.id,
+        namespace,
+        message: `Memory #${existing.id} already exists. Boosted importance.`
+      };
+    }
+
+    const id = insertMemory(content, importance, {
+      source_type: normalizedAgentId ? 'agent' : 'manual',
+      source_id: normalizedAgentId,
+      confidence: 1.0
+    }, namespace);
+
+    const embedding = await generateEmbedding(content);
+    insertVector(id, embedding);
+
+    // Feature 1: Invalidate search cache on write
+    searchCache.invalidate();
+
+    // Feature 2: Contradiction Detection
+    let contradictions = [];
+    try {
+      const similarHits = searchVector(embedding, 20);
+      for (const hit of similarHits) {
+        const hitId = Number(hit.rowid);
+        if (hitId === id) continue; // Skip self
+
+        const sim = Math.max(0, 1 - (hit.distance * hit.distance) / 2);
+        if (sim > 0.70) {
+          const existingMemory = getMemoryById(hitId, namespace);
+          if (!existingMemory) continue;
+
+          const jaccard = jaccardDistance(content, existingMemory.content);
+          // Contradiction: similar topic (high similarity), but differing key terms
+          if (jaccard > 0 && jaccard < 0.65) {
+            // Fetch provenances for trust calculation
+            const oldProv = getProvenance(hitId);
+            let oldReputation = 1.0;
+            if (oldProv && oldProv.source_type === 'agent' && oldProv.source_id) {
+              const agentRow = db.prepare('SELECT reputation_score FROM agent_stats WHERE agent_id = ?').get(oldProv.source_id);
+              if (agentRow) oldReputation = agentRow.reputation_score;
+            }
+
+            let newReputation = 1.0;
+            if (normalizedAgentId) {
+              const agentRow = db.prepare('SELECT reputation_score FROM agent_stats WHERE agent_id = ?').get(normalizedAgentId);
+              if (agentRow) newReputation = agentRow.reputation_score;
+            }
+
+            const trustOld = (oldProv ? oldProv.confidence : 1.0) * oldReputation;
+            const trustNew = 1.0 * newReputation; // New confidence is 1.0
+
+            const isSelfUpdate = oldProv && oldProv.source_type === 'agent' && oldProv.source_id === normalizedAgentId;
+
+            if (isSelfUpdate || trustNew > trustOld) {
+              // New is preferred
+              logContradiction(hitId, id, `Auto-detected contradiction: new memory is more trustworthy (similarity: ${sim.toFixed(3)}, content_diff: ${jaccard.toFixed(3)})`);
+              contradictions.push({
+                old_memory_id: hitId,
+                old_content_preview: existingMemory.content.slice(0, 100),
+                similarity: sim.toFixed(4),
+                content_difference: jaccard.toFixed(4),
+                resolution: 'replaced_old'
+              });
+            } else {
+              // Old is preferred
+              logContradiction(id, hitId, `Auto-detected contradiction: existing memory is more trustworthy (similarity: ${sim.toFixed(3)}, content_diff: ${jaccard.toFixed(3)})`);
+              contradictions.push({
+                old_memory_id: hitId,
+                old_content_preview: existingMemory.content.slice(0, 100),
+                similarity: sim.toFixed(4),
+                content_difference: jaccard.toFixed(4),
+                resolution: 'kept_old'
+              });
+              break; // New memory was archived, stop contradiction check
+            }
+          }
+        }
+      }
+    } catch (e) {
+      console.error(`[persyst] Contradiction detection error: ${e.message}`);
+    }
+
+    const result = { success: true, id, namespace, message: `Memory #${id} stored` };
+    if (contradictions.length > 0) {
+      result.contradictions_detected = contradictions;
+      result.message += `. Detected ${contradictions.length} contradiction(s) — older memories archived.`;
+    }
+
+    return result;
+  } catch (err) {
+    return { error: err.message };
+  }
+}
+
+const toolHandlers = new Map();
+
+/**
+ * Programmatically execute any registered MCP tool.
+ * Used by the HTTP Gateway server to route requests to tool handlers.
+ */
+export async function executeToolInternal(name, args) {
+  const handler = toolHandlers.get(name);
+  if (!handler) {
+    throw new Error(`Tool ${name} not found`);
+  }
+  return await handler(args);
+}
+
 /**
  * Register all MCP tools on the server.
  * @param {McpServer} server - The MCP server instance
@@ -108,6 +251,11 @@ export function registerTools(server) {
   let count = 0;
   const originalTool = server.tool.bind(server);
   server.tool = (...args) => {
+    const name = args[0];
+    const handler = args[args.length - 1];
+    if (typeof handler === 'function') {
+      toolHandlers.set(name, handler);
+    }
     originalTool(...args);
     count++;
   };
@@ -128,114 +276,11 @@ export function registerTools(server) {
       shared: z.boolean().default(true).describe('If true, memory is visible to all agents. If false, only visible to this agent.')
     },
     async ({ content, importance, agent_id, session_id, shared }) => {
-      try {
-        // Bug 7 + Feature 4: Validate content size
-        const validation = validateMemoryContent(content);
-        if (!validation.valid) {
-          return text({ error: validation.error });
-        }
-
-        // Derive namespace from agent_id and shared flag
-        const namespace = (shared || !agent_id) ? 'shared' : agent_id;
-
-        // Deduplication check (namespace-aware)
-        const existing = getMemoryByContent(content, namespace);
-        if (existing) {
-          boostMemory(existing.id);
-          return text({
-            success: true,
-            id: existing.id,
-            namespace,
-            message: `Memory #${existing.id} already exists. Boosted importance.`
-          });
-        }
-
-        const id = insertMemory(content, importance, {
-          source_type: agent_id ? 'agent' : 'manual',
-          source_id: agent_id || null,
-          confidence: 1.0
-        }, namespace);
-
-        const embedding = await generateEmbedding(content);
-        insertVector(id, embedding);
-
-        // Feature 1: Invalidate search cache on write
-        searchCache.invalidate();
-
-        // Feature 2: Contradiction Detection
-        let contradictions = [];
-        try {
-          const similarHits = searchVector(embedding, 3);
-          for (const hit of similarHits) {
-            const hitId = Number(hit.rowid);
-            if (hitId === id) continue; // Skip self
-
-            const sim = Math.max(0, 1 - (hit.distance * hit.distance) / 2);
-            if (sim > 0.75) {
-              const existingMemory = getMemoryById(hitId, namespace);
-              if (!existingMemory) continue;
-
-              const jaccard = jaccardDistance(content, existingMemory.content);
-              // Contradiction: similar topic (high similarity), but differing key terms
-              if (jaccard > 0 && jaccard < 0.5) {
-                // Fetch provenances for trust calculation
-                const oldProv = getProvenance(hitId);
-                let oldReputation = 1.0;
-                if (oldProv && oldProv.source_type === 'agent' && oldProv.source_id) {
-                  const agentRow = db.prepare('SELECT reputation_score FROM agent_stats WHERE agent_id = ?').get(oldProv.source_id);
-                  if (agentRow) oldReputation = agentRow.reputation_score;
-                }
-
-                let newReputation = 1.0;
-                if (agent_id) {
-                  const agentRow = db.prepare('SELECT reputation_score FROM agent_stats WHERE agent_id = ?').get(agent_id);
-                  if (agentRow) newReputation = agentRow.reputation_score;
-                }
-
-                const trustOld = (oldProv ? oldProv.confidence : 1.0) * oldReputation;
-                const trustNew = 1.0 * newReputation; // New confidence is 1.0
-
-                const isSelfUpdate = oldProv && oldProv.source_type === 'agent' && oldProv.source_id === agent_id;
-
-                if (isSelfUpdate || trustNew > trustOld) {
-                  // New is preferred
-                  logContradiction(hitId, id, `Auto-detected contradiction: new memory is more trustworthy (similarity: ${sim.toFixed(3)}, content_diff: ${jaccard.toFixed(3)})`);
-                  contradictions.push({
-                    old_memory_id: hitId,
-                    old_content_preview: existingMemory.content.slice(0, 100),
-                    similarity: sim.toFixed(4),
-                    content_difference: jaccard.toFixed(4),
-                    resolution: 'replaced_old'
-                  });
-                } else {
-                  // Old is preferred
-                  logContradiction(id, hitId, `Auto-detected contradiction: existing memory is more trustworthy (similarity: ${sim.toFixed(3)}, content_diff: ${jaccard.toFixed(3)})`);
-                  contradictions.push({
-                    old_memory_id: hitId,
-                    old_content_preview: existingMemory.content.slice(0, 100),
-                    similarity: sim.toFixed(4),
-                    content_difference: jaccard.toFixed(4),
-                    resolution: 'kept_old'
-                  });
-                  break; // New memory was archived, stop contradiction check
-                }
-              }
-            }
-          }
-        } catch (e) {
-          console.error(`[persyst] Contradiction detection error: ${e.message}`);
-        }
-
-        const result = { success: true, id, namespace, message: `Memory #${id} stored` };
-        if (contradictions.length > 0) {
-          result.contradictions_detected = contradictions;
-          result.message += `. Detected ${contradictions.length} contradiction(s) — older memories archived.`;
-        }
-
-        return text(result);
-      } catch (err) {
-        return text({ error: err.message });
+      const res = await addMemoryInternal({ content, importance, agent_id, session_id, shared });
+      if (res.error) {
+        return text({ error: res.error });
       }
+      return text(res);
     }
   );
 
@@ -295,6 +340,8 @@ export function registerTools(server) {
     },
     async ({ id, content, agent_id }) => {
       try {
+        const normalizedAgentId = agent_id ? agent_id.toLowerCase() : null;
+
         // Bug 7 + Feature 4: Validate content size
         const validation = validateMemoryContent(content);
         if (!validation.valid) {
@@ -306,7 +353,7 @@ export function registerTools(server) {
 
         // Retrieve old agent_id from provenance
         const oldProv = getProvenance(id);
-        const resolvedAgentId = agent_id || (oldProv && oldProv.source_type === 'agent' ? oldProv.source_id : null);
+        const resolvedAgentId = normalizedAgentId || (oldProv && oldProv.source_type === 'agent' ? oldProv.source_id : null);
 
         // Insert new version
         const newId = insertMemory(