Skip to content

armgit / codex

Public Imported from GitHub
0

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.rs
index 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.rs
index 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.rs
index 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.rs
index 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_controller
diff --git a/codex-rs/tui/src/chatwidget/tests.rs b/codex-rs/tui/src/chatwidget/tests.rs
index 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.rs
new file mode 100644
index 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.snap
new file mode 100644
index 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. Four
diff --git a/codex-rs/tui/src/history_cell/markdown_render_cache.rs b/codex-rs/tui/src/history_cell/markdown_render_cache.rs
index 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.rs
index 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>) -> V
lines
}
-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.rs
index 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.rs
index 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.rs
index 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 raw
diff --git a/codex-rs/tui/src/markdown_render.rs b/codex-rs/tui/src/markdown_render.rs
index 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 @@ where
list_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 @@ where
list_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 @@ where
TagEnd::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 @@ where
fn 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.rs
new file mode 100644
index 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.rs
new file mode 100644
index 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.snap
new file mode 100644
index 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
+
+- End
diff --git a/codex-rs/tui/src/markdown_render/streaming.rs b/codex-rs/tui/src/markdown_render/streaming.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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)
}