diff --git a/crates/astra-cli/src/tui/ARCHITECTURE.md b/crates/astra-cli/src/tui/ARCHITECTURE.md
index d4768fa979..33161e5988 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
+│    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 with `█ ` accent gutter; 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,21 @@ 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.
+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
+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/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..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/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 e004786131..660056b95d 100644
--- a/crates/astra-cli/src/tui/history_cell/assistant.rs
+++ b/crates/astra-cli/src/tui/history_cell/assistant.rs
@@ -11,12 +11,11 @@
 //! 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 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.
 //!
 //! ## Inline thinking handling
@@ -46,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;
 
@@ -63,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
@@ -270,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,
         });
     }
 
@@ -290,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
@@ -302,42 +299,29 @@ 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
     }
 
-    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);
         }
         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| {
-                let mut spans = Vec::with_capacity(line.spans.len() + 1);
-                spans.push(Span::styled("█ ", gutter_style));
-                spans.extend(line.spans);
-                Line::from(spans)
-            })
-            .collect();
+        let lines = rendered.into_iter().map(prefix_settled_row).collect();
         (lines, total)
     }
 
@@ -515,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);
@@ -545,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);
@@ -560,7 +545,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,22 +563,29 @@ impl AssistantCell {
             return Vec::new();
         }
 
-        let theme = crate::tui::theme::current();
-        let gutter_style = Style::default().fg(theme.success);
         rendered
             .into_iter()
-            .map(|line| {
-                let mut spans: Vec<Span<'static>> = Vec::with_capacity(line.spans.len() + 1);
+            .map(|row| {
                 if prepend_gutter {
-                    spans.push(Span::styled("█ ", gutter_style));
+                    prefix_settled_row(row).line
+                } else {
+                    row.line
                 }
-                spans.extend(line.spans.iter().cloned());
-                Line::from(spans)
             })
             .collect()
     }
 }
 
+/// 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 {
     fn model_item_id(&self) -> Option<&str> {
         self.model_item_id.as_deref()
@@ -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;
             }
@@ -1088,15 +1080,46 @@ mod tests {
     }
 
     #[test]
-    fn settled_assistant_guide_matches_terminal_success_marker() {
-        let c = AssistantCell::from_markdown("done");
-        let lines = c.display_lines(40);
-        let guide = 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));
+    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_rows_chunk(80, 0, usize::MAX);
+            assert!(complete);
+            for lines in [
+                c.display_lines(80),
+                scrollback.into_iter().map(|row| row.line).collect(),
+            ] {
+                assert_eq!(line_text(&lines), "  git status", "{source:?}");
+            }
+        }
+    }
+
+    #[test]
+    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_rows_chunk(80, 0, usize::MAX);
+            assert!(complete);
+            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}")),
+                    "{source:?} rendered {text:?}"
+                );
+                assert!(!text.contains('●'), "{text}");
+                assert!(!text.contains('█'), "{text}");
+            }
+        }
     }
 
     #[test]
@@ -1136,17 +1159,22 @@ 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);
-        assert!(first[0].spans[0].content.starts_with("█ "));
-        assert!(second[0].spans[0].content.starts_with("█ "));
+        assert!(
+            first
+                .iter()
+                .chain(&second)
+                .all(|row| row.line.spans[0].content.as_ref() == "  "),
+            "every chunk indents prose rows with plain spaces"
+        );
     }
 
     #[test]
@@ -1157,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/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..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 4c7df78546..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:
-█ • 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..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/insert_history.rs b/crates/astra-cli/src/tui/insert_history.rs
index 0741645ea3..43663f7ff3 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,97 +11,95 @@ 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;
 
 /// 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>,
-    lines: &[Line<'_>],
+    rows: &[MarkdownRow],
     trusted_links: bool,
     is_zellij: bool,
-) -> io::Result<()> {
-    if lines.is_empty() {
-        return Ok(());
+) -> io::Result<bool> {
+    if rows.is_empty() {
+        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 = area.width.max(1) as usize;
-    let mut should_update_area = false;
+    let wrap_width = screen_size.width.max(1) as usize;
 
-    // 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)
-                }
-            }));
         }
     }
 
     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))?;
 
-        let cursor_top = area.top().saturating_sub(scroll_up + shift_down);
-        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"))?;
@@ -108,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:
@@ -128,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());
 
@@ -145,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)
@@ -163,21 +157,47 @@ 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
+/// 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(
diff --git a/crates/astra-cli/src/tui/markdown_render.rs b/crates/astra-cli/src/tui/markdown_render.rs
index c43c34b33d..b248e77b02 100644
--- a/crates/astra-cli/src/tui/markdown_render.rs
+++ b/crates/astra-cli/src/tui/markdown_render.rs
@@ -47,6 +47,35 @@ 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` 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>,
+) -> 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 +83,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 +93,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 +145,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 +358,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 +612,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/terminal.rs b/crates/astra-cli/src/tui/terminal.rs
index b696017f25..8e737cd241 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> {
@@ -487,9 +489,7 @@ impl TerminalGuard {
             &lines,
             trusted_links,
             is_zellij,
-        )?;
-
-        Ok(is_zellij)
+        )
     }
 
     fn pending_history_has_ready_lines(&self) -> bool {
@@ -570,41 +570,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 +606,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 +629,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 +645,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 +653,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 +675,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 +693,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 +721,509 @@ 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};
 
+    struct RecordingBackend {
+        inner: ratatui::backend::TestBackend,
+        bytes: Vec<u8>,
+        fail_writes: bool,
+    }
+
+    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(),
+        })])
+    }
+
+    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 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<_>>();
+    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");
+                    }
+                }
+            }
+        }
+    }
 
-        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}")
-        );
+    #[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 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));
+                }
+            }
+        }
+    }
+
+    #[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] {
+            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));
+                }
+            }
+        }
+    }
 
-        let first = take_history_batch(&mut pending);
-        assert_eq!(first.len(), 1);
-        assert_eq!(first[0].spans[0].content.len(), 32 * 1024);
+    #[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 +1248,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 +1258,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"
         );
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() {