revert: remove PTY gate/permit code from terminal.rs

RUST_TEST_THREADS=1 is the actual fix — the SIGSEGV is caused by musl's
fork() in multi-threaded processes, not just concurrent PTY operations.
The gate code added complexity without addressing the root cause.

Author: claude

crates/pty_terminal/src/terminal.rs

@@ -12,40 +12,13 @@ use crate::geo::ScreenSize;
 
 type ChildWaitResult = Result<ExitStatus, Arc<std::io::Error>>;
 
-// On musl libc (Alpine Linux), concurrent PTY operations trigger
-// SIGSEGV/SIGBUS in musl internals (sysconf, fcntl). This affects
-// openpty+fork, FD operations (read/write/close), and FD drops.
-// Ensure only one Terminal exists at a time by blocking spawn until
-// all PTY FDs from the previous Terminal are closed.
-#[cfg(target_env = "musl")]
-static PTY_GATE: (std::sync::Mutex<bool>, std::sync::Condvar) =
-    (std::sync::Mutex::new(false), std::sync::Condvar::new());
-
-/// RAII guard that releases the PTY gate when dropped.
-/// Shared via `Arc` so the gate stays held while any part of the
-/// Terminal (reader, writer, background thread) is still alive.
-#[cfg(target_env = "musl")]
-struct PtyPermit;
-
-#[cfg(target_env = "musl")]
-impl Drop for PtyPermit {
-    fn drop(&mut self) {
-        let (lock, cvar) = &PTY_GATE;
-        *lock.lock().unwrap_or_else(|e| e.into_inner()) = false;
-        cvar.notify_one();
-    }
-}
-
 /// The read half of a PTY connection. Implements [`Read`].
 ///
 /// Reading feeds data through an internal vt100 parser (shared with [`PtyWriter`]),
 /// keeping `screen_contents()` up-to-date with parsed terminal output.
 pub struct PtyReader {
     reader: Box<dyn Read + Send>,
     parser: Arc<Mutex<vt100::Parser<Vt100Callbacks>>>,
-    /// Prevent concurrent PTY sessions on musl; released when all parts are dropped.
-    #[cfg(target_env = "musl")]
-    _permit: Arc<PtyPermit>,
 }
 
 /// The write half of a PTY connection. Implements [`Write`].
@@ -56,9 +29,6 @@ pub struct PtyWriter {
     writer: Arc<Mutex<Option<Box<dyn Write + Send>>>>,
     parser: Arc<Mutex<vt100::Parser<Vt100Callbacks>>>,
     master: Box<dyn MasterPty + Send>,
-    /// Prevent concurrent PTY sessions on musl; released when all parts are dropped.
-    #[cfg(target_env = "musl")]
-    _permit: Arc<PtyPermit>,
 }
 
 /// A cloneable handle to a child process spawned in a PTY.
@@ -286,17 +256,14 @@ impl Terminal {
     ///
     /// Panics if the writer lock is poisoned when the background thread closes it.
     pub fn spawn(size: ScreenSize, cmd: CommandBuilder) -> anyhow::Result<Self> {
-        // On musl, block until no other Terminal is alive.
+        // On musl libc (Alpine Linux), concurrent PTY operations trigger
+        // SIGSEGV/SIGBUS in musl internals (sysconf, fcntl). This affects
+        // both openpty+fork and FD cleanup (close) from background threads.
+        // Serialize all PTY lifecycle operations that touch musl internals.
         #[cfg(target_env = "musl")]
-        let permit = {
-            let (lock, cvar) = &PTY_GATE;
-            let mut busy = lock.lock().unwrap_or_else(|e| e.into_inner());
-            while *busy {
-                busy = cvar.wait(busy).unwrap_or_else(|e| e.into_inner());
-            }
-            *busy = true;
-            Arc::new(PtyPermit)
-        };
+        static PTY_LOCK: std::sync::Mutex<()> = std::sync::Mutex::new(());
+        #[cfg(target_env = "musl")]
+        let _spawn_guard = PTY_LOCK.lock().unwrap_or_else(|e| e.into_inner());
 
         let pty_pair = portable_pty::native_pty_system().openpty(portable_pty::PtySize {
             rows: size.rows,
@@ -326,16 +293,15 @@ impl Terminal {
             let writer = Arc::clone(&writer);
             let exit_status = Arc::clone(&exit_status);
             let slave = pty_pair.slave;
-            // Hold a permit clone so the gate stays held while FDs are being cleaned up.
-            #[cfg(target_env = "musl")]
-            let _permit = Arc::clone(&permit);
             move || {
                 let _ = exit_status.set(child.wait().map_err(Arc::new));
+                // On musl, serialize FD cleanup (close) with PTY spawn to
+                // prevent racing on musl-internal state.
+                #[cfg(target_env = "musl")]
+                let _cleanup_guard = PTY_LOCK.lock().unwrap_or_else(|e| e.into_inner());
                 // Close writer first, then drop slave to trigger EOF on the reader.
                 *writer.lock().unwrap() = None;
                 drop(slave);
-                // _permit is dropped here (after FD cleanup), releasing the gate
-                // once all other permit clones are also dropped.
             }
         });
 
@@ -350,19 +316,8 @@ impl Terminal {
         )));
 
         Ok(Self {
-            pty_reader: PtyReader {
-                reader,
-                parser: Arc::clone(&parser),
-                #[cfg(target_env = "musl")]
-                _permit: Arc::clone(&permit),
-            },
-            pty_writer: PtyWriter {
-                writer,
-                parser,
-                master,
-                #[cfg(target_env = "musl")]
-                _permit: permit,
-            },
+            pty_reader: PtyReader { reader, parser: Arc::clone(&parser) },
+            pty_writer: PtyWriter { writer, parser, master },
             child_handle: ChildHandle { child_killer, exit_status },
         })
     }