specmem-hardwicksoftware 3.5.99 → 3.6.1

package/dist/mcp/embeddingServerManager.js

@@ -48,6 +48,11 @@ const DEFAULT_CONFIG = {
     autoStart: process.env['SPECMEM_EMBEDDING_AUTO_START'] !== 'false',
     killStaleOnStart: process.env['SPECMEM_EMBEDDING_KILL_STALE'] !== 'false',
     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),
 };
 // ============================================================================
 // EMBEDDING SERVER MANAGER
@@ -89,6 +94,13 @@ export class EmbeddingServerManager extends EventEmitter {
     stoppedFlagPath;
     // Phase 4: Track restart timestamps for loop detection
     restartTimestamps = [];
+    // Circuit breaker state (Issue #10)
+    // States: 'closed' (normal), 'open' (tripped, blocking restarts), 'half-open' (testing one restart)
+    cbState = 'closed';
+    cbRestartTimestamps = []; // sliding window of restart timestamps
+    cbCurrentCooldownMs = 0; // current cooldown duration (doubles on repeated failures)
+    cbCooldownUntil = 0; // timestamp when cooldown expires
+    cbLastStateChange = Date.now();
     // KYS (Keep Yourself Safe) heartbeat timer - sends heartbeat every 25s to embedding server
     // If embedding server doesn't receive heartbeat within 90s, it commits suicide
     // This prevents zombie embedding servers when MCP crashes (increased from 30s for startup tolerance)
@@ -329,6 +341,56 @@ export class EmbeddingServerManager extends EventEmitter {
                 logger.warn({ error: err }, '[EmbeddingServerManager] Failed to remove old socket');
             }
         }
+        // ═══════════════════════════════════════════════════════════════════════════
+        // PRE-SPAWN ORPHAN KILL: Ensure NO other Frankenstein is running for this socket
+        // This is the LAST line of defense before spawning a new process
+        // ═══════════════════════════════════════════════════════════════════════════
+        try {
+            const killWaitMs = parseInt(process.env['SPECMEM_ORPHAN_KILL_WAIT_MS'] || '2000', 10);
+            // 1. Kill via PID file
+            const pidFilePath = join(dirname(this.socketPath), 'embedding.pid');
+            if (existsSync(pidFilePath)) {
+                const pidContent = readFileSync(pidFilePath, 'utf8').trim();
+                const oldPid = parseInt(pidContent.split(':')[0], 10);
+                if (oldPid && !isNaN(oldPid) && oldPid !== process.pid) {
+                    try {
+                        process.kill(oldPid, 0);
+                        logger.info({ pid: oldPid }, '[EmbeddingServerManager] Killing existing process before spawn');
+                        process.kill(oldPid, 'SIGTERM');
+                        await this.sleep(killWaitMs);
+                        try {
+                            process.kill(oldPid, 0);
+                            process.kill(oldPid, 'SIGKILL');
+                            logger.warn({ pid: oldPid }, '[EmbeddingServerManager] Force killed stubborn process');
+                        } catch { /* dead */ }
+                    } catch { /* not running */ }
+                }
+            }
+            // 2. Kill via pgrep as fallback (catches processes without PID files)
+            try {
+                const { execSync: execSyncLocal } = await import('child_process');
+                const pids = execSyncLocal(`pgrep -f "frankenstein-embeddings.py" 2>/dev/null || true`, { encoding: 'utf8' }).trim().split('\n').filter(Boolean);
+                for (const pidStr of pids) {
+                    const pid = parseInt(pidStr, 10);
+                    if (pid && pid !== process.pid) {
+                        try {
+                            process.kill(pid, 'SIGTERM');
+                            logger.info({ pid }, '[EmbeddingServerManager] Killed orphan frankenstein process (pgrep)');
+                        } catch { /* already dead */ }
+                    }
+                }
+                if (pids.filter(Boolean).length > 0) {
+                    await this.sleep(killWaitMs);
+                }
+            } catch { /* pgrep not available or no matches */ }
+            // 3. Clean stale socket
+            if (existsSync(this.socketPath)) {
+                unlinkSync(this.socketPath);
+                logger.debug('[EmbeddingServerManager] Removed stale socket before spawn');
+            }
+        } catch (preSpawnErr) {
+            logger.debug({ error: preSpawnErr }, '[EmbeddingServerManager] Pre-spawn cleanup failed (non-fatal)');
+        }
         // Find the embedding script (prefers warm-start.sh Docker mode)
         const scriptInfo = this.findEmbeddingScript();
         if (!scriptInfo) {
@@ -1064,6 +1126,8 @@ export class EmbeddingServerManager extends EventEmitter {
         this.restartTimestamps = [];
         this.consecutiveFailures = 0;
         this.isShuttingDown = false;
+        // Reset circuit breaker on user-initiated start (Issue #10)
+        this.resetCircuitBreaker();
         // Kill existing and start fresh
         await this.stop();
         // Clear the shutdown flag that stop() sets
@@ -1109,6 +1173,7 @@ export class EmbeddingServerManager extends EventEmitter {
             ...this.getStatus(),
             stoppedByUser: this.isStoppedByUser(),
             restartLoop: this.getRestartLoopInfo(),
+            circuitBreaker: this.getCircuitBreakerStatus(),
             startupGrace: graceActive ? {
                 active: true,
                 remainingMs: this.startupGraceUntil - Date.now(),
@@ -1117,6 +1182,59 @@ export class EmbeddingServerManager extends EventEmitter {
         };
     }
     // ==========================================================================
+    // CIRCUIT BREAKER (Issue #10)
+    // ==========================================================================
+    /**
+     * Manually reset the circuit breaker - callable from MCP tools
+     * Resets the circuit breaker to closed state, clears all cooldowns and counters.
+     * Use this when the underlying issue has been resolved (e.g., model file fixed, dependency installed).
+     */
+    resetCircuitBreaker() {
+        const previousState = this.cbState;
+        this.cbState = 'closed';
+        this.cbRestartTimestamps = [];
+        this.cbCurrentCooldownMs = 0;
+        this.cbCooldownUntil = 0;
+        this.cbLastStateChange = Date.now();
+        // Also reset the legacy restart counters
+        this.restartCount = 0;
+        this.restartTimestamps = [];
+        this.consecutiveFailures = 0;
+        logger.info({
+            previousState,
+            newState: 'closed',
+        }, '[EmbeddingServerManager] Circuit breaker manually reset: -> closed (all counters cleared)');
+        this.emit('circuit_breaker', { state: 'closed', manualReset: true });
+        return {
+            success: true,
+            previousState,
+            newState: 'closed',
+            message: `Circuit breaker reset from '${previousState}' to 'closed'. All cooldowns and counters cleared.`,
+        };
+    }
+    /**
+     * Get circuit breaker status for diagnostics
+     */
+    getCircuitBreakerStatus() {
+        const now = Date.now();
+        // Prune window for accurate count
+        const restartsInWindow = this.cbRestartTimestamps.filter(
+            ts => (now - ts) < this.config.cbRestartWindowMs
+        ).length;
+        return {
+            state: this.cbState,
+            restartsInWindow,
+            maxRestartsInWindow: this.config.cbMaxRestartsInWindow,
+            windowMs: this.config.cbRestartWindowMs,
+            currentCooldownMs: this.cbCurrentCooldownMs,
+            maxCooldownMs: this.config.cbMaxCooldownMs,
+            cooldownUntil: this.cbCooldownUntil > 0 ? new Date(this.cbCooldownUntil).toISOString() : null,
+            cooldownRemainingMs: this.cbCooldownUntil > now ? this.cbCooldownUntil - now : 0,
+            lastStateChange: new Date(this.cbLastStateChange).toISOString(),
+            timeSinceLastStateChangeMs: now - this.cbLastStateChange,
+        };
+    }
+    // ==========================================================================
     // PRIVATE METHODS
     // ==========================================================================
     /**
@@ -1610,7 +1728,12 @@ export class EmbeddingServerManager extends EventEmitter {
         this.attemptRestart();
     }
     /**
-     * Attempt to restart the server
+     * Attempt to restart the server (with circuit breaker - Issue #10)
+     *
+     * Circuit breaker pattern:
+     * - CLOSED: Normal operation, restarts allowed. Track restarts in sliding window.
+     * - OPEN: Too many restarts in window, block all restarts, wait for cooldown.
+     * - HALF-OPEN: After cooldown, allow ONE test restart. Success -> CLOSED, failure -> OPEN (doubled cooldown).
      */
     async attemptRestart() {
         // Phase 4: Don't restart if user manually stopped
@@ -1618,7 +1741,60 @@ export class EmbeddingServerManager extends EventEmitter {
             logger.info('[EmbeddingServerManager] Skipping restart - stopped by user');
             return;
         }
-        // Phase 4: Check for restart loop (>3 restarts in 60 seconds)
+        const now = Date.now();
+        // --- Circuit Breaker Logic (Issue #10) ---
+        // Prune the sliding window: remove timestamps older than cbRestartWindowMs
+        this.cbRestartTimestamps = this.cbRestartTimestamps.filter(
+            ts => (now - ts) < this.config.cbRestartWindowMs
+        );
+        if (this.cbState === 'open') {
+            // Circuit is OPEN - check if cooldown has elapsed
+            if (now < this.cbCooldownUntil) {
+                const remainingMs = this.cbCooldownUntil - now;
+                logger.warn({
+                    cbState: this.cbState,
+                    cooldownRemainingMs: remainingMs,
+                    currentCooldownMs: this.cbCurrentCooldownMs,
+                }, '[EmbeddingServerManager] Circuit breaker OPEN - restart blocked, waiting for cooldown');
+                return;
+            }
+            // Cooldown elapsed - transition to half-open
+            this.cbState = 'half-open';
+            this.cbLastStateChange = now;
+            logger.info({
+                previousState: 'open',
+                newState: 'half-open',
+                cooldownMs: this.cbCurrentCooldownMs,
+            }, '[EmbeddingServerManager] Circuit breaker: open -> half-open (allowing one test restart)');
+            this.emit('circuit_breaker', { state: 'half-open', cooldownMs: this.cbCurrentCooldownMs });
+        }
+        if (this.cbState === 'closed') {
+            // Check if we should trip the breaker
+            if (this.cbRestartTimestamps.length >= this.config.cbMaxRestartsInWindow) {
+                // Trip the circuit breaker
+                this.cbState = 'open';
+                this.cbCurrentCooldownMs = this.cbCurrentCooldownMs || this.config.cbCooldownMs;
+                this.cbCooldownUntil = now + this.cbCurrentCooldownMs;
+                this.cbLastStateChange = now;
+                logger.error({
+                    previousState: 'closed',
+                    newState: 'open',
+                    restartsInWindow: this.cbRestartTimestamps.length,
+                    windowMs: this.config.cbRestartWindowMs,
+                    maxAllowed: this.config.cbMaxRestartsInWindow,
+                    cooldownMs: this.cbCurrentCooldownMs,
+                    cooldownUntil: new Date(this.cbCooldownUntil).toISOString(),
+                }, '[EmbeddingServerManager] Circuit breaker TRIPPED: closed -> open (too many restarts in window)');
+                this.emit('circuit_breaker', {
+                    state: 'open',
+                    restartsInWindow: this.cbRestartTimestamps.length,
+                    cooldownMs: this.cbCurrentCooldownMs,
+                });
+                return;
+            }
+        }
+        // --- End Circuit Breaker pre-check ---
+        // Phase 4: Check for restart loop (>3 restarts in 60 seconds) - legacy check
         const loopInfo = this.getRestartLoopInfo();
         if (loopInfo.inLoop) {
             logger.error({
@@ -1632,7 +1808,7 @@ export class EmbeddingServerManager extends EventEmitter {
             await this.sleep(backoffMs);
         }
         // Check cooldown
-        const timeSinceLastRestart = Date.now() - this.lastRestartTime;
+        const timeSinceLastRestart = now - this.lastRestartTime;
         if (timeSinceLastRestart < this.config.restartCooldownMs) {
             const waitTime = this.config.restartCooldownMs - timeSinceLastRestart;
             logger.debug({ waitTime }, '[EmbeddingServerManager] Waiting for restart cooldown');
@@ -1649,15 +1825,57 @@ export class EmbeddingServerManager extends EventEmitter {
         }
         this.restartCount++;
         this.lastRestartTime = Date.now();
-        // Phase 4: Track restart timestamp for loop detection
-        this.restartTimestamps.push(Date.now());
-        // Keep only last 10 timestamps
+        // Track restart timestamp for both legacy loop detection and circuit breaker window
+        const restartTs = Date.now();
+        this.restartTimestamps.push(restartTs);
+        this.cbRestartTimestamps.push(restartTs);
+        // Keep only last 10 timestamps for legacy tracking
         if (this.restartTimestamps.length > 10) {
             this.restartTimestamps.shift();
         }
-        logger.info({ attempt: this.restartCount }, '[EmbeddingServerManager] Attempting restart');
+        logger.info({
+            attempt: this.restartCount,
+            cbState: this.cbState,
+            restartsInWindow: this.cbRestartTimestamps.length,
+        }, '[EmbeddingServerManager] Attempting restart');
         this.emit('restarting', { attempt: this.restartCount });
         const success = await this.start();
+        // --- Circuit Breaker post-restart evaluation ---
+        if (this.cbState === 'half-open') {
+            if (success) {
+                // Test restart succeeded - close the circuit breaker
+                this.cbState = 'closed';
+                this.cbCurrentCooldownMs = 0; // Reset cooldown on success
+                this.cbRestartTimestamps = [];
+                this.cbLastStateChange = Date.now();
+                logger.info({
+                    previousState: 'half-open',
+                    newState: 'closed',
+                }, '[EmbeddingServerManager] Circuit breaker: half-open -> closed (restart succeeded, counters reset)');
+                this.emit('circuit_breaker', { state: 'closed' });
+            }
+            else {
+                // Test restart failed - reopen with doubled cooldown
+                this.cbState = 'open';
+                this.cbCurrentCooldownMs = Math.min(
+                    this.cbCurrentCooldownMs * 2,
+                    this.config.cbMaxCooldownMs
+                );
+                this.cbCooldownUntil = Date.now() + this.cbCurrentCooldownMs;
+                this.cbLastStateChange = Date.now();
+                logger.error({
+                    previousState: 'half-open',
+                    newState: 'open',
+                    newCooldownMs: this.cbCurrentCooldownMs,
+                    maxCooldownMs: this.config.cbMaxCooldownMs,
+                    cooldownUntil: new Date(this.cbCooldownUntil).toISOString(),
+                }, '[EmbeddingServerManager] Circuit breaker: half-open -> open (restart failed, cooldown doubled)');
+                this.emit('circuit_breaker', {
+                    state: 'open',
+                    cooldownMs: this.cbCurrentCooldownMs,
+                });
+            }
+        }
         if (!success) {
             // Will retry on next health check
             logger.warn('[EmbeddingServerManager] Restart attempt failed');

package/dist/mcp/healthMonitor.js

@@ -31,7 +31,9 @@ export var ComponentHealth;
     ComponentHealth["UNKNOWN"] = "unknown";
 })(ComponentHealth || (ComponentHealth = {}));
 const DEFAULT_CONFIG = {
-    checkIntervalMs: parseInt(process.env['SPECMEM_HEALTH_CHECK_INTERVAL'] || '30000', 10),
+    checkIntervalMs: parseInt(process.env['SPECMEM_HEALTH_CHECK_INTERVAL_MS'] || process.env['SPECMEM_HEALTH_CHECK_INTERVAL'] || '30000', 10),
+    // Adaptive interval for unhealthy state (Issue #16)
+    unhealthyCheckIntervalMs: parseInt(process.env['SPECMEM_HEALTH_CHECK_UNHEALTHY_INTERVAL_MS'] || '5000', 10),
     dbTimeoutMs: parseInt(process.env['SPECMEM_HEALTH_DB_TIMEOUT'] || '5000', 10),
     // Use unified timeout config for embedding health checks
     embeddingTimeoutMs: getEmbeddingTimeout('health'),
@@ -58,6 +60,14 @@ export class HealthMonitor extends EventEmitter {
     checkTimer = null;
     logTimer = null;
     isRunning = false;
+    // Issue #16: Concurrency guard - prevents overlapping health checks
+    isCheckRunning = false;
+    // Issue #16: Diagnostics
+    totalHealthChecks = 0;
+    lastCheckTimestamp = 0;
+    // Issue #16: Adaptive interval tracking
+    currentCheckIntervalMs = 0;
+    consecutiveHealthyChecks = 0;
     // Component references
     resilientTransport = null;
     database = null;
@@ -76,8 +86,11 @@ export class HealthMonitor extends EventEmitter {
         this.transportHealth = this.createInitialHealth('transport');
         this.databaseHealth = this.createInitialHealth('database');
         this.embeddingHealth = this.createInitialHealth('embedding');
+        // Issue #16: Initialize adaptive interval to healthy rate
+        this.currentCheckIntervalMs = this.config.checkIntervalMs;
         logger.info({
             checkIntervalMs: this.config.checkIntervalMs,
+            unhealthyCheckIntervalMs: this.config.unhealthyCheckIntervalMs,
             autoRecoveryEnabled: this.config.autoRecoveryEnabled,
             logHealthStatus: this.config.logHealthStatus
         }, '[HealthMonitor] Initialized with config');
@@ -116,6 +129,10 @@ export class HealthMonitor extends EventEmitter {
     }
     /**
      * Start the health monitoring loop
+     *
+     * Issue #16: Uses setTimeout + recursive scheduling instead of setInterval
+     * to prevent check stacking when a health check takes longer than the interval.
+     * Uses adaptive intervals: faster checks when unhealthy, slower when healthy.
      */
     start() {
         if (this.isRunning) {
@@ -124,13 +141,9 @@ export class HealthMonitor extends EventEmitter {
         }
         this.isRunning = true;
         this.startTime = Date.now();
-        // Start periodic health checks
-        this.checkTimer = setInterval(() => {
-            this.runHealthChecks().catch(err => {
-                logger.error({ error: err }, '[HealthMonitor] Health check error');
-            });
-        }, this.config.checkIntervalMs);
-        this.checkTimer.unref();
+        this.currentCheckIntervalMs = this.config.checkIntervalMs;
+        // Issue #16: Start recursive setTimeout-based health check loop
+        this.scheduleNextHealthCheck();
         // Start periodic health logging if enabled
         if (this.config.logHealthStatus) {
             this.logTimer = setInterval(() => {
@@ -138,11 +151,40 @@ export class HealthMonitor extends EventEmitter {
             }, this.config.logIntervalMs);
             this.logTimer.unref();
         }
-        // Run initial health check
+        // Run initial health check immediately
         this.runHealthChecks().catch(err => {
             logger.error({ error: err }, '[HealthMonitor] Initial health check error');
         });
-        logger.info('[HealthMonitor] Health monitoring started');
+        logger.info({
+            initialIntervalMs: this.currentCheckIntervalMs,
+            unhealthyIntervalMs: this.config.unhealthyCheckIntervalMs,
+        }, '[HealthMonitor] Health monitoring started (adaptive setTimeout scheduling)');
+    }
+    /**
+     * Issue #16: Schedule the next health check using setTimeout (prevents stacking)
+     * Each check schedules the next one after completing, so checks never overlap from the timer.
+     */
+    scheduleNextHealthCheck() {
+        if (!this.isRunning) {
+            return;
+        }
+        // Clear any existing timer to prevent duplicates
+        if (this.checkTimer) {
+            clearTimeout(this.checkTimer);
+            this.checkTimer = null;
+        }
+        this.checkTimer = setTimeout(async () => {
+            if (!this.isRunning) return;
+            try {
+                await this.runHealthChecks();
+            }
+            catch (err) {
+                logger.error({ error: err }, '[HealthMonitor] Health check error');
+            }
+            // Schedule the next check (recursive scheduling)
+            this.scheduleNextHealthCheck();
+        }, this.currentCheckIntervalMs);
+        this.checkTimer.unref();
     }
     /**
      * Stop the health monitoring loop
@@ -152,36 +194,122 @@ export class HealthMonitor extends EventEmitter {
             return;
         }
         this.isRunning = false;
+        // Issue #16: checkTimer is now a setTimeout, use clearTimeout
         if (this.checkTimer) {
-            clearInterval(this.checkTimer);
+            clearTimeout(this.checkTimer);
             this.checkTimer = null;
         }
         if (this.logTimer) {
             clearInterval(this.logTimer);
             this.logTimer = null;
         }
-        logger.info('[HealthMonitor] Health monitoring stopped');
+        logger.info({
+            totalHealthChecks: this.totalHealthChecks,
+            lastCheckTimestamp: this.lastCheckTimestamp > 0 ? new Date(this.lastCheckTimestamp).toISOString() : null,
+            uptimeMs: Date.now() - this.startTime,
+        }, '[HealthMonitor] Health monitoring stopped');
+    }
+    /**
+     * Issue #16: Full cleanup/destroy method for graceful shutdown
+     * Stops all timers, removes all listeners, and resets all state.
+     */
+    destroy() {
+        this.stop();
+        this.removeAllListeners();
+        this.resilientTransport = null;
+        this.database = null;
+        this.embeddingSocketPath = null;
+        this.isCheckRunning = false;
+        this.totalHealthChecks = 0;
+        this.lastCheckTimestamp = 0;
+        this.consecutiveHealthyChecks = 0;
+        logger.info('[HealthMonitor] Destroyed - all resources released');
     }
     /**
      * Run all health checks (non-blocking)
+     *
+     * Issue #16: Added concurrency guard to prevent overlapping checks,
+     * diagnostic counters, and adaptive interval adjustment.
      */
     async runHealthChecks() {
-        const checkPromises = [
-            this.checkTransportHealth(),
-            this.checkDatabaseHealth(),
-            this.checkEmbeddingHealth()
-        ];
-        // Run all checks in parallel - they shouldn't block each other
-        await Promise.allSettled(checkPromises);
-        // Calculate overall health
-        const result = this.getSystemHealth();
-        // Emit health event
-        this.emit('health', result);
-        // Check for auto-recovery needs
-        if (this.config.autoRecoveryEnabled) {
-            await this.attemptAutoRecovery();
-        }
-        return result;
+        // Issue #16: Concurrency guard - prevent overlapping health checks
+        if (this.isCheckRunning) {
+            logger.debug('[HealthMonitor] Health check already in progress, skipping to prevent stacking');
+            return this.getSystemHealth();
+        }
+        this.isCheckRunning = true;
+        try {
+            const checkPromises = [
+                this.checkTransportHealth(),
+                this.checkDatabaseHealth(),
+                this.checkEmbeddingHealth()
+            ];
+            // Run all checks in parallel - they shouldn't block each other
+            await Promise.allSettled(checkPromises);
+            // Issue #16: Update diagnostics
+            this.totalHealthChecks++;
+            this.lastCheckTimestamp = Date.now();
+            // Calculate overall health
+            const result = this.getSystemHealth();
+            // Issue #16: Adaptive interval adjustment
+            this.adjustCheckInterval(result.overallHealth);
+            // Emit health event
+            this.emit('health', result);
+            // Check for auto-recovery needs
+            if (this.config.autoRecoveryEnabled) {
+                await this.attemptAutoRecovery();
+            }
+            return result;
+        }
+        finally {
+            this.isCheckRunning = false;
+        }
+    }
+    /**
+     * Issue #16: Adjust the check interval based on current system health
+     *
+     * - Healthy: use normal interval (SPECMEM_HEALTH_CHECK_INTERVAL_MS, default 30s)
+     * - Unhealthy: use fast interval (SPECMEM_HEALTH_CHECK_UNHEALTHY_INTERVAL_MS, default 5s)
+     * - Recovering: gradually increase from unhealthy to healthy interval
+     *   (each consecutive healthy check increases interval by 25% toward the healthy rate)
+     */
+    adjustCheckInterval(overallHealth) {
+        const healthyInterval = this.config.checkIntervalMs;
+        const unhealthyInterval = this.config.unhealthyCheckIntervalMs;
+        const previousInterval = this.currentCheckIntervalMs;
+        if (overallHealth === ComponentHealth.UNHEALTHY) {
+            // Unhealthy: switch to fast polling immediately
+            this.currentCheckIntervalMs = unhealthyInterval;
+            this.consecutiveHealthyChecks = 0;
+        }
+        else if (overallHealth === ComponentHealth.DEGRADED) {
+            // Degraded: use midpoint between unhealthy and healthy
+            this.currentCheckIntervalMs = Math.round((unhealthyInterval + healthyInterval) / 2);
+            this.consecutiveHealthyChecks = 0;
+        }
+        else if (overallHealth === ComponentHealth.HEALTHY) {
+            this.consecutiveHealthyChecks++;
+            if (this.currentCheckIntervalMs < healthyInterval) {
+                // Recovering: gradually increase interval back to healthy rate
+                // Each consecutive healthy check moves 25% closer to the healthy interval
+                const step = (healthyInterval - this.currentCheckIntervalMs) * 0.25;
+                this.currentCheckIntervalMs = Math.round(
+                    Math.min(this.currentCheckIntervalMs + Math.max(step, 1000), healthyInterval)
+                );
+            }
+            else {
+                this.currentCheckIntervalMs = healthyInterval;
+            }
+        }
+        // Log interval changes
+        if (previousInterval !== this.currentCheckIntervalMs) {
+            logger.info({
+                previousIntervalMs: previousInterval,
+                newIntervalMs: this.currentCheckIntervalMs,
+                overallHealth,
+                consecutiveHealthyChecks: this.consecutiveHealthyChecks,
+            }, '[HealthMonitor] Adaptive interval adjusted');
+        }
     }
     /**
      * Check transport health
@@ -590,7 +718,12 @@ export class HealthMonitor extends EventEmitter {
                 embedding: { ...this.embeddingHealth }
             },
             uptime: Date.now() - this.startTime,
-            timestamp: new Date().toISOString()
+            timestamp: new Date().toISOString(),
+            // Issue #16: Diagnostics
+            totalHealthChecks: this.totalHealthChecks,
+            lastCheckTimestamp: this.lastCheckTimestamp > 0 ? new Date(this.lastCheckTimestamp).toISOString() : null,
+            currentCheckIntervalMs: this.currentCheckIntervalMs,
+            consecutiveHealthyChecks: this.consecutiveHealthyChecks,
         };
     }
     /**
@@ -667,7 +800,7 @@ export function resetHealthMonitor(projectPath) {
     const targetProject = projectPath || getProjectPath();
     const monitor = healthMonitorsByProject.get(targetProject);
     if (monitor) {
-        monitor.stop();
+        monitor.destroy();
         healthMonitorsByProject.delete(targetProject);
         logger.debug({ projectPath: targetProject }, '[HealthMonitor] Reset instance for project');
     }
@@ -677,8 +810,8 @@ export function resetHealthMonitor(projectPath) {
  */
 export function resetAllHealthMonitors() {
     for (const [projectPath, monitor] of healthMonitorsByProject) {
-        monitor.stop();
-        logger.debug({ projectPath }, '[HealthMonitor] Stopped instance for project');
+        monitor.destroy();
+        logger.debug({ projectPath }, '[HealthMonitor] Destroyed instance for project');
     }
     healthMonitorsByProject.clear();
 }

package/dist/mcp/tools/embeddingControl.js

@@ -12,6 +12,7 @@
  */
 import { getEmbeddingServerManager } from '../embeddingServerManager.js';
 import { logger } from '../../utils/logger.js';
+import { execSync } from 'child_process';
 // Module-level reference to embedding provider for socket reset
 let embeddingProviderRef = null;
 /**
@@ -56,6 +57,36 @@ export class EmbeddingStart {
                     status: manager.getExtendedStatus()
                 };
             }
+            // ═══════════════════════════════════════════════════════════════
+            // HARD KILL: Force kill ALL frankenstein processes before restart
+            // This ensures force start actually works even when manager lost
+            // track of the process (e.g., after MCP reconnect)
+            // ═══════════════════════════════════════════════════════════════
+            try {
+                const pids = execSync('pgrep -f "frankenstein-embeddings.py" 2>/dev/null || true', { encoding: 'utf8' }).trim().split('\n').filter(Boolean);
+                if (pids.length > 0) {
+                    logger.info({ pids, count: pids.length }, '[EmbeddingStart] Hard killing all frankenstein processes');
+                    for (const pidStr of pids) {
+                        const pid = parseInt(pidStr, 10);
+                        if (pid && pid !== process.pid) {
+                            try { process.kill(pid, 'SIGTERM'); } catch { /* already dead */ }
+                        }
+                    }
+                    // Wait for them to die
+                    const killWaitMs = parseInt(process.env['SPECMEM_ORPHAN_KILL_WAIT_MS'] || '2000', 10);
+                    await new Promise(r => setTimeout(r, killWaitMs));
+                    // Force kill survivors
+                    for (const pidStr of pids) {
+                        const pid = parseInt(pidStr, 10);
+                        if (pid && pid !== process.pid) {
+                            try { process.kill(pid, 'SIGKILL'); } catch { /* already dead */ }
+                        }
+                    }
+                    logger.info('[EmbeddingStart] All old frankenstein processes killed');
+                }
+            } catch (killErr) {
+                logger.debug({ error: killErr }, '[EmbeddingStart] Hard kill failed (non-fatal)');
+            }
             const result = await manager.userStart();
             // CRITICAL: Reset the MCP's socket connection to pick up new server
             if (result.success && embeddingProviderRef?.resetSocket) {

package/dist/mcp/tools/teamComms.js

@@ -29,6 +29,7 @@ import { logger } from '../../utils/logger.js';
 import { v4 as uuidv4 } from 'uuid';
 import { createHash } from 'crypto';
 import fs from 'fs';
+import path from 'path';
 import { getProjectPathForInsert } from '../../services/ProjectContext.js';
 import { getFileCommsTransport } from '../../comms/fileCommsTransport.js';
 import { smartCompress } from '../../utils/tokenCompressor.js';
@@ -649,6 +650,13 @@ Examples:
                 logger.warn({ error: fileErr }, '[TeamComms] File fallback failed - message only visible in current process');
             }
         }
+        // Write latest team message to statusbar state file for live display
+        try {
+            const statusFile = path.join(projectPath, 'specmem', 'sockets', 'team-comms-latest.json');
+            const commsState = { sender: senderDisplayName, message: message.slice(0, 80), timestamp, channel: channel || 'main' };
+            fs.writeFileSync(statusFile, JSON.stringify(commsState));
+        }
+        catch (_e) { /* non-fatal */ }
         logToTeamChannel('send_message', {
             messageId,
             type,
@@ -1130,6 +1138,14 @@ Use cross_project: true for system-wide announcements (use sparingly).`;
             };
             teamMessagesMemory.set(messageId, teamMessage);
         }
+        // Write latest broadcast to statusbar state file for live display
+        try {
+            const broadcastProjectPath = cross_project ? (process.env.SPECMEM_PROJECT_PATH || process.cwd()) : projectPath;
+            const statusFile = path.join(broadcastProjectPath, 'specmem', 'sockets', 'team-comms-latest.json');
+            const commsState = { sender: senderName, message: message.slice(0, 80), timestamp, channel: 'broadcast' };
+            fs.writeFileSync(statusFile, JSON.stringify(commsState));
+        }
+        catch (_e) { /* non-fatal */ }
         logToTeamChannel('broadcast', {
             messageId,
             broadcast_type,