specmem-hardwicksoftware 3.7.35 → 3.7.38

package/dist/mcp/embeddingServerManager.js

@@ -47,13 +47,22 @@ const DEFAULT_CONFIG = {
     startupTimeoutMs: parseInt(process.env['SPECMEM_EMBEDDING_STARTUP_TIMEOUT'] || '45000', 10),
     maxRestartAttempts: parseInt(process.env['SPECMEM_EMBEDDING_MAX_RESTARTS'] || '5', 10),
     autoStart: process.env['SPECMEM_EMBEDDING_AUTO_START'] !== 'false',
-    killStaleOnStart: process.env['SPECMEM_EMBEDDING_KILL_STALE'] !== 'false',
+    // FIX: Default to false - only kill if THIS project's socket/PID exists
+    // This prevents cross-project conflicts when multiple projects have embedding servers
+    killStaleOnStart: process.env['SPECMEM_EMBEDDING_KILL_STALE'] === 'true',
+    // New: Strict isolation mode - skip ALL cross-project process checks
+    // Set SPECMEM_EMBEDDING_STRICT_ISOLATION=1 to enable
+    strictIsolation: process.env['SPECMEM_EMBEDDING_STRICT_ISOLATION'] === '1',
     maxProcessAgeHours: parseFloat(process.env['SPECMEM_EMBEDDING_MAX_AGE_HOURS'] || '1'),
     // Circuit breaker configuration (Issue #10)
     cbRestartWindowMs: parseInt(process.env['SPECMEM_RESTART_WINDOW_MS'] || '300000', 10),
     cbMaxRestartsInWindow: parseInt(process.env['SPECMEM_RESTART_MAX_IN_WINDOW'] || '5', 10),
     cbCooldownMs: parseInt(process.env['SPECMEM_RESTART_COOLDOWN_MS'] || '60000', 10),
     cbMaxCooldownMs: parseInt(process.env['SPECMEM_RESTART_MAX_COOLDOWN_MS'] || '600000', 10),
+    // FIX: Status stability - require 3 consecutive failures before marking offline to prevent flickering
+    statusStabilityThreshold: parseInt(process.env['SPECMEM_STATUS_STABILITY_THRESHOLD'] || '3', 10),
+    // FIX: Reduce CPU by throttling duplicate detection to every 5th health check
+    duplicateCheckInterval: parseInt(process.env['SPECMEM_DUPLICATE_CHECK_INTERVAL'] || '5', 10),
 };
 // ============================================================================
 // EMBEDDING SERVER MANAGER
@@ -75,6 +84,27 @@ export class EmbeddingServerManager extends EventEmitter {
     healthCheckTimer = null;
     isRunning = false;
     consecutiveFailures = 0;
+    healthCheckCycle = 0; // FIX: Track health check cycles for throttling duplicate detection
+    // FIX: Unique instance ID to distinguish this SpecMem installation from others
+    instanceId = null;
+    // FIX: Generate unique instance ID per SpecMem installation
+    _ensureInstanceId() {
+        if (this.instanceId) return this.instanceId;
+        // Try to load from file
+        const instanceIdFile = path.join(this.dataDir || this.projectPath, '.specmem-instance-id');
+        try {
+            if (existsSync(instanceIdFile)) {
+                this.instanceId = readFileSync(instanceIdFile, 'utf-8').trim();
+                return this.instanceId;
+            }
+        } catch (e) { /* ignore */ }
+        // Generate new ID
+        this.instanceId = `inst-${Date.now()}-${Math.random().toString(36).slice(2, 10)}`;
+        try {
+            writeFileSync(instanceIdFile, this.instanceId);
+        } catch (e) { /* ignore */ }
+        return this.instanceId;
+    }
     restartCount = 0;
     lastRestartTime = 0;
     startTime = null;
@@ -156,9 +186,17 @@ export class EmbeddingServerManager extends EventEmitter {
             this.startKysHeartbeat();
             return;
         }
-        // Step 1: Kill any stale processes
-        if (this.config.killStaleOnStart) {
+        // FIX: Only kill stale processes if THIS project's PID file exists
+        // This prevents cross-project conflicts when multiple projects have embedding servers
+        const pidFileExists = existsSync(this.pidFilePath);
+        // Step 1: Kill any stale processes (only if our PID file exists or explicitly enabled)
+        // skip if strictIsolation is enabled to prevent ANY cross-project checks
+        if (this.config.strictIsolation) {
+            logger.info('[EmbeddingServerManager] Strict isolation mode - skipping stale process cleanup');
+        } else if (this.config.killStaleOnStart && pidFileExists) {
             await this.killStaleProcesses();
+        } else if (this.config.killStaleOnStart) {
+            logger.debug('[EmbeddingServerManager] killStaleOnStart enabled but no PID file - skipping cleanup');
         }
         // Step 2: Start the embedding server if auto-start is enabled
         if (this.config.autoStart) {
@@ -187,6 +225,8 @@ export class EmbeddingServerManager extends EventEmitter {
             this.isRunning = true;
             return true;
         }
+        // Refresh socket path before start to pick up any externally-created sockets
+        this.refreshSocketPath();
         if (this.isRunning) {
             logger.debug('[EmbeddingServerManager] Server already running');
             return true;
@@ -561,6 +601,7 @@ export class EmbeddingServerManager extends EventEmitter {
                 SPECMEM_SOCKET_DIR: socketDir,
                 SPECMEM_EMBEDDING_SOCKET: this.socketPath,
                 SPECMEM_EMBEDDING_IDLE_TIMEOUT: '0',
+                SPECMEM_INSTANCE_ID: this.instanceId || this._ensureInstanceId(),
                 SPECMEM_DB_SCHEMA: projectSchema,
                 ...configEnv,
             });
@@ -924,12 +965,12 @@ export class EmbeddingServerManager extends EventEmitter {
                         if (response.error) {
                             clearTimeout(timeout);
                             resolved = true;
-                            socket.end();
+                            socket.destroy();
                             reject(new Error(response.error));
                             return;
                         }
-                        // Skip "processing" status messages - wait for actual embedding
-                        if (response.status === 'processing') {
+                        // Skip "processing"/"working" status messages - wait for actual embedding
+                        if (response.status === 'working' || response.status === 'processing') {
                             logger.debug({ textLength: response.text_length }, '[EmbeddingServerManager] Embedding request queued, waiting for result...');
                             continue; // Keep reading for the actual embedding
                         }
@@ -937,7 +978,7 @@ export class EmbeddingServerManager extends EventEmitter {
                         if (response.embedding && Array.isArray(response.embedding)) {
                             clearTimeout(timeout);
                             resolved = true;
-                            socket.end();
+                            socket.destroy();
                             resolve(response.embedding);
                             return;
                         }
@@ -953,6 +994,7 @@ export class EmbeddingServerManager extends EventEmitter {
                 clearTimeout(timeout);
                 if (!resolved) {
                     resolved = true;
+                    socket.destroy();
                     reject(err);
                 }
             });
@@ -993,17 +1035,17 @@ export class EmbeddingServerManager extends EventEmitter {
                         if (response.error) {
                             clearTimeout(timeout);
                             resolved = true;
-                            socket.end();
+                            socket.destroy();
                             reject(new Error(response.error));
                             return;
                         }
-                        if (response.status === 'processing') {
+                        if (response.status === 'working' || response.status === 'processing') {
                             continue; // Wait for actual result
                         }
                         if (response.embeddings && Array.isArray(response.embeddings)) {
                             clearTimeout(timeout);
                             resolved = true;
-                            socket.end();
+                            socket.destroy();
                             resolve(response.embeddings);
                             return;
                         }
@@ -1017,6 +1059,7 @@ export class EmbeddingServerManager extends EventEmitter {
                 clearTimeout(timeout);
                 if (!resolved) {
                     resolved = true;
+                    socket.destroy();
                     reject(err);
                 }
             });
@@ -1073,11 +1116,11 @@ export class EmbeddingServerManager extends EventEmitter {
                         if (response.error) {
                             clearTimeout(timeout);
                             resolved = true;
-                            socket.end();
+                            socket.destroy();
                             reject(new Error(response.error));
                             return;
                         }
-                        if (response.status === 'processing') {
+                        if (response.status === 'working' || response.status === 'processing') {
                             logger.debug('[EmbeddingServerManager] Server-side processing in progress...');
                             continue;
                         }
@@ -1085,7 +1128,7 @@ export class EmbeddingServerManager extends EventEmitter {
                         if (response.total_processed !== undefined || response.processed !== undefined) {
                             clearTimeout(timeout);
                             resolved = true;
-                            socket.end();
+                            socket.destroy();
                             logger.info({ response }, '[EmbeddingServerManager] Server-side processing complete');
                             resolve(response);
                             return;
@@ -1119,6 +1162,8 @@ export class EmbeddingServerManager extends EventEmitter {
         this.isShuttingDown = true;
         this.isStarting = false; // Reset starting flag on stop
         this.startupGraceUntil = 0; // Clear any active grace period
+        // Refresh socket path to find actual socket before stopping
+        this.refreshSocketPath();
         logger.info('[EmbeddingServerManager] Stopping embedding server...');
         // Stop health monitoring
         this.stopHealthMonitoring();
@@ -1186,6 +1231,8 @@ export class EmbeddingServerManager extends EventEmitter {
      */
     async healthCheck() {
         const startTime = Date.now();
+        // Refresh socket path to find socket that may have appeared after construction
+        this.refreshSocketPath();
         // Quick check: socket must exist
         if (!existsSync(this.socketPath)) {
             return {
@@ -1300,11 +1347,54 @@ export class EmbeddingServerManager extends EventEmitter {
     /**
      * Get current server status
      */
+    /**
+     * Refresh socketPath by re-scanning known locations.
+     * Ensures we pick up a socket that appeared after construction.
+     */
+    refreshSocketPath() {
+        try {
+            const freshPath = getEmbeddingSocketPath();
+            if (freshPath && freshPath !== this.socketPath) {
+                logger.debug({ old: this.socketPath, new: freshPath }, '[EmbeddingServerManager] Socket path updated');
+                this.socketPath = freshPath;
+                this.pidFilePath = join(dirname(freshPath), 'embedding.pid');
+                this.stoppedFlagPath = join(dirname(freshPath), 'embedding.stopped');
+            }
+        }
+        catch (err) {
+            logger.debug({ error: err.message }, '[EmbeddingServerManager] refreshSocketPath failed');
+        }
+    }
+    /**
+     * Check if the PID from the PID file is alive (signal 0 check).
+     */
+    isPidAlive(pid) {
+        if (!pid || pid <= 0)
+            return false;
+        try {
+            process.kill(pid, 0);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
     getStatus() {
+        // Refresh socket path to pick up sockets that appeared after construction
+        this.refreshSocketPath();
         const pid = this.readPidFile();
         const socketExists = existsSync(this.socketPath);
+        // Determine running state: use in-memory flag OR check PID file + process alive
+        // This handles the case where server is running but manager was freshly created
+        const running = this.isRunning || (pid != null && this.isPidAlive(pid) && socketExists);
+        // Sync in-memory flag if we detected a running server via PID
+        if (running && !this.isRunning && pid != null) {
+            this.isRunning = true;
+            this.startTime = this.startTime || Date.now();
+            logger.info({ pid }, '[EmbeddingServerManager] Detected running server from PID file, syncing state');
+        }
         return {
-            running: this.isRunning,
+            running,
             pid,
             socketPath: this.socketPath,
             socketExists,
@@ -1874,10 +1964,38 @@ export class EmbeddingServerManager extends EventEmitter {
             const envVars = environ.split('\0');
             const projectPath = this.projectPath || process.cwd();
             const socketPath = this.socketPath;
+            let foundInstanceId = null;
             for (const v of envVars) {
-                if (v.startsWith('SPECMEM_PROJECT_PATH=') && v.includes(projectPath)) return true;
-                if (v.startsWith('SPECMEM_SOCKET_PATH=') && v.includes(projectPath)) return true;
-                if (v.startsWith('SPECMEM_EMBEDDING_SOCKET=') && socketPath && v.includes(socketPath)) return true;
+                // FIX: Check SPECMEM_INSTANCE_ID - if both have it and they match, it's duplicate
+                if (v.startsWith('SPECMEM_INSTANCE_ID=')) {
+                    foundInstanceId = v.replace('SPECMEM_INSTANCE_ID=', '');
+                }
+            }
+            // If both have instance IDs and they match → definitely same instance = duplicate
+            if (foundInstanceId && this.instanceId && foundInstanceId === this.instanceId) {
+                return true;
+            }
+            // If instance IDs differ → different installations → NOT duplicate
+            if (foundInstanceId && this.instanceId && foundInstanceId !== this.instanceId) {
+                return false;
+            }
+            // At least one is legacy (no instance ID) → use path-based matching
+            for (const v of envVars) {
+                // FIX: Use exact path match or path separator to prevent false positives
+                // Previously used .includes() which matched partial paths like /specmem/abc matching /specmem
+                if (v.startsWith('SPECMEM_PROJECT_PATH=')) {
+                    const envProjectPath = v.replace('SPECMEM_PROJECT_PATH=', '');
+                    // Match exact path or child path (with / separator)
+                    if (envProjectPath === projectPath || envProjectPath.startsWith(projectPath + '/')) return true;
+                }
+                if (v.startsWith('SPECMEM_SOCKET_PATH=')) {
+                    const envSocketPath = v.replace('SPECMEM_SOCKET_PATH=', '');
+                    if (envSocketPath === socketPath || envSocketPath.startsWith(projectPath + '/')) return true;
+                }
+                if (v.startsWith('SPECMEM_EMBEDDING_SOCKET=') && socketPath) {
+                    const envEmbSocket = v.replace('SPECMEM_EMBEDDING_SOCKET=', '');
+                    if (envEmbSocket === socketPath) return true;
+                }
             }
             return false;
         }
@@ -2009,6 +2127,9 @@ export class EmbeddingServerManager extends EventEmitter {
         // Phase 1: Wait for socket file to appear (use 50% of timeout for file appearance)
         const fileWaitDeadline = startTime + (this.config.startupTimeoutMs * 0.5);
         while (Date.now() < fileWaitDeadline) {
+            // Refresh socket path each iteration — the socket may appear at a path
+            // different from what was computed at construction time
+            this.refreshSocketPath();
             if (existsSync(this.socketPath)) {
                 logger.debug({ elapsed: Date.now() - startTime }, '[EmbeddingServerManager] Socket file appeared, starting health check polling');
                 break;
@@ -2340,9 +2461,14 @@ export class EmbeddingServerManager extends EventEmitter {
                     }
                 }
             }
+            // FIX: Increment health check cycle counter for throttling duplicate detection
+            this.healthCheckCycle++;
+            // FIX: Only run duplicate detection every N health checks (default every 5th = 2.5 min)
+            const shouldCheckDuplicates = this.healthCheckCycle % this.config.duplicateCheckInterval === 0;
             // FIX 4: Duplicate process detection during health monitoring
             // Check for multiple embedding server processes FOR THIS PROJECT and kill extras
             // PROJECT ISOLATION: Filter to only this project's processes before killing duplicates
+            if (!shouldCheckDuplicates) return; // Throttle: skip this cycle
             try {
                 const runningServers = await this.findRunningEmbeddingServers();
                 // PROJECT ISOLATION: Only consider processes belonging to this project
@@ -2672,6 +2798,14 @@ export function getEmbeddingServerManager(config) {
     }
     // Create new manager for this project
     const manager = new EmbeddingServerManager(config);
+    // Recover state from PID file if server is already running externally
+    // This handles the case where manager is recreated but server is still alive
+    const existingPid = manager.readPidFile();
+    if (existingPid && manager.isPidAlive(existingPid) && existsSync(manager.socketPath)) {
+        manager.isRunning = true;
+        manager.startTime = Date.now();
+        logger.info({ pid: existingPid, socketPath: manager.socketPath }, '[EmbeddingServerManager] Recovered running state from existing PID file');
+    }
     embeddingManagersByProject.set(projectPath, manager);
     logger.info({ projectPath, totalManagers: embeddingManagersByProject.size }, '[EmbeddingServerManager] Created new per-project manager');
     return manager;

package/dist/mcp/mcpProtocolHandler.js

@@ -388,8 +388,13 @@ export class MCPProtocolHandler {
             // validate inputs if we have a schema
             const schema = TOOL_SCHEMAS[toolName];
             let validatedArgs = args;
+            // Strip proxy artifacts before validation — compaction proxy sometimes injects _stripped
+            if (validatedArgs && typeof validatedArgs === 'object' && '_stripped' in validatedArgs) {
+                const { _stripped, ...clean } = validatedArgs;
+                validatedArgs = clean;
+            }
             if (schema) {
-                const result = schema.safeParse(args);
+                const result = schema.safeParse(validatedArgs);
                 if (!result.success) {
                     throw new Error(`validation failed fr: ${result.error.message}`);
                 }

package/dist/mcp/miniCOTServerManager.js

@@ -28,7 +28,7 @@
  * @author hardwicksoftwareservices
  */
 import { spawn, execSync } from 'child_process';
-import { existsSync, readFileSync, writeFileSync, unlinkSync, mkdirSync } from 'fs';
+import { existsSync, readFileSync, writeFileSync, unlinkSync, mkdirSync, renameSync } from 'fs';
 import { join, dirname } from 'path';
 import { createConnection } from 'net';
 import { EventEmitter } from 'events';
@@ -220,6 +220,18 @@ export class MiniCOTServerManager extends EventEmitter {
                 this.startTime = Date.now();
                 this.consecutiveFailures = 0;
                 this.isStarting = false;
+                // Clean stale PID file — we don't own this process
+                const stalePid = this.readPidFile();
+                if (stalePid) {
+                    try {
+                        process.kill(stalePid, 0);
+                    }
+                    catch (_e) {
+                        // Stale PID — remove it
+                        this.removePidFile();
+                        logger.debug({ stalePid }, '[MiniCOTServerManager] Removed stale PID file for dead process while adopting external server');
+                    }
+                }
                 this.emit('started', { pid: null, external: true });
                 return true;
             }
@@ -231,6 +243,17 @@ export class MiniCOTServerManager extends EventEmitter {
             catch (err) {
                 logger.warn({ error: err }, '[MiniCOTServerManager] Failed to remove old socket');
             }
+            // Also clean stale PID file if process is dead
+            const stalePid = this.readPidFile();
+            if (stalePid) {
+                try {
+                    process.kill(stalePid, 0);
+                }
+                catch (_e) {
+                    this.removePidFile();
+                    logger.debug({ stalePid }, '[MiniCOTServerManager] Removed stale PID file for dead process during startup cleanup');
+                }
+            }
         }
         // Find the Mini COT script
         const miniCOTScript = this.findMiniCOTScript();
@@ -376,7 +399,21 @@ export class MiniCOTServerManager extends EventEmitter {
             return true;
         }
         catch (err) {
-            logger.error({ error: err }, '[MiniCOTServerManager] Failed to start server');
+            const errMsg = err?.message || String(err);
+            const isEADDRINUSE = errMsg.includes('EADDRINUSE') || errMsg.includes('address already in use');
+            const isENOENT = errMsg.includes('ENOENT') || errMsg.includes('no such file');
+            const isEACCES = errMsg.includes('EACCES') || errMsg.includes('permission denied');
+            let hint = '';
+            if (isEADDRINUSE) {
+                hint = ` (socket ${this.socketPath} already in use — another Mini COT instance may be running)`;
+            }
+            else if (isENOENT) {
+                hint = ` (Mini COT script not found — check installation)`;
+            }
+            else if (isEACCES) {
+                hint = ` (permission denied — check file permissions on script or socket directory)`;
+            }
+            logger.error({ error: err, socketPath: this.socketPath }, `[MiniCOTServerManager] Failed to start server${hint}`);
             this.isStarting = false;
             return false;
         }
@@ -424,11 +461,12 @@ export class MiniCOTServerManager extends EventEmitter {
                 logger.debug({ error: err }, '[MiniCOTServerManager] Failed to remove socket');
             }
         }
+        const stoppedPid = this.process?.pid ?? null;
         this.process = null;
         this.isRunning = false;
         this.startTime = null;
         logger.info('[MiniCOTServerManager] Server stopped');
-        this.emit('stopped', { pid: this.process?.pid });
+        this.emit('stopped', { pid: stoppedPid });
     }
     /**
      * Perform a health check on the Mini COT server
@@ -529,12 +567,31 @@ export class MiniCOTServerManager extends EventEmitter {
     getStatus() {
         const pid = this.readPidFile();
         const socketExists = existsSync(this.socketPath);
+        // Check actual process liveness, not just in-memory flag
+        let processAlive = false;
+        if (pid) {
+            try {
+                process.kill(pid, 0); // signal 0 = existence check
+                processAlive = true;
+            }
+            catch (_e) {
+                // Process does not exist
+                processAlive = false;
+            }
+        }
+        // Reconcile: if isRunning but process is dead, correct the state
+        const actuallyRunning = this.isRunning && processAlive;
+        if (this.isRunning && !processAlive && pid) {
+            logger.warn({ pid }, '[MiniCOTServerManager] getStatus: process dead but isRunning was true, correcting state');
+            this.isRunning = false;
+        }
         return {
-            running: this.isRunning,
+            running: actuallyRunning,
             pid,
+            processAlive,
             socketPath: this.socketPath,
             socketExists,
-            healthy: this.isRunning && socketExists && this.consecutiveFailures === 0,
+            healthy: actuallyRunning && socketExists && this.consecutiveFailures === 0,
             lastHealthCheck: this.healthCheckTimer ? Date.now() : null,
             consecutiveFailures: this.consecutiveFailures,
             restartCount: this.restartCount,
@@ -1184,6 +1241,14 @@ export class MiniCOTServerManager extends EventEmitter {
             logger.debug({ pid: healthInfo.pid }, '[MiniCOTServerManager] Process from PID file no longer exists');
         }
         this.removePidFile();
+        // Also clean up stale socket
+        try {
+            if (existsSync(this.socketPath)) {
+                unlinkSync(this.socketPath);
+                logger.debug('[MiniCOTServerManager] Cleaned up stale socket in killByPidFile');
+            }
+        }
+        catch (_e) { /* ignore */ }
     }
     /**
      * Find the Mini COT script path
@@ -1237,6 +1302,8 @@ export class MiniCOTServerManager extends EventEmitter {
         if (this.process) {
             this.process = null;
         }
+        // Always clean up PID file on exit to prevent stale PIDs
+        this.removePidFile();
         if (this.isShuttingDown) {
             // Expected exit during shutdown
             return;
@@ -1392,9 +1459,11 @@ export class MiniCOTServerManager extends EventEmitter {
             if (!existsSync(pidDir)) {
                 mkdirSync(pidDir, { recursive: true });
             }
-            // Format: PID:TIMESTAMP
-            writeFileSync(this.pidFilePath, `${pid}:${Date.now()}`, 'utf8');
-            logger.debug({ pid, path: this.pidFilePath }, '[MiniCOTServerManager] Wrote PID file');
+            // Format: PID:TIMESTAMP — atomic write via rename to prevent partial reads
+            const tmpPath = this.pidFilePath + '.tmp';
+            writeFileSync(tmpPath, `${pid}:${Date.now()}`, 'utf8');
+            renameSync(tmpPath, this.pidFilePath);
+            logger.debug({ pid, path: this.pidFilePath }, '[MiniCOTServerManager] Wrote PID file (atomic)');
         }
         catch (err) {
             logger.error({ error: err }, '[MiniCOTServerManager] Failed to write PID file');
@@ -1425,6 +1494,11 @@ export class MiniCOTServerManager extends EventEmitter {
                 unlinkSync(this.pidFilePath);
                 logger.debug('[MiniCOTServerManager] Removed PID file');
             }
+            // Also clean up any leftover .tmp from atomic write
+            const tmpPath = this.pidFilePath + '.tmp';
+            if (existsSync(tmpPath)) {
+                unlinkSync(tmpPath);
+            }
         }
         catch (err) {
             logger.debug({ error: err }, '[MiniCOTServerManager] Failed to remove PID file');

package/dist/mcp/specMemServer.js

@@ -85,7 +85,9 @@ import { getSkillScanner } from '../skills/skillScanner.js';
 import { getSkillResourceProvider } from '../skills/skillsResource.js';
 import { getSkillReminder } from '../reminders/skillReminder.js';
 // Compaction proxy — MITM token stripper for faster compaction
-import { startCompactionProxy, stopCompactionProxy, killCompactionProxy } from './compactionProxy.js';
+import { startCompactionProxy, stopCompactionProxy, killCompactionProxy, registerWithDaemon, checkDaemonHealth } from './compactionProxy.js';
+// Context vault — token-saving stash for thicc tool outputs (auto-stash + search)
+import { initContextVault, stashTheGoods as vaultStash, formatVaultReceipt, VAULT_THRESHOLD, VAULT_SKIP_TOOLS } from './contextVault.js';
 // Command loader - load command .md files as MCP prompts
 import { getCommandLoader } from '../commands/commandLoader.js';
 // CLI Notifications - centralized notification system
@@ -586,6 +588,25 @@ export class SpecMemServer {
                     __debugLog('[MCP DEBUG]', Date.now(), 'TOOL_SLOW_WARNING', { callId, toolName: name, durationMs: duration, threshold: 100 });
                     logger.warn({ duration, tool: name }, 'tool execution kinda slow ngl');
                 }
+                // === Auto-vault large tool results to save tokens ===
+                // If a tool returns >5KB, stash it and hand back a compact receipt.
+                // Claude can dig_in_the_vault later for specific data.
+                if (!VAULT_SKIP_TOOLS.has(name)) {
+                    try {
+                        const resultStr = typeof result === 'string' ? result : JSON.stringify(result, null, 2);
+                        if (resultStr.length > VAULT_THRESHOLD) {
+                            const vaultResult = await vaultStash(resultStr, { tool: name, callId });
+                            if (!vaultResult.deduplicated) {
+                                startupLog(`[VAULT] Auto-stashed ${name}: ${resultStr.length} chars → receipt (vault:${vaultResult.vaultId})`);
+                            }
+                            result = formatVaultReceipt(vaultResult);
+                        }
+                    }
+                    catch (vaultErr) {
+                        // Non-fatal — fall through with original result
+                        __debugLog('[MCP DEBUG]', Date.now(), 'AUTO_VAULT_FAILED', { callId, toolName: name, error: vaultErr.message });
+                    }
+                }
                 __debugLog('[MCP DEBUG]', Date.now(), 'FORMATTING_RESPONSE', { callId, toolName: name });
                 const formattedResponse = this.formatResponse(result);
                 __debugLog('[MCP DEBUG]', Date.now(), 'RESPONSE_FORMATTED', {
@@ -1250,20 +1271,23 @@ export class SpecMemServer {
         // Each step waits for the previous to complete + yields to event loop
         // This prevents CPU spikes that cause MCP connection timeouts
         logger.info('SpecMem MCP server connected — lazy init starting');
-        // Step 2.5: Compaction Proxy — lightweight HTTP server, starts in <100ms
-        // Sits between Claude Code and Anthropic API, strips tool_result bodies
-        // from compaction requests (50-80% token reduction = faster compaction)
+        // Step 2.5: Register with compaction proxy daemon (DO NOT spawn here)
+        // The proxy daemon is started by specmem-init BEFORE Claude launches.
+        // By the time oninitialized fires, Claude is already running and routing
+        // traffic through ANTHROPIC_BASE_URL — spawning here is too late.
+        // We just register this project so the daemon knows we're alive.
         try {
-            const proxyResult = await startCompactionProxy();
-            if (proxyResult.started) {
-                startupLog(`Compaction proxy started on port ${proxyResult.port}`);
-                logger.info({ port: proxyResult.port }, 'Compaction proxy started');
+            const healthy = await checkDaemonHealth();
+            if (healthy) {
+                registerWithDaemon(process.env.SPECMEM_PROJECT_PATH, process.pid);
+                startupLog('Registered with existing compaction proxy daemon');
+                logger.info('Registered with compaction proxy daemon');
             } else {
-                startupLog(`Compaction proxy skipped: ${proxyResult.reason}`);
+                startupLog('Compaction proxy daemon not running — skipping registration (must be started by specmem-init)');
             }
         } catch (proxyErr) {
             // Non-fatal — proxy is optional, compaction still works without it
-            startupLog('Compaction proxy failed to start (non-fatal)', proxyErr);
+            startupLog('Compaction proxy registration check failed (non-fatal)', proxyErr);
         }
         // Step 3: Database init (deferred, tools wait via waitForReady())
         startupLog('Starting deferred database initialization...');
@@ -1928,6 +1952,17 @@ export class SpecMemServer {
                 // Non-fatal - tools can still work with in-memory fallback
                 logger.warn({ error: teamCommsError }, 'Team comms DB init failed - using in-memory fallback');
             }
+            // Initialize context vault for token-saving auto-stash
+            try {
+                if (pool) {
+                    initContextVault(pool, process.env['SPECMEM_PROJECT_PATH'] || '/');
+                    logger.info('Context vault initialized — auto-stash ready');
+                }
+            }
+            catch (vaultError) {
+                // Non-fatal — auto-stash disabled, manual tools still work
+                logger.warn({ error: vaultError }, 'Context vault init failed — auto-stash disabled');
+            }
             // FIX 1.02: Create CommandHandler AFTER DB is initialized
             // Previously created in constructor with uninitialized db
             // ORDERING INVARIANT (CRIT-1): commandHandler MUST be created here in deferredInit(),

package/dist/mcp/toolRegistry.js

@@ -57,6 +57,9 @@ import { GetMemoryFull } from '../tools/goofy/getMemoryFull.js';
 // Import project memory import/export tools - carry context across projects
 import { ImportProjectMemories } from '../tools/goofy/importProjectMemories.js';
 import { ExportProjectMemories } from '../tools/goofy/exportProjectMemories.js';
+// Import context vault tools - token-saving stash for thicc tool outputs
+import { StashTheGoods } from '../tools/goofy/stashTheGoods.js';
+import { DigInTheVault } from '../tools/goofy/digInTheVault.js';
 // Import MCP-based team communication tools (NEW - replaces HTTP team member comms)
 import { createTeamCommTools } from './tools/teamComms.js';
 // Import embedding server control tools (Phase 4 - user start/stop/status)
@@ -543,6 +546,9 @@ export function createToolRegistry(db, embeddingProvider) {
     // Project memory import/export tools - carry context across projects
     registry.register(new ImportProjectMemories(db, cachingProvider));
     registry.register(new ExportProjectMemories(db));
+    // Context vault tools - token-saving stash + search for thicc tool outputs
+    registry.register(new StashTheGoods());
+    registry.register(new DigInTheVault());
     // Team communication tools - multi-team member coordination
     const teamCommTools = createTeamCommTools();
     for (const tool of teamCommTools) {

package/dist/startup/startupIndexing.js

@@ -183,6 +183,16 @@ export async function triggerBackgroundIndexing(embeddingProvider, options = {})
     }
     state.indexingInProgress = true;
     state.lastIndexingCheck = new Date();
+    // Pause file watcher queue during indexing to avoid resource contention
+    let watcherQueue = null;
+    try {
+        const { getWatcherManager } = await import('../mcp/watcherIntegration.js');
+        const mgr = getWatcherManager();
+        if (mgr?.queue) {
+            watcherQueue = mgr.queue;
+            watcherQueue.pause('background indexing');
+        }
+    } catch { /* watcher not initialized yet — that's fine */ }
     try {
         const db = getDatabase();
         if (!db) {
@@ -241,6 +251,10 @@ export async function triggerBackgroundIndexing(embeddingProvider, options = {})
     }
     finally {
         state.indexingInProgress = false;
+        // Resume watcher queue after indexing completes (or fails)
+        if (watcherQueue) {
+            watcherQueue.resume();
+        }
     }
 }
 /**

package/dist/team-members/taskOrchestrator.js

@@ -1,8 +1,8 @@
 /**
- * Task Orchestrator - Smart Work Distribution System
+ * Agent Orchestrator - Smart Work Distribution System
  *
- * Provides intelligent task distribution to teamMembers:
- * - Task queue with priority management
+ * Provides intelligent agent distribution to teamMembers:
+ * - Agent queue with priority management
  * - Capability-based task matching
  * - Load balancing across team members
  * - Automatic failover and task reassignment