claude-flow-novice 2.0.0 → 2.0.1

package/.claude-flow-novice/dist/src/cfn-loop/heartbeat-integration-example.js

@@ -0,0 +1,187 @@
+/**
+ * Heartbeat Warning System Integration Example
+ *
+ * Demonstrates how to integrate heartbeat monitoring with blocking coordination
+ * for dead coordinator detection in CFN Loop workflows.
+ *
+ * Sprint 1.2: Dead Coordinator Detection
+ *
+ * @module cfn-loop/heartbeat-integration-example
+ */ import Redis from "ioredis";
+import { createHeartbeatWarningSystem } from "./heartbeat-warning-system.js";
+import { createBlockingCoordinationSignals, SignalType } from "./blocking-coordination-signals.js";
+// ===== EXAMPLE USAGE =====
+async function main() {
+    console.log('🚀 Heartbeat Warning System Integration Example\n');
+    // Initialize Redis client
+    const redis = new Redis({
+        host: process.env.REDIS_HOST || 'localhost',
+        port: parseInt(process.env.REDIS_PORT || '6379')
+    });
+    await new Promise((resolve, reject)=>{
+        redis.once('ready', resolve);
+        redis.once('error', reject);
+    });
+    console.log('✅ Redis connected\n');
+    // Initialize blocking coordination signals
+    const signalSystem = createBlockingCoordinationSignals({
+        redisHost: process.env.REDIS_HOST || 'localhost',
+        redisPort: parseInt(process.env.REDIS_PORT || '6379'),
+        signalTTL: 86400,
+        enableIdempotency: true
+    });
+    await signalSystem.connect();
+    console.log('✅ Blocking Coordination Signals initialized\n');
+    // Initialize heartbeat warning system
+    const warningSystem = createHeartbeatWarningSystem({
+        redisClient: redis,
+        monitorInterval: 10000,
+        staleThreshold: 120000,
+        maxWarnings: 3,
+        autoCleanup: true,
+        debug: true
+    });
+    console.log('✅ Heartbeat Warning System initialized\n');
+    // ===== SET UP EVENT LISTENERS =====
+    // Listen for heartbeat warnings
+    warningSystem.on('heartbeat:warning', (warning)=>{
+        console.log(`⚠️  HEARTBEAT WARNING:`, {
+            coordinator: warning.coordinatorId,
+            health: warning.health,
+            staleDuration: `${Math.round(warning.staleDuration / 1000)}s`,
+            consecutiveWarnings: `${warning.consecutiveWarnings}/3`,
+            reason: warning.reason
+        });
+    });
+    // Listen for coordinator recovery
+    warningSystem.on('coordinator:recovered', (event)=>{
+        console.log(`✅ Coordinator recovered:`, {
+            coordinator: event.coordinatorId,
+            previousWarnings: event.previousWarnings
+        });
+    });
+    // Listen for dead coordinator events
+    warningSystem.on('coordinator:dead', (event)=>{
+        console.log(`💀 COORDINATOR DEAD:`, {
+            coordinator: event.coordinatorId,
+            reason: event.reason,
+            consecutiveWarnings: event.consecutiveWarnings
+        });
+    });
+    // Listen for cleanup events
+    warningSystem.on('cleanup:complete', (event)=>{
+        console.log(`🧹 Cleanup complete:`, {
+            coordinator: event.coordinatorId,
+            keysDeleted: event.keysDeleted
+        });
+    });
+    // Listen for continuity violations
+    warningSystem.on('continuity:violation', (event)=>{
+        console.log(`⚠️  Heartbeat sequence gap:`, {
+            coordinator: event.coordinatorId,
+            expected: event.expectedSequence,
+            received: event.receivedSequence,
+            gap: event.gap
+        });
+    });
+    // Listen for critical errors
+    warningSystem.on('error', (error)=>{
+        console.error(`🚨 CRITICAL ERROR:`, error.message);
+    });
+    console.log('✅ Event listeners configured\n');
+    // ===== START MONITORING =====
+    console.log('🔍 Starting heartbeat monitoring...\n');
+    warningSystem.startMonitoring();
+    // ===== SIMULATE COORDINATOR ACTIVITY =====
+    // Coordinator 1: Healthy coordinator sending regular heartbeats
+    const coordinator1 = 'coordinator-healthy';
+    let iteration1 = 0;
+    const heartbeatTimer1 = setInterval(async ()=>{
+        iteration1++;
+        // Register heartbeat
+        await warningSystem.registerHeartbeat(coordinator1, iteration1, {
+            phase: 'auth',
+            agentCount: 5,
+            status: 'running'
+        });
+        // Send heartbeat signal
+        await signalSystem.sendSignal(coordinator1, 'coordinator-healthy', SignalType.HEARTBEAT, iteration1, {
+            status: 'healthy'
+        });
+        console.log(`💓 [${coordinator1}] Heartbeat sent (iteration ${iteration1})`);
+    }, 30000); // Every 30 seconds (well within 120s threshold)
+    // Coordinator 2: Coordinator that will go silent (simulate dead coordinator)
+    const coordinator2 = 'coordinator-silent';
+    let iteration2 = 0;
+    // Send initial heartbeat
+    await warningSystem.registerHeartbeat(coordinator2, iteration2, {
+        phase: 'profile',
+        agentCount: 3,
+        status: 'running'
+    });
+    console.log(`💓 [${coordinator2}] Initial heartbeat sent\n`);
+    // Coordinator 2 goes silent after initial heartbeat
+    // Warning system will detect stale heartbeat after 120 seconds
+    // ===== RUN FOR 5 MINUTES =====
+    console.log('⏱️  Running example for 5 minutes...\n');
+    console.log('Expected behavior:');
+    console.log('  1. coordinator-healthy: Regular heartbeats every 30s (no warnings)');
+    console.log('  2. coordinator-silent: No heartbeats → warnings after 120s → DEAD after 3 warnings\n');
+    // Wait 5 minutes
+    await new Promise((resolve)=>setTimeout(resolve, 300000));
+    // ===== CLEANUP =====
+    console.log('\n🧹 Cleaning up...\n');
+    clearInterval(heartbeatTimer1);
+    warningSystem.stopMonitoring();
+    // Show final statistics
+    const stats = warningSystem.getStatistics();
+    console.log('📊 Final Statistics:', stats);
+    await signalSystem.disconnect();
+    await redis.quit();
+    console.log('\n✅ Example complete');
+}
+// ===== SIMPLIFIED USAGE EXAMPLE =====
+/**
+ * Basic usage pattern for heartbeat monitoring
+ */ async function basicUsageExample() {
+    // 1. Initialize Redis
+    const redis = new Redis();
+    // 2. Create heartbeat warning system
+    const warningSystem = createHeartbeatWarningSystem({
+        redisClient: redis,
+        monitorInterval: 10000,
+        staleThreshold: 120000,
+        maxWarnings: 3,
+        autoCleanup: true
+    });
+    // 3. Set up event listeners
+    warningSystem.on('heartbeat:warning', (warning)=>{
+        console.log(`Warning: ${warning.coordinatorId} stale for ${warning.staleDuration}ms`);
+    });
+    warningSystem.on('coordinator:dead', (event)=>{
+        console.error(`CRITICAL: ${event.coordinatorId} marked as DEAD - ${event.reason}`);
+    // Handle dead coordinator (e.g., spawn replacement, notify admin)
+    });
+    // 4. Start monitoring
+    warningSystem.startMonitoring();
+    // 5. Register heartbeats in your coordinator
+    const coordinatorId = 'my-coordinator';
+    let iteration = 0;
+    setInterval(async ()=>{
+        iteration++;
+        await warningSystem.registerHeartbeat(coordinatorId, iteration, {
+            phase: 'current-phase',
+            agentCount: 5
+        });
+    }, 30000); // Every 30 seconds
+// 6. Stop monitoring when done
+// warningSystem.stopMonitoring();
+}
+// ===== RUN EXAMPLE =====
+if (import.meta.url === `file://${process.argv[1]}`) {
+    main().catch((error)=>{
+        console.error('Example failed:', error);
+        process.exit(1);
+    });
+}
+export { main, basicUsageExample };

package/.claude-flow-novice/dist/src/cfn-loop/heartbeat-warning-system.js

@@ -0,0 +1,492 @@
+/**
+ * Heartbeat Warning System - Sprint 1.2: Dead Coordinator Detection
+ *
+ * Monitors coordinator heartbeats and detects dead coordinators within 2 minutes.
+ * Implements warning escalation, critical exit paths, and orphan cleanup.
+ *
+ * Features:
+ * - Monitor heartbeat freshness every 10 seconds
+ * - Warning threshold: >120 seconds without heartbeat update
+ * - Escalation: 3 consecutive warnings → coordinator marked as DEAD
+ * - Critical exit: Error emission for dead coordinator scenarios
+ * - Cleanup: Remove stale state, ACKs, signals for dead coordinators
+ *
+ * Epic: production-blocking-coordination
+ * Sprint: 1.2 - Dead Coordinator Detection
+ * Target: Detection within 2 minutes (120 seconds)
+ *
+ * @module cfn-loop/heartbeat-warning-system
+ */ function _define_property(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+import { EventEmitter } from "events";
+import { Logger } from "../core/logger.js";
+/**
+ * Coordinator health status
+ */ export var CoordinatorHealth = /*#__PURE__*/ function(CoordinatorHealth) {
+    CoordinatorHealth["HEALTHY"] = "healthy";
+    CoordinatorHealth["WARNING"] = "warning";
+    CoordinatorHealth["CRITICAL"] = "critical";
+    CoordinatorHealth["DEAD"] = "dead";
+    return CoordinatorHealth;
+}({});
+// ===== HEARTBEAT WARNING SYSTEM =====
+/**
+ * Manages heartbeat monitoring and dead coordinator detection
+ */ export class HeartbeatWarningSystem extends EventEmitter {
+    /**
+   * Start heartbeat monitoring
+   */ startMonitoring() {
+        if (this.isMonitoring) {
+            this.logger.warn('Heartbeat monitoring already running');
+            return;
+        }
+        this.isMonitoring = true;
+        this.logger.info('Starting heartbeat monitoring', {
+            interval: this.monitorInterval,
+            staleThreshold: this.staleThreshold
+        });
+        // Start monitoring loop
+        this.monitorTimer = setInterval(()=>{
+            this.monitorHeartbeats().catch((error)=>{
+                this.logger.error('Heartbeat monitor cycle failed', {
+                    error: error instanceof Error ? error.message : String(error)
+                });
+            });
+        }, this.monitorInterval);
+        // Emit monitoring started event
+        this.emit('monitoring:started', {
+            interval: this.monitorInterval,
+            threshold: this.staleThreshold
+        });
+    }
+    /**
+   * Stop heartbeat monitoring
+   */ stopMonitoring() {
+        if (!this.isMonitoring) {
+            this.logger.warn('Heartbeat monitoring not running');
+            return;
+        }
+        if (this.monitorTimer) {
+            clearInterval(this.monitorTimer);
+            this.monitorTimer = null;
+        }
+        this.isMonitoring = false;
+        this.logger.info('Stopped heartbeat monitoring', {
+            totalCycles: this.stats.totalMonitorCycles,
+            warningsIssued: this.stats.warningsIssued,
+            coordinatorsMarkedDead: this.stats.coordinatorsMarkedDead
+        });
+        // Emit monitoring stopped event
+        this.emit('monitoring:stopped', {
+            statistics: this.getStatistics()
+        });
+    }
+    /**
+   * Register heartbeat for a coordinator
+   *
+   * @param coordinatorId - Coordinator ID
+   * @param iteration - Current iteration count
+   * @param metadata - Optional metadata
+   * @returns Heartbeat record
+   */ async registerHeartbeat(coordinatorId, iteration, metadata) {
+        const timestamp = Date.now();
+        // Get current sequence (increment from last)
+        const lastSequence = this.lastSequences.get(coordinatorId) ?? 0;
+        const sequence = lastSequence + 1;
+        const heartbeat = {
+            coordinatorId,
+            lastHeartbeat: timestamp,
+            sequence,
+            iteration,
+            metadata
+        };
+        // Store heartbeat in Redis with TTL
+        const key = this.buildHeartbeatKey(coordinatorId);
+        await this.redis.setex(key, 300, JSON.stringify(heartbeat)); // 5 min TTL
+        // Update local tracking
+        this.lastSequences.set(coordinatorId, sequence);
+        // Reset warning count on successful heartbeat
+        if (this.warningCounts.has(coordinatorId)) {
+            this.warningCounts.set(coordinatorId, 0);
+            this.healthStatus.set(coordinatorId, "healthy");
+        }
+        this.logger.debug('Heartbeat registered', {
+            coordinatorId,
+            sequence,
+            iteration,
+            timestamp
+        });
+        return heartbeat;
+    }
+    /**
+   * Get heartbeat for a coordinator
+   *
+   * @param coordinatorId - Coordinator ID
+   * @returns Heartbeat record or null if not found
+   */ async getHeartbeat(coordinatorId) {
+        const key = this.buildHeartbeatKey(coordinatorId);
+        try {
+            const heartbeatJson = await this.redis.get(key);
+            if (!heartbeatJson) {
+                return null;
+            }
+            const heartbeat = JSON.parse(heartbeatJson);
+            return heartbeat;
+        } catch (error) {
+            this.logger.error('Failed to get heartbeat', {
+                coordinatorId,
+                error: error instanceof Error ? error.message : String(error)
+            });
+            return null;
+        }
+    }
+    /**
+   * Check heartbeat freshness for a coordinator
+   *
+   * @param coordinatorId - Coordinator ID
+   * @returns Staleness duration in milliseconds, or null if no heartbeat
+   */ async checkHeartbeatFreshness(coordinatorId) {
+        const heartbeat = await this.getHeartbeat(coordinatorId);
+        if (!heartbeat) {
+            return null;
+        }
+        const now = Date.now();
+        const staleDuration = now - heartbeat.lastHeartbeat;
+        return staleDuration;
+    }
+    /**
+   * Get coordinator health status
+   *
+   * @param coordinatorId - Coordinator ID
+   * @returns Health status
+   */ getHealthStatus(coordinatorId) {
+        return this.healthStatus.get(coordinatorId) ?? "healthy";
+    }
+    /**
+   * Mark coordinator as dead and trigger cleanup
+   *
+   * @param coordinatorId - Coordinator ID
+   * @param reason - Reason for marking as dead
+   */ async markCoordinatorDead(coordinatorId, reason) {
+        this.logger.error('Marking coordinator as DEAD', {
+            coordinatorId,
+            reason,
+            consecutiveWarnings: this.warningCounts.get(coordinatorId) ?? 0
+        });
+        // Update health status
+        this.healthStatus.set(coordinatorId, "dead");
+        this.stats.coordinatorsMarkedDead++;
+        // Emit critical dead coordinator event
+        const deadEvent = {
+            coordinatorId,
+            reason,
+            consecutiveWarnings: this.warningCounts.get(coordinatorId) ?? 0,
+            timestamp: Date.now()
+        };
+        this.emit('coordinator:dead', deadEvent);
+        // Perform automatic cleanup if enabled
+        if (this.autoCleanup) {
+            await this.cleanupDeadCoordinator(coordinatorId);
+        }
+        // Throw error for critical exit path
+        const error = new Error(`CRITICAL: Coordinator ${coordinatorId} marked as DEAD - ${reason}. ` + `Consecutive warnings: ${this.warningCounts.get(coordinatorId) ?? 0}/${this.maxWarnings}`);
+        error.name = 'DeadCoordinatorError';
+        this.emit('error', error);
+    }
+    /**
+   * Cleanup stale state for a dead coordinator
+   *
+   * Removes:
+   * - Heartbeat records
+   * - Signal ACKs (blocking:ack:coordinatorId:*)
+   * - Signals (blocking:signal:coordinatorId)
+   * - Idempotency records (blocking:idempotency:*coordinatorId*)
+   *
+   * @param coordinatorId - Coordinator ID
+   */ async cleanupDeadCoordinator(coordinatorId) {
+        this.logger.info('Cleaning up dead coordinator state', {
+            coordinatorId
+        });
+        try {
+            const keysToDelete = [];
+            // 1. Heartbeat key
+            const heartbeatKey = this.buildHeartbeatKey(coordinatorId);
+            keysToDelete.push(heartbeatKey);
+            // 2. Signal ACK keys (blocking:ack:coordinatorId:*)
+            const ackPattern = `blocking:ack:${coordinatorId}:*`;
+            const ackKeys = await this.redis.keys(ackPattern);
+            keysToDelete.push(...ackKeys);
+            // 3. Signal key (blocking:signal:coordinatorId)
+            const signalKey = `blocking:signal:${coordinatorId}`;
+            keysToDelete.push(signalKey);
+            // 4. Idempotency keys (blocking:idempotency:*coordinatorId*)
+            const idempotencyPattern = `blocking:idempotency:*${coordinatorId}*`;
+            const idempotencyKeys = await this.redis.keys(idempotencyPattern);
+            keysToDelete.push(...idempotencyKeys);
+            // Delete all keys in batch
+            if (keysToDelete.length > 0) {
+                await this.redis.del(keysToDelete);
+            }
+            this.stats.cleanupsPerformed++;
+            this.logger.info('Dead coordinator cleanup complete', {
+                coordinatorId,
+                keysDeleted: keysToDelete.length,
+                categories: {
+                    heartbeat: 1,
+                    acks: ackKeys.length,
+                    signals: 1,
+                    idempotency: idempotencyKeys.length
+                }
+            });
+            // Emit cleanup complete event
+            this.emit('cleanup:complete', {
+                coordinatorId,
+                keysDeleted: keysToDelete.length,
+                timestamp: Date.now()
+            });
+        } catch (error) {
+            this.logger.error('Cleanup failed for dead coordinator', {
+                coordinatorId,
+                error: error instanceof Error ? error.message : String(error)
+            });
+            this.emit('cleanup:failed', {
+                coordinatorId,
+                error: error instanceof Error ? error.message : String(error),
+                timestamp: Date.now()
+            });
+        }
+    }
+    /**
+   * Validate heartbeat continuity (sequence numbers)
+   *
+   * @param coordinatorId - Coordinator ID
+   * @param heartbeat - Heartbeat record
+   * @returns True if sequence is valid, false if gap detected
+   */ validateHeartbeatContinuity(coordinatorId, heartbeat) {
+        const lastSequence = this.lastSequences.get(coordinatorId);
+        if (lastSequence === undefined) {
+            // First heartbeat for this coordinator
+            return true;
+        }
+        const expectedSequence = lastSequence + 1;
+        if (heartbeat.sequence !== expectedSequence) {
+            this.logger.warn('Heartbeat sequence gap detected', {
+                coordinatorId,
+                expected: expectedSequence,
+                received: heartbeat.sequence,
+                gap: heartbeat.sequence - expectedSequence
+            });
+            this.stats.continuityViolations++;
+            this.emit('continuity:violation', {
+                coordinatorId,
+                expectedSequence,
+                receivedSequence: heartbeat.sequence,
+                gap: heartbeat.sequence - expectedSequence,
+                timestamp: Date.now()
+            });
+            return false;
+        }
+        return true;
+    }
+    /**
+   * Get statistics
+   */ getStatistics() {
+        return {
+            ...this.stats,
+            coordinatorsMonitored: this.healthStatus.size,
+            deadCoordinators: Array.from(this.healthStatus.entries()).filter(([_, status])=>status === "dead").map(([id])=>id)
+        };
+    }
+    /**
+   * Reset statistics
+   */ resetStatistics() {
+        this.stats = {
+            totalMonitorCycles: 0,
+            warningsIssued: 0,
+            coordinatorsMarkedDead: 0,
+            cleanupsPerformed: 0,
+            continuityViolations: 0
+        };
+    }
+    // ===== PRIVATE METHODS =====
+    /**
+   * Monitor heartbeats for all coordinators
+   */ async monitorHeartbeats() {
+        this.stats.totalMonitorCycles++;
+        const now = Date.now();
+        this.logger.debug('Starting heartbeat monitor cycle', {
+            cycle: this.stats.totalMonitorCycles,
+            timestamp: now
+        });
+        try {
+            // Find all heartbeat keys
+            const pattern = 'blocking:heartbeat:*';
+            const keys = await this.redis.keys(pattern);
+            this.logger.debug('Found heartbeat keys', {
+                count: keys.length,
+                keys
+            });
+            for (const key of keys){
+                const coordinatorId = this.extractCoordinatorId(key);
+                if (!coordinatorId) {
+                    continue;
+                }
+                // Skip if already marked as dead
+                if (this.healthStatus.get(coordinatorId) === "dead") {
+                    continue;
+                }
+                // Check heartbeat freshness
+                const heartbeat = await this.getHeartbeat(coordinatorId);
+                if (!heartbeat) {
+                    this.logger.warn('Heartbeat key exists but data missing', {
+                        coordinatorId,
+                        key
+                    });
+                    continue;
+                }
+                // Validate heartbeat continuity
+                this.validateHeartbeatContinuity(coordinatorId, heartbeat);
+                const staleDuration = now - heartbeat.lastHeartbeat;
+                // Check if heartbeat is stale
+                if (staleDuration > this.staleThreshold) {
+                    await this.handleStaleHeartbeat(coordinatorId, staleDuration, heartbeat);
+                } else {
+                    // Heartbeat is fresh - reset warning count if it was previously warned
+                    if (this.warningCounts.has(coordinatorId) && this.warningCounts.get(coordinatorId) > 0) {
+                        this.logger.info('Coordinator recovered from warning state', {
+                            coordinatorId,
+                            previousWarnings: this.warningCounts.get(coordinatorId),
+                            staleDuration
+                        });
+                        this.warningCounts.set(coordinatorId, 0);
+                        this.healthStatus.set(coordinatorId, "healthy");
+                        this.emit('coordinator:recovered', {
+                            coordinatorId,
+                            previousWarnings: this.warningCounts.get(coordinatorId),
+                            timestamp: now
+                        });
+                    }
+                }
+            }
+        } catch (error) {
+            this.logger.error('Monitor heartbeats cycle failed', {
+                error: error instanceof Error ? error.message : String(error)
+            });
+        }
+    }
+    /**
+   * Handle stale heartbeat detection
+   */ async handleStaleHeartbeat(coordinatorId, staleDuration, heartbeat) {
+        // Increment warning count
+        const currentWarnings = this.warningCounts.get(coordinatorId) ?? 0;
+        const newWarnings = currentWarnings + 1;
+        this.warningCounts.set(coordinatorId, newWarnings);
+        // Determine health status
+        let health;
+        if (newWarnings >= this.maxWarnings) {
+            health = "dead";
+        } else if (newWarnings >= 2) {
+            health = "critical";
+        } else {
+            health = "warning";
+        }
+        this.healthStatus.set(coordinatorId, health);
+        const warning = {
+            coordinatorId,
+            health,
+            staleDuration,
+            consecutiveWarnings: newWarnings,
+            lastHeartbeat: heartbeat.lastHeartbeat,
+            timestamp: Date.now(),
+            reason: `Heartbeat stale for ${Math.round(staleDuration / 1000)}s (threshold: ${Math.round(this.staleThreshold / 1000)}s)`
+        };
+        this.stats.warningsIssued++;
+        this.logger.warn('Stale heartbeat detected', {
+            coordinatorId,
+            health,
+            staleDuration,
+            staleSeconds: Math.round(staleDuration / 1000),
+            thresholdSeconds: Math.round(this.staleThreshold / 1000),
+            consecutiveWarnings: newWarnings,
+            maxWarnings: this.maxWarnings
+        });
+        // Emit warning event
+        this.emit('heartbeat:warning', warning);
+        // If reached max warnings, mark as dead
+        if (newWarnings >= this.maxWarnings) {
+            await this.markCoordinatorDead(coordinatorId, `${newWarnings} consecutive warnings - heartbeat stale for ${Math.round(staleDuration / 1000)}s`);
+        }
+    }
+    /**
+   * Build Redis key for heartbeat
+   */ buildHeartbeatKey(coordinatorId) {
+        return `blocking:heartbeat:${coordinatorId}`;
+    }
+    /**
+   * Extract coordinator ID from heartbeat key
+   */ extractCoordinatorId(key) {
+        const match = key.match(/^blocking:heartbeat:(.+)$/);
+        return match ? match[1] : null;
+    }
+    constructor(config){
+        super(), _define_property(this, "logger", void 0), _define_property(this, "redis", void 0), _define_property(this, "monitorInterval", void 0), _define_property(this, "staleThreshold", void 0), _define_property(this, "maxWarnings", void 0), _define_property(this, "autoCleanup", void 0), _define_property(this, "debug", void 0), // Monitoring state
+        _define_property(this, "monitorTimer", null), _define_property(this, "isMonitoring", false), // Tracking consecutive warnings per coordinator
+        _define_property(this, "warningCounts", new Map()), // Track coordinator health status
+        _define_property(this, "healthStatus", new Map()), // Track last sequence numbers for continuity validation
+        _define_property(this, "lastSequences", new Map()), // Statistics
+        _define_property(this, "stats", {
+            totalMonitorCycles: 0,
+            warningsIssued: 0,
+            coordinatorsMarkedDead: 0,
+            cleanupsPerformed: 0,
+            continuityViolations: 0
+        });
+        this.redis = config.redisClient;
+        this.monitorInterval = config.monitorInterval ?? 10000; // 10 seconds
+        this.staleThreshold = config.staleThreshold ?? 120000; // 120 seconds
+        this.maxWarnings = config.maxWarnings ?? 3; // 3 consecutive warnings
+        this.autoCleanup = config.autoCleanup ?? true;
+        this.debug = config.debug ?? false;
+        // Initialize logger
+        const loggerConfig = process.env.CLAUDE_FLOW_ENV === 'test' ? {
+            level: 'error',
+            format: 'json',
+            destination: 'console'
+        } : {
+            level: this.debug ? 'debug' : 'info',
+            format: 'json',
+            destination: 'console'
+        };
+        this.logger = new Logger(loggerConfig, {
+            component: 'HeartbeatWarningSystem'
+        });
+        this.logger.info('Heartbeat Warning System initialized', {
+            monitorInterval: this.monitorInterval,
+            staleThreshold: this.staleThreshold,
+            maxWarnings: this.maxWarnings,
+            autoCleanup: this.autoCleanup
+        });
+    }
+}
+// ===== FACTORY FUNCTION =====
+/**
+ * Create a HeartbeatWarningSystem instance
+ *
+ * @param config - Configuration for heartbeat warning system
+ * @returns Configured HeartbeatWarningSystem
+ */ export function createHeartbeatWarningSystem(config) {
+    return new HeartbeatWarningSystem(config);
+}
+// ===== EXPORTS =====
+export default HeartbeatWarningSystem;