specmem-hardwicksoftware 3.7.29 → 3.7.31

package/dist/mcp/embeddingServerManager.js

@@ -2313,8 +2313,22 @@ export class EmbeddingServerManager extends EventEmitter {
                         logger.warn({
                             failures: this.config.maxFailuresBeforeRestart,
                             restartCount: this.restartCount,
-                        }, '[EmbeddingServerManager] Too many consecutive failures in container mode - cannot restart container process from host');
+                        }, '[EmbeddingServerManager] Too many consecutive failures in container mode - attempting container restart');
                         this.emit('unhealthy_container', { failures: this.config.maxFailuresBeforeRestart });
+                        // FIX: Auto-restart brain container when embedding is dead
+                        try {
+                            const { getContainerManager } = require('../container/containerManager.js');
+                            const projectPath = process.env['SPECMEM_PROJECT_PATH'] || process.cwd();
+                            const cm = getContainerManager(projectPath);
+                            logger.info({ projectPath }, '[EmbeddingServerManager] Restarting brain container...');
+                            await cm.start();
+                            logger.info('[EmbeddingServerManager] Brain container restarted successfully');
+                            this.isRunning = true;
+                            this.startTime = Date.now();
+                        } catch (containerErr) {
+                            logger.error({ error: containerErr?.message || containerErr },
+                                '[EmbeddingServerManager] Failed to restart brain container');
+                        }
                     }
                     else {
                         logger.warn({

package/dist/mcp/mcpProtocolHandler.js

@@ -424,12 +424,30 @@ export class MCPProtocolHandler {
         }
     }
     /**
-     * batch handle multiple tool calls - for efficiency
+     * batch handle multiple tool calls - with concurrency limit
+     * prevents overwhelming the db pool when claude fires 5+ calls at once
      */
     async handleBatchToolCalls(calls) {
         const results = [];
-        // process in parallel for speed
-        const promises = calls.map(async (call) => {
+        // inline concurrency limiter - no npm deps needed
+        // max 2 concurrent to leave headroom on 4-core/8GB systems
+        const _limitConcurrency = (concurrency) => {
+            let active = 0;
+            const queue = [];
+            const next = () => {
+                while (active < concurrency && queue.length > 0) {
+                    active++;
+                    const { fn, resolve, reject } = queue.shift();
+                    fn().then(resolve, reject).finally(() => { active--; next(); });
+                }
+            };
+            return (fn) => new Promise((resolve, reject) => {
+                queue.push({ fn, resolve, reject });
+                next();
+            });
+        };
+        const limit = _limitConcurrency(2);
+        const promises = calls.map((call) => limit(async () => {
             try {
                 const result = await this.handleToolCall(call.name, call.args);
                 return { name: call.name, result };
@@ -440,7 +458,7 @@ export class MCPProtocolHandler {
                     error: error instanceof Error ? error.message : 'unknown error'
                 };
             }
-        });
+        }));
         const settled = await Promise.allSettled(promises);
         for (const result of settled) {
             if (result.status === 'fulfilled') {

package/dist/mcp/specMemServer.js

@@ -236,8 +236,9 @@ export class SpecMemServer {
             this.announceToOnStartup();
             // Auto-start Codebook Learner (resource-capped background service)
             this._startCodebookLearner();
-            // Auto-trigger background codebase indexing (populates code_definitions)
-            // Runs deferred (10s delay) so it doesn't block MCP startup
+            // NOTE: _triggerCodebaseIndexing() is also called from deferredInitPromise.then()
+            // after DB migrations complete (which create codebase_files table).
+            // This early call may no-op if DB not ready yet — the post-DB call is the critical one.
             this._triggerCodebaseIndexing();
         };
         // get that db connection no cap
@@ -1285,6 +1286,14 @@ export class SpecMemServer {
             await this.initializeMiniCOTServerManager();
             startupLog('Mini COT server manager initialized');
             logger.info('SpecMem MCP server fully initialized — all components ready');
+            // FIX: Trigger codebase indexing AFTER DB init (migrations create codebase_files table)
+            // Previously only called in oninitialized which fires BEFORE deferred DB init,
+            // causing checkCodebaseIndexStatus to see missing table → needsReindex=false → skip
+            try {
+                await this._triggerCodebaseIndexing();
+            } catch (indexErr) {
+                logger.warn({ error: indexErr?.message }, 'Post-DB-init codebase indexing failed (non-fatal)');
+            }
             // Run initial sync on startup — ensures codebase is fresh when Claude Code launches
             await this._runStartupSync();
             // Start idle sync timer — auto-syncs when no tool calls for 60s
@@ -1354,7 +1363,11 @@ export class SpecMemServer {
                 const checkResult = await CheckSyncStatus.execute({ detailed: false }, wm);
                 const syncScore = checkResult?.syncScore ?? 100;
                 // Only resync if drift detected (score < 100)
-                if (syncScore < 100) {
+                // Skip resync if indexing is still pending (syncScore === -1)
+                if (checkResult?.indexingPending) {
+                    process.stderr.write(`[SPECMEM IDLE-SYNC] Indexing still in progress, skipping resync\n`);
+                }
+                else if (syncScore < 100) {
                     process.stderr.write(`[SPECMEM IDLE-SYNC] Drift detected (${syncScore}%), resyncing...\n`);
                     const resyncResult = await ForceResync.execute({ dryRun: false }, wm);
                     const added = resyncResult?.stats?.filesAdded ?? 0;

package/dist/mcp/toolRegistry.js

@@ -94,32 +94,30 @@ _cacheCleanupTimer.unref();
 /**
  * Get the project-scoped embedding cache
  */
-// HIGH-4: Simple lock to prevent concurrent eviction
-let _evictionInProgress = false;
+// HIGH-4: Eviction uses while-loop to guarantee room before creating new entry.
+// Old boolean _evictionInProgress flag was broken: when flag was true, eviction was
+// skipped but new entry was still created at line 125, exceeding the 20-project limit.
 function getProjectEmbeddingCache() {
     const project = getProjectPath();
     _EMBEDDING_CACHE_ACCESS_TIMES.set(project, Date.now());
     if (!_EMBEDDING_CACHE_BY_PROJECT.has(project)) {
-        // HIGH-4: Changed > to >= to evict at limit, not after. Added lock to prevent concurrent eviction.
-        if (_EMBEDDING_CACHE_BY_PROJECT.size >= 20 && !_evictionInProgress) {
-            _evictionInProgress = true;
-            try {
-                // Evict the least recently accessed project cache
-                let oldestProject = null;
-                let oldestTime = Infinity;
-                for (const [p, t] of _EMBEDDING_CACHE_ACCESS_TIMES) {
-                    if (t < oldestTime) {
-                        oldestTime = t;
-                        oldestProject = p;
-                    }
+        // Evict until there's room - loop guarantees we never exceed limit
+        while (_EMBEDDING_CACHE_BY_PROJECT.size >= 20) {
+            let oldestProject = null;
+            let oldestTime = Infinity;
+            for (const [p, t] of _EMBEDDING_CACHE_ACCESS_TIMES) {
+                if (t < oldestTime && p !== project) {
+                    oldestTime = t;
+                    oldestProject = p;
                 }
-                if (oldestProject) {
-                    _EMBEDDING_CACHE_BY_PROJECT.delete(oldestProject);
-                    _EMBEDDING_CACHE_ACCESS_TIMES.delete(oldestProject);
-                    __debugLog('[MCP DEBUG]', Date.now(), 'CACHE_PROJECT_EVICTED', { evictedProject: oldestProject, reason: 'max_projects_reached' });
-                }
-            } finally {
-                _evictionInProgress = false;
+            }
+            if (oldestProject) {
+                _EMBEDDING_CACHE_BY_PROJECT.delete(oldestProject);
+                _EMBEDDING_CACHE_ACCESS_TIMES.delete(oldestProject);
+                __debugLog('[MCP DEBUG]', Date.now(), 'CACHE_PROJECT_EVICTED', { evictedProject: oldestProject, reason: 'max_projects_reached' });
+            } else {
+                // Safety: no evictable project found (all entries are current project?), break to avoid infinite loop
+                break;
             }
         }
         _EMBEDDING_CACHE_BY_PROJECT.set(project, new Map());

package/dist/tools/goofy/checkSyncStatus.js

@@ -27,7 +27,10 @@ export class CheckSyncStatus {
             const driftReport = await watcherManager.checkSync();
             // build summary message
             let summary;
-            if (driftReport.inSync) {
+            if (driftReport.indexingPending) {
+                summary = `Codebase indexing in progress — sync score not yet available. ${driftReport.totalFiles} files on disk awaiting indexing.`;
+            }
+            else if (driftReport.inSync) {
                 summary = `Everything is in sync! ${driftReport.upToDate} files are up to date.`;
             }
             else {
@@ -45,7 +48,8 @@ export class CheckSyncStatus {
             }
             const result = {
                 inSync: driftReport.inSync,
-                syncScore: driftReport.syncScore,
+                syncScore: driftReport.indexingPending ? -1 : driftReport.syncScore,
+                indexingPending: !!driftReport.indexingPending,
                 driftPercentage: driftReport.driftPercentage,
                 summary,
                 stats: {
@@ -70,10 +74,12 @@ export class CheckSyncStatus {
                     contentMismatch: driftReport.contentMismatch
                 };
             }
-            // Update statusbar sync score live
-            try {
-                await watcherManager.writeSyncScore(driftReport.syncScore);
-            } catch (e) { /* non-critical */ }
+            // Update statusbar sync score live (skip if indexing pending — don't write -1)
+            if (!driftReport.indexingPending) {
+                try {
+                    await watcherManager.writeSyncScore(driftReport.syncScore);
+                } catch (e) { /* non-critical */ }
+            }
             logger.info({ inSync: driftReport.inSync, syncScore: driftReport.syncScore }, 'sync check complete');
             // Build human readable response
             const drifted = driftReport.missingFromMcp.length + driftReport.missingFromDisk.length + driftReport.contentMismatch.length;
@@ -99,7 +105,8 @@ export class CheckSyncStatus {
                     if (more > 0) detailLines += `\n  ... and ${more} more`;
                 }
             }
-            const message = `Sync Score: ${Math.round(driftReport.syncScore * 100)}%
+            const displayScore = driftReport.indexingPending ? 'Pending' : `${Math.round(driftReport.syncScore * 100)}%`;
+            const message = `Sync Score: ${displayScore}
 ${summary}
 
 Stats:

package/dist/watcher/fileWatcher.js

@@ -55,6 +55,11 @@ export class WatchForChangesNoCap {
     debounceCleanupTimer = null;
     // FIX 7.14: Track pending flush promises so stop() can await them
     pendingFlushPromises = new Set();
+    // PERF: Batch-level debounce — collect per-file handler results into batches
+    // so git operations changing many files don't fire hundreds of individual handler calls
+    _batchTimer = null;
+    _batchQueue = [];
+    _batchDebounceMs = 500; // collect events for 500ms before dispatching batch
     // stats tracking
     stats = {
         filesWatched: 0,
@@ -75,6 +80,37 @@ export class WatchForChangesNoCap {
             verbose: config.verbose ?? false
         };
     }
+    /**
+     * _enqueueBatchEvent - batch-level debounce for handler calls
+     *
+     * Instead of calling changeHandler() immediately per-file, queue events
+     * and dispatch the entire batch after 500ms of quiet. This prevents
+     * git operations (checkout, merge, rebase) from firing hundreds of
+     * individual handler calls that each trigger sync/DB work.
+     */
+    _enqueueBatchEvent(event) {
+        this._batchQueue.push(event);
+        if (this._batchTimer) clearTimeout(this._batchTimer);
+        this._batchTimer = setTimeout(async () => {
+            this._batchTimer = null;
+            const batch = this._batchQueue.splice(0);
+            if (batch.length === 0 || !this.changeHandler) return;
+            const batchSize = batch.length;
+            if (batchSize > 5) {
+                logger.info({ batchSize }, `batch debounce: dispatching ${batchSize} file events as batch`);
+            }
+            // Process each event in the batch sequentially
+            // (changeHandler expects individual events)
+            for (const evt of batch) {
+                try {
+                    await this.changeHandler(evt);
+                }
+                catch (err) {
+                    logger.error({ error: err, path: evt.path }, 'batch handler error for file');
+                }
+            }
+        }, this._batchDebounceMs);
+    }
     /**
      * startWatching - fires up the file watcher
      *
@@ -189,7 +225,7 @@ export class WatchForChangesNoCap {
                 depth: undefined, // watch all depths
                 // debouncing built into chokidar
                 awaitWriteFinish: {
-                    stabilityThreshold: 300, // wait 300ms for file to stop changing
+                    stabilityThreshold: 500, // wait 500ms for file to stop changing (reduced CPU from rapid fire events)
                     pollInterval: 100 // check every 100ms
                 },
                 // dont follow symlinks (security)
@@ -240,6 +276,18 @@ export class WatchForChangesNoCap {
             await Promise.allSettled([...this.pendingFlushPromises]);
             this.pendingFlushPromises.clear();
         }
+        // PERF: Clear batch timer and flush pending batch events
+        if (this._batchTimer) {
+            clearTimeout(this._batchTimer);
+            this._batchTimer = null;
+        }
+        if (this._pendingBatchEvents.length > 0 && this.changeHandler) {
+            // Flush remaining batch events before shutdown
+            const batch = this._pendingBatchEvents.splice(0);
+            for (const evt of batch) {
+                try { await this.changeHandler(evt); } catch { /* shutting down */ }
+            }
+        }
         // FIX MED-13: Cancel all debounced handlers before clearing to prevent memory leaks
         // The debounce library's clear() method cancels pending timer execution
         for (const handler of this.debouncedHandlers.values()) {
@@ -381,7 +429,9 @@ export class WatchForChangesNoCap {
                     if (latestEvent) {
                         // Update timestamp to reflect when we actually process the event
                         latestEvent.timestamp = new Date();
-                        await this.changeHandler(latestEvent);
+                        // PERF: Route through batch debounce instead of calling handler directly
+                        // This prevents git operations (200+ files) from firing 200 individual handler calls
+                        this._enqueueBatchEvent(latestEvent);
                         this.stats.eventsProcessed++;
                         this.stats.lastEventTime = new Date();
                     }
@@ -435,7 +485,8 @@ export class WatchForChangesNoCap {
                     const flushPromise = Promise.resolve().then(async () => {
                         try {
                             latestEvent.timestamp = new Date();
-                            await this.changeHandler(latestEvent);
+                            // PERF: Route through batch debounce
+                            this._enqueueBatchEvent(latestEvent);
                             this.stats.eventsProcessed++;
                             this.stats.lastEventTime = new Date();
                         }
@@ -479,23 +530,9 @@ export class WatchForChangesNoCap {
                     const latestEvent = this.pendingEventData.get(key);
                     if (latestEvent && this.changeHandler) {
                         this.pendingEventData.delete(key);
-                        // FIX 7.14: Track flush promise so stop() can await it
-                        const flushPromise = Promise.resolve().then(async () => {
-                            try {
-                                latestEvent.timestamp = new Date();
-                                await this.changeHandler(latestEvent);
-                                this.stats.eventsProcessed++;
-                                this.stats.lastEventTime = new Date();
-                            }
-                            catch (error) {
-                                this.stats.errors++;
-                                logger.error({ error, event: latestEvent }, 'error processing stale debounce entry');
-                            }
-                            finally {
-                                this.pendingFlushPromises.delete(flushPromise);
-                            }
-                        });
-                        this.pendingFlushPromises.add(flushPromise);
+                        // PERF: Route stale entries through batch debounce too
+                        latestEvent.timestamp = new Date();
+                        this._enqueueBatchEvent(latestEvent);
                     }
                     else {
                         this.pendingEventData.delete(key);

package/dist/watcher/syncChecker.js

@@ -119,22 +119,26 @@ export class AreWeStillInSync {
             const totalFiles = diskFiles.length;
             const totalMemories = mcpFiles.length;
             const totalDrift = missingFromMcp.length + missingFromDisk.length + contentMismatch.length;
+            // FIX: If codebase_files is empty but disk files exist, indexing hasn't completed yet.
+            // Don't report 0% sync — that's misleading. Report indexing-pending state instead.
+            const indexingPending = totalMemories === 0 && totalFiles > 0;
             // Sync score = what % of disk files are correctly synced in MCP
             // Deleted-from-disk files are cleanup work, not sync failures
             const totalItems = totalFiles || 1;
-            const driftPercentage = totalItems > 0 ? (totalDrift / totalItems) * 100 : 0;
-            const syncScore = totalItems > 0 ? upToDate / totalItems : 1;
+            const driftPercentage = indexingPending ? 0 : (totalItems > 0 ? (totalDrift / totalItems) * 100 : 0);
+            const syncScore = indexingPending ? -1 : (totalItems > 0 ? upToDate / totalItems : 1);
             const report = {
-                inSync: totalDrift === 0,
+                inSync: indexingPending ? false : totalDrift === 0,
                 lastChecked: new Date(),
                 totalFiles,
                 totalMemories,
-                missingFromMcp,
+                missingFromMcp: indexingPending ? [] : missingFromMcp,
                 missingFromDisk,
-                contentMismatch,
-                upToDate,
+                contentMismatch: indexingPending ? [] : contentMismatch,
+                upToDate: indexingPending ? 0 : upToDate,
                 driftPercentage,
-                syncScore
+                syncScore,
+                indexingPending
             };
             this.lastSyncCheck = report.lastChecked;
             this.lastCheckTime = startTime; // FIX 7.03: Record check time for mtime optimization

package/package.json

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

package/scripts/global-postinstall.cjs

@@ -947,9 +947,14 @@ function adjustPgAuth() {
     // Backup and modify
     run(`sudo cp ${pgHbaPath} ${pgHbaPath}.backup`);
 
-    // Add password auth for our user
+    // Add password auth for our user — check if already exists to prevent duplicates
     const authLine = `host    ${DB_CONFIG.name}    ${DB_CONFIG.user}    127.0.0.1/32    md5`;
-    run(`echo '${authLine}' | sudo tee -a ${pgHbaPath}`);
+    const alreadyExists = run(`sudo grep -qF '${authLine}' ${pgHbaPath}`, { silent: true });
+    if (!alreadyExists.success) {
+      run(`echo '${authLine}' | sudo tee -a ${pgHbaPath}`);
+    } else {
+      log.info('pg_hba.conf auth line already present, skipping');
+    }
 
     // Reload PostgreSQL
     run('sudo systemctl reload postgresql 2>/dev/null || sudo -u postgres pg_ctl reload');