specmem-hardwicksoftware 3.7.35 → 3.7.38

package/dist/codebase/pdfExtractor.js

@@ -0,0 +1,298 @@
+/**
+ * pdfExtractor.js — PDF text extraction for codebase indexing
+ *
+ * Spawns pdf-text-extract.py (PyMuPDF) as a child process.
+ * Digital PDFs: instant text extraction (0.003s/page).
+ * Scanned PDFs: Tesseract OCR fallback (1-3s/page).
+ *
+ * Used by codebaseIndexer.js and changeHandler.js to index PDF files
+ * alongside regular source code.
+ */
+import { spawn } from 'child_process';
+import { existsSync } from 'fs';
+import { join, dirname } from 'path';
+import { logger } from '../utils/logger.js';
+import { getPythonPath } from '../utils/projectEnv.js';
+
+const PDF_EXTRACT_TIMEOUT_MS = 60000; // 60s — generous for large scanned PDFs
+const MAX_PDF_PAGES = 100;
+
+// Cache the script path after first discovery
+let _cachedScriptPath = null;
+let _pymupdfAvailable = null; // null = unknown, true/false after first check
+
+/**
+ * Find the pdf-text-extract.py script.
+ * Search pattern matches miniCOTServerManager.findMiniCOTScript().
+ */
+function findPdfExtractScript() {
+    if (_cachedScriptPath && existsSync(_cachedScriptPath)) {
+        return _cachedScriptPath;
+    }
+
+    const specmemRoot = dirname(dirname(__dirname));
+    const possiblePaths = [
+        // SpecMem package root (works for all installs)
+        join(specmemRoot, 'embedding-sandbox', 'pdf-text-extract.py'),
+        // Direct package root (flat layout)
+        join(specmemRoot, 'pdf-text-extract.py'),
+        // Global npm install fallback
+        join(dirname(dirname(process.execPath)), 'lib', 'node_modules', 'specmem-hardwicksoftware', 'embedding-sandbox', 'pdf-text-extract.py'),
+    ];
+
+    for (const p of possiblePaths) {
+        if (existsSync(p)) {
+            _cachedScriptPath = p;
+            logger.debug({ path: p }, '[pdfExtractor] Found pdf-text-extract.py');
+            return p;
+        }
+    }
+
+    logger.warn({ searchedPaths: possiblePaths }, '[pdfExtractor] pdf-text-extract.py not found');
+    return null;
+}
+
+/**
+ * Extract text from a PDF file.
+ *
+ * @param {string} filePath - Absolute path to the PDF file
+ * @param {object} options - { maxPages?: number, language?: string }
+ * @returns {Promise<{text: string, pages: number, scannedPages?: number[], chars: number} | null>}
+ *          Returns null if extraction fails or pymupdf not available.
+ */
+export async function extractPdfText(filePath, options = {}) {
+    const { maxPages = MAX_PDF_PAGES, language = 'eng' } = options;
+
+    // Fast bail if we already know pymupdf is unavailable
+    if (_pymupdfAvailable === false) {
+        return null;
+    }
+
+    const scriptPath = findPdfExtractScript();
+    if (!scriptPath) {
+        logger.warn('[pdfExtractor] Cannot extract PDF — script not found');
+        return null;
+    }
+
+    const pythonPath = getPythonPath();
+
+    return new Promise((resolve) => {
+        const args = [scriptPath, filePath, '--max-pages', String(maxPages), '--language', language];
+        let stdout = '';
+        let stderr = '';
+        let resolved = false;
+
+        const proc = spawn(pythonPath, args, {
+            timeout: PDF_EXTRACT_TIMEOUT_MS,
+            stdio: ['ignore', 'pipe', 'pipe'],
+            env: { ...process.env },
+        });
+
+        const timeoutId = setTimeout(() => {
+            if (!resolved) {
+                resolved = true;
+                proc.kill('SIGKILL');
+                logger.warn({ filePath, timeoutMs: PDF_EXTRACT_TIMEOUT_MS }, '[pdfExtractor] PDF extraction timed out');
+                resolve(null);
+            }
+        }, PDF_EXTRACT_TIMEOUT_MS);
+
+        proc.stdout.on('data', (data) => { stdout += data.toString(); });
+        proc.stderr.on('data', (data) => { stderr += data.toString(); });
+
+        proc.on('close', (code) => {
+            clearTimeout(timeoutId);
+            if (resolved) return;
+            resolved = true;
+
+            if (stderr && stderr.includes('pymupdf not found')) {
+                _pymupdfAvailable = false;
+                logger.warn('[pdfExtractor] pymupdf not installed — PDF indexing disabled');
+                resolve(null);
+                return;
+            }
+
+            if (code !== 0) {
+                logger.warn({ filePath, code, stderr: stderr.slice(0, 200) }, '[pdfExtractor] PDF extraction failed');
+                resolve(null);
+                return;
+            }
+
+            try {
+                const result = JSON.parse(stdout.trim());
+                if (result.error) {
+                    logger.warn({ filePath, error: result.error }, '[pdfExtractor] PDF extraction error');
+                    resolve(null);
+                    return;
+                }
+
+                // Mark pymupdf as available on first success
+                if (_pymupdfAvailable === null) {
+                    _pymupdfAvailable = true;
+                }
+
+                resolve({
+                    text: result.text,
+                    pages: result.pages,
+                    chars: result.chars,
+                    scannedPages: result.scanned_pages || [],
+                    truncated: result.truncated || false,
+                    totalPages: result.total_pages || result.pages,
+                });
+            } catch (parseErr) {
+                logger.warn({ filePath, stdout: stdout.slice(0, 200) }, '[pdfExtractor] Failed to parse extraction result');
+                resolve(null);
+            }
+        });
+
+        proc.on('error', (err) => {
+            clearTimeout(timeoutId);
+            if (!resolved) {
+                resolved = true;
+                logger.warn({ filePath, error: err.message }, '[pdfExtractor] Failed to spawn Python');
+                resolve(null);
+            }
+        });
+    });
+}
+
+/**
+ * Extract text from multiple PDFs in a single Python process (batch mode).
+ * One Python startup for N PDFs — avoids interpreter overhead per file.
+ * Returns a Map<filePath, result> where result is the extraction output or null.
+ *
+ * @param {string[]} filePaths - Absolute paths to PDF files
+ * @param {object} options - { maxPages?: number, language?: string }
+ * @returns {Promise<Map<string, {text: string, pages: number, chars: number} | null>>}
+ */
+export async function extractPdfBatch(filePaths, options = {}) {
+    const { maxPages = MAX_PDF_PAGES, language = 'eng' } = options;
+    const results = new Map();
+
+    if (!filePaths.length) return results;
+
+    // Fast bail if pymupdf is known unavailable
+    if (_pymupdfAvailable === false) {
+        for (const fp of filePaths) results.set(fp, null);
+        return results;
+    }
+
+    const scriptPath = findPdfExtractScript();
+    if (!scriptPath) {
+        for (const fp of filePaths) results.set(fp, null);
+        return results;
+    }
+
+    const pythonPath = getPythonPath();
+    // Batch timeout: 60s base + 10s per PDF (scanned pages take 1-3s each)
+    const batchTimeout = PDF_EXTRACT_TIMEOUT_MS + (filePaths.length * 10000);
+
+    return new Promise((resolve) => {
+        const args = [scriptPath, '--batch', ...filePaths, '--max-pages', String(maxPages), '--language', language];
+        let stdout = '';
+        let stderr = '';
+        let resolved = false;
+
+        const proc = spawn(pythonPath, args, {
+            stdio: ['ignore', 'pipe', 'pipe'],
+            env: { ...process.env },
+        });
+
+        const timeoutId = setTimeout(() => {
+            if (!resolved) {
+                resolved = true;
+                proc.kill('SIGKILL');
+                logger.warn({ count: filePaths.length, timeoutMs: batchTimeout }, '[pdfExtractor] Batch extraction timed out');
+                // Return whatever we parsed so far + null for the rest
+                for (const fp of filePaths) {
+                    if (!results.has(fp)) results.set(fp, null);
+                }
+                resolve(results);
+            }
+        }, batchTimeout);
+
+        proc.stdout.on('data', (data) => { stdout += data.toString(); });
+        proc.stderr.on('data', (data) => { stderr += data.toString(); });
+
+        proc.on('close', (code) => {
+            clearTimeout(timeoutId);
+            if (resolved) return;
+            resolved = true;
+
+            if (stderr && stderr.includes('pymupdf not found')) {
+                _pymupdfAvailable = false;
+                logger.warn('[pdfExtractor] pymupdf not installed — PDF indexing disabled');
+                for (const fp of filePaths) results.set(fp, null);
+                resolve(results);
+                return;
+            }
+
+            // Parse JSONL — one JSON object per line
+            const lines = stdout.split('\n').filter(l => l.trim());
+            for (const line of lines) {
+                try {
+                    const result = JSON.parse(line);
+                    const path = result.path;
+                    if (!path) continue;
+
+                    if (result.error) {
+                        logger.warn({ path, error: result.error }, '[pdfExtractor] PDF extraction error');
+                        results.set(path, null);
+                        continue;
+                    }
+
+                    if (_pymupdfAvailable === null) _pymupdfAvailable = true;
+
+                    results.set(path, {
+                        text: result.text,
+                        pages: result.pages,
+                        chars: result.chars,
+                        scannedPages: result.scanned_pages || [],
+                        truncated: result.truncated || false,
+                        totalPages: result.total_pages || result.pages,
+                    });
+                } catch (e) {
+                    logger.debug({ line: line.slice(0, 100) }, '[pdfExtractor] Failed to parse JSONL line');
+                }
+            }
+
+            // Fill nulls for any missing paths
+            for (const fp of filePaths) {
+                if (!results.has(fp)) results.set(fp, null);
+            }
+
+            logger.info({
+                total: filePaths.length,
+                extracted: [...results.values()].filter(v => v !== null).length,
+                failed: [...results.values()].filter(v => v === null).length,
+            }, '[pdfExtractor] Batch extraction complete');
+
+            resolve(results);
+        });
+
+        proc.on('error', (err) => {
+            clearTimeout(timeoutId);
+            if (!resolved) {
+                resolved = true;
+                logger.warn({ error: err.message }, '[pdfExtractor] Failed to spawn Python for batch');
+                for (const fp of filePaths) results.set(fp, null);
+                resolve(results);
+            }
+        });
+    });
+}
+
+/**
+ * Check if PDF extraction is available (pymupdf installed + script found).
+ */
+export function isPdfExtractionAvailable() {
+    if (_pymupdfAvailable === false) return false;
+    return findPdfExtractScript() !== null;
+}
+
+/**
+ * Check if a file is a PDF by extension.
+ */
+export function isPdfFile(filePath) {
+    return filePath.toLowerCase().endsWith('.pdf');
+}

package/dist/dashboard/api/taskTeamMembers.js

@@ -1,7 +1,7 @@
 /**
- * taskTeamMembers.ts - API endpoints for Task team member tracking
+ * taskTeamMembers.ts - API endpoints for Agent team member tracking
  *
- * yo fr fr this lets you view and manually log Task team members
+ * yo fr fr this lets you view and manually log Agent team members
  */
 import { Router } from 'express';
 import { z } from 'zod';

package/dist/db/bigBrainMigrations.js

@@ -4388,6 +4388,35 @@ export class BigBrainMigrations {
           -- no-op: we only ADD COLUMN IF NOT EXISTS, nothing to reverse
         `,
                 checksum: this.generateChecksum('reconcile_code_definitions_columns_v37')
+            },
+            // migration 38: context vault — token-saving stash for thicc tool outputs
+            // chunks large content, indexes with tsvector for BM25 search,
+            // auto-expires after 24h. inspired by claude-context-mode but on postgres.
+            {
+                version: 38,
+                name: 'context_vault_table',
+                up: `
+          CREATE TABLE IF NOT EXISTS context_vault (
+            id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+            vault_id VARCHAR(16) NOT NULL,
+            chunk_idx INTEGER NOT NULL DEFAULT 0,
+            content TEXT NOT NULL,
+            content_tsv TSVECTOR GENERATED ALWAYS AS (to_tsvector('english', content)) STORED,
+            source_tool VARCHAR(128),
+            source_size INTEGER DEFAULT 0,
+            metadata JSONB DEFAULT '{}',
+            project_path VARCHAR(500) DEFAULT '/',
+            stashed_at TIMESTAMPTZ DEFAULT NOW(),
+            expires_at TIMESTAMPTZ DEFAULT (NOW() + INTERVAL '24 hours'),
+            UNIQUE(vault_id, chunk_idx)
+          );
+          CREATE INDEX IF NOT EXISTS idx_ctx_vault_tsv ON context_vault USING GIN(content_tsv);
+          CREATE INDEX IF NOT EXISTS idx_ctx_vault_id ON context_vault(vault_id);
+          CREATE INDEX IF NOT EXISTS idx_ctx_vault_expires ON context_vault(expires_at);
+          CREATE INDEX IF NOT EXISTS idx_ctx_vault_project ON context_vault(project_path);
+        `,
+                down: `DROP TABLE IF EXISTS context_vault;`,
+                checksum: this.generateChecksum('context_vault_table_v38')
             }
         ];
     }

package/dist/hooks/hookManager.js

@@ -486,7 +486,7 @@ export class HookManager {
         };
     }
     /**
-     * Create the team framing hook for Task tool interception
+     * Create the team framing hook for Agent tool interception
      * This hook injects "dev team" framing into spawned team members
      */
     createTeamFramingHook() {
@@ -495,7 +495,7 @@ export class HookManager {
 /**
  * Team Framing Hook for SpecMem
  *
- * PreToolUse hook that intercepts Task tool calls and injects
+ * PreToolUse hook that intercepts Agent tool calls and injects
  * a "dev team" framing prompt to spawned team members.
  *
  * The framing creates a psychological context where:
@@ -518,7 +518,7 @@ const DEFAULT_CONFIG = {
   enabled: true,
   channelName: 'dev-coordination',
   customPreprompt: '',
-  triggerTools: ['Task', 'task', 'spawn_agent', 'deploy_agent'],
+  triggerTools: ['Agent', 'agent', 'spawn_agent', 'deploy_agent'],
   includeMcpToolInstructions: true,
   seniorEngineerName: 'the senior engineer',
   teamName: 'the development team'
@@ -635,7 +635,7 @@ main().catch(() => process.exit(0));
             type: 'PreToolUse',
             enabled: true,
             file: hookPath,
-            description: 'Injects dev team framing into Task tool calls for team member spawning'
+            description: 'Injects dev team framing into Agent tool calls for team member spawning'
         });
         logger.info({ path: hookPath }, 'Created team framing hook');
         return hookPath;

package/dist/hooks/teamFramingCli.js

@@ -167,7 +167,7 @@ ${'-'.repeat(60)}
 async function runTest() {
     console.log('Running test with sample Task tool input...\n');
     const testInput = {
-        tool_name: 'Task',
+        tool_name: 'Agent',
         tool_input: {
             prompt: 'Implement the user authentication feature',
             description: 'Create login and registration flows'

package/dist/hooks/teamMemberPrepromptHook.js

@@ -2,7 +2,7 @@
  * SPECMEM TEAM_MEMBER PREPROMPT HOOK
  * ===================================
  *
- * Pre-tool hook that intercepts Task tool calls and injects a "dev team"
+ * Pre-tool hook that intercepts Agent tool calls and injects a "dev team"
  * framing prompt to all spawned team members (teamMembers).
  *
  * The framing creates a psychological context where:
@@ -11,10 +11,10 @@
  *   - Team communication tools encourage coordination
  *   - The artificial nature of the team is not revealed
  *
- * Hook Type: PreToolUse (intercepts Task tool calls before execution)
+ * Hook Type: PreToolUse (intercepts Agent tool calls before execution)
  *
  * Flow:
- *   1.  calls Task tool to spawn a team member
+ *   1.  calls Agent tool to spawn a team member
  *   2. This hook intercepts the call
  *   3. The prompt is modified to include team framing
  *   4. TeamMember spawns with team context + original task
@@ -36,7 +36,7 @@ export const DEFAULT_TEAM_CONFIG = {
     channelName: 'dev-coordination',
     customPreprompt: '',
     additionalContext: '',
-    triggerTools: ['Task', 'task', 'spawn_agent', 'deploy_agent'],
+    triggerTools: ['Agent', 'agent', 'spawn_agent', 'deploy_agent'],
     includeMcpToolInstructions: true,
     seniorEngineerName: 'the senior engineer',
     teamName: 'the development team'
@@ -152,7 +152,7 @@ function extractTaskDescription(toolInput) {
     return null;
 }
 /**
- * Main hook function - intercepts Task tool calls and injects team framing
+ * Main hook function - intercepts Agent tool calls and injects team framing
  *
  * @param toolName - Name of the tool being called
  * @param toolInput - Tool arguments/input

package/dist/index.js

@@ -382,8 +382,9 @@ class LocalEmbeddingProvider {
         if (this._socketCleanupInterval) {
             clearInterval(this._socketCleanupInterval);
         }
-        const cleanupIntervalMs = parseInt(process.env['SPECMEM_SOCKET_CLEANUP_INTERVAL_MS'] || '300000', 10);
-        const maxAgeMs = parseInt(process.env['SPECMEM_SOCKET_MAX_AGE_MS'] || '60000', 10);
+        // FIX: Reduced from 5min/60s to 30s/10s — 75+ leaked sockets cause EAGAIN on accept
+        const cleanupIntervalMs = parseInt(process.env['SPECMEM_SOCKET_CLEANUP_INTERVAL_MS'] || '30000', 10);
+        const maxAgeMs = parseInt(process.env['SPECMEM_SOCKET_MAX_AGE_MS'] || '10000', 10);
         this._socketCleanupInterval = setInterval(() => {
             const now = Date.now();
             let cleaned = 0;
@@ -604,7 +605,7 @@ class LocalEmbeddingProvider {
                             }, timeoutMs);
                         }
                         // Handle heartbeat/processing status - just reset timeout and continue
-                        if (response.status === 'processing') {
+                        if (response.status === 'working') {
                             __debugLog('[EMBEDDING DEBUG]', Date.now(), 'INIT_PERSISTENT_SOCKET_HEARTBEAT', {
                                 requestId,
                                 textLength: response.text_length
@@ -2041,7 +2042,9 @@ class LocalEmbeddingProvider {
             this._trackSocket(socket, `batch-${texts.length}`);
             let buffer = '';
             let resolved = false;
+            let workingReceived = false;
             const startTime = Date.now();
+            const WORKING_TIMEOUT_MS = 25000; // 25s to receive "working" status
             // FIX Issue #1: Ensure socket is destroyed on all exit paths
             const ensureSocketCleanup = () => {
                 try {
@@ -2068,6 +2071,14 @@ class LocalEmbeddingProvider {
                     reject(new Error(`Batch embedding timeout after ${Math.round(timeoutMs / 1000)}s for ${texts.length} texts`));
                 }
             }, timeoutMs);
+            // 25s timeout to receive "working" status - if not received, server may be stuck
+            let workingTimeout = setTimeout(() => {
+                if (!resolved && !workingReceived) {
+                    resolved = true;
+                    ensureSocketCleanup();
+                    reject(new Error(`Embedding server not responding (no 'working' status in 25s). Server may be overloaded or stuck.`));
+                }
+            }, WORKING_TIMEOUT_MS);
             socket.on('connect', () => {
                 __debugLog('[EMBEDDING DEBUG]', Date.now(), 'BATCH_SOCKET_CONNECTED', {
                     batchSize: texts.length,
@@ -2100,7 +2111,9 @@ class LocalEmbeddingProvider {
                     try {
                         const response = JSON.parse(responseJson);
                         // Skip heartbeat/processing status - keep waiting
-                        if (response.status === 'processing') {
+                        if (response.status === 'working') {
+                            workingReceived = true;
+                            clearTimeout(workingTimeout); // Server confirmed working
                             __debugLog('[EMBEDDING DEBUG]', Date.now(), 'BATCH_SOCKET_HEARTBEAT', {
                                 batchSize: texts.length,
                                 count: response.count,
@@ -2110,6 +2123,7 @@ class LocalEmbeddingProvider {
                         }
                         // Got actual response - resolve or reject
                         clearTimeout(timeout);
+                        clearTimeout(workingTimeout);
                         resolved = true;
                         ensureSocketCleanup();
                         const responseTime = Date.now() - startTime;
@@ -2132,6 +2146,7 @@ class LocalEmbeddingProvider {
                     }
                     catch (err) {
                         clearTimeout(timeout);
+                        clearTimeout(workingTimeout);
                         resolved = true;
                         ensureSocketCleanup();
                         reject(new Error(`Failed to parse batch embedding response: ${err}`));
@@ -2372,7 +2387,7 @@ class LocalEmbeddingProvider {
                     try {
                         const response = JSON.parse(line);
                         // HEARTBEAT: "processing" status means server is working - reset timeout and keep waiting
-                        if (response.status === 'processing') {
+                        if (response.status === 'working') {
                             clearTimeout(timeout);
                             timeout = setTimeout(() => {
                                 if (!resolved) {
@@ -2662,13 +2677,32 @@ class LocalEmbeddingProvider {
      * Takes socket path as parameter to ensure we ALWAYS use the fresh path.
      */
     async generateWithDirectSocket(text, socketPath) {
+        // FIX: Limit concurrent socket connections to prevent EAGAIN from socket exhaustion
+        // Without this, startup indexing fires 100+ concurrent requests, each opening a socket
+        const MAX_CONCURRENT_SOCKETS = 6;
+        if (!this._socketSemaphore) {
+            this._socketSemaphore = { count: 0, waiters: [] };
+        }
+        const sem = this._socketSemaphore;
+        if (sem.count >= MAX_CONCURRENT_SOCKETS) {
+            await new Promise(resolve => sem.waiters.push(resolve));
+        }
+        sem.count++;
+        const releaseSemaphore = () => {
+            sem.count--;
+            if (sem.waiters.length > 0) {
+                sem.waiters.shift()();
+            }
+        };
+        try {
         let lastError = null;
         for (let attempt = 1; attempt <= LocalEmbeddingProvider.SOCKET_MAX_RETRIES; attempt++) {
             try {
                 __debugLog('[EMBEDDING DEBUG]', Date.now(), 'DIRECT_SOCKET_ATTEMPT', {
                     attempt,
                     socketPath,
-                    maxRetries: LocalEmbeddingProvider.SOCKET_MAX_RETRIES
+                    maxRetries: LocalEmbeddingProvider.SOCKET_MAX_RETRIES,
+                    concurrentSockets: sem.count
                 });
                 return await this.generateWithDirectSocketAttempt(text, socketPath, attempt);
             }
@@ -2720,6 +2754,9 @@ class LocalEmbeddingProvider {
             `Socket: ${socketPath}. ` +
             `Last error: ${lastError?.message || 'unknown'}. ` +
             `Check if Frankenstein embedding service is running.`);
+        } finally {
+            releaseSemaphore();
+        }
     }
     /**
      * Single attempt to generate embedding via DIRECT socket connection
@@ -2806,7 +2843,7 @@ class LocalEmbeddingProvider {
                     try {
                         const response = JSON.parse(responseJson);
                         // Handle heartbeat/processing status - just keep waiting
-                        if (response.status === 'processing') {
+                        if (response.status === 'working') {
                             __debugLog('[EMBEDDING DEBUG]', Date.now(), 'DIRECT_SOCKET_HEARTBEAT', {
                                 socketPath,
                                 attempt,
@@ -3198,7 +3235,7 @@ class LocalEmbeddingProvider {
                     try {
                         const response = JSON.parse(responseJson);
                         // Handle heartbeat/processing status - just keep waiting
-                        if (response.status === 'processing') {
+                        if (response.status === 'working') {
                             continue;
                         }
                         // Got actual response - resolve or reject
@@ -4134,15 +4171,15 @@ async function main() {
                                     buffer = buffer.slice(idx + 1);
                                     try {
                                         const resp = JSON.parse(line);
-                                        if (resp.error) { clearTimeout(timeout); resolved = true; socket.end(); reject(new Error(resp.error)); return; }
-                                        if (resp.status === 'processing') continue;
+                                        if (resp.error) { clearTimeout(timeout); resolved = true; socket.destroy(); reject(new Error(resp.error)); return; }
+                                        if (resp.status === 'working' || resp.status === 'processing') continue;
                                         if (resp.embedding && Array.isArray(resp.embedding)) {
-                                            clearTimeout(timeout); resolved = true; socket.end(); resolve(resp.embedding); return;
+                                            clearTimeout(timeout); resolved = true; socket.destroy(); resolve(resp.embedding); return;
                                         }
                                     } catch (e) { /* ignore parse errors */ }
                                 }
                             });
-                            socket.on('error', (e) => { clearTimeout(timeout); if (!resolved) { resolved = true; reject(e); } });
+                            socket.on('error', (e) => { clearTimeout(timeout); if (!resolved) { resolved = true; socket.destroy(); reject(e); } });
                         });
                     },
                     generateEmbeddingsBatch: async (texts) => {

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',
@@ -727,7 +727,7 @@ function getRequiredHooks() {
         PreToolUse: [
             // CRITICAL: Agent loading hook for Task tool - injects SpecMem context & auto-backgrounds
             ...(fs.existsSync(HOOKS.agentLoading) ? [{
-                    matcher: 'Task',
+                    matcher: 'Agent',
                     hooks: [{
                             type: 'command',
                             command: `node ${HOOKS.agentLoading}`,
@@ -802,7 +802,7 @@ function getRequiredHooks() {
         // =========================================================================
         PostToolUse: [
             ...(fs.existsSync(HOOKS.taskProgress) ? [{
-                    matcher: 'Task',
+                    matcher: 'Agent',
                     hooks: [{
                             type: 'command',
                             command: `node ${HOOKS.taskProgress}`,
@@ -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' };