specmem-hardwicksoftware 3.7.5 → 3.7.7

package/dist/mcp/embeddingServerManager.js

@@ -1518,9 +1518,14 @@ export class EmbeddingServerManager extends EventEmitter {
             // Environment variables are null-separated
             const envVars = environ.split('\0');
             for (const envVar of envVars) {
+                // Check both env var names - MCP manager uses SPECMEM_EMBEDDING_SOCKET,
+                // but specmem-init spawns with SPECMEM_SOCKET_PATH
                 if (envVar.startsWith('SPECMEM_EMBEDDING_SOCKET=')) {
                     return envVar.split('=')[1];
                 }
+                if (envVar.startsWith('SPECMEM_SOCKET_PATH=')) {
+                    return envVar.split('=')[1];
+                }
             }
             return null;
         }

package/dist/utils/processHealthCheck.js

@@ -70,7 +70,31 @@ export function checkProcessHealth(config) {
         if (commandLine) {
             const isEmbedding = commandLine.includes('frankenstein-embeddings.py') ||
                 (expectedProcessName && commandLine.includes(expectedProcessName));
-            const isCorrectProject = !projectPath || commandLine.includes(projectPath);
+            // Check project path in command line first, then fall back to env vars
+            // CRITICAL FIX: The embedding server receives project path via SPECMEM_PROJECT_PATH
+            // and socket path via SPECMEM_SOCKET_PATH env vars, NOT command line args.
+            // Without this check, every embedding server appears to be "wrong project" and gets killed.
+            let isCorrectProject = !projectPath || commandLine.includes(projectPath);
+            if (!isCorrectProject && projectPath && isEmbedding) {
+                // Check process environment for SPECMEM_PROJECT_PATH
+                const processEnvProjectPath = getProcessEnvVar(pid, 'SPECMEM_PROJECT_PATH');
+                if (processEnvProjectPath) {
+                    isCorrectProject = processEnvProjectPath === projectPath || processEnvProjectPath.startsWith(projectPath);
+                    if (isCorrectProject) {
+                        logger.debug({ pid, processEnvProjectPath, expectedProject: projectPath },
+                            '[ProcessHealthCheck] Project path matched via SPECMEM_PROJECT_PATH env var');
+                    }
+                }
+                // Also check SPECMEM_SOCKET_PATH which contains the project path
+                if (!isCorrectProject) {
+                    const processSocketPath = getProcessEnvVar(pid, 'SPECMEM_SOCKET_PATH');
+                    if (processSocketPath && processSocketPath.includes(projectPath)) {
+                        isCorrectProject = true;
+                        logger.debug({ pid, processSocketPath, expectedProject: projectPath },
+                            '[ProcessHealthCheck] Project path matched via SPECMEM_SOCKET_PATH env var');
+                    }
+                }
+            }
             isEmbeddingServer = isEmbedding && isCorrectProject;
             if (isEmbedding && !isCorrectProject) {
                 logger.warn({
@@ -144,6 +168,30 @@ export function checkProcessHealth(config) {
 // ============================================================================
 // LOW-LEVEL UTILITIES
 // ============================================================================
+/**
+ * Read a specific environment variable from a running process via /proc
+ * Returns the value or null if not found/readable
+ */
+function getProcessEnvVar(pid, varName) {
+    try {
+        const environPath = `/proc/${pid}/environ`;
+        if (!existsSync(environPath)) {
+            return null;
+        }
+        const environ = readFileSync(environPath, 'utf8');
+        const prefix = varName + '=';
+        const envVars = environ.split('\0');
+        for (const envVar of envVars) {
+            if (envVar.startsWith(prefix)) {
+                return envVar.slice(prefix.length);
+            }
+        }
+        return null;
+    }
+    catch {
+        return null;
+    }
+}
 /**
  * Read PID file with timestamp
  * Format: PID:TIMESTAMP

package/embedding-sandbox/frankenstein-embeddings.py

@@ -4014,9 +4014,23 @@ def main():
 
     # Signal handling for graceful shutdown
     import signal
+    import traceback
     def handle_signal(signum, frame):
         sig_name = signal.Signals(signum).name
+        # DEBUG: Log who sent the signal for troubleshooting
+        my_pid = os.getpid()
+        my_ppid = os.getppid()
         print(f"\n⚡ Received {sig_name} - shutting down gracefully...", file=sys.stderr)
+        print(f"   DEBUG: my_pid={my_pid}, my_ppid={my_ppid}", file=sys.stderr)
+        # Try to identify caller via /proc
+        try:
+            with open(f'/proc/{my_ppid}/cmdline', 'r') as f:
+                parent_cmd = f.read().replace('\x00', ' ').strip()
+            print(f"   DEBUG: parent_cmd={parent_cmd[:200]}", file=sys.stderr)
+        except Exception as e:
+            print(f"   DEBUG: could not read parent cmdline: {e}", file=sys.stderr)
+        print(f"   DEBUG: stack trace:", file=sys.stderr)
+        traceback.print_stack(frame, file=sys.stderr)
         server.shutdown_requested = True
         # Stop QQMS v2 drain thread if enabled
         if qqms_v2_instance:

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "specmem-hardwicksoftware",
-  "version": "3.7.5",
+  "version": "3.7.7",
   "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",

package/scripts/specmem-init.cjs

@@ -3659,15 +3659,18 @@ async function indexCodebase(projectPath, ui, embeddingResult) {
           try { fs.unlinkSync(projectSocketPath); } catch { /* ignore */ }
         }
         const pythonPath = getPythonPath();
+        // CRITICAL: Use file descriptor stdio, NOT pipes. Piped stdio causes SIGTERM
+        // when parent event loop is under heavy load during batch indexing.
+        const revalLogPath = path.join(projectPath, 'specmem', 'sockets', 'embedding-autostart.log');
+        const revalLogFd = fs.openSync(revalLogPath, 'a');
         const proc = spawn(pythonPath, [embeddingScript], {
           cwd: path.dirname(embeddingScript),
           env: { ...process.env, SPECMEM_SOCKET_PATH: projectSocketPath, SPECMEM_PROJECT_PATH: projectPath },
           detached: true,
-          stdio: ['ignore', 'pipe', 'pipe']
+          stdio: ['ignore', revalLogFd, revalLogFd]
         });
-        proc.stdout.on('data', () => {});
-        proc.stderr.on('data', () => {});
         proc.on('error', () => {});
+        fs.closeSync(revalLogFd);
         proc.unref();
         // Wait up to 15s for socket to appear
         for (let i = 0; i < 30; i++) {
@@ -4867,6 +4870,10 @@ async function extractSessions(projectPath, ui, embeddingResult = null) {
 
       // Task #22 fix: Use getPythonPath() instead of hardcoded 'python3'
       const pythonPath = getPythonPath();
+      // CRITICAL: Use file descriptor stdio, NOT pipes. Piped stdio causes SIGTERM
+      // when parent event loop is under heavy load during batch indexing.
+      const sessEmbedLogPath = path.join(projectPath, 'specmem', 'sockets', 'embedding-autostart.log');
+      const sessEmbedLogFd = fs.openSync(sessEmbedLogPath, 'a');
       const embeddingProcess = spawn(pythonPath, [embeddingScript], {
         cwd: path.dirname(embeddingScript),
         env: {
@@ -4875,7 +4882,7 @@ async function extractSessions(projectPath, ui, embeddingResult = null) {
           SPECMEM_PROJECT_PATH: projectPath
         },
         detached: true,
-        stdio: ['ignore', 'pipe', 'pipe']
+        stdio: ['ignore', sessEmbedLogFd, sessEmbedLogFd]
       });
 
       // error handler BEFORE unref - prevents silent spawn failures
@@ -4883,14 +4890,7 @@ async function extractSessions(projectPath, ui, embeddingResult = null) {
         ui.setSubStatus('Embedding spawn error: ' + err.message);
       });
 
-      // CRITICAL: Consume stdout/stderr so Python startup banner doesn't leak to terminal
-      embeddingProcess.stdout.on('data', (chunk) => {
-        initLog('[EMBED-STDOUT] ' + chunk.toString().trim());
-      });
-      embeddingProcess.stderr.on('data', (chunk) => {
-        initLog('[EMBED-STDERR] ' + chunk.toString().trim());
-      });
-
+      fs.closeSync(sessEmbedLogFd);
       embeddingProcess.unref();
 
       // Wait for socket to appear (up to 30s)