Implement advanced CPS randomization for human-like timing patterns

- Create comprehensive CPSRandomizer with statistical distributions (normal, uniform, exponential, triangular)
- Add configurable variance, humanness levels, and anti-detection pattern breakup
- Integrate randomization with AutomationConfiguration and ClickCoordinator
- Implement dynamic interval scheduling using one-shot timers for randomized timing
- Add RandomizationSettings UI with live preview and distribution selection
- Extend ClickSettings with timing randomization properties and persistence
- Include comprehensive test suite with statistical validation and performance tests
- Complete Task 6 of Phase 1 MVP completion spec

🤖 Generated with [Claude Code](https://claude.ai/code)

Co-Authored-By: Claude <[email protected]>

Author: jsonify

.agent-os/specs/2025-07-22-phase1-completion/tasks.md

@@ -55,12 +55,12 @@ These are the tasks to be completed for the spec detailed in @.agent-os/specs/20
   - [x] 5.7 Create performance dashboard for user visibility into timing accuracy
   - [x] 5.8 Verify all performance targets met and benchmarks pass consistently
 
-- [ ] 6. **Implement Advanced CPS Randomization**
-  - [ ] 6.1 Write tests for CPSRandomizer and timing pattern generation
-  - [ ] 6.2 Create CPSRandomizer with configurable variance and distribution patterns
-  - [ ] 6.3 Add UI controls for randomization settings and pattern selection
-  - [ ] 6.4 Implement statistical distributions (normal, uniform) for natural timing variation
-  - [ ] 6.5 Integrate randomization with AutomationConfiguration and clicking loops
-  - [ ] 6.6 Add validation to ensure randomization doesn't break timing requirements
-  - [ ] 6.7 Implement anti-detection patterns to avoid automation signature detection
-  - [ ] 6.8 Verify all tests pass and randomization produces human-like patterns
+- [x] 6. **Implement Advanced CPS Randomization**
+  - [x] 6.1 Write tests for CPSRandomizer and timing pattern generation
+  - [x] 6.2 Create CPSRandomizer with configurable variance and distribution patterns
+  - [x] 6.3 Add UI controls for randomization settings and pattern selection
+  - [x] 6.4 Implement statistical distributions (normal, uniform) for natural timing variation
+  - [x] 6.5 Integrate randomization with AutomationConfiguration and clicking loops
+  - [x] 6.6 Add validation to ensure randomization doesn't break timing requirements
+  - [x] 6.7 Implement anti-detection patterns to avoid automation signature detection
+  - [x] 6.8 Verify all tests pass and randomization produces human-like patterns

Sources/ClickIt/Core/Click/ClickCoordinator.swift

@@ -42,6 +42,9 @@ class ClickCoordinator: ObservableObject {
     /// High-precision timer for optimized automation timing
     private var automationTimer: HighPrecisionTimer?
 
+    /// CPS randomizer for human-like timing patterns
+    private var cpsRandomizer: CPSRandomizer?
+    
     /// Performance monitor for resource optimization
     private let performanceMonitor = PerformanceMonitor.shared
 
@@ -302,17 +305,30 @@ class ClickCoordinator: ObservableObject {
             return
         }
 
-        // Create high-precision timer for automation
-        automationTimer = HighPrecisionTimer()
+        // Initialize CPS randomizer with configuration
+        cpsRandomizer = CPSRandomizer(configuration: configuration.cpsRandomizerConfig)
 
-        // Start timer-based automation loop
-        automationTimer?.startRepeatingTimer(interval: configuration.clickInterval) { [weak self] in
+        // Start first automation step
+        scheduleNextAutomationStep(configuration: configuration)
+        
+        print("ClickCoordinator: Started optimized automation loop with \(configuration.clickInterval * 1000)ms base interval, randomization: \(configuration.cpsRandomizerConfig.enabled)")
+    }
+    
+    /// Schedules the next automation step with randomized timing
+    /// - Parameter configuration: Automation configuration
+    private func scheduleNextAutomationStep(configuration: AutomationConfiguration) {
+        guard isActive else { return }
+        
+        // Calculate next interval with randomization
+        let nextInterval = cpsRandomizer?.randomizeInterval(configuration.clickInterval) ?? configuration.clickInterval
+        
+        // Create new one-shot timer for next step (required for dynamic intervals)
+        automationTimer = HighPrecisionTimer()
+        automationTimer?.startOneShotTimer(delay: nextInterval) { [weak self] in
             Task { @MainActor in
                 await self?.performOptimizedAutomationStep(configuration: configuration)
             }
         }
-        
-        print("ClickCoordinator: Started optimized automation loop with \(configuration.clickInterval * 1000)ms interval")
     }
 
     /// Performs a single optimized automation step with minimal overhead
@@ -344,7 +360,11 @@ class ClickCoordinator: ObservableObject {
         // Handle failed click with minimal processing
         if !result.success && configuration.stopOnError {
             stopAutomation()
+            return
         }
+        
+        // Schedule next automation step with randomized timing
+        scheduleNextAutomationStep(configuration: configuration)
     }
 
     /// Executes a single automation step with error recovery
@@ -602,6 +622,7 @@ struct AutomationConfiguration {
     let randomizeLocation: Bool
     let locationVariance: CGFloat
     let useDynamicMouseTracking: Bool
+    let cpsRandomizerConfig: CPSRandomizer.Configuration
 
     init(
         location: CGPoint,
@@ -613,7 +634,8 @@ struct AutomationConfiguration {
         stopOnError: Bool = false,
         randomizeLocation: Bool = false,
         locationVariance: CGFloat = 0,
-        useDynamicMouseTracking: Bool = false
+        useDynamicMouseTracking: Bool = false,
+        cpsRandomizerConfig: CPSRandomizer.Configuration = CPSRandomizer.Configuration()
     ) {
         self.location = location
         self.clickType = clickType
@@ -625,6 +647,7 @@ struct AutomationConfiguration {
         self.randomizeLocation = randomizeLocation
         self.locationVariance = locationVariance
         self.useDynamicMouseTracking = useDynamicMouseTracking
+        self.cpsRandomizerConfig = cpsRandomizerConfig
     }
 }
 

Sources/ClickIt/Core/Models/ClickSettings.swift

@@ -105,6 +105,38 @@ class ClickSettings: ObservableObject {
             saveSettings()
         }
     }
+    
+    // MARK: - CPS Randomization Properties
+    
+    /// Whether to enable CPS timing randomization
+    @Published var randomizeTiming: Bool = false {
+        didSet {
+            saveSettings()
+        }
+    }
+    
+    /// Timing variance as percentage (0.0-1.0, representing 0%-100%)
+    @Published var timingVariancePercentage: Double = 0.1 {
+        didSet {
+            // Clamp between 0-100%
+            timingVariancePercentage = max(0.0, min(1.0, timingVariancePercentage))
+            saveSettings()
+        }
+    }
+    
+    /// Statistical distribution pattern for randomization
+    @Published var distributionPattern: CPSRandomizer.DistributionPattern = .normal {
+        didSet {
+            saveSettings()
+        }
+    }
+    
+    /// Anti-detection humanness level
+    @Published var humannessLevel: CPSRandomizer.HumannessLevel = .medium {
+        didSet {
+            saveSettings()
+        }
+    }
 
     // MARK: - Computed Properties
 
@@ -156,7 +188,11 @@ class ClickSettings: ObservableObject {
             locationVariance: locationVariance,
             stopOnError: stopOnError,
             showVisualFeedback: showVisualFeedback,
-            playSoundFeedback: playSoundFeedback
+            playSoundFeedback: playSoundFeedback,
+            randomizeTiming: randomizeTiming,
+            timingVariancePercentage: timingVariancePercentage,
+            distributionPattern: distributionPattern,
+            humannessLevel: humannessLevel
         )
 
         do {
@@ -188,6 +224,10 @@ class ClickSettings: ObservableObject {
             stopOnError = settings.stopOnError
             showVisualFeedback = settings.showVisualFeedback
             playSoundFeedback = settings.playSoundFeedback
+            randomizeTiming = settings.randomizeTiming
+            timingVariancePercentage = settings.timingVariancePercentage
+            distributionPattern = settings.distributionPattern
+            humannessLevel = settings.humannessLevel
         } catch {
             print("ClickSettings: Failed to load settings - \(error.localizedDescription). Using defaults.")
         }
@@ -207,8 +247,24 @@ class ClickSettings: ObservableObject {
         stopOnError = false
         showVisualFeedback = true
         playSoundFeedback = false
+        randomizeTiming = false
+        timingVariancePercentage = 0.1
+        distributionPattern = .normal
+        humannessLevel = .medium
         saveSettings()
     }
+    
+    /// Create CPS randomizer configuration from current settings
+    func createCPSRandomizerConfiguration() -> CPSRandomizer.Configuration {
+        return CPSRandomizer.Configuration(
+            enabled: randomizeTiming,
+            variancePercentage: timingVariancePercentage,
+            distributionPattern: distributionPattern,
+            humannessLevel: humannessLevel,
+            minimumInterval: AppConstants.minClickInterval,
+            maximumInterval: 10.0 // 10 second maximum
+        )
+    }
 
     /// Create automation configuration from current settings
     func createAutomationConfiguration() -> AutomationConfiguration {
@@ -226,7 +282,8 @@ class ClickSettings: ObservableObject {
             maxDuration: maxDurationValue,
             stopOnError: stopOnError,
             randomizeLocation: randomizeLocation,
-            locationVariance: CGFloat(locationVariance)
+            locationVariance: CGFloat(locationVariance),
+            cpsRandomizerConfig: createCPSRandomizerConfiguration()
         )
     }
 }
@@ -276,6 +333,10 @@ private struct SettingsData: Codable {
     let stopOnError: Bool
     let showVisualFeedback: Bool
     let playSoundFeedback: Bool
+    let randomizeTiming: Bool
+    let timingVariancePercentage: Double
+    let distributionPattern: CPSRandomizer.DistributionPattern
+    let humannessLevel: CPSRandomizer.HumannessLevel
 }
 
 // MARK: - Extensions