preserve scrollback when TUI enters alternate screen

When a TUI app (vim, claude, etc.) enters alternate screen mode, we now
save the main screen content. When getting scrollback while in alternate
screen, we combine both buffers with a separator line.

This means Alt-e in Claude Code now shows:
1. Pre-Claude shell history
2. "--- alternate screen ---"
3. Current Claude Code screen

Author: andrewgazelka

crates/tap-server/src/scrollback.rs

@@ -3,16 +3,26 @@ const DEFAULT_TERMINAL_ROWS: u16 = 24;
 const DEFAULT_TERMINAL_COLS: u16 = 80;
 
 /// A scrollback buffer backed by vt100 terminal emulator.
+///
+/// Handles alternate screen mode properly - when a TUI app enters alternate
+/// screen, we preserve the main screen scrollback and combine it with the
+/// alternate screen content when reading.
 pub struct ScrollbackBuffer {
     parser: Option<vt100::Parser>,
     max_lines: usize,
+    /// Saved main screen content when entering alternate screen mode
+    saved_main_content: Option<String>,
+    /// Track previous alternate screen state to detect transitions
+    was_alternate: bool,
 }
 
 impl ScrollbackBuffer {
     pub const fn new() -> Self {
         Self {
             parser: None,
             max_lines: DEFAULT_SCROLLBACK_LINES,
+            saved_main_content: None,
+            was_alternate: false,
         }
     }
 
@@ -23,7 +33,38 @@ impl ScrollbackBuffer {
     }
 
     pub fn push(&mut self, data: &[u8]) {
+        // Check if we need to save main screen before processing
+        // (in case this data switches to alternate screen)
+        let was_alternate_before = self.parser.as_ref().is_some_and(|p| p.screen().alternate_screen());
+
         self.ensure_parser().process(data);
+
+        let is_alternate_now = self.parser.as_ref().is_some_and(|p| p.screen().alternate_screen());
+
+        // Detect transition from main -> alternate screen
+        if !was_alternate_before && is_alternate_now {
+            // We just entered alternate screen - but the content has already been
+            // replaced. We need to save BEFORE the switch happens.
+            // Unfortunately vt100 doesn't give us a hook for this, so we need to
+            // save content continuously while in main screen mode.
+            tracing::debug!("entered alternate screen mode");
+        }
+
+        // Detect transition from alternate -> main screen
+        if was_alternate_before && !is_alternate_now {
+            // We just exited alternate screen - clear saved content
+            self.saved_main_content = None;
+            tracing::debug!("exited alternate screen mode");
+        }
+
+        // If we're in main screen mode, keep saving content for potential alternate switch
+        if !is_alternate_now {
+            if let Some(parser) = &self.parser {
+                self.saved_main_content = Some(parser.screen().contents());
+            }
+        }
+
+        self.was_alternate = is_alternate_now;
     }
 
     pub fn get_lines(&self, count: Option<usize>) -> String {
@@ -32,7 +73,20 @@ impl ScrollbackBuffer {
         };
 
         let screen = parser.screen();
-        let all_contents = screen.contents();
+        let is_alternate = screen.alternate_screen();
+
+        // If in alternate screen and we have saved main content, combine them
+        let all_contents = if is_alternate {
+            if let Some(saved) = &self.saved_main_content {
+                // Combine: saved main scrollback + current alternate screen
+                let alternate_content = screen.contents();
+                format!("{saved}\n--- alternate screen ---\n{alternate_content}")
+            } else {
+                screen.contents()
+            }
+        } else {
+            screen.contents()
+        };
 
         match count {
             Some(n) => {
@@ -56,6 +110,10 @@ impl ScrollbackBuffer {
         )
     }
 
+    /// Returns true if currently in alternate screen mode
+    pub fn is_alternate_screen(&self) -> bool {
+        self.parser.as_ref().is_some_and(|p| p.screen().alternate_screen())
+    }
 }
 
 #[cfg(test)]
@@ -107,4 +165,35 @@ mod tests {
         assert!(!content.contains("\x1b[31m"));
         assert!(!content.contains("[31m"));
     }
+
+    #[test]
+    fn test_alternate_screen_detection() {
+        let mut buf = ScrollbackBuffer::new();
+        buf.push(b"main screen content");
+        assert!(!buf.is_alternate_screen());
+
+        // Enter alternate screen mode
+        buf.push(b"\x1b[?1049h");
+        assert!(buf.is_alternate_screen());
+
+        // Exit alternate screen mode
+        buf.push(b"\x1b[?1049l");
+        assert!(!buf.is_alternate_screen());
+    }
+
+    #[test]
+    fn test_alternate_screen_preserves_main_content() {
+        let mut buf = ScrollbackBuffer::new();
+        buf.push(b"line1\r\nline2\r\nline3");
+
+        // Enter alternate screen
+        buf.push(b"\x1b[?1049h");
+        buf.push(b"alternate content");
+
+        // Should contain both main and alternate content
+        let content = buf.get_lines(None);
+        assert!(content.contains("line1"));
+        assert!(content.contains("line2"));
+        assert!(content.contains("alternate content"));
+    }
 }