fix(wharf): sweep .expect("TODO: handle error") — 91 sites cleared

Policy breakdown:
- 3 production JSON handlers (yacht-agent): expect with invariant messages
- 4 byte-slice operations (crypto): expect with invariant (fixed-size slices)
- 2 path operations (xtask): converted to proper Result error handling
- 82 test functions across 7 crates: converted to .unwrap() convention

Tests: 49 passed; 0 failed

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

Author: hyperpolymath

bin/yacht-agent/src/main.rs

@@ -877,7 +877,7 @@ async fn mooring_init(
         status: yacht_status,
     };
 
-    Json(serde_json::to_value(response).expect("TODO: handle error"))
+    Json(serde_json::to_value(response).expect("invariant: MooringInitResponse must be JSON-serializable (in-memory struct)"))
 }
 
 /// Verify a layer against expected manifest
@@ -980,7 +980,7 @@ async fn mooring_verify(
         }
     };
 
-    Json(serde_json::to_value(response).expect("TODO: handle error"))
+    Json(serde_json::to_value(response).expect("invariant: VerifyResponse must be JSON-serializable (in-memory struct)"))
 }
 
 /// Commit transferred layers
@@ -1030,7 +1030,7 @@ async fn mooring_commit(
         error: None,
     };
 
-    Json(serde_json::to_value(response).expect("TODO: handle error"))
+    Json(serde_json::to_value(response).expect("invariant: CommitResponse must be JSON-serializable (in-memory struct)"))
 }
 
 // =============================================================================
@@ -1348,10 +1348,10 @@ mod tests {
         let listener = tokio::net::TcpListener::bind("127.0.0.1:0")
             .await
             .expect("Failed to bind test listener");
-        let addr = listener.local_addr().expect("TODO: handle error");
+        let addr = listener.local_addr().unwrap();
 
         tokio::spawn(async move {
-            axum::serve(listener, app).await.expect("TODO: handle error");
+            axum::serve(listener, app).await.unwrap();
         });
 
         // Give the server a moment to start
@@ -1416,11 +1416,11 @@ mod tests {
 
         let listener = tokio::net::TcpListener::bind("127.0.0.1:0")
             .await
-            .expect("TODO: handle error");
-        let addr = listener.local_addr().expect("TODO: handle error");
+            .unwrap();
+        let addr = listener.local_addr().unwrap();
 
         tokio::spawn(async move {
-            axum::serve(listener, app).await.expect("TODO: handle error");
+            axum::serve(listener, app).await.unwrap();
         });
 
         tokio::time::sleep(std::time::Duration::from_millis(50)).await;
@@ -1430,7 +1430,7 @@ mod tests {
             .expect("health request failed");
 
         assert!(resp.status().is_success());
-        assert_eq!(resp.text().await.expect("TODO: handle error"), "OK");
+        assert_eq!(resp.text().await.unwrap(), "OK");
     }
 
     /// Test that metrics endpoint returns real counters
@@ -1446,11 +1446,11 @@ mod tests {
 
         let listener = tokio::net::TcpListener::bind("127.0.0.1:0")
             .await
-            .expect("TODO: handle error");
-        let addr = listener.local_addr().expect("TODO: handle error");
+            .unwrap();
+        let addr = listener.local_addr().unwrap();
 
         tokio::spawn(async move {
-            axum::serve(listener, app).await.expect("TODO: handle error");
+            axum::serve(listener, app).await.unwrap();
         });
 
         tokio::time::sleep(std::time::Duration::from_millis(50)).await;
@@ -1459,7 +1459,7 @@ mod tests {
             .await
             .expect("metrics request failed");
 
-        let body = resp.text().await.expect("TODO: handle error");
+        let body = resp.text().await.unwrap();
         assert!(body.contains("yacht_queries_total{status=\"allowed\"} 42"));
         assert!(body.contains("yacht_queries_total{status=\"blocked\"} 3"));
     }
@@ -1478,11 +1478,11 @@ mod tests {
 
         let listener = tokio::net::TcpListener::bind("127.0.0.1:0")
             .await
-            .expect("TODO: handle error");
-        let addr = listener.local_addr().expect("TODO: handle error");
+            .unwrap();
+        let addr = listener.local_addr().unwrap();
 
         tokio::spawn(async move {
-            axum::serve(listener, app).await.expect("TODO: handle error");
+            axum::serve(listener, app).await.unwrap();
         });
 
         tokio::time::sleep(std::time::Duration::from_millis(50)).await;
@@ -1491,7 +1491,7 @@ mod tests {
             .await
             .expect("stats request failed");
 
-        let body: serde_json::Value = resp.json().await.expect("TODO: handle error");
+        let body: serde_json::Value = resp.json().await.unwrap();
         assert_eq!(body["queries"]["allowed"], 10);
         assert_eq!(body["queries"]["blocked"], 5);
         assert_eq!(body["queries"]["audited"], 2);

crates/wharf-core/src/config.rs

@@ -459,7 +459,7 @@ mod tests {
     #[test]
     fn test_config_serialization() {
         let config = YachtAgentConfig::default();
-        let toml_str = toml::to_string(&config).expect("TODO: handle error");
+        let toml_str = toml::to_string(&config).unwrap();
         assert!(toml_str.contains("[db_proxy]"));
         assert!(toml_str.contains("protocol"));
     }

crates/wharf-core/src/crypto.rs

@@ -231,7 +231,7 @@ pub fn deserialize_keypair_raw(data: &[u8]) -> Result<HybridKeypair, CryptoError
     }
 
     // Verify version
-    let version = u32::from_le_bytes(data[4..8].try_into().expect("TODO: handle error"));
+    let version = u32::from_le_bytes(data[4..8].try_into().expect("invariant: fixed slice [4..8] is exactly 4 bytes"));
     if version != KEYPAIR_VERSION {
         return Err(CryptoError::SerializationError(
             format!("Unsupported keypair version: {} (expected {})", version, KEYPAIR_VERSION),
@@ -256,7 +256,7 @@ pub fn deserialize_keypair_raw(data: &[u8]) -> Result<HybridKeypair, CryptoError
     if data.len() < offset + 4 {
         return Err(CryptoError::SerializationError("Truncated ML-DSA-87 secret key length".to_string()));
     }
-    let mldsa_sk_len = u32::from_le_bytes(data[offset..offset + 4].try_into().expect("TODO: handle error")) as usize;
+    let mldsa_sk_len = u32::from_le_bytes(data[offset..offset + 4].try_into().expect("invariant: fixed slice [offset..offset+4] is exactly 4 bytes")) as usize;
     offset += 4;
 
     if data.len() < offset + mldsa_sk_len {
@@ -269,7 +269,7 @@ pub fn deserialize_keypair_raw(data: &[u8]) -> Result<HybridKeypair, CryptoError
     if data.len() < offset + 4 {
         return Err(CryptoError::SerializationError("Truncated ML-DSA-87 public key length".to_string()));
     }
-    let mldsa_pk_len = u32::from_le_bytes(data[offset..offset + 4].try_into().expect("TODO: handle error")) as usize;
+    let mldsa_pk_len = u32::from_le_bytes(data[offset..offset + 4].try_into().expect("invariant: fixed slice [offset..offset+4] is exactly 4 bytes")) as usize;
     offset += 4;
 
     if data.len() < offset + mldsa_pk_len {
@@ -344,7 +344,7 @@ pub fn deserialize_keypair(data: &[u8], password: &[u8]) -> Result<HybridKeypair
     }
 
     // Verify version
-    let version = u32::from_le_bytes(data[4..8].try_into().expect("TODO: handle error"));
+    let version = u32::from_le_bytes(data[4..8].try_into().expect("invariant: fixed slice [4..8] is exactly 4 bytes"));
     if version != KEYPAIR_VERSION {
         return Err(CryptoError::SerializationError(
             format!("Unsupported keypair version: {}", version),
@@ -697,15 +697,15 @@ mod tests {
 
     #[test]
     fn test_hybrid_keypair_generation() {
-        let keypair = generate_hybrid_keypair().expect("TODO: handle error");
+        let keypair = generate_hybrid_keypair().unwrap();
         let pubkey = hybrid_public_key(&keypair);
         assert!(!pubkey.ed448.is_empty());
         assert!(!pubkey.mldsa87.is_empty());
     }
 
     #[test]
     fn test_hybrid_sign_verify() {
-        let keypair = generate_hybrid_keypair().expect("TODO: handle error");
+        let keypair = generate_hybrid_keypair().unwrap();
         let pubkey = hybrid_public_key(&keypair);
         let message = b"test message for hybrid signing";
 
@@ -714,12 +714,12 @@ mod tests {
         assert!(!sig.mldsa87_sig.is_empty());
 
         // Full hybrid verification should succeed
-        verify_hybrid(&pubkey, message, &sig).expect("TODO: handle error");
+        verify_hybrid(&pubkey, message, &sig).unwrap();
     }
 
     #[test]
     fn test_hybrid_verify_wrong_message() {
-        let keypair = generate_hybrid_keypair().expect("TODO: handle error");
+        let keypair = generate_hybrid_keypair().unwrap();
         let pubkey = hybrid_public_key(&keypair);
 
         let sig = sign_hybrid(&keypair, b"original message");
@@ -734,10 +734,10 @@ mod tests {
         let nonce = secure_random_bytes(24);
         let plaintext = b"secret message";
 
-        let ciphertext = encrypt_xchacha20(&key, &nonce, plaintext).expect("TODO: handle error");
+        let ciphertext = encrypt_xchacha20(&key, &nonce, plaintext).unwrap();
         assert_ne!(&ciphertext, plaintext);
 
-        let decrypted = decrypt_xchacha20(&key, &nonce, &ciphertext).expect("TODO: handle error");
+        let decrypted = decrypt_xchacha20(&key, &nonce, &ciphertext).unwrap();
         assert_eq!(&decrypted, plaintext);
     }
 
@@ -747,7 +747,7 @@ mod tests {
         let wrong_key = secure_random_bytes(32);
         let nonce = secure_random_bytes(24);
 
-        let ciphertext = encrypt_xchacha20(&key, &nonce, b"secret").expect("TODO: handle error");
+        let ciphertext = encrypt_xchacha20(&key, &nonce, b"secret").unwrap();
         assert!(decrypt_xchacha20(&wrong_key, &nonce, &ciphertext).is_err());
     }
 
@@ -757,15 +757,15 @@ mod tests {
         let salt = b"optional salt";
         let info = b"context info";
 
-        let key1 = derive_key_hkdf_sha3_256(ikm, Some(salt), info).expect("TODO: handle error");
+        let key1 = derive_key_hkdf_sha3_256(ikm, Some(salt), info).unwrap();
         assert_eq!(key1.len(), 32);
 
         // Same inputs should produce same output
-        let key2 = derive_key_hkdf_sha3_256(ikm, Some(salt), info).expect("TODO: handle error");
+        let key2 = derive_key_hkdf_sha3_256(ikm, Some(salt), info).unwrap();
         assert_eq!(key1, key2);
 
         // Different info should produce different output
-        let key3 = derive_key_hkdf_sha3_256(ikm, Some(salt), b"different").expect("TODO: handle error");
+        let key3 = derive_key_hkdf_sha3_256(ikm, Some(salt), b"different").unwrap();
         assert_ne!(key1, key3);
     }
 
@@ -784,7 +784,7 @@ mod tests {
             mldsa87_sig: vec![4, 5, 6],
         };
         let json = serialize_signature(&sig);
-        let deserialized = deserialize_signature(&json).expect("TODO: handle error");
+        let deserialized = deserialize_signature(&json).unwrap();
         assert_eq!(deserialized.ed448_sig, sig.ed448_sig);
         assert_eq!(deserialized.mldsa87_sig, sig.mldsa87_sig);
     }
@@ -796,18 +796,18 @@ mod tests {
             mldsa87: vec![40, 50, 60],
         };
         let json = serialize_public_key(&pk);
-        let deserialized = deserialize_public_key(&json).expect("TODO: handle error");
+        let deserialized = deserialize_public_key(&json).unwrap();
         assert_eq!(deserialized.ed448, pk.ed448);
         assert_eq!(deserialized.mldsa87, pk.mldsa87);
     }
 
     #[test]
     fn test_keypair_serialization_roundtrip() {
-        let keypair = generate_hybrid_keypair().expect("TODO: handle error");
+        let keypair = generate_hybrid_keypair().unwrap();
         let pubkey_before = hybrid_public_key(&keypair);
 
-        let data = serialize_keypair_raw(&keypair).expect("TODO: handle error");
-        let restored = deserialize_keypair_raw(&data).expect("TODO: handle error");
+        let data = serialize_keypair_raw(&keypair).unwrap();
+        let restored = deserialize_keypair_raw(&data).unwrap();
         let pubkey_after = hybrid_public_key(&restored);
 
         // Public keys must match
@@ -817,17 +817,17 @@ mod tests {
         // Sign with restored key, verify with original pubkey
         let msg = b"roundtrip test message";
         let sig = sign_hybrid(&restored, msg);
-        verify_hybrid(&pubkey_before, msg, &sig).expect("TODO: handle error");
+        verify_hybrid(&pubkey_before, msg, &sig).unwrap();
     }
 
     #[test]
     fn test_keypair_encrypted_roundtrip() {
-        let keypair = generate_hybrid_keypair().expect("TODO: handle error");
+        let keypair = generate_hybrid_keypair().unwrap();
         let pubkey_before = hybrid_public_key(&keypair);
         let password = b"test-password-wharf";
 
-        let encrypted = serialize_keypair(&keypair, password).expect("TODO: handle error");
-        let restored = deserialize_keypair(&encrypted, password).expect("TODO: handle error");
+        let encrypted = serialize_keypair(&keypair, password).unwrap();
+        let restored = deserialize_keypair(&encrypted, password).unwrap();
         let pubkey_after = hybrid_public_key(&restored);
 
         assert_eq!(pubkey_before.ed448, pubkey_after.ed448);
@@ -836,21 +836,21 @@ mod tests {
         // Verify signing still works
         let msg = b"encrypted roundtrip";
         let sig = sign_hybrid(&restored, msg);
-        verify_hybrid(&pubkey_before, msg, &sig).expect("TODO: handle error");
+        verify_hybrid(&pubkey_before, msg, &sig).unwrap();
     }
 
     #[test]
     fn test_keypair_wrong_password() {
-        let keypair = generate_hybrid_keypair().expect("TODO: handle error");
-        let encrypted = serialize_keypair(&keypair, b"correct").expect("TODO: handle error");
+        let keypair = generate_hybrid_keypair().unwrap();
+        let encrypted = serialize_keypair(&keypair, b"correct").unwrap();
 
         // Wrong password should fail decryption
         assert!(deserialize_keypair(&encrypted, b"wrong").is_err());
     }
 
     #[test]
     fn test_mldsa87_only_sign_verify() {
-        let keypair = generate_hybrid_keypair().expect("TODO: handle error");
+        let keypair = generate_hybrid_keypair().unwrap();
         let pubkey = hybrid_public_key(&keypair);
         let msg = b"mldsa87-only test message";
 
@@ -860,20 +860,20 @@ mod tests {
         assert!(!sig.mldsa87_sig.is_empty());
 
         // Verification with same scheme should succeed
-        verify_with_scheme(&pubkey, msg, &sig, SignatureScheme::MlDsa87Only).expect("TODO: handle error");
+        verify_with_scheme(&pubkey, msg, &sig, SignatureScheme::MlDsa87Only).unwrap();
     }
 
     #[test]
     fn test_mldsa87_only_wrong_message() {
-        let keypair = generate_hybrid_keypair().expect("TODO: handle error");
+        let keypair = generate_hybrid_keypair().unwrap();
         let pubkey = hybrid_public_key(&keypair);
         let sig = sign_with_scheme(&keypair, b"original", SignatureScheme::MlDsa87Only);
         assert!(verify_with_scheme(&pubkey, b"tampered", &sig, SignatureScheme::MlDsa87Only).is_err());
     }
 
     #[test]
     fn test_hybrid_scheme_sign_verify() {
-        let keypair = generate_hybrid_keypair().expect("TODO: handle error");
+        let keypair = generate_hybrid_keypair().unwrap();
         let pubkey = hybrid_public_key(&keypair);
         let msg = b"hybrid scheme test";
 
@@ -882,7 +882,7 @@ mod tests {
         assert!(!sig.ed448_sig.is_empty());
         assert!(!sig.mldsa87_sig.is_empty());
 
-        verify_with_scheme(&pubkey, msg, &sig, SignatureScheme::Hybrid).expect("TODO: handle error");
+        verify_with_scheme(&pubkey, msg, &sig, SignatureScheme::Hybrid).unwrap();
     }
 
     #[test]
@@ -892,18 +892,18 @@ mod tests {
 
     #[test]
     fn test_keypair_persistence() {
-        let dir = tempfile::tempdir().expect("TODO: handle error");
+        let dir = tempfile::tempdir().unwrap();
         let key_path = dir.path().join("test.key");
 
         // Generate, serialize, write
-        let keypair = generate_hybrid_keypair().expect("TODO: handle error");
+        let keypair = generate_hybrid_keypair().unwrap();
         let pubkey_original = hybrid_public_key(&keypair);
-        let data = serialize_keypair_raw(&keypair).expect("TODO: handle error");
-        std::fs::write(&key_path, &data).expect("TODO: handle error");
+        let data = serialize_keypair_raw(&keypair).unwrap();
+        std::fs::write(&key_path, &data).unwrap();
 
         // Read, deserialize, verify
-        let loaded_data = std::fs::read(&key_path).expect("TODO: handle error");
-        let restored = deserialize_keypair_raw(&loaded_data).expect("TODO: handle error");
+        let loaded_data = std::fs::read(&key_path).unwrap();
+        let restored = deserialize_keypair_raw(&loaded_data).unwrap();
         let pubkey_restored = hybrid_public_key(&restored);
 
         assert_eq!(pubkey_original.ed448, pubkey_restored.ed448);
@@ -912,6 +912,6 @@ mod tests {
         // Sign → verify across the persistence boundary
         let msg = b"persistence test";
         let sig = sign_hybrid(&restored, msg);
-        verify_hybrid(&pubkey_original, msg, &sig).expect("TODO: handle error");
+        verify_hybrid(&pubkey_original, msg, &sig).unwrap();
     }
 }