claude-flow-novice 2.0.0 → 2.0.1

package/.claude-flow-novice/dist/__tests__/redis/RedisHealthMonitor.test.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Redis Health Monitor Tests
+ *
+ * Tests for Sprint 1.3: Auto-reconnect with exponential backoff
+ *
+ * Coverage:
+ * - Connection lifecycle
+ * - Health checks
+ * - Auto-reconnection with exponential backoff
+ * - Event emission
+ * - Metrics collection
+ * - Error handling and recovery
+ */
+export {};

package/.claude-flow-novice/dist/agents/heartbeat-manager.d.ts

@@ -0,0 +1,73 @@
+/**
+ * Agent Heartbeat Manager
+ * Sprint 3.2: Memory Leak Prevention - Agent Heartbeat System
+ *
+ * Features:
+ * - Agents send heartbeat every 30s to Redis
+ * - Meta-coordinator monitors heartbeats
+ * - Timeout handler detects dead agents (>2min idle)
+ * - Work transfer to replacement agents
+ * - Integration with lifecycle cleanup
+ *
+ * Epic: memory-leak-prevention
+ * Sprint: 3.2 - Agent Heartbeat System
+ *
+ * @module agents/heartbeat-manager
+ */
+import { EventEmitter } from 'events';
+import type { Redis } from 'ioredis';
+export interface HeartbeatConfig {
+    redisClient: Redis;
+    heartbeatInterval: number;
+    deadAgentThreshold: number;
+    enableWorkTransfer: boolean;
+    debug?: boolean;
+}
+export interface AgentHeartbeat {
+    agentId: string;
+    agentType: string;
+    timestamp: number;
+    sequenceNumber: number;
+    metadata?: {
+        taskId?: string;
+        swarmId?: string;
+        status?: string;
+        currentWork?: string;
+    };
+}
+export interface DeadAgentEvent {
+    agentId: string;
+    agentType: string;
+    lastHeartbeat: number;
+    idleDuration: number;
+    currentWork?: string;
+    replacementRequired: boolean;
+}
+export declare class HeartbeatManager extends EventEmitter {
+    private redis;
+    private logger;
+    private heartbeatInterval;
+    private deadAgentThreshold;
+    private enableWorkTransfer;
+    private isRunning;
+    private heartbeatTimer?;
+    private monitorTimer?;
+    private agentSequences;
+    private metrics;
+    constructor(config: HeartbeatConfig);
+    sendHeartbeat(agentId: string, agentType: string, metadata?: AgentHeartbeat['metadata']): Promise<void>;
+    startMonitoring(): void;
+    stopMonitoring(): void;
+    private checkForDeadAgents;
+    private handleDeadAgent;
+    private transferWork;
+    getMetrics(): {
+        isRunning: boolean;
+        heartbeatsSent: number;
+        deadAgentsDetected: number;
+        workTransfersExecuted: number;
+        errors: number;
+    };
+    shutdown(): Promise<void>;
+}
+export declare function createHeartbeatManager(config: HeartbeatConfig): HeartbeatManager;

package/.claude-flow-novice/dist/agents/lifecycle-cleanup-enhanced.d.ts

@@ -0,0 +1,190 @@
+/**
+ * Enhanced Lifecycle Cleanup Manager
+ * Sprint 3.1: Memory Leak Prevention - Enhanced Lifecycle Cleanup
+ *
+ * Features:
+ * - Redis-synchronized cleanup for cross-process coordination
+ * - Orphan detection (agents idle >2min)
+ * - Force cleanup with distributed lock acquisition
+ * - Memory leak detection and monitoring
+ * - Automatic cleanup of stale agent state
+ *
+ * Epic: memory-leak-prevention
+ * Sprint: 3.1 - Enhanced Lifecycle Cleanup
+ *
+ * @module agents/lifecycle-cleanup-enhanced
+ */
+import { EventEmitter } from 'events';
+import type { Redis } from 'ioredis';
+import type { AgentLifecycleContext, AgentLifecycleState } from './lifecycle-manager.js';
+/**
+ * Orphan detection configuration
+ */
+export interface OrphanDetectionConfig {
+    /** Idle threshold in milliseconds (default: 120000 = 2 minutes) */
+    idleThreshold: number;
+    /** Check interval in milliseconds (default: 30000 = 30 seconds) */
+    checkInterval: number;
+    /** Enable automatic cleanup of detected orphans */
+    autoCleanup: boolean;
+}
+/**
+ * Cleanup lock configuration
+ */
+export interface CleanupLockConfig {
+    /** Lock timeout in seconds (default: 30) */
+    lockTimeout: number;
+    /** Lock retry attempts (default: 3) */
+    retryAttempts: number;
+    /** Retry delay in milliseconds (default: 1000) */
+    retryDelay: number;
+}
+/**
+ * Enhanced lifecycle cleanup configuration
+ */
+export interface EnhancedLifecycleCleanupConfig {
+    /** Redis client instance */
+    redisClient: Redis;
+    /** Redis key prefix for cleanup coordination */
+    redisKeyPrefix?: string;
+    /** Orphan detection configuration */
+    orphanDetection: OrphanDetectionConfig;
+    /** Cleanup lock configuration */
+    cleanupLock?: CleanupLockConfig;
+    /** Enable debug logging */
+    debug?: boolean;
+}
+/**
+ * Orphan agent information
+ */
+export interface OrphanAgent {
+    agentId: string;
+    agentName: string;
+    agentType: string;
+    state: AgentLifecycleState;
+    lastActivity: Date;
+    idleDuration: number;
+    swarmId?: string;
+    taskId?: string;
+    reason: string;
+}
+/**
+ * Cleanup result
+ */
+export interface CleanupResult {
+    success: boolean;
+    agentId: string;
+    cleanupTime: number;
+    redisKeysRemoved: number;
+    memoryFreed: number;
+    error?: Error;
+}
+/**
+ * Memory leak metrics
+ */
+export interface MemoryLeakMetrics {
+    totalAgents: number;
+    activeAgents: number;
+    orphanedAgents: number;
+    zombieAgents: number;
+    averageIdleTime: number;
+    memoryUsage: {
+        heapUsed: number;
+        heapTotal: number;
+        external: number;
+        arrayBuffers: number;
+    };
+    redisKeys: {
+        total: number;
+        stale: number;
+    };
+}
+/**
+ * Enhanced lifecycle cleanup manager with Redis coordination
+ */
+export declare class EnhancedLifecycleCleanupManager extends EventEmitter {
+    private redis;
+    private redisKeyPrefix;
+    private orphanDetectionConfig;
+    private cleanupLockConfig;
+    private logger;
+    private debug;
+    private orphanCheckInterval?;
+    private isMonitoring;
+    private metrics;
+    constructor(config: EnhancedLifecycleCleanupConfig);
+    /**
+     * Start orphan detection monitoring
+     */
+    startMonitoring(): void;
+    /**
+     * Stop orphan detection monitoring
+     */
+    stopMonitoring(): void;
+    /**
+     * Detect orphaned agents
+     */
+    detectOrphans(agents: AgentLifecycleContext[]): Promise<OrphanAgent[]>;
+    /**
+     * Check if agent is truly orphaned (cross-check with Redis)
+     */
+    private isAgentOrphaned;
+    /**
+     * Get reason for orphan classification
+     */
+    private getOrphanReason;
+    /**
+     * Detect and cleanup orphans (automatic monitoring cycle)
+     */
+    private detectAndCleanupOrphans;
+    /**
+     * Force cleanup agent with distributed lock
+     */
+    forceCleanupAgent(agentId: string, reason: string): Promise<CleanupResult>;
+    /**
+     * Acquire distributed cleanup lock
+     */
+    private acquireCleanupLock;
+    /**
+     * Release distributed cleanup lock
+     */
+    private releaseCleanupLock;
+    /**
+     * Execute agent cleanup
+     */
+    private executeCleanup;
+    /**
+     * Get memory leak metrics
+     */
+    getMemoryLeakMetrics(): Promise<MemoryLeakMetrics>;
+    /**
+     * Find stale Redis keys (keys without TTL or expired content)
+     */
+    private findStaleRedisKeys;
+    /**
+     * Cleanup stale Redis keys
+     */
+    cleanupStaleRedisKeys(): Promise<number>;
+    /**
+     * Get cleanup metrics
+     */
+    getMetrics(): {
+        isMonitoring: boolean;
+        orphansDetected: number;
+        orphansCleaned: number;
+        forceCleanupsExecuted: number;
+        cleanupFailures: number;
+        redisKeysRemoved: number;
+        memoryFreed: number;
+        lastOrphanCheckTime: number;
+    };
+    /**
+     * Graceful shutdown
+     */
+    shutdown(): Promise<void>;
+}
+/**
+ * Create enhanced lifecycle cleanup manager
+ */
+export declare function createEnhancedLifecycleCleanupManager(config: EnhancedLifecycleCleanupConfig): EnhancedLifecycleCleanupManager;
+export default EnhancedLifecycleCleanupManager;

package/.claude-flow-novice/dist/cfn-loop/__tests__/agent-lifecycle-sqlite.test.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Agent Lifecycle SQLite Integration Tests - Sprint 1.7
+ *
+ * Test Coverage:
+ * 1. Agent spawn registration in SQLite
+ * 2. Confidence score updates and history tracking
+ * 3. Agent termination cleanup
+ * 4. Audit log completeness for lifecycle events
+ * 5. Cross-session state recovery
+ * 6. Concurrent agent operations
+ *
+ * Epic: SQLite Integration Migration
+ * Sprint: 1.7 - Testing & Validation
+ *
+ * @module cfn-loop/__tests__/agent-lifecycle-sqlite.test
+ */
+export {};

package/.claude-flow-novice/dist/cfn-loop/__tests__/blocking-coordination-audit.test.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Blocking Coordination Audit Tests with SQLite - Sprint 1.7
+ *
+ * Test Coverage:
+ * 1. Signal ACK event logging to SQLite
+ * 2. Timeout event persistence
+ * 3. Dead coordinator escalation logging
+ * 4. Audit trail completeness
+ * 5. Query performance for audit logs
+ *
+ * Epic: SQLite Integration Migration
+ * Sprint: 1.7 - Testing & Validation
+ *
+ * @module cfn-loop/__tests__/blocking-coordination-audit.test
+ */
+export {};

package/.claude-flow-novice/dist/cfn-loop/__tests__/blocking-coordination-signals.test.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Blocking Coordination Signals - Unit Tests
+ *
+ * Sprint 1.1: Signal ACK Protocol - Signal Delivery Tests
+ *
+ * Tests verify:
+ * 1. Redis SETEX atomic signal delivery with 24h TTL
+ * 2. Idempotent signal handling (duplicate detection)
+ * 3. Signal persistence and retrieval
+ * 4. Error handling and edge cases
+ *
+ * @module cfn-loop/__tests__/blocking-coordination-signals.test
+ */
+export {};

package/.claude-flow-novice/dist/cfn-loop/__tests__/byzantine-consensus-adapter.test.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Byzantine Consensus Adapter Unit Tests
+ *
+ * Comprehensive test suite for Byzantine consensus integration in CFN Loop 2
+ * Tests PBFT consensus, malicious agent detection, and fault tolerance
+ *
+ * Coverage Requirements:
+ * - 100% code coverage for ByzantineConsensusAdapter
+ * - All PBFT phases (prepare, commit, reply)
+ * - Malicious agent detection scenarios
+ * - Signature verification
+ * - Error handling and edge cases
+ */
+export {};

package/.claude-flow-novice/dist/cfn-loop/__tests__/byzantine-performance.test.d.ts

@@ -0,0 +1,17 @@
+/**
+ * @jest-environment node
+ */
+/**
+ * Byzantine Consensus Performance Benchmarks
+ *
+ * Performance testing for Byzantine consensus vs simple consensus
+ * Measures latency, throughput, and scalability characteristics
+ *
+ * Benchmarks:
+ * 1. Byzantine vs Simple consensus latency
+ * 2. Validator count scalability (4 vs 7 validators)
+ * 3. Malicious detection accuracy (precision/recall)
+ * 4. Concurrent consensus execution
+ * 5. Memory usage patterns
+ */
+export {};

package/.claude-flow-novice/dist/cfn-loop/__tests__/cfn-loop-byzantine-integration.test.d.ts

@@ -0,0 +1,15 @@
+/**
+ * CFN Loop Byzantine Consensus Integration Tests
+ *
+ * Tests the integration of Byzantine consensus in CFN Loop 2 validation
+ * Validates end-to-end flow: Loop 3 → Byzantine Loop 2 → Results
+ *
+ * Test Scenarios:
+ * 1. Happy path: All validators agree, consensus ≥0.90
+ * 2. Single malicious validator: 3/4 agreement, still pass
+ * 3. Multiple malicious validators: 2/4 agreement, fail and retry
+ * 4. Byzantine disabled: Falls back to simple consensus
+ * 5. Byzantine timeout: Graceful fallback
+ * 6. Malicious agent persistence across iterations
+ */
+export {};

package/.claude-flow-novice/dist/cfn-loop/__tests__/cfn-loop-e2e.test.d.ts

@@ -0,0 +1,15 @@
+/**
+ * CFN Loop End-to-End Tests
+ *
+ * Complete end-to-end testing of CFN Loop workflow:
+ * Loop 3 (implementation) → Gate → Loop 2 (Byzantine consensus) → Decision
+ *
+ * Test Scenarios:
+ * 1. Complete successful CFN Loop execution
+ * 2. Multiple Loop 2 iterations with feedback injection
+ * 3. Malicious agent persistence across iterations
+ * 4. Memory recovery and state management
+ * 5. Performance testing
+ * 6. Error handling and resilience
+ */
+export {};

package/.claude-flow-novice/dist/cfn-loop/__tests__/cfn-loop-memory-manager.test.d.ts

@@ -0,0 +1,9 @@
+/**
+ * CFN Loop Memory Manager Unit Tests
+ * Sprint 1.5: Testing & Validation
+ *
+ * Tests dual-write pattern, ACL enforcement, and Loop 3/2/4 integration.
+ *
+ * @module cfn-loop/__tests__/cfn-loop-memory-manager.test
+ */
+export {};

package/.claude-flow-novice/dist/cfn-loop/__tests__/cleanup-integration.test.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Cleanup Script Integration Tests - Sprint 3.2 Loop 3 Iteration 2/10
+ *
+ * REC-001: Verify cleanup-blocking-coordination.sh doesn't affect active coordinators
+ *
+ * Test Coverage:
+ * 1. Stale coordinator cleanup success (>10 min old)
+ * 2. Active coordinator preservation (<5 min old)
+ * 3. Mixed scenario (5 stale + 3 active coordinators)
+ * 4. Redis SCAN performance (10k+ coordinator heartbeats)
+ * 5. Error handling (Redis connection failure)
+ *
+ * Acceptance Criteria:
+ * - All 5 test scenarios implemented ≥0.85
+ * - Tests pass 100% ≥0.90
+ * - Error handling comprehensive ≥0.80
+ * - Minimum coverage: 80% of cleanup script logic
+ *
+ * @module cfn-loop/__tests__/cleanup-integration
+ */
+export {};

package/.claude-flow-novice/dist/cfn-loop/__tests__/cleanup-performance-validation.test.d.ts

@@ -0,0 +1,13 @@
+/**
+ * cleanup-performance-validation.test.ts
+ *
+ * Sprint 1.4: Empirical validation of cleanup script performance
+ * Target: <5s for 10,000 stale coordinator keys
+ *
+ * Test Scenario:
+ * 1. Populate Redis with 10,000 stale coordinator keys (>10 min old)
+ * 2. Add 10 active coordinator keys (should be preserved)
+ * 3. Execute cleanup script and measure time
+ * 4. Verify all stale keys removed and active keys preserved
+ */
+export {};

package/.claude-flow-novice/dist/cfn-loop/__tests__/coordinator-timeout-handler.test.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Coordinator Timeout Handler Tests - Sprint 1.4
+ *
+ * Test Coverage:
+ * 1. Timeout detection based on threshold
+ * 2. State cleanup on timeout (heartbeat, ACKs, signals, idempotency)
+ * 3. Event emission (coordinator:timeout)
+ * 4. Metrics tracking (timeout_events_total)
+ * 5. Integration with HeartbeatWarningSystem cleanup
+ * 6. Activity tracking and monitoring
+ *
+ * @module cfn-loop/__tests__/coordinator-timeout-handler.test
+ */
+export {};

package/.claude-flow-novice/dist/cfn-loop/__tests__/dead-coordinator-detection.test.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Dead Coordinator Detection Test Suite
+ *
+ * Sprint 1.2: Validates dead coordinator detection within 2 minutes
+ *
+ * Test Coverage:
+ * 1. Heartbeat Freshness - Verify warnings trigger at >120s
+ * 2. Escalation - Verify 3 warnings → DEAD status
+ * 3. Orphan Cleanup - Verify state/ACKs/signals removed
+ * 4. False Positives - Verify fresh heartbeats don't trigger warnings
+ * 5. Recovery - Verify coordinator can restart after being marked dead
+ *
+ * @module cfn-loop/__tests__/dead-coordinator-detection
+ */
+export {};

package/.claude-flow-novice/dist/cfn-loop/__tests__/doc-code-examples-validator.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Documentation Code Examples Validator
+ * Sprint 4.1 - Validates code examples from technical documentation
+ */
+interface ValidationResult {
+    file: string;
+    example: number;
+    lineStart: number;
+    lineEnd: number;
+    language: string;
+    syntaxValid: boolean;
+    executable: boolean;
+    issues: string[];
+    warnings: string[];
+}
+/**
+ * Main validation function
+ */
+export declare function validateDocumentationExamples(docFiles: string[]): {
+    results: ValidationResult[];
+    summary: {
+        totalExamples: number;
+        executableExamples: number;
+        pseudoCodeExamples: number;
+        syntaxValid: number;
+        syntaxInvalid: number;
+        totalIssues: number;
+        totalWarnings: number;
+    };
+};
+/**
+ * Format validation results as JSON report
+ */
+export declare function formatReport(results: ValidationResult[], summary: any): string;
+export {};

package/.claude-flow-novice/dist/cfn-loop/__tests__/doc-executable-examples.test.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Test Executable Code Examples from Documentation
+ * Sprint 4.1 - Validates that critical executable examples work correctly
+ *
+ * This test suite validates code examples from:
+ * - docs/patterns/blocking-coordination-pattern.md
+ * - docs/integration/cfn-loop-examples.md
+ * - docs/api/blocking-coordination-api.md
+ */
+export {};

package/.claude-flow-novice/dist/cfn-loop/__tests__/extended-timeout-testing.test.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Extended Timeout Testing - Sprint 1.4
+ *
+ * Configurable timeout tests for blocking coordination system.
+ * Validates timeout behavior at multiple intervals from 3-minute baseline to production 30-minute.
+ *
+ * Epic: production-blocking-coordination
+ * Sprint: 1.4 - Extended Timeout Testing
+ *
+ * Test Coverage Requirements:
+ * - 3-minute baseline with signal at 2:30 (coordinator unblocks)
+ * - 5-minute timeout without signal (coordinator times out)
+ * - Timeout trigger validation at configured time
+ * - State cleanup after timeout
+ * - Production 30-minute timeout verification (optional long test)
+ *
+ * Test Categories:
+ * 1. Baseline Tests (3 minutes) - Fast validation
+ * 2. Extended Tests (5 minutes) - Timeout trigger validation
+ * 3. Production Tests (30 minutes) - Optional slow tests
+ *
+ * @module cfn-loop/__tests__/extended-timeout-testing
+ */
+export {};

package/.claude-flow-novice/dist/cfn-loop/__tests__/heartbeat-warning-system.test.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Heartbeat Warning System Test Suite - Sprint 1.2
+ *
+ * Tests dead coordinator detection via heartbeat monitoring.
+ * Validates warning escalation, cleanup, and critical exit paths.
+ *
+ * Epic: production-blocking-coordination
+ * Sprint: 1.2 - Dead Coordinator Detection
+ * Target: Detection within 2 minutes (120 seconds)
+ *
+ * Test Coverage Requirements:
+ * - Heartbeat registration and retrieval
+ * - Stale heartbeat detection (>120s)
+ * - Warning escalation (3 consecutive warnings)
+ * - Dead coordinator marking and cleanup
+ * - Heartbeat continuity validation
+ * - Orphan state cleanup
+ *
+ * @module cfn-loop/__tests__/heartbeat-warning-system
+ */
+export {};

package/.claude-flow-novice/dist/cfn-loop/__tests__/redis-health-monitor.test.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Redis Health Monitor Test Suite - Sprint 1.3
+ *
+ * Tests Redis health check detection and auto-reconnection capabilities.
+ * Validates health monitoring, reconnection attempts, and graceful degradation.
+ *
+ * Epic: production-blocking-coordination
+ * Sprint: 1.3 - Redis Health Check
+ * Target: Detection within 5s, Reconnection within 30s
+ *
+ * Test Coverage Requirements:
+ * - Health check detection (PING succeeds/fails within 5s timeout)
+ * - Connection recovery (PING succeeds after reconnection)
+ * - Auto-reconnect with exponential backoff (1s, 2s, 4s delays)
+ * - Max reconnect attempts (3 attempts, emit redis:failed)
+ * - Event emission (connected, disconnected, reconnecting, reconnected)
+ * - Graceful degradation (operations fail safely without crash)
+ * - Metrics tracking during disconnection
+ *
+ * @module cfn-loop/__tests__/redis-health-monitor
+ */
+export {};

package/.claude-flow-novice/dist/cfn-loop/__tests__/signal-ack-protocol.test.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Signal ACK Protocol Test Suite - Sprint 1.1
+ *
+ * Tests the Signal ACK protocol implementation for blocking coordination
+ * in CFN Loop workflows. Validates signal delivery, acknowledgment receipt,
+ * idempotency, persistence, and full signal → ACK → unblock flow.
+ *
+ * Epic: production-blocking-coordination
+ * Sprint: 1.1 - Signal ACK Protocol
+ * Target: Signal delivery success rate ≥99.99%
+ *
+ * Test Coverage Requirements:
+ * - Unit tests for signal delivery mechanism
+ * - ACK verification and timeout handling
+ * - Idempotency tests for duplicate signals
+ * - Integration test for complete signal flow
+ * - Signal persistence and TTL validation
+ *
+ * @module cfn-loop/__tests__/signal-ack-protocol
+ */
+export {};

package/.claude-flow-novice/dist/cfn-loop/__tests__/sqlite-memory-manager.test.d.ts

@@ -0,0 +1,19 @@
+/**
+ * SQLite Memory Manager Unit Tests - Sprint 1.7
+ *
+ * Test Coverage:
+ * 1. Dual-write pattern (Redis + SQLite simultaneous writes)
+ * 2. ACL enforcement (5 levels: private, agent, swarm, project, system)
+ * 3. Encryption (AES-256-GCM for levels 1, 2, 5)
+ * 4. TTL expiration handling
+ * 5. Fallback behavior on Redis failure
+ * 6. Query performance and indexing
+ * 7. Transaction safety and rollback
+ * 8. Concurrent write handling
+ *
+ * Epic: SQLite Integration Migration
+ * Sprint: 1.7 - Testing & Validation
+ *
+ * @module cfn-loop/__tests__/sqlite-memory-manager.test
+ */
+export {};