review(http): mark http/review-mcp completed + fix formatting across crate

Review-mcp verification complete: all 12 checklist items pass (from_mcp/to_mcp
conformance, ADR-037/041/014/023/034, feature gate isolation, GatewayDispatch
concrete struct, test coverage 223+5). Applied cargo fmt across crate.

crates/alknet-http/src/client/http_client.rs

@@ -125,10 +125,11 @@ fn build_client(config: &HttpClientConfig) -> Result<ClientWithMiddleware, HttpC
         builder = builder.timeout(timeout);
     }
     if let Some(ca_bundle_path) = &config.ca_bundle {
-        let pem = std::fs::read(ca_bundle_path).map_err(|source| HttpClientBuildError::CaBundleRead {
-            path: ca_bundle_path.clone(),
-            source,
-        })?;
+        let pem =
+            std::fs::read(ca_bundle_path).map_err(|source| HttpClientBuildError::CaBundleRead {
+                path: ca_bundle_path.clone(),
+                source,
+            })?;
         let certs = reqwest::Certificate::from_pem_bundle(&pem).map_err(|source| {
             HttpClientBuildError::CaBundleParse {
                 path: ca_bundle_path.clone(),
@@ -152,19 +153,21 @@ fn build_client(config: &HttpClientConfig) -> Result<ClientWithMiddleware, HttpC
                 source,
             }
         })?;
-        let identity = reqwest::Identity::from_pem(
-            concat_pem(&cert_pem, &key_pem).as_slice(),
-        )
-        .map_err(|source| HttpClientBuildError::ClientCertParse {
-            path: client_cert_cfg.cert_pem.clone(),
-            source,
-        })?;
+        let identity = reqwest::Identity::from_pem(concat_pem(&cert_pem, &key_pem).as_slice())
+            .map_err(|source| HttpClientBuildError::ClientCertParse {
+                path: client_cert_cfg.cert_pem.clone(),
+                source,
+            })?;
         builder = builder.identity(identity);
     }
     let reqwest_client = builder.build().map_err(HttpClientBuildError::Build)?;
     let client = reqwest_middleware::ClientBuilder::new(reqwest_client)
-        .with(RetryTransientMiddleware::new_with_policy(config.retry_policy))
-        .with(RetryAfterMiddleware::with_capacity(DEFAULT_RETRY_AFTER_CAPACITY))
+        .with(RetryTransientMiddleware::new_with_policy(
+            config.retry_policy,
+        ))
+        .with(RetryAfterMiddleware::with_capacity(
+            DEFAULT_RETRY_AFTER_CAPACITY,
+        ))
         .build();
     Ok(client)
 }
@@ -203,10 +206,7 @@ mod tests {
             .build()
             .expect("RequestBuilder builds");
         assert_eq!(request.method(), reqwest::Method::GET);
-        assert_eq!(
-            request.url().as_str(),
-            "https://api.example.com/v1/chat"
-        );
+        assert_eq!(request.url().as_str(), "https://api.example.com/v1/chat");
     }
 
     #[test]
@@ -326,4 +326,4 @@ mod tests {
         let config = HttpClientConfig::default();
         assert!(config.ca_bundle.is_none());
     }
-}
+}

crates/alknet-http/src/client/mod.rs

@@ -7,4 +7,4 @@ mod http_client;
 mod retry_after;
 
 pub use http_client::{ClientCertConfig, HttpClientBuildError, HttpClientConfig, SharedHttpClient};
-pub use retry_after::RetryAfterMiddleware;
+pub use retry_after::RetryAfterMiddleware;

crates/alknet-http/src/client/retry_after.rs

@@ -99,7 +99,10 @@ impl RetryAfterMiddleware {
 
     #[cfg(test)]
     fn len(&self) -> usize {
-        self.deadlines.lock().expect("deadlines mutex poisoned").len()
+        self.deadlines
+            .lock()
+            .expect("deadlines mutex poisoned")
+            .len()
     }
 
     #[cfg(test)]
@@ -156,8 +159,8 @@ mod tests {
 
     #[test]
     fn parse_retry_after_http_date() {
-        let deadline = parse_retry_after("Wed, 21 Oct 2099 07:28:00 GMT")
-            .expect("HTTP-date value parses");
+        let deadline =
+            parse_retry_after("Wed, 21 Oct 2099 07:28:00 GMT").expect("HTTP-date value parses");
         assert!(deadline > SystemTime::now());
     }
 
@@ -272,7 +275,10 @@ mod tests {
     async fn middleware_sleeps_before_request_with_active_deadline() {
         let mw = std::sync::Arc::new(RetryAfterMiddleware::with_capacity(8));
         let target = url("https://api.example.com/v1/chat");
-        mw.record_test(target.clone(), SystemTime::now() + Duration::from_millis(50));
+        mw.record_test(
+            target.clone(),
+            SystemTime::now() + Duration::from_millis(50),
+        );
         let started = SystemTime::now();
         mw.maybe_sleep_for(&target).await;
         let elapsed = SystemTime::now().duration_since(started).unwrap();
@@ -281,4 +287,4 @@ mod tests {
             "middleware must sleep until the deadline elapses"
         );
     }
-}
+}