docs(proxy): fix stale API references in README and mdBook

- with_round_robin(Default::default()) → with_round_robin(storage, config)
  (constructor takes two args: Arc<dyn ProxyStoragePort> + ProxyConfig)
- start_health_checker(token) → let (cancel, _task) = manager.start()
  (start() returns the CancellationToken rather than accepting one)
- ProxyManager::with_strategy(...) → builder pattern
  (no with_strategy method; use builder().storage().strategy().config().build())
- RotationStrategy impl: fn select → async fn select, Option → ProxyResult
- Remove stale tokio_util::sync::CancellationToken imports from book examples
- Add missing Arc/MemoryProxyStore imports to README code blocks

Author: greysquirr3l

Cargo.lock

@@ -17,7 +17,6 @@ slow or timing-out proxy does not delay checks for healthy ones.
 
 ```rust,no_run
 use std::sync::Arc;
-use tokio_util::sync::CancellationToken;
 use stygian_proxy::{MemoryProxyStore, ProxyConfig, ProxyManager};
 
 let storage = Arc::new(MemoryProxyStore::default());
@@ -31,11 +30,10 @@ let manager = Arc::new(
     ProxyManager::with_round_robin(storage, config)?
 );
 
-let token = CancellationToken::new();
-manager.start_health_checker(token.clone());
+let (cancel, _task) = manager.start();
 
 // When shutting down:
-token.cancel();
+cancel.cancel();
 ```
 
 ### On-demand check

book/src/proxy/health-circuit-breaker.md

@@ -35,7 +35,6 @@ Build a pool and make a request:
 
 ```rust,no_run
 use std::sync::Arc;
-use tokio_util::sync::CancellationToken;
 use stygian_proxy::{MemoryProxyStore, ProxyConfig, ProxyManager};
 use stygian_proxy::types::{Proxy, ProxyType};
 
@@ -57,8 +56,7 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
     }).await?;
 
     // Start background health checks
-    let token = CancellationToken::new();
-    manager.start_health_checker(token.clone());
+    let (cancel, _task) = manager.start();
 
     // Acquire a proxy for a request
     let handle = manager.acquire_proxy().await?;
@@ -67,7 +65,7 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
     // Signal success — omitting this counts as a failure toward the circuit breaker
     handle.mark_success();
 
-    token.cancel(); // stop health checker
+    cancel.cancel(); // stop health checker
     Ok(())
 }
 ```

book/src/proxy/overview.md

@@ -47,11 +47,12 @@ use stygian_proxy::{MemoryProxyStore, ProxyConfig, ProxyManager};
 use stygian_proxy::strategy::RandomStrategy;
 
 let storage = Arc::new(MemoryProxyStore::default());
-let manager = ProxyManager::with_strategy(
-    storage,
-    ProxyConfig::default(),
-    Arc::new(RandomStrategy),
-).unwrap();
+let manager = ProxyManager::builder()
+    .storage(storage)
+    .strategy(Arc::new(RandomStrategy))
+    .config(ProxyConfig::default())
+    .build()
+    .unwrap();
 ```
 
 ---
@@ -88,11 +89,12 @@ use stygian_proxy::{MemoryProxyStore, ProxyConfig, ProxyManager};
 use stygian_proxy::strategy::LeastUsedStrategy;
 
 let storage = Arc::new(MemoryProxyStore::default());
-let manager = ProxyManager::with_strategy(
-    storage,
-    ProxyConfig::default(),
-    Arc::new(LeastUsedStrategy),
-).unwrap();
+let manager = ProxyManager::builder()
+    .storage(storage)
+    .strategy(Arc::new(LeastUsedStrategy))
+    .config(ProxyConfig::default())
+    .build()
+    .unwrap();
 ```
 
 ---
@@ -128,7 +130,7 @@ impl RotationStrategy for BestSuccessRateStrategy {
 }
 ```
 
-Pass it to `ProxyManager::with_strategy(storage, config, Arc::new(BestSuccessRateStrategy))`.
+Pass it to `ProxyManager::builder().storage(storage).strategy(Arc::new(BestSuccessRateStrategy)).config(config).build().unwrap()`.
 
 ---
 

book/src/proxy/strategies.md

@@ -48,13 +48,14 @@ stygian-proxy = { version = "0.1", features = ["browser"] }
 ## Quick Start
 
 ```rust,no_run
-use stygian_proxy::{ProxyManager, Proxy, types::ProxyType};
+use stygian_proxy::{ProxyManager, MemoryProxyStore, Proxy, types::{ProxyType, ProxyConfig}};
+use std::sync::Arc;
 use std::time::Duration;
 
 #[tokio::main]
 async fn main() -> Result<(), Box<dyn std::error::Error>> {
     // Build a pool with round-robin rotation
-    let manager = ProxyManager::with_round_robin(Default::default())?;
+    let manager = ProxyManager::with_round_robin(Arc::new(MemoryProxyStore::default()), ProxyConfig::default())?;
 
     // Add proxies
     manager.add_proxy(Proxy {
@@ -105,17 +106,20 @@ Custom strategies implement `RotationStrategy`:
 
 ```rust,no_run
 use stygian_proxy::strategy::{RotationStrategy, ProxyCandidate};
+use stygian_proxy::error::ProxyResult;
+use async_trait::async_trait;
 
 #[derive(Debug)]
 struct MyStrategy;
 
+#[async_trait]
 impl RotationStrategy for MyStrategy {
-    fn select<'a>(&self, candidates: &'a [ProxyCandidate]) -> Option<&'a ProxyCandidate> {
+    async fn select<'a>(&self, candidates: &'a [ProxyCandidate]) -> ProxyResult<&'a ProxyCandidate> {
         // pick the candidate with the best success rate
         candidates.iter().max_by(|a, b| {
             a.metrics.success_rate().partial_cmp(&b.metrics.success_rate())
                 .unwrap_or(std::cmp::Ordering::Equal)
-        })
+        }).ok_or(stygian_proxy::error::ProxyError::AllProxiesUnhealthy)
     }
 }
 ```
@@ -127,7 +131,8 @@ impl RotationStrategy for MyStrategy {
 Each proxy has its own `CircuitBreaker`. After `circuit_open_threshold` consecutive failures the breaker opens, and the proxy is excluded from rotation for `circuit_half_open_after`. After that window the proxy is tried once in HalfOpen state — a success closes it; another failure reopens it.
 
 ```rust,no_run
-use stygian_proxy::{ProxyManager, types::ProxyConfig};
+use stygian_proxy::{ProxyManager, MemoryProxyStore, types::ProxyConfig};
+use std::sync::Arc;
 use std::time::Duration;
 
 let config = ProxyConfig {
@@ -138,7 +143,7 @@ let config = ProxyConfig {
     ..Default::default()
 };
 
-let manager = ProxyManager::with_round_robin(config)?;
+let manager = ProxyManager::with_round_robin(Arc::new(MemoryProxyStore::default()), config)?;
 ```
 
 If a `ProxyHandle` is dropped without calling `mark_success()`, the circuit breaker records a failure automatically.
@@ -150,7 +155,8 @@ If a `ProxyHandle` is dropped without calling `mark_success()`, the circuit brea
 `ProxyManager::start()` spawns a background task that probes each proxy on a configurable interval and updates per-proxy health scores:
 
 ```rust,no_run
-use stygian_proxy::{ProxyManager, types::ProxyConfig};
+use stygian_proxy::{ProxyManager, MemoryProxyStore, types::ProxyConfig};
+use std::sync::Arc;
 use std::time::Duration;
 
 let config = ProxyConfig {
@@ -159,7 +165,7 @@ let config = ProxyConfig {
     ..Default::default()
 };
 
-let manager = ProxyManager::with_round_robin(config)?;
+let manager = ProxyManager::with_round_robin(Arc::new(MemoryProxyStore::default()), config)?;
 let (cancel_token, health_task) = manager.start();
 
 // Graceful shutdown
@@ -178,9 +184,11 @@ stygian-graph = "0.1"
 ```
 
 ```rust,no_run
-use stygian_proxy::{ProxyManager, graph::ProxyManagerPort};
+use stygian_proxy::{ProxyManager, MemoryProxyStore, graph::ProxyManagerPort};
+use stygian_proxy::types::ProxyConfig;
+use std::sync::Arc;
 
-let manager = ProxyManager::with_round_robin(Default::default())?;
+let manager = ProxyManager::with_round_robin(Arc::new(MemoryProxyStore::default()), ProxyConfig::default())?;
 // Pass as Arc<dyn ProxyManagerPort> to RestApiAdapter or HttpAdapter
 ```
 
@@ -196,10 +204,12 @@ stygian-browser = "0.1"
 ```
 
 ```rust,no_run
-use stygian_proxy::{ProxyManager, browser::ProxyManagerBridge};
+use stygian_proxy::{ProxyManager, MemoryProxyStore, browser::ProxyManagerBridge};
+use stygian_proxy::types::ProxyConfig;
 use stygian_browser::BrowserConfig;
+use std::sync::Arc;
 
-let manager = std::sync::Arc::new(ProxyManager::with_round_robin(Default::default())?);
+let manager = Arc::new(ProxyManager::with_round_robin(Arc::new(MemoryProxyStore::default()), ProxyConfig::default())?);
 let bridge = ProxyManagerBridge::new(manager);
 // bridge.next_proxy_url().await? → inject into BrowserConfig::proxy
 ```

crates/stygian-proxy/README.md

@@ -282,10 +282,7 @@ impl ProxyManager {
         // add_proxy() holds the circuit_breakers write lock for the full duration
         // of its storage write, so every proxy visible in candidates is guaranteed
         // to have a CB entry by the time we reach here.
-        let cb = cb_map
-            .get(&id)
-            .cloned()
-            .ok_or(ProxyError::PoolExhausted)?;
+        let cb = cb_map.get(&id).cloned().ok_or(ProxyError::PoolExhausted)?;
 
         let url = with_metrics
             .iter()