fix(patallm-gallery): sweep .expect("TODO: handle error") — 175 sites cleared

Categorized each site by context and applied appropriate error handling policies:

- 9 sites: Regex::new() in claim_extractor.rs — (e) true invariants (hardcoded patterns)
- 2 sites: serde_json in main.rs output — (e) true invariants (struct serialization)
- 2 sites: serde_json in slm/ensemble.rs test — (a) test code, .unwrap()
- 2 sites: serde_json in slm/mod.rs test — (a) test code, .unwrap()
- 159 sites: Test functions, benches, examples, fuzz, .archive — (a) all test code, .unwrap()

Tests: 132 passed / 0 failed

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

Author: hyperpolymath

did-you-actually-do-that/src/claim_extractor.rs

@@ -73,35 +73,35 @@ impl ClaimExtractor {
             // Must contain a file extension or path separator to be a valid file path
             file_created_pattern: Regex::new(
                 r#"(?i)(?:I\s+)?(?:created|made|added)\s+(?:the\s+)?file\s+[`"']?([^\s`"']+\.[a-zA-Z0-9]+)[`"']?"#
-            ).expect("TODO: handle error"),
+            ).expect("invariant: regex pattern is syntactically valid"),
             file_wrote_pattern: Regex::new(
                 r#"(?i)(?:I\s+)?(?:wrote|written)\s+(?:to\s+)?(?:the\s+)?file\s+[`"']?([^\s`"']+\.[a-zA-Z0-9]+)[`"']?"#
-            ).expect("TODO: handle error"),
+            ).expect("invariant: regex pattern is syntactically valid"),
             file_modified_pattern: Regex::new(
                 r#"(?i)(?:I\s+)?(?:modified|updated|edited|changed)\s+(?:the\s+)?(?:file\s+)?[`"']?([^\s`"']+\.[a-zA-Z0-9]+)[`"']?"#
-            ).expect("TODO: handle error"),
+            ).expect("invariant: regex pattern is syntactically valid"),
             file_deleted_pattern: Regex::new(
                 r#"(?i)(?:I\s+)?(?:deleted|removed)\s+(?:the\s+)?file\s+[`"']?([^\s`"']+\.[a-zA-Z0-9]+)[`"']?"#
-            ).expect("TODO: handle error"),
+            ).expect("invariant: regex pattern is syntactically valid"),
             // Command execution
             command_ran_pattern: Regex::new(
                 r#"(?i)(?:I\s+)?(?:ran|executed)\s+(?:the\s+)?command\s+[`"']([^`"']+)[`"']"#
-            ).expect("TODO: handle error"),
+            ).expect("invariant: regex pattern is syntactically valid"),
             // Git operations - require hash to be present for commit detection
             git_commit_pattern: Regex::new(
                 r#"(?i)(?:committed|commit)\s+(?:with\s+)?(?:hash\s+)?([a-f0-9]{7,40})"#
-            ).expect("TODO: handle error"),
+            ).expect("invariant: regex pattern is syntactically valid"),
             git_push_pattern: Regex::new(
                 r#"(?i)(?:I\s+)?pushed\s+(?:to\s+)?(?:the\s+)?branch\s+[`"']?([^\s`"']+)[`"']?"#
-            ).expect("TODO: handle error"),
+            ).expect("invariant: regex pattern is syntactically valid"),
             // Git branch - require "branch" keyword to avoid false positives
             git_branch_pattern: Regex::new(
                 r#"(?i)(?:I\s+)?(?:created|switched\s+to)\s+(?:the\s+)?branch\s+[`"']?([^\s`"']+)[`"']?"#
-            ).expect("TODO: handle error"),
+            ).expect("invariant: regex pattern is syntactically valid"),
             // Directory operations - require "directory" or "folder" keyword
             directory_created_pattern: Regex::new(
                 r#"(?i)(?:I\s+)?(?:created|made)\s+(?:the\s+)?(?:directory|folder|dir)\s+[`"']?([^\s`"']+)[`"']?"#
-            ).expect("TODO: handle error"),
+            ).expect("invariant: regex pattern is syntactically valid"),
         }
     }
 

did-you-actually-do-that/src/hooks.rs

@@ -408,7 +408,7 @@ mod tests {
             "working_directory": "/home/user"
         }"#;
 
-        let input = parse_hook_input(json).expect("TODO: handle error");
+        let input = parse_hook_input(json).unwrap();
         assert_eq!(input.event, HookEvent::PostToolExecution);
         assert_eq!(input.tool_name, Some("Write".to_string()));
     }

did-you-actually-do-that/src/main.rs

@@ -281,7 +281,7 @@ fn output_json(reports: &[VerificationReport]) {
             "unverifiable": reports.iter().filter(|r| r.overall_verdict == Verdict::Unverifiable).count()
         }
     });
-    println!("{}", serde_json::to_string_pretty(&output).expect("TODO: handle error"));
+    println!("{}", serde_json::to_string_pretty(&output).expect("invariant: struct is serializable"));
 }
 
 /// Output reports as SARIF (Static Analysis Results Interchange Format)
@@ -372,7 +372,7 @@ fn output_sarif(reports: &[VerificationReport]) {
         }]
     });
 
-    println!("{}", serde_json::to_string_pretty(&sarif).expect("TODO: handle error"));
+    println!("{}", serde_json::to_string_pretty(&sarif).expect("invariant: struct is serializable"));
 }
 
 /// Output reports as JUnit XML (for CI systems)

did-you-actually-do-that/src/mcp_server.rs

@@ -564,7 +564,7 @@ mod tests {
         let response = server.handle_initialize(json!(1));
 
         assert!(response.result.is_some());
-        let result = response.result.expect("TODO: handle error");
+        let result = response.result.unwrap();
         assert_eq!(result["protocolVersion"], MCP_VERSION);
         assert!(result["serverInfo"]["name"].is_string());
     }
@@ -575,11 +575,11 @@ mod tests {
         let response = server.handle_tools_list(json!(1));
 
         assert!(response.result.is_some());
-        let result = response.result.expect("TODO: handle error");
-        let tools = result["tools"].as_array().expect("TODO: handle error");
+        let result = response.result.unwrap();
+        let tools = result["tools"].as_array().unwrap();
         assert_eq!(tools.len(), 4);
 
-        let tool_names: Vec<&str> = tools.iter().map(|t| t["name"].as_str().expect("TODO: handle error")).collect();
+        let tool_names: Vec<&str> = tools.iter().map(|t| t["name"].as_str().unwrap()).collect();
         assert!(tool_names.contains(&"verify_claim"));
         assert!(tool_names.contains(&"quick_verify"));
         assert!(tool_names.contains(&"compute_hash"));
@@ -594,7 +594,7 @@ mod tests {
         }));
 
         assert!(result.is_ok());
-        let text = result.expect("TODO: handle error");
+        let text = result.unwrap();
         assert!(text.contains("Refuted"));
     }
 
@@ -613,7 +613,7 @@ mod tests {
         }));
 
         assert!(result.is_ok());
-        let text = result.expect("TODO: handle error");
+        let text = result.unwrap();
         assert!(text.contains("Test claim"));
         assert!(text.contains("Refuted"));
     }

did-you-actually-do-that/src/port_protocol.rs

@@ -417,7 +417,7 @@ mod tests {
         let resp = PortResponse::err("test-2".to_string(), -1, "oops".to_string());
         assert!(resp.result.is_none());
         assert!(resp.error.is_some());
-        assert_eq!(resp.error.expect("TODO: handle error").code, -1);
+        assert_eq!(resp.error.unwrap().code, -1);
     }
 
     #[test]
@@ -431,7 +431,7 @@ mod tests {
         };
         let response = handle_request(&verifier, &ensemble, &request);
         assert!(response.result.is_some());
-        assert_eq!(response.result.expect("TODO: handle error")["pong"], true);
+        assert_eq!(response.result.unwrap()["pong"], true);
     }
 
     #[test]
@@ -445,7 +445,7 @@ mod tests {
         };
         let response = handle_request(&verifier, &ensemble, &request);
         assert!(response.error.is_some());
-        assert_eq!(response.error.expect("TODO: handle error").code, -32601);
+        assert_eq!(response.error.unwrap().code, -32601);
     }
 
     #[test]
@@ -463,7 +463,7 @@ mod tests {
         };
         let response = handle_request(&verifier, &ensemble, &request);
         assert!(response.result.is_some());
-        let result = response.result.expect("TODO: handle error");
+        let result = response.result.unwrap();
         assert!(result["votes"].is_array());
         assert!(result["suggested_verdict"].is_string());
     }
@@ -472,10 +472,10 @@ mod tests {
     fn test_read_write_message_roundtrip() {
         let data = b"hello world";
         let mut buf = Vec::new();
-        write_message(&mut buf, data).expect("TODO: handle error");
+        write_message(&mut buf, data).unwrap();
 
         let mut cursor = io::Cursor::new(buf);
-        let result = read_message(&mut cursor).expect("TODO: handle error").expect("TODO: handle error");
+        let result = read_message(&mut cursor).unwrap().unwrap();
         assert_eq!(result, data);
     }
 }

did-you-actually-do-that/src/slm/ensemble.rs

@@ -297,8 +297,8 @@ mod tests {
     fn test_ensemble_result_serialization() {
         let ensemble = Ensemble::new();
         let result = ensemble.evaluate(&sample_context());
-        let json = serde_json::to_string(&result).expect("TODO: handle error");
-        let back: EnsembleResult = serde_json::from_str(&json).expect("TODO: handle error");
+        let json = serde_json::to_string(&result).unwrap();
+        let back: EnsembleResult = serde_json::from_str(&json).unwrap();
         assert_eq!(back.votes.len(), result.votes.len());
         assert_eq!(back.suggested_verdict, result.suggested_verdict);
     }

did-you-actually-do-that/src/slm/mod.rs

@@ -177,8 +177,8 @@ mod tests {
             reasoning: "Stub functions detected".to_string(),
             weight: 1.5,
         };
-        let json = serde_json::to_string(&vote).expect("TODO: handle error");
-        let back: Vote = serde_json::from_str(&json).expect("TODO: handle error");
+        let json = serde_json::to_string(&vote).unwrap();
+        let back: Vote = serde_json::from_str(&json).unwrap();
         assert_eq!(back.voter, "test-model");
         assert_eq!(back.decision, VoteDecision::Reject);
         assert_eq!(back.weight, 1.5);

did-you-actually-do-that/src/verifiers/attestation.rs

@@ -393,7 +393,7 @@ mod tests {
     #[test]
     fn test_valid_attestation() {
         let (envelope_str, report_bytes) = build_test_attestation();
-        let envelope: Envelope = serde_json::from_str(&envelope_str).expect("TODO: handle error");
+        let envelope: Envelope = serde_json::from_str(&envelope_str).unwrap();
         let result = verify_envelope(&envelope, &report_bytes, None);
         assert_eq!(result.verdict, Verdict::Confirmed);
         assert!(result.structure_valid);
@@ -407,7 +407,7 @@ mod tests {
     #[test]
     fn test_tampered_report_detected() {
         let (envelope_str, _) = build_test_attestation();
-        let envelope: Envelope = serde_json::from_str(&envelope_str).expect("TODO: handle error");
+        let envelope: Envelope = serde_json::from_str(&envelope_str).unwrap();
         // Tamper: different report bytes
         let tampered = b"tampered report content";
         let result = verify_envelope(&envelope, tampered, None);

did-you-actually-do-that/src/verifiers/completeness.rs

@@ -464,7 +464,7 @@ mod tests {
 
         let stub_file = tmp.join("stub.rs");
         fs::write(&stub_file, "fn main() { todo!() }\nfn helper() { unimplemented!() }")
-            .expect("TODO: handle error");
+            .unwrap();
 
         let claims = vec![make_claim(
             "Created stub.rs",

did-you-actually-do-that/src/verifiers/content_hash.rs

@@ -51,17 +51,17 @@ mod tests {
 
     #[test]
     fn test_hash_matches() {
-        let dir = TempDir::new().expect("TODO: handle error");
+        let dir = TempDir::new().unwrap();
         let file_path = dir.path().join("test.txt");
         let content = b"hello world";
-        fs::write(&file_path, content).expect("TODO: handle error");
+        fs::write(&file_path, content).unwrap();
 
         let mut hasher = Sha256::new();
         hasher.update(content);
         let hash = hex::encode(hasher.finalize());
 
         let evidence = EvidenceSpec::FileWithHash {
-            path: file_path.to_str().expect("TODO: handle error").to_string(),
+            path: file_path.to_str().unwrap().to_string(),
             sha256: hash,
         };
         let result = check(&evidence);
@@ -70,12 +70,12 @@ mod tests {
 
     #[test]
     fn test_hash_mismatch() {
-        let dir = TempDir::new().expect("TODO: handle error");
+        let dir = TempDir::new().unwrap();
         let file_path = dir.path().join("test.txt");
-        fs::write(&file_path, "hello world").expect("TODO: handle error");
+        fs::write(&file_path, "hello world").unwrap();
 
         let evidence = EvidenceSpec::FileWithHash {
-            path: file_path.to_str().expect("TODO: handle error").to_string(),
+            path: file_path.to_str().unwrap().to_string(),
             sha256: "0000000000000000000000000000000000000000000000000000000000000000"
                 .to_string(),
         };