From 5675499b4cd8e4947bc85e14b3a5bfe6a5ef8f67 Mon Sep 17 00:00:00 2001
From: lr90 <qiuweimin@matrixorigin.cn>
Date: Mon, 26 Oct 2026 17:40:15 +0800
Subject: [PATCH 1/6] fix(tui): keep copied assistant scrollback free of gutter
 glyphs
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Settled assistant replies prefixed every scrollback row with a literal
`█ ` gutter. Terminal selection copies written cells, so commands copied
from a reply came out as `█ git status` and did not run when pasted.

Mark only the first body row with `● ` (same `theme.success` colour) and
indent continuation rows with two plain spaces, matching the first-row
marker convention used by tool cells. Layout width and colours are
unchanged; the live `LiveFramedCell` gutter is out of scope.

Refs #1142

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 crates/astra-cli/src/tui/ARCHITECTURE.md      |  6 +-
 ...idget__turn_driver__canonical_turn_80.snap |  2 +-
 .../src/tui/history_cell/assistant.rs         | 91 ++++++++++++++-----
 ...tant__tests__assistant_inline_code_60.snap |  2 +-
 ...istant__tests__assistant_paragraph_60.snap |  6 +-
 ...ant__tests__assistant_think_closed_60.snap |  2 +-
 crates/astra-cli/src/tui/terminal.rs          |  3 +-
 7 files changed, 77 insertions(+), 35 deletions(-)

diff --git a/crates/astra-cli/src/tui/ARCHITECTURE.md b/crates/astra-cli/src/tui/ARCHITECTURE.md
index d4768fa979..8acccadda3 100644
--- a/crates/astra-cli/src/tui/ARCHITECTURE.md
+++ b/crates/astra-cli/src/tui/ARCHITECTURE.md
@@ -10,8 +10,8 @@
 │                                                                 │
 │  › user message                                                 │  ← UserCell
 │                                                                 │
-│  █ assistant response, streamed word by word, markdown-rendered │  ← AssistantCell
-│  █ with the accent gutter ("█ ") on every wrapped row            │
+│  ● assistant response, streamed word by word, markdown-rendered │  ← AssistantCell
+│    with a first-row marker and plain-space continuation indent  │
 │                                                                 │
 │  • Ran bash (52ms)                                              │  ← ToolCell
 │    │ $ echo hello                                               │
@@ -104,7 +104,7 @@ All cells live in `history_cell/` and implement the `HistoryCell` trait
 | Cell | File | Role |
 |------|------|------|
 | **UserCell** | `user.rs` | `›` accent-bold prefix + user message text |
-| **AssistantCell** | `assistant.rs` | Streaming markdown with `█ ` accent gutter; blinking cursor while live |
+| **AssistantCell** | `assistant.rs` | Streaming markdown; settled body has a `● ` first-row marker and space-indented continuation rows so scrollback copies cleanly; blinking cursor while live |
 | **ReasoningCell** | `reasoning.rs` | `💭 Thinking` header + compact body; committed on `ReasoningDone` or first answer delta |
 | **ToolCell** | `tool.rs` | `• Ran tool (Nms)` header + `│` args + `└` output; diff-aware coloring |
 | **SystemCell** | `system.rs` | info / warning / error; error text is humanized (strips `<tool_use_error>` wrappers) |
diff --git a/crates/astra-cli/src/tui/chat_widget/snapshots/astra__tui__chat_widget__turn_driver__canonical_turn_80.snap b/crates/astra-cli/src/tui/chat_widget/snapshots/astra__tui__chat_widget__turn_driver__canonical_turn_80.snap
index ec3f7a9c97..b9d579dcb2 100644
--- a/crates/astra-cli/src/tui/chat_widget/snapshots/astra__tui__chat_widget__turn_driver__canonical_turn_80.snap
+++ b/crates/astra-cli/src/tui/chat_widget/snapshots/astra__tui__chat_widget__turn_driver__canonical_turn_80.snap
@@ -9,6 +9,6 @@ expression: "render_history(&w, 80)"
   ├ ls /tmp
   └ 3 entries
 
-█ There are 3 files.
+● There are 3 files.
 
   1.2s total · ttft 400ms · 240 tokens · 1 tool
diff --git a/crates/astra-cli/src/tui/history_cell/assistant.rs b/crates/astra-cli/src/tui/history_cell/assistant.rs
index e004786131..8293070258 100644
--- a/crates/astra-cli/src/tui/history_cell/assistant.rs
+++ b/crates/astra-cli/src/tui/history_cell/assistant.rs
@@ -11,12 +11,10 @@
 //! thinking window). One source of truth, one render path. See
 //! `docs/design/tui-refactor.md` §3.3.
 //!
-//! Reply body keeps a stable left accent gutter once settled in
-//! scrollback, so long numbered answers still scan like one unified
-//! assistant block. Live cells still use the active-slot wrapper for
-//! structure, but committed replies retain the visual anchor the old
-//! TUI had. A
-//! active response is kept visually distinct by the surrounding status line;
+//! Settled reply bodies start with a `● ` marker and indent continuation
+//! rows with plain spaces, so text selected from native scrollback copies
+//! as written. Live cells still use the active-slot wrapper for structure.
+//! An active response is kept visually distinct by the surrounding status line;
 //! its content itself stays free of transient transport counters.
 //!
 //! ## Inline thinking handling
@@ -324,16 +322,12 @@ impl AssistantCell {
         }
         let inner_width = (width as usize).saturating_sub(2).max(20);
         let (rendered, total) = self.markdown_layout_window(source, inner_width, start, maximum);
-        let theme = crate::tui::theme::current();
-        // A settled assistant response is a completed unit, so its guide uses
-        // the exact success colour of terminal `●` markers. Live responses
-        // use the distinct focus gutter supplied by `LiveFramedCell`.
-        let gutter_style = Style::default().fg(theme.success);
         let lines = rendered
             .into_iter()
-            .map(|line| {
+            .enumerate()
+            .map(|(offset, line)| {
                 let mut spans = Vec::with_capacity(line.spans.len() + 1);
-                spans.push(Span::styled("█ ", gutter_style));
+                spans.push(settled_body_prefix(start.saturating_add(offset)));
                 spans.extend(line.spans);
                 Line::from(spans)
             })
@@ -560,7 +554,7 @@ impl AssistantCell {
         if source.trim().is_empty() {
             return Vec::new();
         }
-        // Settled cells prepend `█ ` (2 cols) to every line, so wrap text
+        // Settled cells prepend a 2-col prefix to every line, so wrap text
         // at `width - 2` to avoid terminal hard-wrap overflow. Live cells
         // already receive `width - 2` from `active_viewport` (the
         // `LiveFramedCell` wrapper paints its own gutter column). This means
@@ -578,14 +572,13 @@ impl AssistantCell {
             return Vec::new();
         }
 
-        let theme = crate::tui::theme::current();
-        let gutter_style = Style::default().fg(theme.success);
         rendered
             .into_iter()
-            .map(|line| {
+            .enumerate()
+            .map(|(index, line)| {
                 let mut spans: Vec<Span<'static>> = Vec::with_capacity(line.spans.len() + 1);
                 if prepend_gutter {
-                    spans.push(Span::styled("█ ", gutter_style));
+                    spans.push(settled_body_prefix(index));
                 }
                 spans.extend(line.spans.iter().cloned());
                 Line::from(spans)
@@ -594,6 +587,24 @@ impl AssistantCell {
     }
 }
 
+/// Two-column prefix for a settled response body line in native scrollback.
+///
+/// Terminal selection copies every written cell, so a full-height glyph
+/// gutter leaks into commands users copy from a reply. Only the first body
+/// line carries the `● ` terminal marker, in the same success colour as tool
+/// markers; continuation lines use plain spaces that shells ignore. Live
+/// responses keep the distinct focus gutter supplied by `LiveFramedCell`.
+fn settled_body_prefix(body_line: usize) -> Span<'static> {
+    if body_line == 0 {
+        Span::styled(
+            "● ",
+            Style::default().fg(crate::tui::theme::current().success),
+        )
+    } else {
+        Span::raw("  ")
+    }
+}
+
 impl HistoryCell for AssistantCell {
     fn model_item_id(&self) -> Option<&str> {
         self.model_item_id.as_deref()
@@ -1088,15 +1099,40 @@ mod tests {
     }
 
     #[test]
-    fn settled_assistant_guide_matches_terminal_success_marker() {
+    fn settled_assistant_marker_matches_terminal_success_marker() {
         let c = AssistantCell::from_markdown("done");
         let lines = c.display_lines(40);
-        let guide = lines
+        let marker = lines
             .first()
             .and_then(|line| line.spans.first())
-            .expect("settled assistant has a guide");
-        assert_eq!(guide.content.as_ref(), "█ ");
-        assert_eq!(guide.style.fg, Some(crate::tui::theme::current().success));
+            .expect("settled assistant has a marker");
+        assert_eq!(marker.content.as_ref(), "● ");
+        assert_eq!(marker.style.fg, Some(crate::tui::theme::current().success));
+    }
+
+    #[test]
+    fn settled_assistant_command_lines_copy_without_gutter_glyphs() {
+        let c = AssistantCell::from_markdown(
+            "Run these:\n\n```sh\ngit status\ncargo test -p astra\n```\n\nThen `make lint`.",
+        );
+        let (scrollback, _, complete) = c.scrollback_lines_chunk(80, 0, usize::MAX);
+        assert!(complete);
+        for lines in [c.display_lines(80), scrollback] {
+            let text = line_text(&lines);
+            assert_eq!(text.matches('●').count(), 1, "{text}");
+            assert!(!text.contains('█'), "{text}");
+            for command in ["git status", "cargo test -p astra"] {
+                let line = text
+                    .lines()
+                    .find(|line| line.contains(command))
+                    .expect("command line rendered");
+                assert_eq!(
+                    line.trim(),
+                    command,
+                    "selection copies only whitespace: {line:?}"
+                );
+            }
+        }
     }
 
     #[test]
@@ -1145,8 +1181,13 @@ mod tests {
         assert_eq!(second.len(), 3);
         assert_eq!(next, 6);
         assert!(!complete);
-        assert!(first[0].spans[0].content.starts_with("█ "));
-        assert!(second[0].spans[0].content.starts_with("█ "));
+        assert_eq!(first[0].spans[0].content.as_ref(), "● ");
+        assert_eq!(first[1].spans[0].content.as_ref(), "  ");
+        assert_eq!(
+            second[0].spans[0].content.as_ref(),
+            "  ",
+            "a later chunk continues the body instead of restarting the marker"
+        );
     }
 
     #[test]
diff --git a/crates/astra-cli/src/tui/history_cell/snapshots/astra__tui__history_cell__assistant__tests__assistant_inline_code_60.snap b/crates/astra-cli/src/tui/history_cell/snapshots/astra__tui__history_cell__assistant__tests__assistant_inline_code_60.snap
index 0de637cb04..27d8e0750f 100644
--- a/crates/astra-cli/src/tui/history_cell/snapshots/astra__tui__history_cell__assistant__tests__assistant_inline_code_60.snap
+++ b/crates/astra-cli/src/tui/history_cell/snapshots/astra__tui__history_cell__assistant__tests__assistant_inline_code_60.snap
@@ -2,4 +2,4 @@
 source: crates/astra-cli/src/tui/history_cell/assistant.rs
 expression: "render(&c, 60, 2)"
 ---
-█ Use cargo build to compile the project.
+● Use cargo build to compile the project.
diff --git a/crates/astra-cli/src/tui/history_cell/snapshots/astra__tui__history_cell__assistant__tests__assistant_paragraph_60.snap b/crates/astra-cli/src/tui/history_cell/snapshots/astra__tui__history_cell__assistant__tests__assistant_paragraph_60.snap
index 4c7df78546..8abc13db55 100644
--- a/crates/astra-cli/src/tui/history_cell/snapshots/astra__tui__history_cell__assistant__tests__assistant_paragraph_60.snap
+++ b/crates/astra-cli/src/tui/history_cell/snapshots/astra__tui__history_cell__assistant__tests__assistant_paragraph_60.snap
@@ -2,6 +2,6 @@
 source: crates/astra-cli/src/tui/history_cell/assistant.rs
 expression: "render(&c, 60, 5)"
 ---
-█ Here is the plan:
-█ • step one
-█ • step two
+● Here is the plan:
+  • step one
+  • step two
diff --git a/crates/astra-cli/src/tui/history_cell/snapshots/astra__tui__history_cell__assistant__tests__assistant_think_closed_60.snap b/crates/astra-cli/src/tui/history_cell/snapshots/astra__tui__history_cell__assistant__tests__assistant_think_closed_60.snap
index 850f886ace..bb84f026d8 100644
--- a/crates/astra-cli/src/tui/history_cell/snapshots/astra__tui__history_cell__assistant__tests__assistant_think_closed_60.snap
+++ b/crates/astra-cli/src/tui/history_cell/snapshots/astra__tui__history_cell__assistant__tests__assistant_think_closed_60.snap
@@ -3,4 +3,4 @@ source: crates/astra-cli/src/tui/history_cell/assistant.rs
 expression: "render(&c, 60, 3)"
 ---
 ● Thought · 2 lines · 14 tokens
-█ Hello — happy to help.
+● Hello — happy to help.
diff --git a/crates/astra-cli/src/tui/terminal.rs b/crates/astra-cli/src/tui/terminal.rs
index b696017f25..5ab3dff9a0 100644
--- a/crates/astra-cli/src/tui/terminal.rs
+++ b/crates/astra-cli/src/tui/terminal.rs
@@ -827,7 +827,8 @@ mod tests {
         let (first, _) = take_pending_history_batch(&mut pending);
         assert_eq!(first.len(), MAX_HISTORY_LINES_PER_DRAW);
         assert!(!pending.is_empty(), "long reply tail remains queued");
-        assert!(first.iter().all(|line| line.spans[0].content == "█ "));
+        assert_eq!(first[0].spans[0].content, "● ");
+        assert!(first[1..].iter().all(|line| line.spans[0].content == "  "));
 
         let mut emitted = first;
         while !pending.is_empty() {

From 6518d32f651cb8a2ba49927b4edb3ec7c643401e Mon Sep 17 00:00:00 2001
From: lr90 <qiuweimin@matrixorigin.cn>
Date: Mon, 26 Oct 2026 20:08:27 +0800
Subject: [PATCH 2/6] fix(tui): copy settled code blocks verbatim from
 scrollback
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

The two-space continuation prefix still leaked into copied code: a
heredoc terminator became `  EOF` and no longer closed the heredoc, and
indentation-sensitive code gained an extra indent.

The Markdown renderer now marks code-block rows as verbatim, and settled
assistant replies write those rows at column 0 without any prefix, so a
selected block matches its source exactly. Prose rows keep the `● `
first-row marker and two-space indent. Tests compare the whole copied
block instead of trimmed rows.

Refs #1142

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 .../src/tui/history_cell/assistant.rs         | 108 +++++++++---------
 crates/astra-cli/src/tui/markdown_render.rs   |  44 ++++++-
 crates/astra-cli/src/tui/tests.rs             |  30 +++++
 3 files changed, 128 insertions(+), 54 deletions(-)

diff --git a/crates/astra-cli/src/tui/history_cell/assistant.rs b/crates/astra-cli/src/tui/history_cell/assistant.rs
index 8293070258..2e95af2021 100644
--- a/crates/astra-cli/src/tui/history_cell/assistant.rs
+++ b/crates/astra-cli/src/tui/history_cell/assistant.rs
@@ -12,8 +12,9 @@
 //! `docs/design/tui-refactor.md` §3.3.
 //!
 //! Settled reply bodies start with a `● ` marker and indent continuation
-//! rows with plain spaces, so text selected from native scrollback copies
-//! as written. Live cells still use the active-slot wrapper for structure.
+//! prose rows with plain spaces; code-block rows stay verbatim at column 0,
+//! so a block selected from native scrollback copies exactly as written.
+//! Live cells still use the active-slot wrapper for structure.
 //! An active response is kept visually distinct by the surrounding status line;
 //! its content itself stays free of transient transport counters.
 //!
@@ -44,7 +45,9 @@ use ratatui::style::{Modifier, Style};
 use ratatui::text::{Line, Span};
 
 use super::HistoryCell;
-use crate::tui::markdown_render::render_markdown_text_with_width;
+use crate::tui::markdown_render::{
+    MarkdownRow, render_markdown_rows_with_width, render_markdown_text_with_width,
+};
 use crate::tui::render::line_utils::line_to_static;
 use crate::tui::turn_event::TurnEvent;
 
@@ -61,7 +64,7 @@ struct MarkdownLayoutCache {
     /// without retaining a second full copy merely for cache matching.
     source_ptr: usize,
     source_len: usize,
-    lines: Vec<Line<'static>>,
+    rows: Vec<MarkdownRow>,
 }
 
 /// Bounded live Markdown projection. It intentionally lags a burst by a
@@ -268,17 +271,13 @@ impl AssistantCell {
             return;
         }
 
-        let lines = render_markdown_text_with_width(source, Some(width))
-            .lines
-            .iter()
-            .map(line_to_static)
-            .collect::<Vec<_>>();
+        let rows = render_markdown_rows_with_width(source, Some(width));
         *cache = Some(MarkdownLayoutCache {
             revision: self.render_revision,
             width,
             source_ptr: source.as_ptr() as usize,
             source_len: source.len(),
-            lines,
+            rows,
         });
     }
 
@@ -288,7 +287,7 @@ impl AssistantCell {
         width: usize,
         start: usize,
         maximum: usize,
-    ) -> (Vec<Line<'static>>, usize) {
+    ) -> (Vec<MarkdownRow>, usize) {
         self.ensure_markdown_layout(source, width);
         let cache = astra_core::sync_poison::recover_mutex_lock(&self.render_cache);
         let cache = cache
@@ -300,13 +299,13 @@ impl AssistantCell {
             width,
             self.render_revision
         ));
-        let total = cache.lines.len();
+        let total = cache.rows.len();
         let start = start.min(total);
         let end = start.saturating_add(maximum).min(total);
-        (cache.lines[start..end].to_vec(), total)
+        (cache.rows[start..end].to_vec(), total)
     }
 
-    fn markdown_layout(&self, source: &str, width: usize) -> Vec<Line<'static>> {
+    fn markdown_layout(&self, source: &str, width: usize) -> Vec<MarkdownRow> {
         self.markdown_layout_window(source, width, 0, usize::MAX).0
     }
 
@@ -325,12 +324,7 @@ impl AssistantCell {
         let lines = rendered
             .into_iter()
             .enumerate()
-            .map(|(offset, line)| {
-                let mut spans = Vec::with_capacity(line.spans.len() + 1);
-                spans.push(settled_body_prefix(start.saturating_add(offset)));
-                spans.extend(line.spans);
-                Line::from(spans)
-            })
+            .map(|(offset, row)| prefix_settled_row(start.saturating_add(offset), row))
             .collect();
         (lines, total)
     }
@@ -575,34 +569,42 @@ impl AssistantCell {
         rendered
             .into_iter()
             .enumerate()
-            .map(|(index, line)| {
-                let mut spans: Vec<Span<'static>> = Vec::with_capacity(line.spans.len() + 1);
+            .map(|(index, row)| {
                 if prepend_gutter {
-                    spans.push(settled_body_prefix(index));
+                    prefix_settled_row(index, row)
+                } else {
+                    row.line
                 }
-                spans.extend(line.spans.iter().cloned());
-                Line::from(spans)
             })
             .collect()
     }
 }
 
-/// Two-column prefix for a settled response body line in native scrollback.
+/// Prefix a settled response body row for native scrollback.
 ///
-/// Terminal selection copies every written cell, so a full-height glyph
-/// gutter leaks into commands users copy from a reply. Only the first body
-/// line carries the `● ` terminal marker, in the same success colour as tool
-/// markers; continuation lines use plain spaces that shells ignore. Live
-/// responses keep the distinct focus gutter supplied by `LiveFramedCell`.
-fn settled_body_prefix(body_line: usize) -> Span<'static> {
-    if body_line == 0 {
+/// Terminal selection copies every written cell, so any prefix leaks into
+/// text users copy from a reply. Code-block rows are therefore written
+/// verbatim at column 0: a copied block (a heredoc, indentation-sensitive
+/// code) matches its source exactly. Other rows get a 2-col prefix: the first
+/// body row carries the `● ` terminal marker, in the same success colour as
+/// tool markers, and the rest are indented with plain spaces. Live responses
+/// keep the distinct focus gutter supplied by `LiveFramedCell`.
+fn prefix_settled_row(body_row: usize, row: MarkdownRow) -> Line<'static> {
+    if row.verbatim {
+        return row.line;
+    }
+    let prefix = if body_row == 0 {
         Span::styled(
             "● ",
             Style::default().fg(crate::tui::theme::current().success),
         )
     } else {
         Span::raw("  ")
-    }
+    };
+    let mut spans = Vec::with_capacity(row.line.spans.len() + 1);
+    spans.push(prefix);
+    spans.extend(row.line.spans);
+    Line::from(spans)
 }
 
 impl HistoryCell for AssistantCell {
@@ -1111,26 +1113,26 @@ mod tests {
     }
 
     #[test]
-    fn settled_assistant_command_lines_copy_without_gutter_glyphs() {
-        let c = AssistantCell::from_markdown(
-            "Run these:\n\n```sh\ngit status\ncargo test -p astra\n```\n\nThen `make lint`.",
-        );
-        let (scrollback, _, complete) = c.scrollback_lines_chunk(80, 0, usize::MAX);
-        assert!(complete);
-        for lines in [c.display_lines(80), scrollback] {
-            let text = line_text(&lines);
-            assert_eq!(text.matches('●').count(), 1, "{text}");
-            assert!(!text.contains('█'), "{text}");
-            for command in ["git status", "cargo test -p astra"] {
-                let line = text
-                    .lines()
-                    .find(|line| line.contains(command))
-                    .expect("command line rendered");
-                assert_eq!(
-                    line.trim(),
-                    command,
-                    "selection copies only whitespace: {line:?}"
+    fn settled_code_blocks_copy_verbatim_from_scrollback() {
+        // A heredoc terminator and indentation only survive a copy when the
+        // selected rows match the source exactly, so compare the whole block
+        // rather than trimmed rows.
+        let block = "cat <<'EOF'\n  indented\nEOF\ngit status";
+        for source in [
+            format!("Run these:\n\n```\n{block}\n```\n\nThen `make lint`."),
+            format!("```\n{block}\n```"),
+        ] {
+            let c = AssistantCell::from_markdown(source.clone());
+            let (scrollback, _, complete) = c.scrollback_lines_chunk(80, 0, usize::MAX);
+            assert!(complete);
+            for lines in [c.display_lines(80), scrollback] {
+                let text = line_text(&lines);
+                assert!(
+                    text.contains(&format!("\n{block}\n")) || text.ends_with(&format!("\n{block}")),
+                    "{source:?} rendered {text:?}"
                 );
+                assert_eq!(text.matches('●').count(), 1, "{text}");
+                assert!(!text.contains('█'), "{text}");
             }
         }
     }
diff --git a/crates/astra-cli/src/tui/markdown_render.rs b/crates/astra-cli/src/tui/markdown_render.rs
index c43c34b33d..a8e573b817 100644
--- a/crates/astra-cli/src/tui/markdown_render.rs
+++ b/crates/astra-cli/src/tui/markdown_render.rs
@@ -47,6 +47,27 @@ pub(crate) fn render_markdown_text_with_width_and_cwd(
     width: Option<usize>,
     cwd: Option<&Path>,
 ) -> Text<'static> {
+    write_markdown(input, width, cwd).into_text()
+}
+
+/// One rendered Markdown row. `verbatim` marks rows that reproduce
+/// code-block source as written; callers that decorate rows must leave
+/// these untouched so terminal selection copies the source exactly.
+#[derive(Debug, Clone)]
+pub(crate) struct MarkdownRow {
+    pub line: Line<'static>,
+    pub verbatim: bool,
+}
+
+pub(crate) fn render_markdown_rows_with_width(
+    input: &str,
+    width: Option<usize>,
+) -> Vec<MarkdownRow> {
+    let cwd = std::env::current_dir().ok();
+    write_markdown(input, width, cwd.as_deref()).into_rows()
+}
+
+fn write_markdown(input: &str, width: Option<usize>, cwd: Option<&Path>) -> Writer {
     let mut options = Options::empty();
     options.insert(Options::ENABLE_STRIKETHROUGH);
     options.insert(Options::ENABLE_TABLES);
@@ -54,7 +75,7 @@ pub(crate) fn render_markdown_text_with_width_and_cwd(
     let mut writer = Writer::new(width, cwd.map(Path::to_path_buf));
     writer.styles = MarkdownStyles::from_theme();
     writer.run(parser);
-    writer.into_text()
+    writer
 }
 
 struct Writer {
@@ -64,6 +85,8 @@ struct Writer {
     style_stack: Vec<Style>,
     in_code_block: Option<String>,
     code_block_content: String,
+    /// Row ranges in `lines` that hold code-block source verbatim.
+    code_rows: Vec<std::ops::Range<usize>>,
     list_stack: Vec<Option<u64>>,
     in_heading: Option<HeadingLevel>,
     in_blockquote: bool,
@@ -114,6 +137,7 @@ impl Writer {
             style_stack: vec![Style::default()],
             in_code_block: None,
             code_block_content: String::new(),
+            code_rows: Vec::new(),
             list_stack: Vec::new(),
             in_heading: None,
             in_blockquote: false,
@@ -326,9 +350,11 @@ impl Writer {
         };
 
         self.lines.push(Line::default());
+        let code_start = self.lines.len();
         for line in highlighted {
             self.lines.push(line_to_static(&line));
         }
+        self.code_rows.push(code_start..self.lines.len());
         self.lines.push(Line::default());
     }
 
@@ -578,6 +604,22 @@ impl Writer {
         }
         Text::from(self.lines)
     }
+
+    fn into_rows(mut self) -> Vec<MarkdownRow> {
+        let code_rows = std::mem::take(&mut self.code_rows);
+        let lines = self.into_text().lines;
+        let mut verbatim = vec![false; lines.len()];
+        for row in code_rows.into_iter().flatten() {
+            if let Some(flag) = verbatim.get_mut(row) {
+                *flag = true;
+            }
+        }
+        lines
+            .into_iter()
+            .zip(verbatim)
+            .map(|(line, verbatim)| MarkdownRow { line, verbatim })
+            .collect()
+    }
 }
 
 fn border_line(col_widths: &[usize], left: char, mid: char, right: char) -> Line<'static> {
diff --git a/crates/astra-cli/src/tui/tests.rs b/crates/astra-cli/src/tui/tests.rs
index 6f3261977a..3e7fce9dd0 100644
--- a/crates/astra-cli/src/tui/tests.rs
+++ b/crates/astra-cli/src/tui/tests.rs
@@ -296,6 +296,36 @@ mod markdown_tests {
         );
     }
 
+    #[test]
+    fn code_block_rows_are_marked_verbatim() {
+        use crate::tui::markdown_render::render_markdown_rows_with_width;
+        let rows =
+            render_markdown_rows_with_width("Intro\n\n```\nEOF\n\n  x\n```\n\nOutro", Some(80));
+        let flagged: Vec<(String, bool)> = rows
+            .iter()
+            .map(|row| {
+                let text = row.line.spans.iter().map(|s| s.content.as_ref()).collect();
+                (text, row.verbatim)
+            })
+            .collect();
+        let verbatim: Vec<&str> = flagged
+            .iter()
+            .filter(|(_, verbatim)| *verbatim)
+            .map(|(text, _)| text.as_str())
+            .collect();
+        assert_eq!(verbatim, ["EOF", "", "  x"], "{flagged:?}");
+        assert!(
+            flagged
+                .iter()
+                .any(|(text, verbatim)| text == "Intro" && !verbatim)
+        );
+        assert!(
+            flagged
+                .iter()
+                .any(|(text, verbatim)| text == "Outro" && !verbatim)
+        );
+    }
+
     #[test]
     #[ignore = "compiles Oniguruma patterns on first use; run manually with -- --ignored"]
     fn renders_highlighted_code_block() {

From 76e0bbc9e2bfd9e11a3490c06c62fa4a0a27a00f Mon Sep 17 00:00:00 2001
From: lr90 <qiuweimin@matrixorigin.cn>
Date: Mon, 26 Oct 2026 20:51:48 +0800
Subject: [PATCH 3/6] fix(tui): drop the first-row marker from settled
 assistant replies
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

A reply that is a single command still rendered as `● git status`, so
copying that row included the marker. Settled prose rows now carry only
a two-space indent and no glyph; code-block rows stay verbatim. Reply
boundaries remain visible through the surrounding user, tool, and turn
summary rows.

Closes #1142

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 crates/astra-cli/src/tui/ARCHITECTURE.md      |  6 +-
 ...idget__turn_driver__canonical_turn_80.snap |  2 +-
 .../src/tui/history_cell/assistant.rs         | 75 ++++++++-----------
 ...tant__tests__assistant_inline_code_60.snap |  2 +-
 ...istant__tests__assistant_paragraph_60.snap |  2 +-
 ...ant__tests__assistant_think_closed_60.snap |  2 +-
 crates/astra-cli/src/tui/terminal.rs          |  3 +-
 7 files changed, 39 insertions(+), 53 deletions(-)

diff --git a/crates/astra-cli/src/tui/ARCHITECTURE.md b/crates/astra-cli/src/tui/ARCHITECTURE.md
index 8acccadda3..a31a1b9534 100644
--- a/crates/astra-cli/src/tui/ARCHITECTURE.md
+++ b/crates/astra-cli/src/tui/ARCHITECTURE.md
@@ -10,8 +10,8 @@
 │                                                                 │
 │  › user message                                                 │  ← UserCell
 │                                                                 │
-│  ● assistant response, streamed word by word, markdown-rendered │  ← AssistantCell
-│    with a first-row marker and plain-space continuation indent  │
+│    assistant response, streamed word by word, markdown-rendered │  ← AssistantCell
+│    prose indented with plain spaces; code blocks verbatim       │
 │                                                                 │
 │  • Ran bash (52ms)                                              │  ← ToolCell
 │    │ $ echo hello                                               │
@@ -104,7 +104,7 @@ All cells live in `history_cell/` and implement the `HistoryCell` trait
 | Cell | File | Role |
 |------|------|------|
 | **UserCell** | `user.rs` | `›` accent-bold prefix + user message text |
-| **AssistantCell** | `assistant.rs` | Streaming markdown; settled body has a `● ` first-row marker and space-indented continuation rows so scrollback copies cleanly; blinking cursor while live |
+| **AssistantCell** | `assistant.rs` | Streaming markdown; settled prose rows are space-indented with no glyph marker and code-block rows are written verbatim, so scrollback copies cleanly; blinking cursor while live |
 | **ReasoningCell** | `reasoning.rs` | `💭 Thinking` header + compact body; committed on `ReasoningDone` or first answer delta |
 | **ToolCell** | `tool.rs` | `• Ran tool (Nms)` header + `│` args + `└` output; diff-aware coloring |
 | **SystemCell** | `system.rs` | info / warning / error; error text is humanized (strips `<tool_use_error>` wrappers) |
diff --git a/crates/astra-cli/src/tui/chat_widget/snapshots/astra__tui__chat_widget__turn_driver__canonical_turn_80.snap b/crates/astra-cli/src/tui/chat_widget/snapshots/astra__tui__chat_widget__turn_driver__canonical_turn_80.snap
index b9d579dcb2..6505da73a6 100644
--- a/crates/astra-cli/src/tui/chat_widget/snapshots/astra__tui__chat_widget__turn_driver__canonical_turn_80.snap
+++ b/crates/astra-cli/src/tui/chat_widget/snapshots/astra__tui__chat_widget__turn_driver__canonical_turn_80.snap
@@ -9,6 +9,6 @@ expression: "render_history(&w, 80)"
   ├ ls /tmp
   └ 3 entries
 
-● There are 3 files.
+  There are 3 files.
 
   1.2s total · ttft 400ms · 240 tokens · 1 tool
diff --git a/crates/astra-cli/src/tui/history_cell/assistant.rs b/crates/astra-cli/src/tui/history_cell/assistant.rs
index 2e95af2021..745275d5d6 100644
--- a/crates/astra-cli/src/tui/history_cell/assistant.rs
+++ b/crates/astra-cli/src/tui/history_cell/assistant.rs
@@ -11,9 +11,9 @@
 //! thinking window). One source of truth, one render path. See
 //! `docs/design/tui-refactor.md` §3.3.
 //!
-//! Settled reply bodies start with a `● ` marker and indent continuation
-//! prose rows with plain spaces; code-block rows stay verbatim at column 0,
-//! so a block selected from native scrollback copies exactly as written.
+//! Settled reply bodies indent prose rows with plain spaces and carry no
+//! glyph marker; code-block rows stay verbatim at column 0, so text selected
+//! from native scrollback copies as written.
 //! Live cells still use the active-slot wrapper for structure.
 //! An active response is kept visually distinct by the surrounding status line;
 //! its content itself stays free of transient transport counters.
@@ -321,11 +321,7 @@ impl AssistantCell {
         }
         let inner_width = (width as usize).saturating_sub(2).max(20);
         let (rendered, total) = self.markdown_layout_window(source, inner_width, start, maximum);
-        let lines = rendered
-            .into_iter()
-            .enumerate()
-            .map(|(offset, row)| prefix_settled_row(start.saturating_add(offset), row))
-            .collect();
+        let lines = rendered.into_iter().map(prefix_settled_row).collect();
         (lines, total)
     }
 
@@ -568,10 +564,9 @@ impl AssistantCell {
 
         rendered
             .into_iter()
-            .enumerate()
-            .map(|(index, row)| {
+            .map(|row| {
                 if prepend_gutter {
-                    prefix_settled_row(index, row)
+                    prefix_settled_row(row)
                 } else {
                     row.line
                 }
@@ -582,27 +577,19 @@ impl AssistantCell {
 
 /// Prefix a settled response body row for native scrollback.
 ///
-/// Terminal selection copies every written cell, so any prefix leaks into
-/// text users copy from a reply. Code-block rows are therefore written
-/// verbatim at column 0: a copied block (a heredoc, indentation-sensitive
-/// code) matches its source exactly. Other rows get a 2-col prefix: the first
-/// body row carries the `● ` terminal marker, in the same success colour as
-/// tool markers, and the rest are indented with plain spaces. Live responses
-/// keep the distinct focus gutter supplied by `LiveFramedCell`.
-fn prefix_settled_row(body_row: usize, row: MarkdownRow) -> Line<'static> {
+/// Terminal selection copies every written cell, so any glyph prefix leaks
+/// into text users copy from a reply, even a one-row marker on a reply that
+/// is a single command. Code-block rows are therefore written verbatim at
+/// column 0: a copied block (a heredoc, indentation-sensitive code) matches
+/// its source exactly. Prose rows get a 2-col plain-space indent, which
+/// shells ignore. Live responses keep the distinct focus gutter supplied by
+/// `LiveFramedCell`.
+fn prefix_settled_row(row: MarkdownRow) -> Line<'static> {
     if row.verbatim {
         return row.line;
     }
-    let prefix = if body_row == 0 {
-        Span::styled(
-            "● ",
-            Style::default().fg(crate::tui::theme::current().success),
-        )
-    } else {
-        Span::raw("  ")
-    };
     let mut spans = Vec::with_capacity(row.line.spans.len() + 1);
-    spans.push(prefix);
+    spans.push(Span::raw("  "));
     spans.extend(row.line.spans);
     Line::from(spans)
 }
@@ -1101,15 +1088,15 @@ mod tests {
     }
 
     #[test]
-    fn settled_assistant_marker_matches_terminal_success_marker() {
-        let c = AssistantCell::from_markdown("done");
-        let lines = c.display_lines(40);
-        let marker = lines
-            .first()
-            .and_then(|line| line.spans.first())
-            .expect("settled assistant has a marker");
-        assert_eq!(marker.content.as_ref(), "● ");
-        assert_eq!(marker.style.fg, Some(crate::tui::theme::current().success));
+    fn settled_single_line_command_reply_copies_without_glyphs() {
+        for source in ["`git status`", "git status"] {
+            let c = AssistantCell::from_markdown(source);
+            let (scrollback, _, complete) = c.scrollback_lines_chunk(80, 0, usize::MAX);
+            assert!(complete);
+            for lines in [c.display_lines(80), scrollback] {
+                assert_eq!(line_text(&lines), "  git status", "{source:?}");
+            }
+        }
     }
 
     #[test]
@@ -1131,7 +1118,7 @@ mod tests {
                     text.contains(&format!("\n{block}\n")) || text.ends_with(&format!("\n{block}")),
                     "{source:?} rendered {text:?}"
                 );
-                assert_eq!(text.matches('●').count(), 1, "{text}");
+                assert!(!text.contains('●'), "{text}");
                 assert!(!text.contains('█'), "{text}");
             }
         }
@@ -1183,12 +1170,12 @@ mod tests {
         assert_eq!(second.len(), 3);
         assert_eq!(next, 6);
         assert!(!complete);
-        assert_eq!(first[0].spans[0].content.as_ref(), "● ");
-        assert_eq!(first[1].spans[0].content.as_ref(), "  ");
-        assert_eq!(
-            second[0].spans[0].content.as_ref(),
-            "  ",
-            "a later chunk continues the body instead of restarting the marker"
+        assert!(
+            first
+                .iter()
+                .chain(&second)
+                .all(|line| line.spans[0].content.as_ref() == "  "),
+            "every chunk indents prose rows with plain spaces"
         );
     }
 
diff --git a/crates/astra-cli/src/tui/history_cell/snapshots/astra__tui__history_cell__assistant__tests__assistant_inline_code_60.snap b/crates/astra-cli/src/tui/history_cell/snapshots/astra__tui__history_cell__assistant__tests__assistant_inline_code_60.snap
index 27d8e0750f..9eed516342 100644
--- a/crates/astra-cli/src/tui/history_cell/snapshots/astra__tui__history_cell__assistant__tests__assistant_inline_code_60.snap
+++ b/crates/astra-cli/src/tui/history_cell/snapshots/astra__tui__history_cell__assistant__tests__assistant_inline_code_60.snap
@@ -2,4 +2,4 @@
 source: crates/astra-cli/src/tui/history_cell/assistant.rs
 expression: "render(&c, 60, 2)"
 ---
-● Use cargo build to compile the project.
+  Use cargo build to compile the project.
diff --git a/crates/astra-cli/src/tui/history_cell/snapshots/astra__tui__history_cell__assistant__tests__assistant_paragraph_60.snap b/crates/astra-cli/src/tui/history_cell/snapshots/astra__tui__history_cell__assistant__tests__assistant_paragraph_60.snap
index 8abc13db55..ea1ea56017 100644
--- a/crates/astra-cli/src/tui/history_cell/snapshots/astra__tui__history_cell__assistant__tests__assistant_paragraph_60.snap
+++ b/crates/astra-cli/src/tui/history_cell/snapshots/astra__tui__history_cell__assistant__tests__assistant_paragraph_60.snap
@@ -2,6 +2,6 @@
 source: crates/astra-cli/src/tui/history_cell/assistant.rs
 expression: "render(&c, 60, 5)"
 ---
-● Here is the plan:
+  Here is the plan:
   • step one
   • step two
diff --git a/crates/astra-cli/src/tui/history_cell/snapshots/astra__tui__history_cell__assistant__tests__assistant_think_closed_60.snap b/crates/astra-cli/src/tui/history_cell/snapshots/astra__tui__history_cell__assistant__tests__assistant_think_closed_60.snap
index bb84f026d8..631adc3ebf 100644
--- a/crates/astra-cli/src/tui/history_cell/snapshots/astra__tui__history_cell__assistant__tests__assistant_think_closed_60.snap
+++ b/crates/astra-cli/src/tui/history_cell/snapshots/astra__tui__history_cell__assistant__tests__assistant_think_closed_60.snap
@@ -3,4 +3,4 @@ source: crates/astra-cli/src/tui/history_cell/assistant.rs
 expression: "render(&c, 60, 3)"
 ---
 ● Thought · 2 lines · 14 tokens
-● Hello — happy to help.
+  Hello — happy to help.
diff --git a/crates/astra-cli/src/tui/terminal.rs b/crates/astra-cli/src/tui/terminal.rs
index 5ab3dff9a0..17cd409ee7 100644
--- a/crates/astra-cli/src/tui/terminal.rs
+++ b/crates/astra-cli/src/tui/terminal.rs
@@ -827,8 +827,7 @@ mod tests {
         let (first, _) = take_pending_history_batch(&mut pending);
         assert_eq!(first.len(), MAX_HISTORY_LINES_PER_DRAW);
         assert!(!pending.is_empty(), "long reply tail remains queued");
-        assert_eq!(first[0].spans[0].content, "● ");
-        assert!(first[1..].iter().all(|line| line.spans[0].content == "  "));
+        assert!(first.iter().all(|line| line.spans[0].content == "  "));
 
         let mut emitted = first;
         while !pending.is_empty() {

From 35befbe29759344101c702481b21cda5dd1573d9 Mon Sep 17 00:00:00 2001
From: XuPeng-SH <xupeng3112@163.com>
Date: Tue, 27 Oct 2026 00:05:24 +0800
Subject: [PATCH 4/6] fix(tui): retain code row semantics through scrollback
 writes

---
 crates/astra-cli/src/tui/ARCHITECTURE.md      |  17 +-
 crates/astra-cli/src/tui/event_loop.rs        |   4 +-
 .../src/tui/history_cell/assistant.rs         |  69 ++-
 crates/astra-cli/src/tui/insert_history.rs    |  92 ++--
 crates/astra-cli/src/tui/markdown_render.rs   |  14 +-
 crates/astra-cli/src/tui/terminal.rs          | 435 ++++++++++++++----
 6 files changed, 466 insertions(+), 165 deletions(-)

diff --git a/crates/astra-cli/src/tui/ARCHITECTURE.md b/crates/astra-cli/src/tui/ARCHITECTURE.md
index a31a1b9534..5f61123120 100644
--- a/crates/astra-cli/src/tui/ARCHITECTURE.md
+++ b/crates/astra-cli/src/tui/ARCHITECTURE.md
@@ -104,7 +104,7 @@ All cells live in `history_cell/` and implement the `HistoryCell` trait
 | Cell | File | Role |
 |------|------|------|
 | **UserCell** | `user.rs` | `›` accent-bold prefix + user message text |
-| **AssistantCell** | `assistant.rs` | Streaming markdown; settled prose rows are space-indented with no glyph marker and code-block rows are written verbatim, so scrollback copies cleanly; blinking cursor while live |
+| **AssistantCell** | `assistant.rs` | Streaming markdown; settled prose rows are space-indented with no glyph marker and code-block rows retain logical line boundaries through the final writer without a gutter or width-generated hard breaks; blinking cursor while live |
 | **ReasoningCell** | `reasoning.rs` | `💭 Thinking` header + compact body; committed on `ReasoningDone` or first answer delta |
 | **ToolCell** | `tool.rs` | `• Ran tool (Nms)` header + `│` args + `└` output; diff-aware coloring |
 | **SystemCell** | `system.rs` | info / warning / error; error text is humanized (strips `<tool_use_error>` wrappers) |
@@ -257,3 +257,18 @@ not an interactive fallback dispatcher.
 
 The current product contract and phased implementation plan live in
 `plans/astra-tui-agent-workbench-productization-2026-07-11.md`.
+
+### Settled code in native scrollback
+
+The Markdown renderer marks code rows and the immutable cached rows retain that
+classification through lazy history batching and the final terminal writer.
+Code rows start at column zero and use terminal soft wrapping; ordinary prose
+keeps its existing layout. Final writes count physical rows at the current
+terminal width without inserting hard line breaks into the code itself.
+Sanitization and structured-link trust remain independent of this layout hint.
+
+This guarantees that Astra adds neither a gutter nor width-generated hard breaks
+to sanitized code rows. Native clipboard selection still depends on the terminal
+and multiplexer; tabs, Unicode width policy, and Markdown newline normalization
+are not a portable byte-for-byte clipboard contract. The live streaming gutter
+is a separate presentation path and is unchanged here.
diff --git a/crates/astra-cli/src/tui/event_loop.rs b/crates/astra-cli/src/tui/event_loop.rs
index efded31831..a7bc47bfcf 100644
--- a/crates/astra-cli/src/tui/event_loop.rs
+++ b/crates/astra-cli/src/tui/event_loop.rs
@@ -15515,9 +15515,9 @@ mod tests {
         let mut emitted = Vec::new();
         let mut start = 0;
         loop {
-            let (chunk, next, complete) = assistant.scrollback_lines_chunk(80, start, 8);
+            let (chunk, next, complete) = assistant.scrollback_rows_chunk(80, start, 8);
             assert!(chunk.len() <= 8);
-            emitted.extend(chunk);
+            emitted.extend(chunk.into_iter().map(|row| row.line));
             if complete {
                 break;
             }
diff --git a/crates/astra-cli/src/tui/history_cell/assistant.rs b/crates/astra-cli/src/tui/history_cell/assistant.rs
index 745275d5d6..660056b95d 100644
--- a/crates/astra-cli/src/tui/history_cell/assistant.rs
+++ b/crates/astra-cli/src/tui/history_cell/assistant.rs
@@ -309,13 +309,13 @@ impl AssistantCell {
         self.markdown_layout_window(source, width, 0, usize::MAX).0
     }
 
-    fn scrollback_body_lines(
+    fn scrollback_body_rows(
         &self,
         source: &str,
         width: u16,
         start: usize,
         maximum: usize,
-    ) -> (Vec<Line<'static>>, usize) {
+    ) -> (Vec<MarkdownRow>, usize) {
         if source.is_empty() || maximum == 0 {
             return (Vec::new(), 0);
         }
@@ -499,12 +499,12 @@ impl AssistantCell {
     /// Materialize only a bounded portion of a final reply for native
     /// scrollback. Long final messages are inserted over several frames so
     /// the event loop can continue accepting composer input between chunks.
-    pub(crate) fn scrollback_lines_chunk(
+    pub(crate) fn scrollback_rows_chunk(
         &self,
         width: u16,
         start: usize,
         maximum: usize,
-    ) -> (Vec<Line<'static>>, usize, bool) {
+    ) -> (Vec<MarkdownRow>, usize, bool) {
         debug_assert!(!self.live, "live assistant cells stay in the viewport");
         if maximum == 0 {
             return (Vec::new(), start, false);
@@ -529,11 +529,12 @@ impl AssistantCell {
             .skip(start)
             .take(maximum)
             .cloned()
+            .map(MarkdownRow::from)
             .collect::<Vec<_>>();
         let body_start = start.saturating_sub(headers.len());
         let remaining = maximum.saturating_sub(lines.len());
         let (body_lines, body_total) =
-            self.scrollback_body_lines(body_source, width, body_start, remaining);
+            self.scrollback_body_rows(body_source, width, body_start, remaining);
         lines.extend(body_lines);
         let next = start.saturating_add(lines.len());
         let total = headers.len().saturating_add(body_total);
@@ -566,7 +567,7 @@ impl AssistantCell {
             .into_iter()
             .map(|row| {
                 if prepend_gutter {
-                    prefix_settled_row(row)
+                    prefix_settled_row(row).line
                 } else {
                     row.line
                 }
@@ -575,23 +576,14 @@ impl AssistantCell {
     }
 }
 
-/// Prefix a settled response body row for native scrollback.
-///
-/// Terminal selection copies every written cell, so any glyph prefix leaks
-/// into text users copy from a reply, even a one-row marker on a reply that
-/// is a single command. Code-block rows are therefore written verbatim at
-/// column 0: a copied block (a heredoc, indentation-sensitive code) matches
-/// its source exactly. Prose rows get a 2-col plain-space indent, which
-/// shells ignore. Live responses keep the distinct focus gutter supplied by
-/// `LiveFramedCell`.
-fn prefix_settled_row(row: MarkdownRow) -> Line<'static> {
-    if row.verbatim {
-        return row.line;
-    }
-    let mut spans = Vec::with_capacity(row.line.spans.len() + 1);
-    spans.push(Span::raw("  "));
-    spans.extend(row.line.spans);
-    Line::from(spans)
+/// Decorate prose while retaining code-row semantics for the final writer.
+/// Settled code starts at column zero and uses terminal soft wrapping; live
+/// responses keep their distinct focus gutter supplied by `LiveFramedCell`.
+fn prefix_settled_row(mut row: MarkdownRow) -> MarkdownRow {
+    if !row.verbatim {
+        row.line.spans.insert(0, Span::raw("  "));
+    }
+    row
 }
 
 impl HistoryCell for AssistantCell {
@@ -1062,9 +1054,9 @@ mod tests {
         let mut actual = Vec::new();
         let mut start = 0;
         loop {
-            let (chunk, next, complete) = c.scrollback_lines_chunk(80, start, 8);
+            let (chunk, next, complete) = c.scrollback_rows_chunk(80, start, 8);
             assert!(chunk.len() <= 8);
-            actual.extend(chunk);
+            actual.extend(chunk.into_iter().map(|row| row.line));
             if complete {
                 break;
             }
@@ -1091,9 +1083,12 @@ mod tests {
     fn settled_single_line_command_reply_copies_without_glyphs() {
         for source in ["`git status`", "git status"] {
             let c = AssistantCell::from_markdown(source);
-            let (scrollback, _, complete) = c.scrollback_lines_chunk(80, 0, usize::MAX);
+            let (scrollback, _, complete) = c.scrollback_rows_chunk(80, 0, usize::MAX);
             assert!(complete);
-            for lines in [c.display_lines(80), scrollback] {
+            for lines in [
+                c.display_lines(80),
+                scrollback.into_iter().map(|row| row.line).collect(),
+            ] {
                 assert_eq!(line_text(&lines), "  git status", "{source:?}");
             }
         }
@@ -1110,9 +1105,12 @@ mod tests {
             format!("```\n{block}\n```"),
         ] {
             let c = AssistantCell::from_markdown(source.clone());
-            let (scrollback, _, complete) = c.scrollback_lines_chunk(80, 0, usize::MAX);
+            let (scrollback, _, complete) = c.scrollback_rows_chunk(80, 0, usize::MAX);
             assert!(complete);
-            for lines in [c.display_lines(80), scrollback] {
+            for lines in [
+                c.display_lines(80),
+                scrollback.into_iter().map(|row| row.line).collect(),
+            ] {
                 let text = line_text(&lines);
                 assert!(
                     text.contains(&format!("\n{block}\n")) || text.ends_with(&format!("\n{block}")),
@@ -1161,12 +1159,12 @@ mod tests {
                 .join("\n\n"),
         );
 
-        let (first, next, complete) = c.scrollback_lines_chunk(80, 0, 3);
+        let (first, next, complete) = c.scrollback_rows_chunk(80, 0, 3);
         assert_eq!(first.len(), 3);
         assert_eq!(next, 3);
         assert!(!complete);
 
-        let (second, next, complete) = c.scrollback_lines_chunk(80, next, 3);
+        let (second, next, complete) = c.scrollback_rows_chunk(80, next, 3);
         assert_eq!(second.len(), 3);
         assert_eq!(next, 6);
         assert!(!complete);
@@ -1174,7 +1172,7 @@ mod tests {
             first
                 .iter()
                 .chain(&second)
-                .all(|line| line.spans[0].content.as_ref() == "  "),
+                .all(|row| row.line.spans[0].content.as_ref() == "  "),
             "every chunk indents prose rows with plain spaces"
         );
     }
@@ -1187,10 +1185,11 @@ mod tests {
         c.prepare_scrollback_layout(80);
 
         assert!(c.has_scrollback_layout(80));
-        let (lines, _, complete) = c.scrollback_lines_chunk(80, 0, 8);
+        let (lines, _, complete) = c.scrollback_rows_chunk(80, 0, 8);
         assert!(complete);
-        assert!(lines.iter().any(|line| {
-            line.spans
+        assert!(lines.iter().any(|row| {
+            row.line
+                .spans
                 .iter()
                 .any(|span| span.content.contains("Result"))
         }));
diff --git a/crates/astra-cli/src/tui/insert_history.rs b/crates/astra-cli/src/tui/insert_history.rs
index 0741645ea3..7cad47ceec 100644
--- a/crates/astra-cli/src/tui/insert_history.rs
+++ b/crates/astra-cli/src/tui/insert_history.rs
@@ -1,5 +1,6 @@
 use std::io::{self, Write};
 
+use super::markdown_render::MarkdownRow;
 use crossterm::{
     cursor::MoveTo,
     queue,
@@ -10,6 +11,7 @@ use ratatui::backend::Backend;
 use ratatui::layout::Size;
 use ratatui::style::{Color as RColor, Modifier, Style};
 use ratatui::text::Line;
+use unicode_segmentation::UnicodeSegmentation;
 use unicode_width::UnicodeWidthStr;
 
 use super::custom_terminal;
@@ -18,58 +20,49 @@ use super::custom_terminal;
 /// Matches Codex insert_history.rs Standard/Zellij paths.
 pub(crate) fn insert_history_lines_with_terminal<B: Backend + Write>(
     terminal: &mut custom_terminal::Terminal<B>,
-    lines: &[Line<'_>],
+    rows: &[MarkdownRow],
     trusted_links: bool,
     is_zellij: bool,
 ) -> io::Result<()> {
-    if lines.is_empty() {
+    if rows.is_empty() {
         return Ok(());
     }
 
     let screen_size = terminal.backend().size().unwrap_or(Size::new(0, 0));
     let area = terminal.viewport_area;
     let last_cursor_pos = terminal.last_known_cursor_pos;
-    let wrap_width = area.width.max(1) as usize;
+    let wrap_width = screen_size.width.max(1) as usize;
     let mut should_update_area = false;
 
-    // Pre-wrap lines using adaptive wrapping (URL-aware, span-preserving)
+    // Sanitization is independent of copy semantics. Code and pure URLs use
+    // terminal soft wrapping so only logical source rows emit CRLFs.
     let mut wrapped: Vec<Line<'static>> = Vec::new();
     let mut wrapped_rows: u16 = 0;
-    for line in lines {
-        let line_w: usize = line.spans.iter().map(|s| s.content.width()).sum();
-        if line_w == 0 {
-            wrapped.push(if trusted_links {
-                super::render::line_utils::sanitize_line_for_terminal_with_links(line)
-            } else {
-                super::render::line_utils::line_to_static(line)
-            });
-            wrapped_rows += 1;
-        } else if super::wrapping::line_contains_url_like(line)
-            && !super::wrapping::line_has_mixed_url_and_non_url_tokens(line)
+    for row in rows {
+        let line = if trusted_links {
+            super::render::line_utils::sanitize_line_for_terminal_with_links(&row.line)
+        } else {
+            super::render::line_utils::line_to_static(&row.line)
+        };
+        let soft_wrap = row.verbatim
+            || (super::wrapping::line_contains_url_like(&line)
+                && !super::wrapping::line_has_mixed_url_and_non_url_tokens(&line));
+        if soft_wrap {
+            let physical = soft_wrapped_rows(&line, wrap_width);
+            wrapped_rows = wrapped_rows.saturating_add(u16::try_from(physical).unwrap_or(u16::MAX));
+            wrapped.push(line);
+            continue;
+        }
+        for line in
+            super::wrapping::adaptive_wrap_line(&line, super::wrapping::RtOptions::new(wrap_width))
         {
-            // Pure URL line — don't wrap, let terminal handle it (keeps URL clickable)
-            let physical = line_w.max(1).div_ceil(wrap_width) as u16;
-            wrapped_rows += physical;
+            let physical = soft_wrapped_rows(&line, wrap_width);
+            wrapped_rows = wrapped_rows.saturating_add(u16::try_from(physical).unwrap_or(u16::MAX));
             wrapped.push(if trusted_links {
-                super::render::line_utils::sanitize_line_for_terminal_with_links(line)
+                super::render::line_utils::sanitize_line_for_terminal_with_links(&line)
             } else {
-                super::render::line_utils::line_to_static(line)
+                super::render::line_utils::line_to_static(&line)
             });
-        } else {
-            let line_wrapped = super::wrapping::adaptive_wrap_line(
-                line,
-                super::wrapping::RtOptions::new(wrap_width),
-            );
-            for wl in &line_wrapped {
-                wrapped_rows += wl.width().max(1).div_ceil(wrap_width) as u16;
-            }
-            wrapped.extend(line_wrapped.into_iter().map(|l| {
-                if trusted_links {
-                    crate::tui::render::line_utils::sanitize_line_for_terminal_with_links(&l)
-                } else {
-                    crate::tui::render::line_utils::line_to_static(&l)
-                }
-            }));
         }
     }
 
@@ -180,6 +173,35 @@ pub(crate) fn insert_history_lines_with_terminal<B: Backend + Write>(
     Ok(())
 }
 
+/// Count terminal rows without materializing physical fragments. Carry the
+/// column across styled spans and account for a wide glyph wrapping early.
+fn soft_wrapped_rows(line: &Line<'_>, width: usize) -> usize {
+    let width = width.max(1);
+    let mut rows = 1usize;
+    let mut column = 0usize;
+    for span in &line.spans {
+        let visible = crate::cli::terminal_hyperlinks::strip_link_markers(&span.content);
+        for grapheme in visible.graphemes(true) {
+            if grapheme == "\t" {
+                // Default terminal tab stops advance without wrapping and
+                // clamp to the last column. No application changes tab stops.
+                column = ((column / 8 + 1) * 8).min(width - 1);
+                continue;
+            }
+            let cells = grapheme.width().min(width);
+            if cells == 0 {
+                continue;
+            }
+            if column > 0 && column + cells > width {
+                rows = rows.saturating_add(1);
+                column = 0;
+            }
+            column += cells;
+        }
+    }
+    rows
+}
+
 fn write_history_line(
     writer: &mut impl Write,
     line: &Line<'_>,
diff --git a/crates/astra-cli/src/tui/markdown_render.rs b/crates/astra-cli/src/tui/markdown_render.rs
index a8e573b817..b248e77b02 100644
--- a/crates/astra-cli/src/tui/markdown_render.rs
+++ b/crates/astra-cli/src/tui/markdown_render.rs
@@ -50,15 +50,23 @@ pub(crate) fn render_markdown_text_with_width_and_cwd(
     write_markdown(input, width, cwd).into_text()
 }
 
-/// One rendered Markdown row. `verbatim` marks rows that reproduce
-/// code-block source as written; callers that decorate rows must leave
-/// these untouched so terminal selection copies the source exactly.
+/// One rendered Markdown row. `verbatim` prevents presentation wrapping
+/// from inserting hard breaks into code. It grants no terminal-control trust.
 #[derive(Debug, Clone)]
 pub(crate) struct MarkdownRow {
     pub line: Line<'static>,
     pub verbatim: bool,
 }
 
+impl From<Line<'static>> for MarkdownRow {
+    fn from(line: Line<'static>) -> Self {
+        Self {
+            line,
+            verbatim: false,
+        }
+    }
+}
+
 pub(crate) fn render_markdown_rows_with_width(
     input: &str,
     width: Option<usize>,
diff --git a/crates/astra-cli/src/tui/terminal.rs b/crates/astra-cli/src/tui/terminal.rs
index 17cd409ee7..a6a6d12ccf 100644
--- a/crates/astra-cli/src/tui/terminal.rs
+++ b/crates/astra-cli/src/tui/terminal.rs
@@ -5,6 +5,7 @@ use std::sync::{
     atomic::{AtomicBool, Ordering},
 };
 
+use super::markdown_render::MarkdownRow;
 use crossterm::{
     SynchronizedUpdate, cursor,
     event::{
@@ -15,8 +16,9 @@ use crossterm::{
     style::Print,
     terminal::{disable_raw_mode, enable_raw_mode, is_raw_mode_enabled},
 };
-use ratatui::backend::CrosstermBackend;
+use ratatui::backend::{Backend, CrosstermBackend};
 use ratatui::text::Line;
+use std::io::Write;
 
 use super::custom_terminal;
 use super::frame_requester::FrameRequester;
@@ -107,7 +109,7 @@ const MAX_LAZY_ASSISTANT_LINES_PER_BATCH: usize = 8;
 
 enum PendingHistory {
     Lines {
-        lines: VecDeque<Line<'static>>,
+        lines: VecDeque<MarkdownRow>,
         trusted_links: bool,
     },
     Assistant(QueuedAssistantHistory),
@@ -122,7 +124,7 @@ struct QueuedAssistantHistory {
     layout_preparing: Arc<AtomicBool>,
     rendered_complete: bool,
     pending_separators: usize,
-    ready: VecDeque<Line<'static>>,
+    ready: VecDeque<MarkdownRow>,
 }
 
 /// Guarantees that a completed blocking layout cannot leave the ordered
@@ -228,7 +230,7 @@ impl TerminalGuard {
         let lines = sanitize_lines_for_terminal(lines);
         if !lines.is_empty() {
             self.pending_history.push_back(PendingHistory::Lines {
-                lines: lines.into(),
+                lines: lines.into_iter().map(MarkdownRow::from).collect(),
                 trusted_links: false,
             });
         }
@@ -270,7 +272,7 @@ impl TerminalGuard {
             lines.extend(std::iter::repeat_n(Line::default(), separators));
             if !lines.is_empty() {
                 self.pending_history.push_back(PendingHistory::Lines {
-                    lines: lines.into(),
+                    lines: lines.into_iter().map(MarkdownRow::from).collect(),
                     trusted_links,
                 });
             }
@@ -472,8 +474,8 @@ impl TerminalGuard {
         Ok(needs_full_repaint)
     }
 
-    fn flush_pending_history(
-        terminal: &mut CustomTerminal,
+    fn flush_pending_history<B: Backend + Write>(
+        terminal: &mut custom_terminal::Terminal<B>,
         pending: &mut VecDeque<PendingHistory>,
         is_zellij: bool,
     ) -> io::Result<bool> {
@@ -570,41 +572,13 @@ impl TerminalGuard {
     }
 }
 
-fn take_history_batch(pending: &mut VecDeque<Line<'static>>) -> Vec<Line<'static>> {
-    let mut lines = Vec::new();
-    let mut chars = 0usize;
-    while lines.len() < MAX_HISTORY_LINES_PER_DRAW {
-        let Some(next) = pending.front() else {
-            break;
-        };
-        let next_chars = next
-            .spans
-            .iter()
-            .map(|span| span.content.len())
-            .sum::<usize>();
-        if !lines.is_empty() && chars.saturating_add(next_chars) > MAX_HISTORY_CHARS_PER_DRAW {
-            break;
-        }
-        chars = chars.saturating_add(next_chars);
-        // Always make progress for one unusually long code/output line. The
-        // markdown and terminal wrappers handle its visual rows; retaining it
-        // indefinitely would be worse than a bounded exceptional write.
-        lines.push(
-            pending
-                .pop_front()
-                .expect("front item exists until this queue is mutated"),
-        );
-    }
-    lines
-}
-
 fn pending_line_chars(line: &Line<'static>) -> usize {
     line.spans.iter().map(|span| span.content.len()).sum()
 }
 
 enum PendingHistoryLine {
     Ready {
-        line: Line<'static>,
+        line: MarkdownRow,
         trusted_links: bool,
     },
     Waiting,
@@ -634,12 +608,15 @@ fn take_next_pending_history_line(pending: &mut VecDeque<PendingHistory>) -> Pen
                         .as_any_ref()
                         .downcast_ref::<AssistantCell>()
                         .expect("only final assistant cells enter the lazy history queue");
-                    let (lines, next_line, complete) = assistant.scrollback_lines_chunk(
+                    let (lines, next_line, complete) = assistant.scrollback_rows_chunk(
                         queued.width,
                         queued.next_line,
                         MAX_LAZY_ASSISTANT_LINES_PER_BATCH,
                     );
-                    queued.ready.extend(sanitize_lines_for_terminal(lines));
+                    queued.ready.extend(lines.into_iter().map(|mut row| {
+                        row.line = super::render::line_utils::sanitize_line_for_terminal(&row.line);
+                        row
+                    }));
                     queued.next_line = next_line;
                     queued.rendered_complete = complete;
                 }
@@ -654,7 +631,7 @@ fn take_next_pending_history_line(pending: &mut VecDeque<PendingHistory>) -> Pen
                         if queued.rendered_complete && queued.pending_separators > 0 {
                             queued.pending_separators -= 1;
                             Some(PendingHistoryLine::Ready {
-                                line: Line::default(),
+                                line: Line::default().into(),
                                 trusted_links: false,
                             })
                         } else {
@@ -670,7 +647,7 @@ fn take_next_pending_history_line(pending: &mut VecDeque<PendingHistory>) -> Pen
     }
 }
 
-fn return_pending_history_line(pending: &mut VecDeque<PendingHistory>, line: Line<'static>) {
+fn return_pending_history_line(pending: &mut VecDeque<PendingHistory>, line: MarkdownRow) {
     match pending.front_mut() {
         Some(PendingHistory::Lines { lines, .. }) => lines.push_front(line),
         Some(PendingHistory::Assistant(queued)) => queued.ready.push_front(line),
@@ -678,9 +655,7 @@ fn return_pending_history_line(pending: &mut VecDeque<PendingHistory>, line: Lin
     }
 }
 
-fn take_pending_history_batch(
-    pending: &mut VecDeque<PendingHistory>,
-) -> (Vec<Line<'static>>, bool) {
+fn take_pending_history_batch(pending: &mut VecDeque<PendingHistory>) -> (Vec<MarkdownRow>, bool) {
     let mut lines = Vec::new();
     let mut chars = 0usize;
     let mut trusted_links = None;
@@ -702,7 +677,7 @@ fn take_pending_history_batch(
             }
             PendingHistoryLine::Waiting | PendingHistoryLine::Exhausted => break,
         };
-        let next_chars = pending_line_chars(&next);
+        let next_chars = pending_line_chars(&next.line);
         if !lines.is_empty() && chars.saturating_add(next_chars) > MAX_HISTORY_CHARS_PER_DRAW {
             return_pending_history_line(pending, next);
             break;
@@ -720,11 +695,9 @@ impl Drop for TerminalGuard {
         // scrollback rather than silently discarding a reply tail when the
         // user exits immediately after it starts painting.
         while !self.pending_history.is_empty() {
-            let (lines, trusted_links) = take_pending_history_batch(&mut self.pending_history);
-            if super::insert_history::insert_history_lines_with_terminal(
+            if Self::flush_pending_history(
                 &mut self.terminal,
-                &lines,
-                trusted_links,
+                &mut self.pending_history,
                 self.is_zellij,
             )
             .is_err()
@@ -750,59 +723,343 @@ mod tests {
 
     use super::{
         MAX_HISTORY_CHARS_PER_DRAW, MAX_HISTORY_LINES_PER_DRAW, PendingHistory,
-        QueuedAssistantHistory, take_history_batch, take_pending_history_batch,
+        QueuedAssistantHistory, take_pending_history_batch,
     };
     use crate::tui::history_cell::{HistoryCell, assistant::AssistantCell};
 
-    #[test]
-    fn history_batch_is_bounded_and_preserves_fifo_order() {
-        let mut pending = (0..MAX_HISTORY_LINES_PER_DRAW + 2)
-            .map(|index| Line::raw(format!("line-{index}")))
-            .collect::<VecDeque<_>>();
+    struct RecordingBackend {
+        inner: ratatui::backend::TestBackend,
+        bytes: Vec<u8>,
+        fail_writes: bool,
+    }
 
-        let first = take_history_batch(&mut pending);
-        assert_eq!(first.len(), MAX_HISTORY_LINES_PER_DRAW);
-        assert_eq!(first[0].spans[0].content, "line-0");
-        assert_eq!(
-            first.last().expect("bounded batch has content").spans[0].content,
-            format!("line-{}", MAX_HISTORY_LINES_PER_DRAW - 1)
-        );
-        assert_eq!(pending.len(), 2);
-        assert_eq!(
-            pending.front().expect("tail remains").spans[0].content,
-            format!("line-{MAX_HISTORY_LINES_PER_DRAW}")
-        );
+    impl std::io::Write for RecordingBackend {
+        fn write(&mut self, bytes: &[u8]) -> std::io::Result<usize> {
+            if self.fail_writes {
+                return Err(std::io::ErrorKind::BrokenPipe.into());
+            }
+            self.bytes.extend_from_slice(bytes);
+            Ok(bytes.len())
+        }
+        fn flush(&mut self) -> std::io::Result<()> {
+            Ok(())
+        }
+    }
+
+    impl ratatui::backend::Backend for RecordingBackend {
+        type Error = std::convert::Infallible;
+        fn draw<'a, I>(&mut self, content: I) -> Result<(), Self::Error>
+        where
+            I: Iterator<Item = (u16, u16, &'a ratatui::buffer::Cell)>,
+        {
+            self.inner.draw(content)
+        }
+        fn hide_cursor(&mut self) -> Result<(), Self::Error> {
+            self.inner.hide_cursor()
+        }
+        fn show_cursor(&mut self) -> Result<(), Self::Error> {
+            self.inner.show_cursor()
+        }
+        fn get_cursor_position(&mut self) -> Result<ratatui::layout::Position, Self::Error> {
+            self.inner.get_cursor_position()
+        }
+        fn set_cursor_position<P: Into<ratatui::layout::Position>>(
+            &mut self,
+            position: P,
+        ) -> Result<(), Self::Error> {
+            self.inner.set_cursor_position(position)
+        }
+        fn clear(&mut self) -> Result<(), Self::Error> {
+            self.inner.clear()
+        }
+        fn clear_region(&mut self, kind: ratatui::backend::ClearType) -> Result<(), Self::Error> {
+            self.inner.clear_region(kind)
+        }
+        fn size(&self) -> Result<ratatui::layout::Size, Self::Error> {
+            self.inner.size()
+        }
+        fn window_size(&mut self) -> Result<ratatui::backend::WindowSize, Self::Error> {
+            self.inner.window_size()
+        }
+        fn scroll_region_up(
+            &mut self,
+            region: std::ops::Range<u16>,
+            lines: u16,
+        ) -> Result<(), Self::Error> {
+            self.inner.scroll_region_up(region, lines)
+        }
+        fn scroll_region_down(
+            &mut self,
+            region: std::ops::Range<u16>,
+            lines: u16,
+        ) -> Result<(), Self::Error> {
+            self.inner.scroll_region_down(region, lines)
+        }
+        fn flush(&mut self) -> Result<(), Self::Error> {
+            self.inner.flush()
+        }
+    }
+
+    fn recording_terminal(
+        width: u16,
+        top: u16,
+    ) -> crate::tui::custom_terminal::Terminal<RecordingBackend> {
+        let backend = RecordingBackend {
+            inner: ratatui::backend::TestBackend::new(width, 40),
+            bytes: Vec::new(),
+            fail_writes: false,
+        };
+        let mut terminal = crate::tui::custom_terminal::Terminal::with_options(backend).unwrap();
+        terminal.set_viewport_area(ratatui::layout::Rect::new(0, top, width, 4));
+        terminal
+    }
+
+    fn queued_assistant(source: &str, width: u16) -> VecDeque<PendingHistory> {
+        let cell: Arc<dyn HistoryCell> = Arc::new(AssistantCell::from_markdown(source.to_owned()));
+        VecDeque::from([PendingHistory::Assistant(QueuedAssistantHistory {
+            cell,
+            width,
+            next_line: 0,
+            layout_preparing: Arc::new(std::sync::atomic::AtomicBool::new(false)),
+            rendered_complete: false,
+            pending_separators: 0,
+            ready: VecDeque::new(),
+        })])
     }
 
     #[test]
-    fn history_batch_never_starves_one_oversized_line() {
-        let mut pending = VecDeque::from([Line::raw("x".repeat(32 * 1024)), Line::raw("tail")]);
+    fn settled_code_reaches_final_writer_without_hard_wraps() {
+        let command =
+            "printf '%s\\n' 'alpha beta gamma delta epsilon zeta eta theta iota kappa lambda mu'";
+        let long_payload = "quoted words ".repeat(16);
+        let code = format!("{command}\ncat <<'EOF'\n  {long_payload}\n\nEOF");
+        for width in [40, 80, 120] {
+            for zellij in [false, true] {
+                for language in ["", "sh"] {
+                    let source = format!("```{language}\n{code}\n```");
+                    let mut pending = queued_assistant(&source, width);
+                    let mut terminal = recording_terminal(width, 12);
+                    while !pending.is_empty() {
+                        super::TerminalGuard::flush_pending_history(
+                            &mut terminal,
+                            &mut pending,
+                            zellij,
+                        )
+                        .unwrap();
+                    }
+                    let raw = String::from_utf8(terminal.backend().bytes.clone()).unwrap();
+                    let plain = crate::cli::terminal_region::strip_ansi_codes(&raw);
+                    assert!(
+                        plain.contains(&code.replace('\n', "\r\n")),
+                        "logical source changed atwidth={width} zellij={zellij} lang={language}: {plain:?}"
+                    );
+                    assert!(!plain.contains('█'));
+                    let mut parser = vt100::Parser::new(40, width, 0);
+                    parser.process(raw.as_bytes());
+                    assert!(
+                        parser.screen().contents().contains(command),
+                        "emulated command was changed or overwritten"
+                    );
+                    assert_eq!(parser.screen().cursor_position(), (0, 0));
+                }
+            }
+        }
+    }
 
-        let first = take_history_batch(&mut pending);
-        assert_eq!(first.len(), 1);
-        assert_eq!(first[0].spans[0].content.len(), 32 * 1024);
+    #[test]
+    fn code_softwrap_counts_wide_glyphs_at_current_width() {
+        for width in [40_u16, 80, 120] {
+            let code = format!(
+                "{}界{}",
+                "x".repeat(usize::from(width - 1)),
+                "y".repeat(usize::from(width - 1))
+            );
+            for top in [12, 36] {
+                for zellij in [false, true] {
+                    // The cached Markdown width deliberately differs from the
+                    // actual width after a resize. Do not reindex the cache.
+                    let mut pending = queued_assistant(&format!("```\n{code}\n```"), 160);
+                    let (rows, trusted) = take_pending_history_batch(&mut pending);
+                    assert_eq!(rows.iter().filter(|row| row.verbatim).count(), 1);
+                    let expected_rows = rows.len() as u16 + 2; // one logical code row occupies three physical rows
+                    let mut terminal = recording_terminal(width, top);
+                    crate::tui::insert_history::insert_history_lines_with_terminal(
+                        &mut terminal,
+                        &rows,
+                        trusted,
+                        zellij,
+                    )
+                    .unwrap();
+                    assert_eq!(terminal.viewport_area.y, top + expected_rows.min(36 - top));
+                    assert_eq!(terminal.visible_history_rows(), expected_rows);
+                    let mut parser = vt100::Parser::new(40, width, 0);
+                    parser.process(&terminal.backend().bytes);
+                    assert_eq!(
+                        parser
+                            .screen()
+                            .rows(0, width)
+                            .filter(|row| !row.is_empty())
+                            .count(),
+                        3,
+                        "code placement width={width} top={top} zellij={zellij}"
+                    );
+                    assert!((0..40).any(|row| parser.screen().row_wrapped(row)));
+                    assert_eq!(parser.screen().contents().matches('界').count(), 1);
+                    assert_eq!(parser.screen().cursor_position(), (0, 0));
+                }
+            }
+        }
+    }
+
+    #[test]
+    fn softwrap_handles_exact_margin_and_combining_style_spans() {
+        use crate::tui::markdown_render::MarkdownRow;
+        use ratatui::text::Span;
+        for length in [39, 40, 41] {
+            let mut terminal = recording_terminal(40, 12);
+            let rows = [MarkdownRow {
+                line: Line::raw("x".repeat(length)),
+                verbatim: true,
+            }];
+            crate::tui::insert_history::insert_history_lines_with_terminal(
+                &mut terminal,
+                &rows,
+                false,
+                false,
+            )
+            .unwrap();
+            assert_eq!(
+                terminal.visible_history_rows(),
+                if length > 40 { 2 } else { 1 }
+            );
+        }
+        let mut terminal = recording_terminal(40, 12);
+        let row = MarkdownRow {
+            line: Line::from(vec![
+                Span::raw(format!("{}e", "x".repeat(39))),
+                Span::raw("\u{301}"),
+                Span::raw("z"),
+            ]),
+            verbatim: true,
+        };
+        crate::tui::insert_history::insert_history_lines_with_terminal(
+            &mut terminal,
+            &[row],
+            false,
+            false,
+        )
+        .unwrap();
+        assert_eq!(terminal.visible_history_rows(), 2);
+        let mut terminal = recording_terminal(40, 12);
+        let row = MarkdownRow {
+            line: Line::raw(format!("{}\tyz", "x".repeat(38))),
+            verbatim: true,
+        };
+        crate::tui::insert_history::insert_history_lines_with_terminal(
+            &mut terminal,
+            &[row],
+            false,
+            false,
+        )
+        .unwrap();
+        assert_eq!(terminal.visible_history_rows(), 2);
+        let mut parser = vt100::Parser::new(40, 40, 0);
+        parser.process(&terminal.backend().bytes);
         assert_eq!(
-            pending.front().expect("tail remains").spans[0].content,
-            "tail"
+            parser
+                .screen()
+                .rows(0, 40)
+                .filter(|row| !row.is_empty())
+                .count(),
+            2
         );
     }
 
     #[test]
-    fn history_batch_stops_at_the_character_budget_between_lines() {
-        let line_size = MAX_HISTORY_CHARS_PER_DRAW / 2 + 1;
-        let mut pending = VecDeque::from([
-            Line::raw("x".repeat(line_size)),
-            Line::raw("y".repeat(line_size)),
-        ]);
-
-        let first = take_history_batch(&mut pending);
-        assert_eq!(first.len(), 1);
-        assert_eq!(pending.len(), 1);
+    fn code_rows_survive_budget_pushback_and_trust_boundaries() {
+        let mut source_rows = (0..20)
+            .map(|index| format!("row-{index}:{}", "x".repeat(1000)))
+            .collect::<Vec<_>>();
+        source_rows.insert(7, format!("oversized:{}", "y".repeat(32 * 1024)));
+        let code = source_rows.join("\n");
+        let mut pending = queued_assistant(&format!("```\n{code}\n```"), 80);
+        let lease =
+            crate::cli::terminal_hyperlinks::register_link("file:///tmp/copy-test.txt").unwrap();
+        pending.push_back(PendingHistory::Lines {
+            lines: VecDeque::from([Line::raw(crate::cli::terminal_hyperlinks::mark_link_label(
+                lease.token(),
+                "trusted-tail",
+            ))
+            .into()]),
+            trusted_links: true,
+        });
+        let mut terminal = recording_terminal(80, 12);
+        let mut oversized_batches = 0;
+        let mut total_code_rows = 0;
+        while !pending.is_empty() {
+            let (rows, trusted) = take_pending_history_batch(&mut pending);
+            assert!(rows.len() <= MAX_HISTORY_LINES_PER_DRAW);
+            let chars = rows
+                .iter()
+                .map(|row| super::pending_line_chars(&row.line))
+                .sum::<usize>();
+            if chars > MAX_HISTORY_CHARS_PER_DRAW {
+                assert_eq!(rows.len(), 1);
+                oversized_batches += 1;
+            }
+            if total_code_rows > 0 {
+                terminal.backend_mut().inner.resize(40, 40);
+                let mut area = terminal.viewport_area;
+                area.width = 40;
+                terminal.set_viewport_area(area);
+            }
+            total_code_rows += rows.iter().filter(|row| row.verbatim).count();
+            crate::tui::insert_history::insert_history_lines_with_terminal(
+                &mut terminal,
+                &rows,
+                trusted,
+                false,
+            )
+            .unwrap();
+        }
+        assert_eq!(oversized_batches, 1);
+        assert_eq!(total_code_rows, source_rows.len());
+        let raw = String::from_utf8(terminal.backend().bytes.clone()).unwrap();
+        let plain = crate::cli::terminal_region::strip_ansi_codes(&raw);
+        assert!(plain.contains(&code.replace('\n', "\r\n")));
+        assert_eq!(plain.matches("oversized:").count(), 1);
+        assert!(plain.ends_with("trusted-tail"));
+        assert!(raw.contains("\x1b]8;;file:///tmp/copy-test.txt\x1b\\trusted-tail"));
+    }
+
+    #[test]
+    fn verbatim_does_not_grant_control_trust_or_hide_writer_errors() {
+        use crate::tui::markdown_render::MarkdownRow;
+        let rows = [MarkdownRow {
+            line: Line::raw("before\x1b]52;c;dGVzdA==\x07after"),
+            verbatim: true,
+        }];
+        let mut terminal = recording_terminal(40, 12);
+        crate::tui::insert_history::insert_history_lines_with_terminal(
+            &mut terminal,
+            &rows,
+            false,
+            false,
+        )
+        .unwrap();
+        let raw = String::from_utf8(terminal.backend().bytes.clone()).unwrap();
+        assert!(!raw.contains("\x1b]52;"));
+        terminal.backend_mut().fail_writes = true;
         assert_eq!(
-            pending.front().expect("second line remains").spans[0]
-                .content
-                .len(),
-            line_size
+            crate::tui::insert_history::insert_history_lines_with_terminal(
+                &mut terminal,
+                &rows,
+                false,
+                false
+            )
+            .unwrap_err()
+            .kind(),
+            std::io::ErrorKind::BrokenPipe
         );
     }
 
@@ -827,7 +1084,7 @@ mod tests {
         let (first, _) = take_pending_history_batch(&mut pending);
         assert_eq!(first.len(), MAX_HISTORY_LINES_PER_DRAW);
         assert!(!pending.is_empty(), "long reply tail remains queued");
-        assert!(first.iter().all(|line| line.spans[0].content == "  "));
+        assert!(first.iter().all(|row| row.line.spans[0].content == "  "));
 
         let mut emitted = first;
         while !pending.is_empty() {
@@ -837,7 +1094,7 @@ mod tests {
             emitted.extend(batch);
         }
         assert_eq!(
-            emitted,
+            emitted.into_iter().map(|row| row.line).collect::<Vec<_>>(),
             cell.display_lines(80),
             "bounded drains preserve every row exactly once"
         );

From 2da7484a68ec303314bce93a4d5d34b629ada72b Mon Sep 17 00:00:00 2001
From: XuPeng-SH <xupeng3112@163.com>
Date: Tue, 27 Oct 2026 00:35:12 +0800
Subject: [PATCH 5/6] fix(tui): preserve existing history when placing Zellij
 replies

---
 crates/astra-cli/src/tui/insert_history.rs |  4 +-
 crates/astra-cli/src/tui/terminal.rs       | 46 ++++++++++++++++++++++
 2 files changed, 49 insertions(+), 1 deletion(-)

diff --git a/crates/astra-cli/src/tui/insert_history.rs b/crates/astra-cli/src/tui/insert_history.rs
index 7cad47ceec..f8cd8ab9f7 100644
--- a/crates/astra-cli/src/tui/insert_history.rs
+++ b/crates/astra-cli/src/tui/insert_history.rs
@@ -91,7 +91,9 @@ pub(crate) fn insert_history_lines_with_terminal<B: Backend + Write>(
             should_update_area = true;
         }
 
-        let cursor_top = area.top().saturating_sub(scroll_up + shift_down);
+        // Only emitted bottom newlines scroll existing content upward.
+        // Reserving unused space below the viewport does not move history.
+        let cursor_top = area.top().saturating_sub(scroll_up);
         queue!(writer, MoveTo(0, cursor_top))?;
 
         for (i, line) in wrapped.iter().enumerate() {
diff --git a/crates/astra-cli/src/tui/terminal.rs b/crates/astra-cli/src/tui/terminal.rs
index a6a6d12ccf..06bc820670 100644
--- a/crates/astra-cli/src/tui/terminal.rs
+++ b/crates/astra-cli/src/tui/terminal.rs
@@ -866,6 +866,52 @@ mod tests {
         }
     }
 
+    #[test]
+    fn appended_batches_preserve_existing_history_and_row_positions() {
+        for zellij in [false, true] {
+            let mut terminal = recording_terminal(40, 12);
+            let mut parser = vt100::Parser::new(40, 40, 0);
+            parser.process(b"\x1b[11;1Hexisting-code");
+            let mut pending = queued_assistant("```\nfirst-A\nfirst-B\nfirst-C\n```", 40);
+            super::TerminalGuard::flush_pending_history(&mut terminal, &mut pending, zellij)
+                .unwrap();
+            parser.process(&std::mem::take(&mut terminal.backend_mut().bytes));
+            assert_eq!(
+                parser.screen().rows(0, 40).nth(10).unwrap(),
+                "existing-code",
+                "earlier history overwritten zellij={zellij}"
+            );
+            assert_eq!(parser.screen().rows(0, 40).nth(13).unwrap(), "first-A");
+            assert_eq!(parser.screen().rows(0, 40).nth(15).unwrap(), "first-C");
+            assert_eq!(terminal.viewport_area.y, 16);
+
+            let second = format!("second-batch-{}", "x".repeat(40));
+            pending.extend(queued_assistant(&format!("```\n{second}\n```"), 40));
+            super::TerminalGuard::flush_pending_history(&mut terminal, &mut pending, zellij)
+                .unwrap();
+            parser.process(&std::mem::take(&mut terminal.backend_mut().bytes));
+            assert_eq!(
+                parser.screen().rows(0, 40).nth(10).unwrap(),
+                "existing-code"
+            );
+            assert_eq!(
+                parser.screen().rows(0, 40).nth(13).unwrap(),
+                "first-A",
+                "later batch overwrote previous reply zellij={zellij}"
+            );
+            assert!(
+                parser
+                    .screen()
+                    .rows(0, 40)
+                    .nth(17)
+                    .unwrap()
+                    .starts_with("second-batch-")
+            );
+            assert!(parser.screen().contents().contains(&second));
+            assert_eq!(terminal.viewport_area.y, 19);
+        }
+    }
+
     #[test]
     fn code_softwrap_counts_wide_glyphs_at_current_width() {
         for width in [40_u16, 80, 120] {

From ded8061f7b2f946137cec0b806085d5f64f3f50e Mon Sep 17 00:00:00 2001
From: XuPeng-SH <xupeng3112@163.com>
Date: Tue, 27 Oct 2026 01:34:57 +0800
Subject: [PATCH 6/6] fix(tui): preserve multi-page history across input
 redraws

---
 crates/astra-cli/src/tui/ARCHITECTURE.md   |   3 +
 crates/astra-cli/src/tui/insert_history.rs |  96 ++++++++--------
 crates/astra-cli/src/tui/terminal.rs       | 124 ++++++++++++++++++++-
 3 files changed, 170 insertions(+), 53 deletions(-)

diff --git a/crates/astra-cli/src/tui/ARCHITECTURE.md b/crates/astra-cli/src/tui/ARCHITECTURE.md
index 5f61123120..33161e5988 100644
--- a/crates/astra-cli/src/tui/ARCHITECTURE.md
+++ b/crates/astra-cli/src/tui/ARCHITECTURE.md
@@ -266,6 +266,9 @@ Code rows start at column zero and use terminal soft wrapping; ordinary prose
 keeps its existing layout. Final writes count physical rows at the current
 terminal width without inserting hard line breaks into the code itself.
 Sanitization and structured-link trust remain independent of this layout hint.
+Zellij lets content flow before reserving space for the input area, preserving
+multi-screen code across input redraws and later replies. A full-height input
+area uses the same operation to move output into native scrollback.
 
 This guarantees that Astra adds neither a gutter nor width-generated hard breaks
 to sanitized code rows. Native clipboard selection still depends on the terminal
diff --git a/crates/astra-cli/src/tui/insert_history.rs b/crates/astra-cli/src/tui/insert_history.rs
index f8cd8ab9f7..43663f7ff3 100644
--- a/crates/astra-cli/src/tui/insert_history.rs
+++ b/crates/astra-cli/src/tui/insert_history.rs
@@ -18,21 +18,21 @@ use super::custom_terminal;
 
 /// Insert history lines above the viewport into terminal scrollback.
 /// Matches Codex insert_history.rs Standard/Zellij paths.
+/// Returns whether the viewport must be fully repainted after insertion.
 pub(crate) fn insert_history_lines_with_terminal<B: Backend + Write>(
     terminal: &mut custom_terminal::Terminal<B>,
     rows: &[MarkdownRow],
     trusted_links: bool,
     is_zellij: bool,
-) -> io::Result<()> {
+) -> io::Result<bool> {
     if rows.is_empty() {
-        return Ok(());
+        return Ok(false);
     }
 
     let screen_size = terminal.backend().size().unwrap_or(Size::new(0, 0));
     let area = terminal.viewport_area;
     let last_cursor_pos = terminal.last_known_cursor_pos;
     let wrap_width = screen_size.width.max(1) as usize;
-    let mut should_update_area = false;
 
     // Sanitization is independent of copy semantics. Code and pure URLs use
     // terminal soft wrapping so only logical source rows emit CRLFs.
@@ -67,35 +67,39 @@ pub(crate) fn insert_history_lines_with_terminal<B: Backend + Write>(
     }
 
     if wrapped_rows == 0 {
-        return Ok(());
+        return Ok(false);
     }
 
     let writer = terminal.backend_mut();
-
-    if is_zellij {
-        // Zellij mode: emit newlines at bottom, write at absolute positions
-        let space_below = screen_size.height.saturating_sub(area.bottom());
-        let shift_down = wrapped_rows.min(space_below);
-        let scroll_up = wrapped_rows.saturating_sub(shift_down);
-
-        if scroll_up > 0 {
-            queue!(writer, MoveTo(0, screen_size.height.saturating_sub(1)))?;
-            for _ in 0..scroll_up {
-                queue!(writer, Print("\n"))?;
-            }
-        }
-
-        let mut new_area = area;
-        if shift_down > 0 {
-            new_area.y += shift_down;
-            should_update_area = true;
+    let mut new_area = area;
+
+    // A full-height viewport has no protected history region. Both it and
+    // Zellij need a repaint after content flows through the transient frame.
+    let needs_full_repaint = is_zellij || area.height == screen_size.height;
+    if needs_full_repaint {
+        let end = u32::from(area.top()) + u32::from(wrapped_rows);
+        new_area.y = end.min(u32::from(screen_size.height.saturating_sub(area.height))) as u16;
+        let reserve = end
+            .min(u32::from(screen_size.height))
+            .saturating_sub(u32::from(new_area.top())) as u16;
+
+        queue!(writer, SetAttribute(Attribute::Reset))?;
+        if area.top() < screen_size.height {
+            queue!(writer, MoveTo(0, area.top()))?;
+        } else {
+            // An empty viewport can sit just past the last screen row.
+            // Append rather than overwriting the final history row.
+            queue!(
+                writer,
+                MoveTo(0, screen_size.height.saturating_sub(1)),
+                Print("\r\n")
+            )?;
         }
+        queue!(writer, Clear(ClearType::FromCursorDown))?;
 
-        // Only emitted bottom newlines scroll existing content upward.
-        // Reserving unused space below the viewport does not move history.
-        let cursor_top = area.top().saturating_sub(scroll_up);
-        queue!(writer, MoveTo(0, cursor_top))?;
-
+        // Write first: terminal autowrap naturally scrolls even a single
+        // multi-page code row. Pre-scrolling would clamp its origin to zero
+        // and leave its tail inside the composer.
         for (i, line) in wrapped.iter().enumerate() {
             if i > 0 {
                 queue!(writer, Print("\r\n"))?;
@@ -103,16 +107,13 @@ pub(crate) fn insert_history_lines_with_terminal<B: Backend + Write>(
             write_history_line(writer, line, trusted_links)?;
         }
 
-        // Restore cursor position
-        queue!(writer, MoveTo(last_cursor_pos.x, last_cursor_pos.y))?;
-        Write::flush(writer)?;
-
-        let _ = writer;
-        if should_update_area {
-            terminal.set_viewport_area(new_area);
-        }
-        if wrapped_rows > 0 {
-            terminal.note_history_rows_inserted(wrapped_rows);
+        // Reserve the transient frame only after content has flowed. This
+        // adds at most one viewport height, independent of the batch size.
+        if reserve > 0 {
+            queue!(writer, MoveTo(0, screen_size.height.saturating_sub(1)))?;
+            for _ in 0..reserve {
+                queue!(writer, Print("\n"))?;
+            }
         }
     } else {
         // Standard mode — matches Codex insert_history.rs Standard path:
@@ -123,7 +124,6 @@ pub(crate) fn insert_history_lines_with_terminal<B: Backend + Write>(
         // 3. Write history lines within that protected region.
         // 4. Reset scroll region and restore cursor.
 
-        let mut new_area = area;
         let cursor_top = if area.bottom() < screen_size.height {
             let scroll_amount = wrapped_rows.min(screen_size.height - area.bottom());
 
@@ -140,7 +140,6 @@ pub(crate) fn insert_history_lines_with_terminal<B: Backend + Write>(
 
             let ct = area.top().saturating_sub(1);
             new_area.y += scroll_amount;
-            should_update_area = true;
             ct
         } else {
             area.top().saturating_sub(1)
@@ -158,21 +157,18 @@ pub(crate) fn insert_history_lines_with_terminal<B: Backend + Write>(
 
             queue!(writer, Print("\x1b[r"))?;
         }
+    }
 
-        // Restore cursor position
-        queue!(writer, MoveTo(last_cursor_pos.x, last_cursor_pos.y))?;
-        Write::flush(writer)?;
+    queue!(writer, MoveTo(last_cursor_pos.x, last_cursor_pos.y))?;
+    Write::flush(writer)?;
 
-        let _ = writer;
-        if should_update_area {
-            terminal.set_viewport_area(new_area);
-        }
-        if wrapped_rows > 0 {
-            terminal.note_history_rows_inserted(wrapped_rows);
-        }
+    let _ = writer;
+    if new_area != area {
+        terminal.set_viewport_area(new_area);
     }
+    terminal.note_history_rows_inserted(wrapped_rows);
 
-    Ok(())
+    Ok(needs_full_repaint)
 }
 
 /// Count terminal rows without materializing physical fragments. Carry the
diff --git a/crates/astra-cli/src/tui/terminal.rs b/crates/astra-cli/src/tui/terminal.rs
index 06bc820670..8e737cd241 100644
--- a/crates/astra-cli/src/tui/terminal.rs
+++ b/crates/astra-cli/src/tui/terminal.rs
@@ -489,9 +489,7 @@ impl TerminalGuard {
             &lines,
             trusted_links,
             is_zellij,
-        )?;
-
-        Ok(is_zellij)
+        )
     }
 
     fn pending_history_has_ready_lines(&self) -> bool {
@@ -827,6 +825,126 @@ mod tests {
         })])
     }
 
+    fn drain_and_repaint_history(
+        terminal: &mut crate::tui::custom_terminal::Terminal<RecordingBackend>,
+        pending: &mut VecDeque<PendingHistory>,
+        zellij: bool,
+        parser: &mut vt100::Parser,
+    ) {
+        while !pending.is_empty() {
+            if super::TerminalGuard::flush_pending_history(terminal, pending, zellij).unwrap() {
+                terminal.invalidate_viewport();
+            }
+            terminal
+                .draw(|frame| {
+                    let area = frame.area();
+                    ratatui::widgets::Widget::render(
+                        ratatui::widgets::Paragraph::new("composer\n".repeat(area.height as usize)),
+                        area,
+                        frame.buffer_mut(),
+                    );
+                })
+                .unwrap();
+            parser.process(&std::mem::take(&mut terminal.backend_mut().bytes));
+        }
+    }
+
+    fn text_including_scrollback(parser: &mut vt100::Parser, width: u16) -> String {
+        parser.screen_mut().set_scrollback(usize::MAX);
+        let history = parser.screen().scrollback();
+        let mut text = String::new();
+        for offset in (1..=history).rev() {
+            parser.screen_mut().set_scrollback(offset);
+            text.push_str(&parser.screen().rows(0, width).next().unwrap());
+        }
+        parser.screen_mut().set_scrollback(0);
+        for row in parser.screen().rows(0, width) {
+            text.push_str(&row);
+        }
+        text
+    }
+
+    #[test]
+    fn multi_page_code_survives_composer_repaint_and_following_reply() {
+        for width in [40_u16, 80] {
+            for top in [12_u16, 36] {
+                for physical_rows in [2_u16, 35, 36, 37, 47, 100] {
+                    let code = format!(
+                        "{}END_OF_CODE",
+                        "x".repeat(usize::from(width) * usize::from(physical_rows - 2))
+                    );
+                    for zellij in [false, true] {
+                        let mut terminal = recording_terminal(width, top);
+                        let mut parser = vt100::Parser::new(40, width, 256);
+                        parser.process(format!("\x1b[{};1Hexisting-code", top - 1).as_bytes());
+                        for row in top..top + 4 {
+                            parser.process(format!("\x1b[{};1HSTALE-UI-TAIL", row + 1).as_bytes());
+                        }
+                        let mut pending = queued_assistant(&format!("```\n{code}\n```"), width);
+                        drain_and_repaint_history(&mut terminal, &mut pending, zellij, &mut parser);
+                        let expected_top = (top + physical_rows).min(36);
+                        assert_eq!(terminal.viewport_area.y, expected_top);
+                        assert!(
+                            parser
+                                .screen()
+                                .rows(0, width)
+                                .nth(usize::from(expected_top - 1))
+                                .unwrap()
+                                .contains("END_OF_CODE"),
+                            "tail overwritten width={width} top={top} rows={physical_rows} zellij={zellij}"
+                        );
+
+                        pending.extend(queued_assistant("```\nnext-command\n```", width));
+                        drain_and_repaint_history(&mut terminal, &mut pending, zellij, &mut parser);
+                        let text = text_including_scrollback(&mut parser, width);
+                        // vt100 discards rows scrolled out of a partial DECSTBM
+                        // region. Standard still checks visible placement and
+                        // repaint; only full-screen flow can round-trip native
+                        // scrollback through this emulator.
+                        if zellij {
+                            assert!(text.contains(&code), "code lost: {text:?}");
+                            assert_eq!(text.matches("existing-code").count(), 1);
+                        }
+                        assert_eq!(text.matches("END_OF_CODE").count(), 1);
+                        assert_eq!(text.matches("next-command").count(), 1);
+                        assert!(!text.contains("STALE-UI"), "transient UI entered history");
+                    }
+                }
+            }
+        }
+    }
+
+    #[test]
+    fn full_height_and_empty_viewports_preserve_code_in_scrollback() {
+        for (top, height) in [(0, 40), (40, 0), (12, 0)] {
+            for zellij in [false, true] {
+                for length in [39, 40, 41, 1800, 1801] {
+                    let code = "x".repeat(length);
+                    let mut terminal = recording_terminal(40, top);
+                    terminal.set_viewport_area(ratatui::layout::Rect::new(0, top, 40, height));
+                    let mut parser = vt100::Parser::new(40, 40, 256);
+                    if top > 0 {
+                        parser.process(format!("\x1b[{top};1Hexisting-code").as_bytes());
+                    }
+                    let mut pending = queued_assistant(&format!("```\n{code}\n```"), 40);
+                    drain_and_repaint_history(&mut terminal, &mut pending, zellij, &mut parser);
+                    let text = text_including_scrollback(&mut parser, 40);
+                    assert!(
+                        text.contains(&code),
+                        "code lost top={top} height={height} zellij={zellij} length={length}"
+                    );
+                    assert_eq!(text.matches('x').count(), length + usize::from(top > 0));
+                    if top > 0 {
+                        assert!(
+                            text.contains("existing-code"),
+                            "last history row overwritten"
+                        );
+                    }
+                }
+            }
+        }
+    }
+
     #[test]
     fn settled_code_reaches_final_writer_without_hard_wraps() {
         let command =