specmem-hardwicksoftware 3.5.99 → 3.6.1

package/dist/mcp/watcherIntegration.js

@@ -22,6 +22,12 @@ import { getProjectContext } from '../services/ProjectContext.js';
 import * as path from 'path';
 /** Map of projectPath -> WatcherState - each project isolated */
 const watcherStateByProject = new Map();
+/**
+ * Initialization lock per project - prevents double watcher initialization (Issue #12).
+ * Maps projectPath -> Promise that resolves when initialization completes.
+ * If init is already in progress, subsequent calls await the existing promise.
+ */
+const initializationLockByProject = new Map();
 /**
  * getWatcherState - get or create watcher state for a project
  * This is the key to per-project isolation - no more cross-pollution!
@@ -94,19 +100,48 @@ async function getWatchedPathsFromDb() {
  * Each SpecMem instance only watches its own project.
  */
 export async function initializeWatcher(embeddingProvider) {
-    // check if watcher is enabled in config
-    // config.watcher is always defined now (never undefined), check .enabled boolean
-    if (!config.watcher.enabled) {
-        logger.info('file watcher disabled in config (SPECMEM_WATCHER_ENABLED=false) - skipping initialization');
+    // check if watcher is EXPLICITLY disabled in config
+    // Default is ENABLED (true) - only skip if user explicitly set SPECMEM_WATCHER_ENABLED=false
+    const watcherEnabled = config.watcher?.enabled ?? true;
+    const envOverride = process.env['SPECMEM_WATCHER_ENABLED'];
+    // Only disable if explicitly set to 'false' - empty string, undefined, 'true' all mean enabled
+    if (envOverride === 'false' || (envOverride === undefined && watcherEnabled === false)) {
+        logger.info('file watcher EXPLICITLY disabled via SPECMEM_WATCHER_ENABLED=false - skipping initialization');
         return null;
     }
     const projectPath = getProjectPath();
     const state = getWatcherState(projectPath);
-    // Prevent re-initialization for the same project
+    // Issue #12 Fix: Check if watcher is already fully initialized for this project
     if (state.manager) {
-        logger.info({ projectPath }, 'watcher already initialized for this project');
+        logger.info({ projectPath }, 'watcher already initialized for this project - returning existing manager');
         return state.manager;
     }
+    // Issue #12 Fix: Promise-based initialization lock prevents double init race condition.
+    // If init is already in progress from another code path (MCP tool call, startup, reconnection),
+    // subsequent calls await the existing init promise instead of creating a second watcher.
+    if (initializationLockByProject.has(projectPath)) {
+        logger.warn({ projectPath }, 'watcher initialization already in progress - awaiting existing init (preventing double init race condition)');
+        return await initializationLockByProject.get(projectPath);
+    }
+    // Create the initialization promise and store it as the lock
+    const initPromise = _doInitializeWatcher(embeddingProvider, projectPath, state);
+    initializationLockByProject.set(projectPath, initPromise);
+    try {
+        const result = await initPromise;
+        return result;
+    }
+    finally {
+        // Always release the lock when init completes (success or failure)
+        initializationLockByProject.delete(projectPath);
+    }
+}
+/**
+ * _doInitializeWatcher - internal init logic, called once per project under lock
+ *
+ * Separated from initializeWatcher to keep the lock logic clean.
+ * This function does the actual work of creating and starting the watcher.
+ */
+async function _doInitializeWatcher(embeddingProvider, projectPath, state) {
     logger.info({ projectPath }, 'initializing PROJECT-SCOPED file watcher...');
     try {
         // get database context - check if it's initialized first
@@ -136,13 +171,17 @@ export async function initializeWatcher(embeddingProvider) {
             paths: watchPaths,
             source: dbPaths.length > 0 ? 'database (project-scoped)' : 'project path only'
         }, 'resolved PROJECT-SCOPED watch paths');
+        // Issue #12 Fix: Watcher event debounce is configurable via SPECMEM_WATCHER_DEBOUNCE_MS
+        // Default is 1000ms. This prevents excessive processing of rapid file change events.
+        const debounceMs = parseInt(process.env['SPECMEM_WATCHER_DEBOUNCE_MS'] || String(config.watcher.debounceMs || 1000), 10);
+        logger.info({ debounceMs }, 'using configurable watcher debounce delay');
         // build watcher config
         const watcherConfig = {
             watcher: {
                 rootPath: primaryPath,
                 additionalPaths: additionalPaths,
                 ignorePath: config.watcher.ignorePath,
-                debounceMs: config.watcher.debounceMs,
+                debounceMs: debounceMs,
                 autoRestart: config.watcher.autoRestart,
                 maxRestarts: config.watcher.maxRestarts,
                 verbose: config.logging.level === 'debug' || config.logging.level === 'trace'
@@ -226,12 +265,16 @@ export async function initializeWatcher(embeddingProvider) {
             projectPath,
             paths: watchPaths,
             syncCheckIntervalMinutes: config.watcher.syncCheckIntervalMinutes,
+            debounceMs: debounceMs,
             filesWatched: status.watcher.filesWatched
         }, 'PROJECT-SCOPED file watcher initialized and VERIFIED running');
         return state.manager;
     }
     catch (error) {
         logger.error({ error, projectPath }, 'failed to initialize project-scoped file watcher');
+        // Clean up state on failure so a retry can succeed
+        state.manager = null;
+        state.watchedPaths.clear();
         return null;
     }
 }

package/dist/services/CameraZoomSearch.js

@@ -40,14 +40,64 @@ class DrilldownRegistry {
     registry = new Map();
     reverseRegistry = new Map();
     nextID = 1;
-    maxEntries = 10000;
-    constructor() { }
+    maxEntries = parseInt(process.env['SPECMEM_DRILLDOWN_MAX_SIZE'] || '10000');
+    ttlMs = parseInt(process.env['SPECMEM_DRILLDOWN_TTL_MS'] || '1800000'); // 30 min default
+    cleanupIntervalMs = parseInt(process.env['SPECMEM_DRILLDOWN_CLEANUP_INTERVAL_MS'] || '300000'); // 5 min default
+    _cleanupTimer = null;
+    constructor() {
+        // Start periodic TTL cleanup
+        this._startPeriodicCleanup();
+    }
     static getInstance() {
         if (!DrilldownRegistry.instance) {
             DrilldownRegistry.instance = new DrilldownRegistry();
         }
         return DrilldownRegistry.instance;
     }
+    /**
+     * Start periodic cleanup timer for TTL-expired entries
+     */
+    _startPeriodicCleanup() {
+        if (this._cleanupTimer) {
+            clearInterval(this._cleanupTimer);
+        }
+        this._cleanupTimer = setInterval(() => {
+            this._expireTTLEntries();
+        }, this.cleanupIntervalMs);
+        // Allow the process to exit even if the timer is running
+        if (this._cleanupTimer && typeof this._cleanupTimer.unref === 'function') {
+            this._cleanupTimer.unref();
+        }
+        logger.debug({ cleanupIntervalMs: this.cleanupIntervalMs, ttlMs: this.ttlMs }, 'DrilldownRegistry periodic TTL cleanup started');
+    }
+    /**
+     * Remove entries that have exceeded their TTL
+     */
+    _expireTTLEntries() {
+        const now = Date.now();
+        let expiredCount = 0;
+        for (const [id, entry] of this.registry.entries()) {
+            const lastTouched = entry.lastAccessed?.getTime() || entry.createdAt.getTime();
+            if ((now - lastTouched) > this.ttlMs) {
+                this.registry.delete(id);
+                this.reverseRegistry.delete(entry.memoryID);
+                expiredCount++;
+            }
+        }
+        if (expiredCount > 0) {
+            logger.info({ expiredCount, remaining: this.registry.size, ttlMs: this.ttlMs }, 'DrilldownRegistry TTL expiration: removed stale entries');
+        }
+    }
+    /**
+     * Stop the periodic cleanup timer (for shutdown)
+     */
+    shutdown() {
+        if (this._cleanupTimer) {
+            clearInterval(this._cleanupTimer);
+            this._cleanupTimer = null;
+            logger.debug('DrilldownRegistry cleanup timer cleared on shutdown');
+        }
+    }
     /**
      * Register a memory and get its drilldown ID
      * Returns existing ID if already registered
@@ -58,6 +108,7 @@ class DrilldownRegistry {
         if (existing !== undefined) {
             const entry = this.registry.get(existing);
             if (entry) {
+                // Refresh TTL on access
                 entry.lastAccessed = new Date();
                 entry.accessCount++;
             }
@@ -70,12 +121,13 @@ class DrilldownRegistry {
             memoryID,
             type,
             createdAt: new Date(),
+            lastAccessed: new Date(),
             accessCount: 1,
             ...context
         };
         this.registry.set(drilldownID, entry);
         this.reverseRegistry.set(memoryID, drilldownID);
-        // Cleanup old entries if needed
+        // Cleanup old entries if needed (LRU eviction when over max size)
         this.cleanup();
         logger.debug({ drilldownID, memoryID, type }, 'Registered drilldown ID');
         return drilldownID;
@@ -88,6 +140,7 @@ class DrilldownRegistry {
         if (typeof drilldownID === 'number') {
             const entry = this.registry.get(drilldownID);
             if (entry) {
+                // Refresh TTL on access (touch)
                 entry.lastAccessed = new Date();
                 entry.accessCount++;
                 return entry;
@@ -106,6 +159,7 @@ class DrilldownRegistry {
             for (const [id, entry] of this.registry.entries()) {
                 const memID = entry.memoryID.toLowerCase().replace(/-/g, '');
                 if (memID.startsWith(shortCode) || memID.includes(shortCode)) {
+                    // Refresh TTL on access (touch)
                     entry.lastAccessed = new Date();
                     entry.accessCount++;
                     return entry;
@@ -132,7 +186,7 @@ class DrilldownRegistry {
         return result;
     }
     /**
-     * Cleanup old entries when registry is full
+     * Cleanup old entries when registry is full (LRU eviction)
      */
     cleanup() {
         if (this.registry.size <= this.maxEntries)
@@ -151,7 +205,7 @@ class DrilldownRegistry {
             this.registry.delete(id);
             this.reverseRegistry.delete(entry.memoryID);
         }
-        logger.info({ removed: toRemove, remaining: this.registry.size }, 'Cleaned up drilldown registry');
+        logger.info({ removed: toRemove, remaining: this.registry.size }, 'Cleaned up drilldown registry (LRU eviction)');
     }
     /**
      * Get registry stats
@@ -161,6 +215,9 @@ class DrilldownRegistry {
         const dates = entries.map(e => e.createdAt.getTime());
         return {
             totalEntries: this.registry.size,
+            maxEntries: this.maxEntries,
+            ttlMs: this.ttlMs,
+            cleanupIntervalMs: this.cleanupIntervalMs,
             oldestEntry: dates.length > 0 ? new Date(Math.min(...dates)) : undefined,
             newestEntry: dates.length > 0 ? new Date(Math.max(...dates)) : undefined
         };

package/dist/services/DimensionService.js

@@ -41,15 +41,27 @@ const EMBEDDING_TABLES = [
 /**
  * Service for dynamic embedding dimension management.
  * All dimension lookups go through the database - no hardcoded values.
+ *
+ * Issue #15 FIX: Cache TTL is now configurable via SPECMEM_DIMENSION_CACHE_TTL_MS (default 300000 = 5min).
+ * Stale cache entries are kept as fallback on fetch failure but logged as warnings.
+ * Dimension override via SPECMEM_EMBEDDING_DIMENSIONS env var.
+ * invalidateCache() method for embedding service restart coordination.
  */
 export class DimensionService {
     db;
     embeddingProvider = null;
     dimensionCache = new Map();
-    CACHE_TTL_MS = 60000; // 1 minute cache to avoid repeated queries
+    // Issue #15 FIX: Cache TTL is env-var configurable (default 5 minutes)
+    CACHE_TTL_MS = parseInt(process.env['SPECMEM_DIMENSION_CACHE_TTL_MS'] || '300000', 10);
+    // Issue #15 FIX: Track last successful verification timestamp
+    lastVerified = null;
     constructor(db, embeddingProvider) {
         this.db = db;
         this.embeddingProvider = embeddingProvider || null;
+        logger.info({
+            cacheTtlMs: this.CACHE_TTL_MS,
+            dimensionOverride: process.env['SPECMEM_EMBEDDING_DIMENSIONS'] || 'auto-detect'
+        }, 'DimensionService initialized with configurable cache TTL (Issue #15 fix)');
     }
     /**
      * Set the embedding provider (for lazy initialization)
@@ -66,12 +78,23 @@ export class DimensionService {
      * @returns The dimension, or null if table/column doesn't exist
      */
     async getTableDimension(tableName, columnName = 'embedding') {
-        // Check cache first
+        // Issue #15 FIX: Check for dimension override via env var (skip DB entirely)
+        const dimensionOverride = parseInt(process.env['SPECMEM_EMBEDDING_DIMENSIONS'] || '0', 10);
+        if (dimensionOverride > 0) {
+            logger.debug({ dimensionOverride, tableName }, 'Using SPECMEM_EMBEDDING_DIMENSIONS override');
+            return dimensionOverride;
+        }
+        // Check cache first - Issue #15 FIX: Use configurable TTL
         const cacheKey = `${tableName}.${columnName}`;
         const cached = this.dimensionCache.get(cacheKey);
         if (cached && Date.now() - cached.timestamp < this.CACHE_TTL_MS) {
             return cached.dimension;
         }
+        // Issue #15 FIX: If cache expired, log it for debugging stale cache issues
+        if (cached) {
+            const ageMs = Date.now() - cached.timestamp;
+            logger.debug({ cacheKey, ageMs, ttl: this.CACHE_TTL_MS }, 'Dimension cache expired, re-fetching from database');
+        }
         try {
             const result = await this.db.query(`SELECT atttypmod FROM pg_attribute
          WHERE attrelid = $1::regclass AND attname = $2`, [tableName, columnName]);
@@ -80,14 +103,28 @@ export class DimensionService {
                 return null;
             }
             const dimension = result.rows[0].atttypmod;
-            // Cache the result
+            // Cache the result with timestamp for TTL and lastVerified tracking
             this.dimensionCache.set(cacheKey, { dimension, timestamp: Date.now() });
+            this.lastVerified = Date.now();
             logger.debug({ tableName, columnName, dimension }, 'Retrieved vector dimension from database');
             return dimension;
         }
         catch (error) {
-            // Table might not exist yet
-            logger.debug({ error, tableName, columnName }, 'Failed to get dimension (table may not exist)');
+            // Issue #15 FIX: If fetch fails but we have a stale cached value, use it
+            // and log a warning. This prevents dimension mismatch errors during transient DB issues.
+            if (cached) {
+                logger.warn({
+                    error: error instanceof Error ? error.message : String(error),
+                    tableName,
+                    columnName,
+                    staleDimension: cached.dimension,
+                    staleAgeMs: Date.now() - cached.timestamp
+                }, 'Failed to refresh dimension from DB - using stale cached value. Will retry on next access.');
+                // Do NOT update the timestamp - keep it stale so next access retries
+                return cached.dimension;
+            }
+            // Table might not exist yet and no cache to fall back on
+            logger.debug({ error, tableName, columnName }, 'Failed to get dimension (table may not exist, no cache fallback)');
             return null;
         }
     }
@@ -238,18 +275,30 @@ export class DimensionService {
     }
     /**
      * Get cache statistics for debugging.
+     * Issue #15 FIX: Now includes lastVerified, TTL, and stale entry info.
      */
     getCacheStats() {
         const entries = [];
         const now = Date.now();
+        let staleCount = 0;
         this.dimensionCache.forEach((entry, key) => {
+            const age = now - entry.timestamp;
+            const isStale = age >= this.CACHE_TTL_MS;
+            if (isStale) staleCount++;
             entries.push({
                 key,
-                age: now - entry.timestamp
+                age,
+                isStale,
+                dimension: entry.dimension
             });
         });
         return {
             size: this.dimensionCache.size,
+            staleCount,
+            cacheTtlMs: this.CACHE_TTL_MS,
+            lastVerified: this.lastVerified,
+            lastVerifiedAge: this.lastVerified ? now - this.lastVerified : null,
+            dimensionOverride: parseInt(process.env['SPECMEM_EMBEDDING_DIMENSIONS'] || '0', 10) || null,
             entries
         };
     }
@@ -313,6 +362,24 @@ export class DimensionService {
         });
         keysToDelete.forEach(key => this.dimensionCache.delete(key));
     }
+    /**
+     * Issue #15 FIX: Invalidate ALL cached dimensions.
+     * Call this when the embedding service restarts or the model changes.
+     * The next dimension request will re-fetch from the database.
+     */
+    invalidateCache() {
+        const cacheSize = this.dimensionCache.size;
+        this.dimensionCache.clear();
+        this.lastVerified = null;
+        logger.info({ clearedEntries: cacheSize }, 'DimensionService cache invalidated (embedding service restart or model change)');
+    }
+    /**
+     * Issue #15 FIX: Get the timestamp of the last successful dimension verification.
+     * Returns null if no verification has occurred since startup/last invalidation.
+     */
+    getLastVerified() {
+        return this.lastVerified;
+    }
     /**
      * Validate a query embedding against a table's expected dimension.
      *

package/dist/services/EmbeddingQueue.js

@@ -24,10 +24,21 @@ export class EmbeddingQueue {
     projectId;
     initialized = false;
     pendingCallbacks = new Map();
+    // Track when each callback was queued for expiry cleanup
+    callbackTimestamps = new Map();
     isDraining = false;
+    // Configurable limits via environment variables
+    maxQueueAge = parseInt(process.env['SPECMEM_EMBED_QUEUE_MAX_AGE_MS'] || '300000'); // 5 min default
+    cleanupIntervalMs = parseInt(process.env['SPECMEM_EMBED_QUEUE_CLEANUP_INTERVAL_MS'] || '60000'); // 1 min default
+    maxQueueSize = parseInt(process.env['SPECMEM_EMBED_QUEUE_MAX_SIZE'] || '500');
+    cleanupTimer = null;
     constructor(pool) {
         this.pool = pool;
         this.projectId = getProjectDirName();
+        // Start periodic cleanup of expired callbacks
+        this.cleanupTimer = setInterval(() => {
+            this.expireStaleCallbacks();
+        }, this.cleanupIntervalMs);
         // CRITICAL: Set search_path on every new connection to ensure queries
         // hit the correct project schema, not public
         this.pool.on('connect', async (client) => {
@@ -82,6 +93,12 @@ export class EmbeddingQueue {
      */
     async queueForEmbedding(text, priority = 5) {
         await this.initialize();
+        // Reject new items when queue is full
+        if (this.pendingCallbacks.size >= this.maxQueueSize) {
+            const err = new Error(`EmbeddingQueue full (${this.pendingCallbacks.size}/${this.maxQueueSize}) - rejecting new request`);
+            logger.warn({ pendingCount: this.pendingCallbacks.size, maxQueueSize: this.maxQueueSize }, err.message);
+            throw err;
+        }
         return new Promise(async (resolve, reject) => {
             try {
                 // Insert into queue
@@ -107,6 +124,8 @@ export class EmbeddingQueue {
                         reject(new Error('No embedding returned'));
                     }
                 });
+                // Track when this callback was added for expiry
+                this.callbackTimestamps.set(queueId, Date.now());
             }
             catch (err) {
                 logger.error({ err, text: text.substring(0, 50) }, 'Failed to queue embedding');
@@ -191,6 +210,7 @@ export class EmbeddingQueue {
                         if (callback) {
                             callback(embedding);
                             this.pendingCallbacks.delete(item.id);
+                            this.callbackTimestamps.delete(item.id);
                         }
                         processed++;
                         logger.debug({ queueId: item.id, processed }, 'Processed queued embedding');
@@ -206,6 +226,7 @@ export class EmbeddingQueue {
                         if (callback) {
                             callback(null, err instanceof Error ? err : new Error(errorMsg));
                             this.pendingCallbacks.delete(item.id);
+                            this.callbackTimestamps.delete(item.id);
                         }
                         logger.warn({ queueId: item.id, error: errorMsg }, 'Failed to process queued embedding');
                     }
@@ -218,6 +239,49 @@ export class EmbeddingQueue {
         }
         return processed;
     }
+    /**
+     * Expire stale callbacks that have been waiting longer than maxQueueAge.
+     * Called periodically by the cleanup timer to prevent unbounded callback growth.
+     */
+    expireStaleCallbacks() {
+        const now = Date.now();
+        let expiredCount = 0;
+        for (const [queueId, timestamp] of this.callbackTimestamps.entries()) {
+            if (now - timestamp > this.maxQueueAge) {
+                const callback = this.pendingCallbacks.get(queueId);
+                if (callback) {
+                    callback(null, new Error(`EmbeddingQueue callback expired after ${this.maxQueueAge}ms (queueId: ${queueId})`));
+                    this.pendingCallbacks.delete(queueId);
+                }
+                this.callbackTimestamps.delete(queueId);
+                expiredCount++;
+            }
+        }
+        if (expiredCount > 0) {
+            logger.warn({ expiredCount, remainingCallbacks: this.pendingCallbacks.size }, 'Expired stale EmbeddingQueue callbacks');
+        }
+    }
+    /**
+     * Shutdown the queue - clears cleanup timer and rejects all pending callbacks.
+     * Must be called when the EmbeddingQueue is no longer needed.
+     */
+    shutdown() {
+        if (this.cleanupTimer) {
+            clearInterval(this.cleanupTimer);
+            this.cleanupTimer = null;
+        }
+        // Reject all remaining pending callbacks
+        let rejectedCount = 0;
+        for (const [queueId, callback] of this.pendingCallbacks.entries()) {
+            callback(null, new Error('EmbeddingQueue shutting down'));
+            rejectedCount++;
+        }
+        this.pendingCallbacks.clear();
+        this.callbackTimestamps.clear();
+        if (rejectedCount > 0) {
+            logger.info({ rejectedCount }, 'EmbeddingQueue shutdown - rejected pending callbacks');
+        }
+    }
     /**
      * Clean up old completed/failed entries
      * Keep last 7 days by default

package/dist/services/MemoryDrilldown.js

@@ -93,7 +93,7 @@ export class MemoryDrilldown {
         m.metadata,
         m.embedding,
         EXISTS(SELECT 1 FROM codebase_pointers WHERE memory_id = m.id) as has_code,
-        EXISTS(SELECT 1 FROM team_member_conversations WHERE memory_id = m.id) as has_conversation,
+        EXISTS(SELECT 1 FROM team_member_conversations tmc WHERE tmc.memory_id = m.id) as has_conversation,
         1 - (m.embedding <=> $1::vector) as relevance
       FROM memories m
       WHERE m.content ILIKE $2
@@ -218,7 +218,8 @@ export class MemoryDrilldown {
      * Fetch the conversation that spawned this memory
      */
     async getConversation(memoryId) {
-        const result = await this.db.query(`
+        try {
+            const result = await this.db.query(`
       SELECT
         team_member_id,
         team_member_name,
@@ -230,17 +231,23 @@ export class MemoryDrilldown {
       ORDER BY timestamp DESC
       LIMIT 1
     `, [memoryId]);
-        if (result.rows.length === 0) {
+            if (result.rows.length === 0) {
+                return null;
+            }
+            const row = result.rows[0];
+            return {
+                team_member_id: row.team_member_id,
+                team_member_name: row.team_member_name,
+                timestamp: row.timestamp,
+                summary: row.summary,
+                full_transcript: row.full_transcript
+            };
+        }
+        catch (err) {
+            // Table may not exist yet - gracefully return null
+            logger.warn({ err: err?.message, memoryId }, 'getConversation failed (table may not exist)');
             return null;
         }
-        const row = result.rows[0];
-        return {
-            team_member_id: row.team_member_id,
-            team_member_name: row.team_member_name,
-            timestamp: row.timestamp,
-            summary: row.summary,
-            full_transcript: row.full_transcript
-        };
     }
     /**
      * GET RELATED MEMORIES
@@ -256,7 +263,7 @@ export class MemoryDrilldown {
         m.tags,
         m.metadata,
         EXISTS(SELECT 1 FROM codebase_pointers WHERE memory_id = m.id) as has_code,
-        EXISTS(SELECT 1 FROM team_member_conversations WHERE memory_id = m.id) as has_conversation,
+        EXISTS(SELECT 1 FROM team_member_conversations tmc WHERE tmc.memory_id = m.id) as has_conversation,
         1 - (m.embedding <=> $1::vector) as relevance
       FROM memories m
       WHERE m.id != $2

package/dist/tools/goofy/findCodePointers.js

@@ -419,13 +419,17 @@ export class FindCodePointers {
         const includeTracebacks = params.includeTracebacks !== false;
         // Broadcast COT start to dashboard
         cotStart('find_code', params.query);
-        // FIXER AGENT 8: Get configurable timeout (default 30s)
+        // Get configurable timeout (default 60s, env: SPECMEM_CODE_SEARCH_TIMEOUT)
         const timeoutMs = getCodeSearchTimeout();
-        // FIX: Deadline-based timeout to prevent compounding (was worst-case 390s!)
-        // All operations share single deadline instead of stacking individual timeouts
-        const deadline = Date.now() + timeoutMs;
-        // Min 10s to allow embedding server to respond even when slow
-        const remainingTime = () => Math.max(10000, deadline - Date.now());
+        // FIX: Per-operation timeout budget instead of shared deadline
+        // The old shared deadline caused a cascade: by retry #2, only 10s remained (the Math.max floor).
+        // Now each operation phase gets its own timeout allocation:
+        // - Embedding generation (with retries): 50% of total budget per attempt
+        // - DB search + post-processing: remaining budget
+        const embeddingTimeoutPerAttempt = Math.max(15000, Math.floor(timeoutMs * 0.5));
+        const postEmbeddingDeadline = Date.now() + timeoutMs;
+        // For post-embedding operations, use remaining time from overall deadline (min 10s)
+        const remainingTime = () => Math.max(10000, postEmbeddingDeadline - Date.now());
         // FIXER AGENT 7: Log socket path for debugging (same detection as find_memory)
         const socketPath = getEmbeddingSocketPath();
         if (process.env['SPECMEM_DEBUG']) {
@@ -446,7 +450,7 @@ export class FindCodePointers {
                 maxRetries: getMaxRetries(),
                 socketPath // FIXER AGENT 7: Include socket path in logs
             }, '[CodePointers] Generating embedding for query');
-            const rawEmbedding = await withRetry(() => withTimeout(() => this.embeddingProvider.generateEmbedding(params.query), remainingTime(), 'Embedding generation'), 'Embedding generation');
+            const rawEmbedding = await withRetry(() => withTimeout(() => this.embeddingProvider.generateEmbedding(params.query), embeddingTimeoutPerAttempt, 'Embedding generation'), 'Embedding generation');
             // Validate and prepare embeddings for each table (may have different dimensions)
             // FIXER AGENT 8: Added timeout wrapper for dimension preparation
             const [queryEmbeddingFiles, queryEmbeddingDefs] = await withTimeout(() => Promise.all([