feat: add persistent server-client sessions

   Make herdr persistent by default.

   Launching herdr now starts or reattaches to a background session
   server. Clients can detach and reattach while panes and agent
   processes keep running. Session mode now supports multi-client attach,
   auto-detect startup, and a thin-client/headless-server split.

   This also refactors the large app, ui, input, pane, config,
   workspace, and persistence modules into smaller focused submodules,
   while preserving behavior and colocating tests with the code they
   exercise.

   Upgrade notes:
   - persistence mode is now the default
   - in-app quit detaches the current client instead of stopping the server
   - use `herdr server stop` to stop the background session
   - use `--no-session` for the old single-process behavior
   - default socket paths now live under the config directory

1 files changed, 135 insertions, 0 deletions

diff --git a/src/client/input.rs b/src/client/input.rs
new file mode 100644
index 00000000..31e1c1e4
--- /dev/null
+++ b/src/client/input.rs
@@ -0,0 +1,135 @@
+//! Stdin input reading for the thin client.
+//!
+//! Reads raw bytes from stdin and forwards them to the main event loop.
+//! Unlike the monolithic herdr, the thin client does NOT parse the input
+//! into key/mouse/paste events — it just sends the raw bytes to the server
+//! as `ClientMessage::Input`. The server handles parsing.
+//!
+//! This is simpler and more reliable because:
+//! - The server has the same input parsing code
+//! - We avoid duplicating parsing logic in the client
+//! - Raw forwarding preserves all escape sequences faithfully
+
+use std::io::{self, Read};
+use std::sync::atomic::{AtomicBool, Ordering};
+use std::sync::Arc;
+
+#[cfg(unix)]
+use std::os::fd::AsRawFd;
+use tokio::sync::mpsc;
+
+use super::ClientLoopEvent;
+
+// ---------------------------------------------------------------------------
+// Stdin reader thread
+// ---------------------------------------------------------------------------
+
+/// Reads raw bytes from stdin and sends them to the main event loop.
+///
+/// This runs on a dedicated thread because stdin reading is blocking.
+/// The main loop receives the raw bytes and forwards them as
+/// `ClientMessage::Input` to the server.
+pub fn stdin_reader_loop(event_tx: mpsc::Sender<ClientLoopEvent>, should_quit: &Arc<AtomicBool>) {
+    let stdin = io::stdin();
+    let mut reader = stdin.lock();
+    let mut scratch = [0u8; 4096];
+    let mut buffer = Vec::new();
+
+    while !should_quit.load(Ordering::Acquire) {
+        match reader.read(&mut scratch) {
+            Ok(0) => break,
+            Ok(n) => {
+                buffer.extend_from_slice(&scratch[..n]);
+
+                for data in crate::raw_input::drain_complete_input_bytes(&mut buffer) {
+                    if event_tx
+                        .blocking_send(ClientLoopEvent::StdinInput(data))
+                        .is_err()
+                    {
+                        return;
+                    }
+                }
+
+                if !buffer.is_empty() && stdin_read_ready(&reader, 10) == Some(false) {
+                    if let Some(data) = crate::raw_input::flush_incomplete_input_bytes(&mut buffer)
+                    {
+                        if event_tx
+                            .blocking_send(ClientLoopEvent::StdinInput(data))
+                            .is_err()
+                        {
+                            return;
+                        }
+                    }
+                }
+            }
+            Err(err) => {
+                if err.kind() == io::ErrorKind::Interrupted {
+                    continue;
+                }
+                break;
+            }
+        }
+    }
+}
+
+#[cfg(unix)]
+fn stdin_read_ready<R: AsRawFd>(reader: &R, timeout_ms: i32) -> Option<bool> {
+    poll_read_ready(reader.as_raw_fd(), timeout_ms)
+}
+
+#[cfg(not(unix))]
+fn stdin_read_ready<R>(_reader: &R, _timeout_ms: i32) -> Option<bool> {
+    None
+}
+
+#[cfg(unix)]
+fn poll_read_ready(fd: i32, timeout_ms: i32) -> Option<bool> {
+    #[repr(C)]
+    struct PollFd {
+        fd: i32,
+        events: i16,
+        revents: i16,
+    }
+
+    unsafe extern "C" {
+        fn poll(fds: *mut PollFd, nfds: usize, timeout: i32) -> i32;
+    }
+
+    const POLLIN: i16 = 0x0001;
+
+    let mut pfd = PollFd {
+        fd,
+        events: POLLIN,
+        revents: 0,
+    };
+
+    let result = unsafe { poll(&mut pfd as *mut PollFd, 1, timeout_ms) };
+    if result < 0 {
+        None
+    } else {
+        Some(result > 0)
+    }
+}
+
+// ---------------------------------------------------------------------------
+// Tests
+// ---------------------------------------------------------------------------
+
+#[cfg(test)]
+mod tests {
+    // The stdin reader thread is hard to unit test since it reads from actual stdin.
+    // Integration tests will verify the full client→server input flow.
+    // Here we test the event type construction.
+
+    use super::*;
+
+    #[test]
+    fn stdin_input_event_carries_raw_bytes() {
+        let data = vec![0x1b, b'[', b'A']; // Up arrow escape sequence
+        let event = ClientLoopEvent::StdinInput(data.clone());
+        match event {
+            ClientLoopEvent::StdinInput(d) => assert_eq!(d, data),
+            _ => panic!("expected StdinInput event"),
+        }
+    }
+}