Fix CI: StopTest detection, mark_complete race, formatting, and nix

- Include error type in protocol error messages so StopTest is detected
  instead of calling process::exit(134)
- Change mark_complete to request-response to prevent race condition
  when closing channels
- Remove unused send_request_json method
- Update Cargo.lock files to include ciborium and crc32fast
- Point flake.nix hegel input to DRMacIver/new-protocol branch
- Fix clippy warnings (div_ceil, io_other_error, manual_range_contains)
- Run cargo fmt and rustfmt on all source files

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

Author: DRMacIver

Cargo.lock

@@ -3,7 +3,7 @@
 
   inputs = {
     nixpkgs.url = "github:nixos/nixpkgs/nixos-unstable";
-    hegel.url = "git+ssh://git@github.com/antithesishq/hegel";
+    hegel.url = "git+ssh://git@github.com/antithesishq/hegel?ref=DRMacIver/new-protocol";
   };
 
   outputs =

flake.nix

@@ -438,10 +438,7 @@ where
             .unwrap_or(0);
 
         if verbosity == Verbosity::Debug {
-            eprintln!(
-                "Test done. interesting_test_cases={}",
-                n_interesting
-            );
+            eprintln!("Test done. interesting_test_cases={}", n_interesting);
         }
 
         // Process final replay test cases (one per interesting example)
@@ -526,8 +523,8 @@ fn run_test_case<F: FnMut()>(
                 got_interesting.store(true, Ordering::SeqCst);
 
                 // Take panic info - we need location for origin, and print details on final
-                let (thread_name, thread_id, location, backtrace) =
-                    take_panic_info().unwrap_or_else(|| {
+                let (thread_name, thread_id, location, backtrace) = take_panic_info()
+                    .unwrap_or_else(|| {
                         (
                             "<unknown>".to_string(),
                             "?".to_string(),
@@ -578,8 +575,8 @@ fn run_test_case<F: FnMut()>(
                     "status": status,
                     "origin": origin,
                 });
-                // Fire-and-forget: server does not send a response to mark_complete
-                let _ = state.channel.send_request_json(&mark_complete);
+                // Wait for server to acknowledge mark_complete before closing
+                let _ = state.channel.request_json(&mark_complete);
                 // Close the test case channel
                 let _ = state.channel.close();
             }

src/embedded.rs

@@ -7,7 +7,7 @@ const BASE64_ALPHABET: &[u8; 64] =
 
 #[cfg(test)]
 fn base64_encode(input: &[u8]) -> String {
-    let mut result = String::with_capacity((input.len() + 2) / 3 * 4);
+    let mut result = String::with_capacity(input.len().div_ceil(3) * 4);
 
     for chunk in input.chunks(3) {
         // 3 bytes (3x8=24 bits) -> 4 base64 chars (4x6=24 bits)

src/gen/binary.rs

@@ -244,18 +244,13 @@ impl Channel {
         Ok(())
     }
 
-    /// Send a JSON request without waiting for a response (fire-and-forget).
-    /// Returns the message ID of the sent request.
-    pub fn send_request_json(&self, message: &serde_json::Value) -> std::io::Result<u32> {
-        let mut payload = Vec::new();
-        ciborium::into_writer(message, &mut payload)
-            .map_err(|e| std::io::Error::new(std::io::ErrorKind::InvalidData, e))?;
-        self.send_request(payload)
-    }
-
     /// Close this channel by sending a close packet to the remote side.
     pub fn close(&self) -> std::io::Result<()> {
-        let packet = Packet::request(self.channel_id, CLOSE_CHANNEL_MESSAGE_ID, CLOSE_CHANNEL_PAYLOAD.to_vec());
+        let packet = Packet::request(
+            self.channel_id,
+            CLOSE_CHANNEL_MESSAGE_ID,
+            CLOSE_CHANNEL_PAYLOAD.to_vec(),
+        );
         self.connection.send_packet(&packet)
     }
 
@@ -276,10 +271,11 @@ impl Channel {
 
         // Check for error response
         if let Some(error) = response.get("error") {
-            return Err(std::io::Error::new(
-                std::io::ErrorKind::Other,
-                format!("Server error: {}", error),
-            ));
+            let error_type = response.get("type").and_then(|t| t.as_str()).unwrap_or("");
+            return Err(std::io::Error::other(format!(
+                "Server error ({}): {}",
+                error_type, error
+            )));
         }
 
         // Extract result field if present

src/protocol.rs

@@ -2,14 +2,11 @@ use hegel::gen::{self, Generate};
 use nix_test::Rectangle;
 
 fn rectangles() -> impl Generate<Rectangle> {
-    gen::tuples(gen::integers::<u32>(), gen::integers::<u32>())
-        .map(|(w, h)| Rectangle::new(w, h))
+    gen::tuples(gen::integers::<u32>(), gen::integers::<u32>()).map(|(w, h)| Rectangle::new(w, h))
 }
 
 #[test]
-fn test_nix_integration_canary() {
-
-}
+fn test_nix_integration_canary() {}
 
 #[test]
 fn test_area_is_product_of_sides() {
@@ -23,7 +20,10 @@ fn test_area_is_product_of_sides() {
 fn test_perimeter_is_twice_sum_of_sides() {
     hegel::hegel(|| {
         let rect = rectangles().generate();
-        assert_eq!(rect.perimeter(), 2 * (rect.width as u64 + rect.height as u64));
+        assert_eq!(
+            rect.perimeter(),
+            2 * (rect.width as u64 + rect.height as u64)
+        );
     });
 }
 

tests/nix/Cargo.lock

@@ -46,7 +46,7 @@ fn test_optional_respects_inner_generator_bounds() {
         let value: Option<i32> =
             gen::optional(gen::integers().with_min(10).with_max(20)).generate();
         if let Some(n) = value {
-            assert!(n >= 10 && n <= 20);
+            assert!((10..=20).contains(&n));
         }
     });
 }