specmem-hardwicksoftware 3.7.9 → 3.7.11

package/scripts/specmem-init.cjs

@@ -2847,6 +2847,43 @@ async function coldStartEmbeddingDocker(projectPath, modelConfig, ui, codebaseRe
     return { serverRunning: false, warmupLatency: null, timeoutConfig };
   }
 
+  // EARLY BAIL-OUT: Check if Docker is actually usable before wasting time
+  // 1. Docker daemon must be running
+  // 2. The embedding image must exist locally (warm-start.sh uses specmem-embedding:latest)
+  // 3. OR there must be an existing container we can resume
+  // If none of these are true, skip Docker entirely — Stage 5 will use native Python.
+  try {
+    const { execSync } = require('child_process');
+    // Check if Docker daemon is accessible
+    try { execSync('docker info', { stdio: 'ignore', timeout: 5000 }); } catch {
+      initLog('[DOCKER] Docker daemon not accessible - skipping Docker stage');
+      ui.setSubStatus('⚠️ Docker not available - will use native Python');
+      return { serverRunning: false, warmupLatency: null, timeoutConfig };
+    }
+    // Check for existing specmem embedding containers (any state)
+    const containers = execSync(
+      `docker ps -a --filter "name=specmem-embedding" --format "{{.Names}}" 2>/dev/null`,
+      { encoding: 'utf8', timeout: 5000 }
+    ).trim();
+    if (!containers) {
+      // No containers — check if the image exists to cold-start from
+      const images = execSync(
+        `docker images -q specmem-embedding:latest 2>/dev/null`,
+        { encoding: 'utf8', timeout: 5000 }
+      ).trim();
+      if (!images) {
+        initLog('[DOCKER] No embedding containers and no specmem-embedding:latest image - skipping Docker');
+        ui.setSubStatus('⚠️ No Docker embedding image - will use native Python');
+        return { serverRunning: false, warmupLatency: null, timeoutConfig };
+      }
+    }
+    initLog(`[DOCKER] Found containers/image - proceeding with Docker warm-start`);
+  } catch (e) {
+    initLog(`[DOCKER] Pre-check failed (${e.message}) - skipping Docker`);
+    ui.setSubStatus('⚠️ Docker pre-check failed - will use native Python');
+    return { serverRunning: false, warmupLatency: null, timeoutConfig };
+  }
+
   // Spawn warm-start.sh with env vars for per-project socket
   const dockerProcess = spawn('bash', [warmStartScript], {
     cwd: path.dirname(warmStartScript),
@@ -2885,21 +2922,26 @@ async function coldStartEmbeddingDocker(projectPath, modelConfig, ui, codebaseRe
   });
 
   // Wait for Docker to start (up to 60s)
-  // RELIABILITY FIX: Increased from 24s (120x200ms) to 60s (300x200ms) to match
-  // warm-start.sh wait times. First-time model loading can take 20-30s.
+  // DYNAMIC WAIT: Poll for Docker socket with adaptive intervals (max 5min)
+  const MAX_DOCKER_WAIT_MS = 300000; // 5 minute absolute cap
   const dockerStart = Date.now();
   ui.setStatus('Waiting for Docker container...');
   ui.setSubProgress(0.3);
 
-  for (let i = 0; i < 300; i++) {
+  let dockerPollInterval = 200; // start fast for Docker
+  while (Date.now() - dockerStart < MAX_DOCKER_WAIT_MS) {
     if (dockerStarted || fs.existsSync(socketPath)) {
       break;
     }
-    await new Promise(r => setTimeout(r, 200));  // Faster polling (200ms)
-
-    // Smooth progress increment
-    if (i % 25 === 0) {
-      ui.setSubProgress(0.3 + (i / 300) * 0.4); // Progress from 30% to 70%
+    await new Promise(r => setTimeout(r, dockerPollInterval));
+    const elapsed = Date.now() - dockerStart;
+    // Slow down polling after 10s
+    if (elapsed > 10000) dockerPollInterval = Math.min(dockerPollInterval + 100, 2000);
+    // Progress update every ~5s
+    if (Math.floor(elapsed / 5000) !== Math.floor((elapsed - dockerPollInterval) / 5000)) {
+      const progress = Math.min(0.7, 0.3 + (elapsed / MAX_DOCKER_WAIT_MS) * 0.4);
+      ui.setSubProgress(progress);
+      ui.setSubStatus(`Waiting for Docker... (${Math.round(elapsed / 1000)}s)`);
     }
   }
 
@@ -3040,6 +3082,13 @@ async function coldStartEmbeddingDocker(projectPath, modelConfig, ui, codebaseRe
 // from the start. Previously, indexing only happened when MCP server started,
 // which meant the first  session had no code search capability.
 
+// CRITICAL BUG FIX: Track the PID of the embedding server spawned by THIS init
+// process. killExistingEmbeddingServer() must NEVER kill our own child.
+// Without this, the init process spawns the server, the server writes its PID
+// to embedding.pid, and then a later call to killExistingEmbeddingServer()
+// reads that PID file and SIGTERMs our own child process.
+let spawnedEmbeddingPid = null;
+
 async function indexCodebase(projectPath, ui, embeddingResult) {
   ui.setStage(5, 'CODEBASE INDEXING');
 
@@ -3071,16 +3120,114 @@ async function indexCodebase(projectPath, ui, embeddingResult) {
   initLog(`Socket paths: project=${projectSocketPath}, shared=${sharedSocketPath}`);
   initLog(`Project socket exists: ${fs.existsSync(projectSocketPath)}, Shared socket exists: ${fs.existsSync(sharedSocketPath)}`);
 
+  // SOCKET LIVENESS CHECK - validate socket is alive, not just that file exists
+  // Orphaned socket files (process died, socket file remains) cause ECONNREFUSED
+  // and stall the entire indexing pipeline.
+  function quickSocketAlive(sockPath) {
+    return new Promise((resolve) => {
+      const client = new net.Socket();
+      const timeout = setTimeout(() => { client.destroy(); resolve(false); }, 3000);
+      client.on('connect', () => { clearTimeout(timeout); client.destroy(); resolve(true); });
+      client.on('error', () => { clearTimeout(timeout); client.destroy(); resolve(false); });
+      client.connect(sockPath);
+    });
+  }
+
+  // DYNAMIC READINESS POLLING — no hardcoded timeouts.
+  // Polls for socket file + health check with adaptive intervals.
+  // Starts fast (500ms), slows down after 10s (2s intervals).
+  // Max wait: 300s (5 minutes). Returns true if server is ready.
+  const MAX_EMBED_WAIT_MS = 300000; // 5 minute absolute cap
+  async function waitForEmbeddingReady(sockPath, opts = {}) {
+    const { ui: _ui, label = 'server', logFn = initLog } = opts;
+    const start = Date.now();
+    let pollInterval = 500;   // start fast
+    let lastLogTime = 0;
+
+    while (Date.now() - start < MAX_EMBED_WAIT_MS) {
+      const elapsed = Date.now() - start;
+
+      // Phase 1: Wait for socket FILE to appear
+      if (!fs.existsSync(sockPath)) {
+        if (elapsed - lastLogTime > 5000) {
+          const elapsedSec = Math.round(elapsed / 1000);
+          if (_ui) _ui.setSubStatus(`Waiting for ${label} socket... (${elapsedSec}s)`);
+          logFn(`[EMBED] Waiting for socket file: ${sockPath} (${elapsedSec}s elapsed)`);
+          lastLogTime = elapsed;
+        }
+        await new Promise(r => setTimeout(r, pollInterval));
+        if (elapsed > 10000) pollInterval = Math.min(pollInterval + 250, 2000);
+        continue;
+      }
+
+      // Phase 2: Socket file exists — check if server is actually responding
+      const alive = await quickSocketAlive(sockPath);
+      if (alive) {
+        const elapsedSec = Math.round((Date.now() - start) / 1000);
+        logFn(`[EMBED] ${label} ready after ${elapsedSec}s`);
+        if (_ui) _ui.setSubStatus(`✓ ${label} ready (${elapsedSec}s)`);
+        return true;
+      }
+
+      // Socket exists but not responding yet — server still warming up
+      if (elapsed - lastLogTime > 3000) {
+        const elapsedSec = Math.round(elapsed / 1000);
+        if (_ui) _ui.setSubStatus(`${label} warming up... (${elapsedSec}s)`);
+        lastLogTime = elapsed;
+      }
+      await new Promise(r => setTimeout(r, pollInterval));
+      if (elapsed > 10000) pollInterval = Math.min(pollInterval + 250, 2000);
+    }
+
+    const totalSec = Math.round((Date.now() - start) / 1000);
+    logFn(`[EMBED] ${label} failed to become ready after ${totalSec}s (max ${MAX_EMBED_WAIT_MS / 1000}s)`);
+    if (_ui) _ui.setSubStatus(`⚠️ ${label} not ready after ${totalSec}s`);
+    return false;
+  }
+
   // Project socket takes priority - it's the fresh one from Docker stage 4
   let activeSocketPath = null;
   if (fs.existsSync(projectSocketPath)) {
-    activeSocketPath = projectSocketPath;
-    initLog(`Using PROJECT socket: ${projectSocketPath}`);
-  } else if (fs.existsSync(sharedSocketPath)) {
-    activeSocketPath = sharedSocketPath;
-    initLog(`Using SHARED socket: ${sharedSocketPath}`);
-  } else {
-    initLog('WARNING: No embedding socket found!');
+    const alive = await quickSocketAlive(projectSocketPath);
+    if (alive) {
+      activeSocketPath = projectSocketPath;
+      initLog(`Using PROJECT socket: ${projectSocketPath} (verified alive)`);
+    } else {
+      // CRITICAL FIX: Don't remove socket if our spawned server owns it.
+      // Check the PID file to see if this socket belongs to our child process.
+      const pidFile = path.join(projectPath, 'specmem', 'sockets', 'embedding.pid');
+      let ownedByUs = false;
+      if (spawnedEmbeddingPid) {
+        try {
+          if (fs.existsSync(pidFile)) {
+            const pidContent = fs.readFileSync(pidFile, 'utf8').trim();
+            const filePid = parseInt(pidContent.split(':')[0], 10);
+            if (filePid === spawnedEmbeddingPid) {
+              ownedByUs = true;
+              initLog(`PROJECT socket not yet responsive but owned by our spawned PID ${spawnedEmbeddingPid} - keeping socket, server may still be warming up`);
+              activeSocketPath = projectSocketPath; // Trust our child, it's just warming up
+            }
+          }
+        } catch { /* ignore */ }
+      }
+      if (!ownedByUs) {
+        initLog(`PROJECT socket exists but DEAD (ECONNREFUSED) - removing orphaned socket: ${projectSocketPath}`);
+        try { fs.unlinkSync(projectSocketPath); } catch {}
+      }
+    }
+  }
+  if (!activeSocketPath && fs.existsSync(sharedSocketPath)) {
+    const alive = await quickSocketAlive(sharedSocketPath);
+    if (alive) {
+      activeSocketPath = sharedSocketPath;
+      initLog(`Using SHARED socket: ${sharedSocketPath} (verified alive)`);
+    } else {
+      initLog(`SHARED socket exists but DEAD - removing orphaned socket: ${sharedSocketPath}`);
+      try { fs.unlinkSync(sharedSocketPath); } catch {}
+    }
+  }
+  if (!activeSocketPath) {
+    initLog('WARNING: No live embedding socket found! Will spawn new server.');
   }
 
   // Check if embedding server is available from Stage 4
@@ -3088,6 +3235,8 @@ async function indexCodebase(projectPath, ui, embeddingResult) {
   const socketExists = activeSocketPath !== null;
 
   // Helper: Kill any existing embedding server for this project before spawning a new one
+  // CRITICAL FIX: Never kill a server that was spawned by THIS init process.
+  // The spawnedEmbeddingPid variable tracks our child's PID to prevent self-kill.
   function killExistingEmbeddingServer(projectPath) {
     const pidFile = path.join(projectPath, 'specmem', 'sockets', 'embedding.pid');
     try {
@@ -3095,6 +3244,18 @@ async function indexCodebase(projectPath, ui, embeddingResult) {
       const content = fs.readFileSync(pidFile, 'utf8').trim();
       const pid = parseInt(content.split(':')[0], 10);
       if (!pid || isNaN(pid)) return false;
+
+      // CRITICAL FIX: Never kill our own child process!
+      // This prevents the race condition where:
+      // 1. Init spawns embedding server
+      // 2. Server writes PID to embedding.pid
+      // 3. Later code path calls killExistingEmbeddingServer()
+      // 4. It reads the PID file and kills our own child
+      if (spawnedEmbeddingPid && pid === spawnedEmbeddingPid) {
+        initLog(`[EMBED] Skipping kill of PID ${pid} - this is OUR spawned server`);
+        return false;
+      }
+
       // Check if process is alive
       try { process.kill(pid, 0); } catch {
         // Process dead, clean up PID file
@@ -3150,6 +3311,8 @@ async function indexCodebase(projectPath, ui, embeddingResult) {
       safeMkdir(socketsDir);
 
       // Kill any existing embedding server before spawning a new one
+      // Reset spawnedEmbeddingPid since we're about to spawn a replacement
+      spawnedEmbeddingPid = null;
       killExistingEmbeddingServer(projectPath);
 
       // Clean up stale socket
@@ -3177,6 +3340,7 @@ async function indexCodebase(projectPath, ui, embeddingResult) {
         cwd: path.dirname(embeddingScript),
         env: {
           ...process.env,
+          SPECMEM_EMBEDDING_SOCKET: projectSocketPath,
           SPECMEM_SOCKET_PATH: projectSocketPath,
           SPECMEM_PROJECT_PATH: projectPath
         },
@@ -3184,6 +3348,10 @@ async function indexCodebase(projectPath, ui, embeddingResult) {
         stdio: ['ignore', embedLogFd, embedLogFd]
       });
 
+      // CRITICAL FIX: Track spawned PID so killExistingEmbeddingServer() won't kill it
+      spawnedEmbeddingPid = embeddingProcess.pid;
+      initLog(`[EMBED] Spawned embedding server with PID ${spawnedEmbeddingPid} - tracking to prevent self-kill`);
+
       // error handler BEFORE unref - prevents silent spawn failures
       embeddingProcess.on('error', (err) => {
         ui.setSubStatus('Embedding spawn error: ' + err.message);
@@ -3194,20 +3362,11 @@ async function indexCodebase(projectPath, ui, embeddingResult) {
 
       embeddingProcess.unref();
 
-      // Wait for socket to appear (up to 60s)
-      // RELIABILITY FIX: Increased from 30s (60x500ms) to 60s (120x500ms)
-      // First-time model loading can take 20-30s, need enough buffer
+      // DYNAMIC WAIT: Poll for socket + health check with adaptive intervals (max 5min)
       ui.setSubStatus('Waiting for embedding server to start...');
-      for (let i = 0; i < 120; i++) {
-        await new Promise(r => setTimeout(r, 500));
-        if (fs.existsSync(projectSocketPath)) {
-          activeSocketPath = projectSocketPath;
-          ui.setSubStatus('✓ Embedding server started!');
-          break;
-        }
-        if (i % 10 === 0) {
-          ui.setSubStatus(`Waiting for embedding server... (${i/2}s)`);
-        }
+      const serverReady = await waitForEmbeddingReady(projectSocketPath, { ui, label: 'Embedding server' });
+      if (serverReady) {
+        activeSocketPath = projectSocketPath;
       }
 
       if (!activeSocketPath) {
@@ -3267,14 +3426,23 @@ async function indexCodebase(projectPath, ui, embeddingResult) {
       ui.setSubStatus('✓ Embedding server responding');
       initLog('Embedding socket test passed');
     } catch (e) {
-      ui.setSubStatus(`⚠️ Socket exists but not responding: ${e.message}`);
-      initLog(`Embedding socket test FAILED: ${e.message}`, e);
+      ui.setSubStatus(`⚠️ Socket test failed: ${e.message} - retrying...`);
+      initLog(`Embedding socket test FAILED: ${e.message} - will retry before killing`, e);
 
-      // CRITICAL FIX: Stale socket exists but nothing listening - clean up and restart!
+      // DYNAMIC READINESS POLL: Don't immediately kill — poll with adaptive intervals (max 5min)
+      const recovered = await waitForEmbeddingReady(activeSocketPath, { ui, label: 'Embedding server warmup' });
+
+      if (recovered) {
+        // Server is alive after retries - continue to indexing
+      } else {
+      // Server truly dead after 15s of retries - now kill and restart
+      // If this is our spawned server, it's been unresponsive for 15s - allow the kill
+      // by resetting spawnedEmbeddingPid (we're giving up on it)
       initLog('Attempting socket recovery - cleaning stale socket and restarting server...');
       ui.setStatus('Recovering embedding server...');
 
-      // Kill any existing embedding server before recovery
+      // Reset PID tracking since we're abandoning this server
+      spawnedEmbeddingPid = null;
       killExistingEmbeddingServer(projectPath);
 
       // Clean up the stale socket file
@@ -3313,49 +3481,15 @@ async function indexCodebase(projectPath, ui, embeddingResult) {
           ui.setSubStatus('Waiting for Docker container to recover...');
           const recoverStart = Date.now();
 
-          for (let i = 0; i < 120; i++) {
-            if (fs.existsSync(projectSocketPath)) {
-              break;
-            }
-            await new Promise(r => setTimeout(r, 500));
-            if (i % 10 === 0) {
-              ui.setSubStatus(`Recovery in progress... (${Math.round(i/2)}s)`);
-            }
-          }
-
+          // DYNAMIC WAIT: Poll for recovery with adaptive intervals (max 5min)
+          const recoveryReady = await waitForEmbeddingReady(projectSocketPath, { ui, label: 'Docker recovery' });
           const recoverLatency = Date.now() - recoverStart;
 
-          if (fs.existsSync(projectSocketPath)) {
+          if (recoveryReady) {
             initLog(`Docker recovery successful in ${recoverLatency}ms`);
-            ui.setSubStatus('✓ Embedding server recovered!');
             activeSocketPath = projectSocketPath;
-
-            // Verify the recovered socket is actually responding
-            try {
-              await new Promise((resolve, reject) => {
-                const verifyClient = new net.Socket();
-                let verifyData = '';
-                verifyClient.setTimeout(10000);
-                verifyClient.connect(projectSocketPath, () => {
-                  verifyClient.write(JSON.stringify({ type: 'embed', text: 'recovery test' }) + '\n');
-                });
-                verifyClient.on('data', chunk => {
-                  verifyData += chunk.toString();
-                  if (verifyData.includes('embedding') || verifyData.includes('processing')) {
-                    verifyClient.destroy();
-                    resolve(true);
-                  }
-                });
-                verifyClient.on('error', reject);
-                verifyClient.on('timeout', () => reject(new Error('timeout')));
-              });
-              initLog('Recovered socket verified - responding correctly');
-            } catch (verifyErr) {
-              initLog(`Recovered socket not responding: ${verifyErr.message}`);
-              activeSocketPath = null;
-            }
           } else {
-            initLog(`Docker recovery failed - socket not created after ${recoverLatency}ms`);
+            initLog(`Docker recovery failed after ${recoverLatency}ms`);
             activeSocketPath = null;
           }
         } catch (recoverErr) {
@@ -3366,7 +3500,8 @@ async function indexCodebase(projectPath, ui, embeddingResult) {
         initLog('warm-start.sh not found - cannot recover Docker container');
         activeSocketPath = null;  // Mark as unavailable
       }
-    }
+    } // end else (server truly dead after retries)
+    } // end catch
     await qqms();
   }
 
@@ -3398,13 +3533,19 @@ async function indexCodebase(projectPath, ui, embeddingResult) {
     initLog('Database connection test passed');
 
     // CRITICAL FIX: Create and set search_path to project schema for proper isolation
-    const schemaName = 'specmem_' + path.basename(projectPath).toLowerCase().replace(/[^a-z0-9]/g, '');
+    const schemaName = 'specmem_' + path.basename(projectPath).toLowerCase().replace(/[^a-z0-9_]/g, '_').replace(/_+/g, '_').replace(/^_|_$/g, '');
 
     // Create schema if it doesn't exist
     await pool.query(`CREATE SCHEMA IF NOT EXISTS ${schemaName}`);
     initLog(`Project schema ensured: ${schemaName}`);
 
-    // Set search_path for this connection
+    // Set search_path for ALL pool connections (not just the current one)
+    // pool.query() checks out different connections; SET only affects one.
+    // Using pool.on('connect') ensures every new connection gets the right search_path.
+    pool.on('connect', (client) => {
+      client.query(`SET search_path TO ${schemaName}, public`).catch(() => {});
+    });
+    // Also set it on the existing connection
     await pool.query(`SET search_path TO ${schemaName}, public`);
     initLog(`Database schema set to: ${schemaName}`);
     ui.setSubStatus(`Database connected (schema: ${schemaName})`);
@@ -3514,6 +3655,50 @@ async function indexCodebase(projectPath, ui, embeddingResult) {
     return results;
   }
 
+  // AUTO-CREATE codebase_files table if it doesn't exist
+  // CRITICAL: Init must not depend on MCP migrations having run first
+  // FIX: Use gen_random_uuid() (built-in PG13+) instead of uuid_generate_v4() (uuid-ossp extension)
+  // The uuid-ossp extension is installed in specmem_specmem schema, NOT public,
+  // so uuid_generate_v4() is unavailable when search_path is set to other project schemas.
+  // Also ensure vector extension exists in public schema (accessible to all project schemas).
+  try {
+    // vector extension must be in public schema so all project schemas can use vector type
+    await pool.query(`CREATE EXTENSION IF NOT EXISTS "vector" SCHEMA public`);
+    await pool.query(`
+      CREATE TABLE IF NOT EXISTS codebase_files (
+        id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+        file_path TEXT NOT NULL,
+        absolute_path TEXT NOT NULL,
+        file_name VARCHAR(255) NOT NULL,
+        extension VARCHAR(50),
+        language_id VARCHAR(50) NOT NULL DEFAULT 'unknown',
+        language_name VARCHAR(100) NOT NULL DEFAULT 'Unknown',
+        language_type VARCHAR(50) NOT NULL DEFAULT 'data',
+        content TEXT NOT NULL,
+        content_hash VARCHAR(64),
+        size_bytes INTEGER NOT NULL DEFAULT 0,
+        line_count INTEGER NOT NULL DEFAULT 0,
+        char_count INTEGER NOT NULL DEFAULT 0,
+        last_modified TIMESTAMPTZ NOT NULL DEFAULT NOW(),
+        chunk_index INTEGER,
+        total_chunks INTEGER,
+        original_file_id UUID,
+        embedding vector(384),
+        project_path TEXT DEFAULT '/',
+        created_at TIMESTAMPTZ NOT NULL DEFAULT NOW(),
+        updated_at TIMESTAMPTZ NOT NULL DEFAULT NOW(),
+        CONSTRAINT content_not_empty CHECK (length(content) > 0)
+      )
+    `);
+    await pool.query(`CREATE INDEX IF NOT EXISTS idx_codebase_files_content_hash ON codebase_files(content_hash)`);
+    await pool.query(`CREATE INDEX IF NOT EXISTS idx_codebase_files_path ON codebase_files(file_path)`);
+    await pool.query(`CREATE INDEX IF NOT EXISTS idx_codebase_files_project_path_file ON codebase_files(file_path, project_path)`);
+    await pool.query(`CREATE INDEX IF NOT EXISTS idx_codebase_files_project_path_hash ON codebase_files(project_path, content_hash)`);
+    initLog('[CODEBASE] Table codebase_files ensured');
+  } catch (e) {
+    initLog(`[CODEBASE] Table ensure warning: ${e.message}`);
+  }
+
   // Load existing hashes to skip unchanged files ONLY if they have embeddings
   // CRITICAL: Files without embeddings need to be re-indexed even if content matches!
   ui.setStatus('Checking existing index...');
@@ -3711,6 +3896,8 @@ async function indexCodebase(projectPath, ui, embeddingResult) {
         const socketsDir = path.join(projectPath, 'specmem', 'sockets');
         if (!fs.existsSync(socketsDir)) fs.mkdirSync(socketsDir, { recursive: true });
         // Kill any existing embedding server before respawn
+        // Reset spawnedEmbeddingPid since we're about to spawn a replacement
+        spawnedEmbeddingPid = null;
         killExistingEmbeddingServer(projectPath);
         // Clean stale socket
         if (fs.existsSync(projectSocketPath)) {
@@ -3723,28 +3910,26 @@ async function indexCodebase(projectPath, ui, embeddingResult) {
         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 },
+          env: { ...process.env, SPECMEM_EMBEDDING_SOCKET: projectSocketPath, SPECMEM_SOCKET_PATH: projectSocketPath, SPECMEM_PROJECT_PATH: projectPath },
           detached: true,
           stdio: ['ignore', revalLogFd, revalLogFd]
         });
+        // CRITICAL FIX: Track spawned PID so killExistingEmbeddingServer() won't kill it
+        spawnedEmbeddingPid = proc.pid;
+        initLog(`[EMBED] Revalidation spawned embedding server with PID ${spawnedEmbeddingPid} - tracking to prevent self-kill`);
         proc.on('error', () => {});
         fs.closeSync(revalLogFd);
         proc.unref();
-        // Wait up to 15s for socket to appear
-        for (let i = 0; i < 30; i++) {
-          await new Promise(r => setTimeout(r, 500));
-          if (fs.existsSync(projectSocketPath)) {
-            activeSocketPath = projectSocketPath;
-            const healthy = await checkSocketHealth();
-            if (healthy) {
-              initLog(`Embedding server auto-restarted successfully, socket at ${projectSocketPath}`);
-              consecutiveEmbeddingFailures = 0;
-              revalidateBackoffMs = 1000;
-              return true;
-            }
-          }
+        // DYNAMIC WAIT: Poll for readiness with adaptive intervals (max 5min)
+        const revalReady = await waitForEmbeddingReady(projectSocketPath, { label: 'Revalidation restart' });
+        if (revalReady) {
+          activeSocketPath = projectSocketPath;
+          initLog(`Embedding server auto-restarted successfully, socket at ${projectSocketPath}`);
+          consecutiveEmbeddingFailures = 0;
+          revalidateBackoffMs = 1000;
+          return true;
         }
-        initLog('Embedding server auto-restart: socket did not appear within 15s');
+        initLog('Embedding server auto-restart: server did not become ready');
       }
     } catch (restartErr) {
       initLog(`Embedding server auto-restart failed: ${restartErr.message || restartErr}`);
@@ -4152,6 +4337,136 @@ async function indexCodebase(projectPath, ui, embeddingResult) {
   let processed = 0;
   let lastUIUpdate = Date.now(); // throttle UI updates to reduce overhead
 
+  // Read maxConcurrent from model-config.json for parallel embedding batches
+  let embeddingMaxConcurrent = 3; // default
+  try {
+    const mcPath = path.join(projectPath, 'specmem', 'model-config.json');
+    if (fs.existsSync(mcPath)) {
+      const mc = JSON.parse(fs.readFileSync(mcPath, 'utf8'));
+      if (mc.embedding && mc.embedding.maxConcurrent) {
+        embeddingMaxConcurrent = mc.embedding.maxConcurrent;
+      }
+    }
+  } catch { /* use default */ }
+  initLog(`Embedding concurrency: ${embeddingMaxConcurrent} parallel batches`);
+
+  // STORE-THEN-EMBED: For large codebases (>1000 files), store files first
+  // then trigger Python server's batch processing (200 files/batch, direct DB)
+  if (files.length > 1000 && activeSocketPath) {
+    initLog(`Large codebase detected (${files.length} files) - using store-then-embed mode`);
+    ui.setStatus('Store-then-embed mode (large codebase)');
+    ui.setSubStatus('Phase 1: Storing files without embeddings...');
+
+    // Phase 1: Store all files without embeddings (fast - no socket calls)
+    await runWithConcurrency(files, async (filePath, idx) => {
+      try {
+        const relativePath = path.relative(projectPath, filePath);
+        const stats = fs.statSync(filePath);
+        if (stats.size > 500 * 1024) { results.filesSkipped++; return; }
+
+        // Binary check
+        const fd = fs.openSync(filePath, 'r');
+        const buf = Buffer.alloc(Math.min(8192, stats.size));
+        fs.readSync(fd, buf, 0, buf.length, 0);
+        fs.closeSync(fd);
+        if (buf.includes(0)) { results.filesSkipped++; return; }
+
+        const content = fs.readFileSync(filePath, 'utf-8');
+        const contentHash = crypto.createHash('sha256').update(content).digest('hex');
+
+        // Skip if already indexed with embedding
+        if (existingHashes.get(relativePath) === contentHash) {
+          results.filesSkipped++;
+          return;
+        }
+
+        const ext = path.extname(filePath).toLowerCase();
+        const lang = fileLanguageMap.get(filePath) || { id: 'unknown', name: 'Unknown' };
+        const lineCount = content.split('\n').length;
+        const fileId = uuidv4();
+
+        try {
+          await pool.query(`DELETE FROM codebase_files WHERE file_path = $1 AND project_path = $2`, [relativePath, projectPath]);
+        } catch { /* ignore */ }
+
+        await pool.query(`
+          INSERT INTO codebase_files (
+            id, file_path, absolute_path, file_name, extension,
+            language_id, language_name, content, content_hash,
+            size_bytes, line_count, project_path
+          ) VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12)
+        `, [
+          fileId, relativePath, filePath, path.basename(filePath), ext,
+          (lang.id || 'unknown').toLowerCase(), lang.name || 'Unknown',
+          content, contentHash, stats.size, lineCount, projectPath
+        ]);
+
+        results.filesIndexed++;
+        if (idx % 100 === 0) {
+          ui.setSubStatus(`Stored ${results.filesIndexed} / ${files.length} files...`);
+        }
+      } catch (e) {
+        results.errors.push(path.relative(projectPath, filePath) + ': ' + e.message);
+      }
+    }, parallelLimit);
+
+    initLog(`Phase 1 complete: ${results.filesIndexed} files stored without embeddings`);
+    ui.setSubStatus(`${results.filesIndexed} files stored, triggering server-side embedding...`);
+
+    // Phase 2: Trigger Python server's process_codebase endpoint
+    try {
+      const ssResult = await new Promise((resolve, reject) => {
+        const client = new net.Socket();
+        let buffer = '';
+        let settled = false;
+        const timeout = setTimeout(() => {
+          if (!settled) { settled = true; client.destroy(); reject(new Error('Server-side processing timeout (10min)')); }
+        }, 600000);
+        client.on('connect', () => {
+          client.write(JSON.stringify({ process_codebase: true, batch_size: 200, limit: 0, project_path: projectPath }) + '\n');
+        });
+        client.on('data', (data) => {
+          buffer += data.toString();
+          let newlineIdx;
+          while ((newlineIdx = buffer.indexOf('\n')) !== -1) {
+            if (settled) return;
+            const line = buffer.slice(0, newlineIdx);
+            buffer = buffer.slice(newlineIdx + 1);
+            try {
+              const resp = JSON.parse(line);
+              if (resp.error) { clearTimeout(timeout); settled = true; client.end(); reject(new Error(resp.error)); return; }
+              if (resp.status === 'processing') continue;
+              if (resp.total_processed !== undefined || resp.processed !== undefined) {
+                clearTimeout(timeout); settled = true; client.end(); resolve(resp); return;
+              }
+            } catch { /* keep waiting */ }
+          }
+        });
+        client.on('error', (e) => { clearTimeout(timeout); if (!settled) { settled = true; reject(e); } });
+        client.connect(activeSocketPath);
+      });
+
+      results.embeddingsGenerated = ssResult.total_processed || ssResult.processed || 0;
+      initLog(`Server-side embedding complete: ${results.embeddingsGenerated} embeddings generated`);
+      ui.setSubStatus(`Server-side: ${results.embeddingsGenerated} embeddings generated`);
+    } catch (ssErr) {
+      initLog(`Server-side embedding failed: ${ssErr.message} - falling back to client-side`);
+      ui.setSubStatus('Server-side failed, falling back to client-side...');
+      // Fall through to standard loop below (it will handle the remaining files)
+    }
+
+    // Skip the standard indexing loop
+    results.durationMs = Date.now() - startTime;
+    ui.enableFileFeed(false);
+    ui.slowRendering(0);
+    await pool.end();
+
+    initLog(`=== CODEBASE INDEXING COMPLETE (store-then-embed) ===`);
+    initLog(`Files: ${results.filesScanned} scanned, ${results.filesIndexed} indexed, ${results.embeddingsGenerated} embeddings`);
+    initLog(`Duration: ${results.durationMs}ms`);
+    return results;
+  }
+
   // Track current file for better progress display
   let currentFile = '';
   let currentFileChunk = 0;
@@ -4344,26 +4659,33 @@ async function indexCodebase(projectPath, ui, embeddingResult) {
       try {
         ui.setSubStatus(`Generating ${fileEmbedTexts.length} embeddings in batch...`);
 
-        // Split into smaller batches if needed
+        // Split into smaller batches
+        const embBatches = [];
         for (let j = 0; j < fileEmbedTexts.length; j += EMBEDDING_BATCH_SIZE) {
-          const textBatch = fileEmbedTexts.slice(j, j + EMBEDDING_BATCH_SIZE);
-          // FIX: Show which batch we're processing
-          const batchNum = Math.floor(j / EMBEDDING_BATCH_SIZE) + 1;
-          const totalBatches = Math.ceil(fileEmbedTexts.length / EMBEDDING_BATCH_SIZE);
-          if (totalBatches > 1) {
-            ui.setSubStatus(`Embedding batch ${batchNum}/${totalBatches} (${textBatch.length} files)...`);
+          embBatches.push({ start: j, texts: fileEmbedTexts.slice(j, j + EMBEDDING_BATCH_SIZE) });
+        }
+
+        // Process embedding batches with concurrency (uses maxConcurrent from model config)
+        const embResults = new Array(embBatches.length);
+        await runWithConcurrency(embBatches, async (batch, batchIdx) => {
+          const batchNum = batchIdx + 1;
+          if (embBatches.length > 1) {
+            ui.setSubStatus(`Embedding batch ${batchNum}/${embBatches.length} (${batch.texts.length} files)...`);
           }
-          // Show each file being embedded in this batch
-          for (let k = 0; k < textBatch.length; k++) {
-            const fileIdx = j + k;
+          for (let k = 0; k < batch.texts.length; k++) {
+            const fileIdx = batch.start + k;
             if (fileDataList[fileIdx]) {
               const fd = fileDataList[fileIdx];
               const sizeKB = (fd.stats.size / 1024).toFixed(1);
               ui.addFileToFeed(fd.relativePath, 'embedding', `(${sizeKB}KB)`);
             }
           }
-          const batchResults = await generateBatchEmbeddings(textBatch);
-          fileEmbeddings.push(...batchResults);
+          embResults[batchIdx] = await generateBatchEmbeddings(batch.texts);
+        }, embeddingMaxConcurrent);
+
+        // Flatten results in order
+        for (const br of embResults) {
+          if (br) fileEmbeddings.push(...br);
         }
 
         // Count successful embeddings
@@ -4377,7 +4699,6 @@ async function indexCodebase(projectPath, ui, embeddingResult) {
       } catch (e) {
         initLog(`Batch embedding failed: ${e.message}`);
         results.embeddingsFailed = (results.embeddingsFailed || 0) + fileEmbedTexts.length;
-        // FIX: Categorize error types for better debugging
         results.errorTypes = results.errorTypes || {};
         const errorType = categorizeEmbeddingError(e);
         results.errorTypes[errorType] = (results.errorTypes[errorType] || 0) + 1;
@@ -4447,27 +4768,31 @@ async function indexCodebase(projectPath, ui, embeddingResult) {
     let defEmbeddings = [];
     if (defEmbedTexts.length > 0 && activeSocketPath) {
       try {
-        // FIX: Show definition embedding progress
         ui.setSubStatus(`Embedding ${defEmbedTexts.length} definitions...`);
+        // Split into batches
+        const defBatches = [];
         for (let j = 0; j < defEmbedTexts.length; j += EMBEDDING_BATCH_SIZE) {
-          const textBatch = defEmbedTexts.slice(j, j + EMBEDDING_BATCH_SIZE);
-          // FIX: Show batch progress for large definition sets
-          const batchNum = Math.floor(j / EMBEDDING_BATCH_SIZE) + 1;
-          const totalBatches = Math.ceil(defEmbedTexts.length / EMBEDDING_BATCH_SIZE);
-          if (totalBatches > 1) {
-            ui.setSubStatus(`[Defs] Batch ${batchNum}/${totalBatches} (${textBatch.length} defs)...`);
+          defBatches.push({ start: j, texts: defEmbedTexts.slice(j, j + EMBEDDING_BATCH_SIZE) });
+        }
+        // Process with concurrency
+        const defResults = new Array(defBatches.length);
+        await runWithConcurrency(defBatches, async (batch, batchIdx) => {
+          if (defBatches.length > 1) {
+            ui.setSubStatus(`[Defs] Batch ${batchIdx + 1}/${defBatches.length} (${batch.texts.length} defs)...`);
           }
-          // Show each definition being embedded
-          for (let k = 0; k < textBatch.length; k++) {
-            const defIdx = j + k;
+          for (let k = 0; k < batch.texts.length; k++) {
+            const defIdx = batch.start + k;
             if (defDataList[defIdx]) {
               const dd = defDataList[defIdx];
               const defLabel = `${dd.def.type} ${dd.def.name}()`;
               ui.addFileToFeed(dd.relativePath, 'def', defLabel);
             }
           }
-          const batchResults = await generateBatchEmbeddings(textBatch);
-          defEmbeddings.push(...batchResults);
+          defResults[batchIdx] = await generateBatchEmbeddings(batch.texts);
+        }, embeddingMaxConcurrent);
+        // Flatten in order
+        for (const dr of defResults) {
+          if (dr) defEmbeddings.push(...dr);
         }
       } catch (e) {
         initLog(`Definition batch embedding failed: ${e.message}`);
@@ -4918,6 +5243,8 @@ async function extractSessions(projectPath, ui, embeddingResult = null) {
       safeMkdir(socketsDir);
 
       // Kill any existing embedding server before spawning for session extraction
+      // Reset spawnedEmbeddingPid since we're about to spawn a replacement
+      spawnedEmbeddingPid = null;
       killExistingEmbeddingServer(projectPath);
 
       // Clean up stale socket
@@ -4940,6 +5267,7 @@ async function extractSessions(projectPath, ui, embeddingResult = null) {
         cwd: path.dirname(embeddingScript),
         env: {
           ...process.env,
+          SPECMEM_EMBEDDING_SOCKET: projectSocketPath,
           SPECMEM_SOCKET_PATH: projectSocketPath,
           SPECMEM_PROJECT_PATH: projectPath
         },
@@ -4947,6 +5275,10 @@ async function extractSessions(projectPath, ui, embeddingResult = null) {
         stdio: ['ignore', sessEmbedLogFd, sessEmbedLogFd]
       });
 
+      // CRITICAL FIX: Track spawned PID so killExistingEmbeddingServer() won't kill it
+      spawnedEmbeddingPid = embeddingProcess.pid;
+      initLog(`[EMBED] Session extraction spawned embedding server with PID ${spawnedEmbeddingPid} - tracking to prevent self-kill`);
+
       // error handler BEFORE unref - prevents silent spawn failures
       embeddingProcess.on('error', (err) => {
         ui.setSubStatus('Embedding spawn error: ' + err.message);
@@ -4955,18 +5287,11 @@ async function extractSessions(projectPath, ui, embeddingResult = null) {
       fs.closeSync(sessEmbedLogFd);
       embeddingProcess.unref();
 
-      // Wait for socket to appear (up to 30s)
+      // DYNAMIC WAIT: Poll for readiness with adaptive intervals (max 5min)
       ui.setSubStatus('Waiting for embedding server to start...');
-      for (let i = 0; i < 60; i++) {
-        await new Promise(r => setTimeout(r, 500));
-        if (fs.existsSync(projectSocketPath)) {
-          socketPath = projectSocketPath;
-          ui.setSubStatus('✓ Embedding server started!');
-          break;
-        }
-        if (i % 10 === 0) {
-          ui.setSubStatus(`Waiting for embedding server... (${i/2}s)`);
-        }
+      const sessReady = await waitForEmbeddingReady(projectSocketPath, { ui, label: 'Session embedding server' });
+      if (sessReady) {
+        socketPath = projectSocketPath;
       }
 
       if (!socketPath) {
@@ -5186,12 +5511,15 @@ async function extractSessions(projectPath, ui, embeddingResult = null) {
     await pool.query('SELECT 1');
 
     // CRITICAL FIX: Create and set search_path to project schema for proper isolation
-    const schemaName = 'specmem_' + path.basename(projectPath).toLowerCase().replace(/[^a-z0-9]/g, '');
+    const schemaName = 'specmem_' + path.basename(projectPath).toLowerCase().replace(/[^a-z0-9_]/g, '_').replace(/_+/g, '_').replace(/^_|_$/g, '');
 
     // Create schema if it doesn't exist
     await pool.query(`CREATE SCHEMA IF NOT EXISTS ${schemaName}`);
 
-    // Set search_path for this connection
+    // Set search_path for ALL pool connections (not just the current one)
+    pool.on('connect', (client) => {
+      client.query(`SET search_path TO ${schemaName}, public`).catch(() => {});
+    });
     await pool.query(`SET search_path TO ${schemaName}, public`);
     ui.setSubStatus(`Connected (schema: ${schemaName})`);
 
@@ -5995,26 +6323,44 @@ async function runAutoSetup(projectPath) {
         // SpecMem hooks take priority for same event types + matchers
         const mergedSettings = { ...existingSettings };
 
-        // Fix hardcoded /root paths in srcSettings for non-root users
+        // Fix hardcoded paths in srcSettings for actual install environment
         const homeDir = os.homedir();
+        const pkgRoot = path.resolve(__dirname, '..');
         let srcSettingsStr = JSON.stringify(srcSettings);
         if (homeDir !== '/root') {
           srcSettingsStr = srcSettingsStr.replace(/\/root\//g, homeDir + '/');
           srcSettingsStr = srcSettingsStr.replace(/"\/root"/g, '"' + homeDir + '"');
         }
+        // Fix SPECMEM_PKG to point to actual install location (not dev /specmem)
+        srcSettingsStr = srcSettingsStr.replace(/"SPECMEM_PKG":\s*"\/specmem"/g, `"SPECMEM_PKG": "${pkgRoot}"`);
+        // Fix SPECMEM_HOME to use actual home directory
+        srcSettingsStr = srcSettingsStr.replace(/"SPECMEM_HOME":\s*"\/root\/.specmem"/g, `"SPECMEM_HOME": "${path.join(homeDir, '.specmem')}"`);
         const fixedSrcSettings = JSON.parse(srcSettingsStr);
 
         if (fixedSrcSettings.hooks) {
           mergedSettings.hooks = mergeHooksDeep(existingSettings.hooks || {}, fixedSrcSettings.hooks);
         }
 
-        // Helper function defined inline for merge logic
+        // Helper: check if a hook command belongs to specmem
+        function isSpecmemHookCmd(hookEntry) {
+          const cmd = (hookEntry.command || '');
+          return cmd.includes('specmem') || cmd.includes('team-comms-enforcer') ||
+                 cmd.includes('agent-loading-hook') || cmd.includes('agent-output-interceptor') ||
+                 cmd.includes('task-progress-hook') || cmd.includes('subagent-loading-hook') ||
+                 cmd.includes('use-code-pointers') || cmd.includes('post-write-memory-hook') ||
+                 cmd.includes('bullshit-radar') || cmd.includes('input-aware-improver') ||
+                 cmd.includes('smart-context-hook');
+        }
+
+        // Deep merge hooks: specmem hooks take priority per-matcher, but user's
+        // custom (non-specmem) hooks within the same matcher are preserved.
+        // On re-init, old specmem hooks are cleaned up and replaced with new ones.
         function mergeHooksDeep(existingHooks, specmemHooks) {
           const merged = {};
 
-          // Copy all existing event types first
+          // Copy all existing event types (deep clone to avoid mutations)
           for (const eventType of Object.keys(existingHooks)) {
-            merged[eventType] = [...existingHooks[eventType]];
+            merged[eventType] = JSON.parse(JSON.stringify(existingHooks[eventType]));
           }
 
           // Process each specmem event type
@@ -6022,44 +6368,61 @@ async function runAutoSetup(projectPath) {
             const specmemGroups = specmemHooks[eventType];
 
             if (!merged[eventType]) {
-              // No existing hooks for this event type, use specmem's
               merged[eventType] = specmemGroups;
               continue;
             }
 
-            // Build set of specmem matchers (undefined = catch-all)
-            const specmemMatchers = new Map();
+            // Build specmem's desired state: one entry per matcher
+            const specmemByMatcher = new Map();
             for (const group of specmemGroups) {
-              const matcherKey = group.matcher || '__CATCHALL__';
-              specmemMatchers.set(matcherKey, group);
+              const key = group.matcher || '__CATCHALL__';
+              if (!specmemByMatcher.has(key)) {
+                specmemByMatcher.set(key, { ...group, hooks: [...(group.hooks || [])] });
+              } else {
+                // Consolidate duplicate matchers from source
+                specmemByMatcher.get(key).hooks.push(...(group.hooks || []));
+              }
             }
 
-            // Filter existing groups:
-            // - Remove groups with same matcher as specmem (specmem takes priority)
-            // - Remove groups that contain specmem hook commands (avoid duplicates)
-            const preservedGroups = merged[eventType].filter(group => {
-              const matcherKey = group.matcher || '__CATCHALL__';
-
-              // If specmem has a hook for this matcher, remove existing
-              if (specmemMatchers.has(matcherKey)) {
-                return false;
+            // Extract user's custom (non-specmem) hooks per matcher from existing config
+            const userHooksByMatcher = new Map();
+            for (const group of merged[eventType]) {
+              const key = group.matcher || '__CATCHALL__';
+              const userHooks = (group.hooks || []).filter(h => !isSpecmemHookCmd(h));
+              if (userHooks.length > 0) {
+                if (!userHooksByMatcher.has(key)) {
+                  userHooksByMatcher.set(key, []);
+                }
+                userHooksByMatcher.get(key).push(...userHooks);
               }
+            }
 
-              // Check if this is a specmem hook (to avoid duplicates on re-init)
-              const groupStr = JSON.stringify(group);
-              if (groupStr.includes('specmem-') ||
-                  groupStr.includes('/specmem/') ||
-                  groupStr.includes('team-comms-enforcer') ||
-                  groupStr.includes('smart-context-hook') ||
-                  groupStr.includes('agent-loading-hook')) {
-                return false;
-              }
+            // Build final result for this event type
+            const result = [];
+            const handledMatchers = new Set();
 
-              return true; // Preserve user's custom hooks
-            });
+            // First: all specmem matchers (with user's custom hooks merged in)
+            for (const [key, group] of specmemByMatcher) {
+              const userHooks = userHooksByMatcher.get(key) || [];
+              result.push({ ...group, hooks: [...group.hooks, ...userHooks] });
+              handledMatchers.add(key);
+            }
+
+            // Then: existing matchers that specmem doesn't touch
+            for (const group of merged[eventType]) {
+              const key = group.matcher || '__CATCHALL__';
+              if (handledMatchers.has(key)) continue;
+              handledMatchers.add(key);
+
+              // Clean orphaned specmem hooks from non-specmem matchers
+              const cleanHooks = (group.hooks || []).filter(h => !isSpecmemHookCmd(h));
+              if (cleanHooks.length > 0) {
+                result.push({ ...group, hooks: cleanHooks });
+              }
+              // If 100% specmem hooks and specmem no longer uses this matcher, drop it
+            }
 
-            // Merge: user's preserved hooks first, then specmem hooks
-            merged[eventType] = [...preservedGroups, ...specmemGroups];
+            merged[eventType] = result;
           }
 
           return merged;