fix(tui): keep session facts in one contiguous stack

Author: 1jehuang

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

@@ -1070,10 +1070,104 @@ mod tests {
             .iter()
             .map(|placement| placement.area.y)
             .collect::<Vec<_>>();
-        assert_eq!(rows, vec![3, 2, 1, 0]);
+        assert_eq!(rows, vec![0, 1, 2, 3]);
         assert!(placements.iter().all(|placement| placement.area.y != 4));
     }
 
+    #[test]
+    fn right_fact_stack_never_leaves_an_occupied_row_between_facts() {
+        let area = Rect::new(0, 0, 40, 7);
+        let mut buffer = ratatui::buffer::Buffer::empty(area);
+        buffer[(39, 4)].set_symbol("x");
+        let lines = ["oauth", "model", "dir", "context"]
+            .into_iter()
+            .map(|text| RightFactLine::new(vec![Span::raw(text)]).expect("fact line"))
+            .collect();
+
+        let placements = right_fact_placements(
+            &buffer,
+            lines,
+            0,
+            7,
+            0,
+            40,
+            Rect::new(0, 0, 40, 5),
+            false,
+            None,
+        );
+        let rows = placements
+            .iter()
+            .map(|placement| placement.area.y)
+            .collect::<Vec<_>>();
+        assert_eq!(rows, vec![0, 1, 2, 3]);
+        assert_eq!(
+            placements
+                .iter()
+                .map(|placement| placement.line.spans[0].content.as_ref())
+                .collect::<Vec<_>>(),
+            vec!["oauth", "model", "dir", "context"]
+        );
+    }
+
+    #[test]
+    fn right_fact_stack_collision_state_space_is_contiguous_or_hidden() {
+        const HEIGHT: u16 = 8;
+        const STACK_HEIGHT: u16 = 4;
+
+        for occupied_mask in 0_u16..(1 << HEIGHT) {
+            let area = Rect::new(0, 0, 40, HEIGHT);
+            let mut buffer = ratatui::buffer::Buffer::empty(area);
+            for row in 0..HEIGHT {
+                if occupied_mask & (1 << row) != 0 {
+                    buffer[(39, row)].set_symbol("x");
+                }
+            }
+            let lines = ["oauth", "model", "dir", "context"]
+                .into_iter()
+                .map(|text| RightFactLine::new(vec![Span::raw(text)]).expect("fact line"))
+                .collect();
+
+            let placements = right_fact_placements(
+                &buffer,
+                lines,
+                0,
+                HEIGHT,
+                0,
+                40,
+                Rect::new(0, 0, 40, HEIGHT),
+                false,
+                None,
+            );
+            let expected_top = (0..=HEIGHT - STACK_HEIGHT).rev().find(|&start| {
+                (start..start + STACK_HEIGHT)
+                    .all(|row| occupied_mask & (1 << row) == 0)
+            });
+
+            match expected_top {
+                Some(start) => {
+                    assert_eq!(placements.len(), STACK_HEIGHT as usize, "mask {occupied_mask:08b}");
+                    assert_eq!(
+                        placements
+                            .iter()
+                            .map(|placement| placement.area.y)
+                            .collect::<Vec<_>>(),
+                        (start..start + STACK_HEIGHT).collect::<Vec<_>>(),
+                        "mask {occupied_mask:08b}"
+                    );
+                    assert_eq!(
+                        placements
+                            .iter()
+                            .map(|placement| placement.line.spans[0].content.as_ref())
+                            .collect::<Vec<_>>(),
+                        vec!["oauth", "model", "dir", "context"],
+                        "mask {occupied_mask:08b}"
+                    );
+                }
+                None => assert!(placements.is_empty(), "mask {occupied_mask:08b}"),
+            }
+        }
+    }
+
     #[test]
     fn right_fact_stack_treats_styled_blank_cells_as_occupied() {
         let area = Rect::new(0, 0, 32, 2);
@@ -2200,10 +2294,7 @@ fn right_fact_lines(app: &dyn TuiState) -> Vec<RightFactLine> {
     if let Some(dir) = app
         .working_dir()
         .and_then(|path| overscroll_dir_label(&path))
-        && let Some(line) = RightFactLine::new(vec![Span::styled(
-            dir,
-            right_fact_neutral_style(),
-        )])
+        && let Some(line) = RightFactLine::new(vec![Span::styled(dir, right_fact_neutral_style())])
     {
         lines.push(line);
     }
@@ -2241,64 +2332,101 @@ fn right_fact_placements(
     transcript_scrollbar_visible: bool,
     protected_position: Option<Position>,
 ) -> Vec<RightFactPlacement> {
-    if top >= bottom || left >= right {
+    if top >= bottom || left >= right || lines.is_empty() {
         return Vec::new();
     }
 
-    let mut placements = Vec::with_capacity(lines.len());
-    let mut next_row = bottom.checked_sub(1);
+    let Ok(block_height) = u16::try_from(lines.len()) else {
+        return Vec::new();
+    };
+    if bottom.saturating_sub(top) < block_height {
+        return Vec::new();
+    }
 
-    for line in lines.into_iter().rev() {
-        let Some(mut row) = next_row else {
-            break;
+    // Facts are one visual object. Probe complete consecutive blocks from the
+    // bottom upward; if any row collides, move the entire stack rather than
+    // skipping that row and letting unrelated content split the facts apart.
+    let mut block_bottom = bottom;
+    loop {
+        let Some(block_top) = block_bottom.checked_sub(block_height) else {
+            return Vec::new();
         };
-        let mut placed = None;
-
-        loop {
-            if row < top {
-                break;
-            }
-            let row_right = if transcript_scrollbar_visible
-                && row >= messages_area.y
-                && row < messages_area.bottom()
-            {
-                right.saturating_sub(1)
-            } else {
-                right
-            };
-
-            let required = line
-                .width
-                .saturating_add(RIGHT_FACT_GAP)
-                .saturating_add(RIGHT_FACT_PAD);
-            if row_right.saturating_sub(left) >= required {
-                let fact_right = row_right.saturating_sub(RIGHT_FACT_PAD);
-                let fact_left = fact_right.saturating_sub(line.width);
-                let probe_left = fact_left.saturating_sub(RIGHT_FACT_GAP);
-                if probe_left >= left
-                    && (probe_left..row_right).all(|x| {
-                        protected_position != Some(Position::new(x, row))
-                            && right_fact_cell_is_blank(&buffer[(x, row)])
-                    })
-                {
-                    placed = Some(Rect::new(fact_left, row, line.width, 1));
-                    break;
-                }
-            }
+        if block_top < top {
+            return Vec::new();
+        }
 
-            let Some(previous) = row.checked_sub(1) else {
-                break;
-            };
-            row = previous;
+        let areas = lines
+            .iter()
+            .enumerate()
+            .map(|(index, line)| {
+                let row = block_top + index as u16;
+                right_fact_area_on_row(
+                    buffer,
+                    line,
+                    row,
+                    left,
+                    right,
+                    messages_area,
+                    transcript_scrollbar_visible,
+                    protected_position,
+                )
+            })
+            .collect::<Option<Vec<_>>>();
+        if let Some(areas) = areas {
+            return lines
+                .into_iter()
+                .zip(areas)
+                .map(|(line, area)| RightFactPlacement { line, area })
+                .collect();
         }
 
-        if let Some(area) = placed {
-            next_row = area.y.checked_sub(1);
-            placements.push(RightFactPlacement { line, area });
+        if block_top == top {
+            return Vec::new();
         }
+        block_bottom = block_bottom.saturating_sub(1);
+    }
+}
+
+fn right_fact_area_on_row(
+    buffer: &ratatui::buffer::Buffer,
+    line: &RightFactLine,
+    row: u16,
+    left: u16,
+    right: u16,
+    messages_area: Rect,
+    transcript_scrollbar_visible: bool,
+    protected_position: Option<Position>,
+) -> Option<Rect> {
+    let row_right = if transcript_scrollbar_visible
+        && row >= messages_area.y
+        && row < messages_area.bottom()
+    {
+        right.saturating_sub(1)
+    } else {
+        right
+    };
+
+    let required = line
+        .width
+        .saturating_add(RIGHT_FACT_GAP)
+        .saturating_add(RIGHT_FACT_PAD);
+    if row_right.saturating_sub(left) < required {
+        return None;
+    }
+
+    let fact_right = row_right.saturating_sub(RIGHT_FACT_PAD);
+    let fact_left = fact_right.saturating_sub(line.width);
+    let probe_left = fact_left.saturating_sub(RIGHT_FACT_GAP);
+    if probe_left < left
+        || !(probe_left..row_right).all(|x| {
+            protected_position != Some(Position::new(x, row))
+                && right_fact_cell_is_blank(&buffer[(x, row)])
+        })
+    {
+        return None;
     }
 
-    placements
+    Some(Rect::new(fact_left, row, line.width, 1))
 }
 
 fn right_fact_cell_is_blank(cell: &ratatui::buffer::Cell) -> bool {

crates/jcode-tui/src/tui/ui_tests/swarm_buffer.rs

@@ -92,6 +92,25 @@ fn row_containing(rows: &[String], needle: &str) -> usize {
         .unwrap_or_else(|| panic!("missing {needle:?} in frame:\n{}", rows.join("\n")))
 }
 
+fn fact_stack_rows(rows: &[String]) -> [usize; 4] {
+    [
+        row_containing(rows, "OpenAI · OAuth"),
+        row_containing(rows, "GPT-5.6-sol high"),
+        row_containing(rows, "~/jcode"),
+        row_containing(rows, "74k/256k"),
+    ]
+}
+
+fn assert_fact_stack_is_contiguous(rows: &[String]) -> [usize; 4] {
+    let positions = fact_stack_rows(rows);
+    assert!(
+        positions.windows(2).all(|pair| pair[1] == pair[0] + 1),
+        "facts must be one uninterrupted OAuth/model/directory/context block:\n{}",
+        rows.join("\n")
+    );
+    positions
+}
+
 #[test]
 fn right_fact_stack_uses_transcript_status_notification_and_input_rows_in_order() {
     let _lock = viewport_snapshot_test_lock();
@@ -104,10 +123,7 @@ fn right_fact_stack_uses_transcript_status_notification_and_input_rows_in_order(
         .expect("fact stack frame");
 
     let rows = buffer_rows(&terminal);
-    let oauth_y = row_containing(&rows, "OpenAI · OAuth");
-    let model_y = row_containing(&rows, "GPT-5.6-sol high");
-    let dir_y = row_containing(&rows, "~/jcode");
-    let context_y = row_containing(&rows, "74k/256k");
+    let [oauth_y, model_y, dir_y, context_y] = assert_fact_stack_is_contiguous(&rows);
     assert!(oauth_y < model_y && model_y < dir_y && dir_y < context_y);
     assert!(rows[context_y].contains("▰▰▱▱▱▱ 29%"));
     assert!(rows[dir_y].contains("next scheduled task in 4m"));
@@ -170,10 +186,7 @@ fn right_fact_stack_shifts_up_when_scheduled_notification_row_is_absent() {
         .expect("fact stack frame without notification");
 
     let rows = buffer_rows(&terminal);
-    let oauth_y = row_containing(&rows, "OpenAI · OAuth");
-    let model_y = row_containing(&rows, "GPT-5.6-sol high");
-    let dir_y = row_containing(&rows, "~/jcode");
-    let context_y = row_containing(&rows, "74k/256k");
+    let [oauth_y, model_y, dir_y, context_y] = assert_fact_stack_is_contiguous(&rows);
     let layout = crate::tui::ui::last_layout_snapshot().expect("layout snapshot");
     let input = layout.input_area.expect("input area");
     let status = crate::tui::ui::last_status_area().expect("status area");
@@ -212,6 +225,7 @@ fn right_fact_stack_leaves_fully_used_input_rows_untouched_and_moves_up() {
             >= 110
     );
     assert!(row_containing(&rows, "74k/256k") < input_area.y as usize);
+    assert_fact_stack_is_contiguous(&rows);
 }
 
 #[test]
@@ -231,7 +245,7 @@ fn right_fact_stack_survives_narrow_widths_without_overwriting_content() {
 }
 
 #[test]
-fn right_fact_stack_does_not_spill_into_a_live_streaming_transcript() {
+fn right_fact_stack_hides_as_a_unit_when_streaming_chrome_cannot_fit_it() {
     let _lock = viewport_snapshot_test_lock();
     clear_flicker_frame_history_for_tests();
     let mut state = fact_test_state(String::new(), true);
@@ -244,22 +258,15 @@ fn right_fact_stack_does_not_spill_into_a_live_streaming_transcript() {
         .expect("streaming fact stack frame");
 
     let rows = buffer_rows(&terminal);
-    let messages_bottom = crate::tui::ui::last_layout_snapshot()
-        .expect("layout snapshot")
-        .messages_area
-        .bottom() as usize;
-    let dir_y = row_containing(&rows, "~/jcode");
-    let context_y = row_containing(&rows, "74k/256k");
     assert!(
-        dir_y >= messages_bottom && context_y >= messages_bottom,
-        "streaming facts must not composite into live transcript rows:\n{}",
+        rows.iter().all(|row| {
+            !row.contains("OpenAI · OAuth")
+                && !row.contains("GPT-5.6-sol high")
+                && !row.contains("74k/256k")
+        }),
+        "the stack must hide completely rather than render a partial block:\n{}",
         rows.join("\n")
     );
-    assert!(rows[..messages_bottom].iter().all(|row| {
-        !row.contains("OpenAI · OAuth")
-            && !row.contains("GPT-5.6-sol high")
-            && !row.contains("74k/256k")
-    }));
 }
 
 #[test]