fix(daemon): refit the shared grid when a client disconnects

The primary client sizes the session, but nothing recomputed that when a
client went away — so killing the primary terminal left the survivor
being rendered at the dead client's size, showing a clipped screen until
it happened to send a resize of its own. Found by driving a real session
through connect/disconnect orderings with two terminals and two browsers
attached at once.

Flag a disconnect like any other resize so the main loop recomputes the
fit and repaints. When the fit turns out unchanged the recompute is a
no-op and the remaining clients just get a fresh frame.

The shared-session test now covers it: a second terminal must not resize
the session, and dropping the primary must hand the fit to the survivor.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01TjGX8SFLLvHLESAw2NDBUs

Author: claude

crates/fresh-editor/src/server/editor_server.rs

@@ -1411,7 +1411,17 @@ impl EditorServer {
         disconnected.sort_unstable();
         disconnected.dedup();
 
-        // Remove disconnected clients
+        // Remove disconnected clients. Losing one changes the shared fit: the
+        // primary terminal sizes the session, so when it goes away the next
+        // client inherits that role and the grid has to be recomputed for it —
+        // otherwise a survivor keeps being rendered at the dead client's size
+        // and shows a clipped screen until it happens to send a resize. Flag it
+        // like any other resize so the main loop refits and repaints; when the
+        // fit turns out unchanged the recompute is a no-op and the clients just
+        // get a fresh frame.
+        if !disconnected.is_empty() {
+            resize_occurred = true;
+        }
         for idx in disconnected.into_iter().rev() {
             let client = self.clients.remove(idx);
             // Clean up --wait tracking if this client was waiting

crates/fresh-editor/src/server/tests.rs

@@ -1808,6 +1808,30 @@ mod integration_tests {
             "both transports write to the same buffer"
         );
 
+        // (5) The primary terminal sizes the session, so when it goes away the
+        //     next client inherits that role and the grid refits to IT. Without
+        //     the refit on disconnect the survivor keeps being rendered at the
+        //     dead client's size and shows a clipped screen until it happens to
+        //     send a resize of its own.
+        let second = ClientConnection::connect(&socket_paths).expect("connect second terminal");
+        let hello = ClientHello::new(TermSize::new(60, 18));
+        second
+            .write_control(&serde_json::to_string(&ClientControl::Hello(hello)).unwrap())
+            .unwrap();
+        drop(second.read_control().unwrap());
+        // A second client is not the primary — it must not resize the session.
+        thread::sleep(Duration::from_millis(300));
+        let still = state_until(port, |v| v["w"].as_u64().is_some());
+        assert_eq!(
+            (still["w"].clone(), still["h"].clone()),
+            (serde_json::json!(80), serde_json::json!(24)),
+            "a non-primary terminal must not resize the shared grid"
+        );
+        // Drop the primary; the survivor's 60x18 becomes the fit.
+        drop(conn);
+        let refitted = state_until(port, |v| v["w"] == 60 && v["h"] == 18);
+        assert_eq!(refitted["h"], 18);
+
         shutdown_handle.store(true, Ordering::SeqCst);
         drop(server_handle.join());
         drop(socket_paths.cleanup());