fix(tui): snap input follow to bottom

Author: 1jehuang

crates/jcode-tui/src/tui/app/input.rs

@@ -862,6 +862,14 @@ pub(super) fn insert_input_text(app: &mut App, text: &str) {
         return;
     }
 
+    // Composer insertions should behave the same in local and remote modes.
+    // Unless the user explicitly enabled typing scroll lock, beginning or
+    // continuing a draft resumes tail-follow before the input height can change.
+    // Keeping this at the shared insertion boundary also covers paste and
+    // Shift+Enter, rather than relying on individual key dispatchers to remember
+    // to reconcile the transcript viewport.
+    app.follow_chat_bottom_for_typing();
+
     let at_end = app.cursor_pos == app.input.len();
 
     // A habitual space typed after an auto-inserted picker separator would

crates/jcode-tui/src/tui/app/navigation.rs

@@ -1756,6 +1756,7 @@ impl App {
         self.pending_history_anchor = None;
         self.scroll_offset = 0;
         self.auto_scroll_paused = false;
+        super::super::ui::request_tail_follow_snap();
     }
 
     /// Record an overscroll tick (downward scroll while already pinned to the

crates/jcode-tui/src/tui/app/remote.rs

@@ -1831,7 +1831,6 @@ fn handle_disconnected_key_internal(
 
     if let Some(text) = text_input.or_else(|| input::text_input_for_key(code, modifiers)) {
         input::handle_text_input(app, &text);
-        app.follow_chat_bottom_for_typing();
         return Ok(());
     }
 

crates/jcode-tui/src/tui/app/remote/key_handling.rs

@@ -5,7 +5,6 @@ use crate::tui::core;
 
 pub(in crate::tui::app) fn handle_remote_char_input(app: &mut App, c: char) {
     input::handle_text_input(app, &c.to_string());
-    app.follow_chat_bottom_for_typing();
 }
 
 pub(in crate::tui::app) async fn send_interleave_now(
@@ -782,7 +781,6 @@ async fn handle_remote_key_internal(
 
     if code == KeyCode::Enter && modifiers.intersects(KeyModifiers::SHIFT | KeyModifiers::ALT) {
         input::insert_input_text(app, "\n");
-        app.follow_chat_bottom_for_typing();
         return Ok(());
     }
 
@@ -794,7 +792,6 @@ async fn handle_remote_key_internal(
 
     if let Some(text) = text_input.or_else(|| input::text_input_for_key(code, modifiers)) {
         input::handle_text_input(app, &text);
-        app.follow_chat_bottom_for_typing();
         return Ok(());
     }
 

crates/jcode-tui/src/tui/app/tests/scroll_copy_01/part_01.rs

@@ -665,6 +665,53 @@ fn test_remote_typing_resumes_bottom_follow_mode() {
     );
 }
 
+#[test]
+fn test_local_typing_resumes_bottom_follow_mode() {
+    let mut app = create_test_app();
+    app.scroll_offset = 7;
+    app.auto_scroll_paused = true;
+
+    app.handle_key(KeyCode::Char('x'), KeyModifiers::empty())
+        .unwrap();
+
+    assert_eq!(app.input, "x");
+    assert_eq!(app.cursor_pos, 1);
+    assert_eq!(app.scroll_offset, 0);
+    assert!(
+        !app.auto_scroll_paused,
+        "local typing should follow newest content just like remote typing"
+    );
+}
+
+#[test]
+fn test_local_typing_snaps_rendered_viewport_to_bottom_in_one_frame() {
+    let _lock = scroll_render_test_lock();
+    crate::tui::ui::clear_test_render_state_for_tests();
+
+    let (mut app, mut terminal) = create_scroll_test_app(50, 12, 0, 32);
+    let _ = render_and_snap(&app, &mut terminal);
+    let max_scroll = crate::tui::ui::last_max_scroll();
+    assert!(max_scroll > 8, "expected a long transcript, got {max_scroll}");
+
+    app.auto_scroll_paused = true;
+    app.scroll_offset = max_scroll - 8;
+    let _ = render_and_snap(&app, &mut terminal);
+    assert_eq!(
+        crate::tui::ui::last_resolved_chat_scroll(),
+        max_scroll - 8
+    );
+
+    app.handle_key(KeyCode::Char('x'), KeyModifiers::empty())
+        .unwrap();
+    let _ = render_and_snap(&app, &mut terminal);
+
+    assert_eq!(
+        crate::tui::ui::last_resolved_chat_scroll(),
+        crate::tui::ui::last_max_scroll(),
+        "typing should explicitly snap to the exact transcript tail, not use content catch-up"
+    );
+}
+
 #[test]
 fn test_remote_shift_slash_preserves_layout_translated_slash() {
     let mut app = create_test_app();
@@ -851,6 +898,26 @@ fn test_remote_typing_scroll_lock_preserves_scroll_position() {
     );
 }
 
+#[test]
+fn test_local_typing_scroll_lock_preserves_scroll_position() {
+    let mut app = create_test_app();
+    app.scroll_offset = 7;
+    app.auto_scroll_paused = true;
+
+    app.handle_key(KeyCode::Char('s'), KeyModifiers::ALT)
+        .unwrap();
+    app.handle_key(KeyCode::Char('x'), KeyModifiers::empty())
+        .unwrap();
+
+    assert_eq!(app.input, "x");
+    assert_eq!(app.cursor_pos, 1);
+    assert_eq!(app.scroll_offset, 7);
+    assert!(
+        app.auto_scroll_paused,
+        "typing scroll lock should preserve local paused scroll state"
+    );
+}
+
 #[test]
 fn test_remote_typing_scroll_lock_can_be_toggled_back_off() {
     let mut app = create_test_app();

crates/jcode-tui/src/tui/ui.rs

@@ -200,6 +200,13 @@ static LAST_RESOLVED_CHAT_SCROLL: AtomicUsize = AtomicUsize::new(0);
 #[cfg(not(test))]
 static TAIL_CATCHUP_ACTIVE: std::sync::atomic::AtomicBool =
     std::sync::atomic::AtomicBool::new(false);
+/// Set by explicit user actions that resume bottom-follow (typing, End,
+/// submitting a prompt). The next renderer pass consumes this request and snaps
+/// directly to the tail instead of mistaking the large offset change for a
+/// newly-appended content block that should use catch-up animation.
+#[cfg(not(test))]
+static TAIL_FOLLOW_SNAP_PENDING: std::sync::atomic::AtomicBool =
+    std::sync::atomic::AtomicBool::new(false);
 /// Wrapped line indices where each user prompt starts (updated each render frame).
 /// Used by prompt-jump keybindings (Ctrl+5..9, Ctrl+[/]) for accurate positioning.
 #[cfg(not(test))]
@@ -215,6 +222,7 @@ thread_local! {
     static TEST_LAST_TOTAL_WRAPPED_LINES: Cell<usize> = const { Cell::new(0) };
     static TEST_LAST_RESOLVED_CHAT_SCROLL: Cell<usize> = const { Cell::new(0) };
     static TEST_TAIL_CATCHUP_ACTIVE: Cell<bool> = const { Cell::new(false) };
+    static TEST_TAIL_FOLLOW_SNAP_PENDING: Cell<bool> = const { Cell::new(false) };
     static TEST_LAST_USER_PROMPT_POSITIONS: RefCell<Vec<usize>> = const { RefCell::new(Vec::new()) };
     static TEST_LAST_LAYOUT: RefCell<Option<LayoutSnapshot>> = const { RefCell::new(None) };
     static TEST_LAST_STATUS_AREA: RefCell<Option<Rect>> = const { RefCell::new(None) };
@@ -463,6 +471,34 @@ pub(crate) fn set_tail_catchup_active(active: bool) {
     }
 }
 
+/// Request that the next tail-follow render land at the exact bottom.
+///
+/// This is reserved for explicit navigation or composer actions. Automatic
+/// transcript growth does not set it, so large committed blocks still use the
+/// bounded catch-up animation.
+pub(crate) fn request_tail_follow_snap() {
+    #[cfg(test)]
+    {
+        TEST_TAIL_FOLLOW_SNAP_PENDING.with(|cell| cell.set(true));
+        return;
+    }
+    #[cfg(not(test))]
+    {
+        TAIL_FOLLOW_SNAP_PENDING.store(true, Ordering::Relaxed);
+    }
+}
+
+pub(crate) fn take_tail_follow_snap_request() -> bool {
+    #[cfg(test)]
+    {
+        return TEST_TAIL_FOLLOW_SNAP_PENDING.with(|cell| cell.replace(false));
+    }
+    #[cfg(not(test))]
+    {
+        TAIL_FOLLOW_SNAP_PENDING.swap(false, Ordering::Relaxed)
+    }
+}
+
 pub(super) fn hash_text_for_cache(text: &str) -> u64 {
     let mut hasher = DefaultHasher::new();
     text.hash(&mut hasher);
@@ -1365,6 +1401,7 @@ pub(crate) fn clear_test_render_state_for_tests() {
     set_last_diff_pane_max_scroll(0);
     set_last_total_wrapped_lines(0);
     set_last_resolved_chat_scroll(0);
+    TEST_TAIL_FOLLOW_SNAP_PENDING.with(|cell| cell.set(false));
     update_user_prompt_positions(&[]);
     // Flicker events recorded by sibling tests add a "⚠ flicker detected"
     // notification line to subsequent renders, shifting every layout-sensitive

crates/jcode-tui/src/tui/ui_viewport.rs

@@ -58,6 +58,10 @@ const TAIL_CATCHUP_MAX_STEP: usize = 3;
 /// frame's resolved position by a bounded step so the new content slides into
 /// view. Disabled on tiers without decorative animations.
 fn resolve_tail_follow_scroll(max_scroll: usize, viewport_height: usize) -> usize {
+    if super::take_tail_follow_snap_request() {
+        super::set_tail_catchup_active(false);
+        return max_scroll;
+    }
     if !crate::perf::tui_policy().enable_decorative_animations {
         super::set_tail_catchup_active(false);
         return max_scroll;
@@ -1323,6 +1327,17 @@ mod tests {
         assert!(!crate::tui::ui::tail_catchup_active());
     }
 
+    #[test]
+    fn explicit_tail_follow_request_skips_content_catch_up_animation() {
+        crate::tui::ui::set_last_resolved_chat_scroll(40);
+        crate::tui::ui::request_tail_follow_snap();
+
+        let scroll = super::resolve_tail_follow_scroll(80, 30);
+
+        assert_eq!(scroll, 80);
+        assert!(!crate::tui::ui::tail_catchup_active());
+    }
+
     #[test]
     fn tail_follow_caps_lag_to_one_viewport() {
         // A huge append (way beyond a screen) starts at most one viewport