specmem-hardwicksoftware 3.7.13 → 3.7.15

package/dist/commands/promptCommands.js

@@ -174,8 +174,8 @@ export class PromptCommands {
           category VARCHAR(100) DEFAULT 'general',
           tags TEXT[] DEFAULT '{}',
           variables TEXT[] DEFAULT '{}',
-          -- NOTE: Dimension is auto-detected from memories table, unbounded initially
-          embedding vector,
+          -- Dimension must be specified for ivfflat index
+          embedding vector(384),
           usage_count INTEGER DEFAULT 0,
           created_at TIMESTAMPTZ NOT NULL DEFAULT NOW(),
           updated_at TIMESTAMPTZ NOT NULL DEFAULT NOW()

package/dist/config/configSync.js

@@ -47,7 +47,9 @@ function getSpecmemDir() {
     // Otherwise we're in src/config
     return path.resolve(currentDir, '..', '..');
 }
-const BOOTSTRAP_PATH = path.join(getSpecmemDir(), 'bootstrap.cjs');
+// Prefer proxy for resilient MCP connections (auto-reconnect on crash)
+const _proxyPath = path.join(getSpecmemDir(), 'mcp-proxy.cjs');
+const BOOTSTRAP_PATH = fs.existsSync(_proxyPath) ? _proxyPath : path.join(getSpecmemDir(), 'bootstrap.cjs');
 const SOURCE_HOOKS_DIR = path.join(getSpecmemDir(), 'claude-hooks');
 const SOURCE_COMMANDS_DIR = path.join(getSpecmemDir(), 'commands');
 // ============================================================================

package/dist/init/claudeConfigInjector.js

@@ -97,8 +97,11 @@ function getSpecmemRoot() {
     // 6. Last resort - return __dirname-based path even without bootstrap
     return fromThisFile;
 }
-// Find the actual bootstrap file (cjs or js)
+// Find the MCP entry point — prefer proxy for resilient connections
 function findBootstrapPath(root) {
+    // Proxy wraps bootstrap.cjs with auto-reconnect on crash
+    const proxy = path.join(root, 'mcp-proxy.cjs');
+    if (fs.existsSync(proxy)) return proxy;
     for (const name of ['bootstrap.cjs', 'bootstrap.js']) {
         const p = path.join(root, name);
         if (fs.existsSync(p)) return p;

package/dist/mcp/embeddingServerManager.js

@@ -1661,6 +1661,20 @@ export class EmbeddingServerManager extends EventEmitter {
                             }, '[EmbeddingServerManager] SAFETY CHECK: Process command line does not match this project - skipping kill');
                             continue;
                         }
+                        // CRITICAL FIX: Never kill --service mode processes based on age
+                        // Service mode is meant to run indefinitely
+                        const isServiceMode = commandLine.includes('--service');
+                        if (isServiceMode) {
+                            logger.info({
+                                pid,
+                                ageHours: ageHours?.toFixed(2) || 'unknown',
+                                socketPath: this.socketPath,
+                            }, '[EmbeddingServerManager] Orphaned --service process found - KEEPING (service mode runs indefinitely)');
+                            // Adopt it instead of killing
+                            this.isRunning = true;
+                            this.process = { pid };
+                            continue;
+                        }
                         // Only kill if older than max age
                         if (ageHours !== null && ageHours <= this.config.maxProcessAgeHours) {
                             logger.info({
@@ -1819,6 +1833,12 @@ export class EmbeddingServerManager extends EventEmitter {
             statusMessage: healthInfo.statusMessage,
         }, '[EmbeddingServerManager] Checked PID file process');
         if (healthInfo.processExists) {
+            // Respect recommended action — don't kill healthy/service processes
+            if (healthInfo.recommendedAction === 'keep') {
+                logger.info({ pid: healthInfo.pid, status: healthInfo.statusMessage },
+                    '[EmbeddingServerManager] killByPidFile: Process is healthy/service - keeping');
+                return;
+            }
             await this.killProcessWithHealthInfo(healthInfo);
         }
         else {

package/dist/utils/processHealthCheck.js

@@ -119,7 +119,10 @@ export function checkProcessHealth(config) {
     // Step 4: Determine if stale
     // Use actual process age if available, otherwise fall back to PID file age
     const effectiveAgeHours = processAgeHours !== null ? processAgeHours : pidFileAgeHours;
-    const isStale = effectiveAgeHours > maxAgeHours;
+    // CRITICAL FIX: --service mode processes are meant to run indefinitely
+    // They should NEVER be considered stale based on age alone
+    const isServiceMode = commandLine && commandLine.includes('--service');
+    const isStale = isServiceMode ? false : effectiveAgeHours > maxAgeHours;
     // Step 5: Determine recommended action
     let recommendedAction = 'keep';
     let statusMessage = '';
@@ -137,7 +140,9 @@ export function checkProcessHealth(config) {
     }
     else {
         recommendedAction = 'keep';
-        statusMessage = `Process ${pid} is healthy (${effectiveAgeHours.toFixed(2)}h old)`;
+        statusMessage = isServiceMode
+            ? `Process ${pid} is healthy service-mode (${effectiveAgeHours.toFixed(2)}h old, age check bypassed)`
+            : `Process ${pid} is healthy (${effectiveAgeHours.toFixed(2)}h old)`;
     }
     logger.info({
         pid,

package/mcp-proxy.cjs

@@ -0,0 +1,336 @@
+#!/usr/bin/env node
+/**
+ * MCP Proxy - Resilient stdio proxy for SpecMem MCP server
+ *
+ * Claude connects to this proxy via stdio. The proxy manages the actual
+ * MCP server (bootstrap.cjs) as a child process. If the server crashes
+ * or restarts, the proxy reconnects transparently — Claude never sees
+ * a disconnect.
+ *
+ * Protocol: MCP uses Content-Length framed JSON-RPC 2.0 over stdio.
+ */
+
+const { spawn } = require('child_process');
+const path = require('path');
+const fs = require('fs');
+
+// Config
+const BOOTSTRAP_PATH = path.join(__dirname, 'bootstrap.cjs');
+const MAX_RESTART_DELAY = 10000; // 10s max backoff
+const INITIAL_RESTART_DELAY = 500; // 500ms first retry
+const MAX_QUEUE_SIZE = 200;
+const HEARTBEAT_INTERVAL = 30000; // 30s keepalive pings
+
+// State
+let child = null;
+let childReady = false;
+let pendingQueue = []; // Messages queued during reconnect
+let restartDelay = INITIAL_RESTART_DELAY;
+let restartCount = 0;
+let lastInitializeRequest = null; // Cache the initialize request for re-init
+let lastInitializeResponse = null;
+let initializeId = null;
+let shuttingDown = false;
+let heartbeatTimer = null;
+let childStdoutBuffer = '';
+let stdinBuffer = '';
+
+function log(msg) {
+  try {
+    fs.appendFileSync('/tmp/specmem-proxy.log',
+      `[${new Date().toISOString()}] ${msg}\n`);
+  } catch {}
+}
+
+log(`Proxy starting. PID=${process.pid} BOOTSTRAP=${BOOTSTRAP_PATH}`);
+log(`ENV: PROJECT_PATH=${process.env.SPECMEM_PROJECT_PATH}`);
+
+// ============================================================================
+// Content-Length framed message parser
+// ============================================================================
+function parseMessages(buffer) {
+  const messages = [];
+  let remaining = buffer;
+
+  while (remaining.length > 0) {
+    // Look for Content-Length header
+    const headerEnd = remaining.indexOf('\r\n\r\n');
+    if (headerEnd === -1) break;
+
+    const header = remaining.substring(0, headerEnd);
+    const match = header.match(/Content-Length:\s*(\d+)/i);
+    if (!match) {
+      // Skip malformed data
+      remaining = remaining.substring(headerEnd + 4);
+      continue;
+    }
+
+    const contentLength = parseInt(match[1], 10);
+    const bodyStart = headerEnd + 4;
+    const bodyEnd = bodyStart + contentLength;
+
+    if (remaining.length < bodyEnd) {
+      break; // Incomplete message, wait for more data
+    }
+
+    const body = remaining.substring(bodyStart, bodyEnd);
+    remaining = remaining.substring(bodyEnd);
+
+    try {
+      messages.push(JSON.parse(body));
+    } catch (e) {
+      log(`Parse error: ${e.message} body=${body.substring(0, 100)}`);
+    }
+  }
+
+  return { messages, remaining };
+}
+
+function frameMessage(obj) {
+  const body = JSON.stringify(obj);
+  return `Content-Length: ${Buffer.byteLength(body)}\r\n\r\n${body}`;
+}
+
+// ============================================================================
+// Send message to Claude (stdout)
+// ============================================================================
+function sendToClient(msg) {
+  try {
+    process.stdout.write(frameMessage(msg));
+  } catch (e) {
+    log(`stdout write error: ${e.message}`);
+  }
+}
+
+// ============================================================================
+// Send message to MCP server (child stdin)
+// ============================================================================
+function sendToServer(msg) {
+  if (!child || !childReady || child.killed) {
+    // Queue it
+    if (pendingQueue.length < MAX_QUEUE_SIZE) {
+      pendingQueue.push(msg);
+      log(`Queued message (${pendingQueue.length} pending): ${msg.method || msg.id || '?'}`);
+    } else {
+      log(`Queue full, dropping message: ${msg.method || msg.id || '?'}`);
+    }
+    return;
+  }
+
+  try {
+    child.stdin.write(frameMessage(msg));
+  } catch (e) {
+    log(`child stdin write error: ${e.message}`);
+    pendingQueue.push(msg);
+  }
+}
+
+// ============================================================================
+// Flush queued messages to server
+// ============================================================================
+function flushQueue() {
+  if (pendingQueue.length === 0) return;
+  log(`Flushing ${pendingQueue.length} queued messages to server`);
+  const queue = [...pendingQueue];
+  pendingQueue = [];
+  for (const msg of queue) {
+    sendToServer(msg);
+  }
+}
+
+// ============================================================================
+// Spawn/restart the MCP server
+// ============================================================================
+function spawnServer() {
+  if (shuttingDown) return;
+  if (child && !child.killed) {
+    try { child.kill('SIGTERM'); } catch {}
+  }
+
+  childReady = false;
+  childStdoutBuffer = '';
+
+  const args = process.argv.slice(2); // Pass through any args
+  const env = { ...process.env };
+
+  log(`Spawning server: node ${BOOTSTRAP_PATH} ${args.join(' ')}`);
+
+  child = spawn('node', ['--max-old-space-size=250', BOOTSTRAP_PATH, ...args], {
+    env,
+    stdio: ['pipe', 'pipe', 'pipe'],
+    cwd: process.env.SPECMEM_PROJECT_PATH || process.cwd()
+  });
+
+  child.stderr.on('data', (data) => {
+    // Forward stderr (logs) to our stderr
+    process.stderr.write(data);
+  });
+
+  child.stdout.on('data', (data) => {
+    childStdoutBuffer += data.toString();
+
+    const { messages, remaining } = parseMessages(childStdoutBuffer);
+    childStdoutBuffer = remaining;
+
+    for (const msg of messages) {
+      // If this is the response to initialize, cache it and mark ready
+      if (msg.id !== undefined && msg.id === initializeId && msg.result) {
+        lastInitializeResponse = msg;
+        childReady = true;
+        restartDelay = INITIAL_RESTART_DELAY;
+        restartCount = 0;
+        log(`Server initialized (id=${msg.id}). Flushing queue.`);
+
+        // If this is a RE-init (not the first), don't send the response
+        // to Claude — Claude already has the init response from first time
+        if (restartCount > 0 || lastInitializeResponse) {
+          // Still send it on first init
+        }
+        sendToClient(msg);
+        flushQueue();
+        startHeartbeat();
+        continue;
+      }
+
+      // Forward everything else to Claude
+      sendToClient(msg);
+    }
+  });
+
+  child.on('error', (err) => {
+    log(`Server process error: ${err.message}`);
+    scheduleRestart();
+  });
+
+  child.on('exit', (code, signal) => {
+    log(`Server exited: code=${code} signal=${signal}`);
+    childReady = false;
+    stopHeartbeat();
+
+    if (!shuttingDown) {
+      scheduleRestart();
+    }
+  });
+
+  // If we have a cached initialize request, re-send it
+  if (lastInitializeRequest && restartCount > 0) {
+    log(`Re-sending initialize request (restart #${restartCount})`);
+    setTimeout(() => {
+      if (child && !child.killed) {
+        try {
+          child.stdin.write(frameMessage(lastInitializeRequest));
+          // Also send initialized notification
+          setTimeout(() => {
+            if (child && !child.killed) {
+              try {
+                child.stdin.write(frameMessage({ jsonrpc: '2.0', method: 'notifications/initialized' }));
+              } catch {}
+            }
+          }, 100);
+        } catch (e) {
+          log(`Re-init write error: ${e.message}`);
+        }
+      }
+    }, 200);
+  }
+
+  restartCount++;
+}
+
+function scheduleRestart() {
+  if (shuttingDown) return;
+  log(`Scheduling restart in ${restartDelay}ms (restart #${restartCount})`);
+  setTimeout(() => {
+    spawnServer();
+  }, restartDelay);
+  restartDelay = Math.min(restartDelay * 2, MAX_RESTART_DELAY);
+}
+
+// ============================================================================
+// Heartbeat — detect dead server
+// ============================================================================
+function startHeartbeat() {
+  stopHeartbeat();
+  heartbeatTimer = setInterval(() => {
+    if (!child || child.killed || !childReady) return;
+    // Send a ping (list tools) to keep connection alive
+    // MCP doesn't have a ping method, but we can use this to detect dead pipes
+    try {
+      child.stdin.write(''); // Zero-byte write to test pipe
+    } catch (e) {
+      log(`Heartbeat detected dead pipe: ${e.message}`);
+      childReady = false;
+      try { child.kill('SIGTERM'); } catch {}
+    }
+  }, HEARTBEAT_INTERVAL);
+}
+
+function stopHeartbeat() {
+  if (heartbeatTimer) {
+    clearInterval(heartbeatTimer);
+    heartbeatTimer = null;
+  }
+}
+
+// ============================================================================
+// Handle stdin from Claude
+// ============================================================================
+process.stdin.on('data', (data) => {
+  stdinBuffer += data.toString();
+
+  const { messages, remaining } = parseMessages(stdinBuffer);
+  stdinBuffer = remaining;
+
+  for (const msg of messages) {
+    // Cache the initialize request so we can re-send on restart
+    if (msg.method === 'initialize') {
+      lastInitializeRequest = msg;
+      initializeId = msg.id;
+      log(`Got initialize request (id=${msg.id})`);
+    }
+
+    // Cache initialized notification
+    if (msg.method === 'notifications/initialized') {
+      log('Got initialized notification');
+    }
+
+    sendToServer(msg);
+  }
+});
+
+process.stdin.on('end', () => {
+  log('stdin closed (Claude disconnected)');
+  shutdown();
+});
+
+process.stdin.on('error', (err) => {
+  log(`stdin error: ${err.message}`);
+  shutdown();
+});
+
+// ============================================================================
+// Graceful shutdown
+// ============================================================================
+function shutdown() {
+  if (shuttingDown) return;
+  shuttingDown = true;
+  log('Proxy shutting down');
+  stopHeartbeat();
+  if (child && !child.killed) {
+    child.kill('SIGTERM');
+    setTimeout(() => {
+      try { child.kill('SIGKILL'); } catch {}
+      process.exit(0);
+    }, 3000);
+  } else {
+    process.exit(0);
+  }
+}
+
+process.on('SIGTERM', shutdown);
+process.on('SIGINT', shutdown);
+
+// ============================================================================
+// Start
+// ============================================================================
+spawnServer();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "specmem-hardwicksoftware",
-  "version": "3.7.13",
+  "version": "3.7.15",
   "type": "module",
   "description": "Persistent memory system for coding sessions - semantic search with pgvector, token compression, team coordination, file watching. Needs root: installs system-wide hooks, manages docker/PostgreSQL, writes global configs, handles screen sessions. justcalljon.pro",
   "main": "dist/index.js",
@@ -128,6 +128,7 @@
     "embedding-sandbox/",
     "legal/",
     "bootstrap.cjs",
+    "mcp-proxy.cjs",
     "specmem-health.cjs",
     "specmem.env",
     "LICENSE.md",

package/scripts/specmem-init.cjs

@@ -6511,12 +6511,16 @@ async function runAutoSetup(projectPath) {
 
       // Configure MCP server for this project
       claudeJson.projects[projectPath].mcpServers = claudeJson.projects[projectPath].mcpServers || {};
+      // Prefer mcp-proxy.cjs for resilient connections (auto-reconnect)
+      const mcpEntry = fs.existsSync(path.join(specmemPkg, 'mcp-proxy.cjs'))
+        ? path.join(specmemPkg, 'mcp-proxy.cjs')
+        : path.join(specmemPkg, 'bootstrap.cjs');
       claudeJson.projects[projectPath].mcpServers.specmem = {
         type: "stdio",
         command: "node",
         args: [
           "--max-old-space-size=250",
-          path.join(specmemPkg, 'bootstrap.cjs')
+          mcpEntry
         ],
         env: {
           HOME: os.homedir(),