refactor(terminal): make live-vs-scrollback genuine per-split state

The previous fix made the *rendering* decision per-split but the mode
itself was still tracked by two coupled window/buffer fields that could
only describe one terminal at a time: `Window::terminal_mode: bool` and
`TerminalBuffer::mode` (a per-buffer Live/Scrollback). So only the
focused split could ever be in scrollback — an unfocused split snapped
back to the live grid the moment it lost focus, and two splits on one
terminal could never hold two different scroll positions.

Replace both with a single source of truth: `TerminalBuffer` now owns a
`scrollback_splits: HashSet<LeafId>`. A split showing a terminal is live
iff its LeafId is absent and scrollback iff present. This makes illegal
states unrepresentable:

  - Live has exactly one representation (absence), so no split can be in
    a contradictory live+scrollback state.
  - The set lives on `TerminalBuffer`, so only terminals can carry a
    mode at all.
  - It is keyed per split, so each split's mode is independent and
    survives losing focus.

Everything else derives from it. `Window::terminal_mode` is deleted;
`focused_terminal_live()` is `key_context == Terminal`, which
`sync_terminal_mode_flags` — the single derivation authority — projects
from the set for the focused split (also owning the `editing_disabled`
edge via `sync_terminal_to_buffer`). The ~20 transition sites that used
to hand-maintain the `(mode, terminal_mode, key_context)` trio inline
now just flip the set and re-derive, collapsing into
`enter_terminal_mode()` / `enter_terminal_scrollback()`. Rendering
(`render_terminal_splits`, `resize_visible_terminals`, the orchestration
scrollbar gate) reads the set directly; the renderer is handed the
`scrollback_view_splits` set instead of a window flag.

Lifecycle:
  - Splits close: `forget_split_terminal_modes` prunes the LeafId from
    every terminal (wired into all split-close paths).
  - Process exit: every split showing the dead terminal is moved to
    scrollback (no live grid for a gone PTY).
  - Workspace restore: terminals come back live by default (empty set);
    the read-only → live completion on focus is unchanged.

Behaviour preserved: single-split terminal mode, #2485 (re-focus keeps a
terminal's remembered mode — now per split), #2029 (file-explorer focus
stops PTY routing), and remote reconnect all keep working. New: any
number of splits can sit in independent scrollback while others stream
live, focused or not.

Tests: `test_unfocused_split_retains_scrollback_independently` drives the
new guarantee end-to-end (screen-only asserts); the existing #2595
reproducer still passes. `issue_2029` and `remote_auto_reconnect` tests
updated to the derived accessors. Docs note the per-split behaviour.

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

Author: claude

crates/fresh-editor/src/app/active_focus.rs

@@ -96,10 +96,7 @@ impl Editor {
     /// can re-enable editing, truncate the stale screen tail, and resize the
     /// PTY. No-op otherwise.
     pub(super) fn complete_terminal_mode_side_effects(&mut self) {
-        if self.active_window().terminal_mode
-            && self
-                .active_window()
-                .is_terminal_buffer(self.active_buffer())
+        if self.active_window().focused_terminal_live()
             && self.active_window().is_editing_disabled()
         {
             self.enter_terminal_mode();
@@ -179,34 +176,33 @@ impl Window {
         true
     }
 
-    /// Derive `terminal_mode`/`key_context` from the active buffer's remembered
-    /// mode. The one place the flags follow focus — every focus path routes
-    /// through it, so none can leave a re-focused terminal in the wrong mode
-    /// (issue #2485). The Editor-level finish for entering live mode is
+    /// Project the `key_context` Terminal↔Normal edge from the per-split
+    /// live↔scrollback source of truth for the *focused* split. The one place
+    /// the key context follows focus — every focus path routes through it, so
+    /// none can leave a re-focused terminal in the wrong context (issue #2485).
+    /// The Editor-level finish for entering live mode is
     /// [`Editor::complete_terminal_mode_side_effects`].
     ///
     /// Owns only the Terminal↔Normal edge: while another surface holds focus
-    /// (file explorer, prompt, popup) it manages `terminal_mode` itself, so the
-    /// guard below leaves the flags untouched.
+    /// (file explorer, prompt, popup) `key_context` is one of their values, so
+    /// the guard below leaves it untouched.
     pub(super) fn sync_terminal_mode_flags(&mut self) {
         use crate::input::keybindings::KeyContext;
         if !matches!(self.key_context, KeyContext::Normal | KeyContext::Terminal) {
             return;
         }
         let active = self.active_buffer();
-        if let Some(terminal) = self.terminal_buffer(active) {
-            if terminal.is_live() {
-                self.terminal_mode = true;
-                self.key_context = KeyContext::Terminal;
-            } else {
-                // Refresh the file-backed scrollback view before keys stop
-                // routing to the PTY.
+        let leaf = self.effective_active_split();
+        if self.is_terminal_buffer(active) {
+            if self.split_terminal_scrollback(leaf, active) {
+                // Refresh the file-backed scrollback view (also marks the
+                // buffer read-only) before keys stop routing to the PTY.
                 self.sync_terminal_to_buffer(active);
-                self.terminal_mode = false;
                 self.key_context = KeyContext::Normal;
+            } else {
+                self.key_context = KeyContext::Terminal;
             }
-        } else if self.terminal_mode {
-            self.terminal_mode = false;
+        } else if self.key_context == KeyContext::Terminal {
             self.key_context = KeyContext::Normal;
         }
     }

crates/fresh-editor/src/app/async_dispatch.rs

@@ -732,9 +732,11 @@ impl Editor {
         // Terminal output received - check if we should auto-jump back to terminal mode
         tracing::trace!("Terminal output received for {}", terminal);
 
-        // If viewing scrollback for this terminal and jump_to_end_on_output is enabled,
-        // automatically re-enter terminal mode
-        if self.config.terminal.jump_to_end_on_output && !self.active_window().terminal_mode {
+        // If the focused split is viewing this terminal in scrollback and
+        // jump_to_end_on_output is enabled, snap it back to the live grid.
+        if self.config.terminal.jump_to_end_on_output
+            && !self.active_window().focused_terminal_live()
+        {
             // Check if active buffer is this terminal
             if let Some(active_terminal_id) =
                 self.active_window().get_terminal_id(self.active_buffer())
@@ -745,8 +747,10 @@ impl Editor {
             }
         }
 
-        // When in terminal mode, ensure display stays at bottom (follows new output)
-        if self.active_window().terminal_mode {
+        // When the focused split's terminal is live, keep its grid pinned to the
+        // bottom so it follows new output. (Unfocused live splits follow on their
+        // own — their grid sits at display_offset 0.)
+        if self.active_window().focused_terminal_live() {
             if let Some(handle) = self.active_window().terminal_manager.get(terminal_id) {
                 if let Ok(mut state) = handle.state.lock() {
                     state.scroll_to_bottom();
@@ -986,21 +990,37 @@ impl Editor {
             .iter()
             .find(|(_, tb)| tb.terminal_id == terminal_id)
         {
-            // A genuinely exited terminal becomes a read-only scrollback tab,
-            // so mark it Scrollback — a later focus shows scrollback instead of
-            // trying to drive a dead PTY. A terminal preserved for remote
-            // reconnect keeps its live mode so it comes back live when the
-            // carrier respawns it.
+            // A genuinely exited terminal has no PTY left to drive, so EVERY
+            // split showing it becomes read-only scrollback (not just the
+            // focused one) — otherwise an unfocused split would keep rendering a
+            // "live" grid of a dead terminal. A terminal preserved for remote
+            // reconnect keeps its per-split live state so it comes back live
+            // when the carrier respawns it.
             if !preserve_for_reconnect {
-                self.active_window_mut().set_terminal_interaction_mode(
-                    buffer_id,
-                    crate::app::window::TerminalInteractionMode::Scrollback,
-                );
+                let dead_splits: Vec<crate::model::event::LeafId> = self
+                    .active_window()
+                    .buffers
+                    .splits()
+                    .map(|(_, vs_map)| {
+                        vs_map
+                            .iter()
+                            .filter(|(_, svs)| svs.active_buffer == buffer_id)
+                            .map(|(leaf, _)| *leaf)
+                            .collect()
+                    })
+                    .unwrap_or_default();
+                for leaf in dead_splits {
+                    self.active_window_mut()
+                        .set_split_terminal_scrollback(leaf, buffer_id, true);
+                }
             }
 
-            // Exit terminal mode if this is the active buffer
-            if self.active_buffer() == buffer_id && self.active_window().terminal_mode {
-                self.active_window_mut().terminal_mode = false;
+            // If the focused split was driving this now-dead terminal, leave the
+            // Terminal key context (its derived live state is already false).
+            if self.active_buffer() == buffer_id
+                && self.active_window().key_context
+                    == crate::input::keybindings::KeyContext::Terminal
+            {
                 self.active_window_mut().key_context =
                     crate::input::keybindings::KeyContext::Normal;
             }

crates/fresh-editor/src/app/buffer_close.rs

@@ -232,9 +232,9 @@ impl Editor {
         // The buffer's remembered mode was dropped when its `terminal_buffers`
         // entry was removed by the caller — nothing else to clean up here.
 
-        // Exit terminal mode if we were in it
-        if self.active_window().terminal_mode {
-            self.active_window_mut().terminal_mode = false;
+        // Leave the Terminal key context if we were in it (the terminal buffer
+        // and its per-split scrollback set are gone; nothing left to be live).
+        if self.active_window().key_context == crate::input::keybindings::KeyContext::Terminal {
             self.active_window_mut().key_context = crate::input::keybindings::KeyContext::Normal;
         }
     }
@@ -528,10 +528,10 @@ impl Editor {
     /// All three paths should behave identically; keep new logic here.
     /// Returns true if the tab was closed without needing a prompt.
     pub fn close_tab_in_split(&mut self, buffer_id: BufferId, split_id: LeafId) -> bool {
-        // If closing a terminal buffer while in terminal mode, exit terminal mode
-        if self.active_window().terminal_mode && self.active_window().is_terminal_buffer(buffer_id)
+        // If closing the focused terminal buffer, leave the Terminal key context.
+        if self.active_window().key_context == crate::input::keybindings::KeyContext::Terminal
+            && self.active_window().is_terminal_buffer(buffer_id)
         {
-            self.active_window_mut().terminal_mode = false;
             self.active_window_mut().key_context = crate::input::keybindings::KeyContext::Normal;
         }
 
@@ -900,10 +900,10 @@ impl Editor {
     /// Used internally by batch close operations
     /// Returns true if the tab was closed, false if it was skipped (e.g., modified buffer)
     fn close_tab_in_split_silent(&mut self, buffer_id: BufferId, split_id: LeafId) -> bool {
-        // If closing a terminal buffer while in terminal mode, exit terminal mode
-        if self.active_window().terminal_mode && self.active_window().is_terminal_buffer(buffer_id)
+        // If closing the focused terminal buffer, leave the Terminal key context.
+        if self.active_window().key_context == crate::input::keybindings::KeyContext::Terminal
+            && self.active_window().is_terminal_buffer(buffer_id)
         {
-            self.active_window_mut().terminal_mode = false;
             self.active_window_mut().key_context = crate::input::keybindings::KeyContext::Normal;
         }
 

crates/fresh-editor/src/app/clipboard.rs

@@ -641,7 +641,7 @@ impl Editor {
         // below assumes there's a real buffer view in front of us. If
         // we somehow landed here under one of those modes anyway,
         // hand off to the synchronous service-level paste.
-        if self.active_window().prompt.is_some() || self.active_window().terminal_mode {
+        if self.active_window().prompt.is_some() || self.active_window().focused_terminal_live() {
             if let Some(text) = self.clipboard.paste() {
                 self.paste_text(text);
             }
@@ -1248,8 +1248,8 @@ impl Editor {
             return;
         }
 
-        // If in terminal mode, send paste to the terminal PTY
-        if self.active_window().terminal_mode {
+        // If the focused split is a live terminal, send paste to its PTY
+        if self.active_window().focused_terminal_live() {
             self.active_window_mut()
                 .send_terminal_input(normalized.as_bytes());
             return;

crates/fresh-editor/src/app/file_explorer.rs

@@ -91,14 +91,15 @@ impl Editor {
     /// writing `key_context = FileExplorer` is not enough — if the user
     /// was in a terminal, every keystroke would still be swallowed by
     /// the PTY and the explorer would only *look* focused (issue #2029).
-    /// Clear `terminal_mode`; the terminal keeps its own remembered mode on
-    /// its `TerminalBuffer` record, so re-focusing it later restores it.
+    /// Moving the key context off the editor pane stops PTY routing; the
+    /// terminal keeps its per-split live/scrollback state, so re-focusing it
+    /// later restores it.
     pub(super) fn take_focus_for_file_explorer(&mut self) {
         let win = self.active_window_mut();
-        // Stop routing keys to the PTY while the explorer holds focus. The
-        // terminal keeps its own remembered live/scrollback mode, so
-        // re-focusing it later restores that mode.
-        win.terminal_mode = false;
+        // Stop routing keys to the PTY while the explorer holds focus:
+        // `focused_terminal_live()` is false in any non-editor key context.
+        // The terminal's per-split scrollback set is untouched, so re-focusing
+        // the pane restores each split's live/scrollback state.
         win.key_context = KeyContext::FileExplorer;
     }
 

crates/fresh-editor/src/app/input.rs

@@ -2330,39 +2330,27 @@ impl Editor {
                 self.close_terminal();
             }
             Action::FocusTerminal => {
-                // If viewing a terminal buffer, switch to terminal mode
+                // If viewing a terminal buffer, drop the focused split into live
+                // mode (clears its scrollback edge, re-enables PTY input,
+                // truncates the stale screen tail, resizes).
                 if self
                     .active_window()
                     .is_terminal_buffer(self.active_buffer())
                 {
-                    // Mode change to live: remember it for the next focus.
-                    let active = self.active_buffer();
-                    self.active_window_mut().set_terminal_interaction_mode(
-                        active,
-                        crate::app::window::TerminalInteractionMode::Live,
-                    );
-                    self.active_window_mut().terminal_mode = true;
-                    self.active_window_mut().key_context = KeyContext::Terminal;
+                    self.enter_terminal_mode();
                     self.set_status_message(t!("status.terminal_mode_enabled").to_string());
                 }
             }
             Action::TerminalEscape => {
-                // Exit terminal mode back to editor
-                if self.active_window().terminal_mode {
-                    // User dropped to read-only scrollback: remember that mode.
-                    let active = self.active_buffer();
-                    self.active_window_mut().set_terminal_interaction_mode(
-                        active,
-                        crate::app::window::TerminalInteractionMode::Scrollback,
-                    );
-                    self.active_window_mut().terminal_mode = false;
-                    self.active_window_mut().key_context = KeyContext::Normal;
+                // Drop the focused live terminal split into read-only scrollback.
+                if self.active_window().focused_terminal_live() {
+                    self.enter_terminal_scrollback();
                     self.set_status_message(t!("status.terminal_mode_disabled").to_string());
                 }
             }
             Action::ToggleKeyboardCapture => {
                 // Toggle keyboard capture mode in terminal
-                if self.active_window().terminal_mode {
+                if self.active_window().focused_terminal_live() {
                     self.active_window_mut().keyboard_capture =
                         !self.active_window_mut().keyboard_capture;
                     if self.active_window_mut().keyboard_capture {
@@ -2379,7 +2367,7 @@ impl Editor {
             }
             Action::TerminalPaste => {
                 // Paste clipboard contents into terminal as a single batch
-                if self.active_window().terminal_mode {
+                if self.active_window().focused_terminal_live() {
                     if let Some(text) = self.clipboard.paste() {
                         self.active_window_mut()
                             .send_terminal_input(text.as_bytes());
@@ -3100,9 +3088,8 @@ impl Editor {
             .set_active_split(new_leaf);
 
         // Mirror open_terminal's post-attach bookkeeping. The buffer was
-        // created via `create_terminal_buffer_detached`, so its remembered
-        // mode is already Live.
-        self.active_window_mut().terminal_mode = true;
+        // created via `create_terminal_buffer_detached` (empty scrollback set),
+        // so it is live in this split; focus the terminal pane.
         self.active_window_mut().key_context = crate::input::keybindings::KeyContext::Terminal;
         self.active_window_mut().resize_visible_terminals();