fix: avoid PTY wait deadlock on wait errors (#165)

## Summary
- Fix the PTY wait deadlock by ensuring the child-monitor thread always
sets the shared completion slot, including wait failures.
- Store wait failures as `Arc<std::io::Error>` in the shared `OnceLock`
(`Result<ExitStatus, Arc<std::io::Error>>`) so error state is shareable
without synthetic fallback status.
- Change `ChildHandle::wait()` to return `anyhow::Result<ExitStatus>`
and propagate wait failures through callers.
- Update downstream helpers/callers (`pty_terminal_test`, milestone
tests, and `vite_task_bin` e2e harness) to consume the new
`anyhow::Result` return type.
- Keep PTY integration tests strict at `#[timeout(5000)]` and run them
without a Windows serialization guard.

## Stable Reproduction (before fix)
To deterministically reproduce the real deadlock path (without mocking
`child.wait()` return values), I used a temporary Windows-only repro
patch that swaps the internal `WinChild` process handle with a
non-process handle (`CreateEventW` event handle). This makes
`child.wait()` execute the real Windows wait/get-exit-code path and
return `Err`.

With the old code path (`if let Ok(status) = child.wait() { ... }`),
`OnceLock` was never set on error, and `ChildHandle::wait()` blocked
forever.

Repro command:

```bash
cargo xtest --builder cargo-xwin --target x86_64-pc-windows-msvc -p pty_terminal --test terminal -- read_to_end_returns_exit_status_nonzero
```

Observed behavior under repro:
- timed out at ~15s with `#[timeout(15000)]`
- timed out again at ~60s with `#[timeout(60000)]`

That demonstrates timeout-independent deadlock behavior.

## Why this fixes it
- Background monitor thread now always sets the shared wait result (`Ok`
or `Err`).
- `ChildHandle::wait()` cannot block forever on an unset `OnceLock`.
- Wait failures are preserved and surfaced as real errors (no synthetic
`ExitStatus::with_exit_code(1)`).

## Validation
- `cargo clippy -p pty_terminal --all-targets --all-features -- -D
warnings`
- `cargo test -p pty_terminal -p pty_terminal_test`
- `cargo test -p vite_task_bin --test e2e_snapshots --no-run`
- `cargo xtest --builder cargo-xwin --target x86_64-pc-windows-msvc -p
pty_terminal --test terminal`
- `cargo xtest --builder cargo-xwin --target aarch64-pc-windows-msvc -p
pty_terminal --test terminal`
- `cargo xtest --builder cargo-xwin --target x86_64-pc-windows-msvc -p
pty_terminal --test terminal` repeated 40 times (all green, without
serial guard)

Author: branchseer

crates/pty_terminal/src/terminal.rs

@@ -10,6 +10,8 @@ use portable_pty::{ChildKiller, ExitStatus, MasterPty};
 
 use crate::geo::ScreenSize;
 
+type ChildWaitResult = Result<ExitStatus, Arc<std::io::Error>>;
+
 /// The read half of a PTY connection. Implements [`Read`].
 ///
 /// Reading feeds data through an internal vt100 parser (shared with [`PtyWriter`]),
@@ -32,7 +34,7 @@ pub struct PtyWriter {
 /// A cloneable handle to a child process spawned in a PTY.
 pub struct ChildHandle {
     child_killer: Box<dyn ChildKiller + Send + Sync>,
-    exit_status: Arc<OnceLock<ExitStatus>>,
+    exit_status: Arc<OnceLock<ChildWaitResult>>,
 }
 
 impl Clone for ChildHandle {
@@ -221,9 +223,15 @@ impl PtyWriter {
 
 impl ChildHandle {
     /// Blocks until the child process has exited and returns its exit status.
-    #[must_use]
-    pub fn wait(&self) -> ExitStatus {
-        self.exit_status.wait().clone()
+    ///
+    /// # Errors
+    ///
+    /// Returns an error if waiting for the child process exit status fails.
+    pub fn wait(&self) -> anyhow::Result<ExitStatus> {
+        match self.exit_status.wait() {
+            Ok(status) => Ok(status.clone()),
+            Err(error) => Err(anyhow::Error::new(Arc::clone(error))),
+        }
     }
 
     /// Kills the child process.
@@ -263,17 +271,14 @@ impl Terminal {
         let child_killer = child.clone_killer();
         drop(pty_pair.slave); // Critical: drop slave so EOF is signaled when child exits
         let master = pty_pair.master;
-        let exit_status: Arc<OnceLock<ExitStatus>> = Arc::new(OnceLock::new());
+        let exit_status: Arc<OnceLock<ChildWaitResult>> = Arc::new(OnceLock::new());
 
         // Background thread: wait for child to exit, set exit status, then close writer to trigger EOF
         thread::spawn({
             let writer = Arc::clone(&writer);
             let exit_status = Arc::clone(&exit_status);
             move || {
-                // Wait for child and set exit status
-                if let Ok(status) = child.wait() {
-                    let _ = exit_status.set(status);
-                }
+                let _ = exit_status.set(child.wait().map_err(Arc::new));
                 // Close writer to signal EOF to the reader
                 *writer.lock().unwrap() = None;
             }

crates/pty_terminal/tests/terminal.rs

@@ -20,7 +20,7 @@ fn is_terminal() {
         Terminal::spawn(ScreenSize { rows: 80, cols: 80 }, cmd).unwrap();
     let mut discard = Vec::new();
     pty_reader.read_to_end(&mut discard).unwrap();
-    let _ = child_handle.wait();
+    let _ = child_handle.wait().unwrap();
     let output = pty_reader.screen_contents();
     assert_eq!(output.trim(), "true true true");
 }
@@ -47,7 +47,7 @@ fn write_basic_echo() {
 
     let mut discard = Vec::new();
     pty_reader.read_to_end(&mut discard).unwrap();
-    let _ = child_handle.wait();
+    let _ = child_handle.wait().unwrap();
 
     let output = pty_reader.screen_contents();
     // PTY echoes the input, so we see "hello world\nhello world"
@@ -98,7 +98,7 @@ fn write_multiple_lines() {
 
     let mut discard = Vec::new();
     pty_reader.read_to_end(&mut discard).unwrap();
-    let _ = child_handle.wait();
+    let _ = child_handle.wait().unwrap();
 
     let output = pty_reader.screen_contents();
     // PTY echoes input, then child prints "Echo: {line}\n" for each
@@ -119,7 +119,7 @@ fn write_after_exit() {
     // Read all output - this blocks until child exits and EOF is reached
     let mut discard = Vec::new();
     pty_reader.read_to_end(&mut discard).unwrap();
-    let _ = child_handle.wait();
+    let _ = child_handle.wait().unwrap();
 
     // Writer shutdown is done by a background thread after child wait returns.
     // Poll briefly for the writer state to flip to closed before asserting write failure.
@@ -165,7 +165,7 @@ fn write_interactive_prompt() {
 
     let mut discard = Vec::new();
     pty_reader.read_to_end(&mut discard).unwrap();
-    let _ = child_handle.wait();
+    let _ = child_handle.wait().unwrap();
 
     let output = pty_reader.screen_contents();
     assert_eq!(output.trim(), "Name: Alice\nHello, Alice");
@@ -346,7 +346,7 @@ fn read_to_end_returns_exit_status_success() {
         Terminal::spawn(ScreenSize { rows: 80, cols: 80 }, cmd).unwrap();
     let mut discard = Vec::new();
     pty_reader.read_to_end(&mut discard).unwrap();
-    let status = child_handle.wait();
+    let status = child_handle.wait().unwrap();
     assert!(status.success());
     assert_eq!(status.exit_code(), 0);
 }
@@ -362,7 +362,7 @@ fn read_to_end_returns_exit_status_nonzero() {
         Terminal::spawn(ScreenSize { rows: 80, cols: 80 }, cmd).unwrap();
     let mut discard = Vec::new();
     pty_reader.read_to_end(&mut discard).unwrap();
-    let status = child_handle.wait();
+    let status = child_handle.wait().unwrap();
     assert!(!status.success());
     assert_eq!(status.exit_code(), 42);
 }

crates/pty_terminal_test/src/lib.rs

@@ -91,10 +91,14 @@ impl Reader {
 
     /// Reads all remaining PTY output until the child exits, then returns the exit status.
     ///
+    /// # Errors
+    ///
+    /// Returns an error if waiting for the child process exit status fails.
+    ///
     /// # Panics
     ///
     /// Panics if reading from the PTY fails.
-    pub fn wait_for_exit(&mut self) -> ExitStatus {
+    pub fn wait_for_exit(&mut self) -> anyhow::Result<ExitStatus> {
         let mut discard = Vec::new();
         self.pty.read_to_end(&mut discard).expect("PTY read_to_end failed");
         self.child_handle.wait()

crates/pty_terminal_test/tests/milestone.rs

@@ -67,7 +67,7 @@ fn milestone_raw_mode_keystrokes() {
     // Write 'q' to quit and wait for the child to exit
     writer.write_all(b"q").unwrap();
     writer.flush().unwrap();
-    let status = reader.wait_for_exit();
+    let status = reader.wait_for_exit().unwrap();
     assert!(status.success());
 }
 
@@ -122,6 +122,6 @@ fn milestone_does_not_pollute_screen() {
 
     writer.write_all(b"q").unwrap();
     writer.flush().unwrap();
-    let status = reader.wait_for_exit();
+    let status = reader.wait_for_exit().unwrap();
     assert!(status.success());
 }

crates/vite_task_bin/tests/e2e_snapshots/main.rs

@@ -391,7 +391,7 @@ fn run_case_inner(tmpdir: &AbsolutePath, fixture_path: &std::path::Path, fixture
                     }
                 }
 
-                let status = terminal.reader.wait_for_exit();
+                let status = terminal.reader.wait_for_exit().unwrap();
                 let screen = terminal.reader.screen_contents();
 
                 {