fix (most) doubled lines and hanging list markers (#2789)

This was mostly written by codex under heavy guidance via test cases
drawn from logged session data and fuzzing. It also uncovered some bugs
in tui_markdown, which will in some cases split a list marker from the
list item content. We're not addressing those bugs for now.

codex-rs/tui/src/streaming/controller.rs

@@ -214,3 +214,189 @@ impl StreamController {
         self.finalize(true, sink)
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use codex_core::config::Config;
+    use codex_core::config::ConfigOverrides;
+    use std::cell::RefCell;
+
+    fn test_config() -> Config {
+        let overrides = ConfigOverrides {
+            cwd: std::env::current_dir().ok(),
+            ..Default::default()
+        };
+        match Config::load_with_cli_overrides(vec![], overrides) {
+            Ok(c) => c,
+            Err(e) => panic!("load test config: {e}"),
+        }
+    }
+
+    struct TestSink {
+        pub lines: RefCell<Vec<Vec<Line<'static>>>>,
+    }
+    impl TestSink {
+        fn new() -> Self {
+            Self {
+                lines: RefCell::new(Vec::new()),
+            }
+        }
+    }
+    impl HistorySink for TestSink {
+        fn insert_history(&self, lines: Vec<Line<'static>>) {
+            self.lines.borrow_mut().push(lines);
+        }
+        fn start_commit_animation(&self) {}
+        fn stop_commit_animation(&self) {}
+    }
+
+    fn lines_to_plain_strings(lines: &[ratatui::text::Line<'_>]) -> Vec<String> {
+        lines
+            .iter()
+            .map(|l| {
+                l.spans
+                    .iter()
+                    .map(|s| s.content.clone())
+                    .collect::<Vec<_>>()
+                    .join("")
+            })
+            .collect()
+    }
+
+    #[test]
+    fn controller_loose_vs_tight_with_commit_ticks_matches_full() {
+        let cfg = test_config();
+        let mut ctrl = StreamController::new(cfg.clone());
+        let sink = TestSink::new();
+        ctrl.begin(&sink);
+
+        // Exact deltas from the session log (section: Loose vs. tight list items)
+        let deltas = vec![
+            "\n\n",
+            "Loose",
+            " vs",
+            ".",
+            " tight",
+            " list",
+            " items",
+            ":\n",
+            "1",
+            ".",
+            " Tight",
+            " item",
+            "\n",
+            "2",
+            ".",
+            " Another",
+            " tight",
+            " item",
+            "\n\n",
+            "1",
+            ".",
+            " Loose",
+            " item",
+            " with",
+            " its",
+            " own",
+            " paragraph",
+            ".\n\n",
+            "  ",
+            " This",
+            " paragraph",
+            " belongs",
+            " to",
+            " the",
+            " same",
+            " list",
+            " item",
+            ".\n\n",
+            "2",
+            ".",
+            " Second",
+            " loose",
+            " item",
+            " with",
+            " a",
+            " nested",
+            " list",
+            " after",
+            " a",
+            " blank",
+            " line",
+            ".\n\n",
+            "  ",
+            " -",
+            " Nested",
+            " bullet",
+            " under",
+            " a",
+            " loose",
+            " item",
+            "\n",
+            "  ",
+            " -",
+            " Another",
+            " nested",
+            " bullet",
+            "\n\n",
+        ];
+
+        // Simulate streaming with a commit tick attempt after each delta.
+        for d in &deltas {
+            ctrl.push_and_maybe_commit(d, &sink);
+            let _ = ctrl.on_commit_tick(&sink);
+        }
+        // Finalize and flush remaining lines now.
+        let _ = ctrl.finalize(true, &sink);
+
+        // Flatten sink output and strip the header that the controller inserts (blank + "codex").
+        let mut flat: Vec<ratatui::text::Line<'static>> = Vec::new();
+        for batch in sink.lines.borrow().iter() {
+            for l in batch {
+                flat.push(l.clone());
+            }
+        }
+        // Drop leading blank and header line if present.
+        if !flat.is_empty() && lines_to_plain_strings(&[flat[0].clone()])[0].is_empty() {
+            flat.remove(0);
+        }
+        if !flat.is_empty() {
+            let s0 = lines_to_plain_strings(&[flat[0].clone()])[0].clone();
+            if s0 == "codex" {
+                flat.remove(0);
+            }
+        }
+        let streamed = lines_to_plain_strings(&flat);
+
+        // Full render of the same source
+        let source: String = deltas.iter().copied().collect();
+        let mut rendered: Vec<ratatui::text::Line<'static>> = Vec::new();
+        crate::markdown::append_markdown(&source, &mut rendered, &cfg);
+        let rendered_strs = lines_to_plain_strings(&rendered);
+
+        assert_eq!(streamed, rendered_strs);
+
+        // Also assert exact expected plain strings for clarity.
+        let expected = vec![
+            "Loose vs. tight list items:".to_string(),
+            "".to_string(),
+            "1. ".to_string(),
+            "Tight item".to_string(),
+            "2. ".to_string(),
+            "Another tight item".to_string(),
+            "3. ".to_string(),
+            "Loose item with its own paragraph.".to_string(),
+            "".to_string(),
+            "This paragraph belongs to the same list item.".to_string(),
+            "4. ".to_string(),
+            "Second loose item with a nested list after a blank line.".to_string(),
+            "    - Nested bullet under a loose item".to_string(),
+            "    - Another nested bullet".to_string(),
+        ];
+        assert_eq!(
+            streamed, expected,
+            "expected exact rendered lines for loose/tight section"
+        );
+    }
+}