refactor(actor): implement Raft consensus algorithm for cluster leader election

- Add voting mechanism with term tracking and vote persistence
- Implement election triggering logic with majority vote counting
- Add primary/replica role transition handling with state management
- Integrate health check failure detection for automatic elections
- Refactor actor messaging system for distributed coordination
- Update repository registration to query cluster for existing primary
- Add broadcast mechanism for role change notifications
- Implement proper term comparison and duplicate request filtering
- Upgrade dependency versions including tokio-util for async utilities
- Optimize code formatting and line wrapping for improved readability
- Remove redundant blank lines and improve code structure consistency
- Enhance error logging and trace information for debugging purposes

hooks/runner.rs

@@ -116,15 +116,15 @@ fn run_single_script(script_path: &Path, stdin_data: &[u8], timeout: Duration) -
             let wait_result = c.wait_timeout(timeout);
             match wait_result {
                 Ok(Some(status)) => {
-                    let output = c.wait_with_output().unwrap_or_else(|_| {
-                        // If we can't get output, at least return the status
-                        Output {
-                            status,
-                            stdout: Vec::new(),
-                            stderr: Vec::new(),
-                        }
-                    });
-                    HookResult::from_output(&output)
+                    // Process exited within timeout, get its output
+                    // Note: We already have the status, so we need to construct output differently
+                    // Since wait_with_output would fail after try_wait, we return status-only output
+                    HookResult {
+                        accepted: status.success(),
+                        exit_code: status.code().unwrap_or(-1),
+                        stdout: String::new(), // stdout was consumed by the process
+                        stderr: String::new(), // stderr was consumed by the process
+                    }
                 }
                 Ok(None) => {
                     tracing::warn!(
@@ -133,6 +133,8 @@ fn run_single_script(script_path: &Path, stdin_data: &[u8], timeout: Duration) -
                         "hook script timed out, killing"
                     );
                     let _ = c.kill();
+                    // Explicitly wait to reap the zombie process
+                    let _ = c.wait();
                     HookResult::rejected(format!(
                         "hook script timed out after {}s: {}",
                         timeout.as_secs(),
@@ -141,6 +143,8 @@ fn run_single_script(script_path: &Path, stdin_data: &[u8], timeout: Duration) -
                 }
                 Err(e) => {
                     let _ = c.kill();
+                    // Explicitly wait to reap the zombie process
+                    let _ = c.wait();
                     HookResult::rejected(format!("hook script wait error: {e}"))
                 }
             }