Lightweight coding agent that runs in your terminal
Rust
Make transcript list spacing uniform after streaming (#46899)
Felipe Coury4ca8e7afff48
diff --git a/codex-rs/tui/src/app/agent_message_consolidation.rs b/codex-rs/tui/src/app/agent_message_consolidation.rsindex dfa3a38ea1..4b8120185d 100644--- a/codex-rs/tui/src/app/agent_message_consolidation.rs+++ b/codex-rs/tui/src/app/agent_message_consolidation.rs@@ -5,7 +5,7 @@//! tail in the bottom pane. Once the answer finishes, the app replaces that//! trailing run with a single source-backed `AgentMarkdownCell`. This makes the//! transcript the canonical owner of the raw markdown source used for future-//! resize re-renders. The retained view remaps its reading position before that+//! resize re-renders. The retained view preserves its displayed revision before that//! replacement, then repaints without replaying terminal scrollback.use std::path::PathBuf;@@ -67,13 +67,24 @@ impl App {);self.native_history.consolidate(&self.transcript_cells[start..end], &consolidated);- self.transcript_view- .replace_range(&self.transcript_cells, start..end, &consolidated);+ if tui.is_owned_screen() {+ self.transcript_view.replace_group(+ &self.transcript_cells,+ start..end,+ &consolidated,+ );+ } else {+ self.transcript_view.replace_range(+ &self.transcript_cells,+ start..end,+ &consolidated,+ );+ }self.transcript_cells.splice(start..end, std::iter::once(consolidated.clone()));if let Some(Overlay::Transcript(t)) = &mut self.overlay {- t.consolidate_cells(start..end, consolidated.clone());+ t.regroup_cells(start..end, consolidated.clone());tui.frame_requester().schedule_frame();}diff --git a/codex-rs/tui/src/app/event_dispatch.rs b/codex-rs/tui/src/app/event_dispatch.rsindex ad2aa6b557..7f1503567d 100644--- a/codex-rs/tui/src/app/event_dispatch.rs+++ b/codex-rs/tui/src/app/event_dispatch.rs@@ -798,12 +798,16 @@ impl App {if start < end {self.native_history.consolidate(&self.transcript_cells[start..end], &consolidated);- self.transcript_view.replace_range(&self.transcript_cells, start..end, &consolidated);+ if tui.is_owned_screen() {+ self.transcript_view.replace_group(&self.transcript_cells, start..end, &consolidated);+ } else {+ self.transcript_view.replace_range(&self.transcript_cells, start..end, &consolidated);+ }self.transcript_cells.splice(start..end, std::iter::once(consolidated.clone()));if let Some(Overlay::Transcript(t)) = &mut self.overlay {- t.consolidate_cells(start..end, consolidated.clone());+ t.regroup_cells(start..end, consolidated.clone());tui.frame_requester().schedule_frame();}diff --git a/codex-rs/tui/src/app/owned_transcript_tests.rs b/codex-rs/tui/src/app/owned_transcript_tests.rsindex 20f8bd69c5..1d3cd14151 100644--- a/codex-rs/tui/src/app/owned_transcript_tests.rs+++ b/codex-rs/tui/src/app/owned_transcript_tests.rs@@ -3,6 +3,7 @@use super::*;use crate::app::tests::make_test_app_with_channels;use crate::app_command::AppCommand;+use crate::app_event::ConsolidationScrollbackReflow;use crate::chatwidget::tests::helpers::normalize_snapshot_paths;use crate::history_cell::HistoryCell;use crate::history_cell::UserHistoryCell;@@ -72,6 +73,52 @@ fn buffer_text(buffer: &Buffer) -> String {.join("\n")}+#[tokio::test]+async fn list_spacing_completion_preserves_the_scrolled_reader() -> Result<()> {+ let mut app = crate::app::test_support::make_test_app().await;+ app.transcript_cells = vec![Arc::new(history_cell::AgentMessageCell::new(+ vec![+ "- First item wraps onto".into(),+ " a second row".into(),+ "- b".into(),+ "- c".into(),+ ],+ /*is_first_line*/ true,+ ))];+ let mut tui = crate::tui::test_support::make_test_tui()?;+ tui.set_owned_screen(/*owned*/ true)?;+ let area = Rect::new(+ /*x*/ 0, /*y*/ 0, /*width*/ 26, /*height*/ 1,+ );+ let mut before = Buffer::empty(area);+ app.transcript_view+ .jump_to_entry(&app.transcript_cells, /*index*/ 0);+ app.transcript_view+ .render(area, &mut before, &app.transcript_cells);+ app.transcript_view+ .scroll(&app.transcript_cells, /*rows*/ 3);+ app.transcript_view+ .render(area, &mut before, &app.transcript_cells);+ assert!(buffer_text(&before).contains("- c"));+ app.handle_consolidate_agent_message(+ &mut tui,+ "- First item wraps onto a second row\n- b\n- c".into(),+ app.config.cwd.to_path_buf(),+ /*inline_visualization_context*/ None,+ ConsolidationScrollbackReflow::Required,+ /*deferred_history_cell*/ None,+ )?;+ let mut after = Buffer::empty(area);+ app.transcript_view+ .render(area, &mut after, &app.transcript_cells);+ assert_eq!(after, before);+ app.transcript_view.jump_to_latest();+ app.transcript_view+ .render(area, &mut after, &app.transcript_cells);+ assert_eq!(after, before);+ Ok(())+}+#[tokio::test]async fn older_page_loading_uses_the_status_row_without_moving_content_or_cursor() -> Result<()> {let mut app = crate::app::test_support::make_test_app().await;diff --git a/codex-rs/tui/src/chatwidget/streaming.rs b/codex-rs/tui/src/chatwidget/streaming.rsindex 3c907a584a..d1d17f8cd5 100644--- a/codex-rs/tui/src/chatwidget/streaming.rs+++ b/codex-rs/tui/src/chatwidget/streaming.rs@@ -4,6 +4,7 @@//! cells, commit ticks, and interrupt deferral.use super::*;+use crate::markdown_render::ListSpacing;fn latest_summary_line(text: &str) -> Option<String> {text.lines().rev().find_map(|line| {@@ -214,11 +215,20 @@ impl ChatWidget {// Before starting a plan stream, flush any active exec cell group.self.flush_unified_exec_wait_streak();self.flush_active_cell();- self.plan_stream_controller = Some(PlanStreamController::new(- self.current_stream_width(/*reserved_cols*/ 4),- &self.config.cwd,- self.history_render_mode(),- ));+ self.plan_stream_controller = Some(+ PlanStreamController::new(+ self.current_stream_width(/*reserved_cols*/ 4),+ &self.config.cwd,+ self.history_render_mode(),+ )+ .with_list_spacing(+ if self.local_settings.transcript_mode.is_owned() {+ ListSpacing::Compact+ } else {+ ListSpacing::AfterMultiline+ },+ ),+ );}let changed = self.plan_stream_controller@@ -572,12 +582,21 @@ impl ChatWidget {thread_id,)});- self.stream_controller = Some(StreamController::new_with_inline_visualizations(- self.current_stream_width(/*reserved_cols*/ 2),- &self.config.cwd,- self.history_render_mode(),- inline_visualization_context,- ));+ self.stream_controller = Some(+ StreamController::new_with_inline_visualizations(+ self.current_stream_width(/*reserved_cols*/ 2),+ &self.config.cwd,+ self.history_render_mode(),+ inline_visualization_context,+ )+ .with_list_spacing(+ if self.local_settings.transcript_mode.is_owned() {+ ListSpacing::Compact+ } else {+ ListSpacing::AfterMultiline+ },+ ),+ );}let changed = self.stream_controllerdiff --git a/codex-rs/tui/src/chatwidget/tests.rs b/codex-rs/tui/src/chatwidget/tests.rsindex d3edcf3133..c8b7d20364 100644--- a/codex-rs/tui/src/chatwidget/tests.rs+++ b/codex-rs/tui/src/chatwidget/tests.rs@@ -314,5 +314,8 @@ pub(super) use helpers::*;#[path = "tests/questions_tests.rs"]mod questions_tests;+#[path = "tests/list_spacing_tests.rs"]+mod list_spacing_tests;+#[path = "tests/question_notifications_tests.rs"]mod question_notifications_tests;diff --git a/codex-rs/tui/src/chatwidget/tests/list_spacing_tests.rs b/codex-rs/tui/src/chatwidget/tests/list_spacing_tests.rsnew file mode 100644index 0000000000..e3df19ed23--- /dev/null+++ b/codex-rs/tui/src/chatwidget/tests/list_spacing_tests.rs@@ -0,0 +1,149 @@+//! Exercise compact streaming and source-backed completion without list-specific holdback.++use super::*;+use crate::local_settings::LocalSettings;+use codex_config::types::AltScreenMode;+use pretty_assertions::assert_eq;++#[tokio::test]+async fn list_spacing_streams_compact_then_reflows_on_completion_or_interruption() {+ let source = "1. One\n2. This item has enough words to wrap\n3. Three\n4. Four";+ let mut stages = Vec::new();+ for (enabled, alternate_screen) in [+ (true, AltScreenMode::Always),+ (false, AltScreenMode::Always),+ (true, AltScreenMode::Never),+ ] {+ for plan in [false, true] {+ for interrupted in [false, true] {+ let (mut chat, mut rx, _ops) =+ make_chatwidget_manual(/*model_override*/ None).await;+ chat.config.tui_fullscreen_transcript = enabled;+ chat.config.tui_alternate_screen = alternate_screen;+ chat.local_settings = LocalSettings::from(&chat.config);+ let owned = chat.local_settings.transcript_mode.is_owned();+ let width = if plan { 28 } else { 26 };+ chat.note_rendered_width(width);+ if plan {+ chat.set_feature_enabled(Feature::CollaborationModes, /*enabled*/ true);+ chat.set_collaboration_mask(CollaborationModeMask {+ name: "Plan".into(),+ mode: Some(ModeKind::Plan),+ model: None,+ reasoning_effort: None,+ developer_instructions: None,+ });+ }+ drain_insert_history(&mut rx);+ let mut live = Vec::new();+ for chunk in source.split_inclusive('\n') {+ let (cell, tail) = if plan {+ chat.on_plan_delta(chunk.into());+ let controller = chat.plan_stream_controller.as_mut().unwrap();+ (+ controller.on_commit_tick_batch(usize::MAX).0,+ controller.current_tail_display_lines(),+ )+ } else {+ chat.on_agent_message_delta(chunk.into());+ let controller = chat.stream_controller.as_mut().unwrap();+ (+ controller.on_commit_tick_batch(usize::MAX).0,+ controller.current_tail_lines(),+ )+ };+ live.extend(+ drain_insert_history_with(&mut rx, |cell| cell.display_lines(width))+ .into_iter()+ .flatten(),+ );+ if let Some(cell) = cell {+ live.extend(cell.display_lines(width));+ }+ if chunk.ends_with('\n') {+ assert!(tail.is_empty(), "completed list rows must not be held back");+ }+ }+ if interrupted {+ chat.flush_answer_and_plan_streams();+ } else if plan {+ chat.on_plan_item_completed(source.into());+ } else {+ chat.finalize_completed_assistant_message(Some(source));+ }+ let mut completed = None;+ while let Ok(event) = rx.try_recv() {+ match event {+ AppEvent::InsertHistoryCell(cell) => live.extend(cell.display_lines(width)),+ AppEvent::ConsolidateAgentMessage {+ source: final_source,+ cwd,+ deferred_history_cell,+ ..+ } => {+ if let Some(cell) = deferred_history_cell {+ live.extend(cell.display_lines(width));+ }+ assert_eq!(final_source.trim_end(), source);+ completed = Some(Box::new(history_cell::AgentMarkdownCell::new(+ final_source,+ &cwd,+ ))+ as Box<dyn HistoryCell>);+ }+ AppEvent::ConsolidateProposedPlan(final_source) => {+ assert_eq!(final_source.trim_end(), source);+ completed = Some(Box::new(history_cell::new_proposed_plan(+ final_source,+ &chat.config.cwd,+ ))+ as Box<dyn HistoryCell>);+ }+ _ => {}+ }+ }+ let completed = completed.expect("termination must retain source for reflow");+ let text = |lines: Vec<Line<'static>>| {+ lines+ .iter()+ .map(|line| line.to_string().trim_end().to_owned())+ .collect::<Vec<_>>()+ .join("\n")+ };+ let render = |width| {+ if owned {+ completed.retained_hyperlink_lines(width, /*detailed*/ false)+ } else {+ completed.display_hyperlink_lines(width)+ }+ };+ let narrow = render(width);+ let native = completed.display_hyperlink_lines(width);+ if owned {+ assert_ne!(native, narrow);+ }+ let wide = render(/*width*/ 100);+ assert_eq!(+ render(width),+ narrow,+ "width and spacing must both key the render cache"+ );+ let live = text(live);+ assert_eq!(live.contains("wrap\n\n"), !owned);+ let stage = format!(+ "owned={owned}, plan={plan}\nStreaming:\n{live}\nCompleted:\n{}\nWide:\n{}",+ text(crate::terminal_hyperlinks::visible_lines(narrow)),+ text(crate::terminal_hyperlinks::visible_lines(wide))+ );+ if enabled && alternate_screen == AltScreenMode::Always {+ if interrupted {+ assert_eq!(stages.last(), Some(&stage));+ } else {+ stages.push(stage);+ }+ }+ }+ }+ }+ insta::assert_snapshot!(stages.join("\n\n---\n\n"));+}diff --git a/codex-rs/tui/src/chatwidget/tests/snapshots/codex_tui__chatwidget__tests__list_spacing_tests__list_spacing_streams_compact_then_reflows_on_completion_or_interruption.snap b/codex-rs/tui/src/chatwidget/tests/snapshots/codex_tui__chatwidget__tests__list_spacing_tests__list_spacing_streams_compact_then_reflows_on_completion_or_interruption.snapnew file mode 100644index 0000000000..f3e5ac41ce--- /dev/null+++ b/codex-rs/tui/src/chatwidget/tests/snapshots/codex_tui__chatwidget__tests__list_spacing_tests__list_spacing_streams_compact_then_reflows_on_completion_or_interruption.snap@@ -0,0 +1,60 @@+---+source: tui/src/chatwidget/tests/list_spacing_tests.rs+expression: "stages.join(\"\\n\\n---\\n\\n\")"+---+owned=true, plan=false+Streaming:+• 1. One+ 2. This item has enough+ words to wrap+ 3. Three+ 4. Four+Completed:+• 1. One++ 2. This item has enough+ words to wrap++ 3. Three++ 4. Four+Wide:+• 1. One+ 2. This item has enough words to wrap+ 3. Three+ 4. Four++---++owned=true, plan=true+Streaming:+• Proposed Plan+++ 1. One+ 2. This item has enough+ words to wrap+ 3. Three+ 4. Four++Completed:+• Proposed Plan+++ 1. One++ 2. This item has enough+ words to wrap++ 3. Three++ 4. Four++Wide:+• Proposed Plan+++ 1. One+ 2. This item has enough words to wrap+ 3. Three+ 4. Fourdiff --git a/codex-rs/tui/src/history_cell/markdown_render_cache.rs b/codex-rs/tui/src/history_cell/markdown_render_cache.rsindex 95e4f6be39..39b1ff7c6f 100644--- a/codex-rs/tui/src/history_cell/markdown_render_cache.rs+++ b/codex-rs/tui/src/history_cell/markdown_render_cache.rs@@ -1,5 +1,6 @@//! Single-width render cache shared by finalized source-backed markdown history cells.+use crate::markdown_render::ListSpacing;use crate::terminal_hyperlinks::HyperlinkLine;use std::sync::Mutex;use std::sync::PoisonError;@@ -12,6 +13,7 @@ pub(super) struct MarkdownRenderCache {#[derive(Clone, Copy, Debug, Eq, PartialEq)]pub(super) struct MarkdownRenderCacheKey {pub(super) width: u16,+ pub(super) list_spacing: ListSpacing,pub(super) syntax_theme_revision: u64,pub(super) terminal_fg: Option<(u8, u8, u8)>,pub(super) terminal_bg: Option<(u8, u8, u8)>,@@ -26,10 +28,12 @@ impl MarkdownRenderCache {pub(super) fn render(&self,width: u16,+ list_spacing: ListSpacing,render: impl FnOnce() -> Vec<HyperlinkLine>,) -> Vec<HyperlinkLine> {let key = MarkdownRenderCacheKey {width,+ list_spacing,syntax_theme_revision: crate::render::highlight::syntax_theme_revision(),terminal_fg: crate::terminal_palette::default_fg(),terminal_bg: crate::terminal_palette::default_bg(),diff --git a/codex-rs/tui/src/history_cell/messages.rs b/codex-rs/tui/src/history_cell/messages.rsindex 3d9e4681f8..1bdc477c0b 100644--- a/codex-rs/tui/src/history_cell/messages.rs+++ b/codex-rs/tui/src/history_cell/messages.rs@@ -572,12 +572,12 @@ fn normalize_whitespace_only_hyperlink_lines(mut lines: Vec<HyperlinkLine>) -> Vlines}-impl HistoryCell for AgentMarkdownCell {- fn display_lines(&self, width: u16) -> Vec<Line<'static>> {- visible_lines(self.display_hyperlink_lines(width))- }-- fn display_hyperlink_lines(&self, width: u16) -> Vec<HyperlinkLine> {+impl AgentMarkdownCell {+ fn render_lines(+ &self,+ width: u16,+ list_spacing: crate::markdown_render::ListSpacing,+ ) -> Vec<HyperlinkLine> {let render = || {let Some(wrap_width) =crate::width::usable_content_width_u16(width, /*reserved_cols*/ 2)@@ -591,11 +591,12 @@ impl HistoryCell for AgentMarkdownCell {// Re-render markdown from source at the current width. Reserve 2 columns for the "• " /// " " prefix prepended below.- let lines = crate::markdown::render_markdown_agent_with_links_cwd_and_visualizations(+ let lines = crate::markdown::render_markdown_agent_with_list_spacing(&self.markdown_source,Some(wrap_width),Some(self.cwd.as_path()),self.inline_visualization_context.as_ref(),+ list_spacing,);let lines = if self.spoken_artifacts {let mut lines = lines;@@ -612,11 +613,25 @@ impl HistoryCell for AgentMarkdownCell {};if let Some(rendered_lines) = &self.rendered_lines {- rendered_lines.render(width, render)+ rendered_lines.render(width, list_spacing, render)} else {render()}}+}++impl HistoryCell for AgentMarkdownCell {+ fn display_lines(&self, width: u16) -> Vec<Line<'static>> {+ visible_lines(self.display_hyperlink_lines(width))+ }++ fn display_hyperlink_lines(&self, width: u16) -> Vec<HyperlinkLine> {+ self.render_lines(width, crate::markdown_render::ListSpacing::AfterMultiline)+ }++ fn retained_hyperlink_lines(&self, width: u16, _detailed: bool) -> Vec<HyperlinkLine> {+ self.render_lines(width, crate::markdown_render::ListSpacing::Uniform)+ }fn transcript_hyperlink_lines(&self, width: u16) -> Vec<HyperlinkLine> {self.display_hyperlink_lines(width)diff --git a/codex-rs/tui/src/history_cell/mod.rs b/codex-rs/tui/src/history_cell/mod.rsindex 92800190dd..5ff39b99c1 100644--- a/codex-rs/tui/src/history_cell/mod.rs+++ b/codex-rs/tui/src/history_cell/mod.rs@@ -235,6 +235,15 @@ pub(crate) trait HistoryCell: std::fmt::Debug + Send + Sync + Any {self.display_hyperlink_lines(width)}+ /// Rich presentation in a viewport that can redraw previously visible rows.+ fn retained_hyperlink_lines(&self, width: u16, detailed: bool) -> Vec<HyperlinkLine> {+ if detailed {+ self.transcript_hyperlink_lines(width)+ } else {+ self.compact_hyperlink_lines(width)+ }+ }+/// Stable, namespaced member identities used to retain disclosure across grouping and replay./// Empty identities indicate ordinary content without a local disclosure control.fn activity_ids(&self) -> Vec<String> {diff --git a/codex-rs/tui/src/history_cell/plans.rs b/codex-rs/tui/src/history_cell/plans.rsindex 8cd272d8ce..7f68f5c7b9 100644--- a/codex-rs/tui/src/history_cell/plans.rs+++ b/codex-rs/tui/src/history_cell/plans.rs@@ -113,13 +113,13 @@ pub(crate) struct ProposedPlanStreamCell {is_stream_continuation: bool,}-impl HistoryCell for ProposedPlanCell {- fn display_lines(&self, width: u16) -> Vec<Line<'static>> {- visible_lines(self.display_hyperlink_lines(width))- }-- fn display_hyperlink_lines(&self, width: u16) -> Vec<HyperlinkLine> {- self.rendered_lines.render(width, || {+impl ProposedPlanCell {+ fn render_lines(+ &self,+ width: u16,+ list_spacing: crate::markdown_render::ListSpacing,+ ) -> Vec<HyperlinkLine> {+ self.rendered_lines.render(width, list_spacing, || {let mut lines = vec![HyperlinkLine::new(vec!["• ".dim(), "Proposed Plan".bold()].into()),HyperlinkLine::new(Line::from(" ")),@@ -128,10 +128,12 @@ impl HistoryCell for ProposedPlanCell {let mut plan_lines = vec![HyperlinkLine::new(Line::from(" "))];let plan_style = proposed_plan_style();let wrap_width = width.saturating_sub(4).max(1) as usize;- let mut body = crate::markdown::render_markdown_agent_with_links_and_cwd(+ let mut body = crate::markdown::render_markdown_agent_with_list_spacing(&self.plan_markdown,Some(wrap_width),Some(self.cwd.as_path()),+ /*inline_visualization_context*/ None,+ list_spacing,);if body.is_empty() {body.push(HyperlinkLine::new(Line::from("(empty)".dim().italic())));@@ -143,6 +145,20 @@ impl HistoryCell for ProposedPlanCell {lines})}+}++impl HistoryCell for ProposedPlanCell {+ fn display_lines(&self, width: u16) -> Vec<Line<'static>> {+ visible_lines(self.display_hyperlink_lines(width))+ }++ fn display_hyperlink_lines(&self, width: u16) -> Vec<HyperlinkLine> {+ self.render_lines(width, crate::markdown_render::ListSpacing::AfterMultiline)+ }++ fn retained_hyperlink_lines(&self, width: u16, _detailed: bool) -> Vec<HyperlinkLine> {+ self.render_lines(width, crate::markdown_render::ListSpacing::Uniform)+ }fn transcript_hyperlink_lines(&self, width: u16) -> Vec<HyperlinkLine> {self.display_hyperlink_lines(width)diff --git a/codex-rs/tui/src/markdown.rs b/codex-rs/tui/src/markdown.rsindex 995f57f917..240cadb538 100644--- a/codex-rs/tui/src/markdown.rs+++ b/codex-rs/tui/src/markdown.rs@@ -31,6 +31,7 @@ use std::sync::Arc;use crate::inline_visualization::InlineVisualizationContext;use crate::inline_visualization::rewrite_inline_visualizations;+use crate::markdown_render::ListSpacing;use crate::table_detect;use crate::terminal_hyperlinks::HyperlinkLine;@@ -73,24 +74,27 @@ pub(crate) fn append_markdown_agent(crate::render::line_utils::push_owned_lines(&rendered.lines, lines);}+#[cfg(test)]pub(crate) fn render_markdown_agent_with_links_and_cwd(markdown_source: &str,width: Option<usize>,cwd: Option<&Path>,) -> Vec<HyperlinkLine> {- render_markdown_agent_with_links_cwd_and_visualizations(+ render_markdown_agent_with_list_spacing(markdown_source,width,cwd,/*inline_visualization_context*/ None,+ ListSpacing::AfterMultiline,)}-pub(crate) fn render_markdown_agent_with_links_cwd_and_visualizations(+pub(crate) fn render_markdown_agent_with_list_spacing(markdown_source: &str,width: Option<usize>,cwd: Option<&Path>,inline_visualization_context: Option<&InlineVisualizationContext>,+ list_spacing: ListSpacing,) -> Vec<HyperlinkLine> {let rewritten = rewrite_inline_visualizations(markdown_source, inline_visualization_context);let normalized = unwrap_markdown_fences(&rewritten.markdown);@@ -103,6 +107,7 @@ pub(crate) fn render_markdown_agent_with_links_cwd_and_visualizations(width,cwd,&is_hidden_link_destination,+ list_spacing,).lines;for hyperlink in lines.iter_mut().flat_map(|line| &mut line.hyperlinks) {@@ -122,6 +127,7 @@ pub(crate) fn render_streaming_markdown_agent_with_links_and_cwd(markdown_source: &str,width: Option<usize>,cwd: Option<&Path>,+ list_spacing: ListSpacing,) -> crate::markdown_render::StreamingMarkdownRender {let normalized = unwrap_markdown_fences(markdown_source);let mut rendered = crate::markdown_render::render_streaming_markdown_lines_with_width_and_cwd(@@ -129,6 +135,7 @@ pub(crate) fn render_streaming_markdown_agent_with_links_and_cwd(width,cwd,&crate::markdown_render::hide_web_link_destination,+ list_spacing,);if normalized != markdown_source {// Fence unwrapping removes opening/closing lines. A normalized tail that is still a rawdiff --git a/codex-rs/tui/src/markdown_render.rs b/codex-rs/tui/src/markdown_render.rsindex b028fa7f2b..3ab4574ef6 100644--- a/codex-rs/tui/src/markdown_render.rs+++ b/codex-rs/tui/src/markdown_render.rs@@ -6,6 +6,8 @@//! `markdown.rs`.//!//! Local file-link parsing and display policy live in [`local_links`].+//! List spacing stays a renderer policy: compact while streaming in an owned viewport, uniform+//! after source-backed consolidation, and historical spacing for native scrollback.//!//! ## Table rendering pipeline//!@@ -72,6 +74,7 @@ use std::path::Path;use std::path::PathBuf;mod file_citations;+mod list_spacing;mod local_links;mod math;mod mermaid;@@ -80,11 +83,16 @@ mod table_key_value;mod web_links;use file_citations::FileCitations;+pub(crate) use list_spacing::ListSpacing;+use list_spacing::UniformList;use local_links::is_local_path_like_link;use local_links::render_local_link_target;use local_links::should_render_local_link_label;pub(crate) use streaming::StreamingMarkdownRender;pub(crate) use streaming::render_streaming_markdown_lines_with_width_and_cwd;+#[cfg(test)]+#[path = "markdown_render/list_spacing_tests.rs"]+mod list_spacing_tests;pub(crate) use web_links::hide_web_link_destination;use web_links::style_bare_web_urls;@@ -403,6 +411,8 @@ wherelist_indices: Vec<Option<u64>>,list_needs_blank_before_next_item: Vec<bool>,list_item_start_line_counts: Vec<usize>,+ list_spacing: ListSpacing,+ uniform_lists: Vec<UniformList>,link: Option<LinkState>,needs_newline: bool,pending_marker_line: bool,@@ -445,6 +455,8 @@ wherelist_indices: Vec::new(),list_needs_blank_before_next_item: Vec::new(),list_item_start_line_counts: Vec::new(),+ list_spacing: ListSpacing::default(),+ uniform_lists: Vec::new(),link: None,needs_newline: false,pending_marker_line: false,@@ -564,6 +576,12 @@ whereTagEnd::Item => {self.flush_current_line();let start_line_count = self.list_item_start_line_counts.pop().unwrap_or_default();+ if let Some(list) = self.uniform_lists.last_mut() {+ let rows = &self.text[start_line_count..];+ list.multiline |= rows.len() > 1+ || (rows.len() == 1+ && self.wrap_width.is_some_and(|width| rows[0].width() > width));+ }if self.text.len().saturating_sub(start_line_count) > 1&& let Some(needs_blank) = self.list_needs_blank_before_next_item.last_mut(){@@ -820,24 +838,45 @@ where}self.list_indices.push(index);self.list_needs_blank_before_next_item.push(false);+ if self.list_spacing == ListSpacing::Uniform {+ self.uniform_lists.push(UniformList::default());+ }}fn end_list(&mut self) {+ self.flush_current_line();+ if let Some(list) = self.uniform_lists.pop() {+ list.finish(&mut self.text);+ }self.list_indices.pop();self.list_needs_blank_before_next_item.pop();self.needs_newline = true;}fn start_item(&mut self) {- if self+ let after_multiline = self.list_needs_blank_before_next_item.last_mut().map(std::mem::take)- .unwrap_or(false)- {+ .unwrap_or(/*default*/ false);+ self.flush_current_line();+ let separate = match self.list_spacing {+ ListSpacing::AfterMultiline => after_multiline,+ ListSpacing::Compact => false,+ ListSpacing::Uniform => self.uniform_lists.last().is_some_and(|list| list.has_item),+ };+ if separate {+ let index = self.text.len();self.push_blank_line();+ if self.text.len() > index+ && let Some(list) = self.uniform_lists.last_mut()+ {+ list.separators.push(index);+ }+ }+ if let Some(list) = self.uniform_lists.last_mut() {+ list.has_item = true;}- self.flush_current_line();self.list_item_start_line_counts.push(self.text.len());self.pending_marker_line = true;let depth = self.list_indices.len();@@ -880,7 +919,14 @@ wherefn start_codeblock(&mut self, lang: Option<String>, indent: Option<Span<'static>>) {self.flush_current_line();- if !self.text.is_empty() {+ let first_item_block = self.pending_marker_line+ && self+ .indent_stack+ .last()+ .is_some_and(|context| context.is_list);+ if !self.text.is_empty()+ && (self.list_spacing == ListSpacing::AfterMultiline || !first_item_block)+ {self.push_blank_line();}self.in_code_block = true;diff --git a/codex-rs/tui/src/markdown_render/list_spacing.rs b/codex-rs/tui/src/markdown_render/list_spacing.rsnew file mode 100644index 0000000000..86d39f2c77--- /dev/null+++ b/codex-rs/tui/src/markdown_render/list_spacing.rs@@ -0,0 +1,44 @@+//! List spacing is a layout policy, not a streaming boundary. Completed redrawable lists use+//! uniform sibling separators; streaming lists stay compact until source-backed consolidation.++use crate::terminal_hyperlinks::HyperlinkLine;++#[derive(Clone, Copy, Debug, Default, Eq, PartialEq)]+pub(crate) enum ListSpacing {+ /// Preserve the historical spacing for terminal-owned scrollback.+ #[default]+ AfterMultiline,+ /// Do not add separators between siblings while an owned transcript streams.+ Compact,+ /// Separate every sibling if any item occupies multiple rendered rows.+ Uniform,+}++#[derive(Default)]+pub(super) struct UniformList {+ pub(super) has_item: bool,+ pub(super) multiline: bool,+ pub(super) separators: Vec<usize>,+}++impl UniformList {+ pub(super) fn finish(self, lines: &mut Vec<HyperlinkLine>) {+ if self.multiline {+ return;+ }+ let mut separators = self.separators.into_iter().peekable();+ let Some(&start) = separators.peek() else {+ return;+ };+ // Only remove this list's provisional separators, preserving source and link metadata.+ let tail = lines.split_off(start);+ lines.extend(tail.into_iter().enumerate().filter_map(|(offset, line)| {+ if separators.peek() == Some(&(start + offset)) {+ separators.next();+ None+ } else {+ Some(line)+ }+ }));+ }+}diff --git a/codex-rs/tui/src/markdown_render/list_spacing_tests.rs b/codex-rs/tui/src/markdown_render/list_spacing_tests.rsnew file mode 100644index 0000000000..a3ffb641e8--- /dev/null+++ b/codex-rs/tui/src/markdown_render/list_spacing_tests.rs@@ -0,0 +1,58 @@+//! Width-aware list policies preserve nested layout, paragraphs, and semantic link metadata.++use super::ListSpacing;+use crate::markdown::render_markdown_agent_with_list_spacing;+use pretty_assertions::assert_eq;++#[test]+fn list_spacing_is_uniform_per_list_and_preserves_item_paragraphs() {+ let sources = [+ "1. One\n2. This item has enough words to wrap\n3. Three\n4. Four",+ "- Parent\n - Short\n - Small\n- Other\n\n> - Quote\n> - This quoted item has enough words to wrap\n> - End",+ "- First paragraph\n\n Second paragraph\n\n- Next\n\n- Last",+ "- One\n- ```text\n code\n ```\n- Three\n\n ```text\n after paragraph\n ```",+ "- https://example.com/a-very-long-path-with-many-segments\n- Short\n- End",+ ];+ let mut stages = Vec::new();+ for source in sources {+ for spacing in [ListSpacing::Compact, ListSpacing::Uniform] {+ let lines = render_markdown_agent_with_list_spacing(+ source,+ Some(24),+ /*cwd*/ None,+ /*inline_visualization_context*/ None,+ spacing,+ );+ stages.push(format!(+ "{spacing:?}:\n{}",+ lines+ .iter()+ .map(|line| line.line.to_string().trim_end().to_owned())+ .collect::<Vec<_>>()+ .join("\n")+ ));+ }+ }+ insta::assert_snapshot!(stages.join("\n\n---\n\n"));+}++#[test]+fn list_spacing_preserves_links_and_source_when_removing_separators() {+ let source = "- [One](https://example.com/one)\n- [Two](https://example.com/two)\n- Three";+ let render = |spacing| {+ render_markdown_agent_with_list_spacing(+ source,+ Some(100),+ /*cwd*/ None,+ /*inline_visualization_context*/ None,+ spacing,+ )+ };+ let compact = render(ListSpacing::Compact);+ let uniform = render(ListSpacing::Uniform);+ assert_eq!(&compact, &uniform);+ assert_eq!(+ compact.iter().map(|line| &line.source).collect::<Vec<_>>(),+ uniform.iter().map(|line| &line.source).collect::<Vec<_>>()+ );+}diff --git a/codex-rs/tui/src/markdown_render/snapshots/codex_tui__markdown_render__list_spacing_tests__list_spacing_is_uniform_per_list_and_preserves_item_paragraphs.snap b/codex-rs/tui/src/markdown_render/snapshots/codex_tui__markdown_render__list_spacing_tests__list_spacing_is_uniform_per_list_and_preserves_item_paragraphs.snapnew file mode 100644index 0000000000..81b875e44e--- /dev/null+++ b/codex-rs/tui/src/markdown_render/snapshots/codex_tui__markdown_render__list_spacing_tests__list_spacing_is_uniform_per_list_and_preserves_item_paragraphs.snap@@ -0,0 +1,109 @@+---+source: tui/src/markdown_render/list_spacing_tests.rs+expression: "stages.join(\"\\n\\n---\\n\\n\")"+---+Compact:+1. One+2. This item has enough+ words to wrap+3. Three+4. Four++---++Uniform:+1. One++2. This item has enough+ words to wrap++3. Three++4. Four++---++Compact:+- Parent+ - Short+ - Small+- Other++> - Quote+> - This quoted item has+> enough words to wrap+> - End++---++Uniform:+- Parent+ - Short+ - Small++- Other++> - Quote+>+> - This quoted item has+> enough words to wrap+>+> - End++---++Compact:+- First paragraph++ Second paragraph+- Next+- Last++---++Uniform:+- First paragraph++ Second paragraph++- Next++- Last++---++Compact:+- One+-+ code+- Three++ after paragraph++---++Uniform:+- One++-+ code++- Three++ after paragraph++---++Compact:+- https://example.com/a-very-long-path-with-many-segments+- Short+- End++---++Uniform:+- https://example.com/a-very-long-path-with-many-segments++- Short++- Enddiff --git a/codex-rs/tui/src/markdown_render/streaming.rs b/codex-rs/tui/src/markdown_render/streaming.rsindex c6978e34ee..3bf0123c08 100644--- a/codex-rs/tui/src/markdown_render/streaming.rs+++ b/codex-rs/tui/src/markdown_render/streaming.rs@@ -7,6 +7,7 @@ use super::DecodedTextMerge;use super::Event;use super::FileCitations;use super::HyperlinkLine;+use super::ListSpacing;use super::Options;use super::Parser;use super::Tag;@@ -40,6 +41,7 @@ pub(crate) fn render_streaming_markdown_lines_with_width_and_cwd(width: Option<usize>,cwd: Option<&Path>,is_hidden_link_destination: &dyn Fn(&str) -> bool,+ list_spacing: ListSpacing,) -> StreamingMarkdownRender {let mut options = Options::empty();options.insert(Options::ENABLE_STRIKETHROUGH);@@ -57,6 +59,7 @@ pub(crate) fn render_streaming_markdown_lines_with_width_and_cwd(mermaid_start: None,};let mut writer = Writer::new(input, parser, width, cwd, is_hidden_link_destination);+ writer.list_spacing = list_spacing;writer.run();StreamingMarkdownRender {lines: writer.text,diff --git a/codex-rs/tui/src/markdown_render/web_links_tests.rs b/codex-rs/tui/src/markdown_render/web_links_tests.rsindex 2657b863a3..7869cc2715 100644--- a/codex-rs/tui/src/markdown_render/web_links_tests.rs+++ b/codex-rs/tui/src/markdown_render/web_links_tests.rs@@ -238,6 +238,7 @@ fn streaming_and_full_render_agree_with_label_only_links() {Some(width),/*cwd*/ None,&|destination| display.hide_destination(destination),+ crate::markdown_render::ListSpacing::AfterMultiline,);assert_eq!(streamed.lines, render(prefix, width, display));}diff --git a/codex-rs/tui/src/resume_picker.rs b/codex-rs/tui/src/resume_picker.rsindex c16433dadc..43778a0857 100644--- a/codex-rs/tui/src/resume_picker.rs+++ b/codex-rs/tui/src/resume_picker.rs@@ -3346,11 +3346,17 @@ fn render_transcript_content_lines(conversation_user_style(),)],TranscriptPreviewSpeaker::Assistant => {- let mut lines = render_assistant(&line.text, /*width*/ None, cwd, &|_| false)- .lines- .into_iter()- .map(|line| line.line)- .collect::<Vec<_>>();+ let mut lines = render_assistant(+ &line.text,+ /*width*/ None,+ cwd,+ &|_| false,+ crate::markdown_render::ListSpacing::AfterMultiline,+ )+ .lines+ .into_iter()+ .map(|line| line.line)+ .collect::<Vec<_>>();for line in &mut lines {*line = conversation_content_line(line.clone(), conversation_assistant_style());}diff --git a/codex-rs/tui/src/streaming/controller.rs b/codex-rs/tui/src/streaming/controller.rsindex d7085ae2b6..660f3e984a 100644--- a/codex-rs/tui/src/streaming/controller.rs+++ b/codex-rs/tui/src/streaming/controller.rs@@ -44,7 +44,8 @@ use crate::history_cell::HistoryCell;use crate::history_cell::HistoryRenderMode;use crate::history_cell::{self};use crate::inline_visualization::InlineVisualizationContext;-use crate::markdown::render_markdown_agent_with_links_cwd_and_visualizations;+use crate::markdown::render_markdown_agent_with_list_spacing;+use crate::markdown_render::ListSpacing;use crate::style::proposed_plan_style;use crate::terminal_hyperlinks::HyperlinkLine;use crate::terminal_hyperlinks::prefix_hyperlink_lines;@@ -59,7 +60,9 @@ use super::StreamState;use super::prose_preview::PreviewMode;use super::prose_preview::ProsePreview;use super::render::StreamingRender;+#[cfg(test)]use super::render::render_source;+use super::render::render_source_with_list_spacing;use super::table_holdback::TableHoldbackScanner;use super::table_holdback::TableHoldbackState;#[cfg(test)]@@ -200,17 +203,18 @@ impl StreamCore {////// This intentionally re-renders from the full raw source instead of/// trying to stitch together queued stable lines and the current tail. The- /// final render is the canonical transcript representation used for- /// consolidation, so callers that skip `reset()` can accidentally replay a- /// finished stream into the next answer.+ /// remaining rows keep the stream's spacing so emitted offsets stay valid. Consolidation+ /// renders the returned source with the completed cell's spacing policy. Callers that skip+ /// `reset()` can accidentally replay a finished stream into the next answer.fn finalize_remaining(&mut self) -> (Vec<HyperlinkLine>, String) {let source = self.state.collector.finalize_and_take_source();- let mut rendered = render_source(+ let mut rendered = render_source_with_list_spacing(&source,self.width,self.cwd.as_path(),self.render_mode,self.inline_visualization_context.as_ref(),+ self.render.list_spacing,);let remaining = rendered.split_off(self.emitted_stable_len.min(rendered.len()));(remaining, source)@@ -383,12 +387,13 @@ impl StreamCore {if let Some(start) = previous_tail_start.or(self.active_tail_source_start(self.render_mode)){let prefix_len = |width, mode| {- render_source(+ render_source_with_list_spacing(&source[..start],width,self.cwd.as_path(),mode,self.inline_visualization_context.as_ref(),+ self.render.list_spacing,).len()};@@ -539,11 +544,12 @@ impl StreamCore {let render_start = Instant::now();let source = self.state.collector.committed_source();- let stable_prefix_render = render_markdown_agent_with_links_cwd_and_visualizations(+ let stable_prefix_render = render_markdown_agent_with_list_spacing(&source[..source_start.min(source.len())],self.width,Some(self.cwd.as_path()),self.inline_visualization_context.as_ref(),+ self.render.list_spacing,);let stable_prefix_len = stable_prefix_render.len();tracing::trace!(@@ -571,6 +577,12 @@ pub(crate) struct StreamController {}impl StreamController {+ /// Select spacing before the first delta; final source-backed cells choose their own layout.+ pub(crate) fn with_list_spacing(mut self, list_spacing: ListSpacing) -> Self {+ self.core.render.list_spacing = list_spacing;+ self+ }+/// Create a controller whose markdown renderer shortens local file links relative to `cwd`.////// `width` is the content width available to markdown rendering, not necessarily the full@@ -697,6 +709,12 @@ pub(crate) struct PlanStreamController {}impl PlanStreamController {+ /// Select spacing before the first delta; no list-specific holdback is needed.+ pub(crate) fn with_list_spacing(mut self, list_spacing: ListSpacing) -> Self {+ self.core.render.list_spacing = list_spacing;+ self+ }+/// Create a plan-stream controller whose markdown renderer shortens local file links relative/// to `cwd`.///diff --git a/codex-rs/tui/src/streaming/inline_math_tests.rs b/codex-rs/tui/src/streaming/inline_math_tests.rsindex 7da430c6f0..bc598985c8 100644--- a/codex-rs/tui/src/streaming/inline_math_tests.rs+++ b/codex-rs/tui/src/streaming/inline_math_tests.rs@@ -27,8 +27,13 @@ fn unicode_math_inline_stream_preserves_display_exclusion_boundaries() {);assert_eq!(render.lines,- render_streaming_markdown_agent_with_links_and_cwd(&source, Some(40), Some(&cwd))- .lines+ render_streaming_markdown_agent_with_links_and_cwd(+ &source,+ Some(40),+ Some(&cwd),+ crate::markdown_render::ListSpacing::AfterMultiline+ )+ .lines);for width in [16, 40] {let mut resized = StreamingRender::new();@@ -44,7 +49,8 @@ fn unicode_math_inline_stream_preserves_display_exclusion_boundaries() {render_streaming_markdown_agent_with_links_and_cwd(&source,Some(width),- Some(&cwd)+ Some(&cwd),+ crate::markdown_render::ListSpacing::AfterMultiline,).lines);diff --git a/codex-rs/tui/src/streaming/math_tests.rs b/codex-rs/tui/src/streaming/math_tests.rsindex 3226278f12..ca4019959f 100644--- a/codex-rs/tui/src/streaming/math_tests.rs+++ b/codex-rs/tui/src/streaming/math_tests.rs@@ -168,6 +168,7 @@ fn unicode_math_rejected_display_keeps_its_closer_and_following_text() {&source,Some(40),Some(&cwd),+ crate::markdown_render::ListSpacing::AfterMultiline,);assert_eq!((&render.lines, render.pending_math_start),diff --git a/codex-rs/tui/src/streaming/render.rs b/codex-rs/tui/src/streaming/render.rsindex 41dab92575..9fa26f7a8f 100644--- a/codex-rs/tui/src/streaming/render.rs+++ b/codex-rs/tui/src/streaming/render.rs@@ -8,8 +8,9 @@ use crate::history_cell::HistoryRenderMode;use crate::history_cell::raw_lines_from_source;use crate::inline_visualization::InlineVisualizationContext;use crate::inline_visualization::contains_inline_visualization;-use crate::markdown::render_markdown_agent_with_links_cwd_and_visualizations;+use crate::markdown::render_markdown_agent_with_list_spacing;use crate::markdown::render_streaming_markdown_agent_with_links_and_cwd;+use crate::markdown_render::ListSpacing;use crate::render::highlight::syntax_theme_revision;use crate::terminal_hyperlinks::HyperlinkLine;use crate::terminal_hyperlinks::plain_hyperlink_lines;@@ -21,6 +22,7 @@ use std::path::Path;/// The prefix before both boundaries is immutable; only the final top-level Markdown block is/// re-rendered as committed source arrives.pub(super) struct StreamingRender {+ pub(super) list_spacing: ListSpacing,pub(super) lines: Vec<HyperlinkLine>,pub(super) pending_math_start: Option<usize>,pub(super) mermaid_start: Option<usize>,@@ -39,6 +41,7 @@ pub(super) struct StreamingRender {impl StreamingRender {pub(super) fn new() -> Self {Self {+ list_spacing: ListSpacing::AfterMultiline,lines: Vec::with_capacity(64),pending_math_start: None,mermaid_start: None,@@ -79,8 +82,12 @@ impl StreamingRender {self.has_inline_visualization_directive = contains_inline_visualization(source);self.lines = match (render_mode, inline_visualization_context) {(HistoryRenderMode::Rich, None) if !self.has_inline_visualization_directive => {- let rendered =- render_streaming_markdown_agent_with_links_and_cwd(source, width, Some(cwd));+ let rendered = render_streaming_markdown_agent_with_links_and_cwd(+ source,+ width,+ Some(cwd),+ self.list_spacing,+ );self.has_reference_link_definition = rendered.has_reference_link_definition;self.pending_math_start = rendered.pending_math_start;self.mermaid_start = rendered.mermaid_start;@@ -93,16 +100,18 @@ impl StreamingRender {source,width,Some(cwd),+ self.list_spacing,);self.pending_math_start = rendered.pending_math_start;self.mermaid_start = rendered.mermaid_start;}- render_source(+ render_source_with_list_spacing(source,width,cwd,render_mode,inline_visualization_context,+ self.list_spacing,)}};@@ -166,8 +175,12 @@ impl StreamingRender {let pending_source = &raw_source[self.stable_source_len..];let theme_revision = syntax_theme_revision();- let pending =- render_streaming_markdown_agent_with_links_and_cwd(pending_source, width, Some(cwd));+ let pending = render_streaming_markdown_agent_with_links_and_cwd(+ pending_source,+ width,+ Some(cwd),+ self.list_spacing,+ );self.pending_math_start = pending.pending_math_start.map(|start| self.stable_source_len + start);@@ -196,12 +209,13 @@ impl StreamingRender {let mut newly_stable_rendered_len = None;if let Some(boundary) = pending.last_top_level_block_start {let newly_stable_source = &pending_source[..boundary];- let newly_stable = render_source(+ let newly_stable = render_source_with_list_spacing(newly_stable_source,width,cwd,render_mode,inline_visualization_context,+ self.list_spacing,);self.stable_source_len += boundary;newly_stable_rendered_len = Some(newly_stable.len());@@ -228,13 +242,32 @@ pub(super) fn render_source(cwd: &Path,render_mode: HistoryRenderMode,inline_visualization_context: Option<&InlineVisualizationContext>,+) -> Vec<HyperlinkLine> {+ render_source_with_list_spacing(+ source,+ width,+ cwd,+ render_mode,+ inline_visualization_context,+ ListSpacing::AfterMultiline,+ )+}++pub(super) fn render_source_with_list_spacing(+ source: &str,+ width: Option<usize>,+ cwd: &Path,+ render_mode: HistoryRenderMode,+ inline_visualization_context: Option<&InlineVisualizationContext>,+ list_spacing: ListSpacing,) -> Vec<HyperlinkLine> {match render_mode {- HistoryRenderMode::Rich => render_markdown_agent_with_links_cwd_and_visualizations(+ HistoryRenderMode::Rich => render_markdown_agent_with_list_spacing(source,width,Some(cwd),inline_visualization_context,+ list_spacing,),HistoryRenderMode::Raw => plain_hyperlink_lines(raw_lines_from_source(source)),}diff --git a/codex-rs/tui/src/streaming/render_tests.rs b/codex-rs/tui/src/streaming/render_tests.rsindex 2a0bbc54a0..255399bc00 100644--- a/codex-rs/tui/src/streaming/render_tests.rs+++ b/codex-rs/tui/src/streaming/render_tests.rs@@ -168,6 +168,7 @@ fn growing_single_top_level_blocks_render_and_scan_in_one_pass() {&source,width,Some(cwd.as_path()),+ crate::markdown_render::ListSpacing::AfterMultiline,);assert_eq!(pending.last_top_level_block_start, None);assert_eq!(render.lines, pending.lines);@@ -200,6 +201,59 @@ fn incremental_raw_render_preserves_blank_lines() {);}+#[test]+fn compact_list_spacing_keeps_incremental_and_full_renders_aligned() {+ use crate::markdown_render::ListSpacing;++ let cwd = test_cwd();+ for mode in [HistoryRenderMode::Rich, HistoryRenderMode::Raw] {+ let mut render = StreamingRender::new();+ render.list_spacing = ListSpacing::Compact;+ let mut source = String::new();+ for chunk in [+ "- Short\n",+ "- A sibling with enough words to wrap across rows\n",+ "- Last\n",+ "\nAfter the list.\n\n",+ "| Name | Value |\n| --- | --- |\n| A | B |\n",+ "\n- Nested\n - One\n - Two\n- End\n",+ ] {+ append(&mut render, &mut source, chunk, Some(24), &cwd, mode);+ assert_eq!(+ render.lines,+ super::render_source_with_list_spacing(+ &source,+ Some(24),+ &cwd,+ mode,+ /*inline_visualization_context*/ None,+ ListSpacing::Compact,+ )+ );+ }+ for width in [80, 24] {+ render.recompute(+ &source,+ Some(width),+ &cwd,+ mode,+ /*inline_visualization_context*/ None,+ );+ assert_eq!(+ render.lines,+ super::render_source_with_list_spacing(+ &source,+ Some(width),+ &cwd,+ mode,+ /*inline_visualization_context*/ None,+ ListSpacing::Compact,+ )+ );+ }+ }+}+#[test]fn inline_visualization_context_without_directives_keeps_stable_prefix() {let cwd = test_cwd();diff --git a/codex-rs/tui/src/transcript_view/layout.rs b/codex-rs/tui/src/transcript_view/layout.rsindex afefd6caef..fe66fb9b91 100644--- a/codex-rs/tui/src/transcript_view/layout.rs+++ b/codex-rs/tui/src/transcript_view/layout.rs@@ -154,10 +154,8 @@ impl TranscriptView {width,expanded,)- } else if detailed {- TextLayout::new(cell.transcript_hyperlink_lines(width), width)- } else if mode == HistoryRenderMode::Rich {- TextLayout::new(cell.compact_hyperlink_lines(width), width)+ } else if detailed || mode == HistoryRenderMode::Rich {+ TextLayout::new(cell.retained_hyperlink_lines(width, detailed), width)} else {TextLayout::new(cell.display_hyperlink_lines_for_mode(width, mode), width)}