specmem-hardwicksoftware 3.7.36 → 3.7.38

package/dist/init/claudeConfigInjector.js

@@ -261,9 +261,9 @@ function configureMcpServer() {
             SPECMEM_PROJECT_PATH: '${PWD}',
             SPECMEM_WATCHER_ROOT_PATH: '${PWD}',
             SPECMEM_CODEBASE_PATH: '${PWD}',
-            // Database (use environment values or defaults)
-            SPECMEM_DB_HOST: process.env.SPECMEM_DB_HOST || 'localhost',
-            SPECMEM_DB_PORT: process.env.SPECMEM_DB_PORT || '5432',
+            // Database - use ${PWD} for project isolation
+            SPECMEM_DB_HOST: '${PWD}/specmem/run',
+            SPECMEM_DB_PORT: '5432',
             // Watchers enabled by default
             SPECMEM_SESSION_WATCHER_ENABLED: 'true',
             SPECMEM_WATCHER_ENABLED: 'true',
@@ -367,8 +367,8 @@ function fixProjectMcpConfigs() {
                     SPECMEM_PROJECT_PATH: '${PWD}',
                     SPECMEM_WATCHER_ROOT_PATH: '${PWD}',
                     SPECMEM_CODEBASE_PATH: '${PWD}',
-                    SPECMEM_DB_HOST: process.env.SPECMEM_DB_HOST || 'localhost',
-                    SPECMEM_DB_PORT: process.env.SPECMEM_DB_PORT || '5432',
+                    SPECMEM_DB_HOST: '${PWD}/specmem/run',
+                    SPECMEM_DB_PORT: '5432',
                     SPECMEM_DB_PASSWORD: 'SPECMEM_DB_PASSWORD' in process.env ? process.env.SPECMEM_DB_PASSWORD : undefined,
                     SPECMEM_SESSION_WATCHER_ENABLED: 'true',
                     SPECMEM_WATCHER_ENABLED: 'true',
@@ -904,6 +904,9 @@ function hasHook(hooks, commandSubstring, matcher) {
 }
 function configureSettings() {
     const settings = safeReadJson(SETTINGS_PATH, {});
+    // Preserve user's custom top-level env (ANTHROPIC_BASE_URL, ANTHROPIC_AUTH_TOKEN, model overrides, etc.)
+    // We explicitly capture and restore this to guard against any future code accidentally touching it.
+    const _userCustomEnv = settings.env;
     const permissionsAdded = [];
     const hooksAdded = [];
     let needsUpdate = false;
@@ -959,8 +962,24 @@ function configureSettings() {
     if (hooksAdded.length > 0) {
         logger.info({ hooksAdded }, '[ConfigInjector] Adding hooks to settings.json');
     }
+    // Restore user's custom env - NEVER clobber ANTHROPIC_BASE_URL, model overrides, etc.
+    if (_userCustomEnv !== undefined) {
+        settings.env = _userCustomEnv;
+    }
+    // Inject Claude Code env flags (append-if-missing, never clobber existing values)
+    const REQUIRED_CLAUDE_ENV = {
+        CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS: '1',
+    };
+    if (!settings.env) settings.env = {};
+    for (const [key, value] of Object.entries(REQUIRED_CLAUDE_ENV)) {
+        if (!(key in settings.env)) {
+            settings.env[key] = value;
+            needsUpdate = true;
+            logger.info({ key, value }, '[ConfigInjector] Injected Claude env flag');
+        }
+    }
     if (safeWriteJson(SETTINGS_PATH, settings)) {
-        logger.info({ path: SETTINGS_PATH, permissionsAdded, hooksAdded }, '[ConfigInjector] Settings updated');
+        logger.info({ path: SETTINGS_PATH, permissionsAdded, hooksAdded }, '[ConfigInjector] Settings updated (custom env preserved)');
         return { updated: true, permissionsAdded, hooksAdded };
     }
     return { updated: false, permissionsAdded: [], hooksAdded: [], error: 'Failed to write settings.json' };

package/dist/installer/autoInstall.js

@@ -274,6 +274,8 @@ export async function configureHooks() {
             logger.warn({ err }, 'could not parse existing settings, starting fresh');
         }
     }
+    // Preserve user's custom env BEFORE any modifications (ANTHROPIC_BASE_URL, model overrides, etc.)
+    const _userCustomEnv = settings.env;
     // ============================================================
     // GOD MODE PERMISSIONS - Allow all SpecMem tools without asking
     // ============================================================
@@ -426,9 +428,13 @@ export async function configureHooks() {
     if (userPromptHooks.length > 0) {
         addHooksToEvent('SessionStart', userPromptHooks.slice(0, 1)); // Just the drilldown hook
     }
+    // Restore user's custom env - NEVER clobber ANTHROPIC_BASE_URL, model overrides, etc.
+    if (_userCustomEnv !== undefined) {
+        settings.env = _userCustomEnv;
+    }
     // Write settings
     fs.writeFileSync(claudeSettingsPath, JSON.stringify(settings, null, 2));
-    logger.info('GOD MODE:  hooks configured successfully');
+    logger.info('GOD MODE:  hooks configured successfully (custom env preserved)');
     logger.info({
         permissions: specmemPermissions.length,
         hooks: Object.keys(settings.hooks).length,

package/dist/mcp/compactionProxy.js

@@ -40,8 +40,73 @@ const OG_SYS_PROMPT_FILE = join(CLAUDE_DIR, '.og-sys-prompt.json');
 // Per-user port: env var > default 4080. Multiple users on same machine
 // should set COMPACTION_PROXY_PORT or rely on the port file mechanism.
 const PROXY_PORT = parseInt(process.env.COMPACTION_PROXY_PORT || '4080', 10);
-const UPSTREAM_HOST = process.env.COMPACTION_PROXY_UPSTREAM || 'api.anthropic.com';
-const UPSTREAM_PORT = 443;
+
+// ============================================================================
+// Custom Upstream Detection — ENV VARS ONLY (no settings.json scanning)
+// ============================================================================
+// For custom APIs (MiniMax, etc.), set these env vars on the MCP server config:
+//   COMPACTION_PROXY_UPSTREAM  — full URL of the real API (e.g., https://api.minimax.io/anthropic)
+//   COMPACTION_PROXY_API_KEY   — API key for the custom upstream
+//   COMPACTION_PROXY_MODEL     — model name to inject (e.g., MiniMax-Text-01)
+//
+// When NONE of these are set, the proxy is transparent: it forwards to api.anthropic.com
+// with all original headers (OAuth Bearer, anthropic-beta, etc.) intact.
+// This is the "native Claude" mode — fast mode, thinking, etc. all work.
+
+// Custom upstream API key (for MiniMax, etc.)
+const UPSTREAM_API_KEY = process.env.COMPACTION_PROXY_API_KEY
+    || process.env.ANTHROPIC_AUTH_TOKEN
+    || process.env.ANTHROPIC_API_KEY
+    || null;
+
+// Custom model override (for MiniMax, etc.)
+const UPSTREAM_MODEL = process.env.COMPACTION_PROXY_MODEL
+    || process.env.ANTHROPIC_MODEL
+    || null;
+
+// Parse upstream URL — env var only, no settings.json scanning
+// Settings.json scanning caused stale MiniMax configs to break native Claude mode.
+function parseUpstreamUrl() {
+    const upstream = process.env.COMPACTION_PROXY_UPSTREAM || null;
+    if (upstream) {
+        try {
+            const url = new URL(upstream.startsWith('http') ? upstream : 'https://' + upstream);
+            return {
+                host: url.hostname,
+                port: parseInt(url.port, 10) || 443,
+                isHttps: url.protocol === 'https:',
+                path: url.pathname || '/'
+            };
+        } catch (e) {
+            return { host: upstream, port: 443, isHttps: true, path: '/' };
+        }
+    }
+    // Default: Anthropic API — headers pass through untouched (OAuth + fast mode work)
+    return { host: 'api.anthropic.com', port: 443, isHttps: true, path: '/' };
+}
+
+const UPSTREAM = parseUpstreamUrl();
+const UPSTREAM_HOST = UPSTREAM.host;
+const UPSTREAM_PORT = UPSTREAM.port;
+const UPSTREAM_IS_HTTPS = UPSTREAM.isHttps;
+const UPSTREAM_PATH = UPSTREAM.path || '/';
+
+// FIX: Get the original model name (like "opus") to use in responses so Claude accepts them
+// When using custom upstream (MiniMax), ALWAYS return "opus" in response
+function getOriginalModel() {
+    // If using custom upstream (MiniMax), always return opus for the response
+    if (UPSTREAM_MODEL && UPSTREAM_HOST !== 'api.anthropic.com') {
+        log('proxy', `Using opus for response (custom upstream: ${UPSTREAM_MODEL})`);
+        return 'opus';
+    }
+    // Otherwise return what's in env (for normal Anthropic)
+    return process.env.ANTHROPIC_MODEL || null;
+}
+
+const ORIGINAL_MODEL = getOriginalModel();
+
+// Helper to pick HTTP or HTTPS request based on upstream
+const upstreamRequest = UPSTREAM_IS_HTTPS ? httpsRequest : httpRequest;
 const LOG_FILE = join('/tmp', `compaction-proxy-${process.getuid?.() ?? 'default'}.log`);
 
 // Orphan detection — track last request time for daemon watchdog
@@ -1889,21 +1954,168 @@ function collectBody(req) {
   });
 }
 
+// FIX: Convert Anthropic /v1/messages format to OpenAI /v1/chat/completions format
+function convertToOpenAIFormat(anthropicBody, model) {
+  try {
+    // Anthropic format: { model, messages: [{role, content}], system, ... }
+    // OpenAI format: { model, messages: [{role, content}], ... }
+    const body = JSON.parse(anthropicBody.toString('utf8'));
+
+    // Convert to OpenAI format
+    const openai = {
+      model: model,
+      messages: []
+    };
+
+    // Handle system prompt - add as first message with role: system
+    if (body.system) {
+      const systemContent = Array.isArray(body.system)
+        ? body.system.map(s => typeof s === 'string' ? s : s.text || '').join('\n')
+        : (typeof body.system === 'string' ? body.system : '');
+      if (systemContent) {
+        openai.messages.push({ role: 'system', content: systemContent });
+      }
+    }
+
+    // Convert messages
+    if (body.messages) {
+      for (const msg of body.messages) {
+        // Anthropic uses "user" and "assistant", OpenAI uses same
+        let role = msg.role;
+        let content = msg.content;
+
+        // Handle content blocks - convert to string
+        if (Array.isArray(content)) {
+          content = content.map(c => {
+            if (typeof c === 'string') return c;
+            return c.text || c.type || '';
+          }).join('\n');
+        }
+
+        // Skip thinking blocks
+        if (role === 'system' && openai.messages.some(m => m.role === 'system')) {
+          continue; // Already added
+        }
+
+        openai.messages.push({ role, content });
+      }
+    }
+
+    // Copy other fields
+    if (body.max_tokens) openai.max_tokens = body.max_tokens;
+    if (body.temperature) openai.temperature = body.temperature;
+    if (body.top_p) openai.top_p = body.top_p;
+    if (body.stream) openai.stream = body.stream;
+    if (body.stop) openai.stop = body.stop;
+
+    log('proxy', `Converted Anthropic format to OpenAI format for model: ${model}`);
+    return Buffer.from(JSON.stringify(openai), 'utf8');
+  } catch (e) {
+    log('proxy', `Format conversion error: ${e.message}`);
+    return anthropicBody; // Fallback to original
+  }
+}
+
+// FIX: Convert OpenAI /v1/chat/completions response to Anthropic /v1/messages response format
+function convertFromOpenAIFormat(openaiBody) {
+  try {
+    const body = JSON.parse(openaiBody.toString('utf8'));
+
+    // OpenAI format: { id, model, choices: [{message: {role, content}}], usage, ... }
+    // Anthropic format: { id, type: "message", role: "assistant", model, content: [{type: "text", text: "..."}], usage }
+
+    if (!body.choices || !body.choices[0]) {
+      return openaiBody; // Not a valid response
+    }
+
+    const choice = body.choices[0];
+    const openaiMsg = choice.message || {};
+
+    // Convert to Anthropic format
+    const anthropic = {
+      id: body.id || `msg_${Date.now()}`,
+      type: 'message',
+      role: 'assistant',
+      model: ORIGINAL_MODEL || body.model, // Use original model so Claude accepts it
+      content: []
+    };
+
+    // Handle content - OpenAI returns message.content as string, Anthropic wants array of blocks
+    if (openaiMsg.content) {
+      anthropic.content.push({
+        type: 'text',
+        text: openaiMsg.content
+      });
+    }
+
+    // Usage mapping
+    if (body.usage) {
+      anthropic.usage = {
+        input_tokens: body.usage.prompt_tokens || 0,
+        output_tokens: body.usage.completion_tokens || 0
+      };
+    }
+
+    // Stop reason
+    if (choice.finish_reason) {
+      anthropic.stop_reason = choice.finish_reason === 'length' ? 'max_tokens' : 'end_turn';
+    }
+
+    log('proxy', `Converted OpenAI response to Anthropic format`);
+    return Buffer.from(JSON.stringify(anthropic), 'utf8');
+  } catch (e) {
+    log('proxy', `Response conversion error: ${e.message}`);
+    return openaiBody; // Fallback to original
+  }
+}
+
 function forwardRequest(req, res, bodyBuffer) {
+  let modifiedBody = bodyBuffer;
+  let modifiedPath = req.url;
+
+  // Detect custom upstream mode (MiniMax, etc.) — env-var driven only
+  const isCustomUpstream = UPSTREAM_HOST !== 'api.anthropic.com';
+
+  // Prepend base path from upstream URL (e.g., /anthropic for MiniMax)
+  if (UPSTREAM_PATH && UPSTREAM_PATH !== '/') {
+    modifiedPath = UPSTREAM_PATH + (req.url.startsWith('/') ? '' : '/') + req.url;
+  }
+
+  // Custom upstream: inject model name into request body
+  if (isCustomUpstream && UPSTREAM_MODEL) {
+    try {
+      const body = JSON.parse(bodyBuffer.toString('utf8'));
+      if (body.model) {
+        body.model = UPSTREAM_MODEL;
+        modifiedBody = Buffer.from(JSON.stringify(body), 'utf8');
+      }
+    } catch (e) {
+      log('proxy', `Failed to replace model: ${e.message}`);
+    }
+  }
+
   const upstreamHeaders = { ...req.headers };
   upstreamHeaders.host = UPSTREAM_HOST;
-  upstreamHeaders['content-length'] = bodyBuffer.length;
+  upstreamHeaders['content-length'] = modifiedBody.length;
   delete upstreamHeaders['proxy-connection'];
   delete upstreamHeaders['proxy-authorization'];
 
-  const upstreamReq = httpsRequest({
+  // Custom upstream: inject API key (MiniMax, etc.)
+  // Native mode: leave original headers untouched (OAuth Bearer + fast mode work)
+  if (isCustomUpstream && UPSTREAM_API_KEY) {
+    upstreamHeaders['x-api-key'] = UPSTREAM_API_KEY;
+    upstreamHeaders['Authorization'] = `Bearer ${UPSTREAM_API_KEY}`;
+  }
+
+  const upstreamReq = upstreamRequest({
     hostname: UPSTREAM_HOST,
     port: UPSTREAM_PORT,
-    path: req.url,
+    path: modifiedPath,
     method: req.method,
     headers: upstreamHeaders,
     timeout: 300000
   }, (upstreamRes) => {
+    // Always write headers — both regular Anthropic and custom upstream (MiniMax) need them
     res.writeHead(upstreamRes.statusCode, upstreamRes.headers);
     upstreamRes.pipe(res);
     upstreamRes.on('error', (err) => {
@@ -1931,7 +2143,7 @@ function forwardRequest(req, res, bodyBuffer) {
     }
   });
 
-  upstreamReq.write(bodyBuffer);
+  upstreamReq.write(modifiedBody);
   upstreamReq.end();
 }
 

package/dist/mcp/embeddingServerManager.js

@@ -47,13 +47,22 @@ const DEFAULT_CONFIG = {
     startupTimeoutMs: parseInt(process.env['SPECMEM_EMBEDDING_STARTUP_TIMEOUT'] || '45000', 10),
     maxRestartAttempts: parseInt(process.env['SPECMEM_EMBEDDING_MAX_RESTARTS'] || '5', 10),
     autoStart: process.env['SPECMEM_EMBEDDING_AUTO_START'] !== 'false',
-    killStaleOnStart: process.env['SPECMEM_EMBEDDING_KILL_STALE'] !== 'false',
+    // FIX: Default to false - only kill if THIS project's socket/PID exists
+    // This prevents cross-project conflicts when multiple projects have embedding servers
+    killStaleOnStart: process.env['SPECMEM_EMBEDDING_KILL_STALE'] === 'true',
+    // New: Strict isolation mode - skip ALL cross-project process checks
+    // Set SPECMEM_EMBEDDING_STRICT_ISOLATION=1 to enable
+    strictIsolation: process.env['SPECMEM_EMBEDDING_STRICT_ISOLATION'] === '1',
     maxProcessAgeHours: parseFloat(process.env['SPECMEM_EMBEDDING_MAX_AGE_HOURS'] || '1'),
     // Circuit breaker configuration (Issue #10)
     cbRestartWindowMs: parseInt(process.env['SPECMEM_RESTART_WINDOW_MS'] || '300000', 10),
     cbMaxRestartsInWindow: parseInt(process.env['SPECMEM_RESTART_MAX_IN_WINDOW'] || '5', 10),
     cbCooldownMs: parseInt(process.env['SPECMEM_RESTART_COOLDOWN_MS'] || '60000', 10),
     cbMaxCooldownMs: parseInt(process.env['SPECMEM_RESTART_MAX_COOLDOWN_MS'] || '600000', 10),
+    // FIX: Status stability - require 3 consecutive failures before marking offline to prevent flickering
+    statusStabilityThreshold: parseInt(process.env['SPECMEM_STATUS_STABILITY_THRESHOLD'] || '3', 10),
+    // FIX: Reduce CPU by throttling duplicate detection to every 5th health check
+    duplicateCheckInterval: parseInt(process.env['SPECMEM_DUPLICATE_CHECK_INTERVAL'] || '5', 10),
 };
 // ============================================================================
 // EMBEDDING SERVER MANAGER
@@ -75,6 +84,27 @@ export class EmbeddingServerManager extends EventEmitter {
     healthCheckTimer = null;
     isRunning = false;
     consecutiveFailures = 0;
+    healthCheckCycle = 0; // FIX: Track health check cycles for throttling duplicate detection
+    // FIX: Unique instance ID to distinguish this SpecMem installation from others
+    instanceId = null;
+    // FIX: Generate unique instance ID per SpecMem installation
+    _ensureInstanceId() {
+        if (this.instanceId) return this.instanceId;
+        // Try to load from file
+        const instanceIdFile = path.join(this.dataDir || this.projectPath, '.specmem-instance-id');
+        try {
+            if (existsSync(instanceIdFile)) {
+                this.instanceId = readFileSync(instanceIdFile, 'utf-8').trim();
+                return this.instanceId;
+            }
+        } catch (e) { /* ignore */ }
+        // Generate new ID
+        this.instanceId = `inst-${Date.now()}-${Math.random().toString(36).slice(2, 10)}`;
+        try {
+            writeFileSync(instanceIdFile, this.instanceId);
+        } catch (e) { /* ignore */ }
+        return this.instanceId;
+    }
     restartCount = 0;
     lastRestartTime = 0;
     startTime = null;
@@ -156,9 +186,17 @@ export class EmbeddingServerManager extends EventEmitter {
             this.startKysHeartbeat();
             return;
         }
-        // Step 1: Kill any stale processes
-        if (this.config.killStaleOnStart) {
+        // FIX: Only kill stale processes if THIS project's PID file exists
+        // This prevents cross-project conflicts when multiple projects have embedding servers
+        const pidFileExists = existsSync(this.pidFilePath);
+        // Step 1: Kill any stale processes (only if our PID file exists or explicitly enabled)
+        // skip if strictIsolation is enabled to prevent ANY cross-project checks
+        if (this.config.strictIsolation) {
+            logger.info('[EmbeddingServerManager] Strict isolation mode - skipping stale process cleanup');
+        } else if (this.config.killStaleOnStart && pidFileExists) {
             await this.killStaleProcesses();
+        } else if (this.config.killStaleOnStart) {
+            logger.debug('[EmbeddingServerManager] killStaleOnStart enabled but no PID file - skipping cleanup');
         }
         // Step 2: Start the embedding server if auto-start is enabled
         if (this.config.autoStart) {
@@ -563,6 +601,7 @@ export class EmbeddingServerManager extends EventEmitter {
                 SPECMEM_SOCKET_DIR: socketDir,
                 SPECMEM_EMBEDDING_SOCKET: this.socketPath,
                 SPECMEM_EMBEDDING_IDLE_TIMEOUT: '0',
+                SPECMEM_INSTANCE_ID: this.instanceId || this._ensureInstanceId(),
                 SPECMEM_DB_SCHEMA: projectSchema,
                 ...configEnv,
             });
@@ -926,12 +965,12 @@ export class EmbeddingServerManager extends EventEmitter {
                         if (response.error) {
                             clearTimeout(timeout);
                             resolved = true;
-                            socket.end();
+                            socket.destroy();
                             reject(new Error(response.error));
                             return;
                         }
-                        // Skip "processing" status messages - wait for actual embedding
-                        if (response.status === 'processing') {
+                        // Skip "processing"/"working" status messages - wait for actual embedding
+                        if (response.status === 'working' || response.status === 'processing') {
                             logger.debug({ textLength: response.text_length }, '[EmbeddingServerManager] Embedding request queued, waiting for result...');
                             continue; // Keep reading for the actual embedding
                         }
@@ -939,7 +978,7 @@ export class EmbeddingServerManager extends EventEmitter {
                         if (response.embedding && Array.isArray(response.embedding)) {
                             clearTimeout(timeout);
                             resolved = true;
-                            socket.end();
+                            socket.destroy();
                             resolve(response.embedding);
                             return;
                         }
@@ -955,6 +994,7 @@ export class EmbeddingServerManager extends EventEmitter {
                 clearTimeout(timeout);
                 if (!resolved) {
                     resolved = true;
+                    socket.destroy();
                     reject(err);
                 }
             });
@@ -995,17 +1035,17 @@ export class EmbeddingServerManager extends EventEmitter {
                         if (response.error) {
                             clearTimeout(timeout);
                             resolved = true;
-                            socket.end();
+                            socket.destroy();
                             reject(new Error(response.error));
                             return;
                         }
-                        if (response.status === 'processing') {
+                        if (response.status === 'working' || response.status === 'processing') {
                             continue; // Wait for actual result
                         }
                         if (response.embeddings && Array.isArray(response.embeddings)) {
                             clearTimeout(timeout);
                             resolved = true;
-                            socket.end();
+                            socket.destroy();
                             resolve(response.embeddings);
                             return;
                         }
@@ -1019,6 +1059,7 @@ export class EmbeddingServerManager extends EventEmitter {
                 clearTimeout(timeout);
                 if (!resolved) {
                     resolved = true;
+                    socket.destroy();
                     reject(err);
                 }
             });
@@ -1075,11 +1116,11 @@ export class EmbeddingServerManager extends EventEmitter {
                         if (response.error) {
                             clearTimeout(timeout);
                             resolved = true;
-                            socket.end();
+                            socket.destroy();
                             reject(new Error(response.error));
                             return;
                         }
-                        if (response.status === 'processing') {
+                        if (response.status === 'working' || response.status === 'processing') {
                             logger.debug('[EmbeddingServerManager] Server-side processing in progress...');
                             continue;
                         }
@@ -1087,7 +1128,7 @@ export class EmbeddingServerManager extends EventEmitter {
                         if (response.total_processed !== undefined || response.processed !== undefined) {
                             clearTimeout(timeout);
                             resolved = true;
-                            socket.end();
+                            socket.destroy();
                             logger.info({ response }, '[EmbeddingServerManager] Server-side processing complete');
                             resolve(response);
                             return;
@@ -1923,10 +1964,38 @@ export class EmbeddingServerManager extends EventEmitter {
             const envVars = environ.split('\0');
             const projectPath = this.projectPath || process.cwd();
             const socketPath = this.socketPath;
+            let foundInstanceId = null;
+            for (const v of envVars) {
+                // FIX: Check SPECMEM_INSTANCE_ID - if both have it and they match, it's duplicate
+                if (v.startsWith('SPECMEM_INSTANCE_ID=')) {
+                    foundInstanceId = v.replace('SPECMEM_INSTANCE_ID=', '');
+                }
+            }
+            // If both have instance IDs and they match → definitely same instance = duplicate
+            if (foundInstanceId && this.instanceId && foundInstanceId === this.instanceId) {
+                return true;
+            }
+            // If instance IDs differ → different installations → NOT duplicate
+            if (foundInstanceId && this.instanceId && foundInstanceId !== this.instanceId) {
+                return false;
+            }
+            // At least one is legacy (no instance ID) → use path-based matching
             for (const v of envVars) {
-                if (v.startsWith('SPECMEM_PROJECT_PATH=') && v.includes(projectPath)) return true;
-                if (v.startsWith('SPECMEM_SOCKET_PATH=') && v.includes(projectPath)) return true;
-                if (v.startsWith('SPECMEM_EMBEDDING_SOCKET=') && socketPath && v.includes(socketPath)) return true;
+                // FIX: Use exact path match or path separator to prevent false positives
+                // Previously used .includes() which matched partial paths like /specmem/abc matching /specmem
+                if (v.startsWith('SPECMEM_PROJECT_PATH=')) {
+                    const envProjectPath = v.replace('SPECMEM_PROJECT_PATH=', '');
+                    // Match exact path or child path (with / separator)
+                    if (envProjectPath === projectPath || envProjectPath.startsWith(projectPath + '/')) return true;
+                }
+                if (v.startsWith('SPECMEM_SOCKET_PATH=')) {
+                    const envSocketPath = v.replace('SPECMEM_SOCKET_PATH=', '');
+                    if (envSocketPath === socketPath || envSocketPath.startsWith(projectPath + '/')) return true;
+                }
+                if (v.startsWith('SPECMEM_EMBEDDING_SOCKET=') && socketPath) {
+                    const envEmbSocket = v.replace('SPECMEM_EMBEDDING_SOCKET=', '');
+                    if (envEmbSocket === socketPath) return true;
+                }
             }
             return false;
         }
@@ -2392,9 +2461,14 @@ export class EmbeddingServerManager extends EventEmitter {
                     }
                 }
             }
+            // FIX: Increment health check cycle counter for throttling duplicate detection
+            this.healthCheckCycle++;
+            // FIX: Only run duplicate detection every N health checks (default every 5th = 2.5 min)
+            const shouldCheckDuplicates = this.healthCheckCycle % this.config.duplicateCheckInterval === 0;
             // FIX 4: Duplicate process detection during health monitoring
             // Check for multiple embedding server processes FOR THIS PROJECT and kill extras
             // PROJECT ISOLATION: Filter to only this project's processes before killing duplicates
+            if (!shouldCheckDuplicates) return; // Throttle: skip this cycle
             try {
                 const runningServers = await this.findRunningEmbeddingServers();
                 // PROJECT ISOLATION: Only consider processes belonging to this project

package/dist/tools/goofy/findCodePointers.js

@@ -410,6 +410,23 @@ export class FindCodePointers {
                 attribution: SPECMEM_ATTRIBUTION
             };
         }
+        // FAST FAIL: Invalid query detection - return immediately with format hint
+        const queryTrimmed = params.query.trim();
+        // Check for natural language questions (not code terms)
+        const isQuestion = /^(how|what|why|when|where|who|can|does|is|should|would|could)\s/i.test(queryTrimmed);
+        if (isQuestion && queryTrimmed.length > 50) {
+            // Likely a natural language question instead of code terms - fail fast with hint
+            logger.warn({ query: params.query }, '[CodePointers] Invalid query format detected - failing fast with hint');
+            return {
+                results: [],
+                query: params.query,
+                total_found: 0,
+                search_type: 'semantic',
+                attribution: SPECMEM_ATTRIBUTION,
+                error: 'INVALID_QUERY_FORMAT',
+                error_hint: 'Query appears to be a natural language question. For code search, use CODE TERMS like "admin login auth" NOT "how does admin login work". See /specmem/HOW_TO_USE.md for examples.'
+            };
+        }
         // MODE SELECTION: Return options if user wants to choose
         if (params.galleryMode === 'ask') {
             return this.returnModeOptions(params.query);

package/dist/tools/goofy/findWhatISaid.js

@@ -690,6 +690,25 @@ export class FindWhatISaid {
                     highlights: []
                 }];
         }
+        // FAST FAIL: Whitespace-only or clearly invalid query
+        const queryTrimmed = params.query.trim();
+        if (queryTrimmed.length < 2) {
+            logger.warn({ query: params.query }, '[find_memory] Query too short - failing fast');
+            return [{
+                memory: {
+                    id: 'error',
+                    content: 'Query too short. Provide at least 2 characters for meaningful search.',
+                    createdAt: new Date(),
+                    updatedAt: new Date(),
+                    tags: ['error'],
+                    importance: 'low',
+                    memoryType: 'semantic',
+                    metadata: { _isError: true }
+                },
+                similarity: 0,
+                highlights: []
+            }];
+        }
         logger.debug({ query: params.query, limit: params.limit }, 'searching memories fr');
         // Broadcast COT to dashboard
         cotStart('find_memory', params.query || 'browsing');

package/embedding-sandbox/frankenstein-embeddings.py

@@ -3916,20 +3916,21 @@ class EmbeddingServer:
             # Extract requestId for persistent socket multiplexing
             request_id = request.get('requestId')
 
-            # Send "processing" heartbeat ONLY for embedding requests (not health/kys/ready)
+            # Send "working" status ONLY for embedding requests (not health/kys/ready)
+            # "working" means actually processing your query (vs "processing" which was ambiguous)
             # Meta requests expect a single response - sending a heartbeat first breaks the protocol
             # and causes clients to read the heartbeat as the actual response
             if not is_meta_request:
                 text = request.get('text') or request.get('texts')
                 text_length = len(text) if isinstance(text, str) else (len(text) if text else 0)
                 heartbeat = {
-                    'status': 'processing',
+                    'status': 'working',
                     'text_length': text_length
                 }
                 if request_id:
                     heartbeat['requestId'] = request_id
                 hb_ok = self._safe_sendall(conn, json.dumps(heartbeat).encode('utf-8') + b'\n')
-                print(f"[WORKER {thread_name}] Heartbeat sent ok={hb_ok}", file=sys.stderr, flush=True)
+                print(f"[WORKER {thread_name}] Working status sent ok={hb_ok}", file=sys.stderr, flush=True)
 
             # Process - each thread gets its own call stack
             print(f"[WORKER {thread_name}] Calling handle_request(type={req_type})...", file=sys.stderr, flush=True)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "specmem-hardwicksoftware",
-  "version": "3.7.36",
+  "version": "3.7.38",
   "type": "module",
   "description": "Your Claude Code sessions don't have to start from scratch anymore — SpecMem gives your AI real memory. It won't forget your conversations, your code, or your architecture decisions between sessions. That's the whole point. Semantic code indexing that actually works: TypeScript, JavaScript, Python, Go, Rust, Java, Kotlin, C, C++, HTML and more. It doesn't just track functions — it gets classes, methods, fields, constants, enums, macros, imports, structs, the whole codebase graph. There's chat memory too, powered by pgvector embeddings. You've also got token compression, team coordination, multi-agent comms, and file watching built in. 74+ MCP tools. Runs on PostgreSQL + Docker. It's kind of a big deal. justcalljon.pro",
   "main": "dist/index.js",