Detect kernel crash before connection and capture stderr

- Check if kernel process has exited before attempting ZMQ connections
- Capture and report kernel stderr on early crash
- Add CI debug step that tries to launch kernel directly with 5s timeout

Author: rgbkrk

.github/workflows/conformance.yml

@@ -243,8 +243,12 @@ jobs:
           echo "Binary: $KERNEL_BIN"
           ls -la "$KERNEL_BIN" 2>/dev/null || echo "Binary not found at $KERNEL_BIN"
           which xoctave 2>/dev/null || echo "xoctave not in PATH"
-          echo "=== Try running ==="
-          ldd "$KERNEL_BIN" 2>/dev/null | grep "not found" || echo "All libraries found (or not an ELF binary)"
+          echo "=== ldd ==="
+          ldd "$KERNEL_BIN" 2>/dev/null || echo "ldd failed"
+          echo "=== Try launching kernel directly (5s timeout) ==="
+          # Create a dummy connection file to see if kernel starts
+          echo '{"transport":"tcp","ip":"127.0.0.1","shell_port":0,"iopub_port":0,"stdin_port":0,"control_port":0,"hb_port":0,"signature_scheme":"hmac-sha256","key":"test"}' > /tmp/test-conn.json
+          timeout 5 xvfb-run -a "$KERNEL_BIN" -f /tmp/test-conn.json 2>&1 || echo "Kernel exited with code $?"
           echo "=== env ==="
           echo "PATH=$PATH"
           echo "LD_LIBRARY_PATH=${LD_LIBRARY_PATH:-unset}"

src/harness.rs

@@ -111,14 +111,40 @@ impl KernelUnderTest {
         tokio::fs::write(&connection_path, content).await?;
 
         // Launch kernel process (capture stderr for diagnostics)
-        let process = kernelspec
+        let mut process = kernelspec
             .command(&connection_path, Some(Stdio::null()), Some(Stdio::piped()))?
             .spawn()
             .map_err(|e| HarnessError::LaunchFailed(e.to_string()))?;
 
         // Give kernel time to start
         tokio::time::sleep(Duration::from_millis(2000)).await;
 
+        // Check if kernel process has already exited (crashed during startup)
+        match process.try_wait() {
+            Ok(Some(exit_status)) => {
+                // Process has already exited - read stderr for diagnostics
+                let mut stderr_output = String::new();
+                if let Some(stderr) = process.stderr.take() {
+                    use tokio::io::AsyncReadExt;
+                    let mut reader = tokio::io::BufReader::new(stderr);
+                    let _ = reader.read_to_string(&mut stderr_output).await;
+                }
+                let msg = if stderr_output.is_empty() {
+                    format!("Kernel process exited with {} before connections could be established", exit_status)
+                } else {
+                    format!("Kernel process exited with {} before connections could be established. Stderr:\n{}", exit_status, stderr_output)
+                };
+                eprintln!("{}", msg);
+                return Err(HarnessError::LaunchFailed(msg));
+            }
+            Ok(None) => {
+                // Process still running - good
+            }
+            Err(e) => {
+                eprintln!("Warning: could not check kernel process status: {}", e);
+            }
+        }
+
         // Create peer identity for shell/stdin (must share identity)
         let identity = peer_identity_for_session(&session_id)?;