specmem-hardwicksoftware 3.7.30 → 3.7.32

package/dist/mcp/compactionProxy.js

@@ -58,7 +58,7 @@ const TOOL_USE_INPUT_PREVIEW_CHARS = 100;
 
 // Old-message stripping config — applied to ALL requests (not just compaction)
 // Only strips tool_results larger than this threshold in messages outside the recent window
-const OLD_STRIP_THRESHOLD = 400;         // chars — only strip results bigger than this
+const OLD_STRIP_THRESHOLD = 100;         // chars — only strip results bigger than this
 const OLD_STRIP_PREVIEW_CHARS = 200;     // chars — keep this much of the original
 
 // Live neural MT compression config
@@ -533,6 +533,23 @@ function stripOldToolResults(messages) {
         return stripped;
       }
 
+      // Strip specmem hook injection text blocks from old messages
+      if (block.type === 'text' && typeof block.text === 'string') {
+        const txt = block.text;
+        const isHookOutput = txt.includes('[SM-找]') || txt.includes('[SM-碼]') ||
+          txt.includes('[SM-檔改]') || txt.includes('[SPECMEM-SESSION]') ||
+          txt.includes('⚠️壓縮:繁中') || txt.includes('[SM-搜]');
+        if (isHookOutput && txt.length > liveConfig.OLD_STRIP_THRESHOLD) {
+          const removed = txt.length - OLD_STRIP_PREVIEW_CHARS;
+          charsRemoved += removed;
+          toolResultsStripped++;
+          return {
+            ...block,
+            text: txt.slice(0, OLD_STRIP_PREVIEW_CHARS) + `...\n[HOOK-TRIMMED: ${txt.length} chars]`
+          };
+        }
+      }
+
       return block;
     });
 
@@ -789,6 +806,9 @@ async function compressMessagesLive(messages) {
 
         // Standalone text blocks (user/assistant conversational text) → steno only
         if (block.type === 'text' && typeof block.text === 'string') {
+          // Skip specmem hook injection text — already partially compressed Chinese, steno would garble
+          const _htxt = block.text;
+          if (_htxt.includes('[SM-') || _htxt.includes('[SPECMEM-SESSION]') || _htxt.includes('⚠️壓縮:繁中')) continue;
           if (looksLikeNaturalLanguage(block.text)) {
             originals.push(block.text);
             textLocations.push({ msgIdx: i, blockIdx: j, mtEligible: false });

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/index.js

@@ -29,6 +29,7 @@ export class WatcherManager {
     syncInterval = null;
     syncInProgress = false;
     syncTimeout = null;
+    lastLowScoreResyncAt = 0;
     constructor(config) {
         // Create handler first - it's the core component
         this.handler = new AutoUpdateTheMemories(config.handler);
@@ -114,6 +115,29 @@ export class WatcherManager {
         try {
             const report = await this.syncChecker.checkSync();
             await this.writeSyncScore(report.syncScore);
+            // Guard: indexingPending (score < 0) — nothing to do yet
+            if (report.syncScore < 0) {
+                logger.debug('periodic sync: indexing pending, skipping resync');
+                return;
+            }
+            // Low-score trigger: if score drops below threshold, force resync w/ debounce
+            const LOW_SCORE_THRESHOLD = parseFloat(process.env['SPECMEM_LOW_SCORE_THRESHOLD'] || '0.85');
+            const LOW_SCORE_DEBOUNCE_MS = parseInt(process.env['SPECMEM_LOW_SCORE_DEBOUNCE_MS'] || String(15 * 60 * 1000), 10);
+            if (report.syncScore < LOW_SCORE_THRESHOLD) {
+                const now = Date.now();
+                const debounceRemaining = LOW_SCORE_DEBOUNCE_MS - (now - this.lastLowScoreResyncAt);
+                if (debounceRemaining > 0) {
+                    logger.warn({ syncScore: report.syncScore, debounceRemainingSec: Math.round(debounceRemaining / 1000) }, 'sync score below threshold but debounce active — skipping forced resync');
+                } else {
+                    this.lastLowScoreResyncAt = now;
+                    logger.warn({ syncScore: report.syncScore, threshold: LOW_SCORE_THRESHOLD }, 'sync score below threshold — forcing resync');
+                    const resyncResult = await this.syncChecker.resyncEverythingFrFr();
+                    logger.info({ filesAdded: resyncResult.filesAdded, filesUpdated: resyncResult.filesUpdated, errors: resyncResult.errors.length }, 'low-score forced resync complete');
+                    const postReport = await this.syncChecker.checkSync();
+                    await this.writeSyncScore(postReport.syncScore);
+                }
+                return;
+            }
             // Skip resync if already at >=98% — chokidar handles incremental changes
             if (report.syncScore >= 0.98) {
                 logger.debug({ syncScore: report.syncScore }, 'periodic sync: score >=98%, skipping resync');
@@ -198,6 +222,8 @@ export class WatcherManager {
      * writeSyncScore - writes sync score to statusbar state file for display
      */
     async writeSyncScore(syncScore) {
+        // Guard: indexingPending returns -1 — never write negative values to statusbar
+        if (syncScore < 0) return;
         try {
             const projectPath = process.env.SPECMEM_PROJECT_PATH || process.cwd();
             const statusbarPath = join(projectPath, 'specmem', 'sockets', 'statusbar-state.json');

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.30",
+  "version": "3.7.32",
   "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');

package/scripts/specmem-init.cjs

@@ -8799,9 +8799,14 @@ CREATE INDEX IF NOT EXISTS idx_embedding_queue_project ON embedding_queue (proje
         ? path.join(specmemPkg, 'mcp-proxy.cjs')
         : path.join(specmemPkg, 'bootstrap.cjs');
       // Container mode: postgres via unix socket in specmem/run/, user=specmem, trust auth
+      // Socket dir bind-mounted to /data/run in container — PG socket appears here after container starts
       // Legacy mode: postgres on localhost:5432, legacy credentials
       const isContainerMode = process.env.SPECMEM_CONTAINER_MODE === 'true';
       const runDir = path.join(projectPath, 'specmem', 'run');
+      if (isContainerMode) {
+        // Ensure socket directory exists on host — container bind-mounts dataDir:/data
+        try { fs.mkdirSync(runDir, { recursive: true }); } catch (e) { /* may already exist */ }
+      }
       const dbEnv = isContainerMode ? {
         SPECMEM_DB_HOST: runDir,
         SPECMEM_DB_PORT: "5432",

package/specmem/model-config.json

@@ -13,9 +13,10 @@
     "cpus": 8
   },
   "embedding": {
-    "batchSize": 24,
+    "batchSize": 64,
     "maxConcurrent": 5,
-    "timeout": 45000
+    "timeout": 45000,
+    "throttleDelayMs": 50
   },
   "watcher": {
     "debounceMs": 750,
@@ -33,13 +34,13 @@
     "maxChunks": 75
   },
   "resources": {
-    "cpuMin": 20,
-    "cpuMax": 40,
+    "cpuMin": 10,
+    "cpuMax": 45,
     "cpuCoreMin": 1,
     "cpuCoreMax": 4,
     "ramMinMb": 4000,
-    "ramMaxMb": 11500,
-    "updatedAt": "2026-02-21T22:33:46.533Z"
+    "ramMaxMb": 15000,
+    "updatedAt": "2026-02-24T19:22:11.693Z"
   },
   "resourcePool": {
     "embedding": {
@@ -79,5 +80,24 @@
       "description": "Adaptive batch sizing based on CPU/RAM"
     },
     "enabledAt": "2026-02-12T23:19:17.948Z"
+  },
+  "powerMode": {
+    "level": "high",
+    "description": "Max Performance - for 16GB+ RAM systems",
+    "lazyLoading": false,
+    "diskCache": false,
+    "diskCacheMaxMb": 0,
+    "aggressiveCleanup": false,
+    "idleUnloadSeconds": 0,
+    "batchSize": 32,
+    "throttleDelayMs": 50,
+    "setAt": "2026-02-24T11:57:23.121Z"
+  },
+  "heavyOps": {
+    "enabled": true,
+    "enabledAt": "2026-02-24T11:57:35.508Z",
+    "originalBatchSize": 32,
+    "batchSizeMultiplier": 2,
+    "throttleReduction": 0.2
   }
 }

package/specmem/supervisord.conf

@@ -1,6 +1,6 @@
 ; ============================================
 ; SPECMEM BRAIN CONTAINER - DYNAMIC SUPERVISORD CONFIG
-; Generated by specmem-init at 2026-02-22T17:39:56.598Z
+; Generated by specmem-init at 2026-02-24T19:19:59.260Z
 ; Thread counts from model-config.json resourcePool
 ; ============================================
 

package/specmem/user-config.json

@@ -7,5 +7,17 @@
   "serviceMode": {
     "enabled": false,
     "disabledAt": "2026-02-18T21:38:50.526Z"
+  },
+  "powerMode": {
+    "level": "high",
+    "description": "Max Performance - for 16GB+ RAM systems",
+    "lazyLoading": false,
+    "diskCache": false,
+    "diskCacheMaxMb": 0,
+    "aggressiveCleanup": false,
+    "idleUnloadSeconds": 0,
+    "batchSize": 32,
+    "throttleDelayMs": 50,
+    "setAt": "2026-02-24T11:57:23.121Z"
   }
 }