@pheem49/mint 1.17.0 → 1.18.0

package/crates/mint-cli/src/agent/diff_render.rs

@@ -49,68 +49,90 @@ pub(super) fn print_diff_header(action: &str, path: &str, additions: usize, dele
     );
 }
 
-/// Prints one diff row as a full-width color band (like a diff viewer's gutter
-/// highlight), padding `content` with spaces out to the terminal width so the
-/// background color fills the row instead of just wrapping the text.
-pub(super) fn print_diff_band(bg: &str, line_num: usize, content: &str, term_width: usize) {
-    let line_num_str = format!("{:>5}", line_num);
-    let prefix_visible_len = 2 + line_num_str.chars().count() + 1;
-    // Use the app's East-Asian/Thai-combining-mark-aware width, not a raw
-    // char count — a naive count over/under-shoots the true terminal column
-    // width for wide glyphs and zero-width Thai marks, leaving the band short
-    // of (or past) the terminal edge.
-    let available_width = term_width.saturating_sub(prefix_visible_len).max(1);
-    let blank_line_num = " ".repeat(line_num_str.chars().count());
-
-    // A code/diff line longer than the terminal is hard-wrapped (never
-    // word-wrapped, which would collapse indentation) into multiple physical
-    // lines so the colored band never overflows past the terminal edge — the
-    // same class of bug the markdown table renderer had.
-    for (i, wrapped_line) in markdown::hard_wrap(content, available_width)
-        .into_iter()
-        .enumerate()
-    {
-        let line_label = if i == 0 {
-            &line_num_str
-        } else {
-            &blank_line_num
-        };
-        let content_len = crate::interactive::string_visual_width(&wrapped_line);
-        let pad_len = available_width.saturating_sub(content_len);
-        println!(
-            "  {DIM}{line_label}{RESET} {bg}{wrapped_line}{}{RESET}",
-            " ".repeat(pad_len)
-        );
-    }
-}
-
-pub(super) fn print_colored_diff(diff: &str) {
-    let (term_width, _) = markdown::terminal_size_or_default();
-    let term_width = term_width as usize;
+pub(crate) fn format_colored_diff_lines(diff: &str, term_width: usize) -> Vec<String> {
+    let term_width = term_width.max(20);
+    let mut out = Vec::new();
     let mut current_old_line = 1;
     let mut current_new_line = 1;
 
+    let push_band = |out: &mut Vec<String>, bg: &str, line_num: usize, content: &str| {
+        let line_num_str = format!("{:>5}", line_num);
+        let prefix_visible_len = 2 + line_num_str.chars().count() + 1;
+        let available_width = term_width.saturating_sub(prefix_visible_len).max(1);
+        let blank_line_num = " ".repeat(line_num_str.chars().count());
+
+        for (i, wrapped_line) in markdown::hard_wrap(content, available_width)
+            .into_iter()
+            .enumerate()
+        {
+            let line_label = if i == 0 {
+                &line_num_str
+            } else {
+                &blank_line_num
+            };
+            let content_len = crate::interactive::string_visual_width(&wrapped_line);
+            let pad_len = available_width.saturating_sub(content_len);
+            out.push(format!(
+                "  {DIM}{line_label}{RESET} {bg}{wrapped_line}{}{RESET}",
+                " ".repeat(pad_len)
+            ));
+        }
+    };
+
     for line in diff.lines() {
         if line.starts_with("@@") {
-            // Still track line numbers from the hunk header, just don't print
-            // the raw unified-diff header/marker lines — they're noise here.
             if let Some((old_s, new_s)) = parse_hunk_header(line) {
                 current_old_line = old_s;
                 current_new_line = new_s;
             }
         } else if line.starts_with("--- ") || line.starts_with("+++ ") {
-            // skip: raw diff file-header lines aren't useful in an approval prompt
+            // skip raw diff file-header lines
         } else if let Some(content) = line.strip_prefix('-') {
-            print_diff_band(BG_DEL, current_old_line, content, term_width);
+            push_band(&mut out, BG_DEL, current_old_line, content);
             current_old_line += 1;
         } else if let Some(content) = line.strip_prefix('+') {
-            print_diff_band(BG_ADD, current_new_line, content, term_width);
+            push_band(&mut out, BG_ADD, current_new_line, content);
             current_new_line += 1;
         } else {
             let line_num_str = format!("{:>5}", current_new_line);
             current_old_line += 1;
             current_new_line += 1;
-            println!("  {DIM}{line_num_str}{RESET} {line}");
+            out.push(format!("  {DIM}{line_num_str}{RESET} {line}"));
         }
     }
+    out
+}
+
+#[allow(dead_code)]
+pub(crate) fn render_diff_to_ratatui_lines(
+    diff: &str,
+    term_width: usize,
+) -> Vec<ratatui::text::Line<'static>> {
+    let ansi_joined = format_colored_diff_lines(diff, term_width).join("\n");
+    if let Ok(parsed) = ansi_joined.into_text() {
+        parsed.lines
+    } else {
+        diff.lines()
+            .map(|l| ratatui::text::Line::raw(l.to_string()))
+            .collect()
+    }
+}
+
+pub(super) fn print_colored_diff(diff: &str) {
+    let (term_width, _) = markdown::terminal_size_or_default();
+    for line in format_colored_diff_lines(diff, term_width as usize) {
+        println!("{line}");
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn render_diff_to_ratatui_lines_formats_hunks_at_requested_width() {
+        let diff = "@@ -1,2 +1,2 @@\n-old line\n+new line\n context";
+        let lines = render_diff_to_ratatui_lines(diff, 60);
+        assert_eq!(lines.len(), 3);
+    }
 }

package/crates/mint-cli/src/agent/live_status.rs

@@ -204,8 +204,16 @@ fn ramp_estimate(estimated: u64, elapsed_secs: f64) -> u64 {
 }
 
 pub(super) fn render_live_summary(summary: &str) {
+    use std::io::IsTerminal;
     let (tw, _) = markdown::terminal_size_or_default();
     let width = tw as usize;
+    let total_lines = summary.lines().count().max(1);
+    let pace_delay = if io::stdout().is_terminal() {
+        let per_line_ms = (500 / total_lines as u64).clamp(4, 16);
+        Duration::from_millis(per_line_ms)
+    } else {
+        Duration::ZERO
+    };
 
     let mut is_first = true;
     let mut table_buffer: Vec<String> = Vec::new();
@@ -219,6 +227,10 @@ pub(super) fn render_live_summary(summary: &str) {
         if !table_buffer.is_empty() {
             print_table_block(&table_buffer, &mut is_first);
             table_buffer.clear();
+            if !pace_delay.is_zero() {
+                let _ = io::stdout().flush();
+                std::thread::sleep(pace_delay);
+            }
         }
 
         let indent = if is_first { "" } else { "  " };
@@ -234,6 +246,10 @@ pub(super) fn render_live_summary(summary: &str) {
         } else {
             print!("\n{wrapped}");
         }
+        if !pace_delay.is_zero() {
+            let _ = io::stdout().flush();
+            std::thread::sleep(pace_delay);
+        }
     }
 
     if !table_buffer.is_empty() {
@@ -544,13 +560,14 @@ pub(super) fn explored_action_label(
 }
 
 pub(super) fn display_tool_target(path: &str) -> String {
-    if path.trim().is_empty() {
-        ".".into()
+    let trimmed = path.trim();
+    if trimmed.is_empty() || trimmed == "." || trimmed == "./" {
+        "workspace".into()
     } else {
-        Path::new(path)
+        Path::new(trimmed)
             .file_name()
             .and_then(|name| name.to_str())
-            .unwrap_or(path)
+            .unwrap_or(trimmed)
             .into()
     }
 }

package/crates/mint-cli/src/agent/markdown_render.rs

@@ -271,9 +271,251 @@ fn try_render_single_line_custom_block(raw: &str, term_width: usize) -> Option<V
     None
 }
 
+pub(crate) fn is_atomic_fenced_lang(lang: &str) -> bool {
+    matches!(
+        lang.to_ascii_lowercase().as_str(),
+        "ui-grid"
+            | "ui_grid"
+            | "ui-grid-json"
+            | "ui_grid_json"
+            | "ui-card"
+            | "ui_card"
+            | "ui-card-json"
+            | "ui_card_json"
+            | "ui-feature"
+            | "ui_feature"
+            | "ui-mockup"
+            | "ui_mockup"
+            | "ui-mockup-json"
+            | "ui_mockup_json"
+            | "weather_json"
+            | "weather-json"
+            | "stock_json"
+            | "stock-json"
+            | "calculation_json"
+            | "calculation-json"
+            | "image_search_json"
+            | "image-search-json"
+            | "image_gen_json"
+            | "image-gen-json"
+            | "mermaid"
+    )
+}
+
+/// Splits Markdown into progressive reveal units:
+/// - Regular text, headings, lists, callouts, and standard code blocks split line-by-line.
+/// - Markdown tables (`| ... |`) group all consecutive rows into a single atomic unit.
+/// - Custom UI/JSON/Mermaid fenced blocks (`ui-card`, `ui-grid`, `ui-mockup`, etc.) group the
+///   entire fenced block into a single atomic unit so raw JSON never flashes mid-stream.
+///
+/// When `is_complete` is `false`, trailing incomplete lines, open tables, and unclosed atomic
+/// fenced blocks are held back until completed.
+pub(crate) fn split_progressive_units(raw: &str, is_complete: bool) -> Vec<String> {
+    if raw.is_empty() {
+        return Vec::new();
+    }
+    let slice = if is_complete || raw.ends_with('\n') {
+        raw
+    } else if let Some(last_nl) = raw.rfind('\n') {
+        &raw[..=last_nl]
+    } else {
+        return Vec::new();
+    };
+
+    let mut units = Vec::new();
+    let mut in_code_block = false;
+    let mut pending_code_fence: Option<(String, bool)> = None;
+    let mut in_atomic_fence = false;
+    let mut atomic_fence_buffer: Vec<String> = Vec::new();
+    let mut table_buffer: Vec<String> = Vec::new();
+
+    for raw_line in slice.lines() {
+        let line = raw_line.strip_suffix('\r').unwrap_or(raw_line);
+        let trimmed = line.trim_start();
+
+        if !in_code_block && !in_atomic_fence && markdown::is_table_line(trimmed) {
+            table_buffer.push(line.to_owned());
+            continue;
+        }
+
+        if !table_buffer.is_empty() {
+            units.push(table_buffer.join("\n"));
+            table_buffer.clear();
+        }
+
+        if trimmed.starts_with("```") {
+            if !in_code_block && !in_atomic_fence {
+                let after_open = trimmed.trim_start_matches('`').trim();
+                if after_open.ends_with("```") && after_open.len() > 3 {
+                    units.push(line.to_owned());
+                    continue;
+                }
+                let lang = if let Some(idx) =
+                    after_open.find(|c: char| c.is_whitespace() || c == '[' || c == '{')
+                {
+                    &after_open[..idx]
+                } else {
+                    after_open
+                };
+                if is_atomic_fenced_lang(lang) {
+                    in_atomic_fence = true;
+                    atomic_fence_buffer.clear();
+                    atomic_fence_buffer.push(line.to_owned());
+                } else {
+                    in_code_block = true;
+                    let can_promote = lang.is_empty() || lang.eq_ignore_ascii_case("plaintext");
+                    pending_code_fence = Some((line.to_owned(), can_promote));
+                }
+            } else if in_atomic_fence {
+                atomic_fence_buffer.push(line.to_owned());
+                units.push(atomic_fence_buffer.join("\n"));
+                atomic_fence_buffer.clear();
+                in_atomic_fence = false;
+            } else {
+                in_code_block = false;
+                if let Some((fence, _)) = pending_code_fence.take() {
+                    units.push(format!("{fence}\n{line}"));
+                } else {
+                    units.push(line.to_owned());
+                }
+            }
+            continue;
+        }
+
+        if in_atomic_fence {
+            atomic_fence_buffer.push(line.to_owned());
+            continue;
+        }
+
+        if let Some((fence, can_promote)) = pending_code_fence.take() {
+            let first_token = trimmed
+                .find(|c: char| c.is_whitespace() || c == '[' || c == '{')
+                .map_or(trimmed, |idx| &trimmed[..idx]);
+            if can_promote && is_atomic_fenced_lang(first_token) {
+                in_code_block = false;
+                in_atomic_fence = true;
+                atomic_fence_buffer.clear();
+                atomic_fence_buffer.push(fence);
+                atomic_fence_buffer.push(line.to_owned());
+            } else {
+                units.push(format!("{fence}\n{line}"));
+            }
+            continue;
+        }
+
+        units.push(line.to_owned());
+    }
+
+    if is_complete {
+        if !table_buffer.is_empty() {
+            units.push(table_buffer.join("\n"));
+        }
+        if let Some((fence, _)) = pending_code_fence.take() {
+            units.push(fence);
+        }
+        if !atomic_fence_buffer.is_empty() {
+            units.push(atomic_fence_buffer.join("\n"));
+        }
+    }
+
+    units
+}
+
+#[derive(Debug, Default, Clone)]
+pub(crate) struct ProgressiveMarkdownPacer {
+    raw_buffer: String,
+    completed: bool,
+    revealed_units: usize,
+}
+
+impl ProgressiveMarkdownPacer {
+    pub fn push_delta(&mut self, delta: &str) {
+        if !delta.is_empty() {
+            self.raw_buffer.push_str(delta);
+        }
+    }
+
+    pub fn finish_with_authoritative(&mut self, full_text: &str) {
+        self.raw_buffer.clear();
+        self.raw_buffer.push_str(full_text);
+        self.completed = true;
+    }
+
+    pub fn is_completed(&self) -> bool {
+        self.completed
+    }
+
+    pub fn is_done(&self) -> bool {
+        if !self.completed {
+            return false;
+        }
+        let units = split_progressive_units(&self.raw_buffer, true);
+        self.revealed_units >= units.len()
+    }
+
+    pub fn step(&mut self) -> Option<String> {
+        let units = split_progressive_units(&self.raw_buffer, self.completed);
+        if self.revealed_units >= units.len() {
+            return None;
+        }
+        let remaining = units.len() - self.revealed_units;
+        let advance = if remaining <= 12 {
+            1
+        } else {
+            (remaining / 10).clamp(1, 4)
+        };
+        self.revealed_units = (self.revealed_units + advance).min(units.len());
+        Some(units[..self.revealed_units].join("\n"))
+    }
+
+    pub fn flush_all(&mut self) -> Option<String> {
+        self.completed = true;
+        let units = split_progressive_units(&self.raw_buffer, true);
+        if units.is_empty() {
+            return None;
+        }
+        self.revealed_units = units.len();
+        Some(units.join("\n"))
+    }
+}
+
 pub(crate) fn format_markdown_bold(text: &str) -> String {
     let (term_width, _) = markdown::terminal_size_or_default();
-    let term_width = term_width as usize;
+    format_markdown_bold_with_width(text, term_width as usize)
+}
+
+pub(crate) fn render_markdown_to_lines(
+    text: &str,
+    term_width: usize,
+) -> (Vec<ratatui::text::Line<'static>>, Vec<String>) {
+    if text.is_empty() {
+        return (Vec::new(), Vec::new());
+    }
+    let processed = format_markdown_bold_with_width(text, term_width.max(20));
+    if let Ok(parsed) = processed.into_text() {
+        let rendered = parsed.lines;
+        let plain: Vec<String> = rendered
+            .iter()
+            .map(|line| {
+                line.spans
+                    .iter()
+                    .map(|span| span.content.as_ref())
+                    .collect::<String>()
+            })
+            .collect();
+        (rendered, plain)
+    } else {
+        let rendered: Vec<ratatui::text::Line<'static>> = text
+            .lines()
+            .map(|l| ratatui::text::Line::raw(l.to_string()))
+            .collect();
+        let plain: Vec<String> = text.lines().map(str::to_owned).collect();
+        (rendered, plain)
+    }
+}
+
+pub(crate) fn format_markdown_bold_with_width(text: &str, term_width: usize) -> String {
+    let term_width = term_width.max(20);
 
     let mut formatted_lines = Vec::new();
     let mut in_code_block = false;
@@ -282,7 +524,7 @@ pub(crate) fn format_markdown_bold(text: &str) -> String {
     let mut custom_block_buffer: Vec<String> = Vec::new();
     let mut active_alert_color: Option<&'static str> = None;
     // Markdown table buffering: collect consecutive `|...|` lines so we can
-    // flush them through `render_markdown_table` as a unit (same as classic
+    // flush them through `render_markdown_table_with_width` as a unit (same as classic
     // mode in `render_live_summary`).
     let mut table_buffer: Vec<String> = Vec::new();
 
@@ -290,7 +532,10 @@ pub(crate) fn format_markdown_bold(text: &str) -> String {
     macro_rules! flush_table {
         () => {
             if !table_buffer.is_empty() {
-                let rendered = markdown::render_markdown_table(&table_buffer);
+                let rendered = markdown::render_markdown_table_with_width(
+                    &table_buffer,
+                    term_width.min(u16::MAX as usize) as u16,
+                );
                 for tl in rendered.split('\n') {
                     formatted_lines.push(tl.to_string());
                 }
@@ -347,7 +592,7 @@ pub(crate) fn format_markdown_bold(text: &str) -> String {
                     } else {
                         formatted_lines.push(code_block_top_border(&custom_lang, term_width));
                         for l in buffered.lines() {
-                            formatted_line = format!("{CODE_BORDER}│{RESET} {l}");
+                            formatted_line = format!("  {l}");
                             formatted_lines.push(formatted_line);
                         }
                         formatted_lines.push(code_block_bottom_border(term_width));
@@ -395,7 +640,7 @@ pub(crate) fn format_markdown_bold(text: &str) -> String {
                 Some(h) => highlight_code_line(h, line),
                 None => line.to_string(),
             };
-            formatted_line = format!("{CODE_BORDER}│{RESET} {content}{RESET}");
+            formatted_line = format!("  {content}{RESET}");
             formatted_lines.push(formatted_line);
             continue;
         }
@@ -767,4 +1012,96 @@ mod tests {
         assert!(output_grid.contains("OptionA"));
         assert!(output_grid.contains("Best choice"));
     }
+
+    #[test]
+    fn test_progressive_units_splits_text_and_code_line_by_line_but_groups_tables_and_ui_cards() {
+        let doc = "\
+# Heading
+Paragraph line 1
+| Col A | Col B |
+| --- | --- |
+| 1 | 2 |
+After table
+```rust
+fn main() {}
+```
+```ui-card
+[{\"title\": \"CardTitle\", \"subtitle\": \"Sub\"}]
+```
+Final line";
+
+        let units = split_progressive_units(doc, true);
+        assert_eq!(
+            units,
+            vec![
+                "# Heading",
+                "Paragraph line 1",
+                "| Col A | Col B |\n| --- | --- |\n| 1 | 2 |",
+                "After table",
+                "```rust\nfn main() {}",
+                "```",
+                "```ui-card\n[{\"title\": \"CardTitle\", \"subtitle\": \"Sub\"}]\n```",
+                "Final line",
+            ]
+        );
+    }
+
+    #[test]
+    fn test_progressive_units_holds_incomplete_table_and_unclosed_ui_card_while_streaming() {
+        let streaming_table = "Intro line\n| Header 1 | Header 2 |\n| --- | --- |\n";
+        let units = split_progressive_units(streaming_table, false);
+        assert_eq!(units, vec!["Intro line"]);
+
+        let streaming_card = "Intro line\n```ui-grid\n[{\"title\": \"A\"}]\n";
+        let units_card = split_progressive_units(streaming_card, false);
+        assert_eq!(units_card, vec!["Intro line"]);
+
+        // Bare opening fence without its first code line is held so an empty code box never flashes
+        let bare_fence = "Intro line\n```rust\n";
+        assert_eq!(
+            split_progressive_units(bare_fence, false),
+            vec!["Intro line"]
+        );
+
+        let streaming_code = "Intro line\n```rust\nlet x = 1;\nlet y = 2;\n";
+        let units_code = split_progressive_units(streaming_code, false);
+        assert_eq!(
+            units_code,
+            vec!["Intro line", "```rust\nlet x = 1;", "let y = 2;"]
+        );
+
+        // Unlabeled fence whose first line is a ui-card keyword is promoted to atomic block
+        let unlabeled_card = "Intro line\n```\nui-card [\n  {\"title\": \"A\"}\n]\n";
+        assert_eq!(
+            split_progressive_units(unlabeled_card, false),
+            vec!["Intro line"]
+        );
+        let closed_unlabeled_card = "Intro line\n```\nui-card [\n  {\"title\": \"A\"}\n]\n```\n";
+        assert_eq!(
+            split_progressive_units(closed_unlabeled_card, false),
+            vec!["Intro line", "```\nui-card [\n  {\"title\": \"A\"}\n]\n```"]
+        );
+    }
+
+    #[test]
+    fn test_progressive_markdown_pacer_reveals_units_progressively_and_flushes() {
+        let mut pacer = ProgressiveMarkdownPacer::default();
+        pacer.push_delta("Line 1\nLine 2\n| A | B |\n| - | - |\n");
+        assert_eq!(pacer.step().as_deref(), Some("Line 1"));
+        assert_eq!(pacer.step().as_deref(), Some("Line 1\nLine 2"));
+        // Table is still open because no non-table line or finish has arrived
+        assert_eq!(pacer.step(), None);
+        assert!(!pacer.is_done());
+
+        pacer.finish_with_authoritative("Line 1\nLine 2\n| A | B |\n| - | - |\nDone");
+        assert_eq!(
+            pacer.step().as_deref(),
+            Some("Line 1\nLine 2\n| A | B |\n| - | - |")
+        );
+        assert_eq!(
+            pacer.step().as_deref(),
+            Some("Line 1\nLine 2\n| A | B |\n| - | - |\nDone")
+        );
+        assert!(pacer.is_done());
+    }
 }

package/crates/mint-cli/src/agent.rs

@@ -25,7 +25,7 @@ mod diff_render;
 mod live_status;
 mod markdown_render;
 use approval_prompts::*;
-use diff_render::*;
+pub(crate) use diff_render::*;
 pub(crate) use live_status::*;
 pub(crate) use markdown_render::*;
 
@@ -483,7 +483,11 @@ fn tui_approval(
         AgentApproval::UserApproval { title, prompt } => yes_no(title, prompt.to_owned()),
         AgentApproval::EnterPlanMode { reason } => yes_no("Enter plan mode?", reason.to_owned()),
         AgentApproval::ExitPlanMode { plan } => {
-            let outcome = yes_no("Review plan", plan.to_owned());
+            tui.push_plan(plan);
+            let outcome = yes_no(
+                "Review plan",
+                "Do you want to proceed with this plan?".to_string(),
+            );
             if outcome == ApprovalOutcome::Approved {
                 match save_plan_file(root, plan) {
                     Ok(path) => tui.push_notice(format!("Plan saved to {}", path.display())),
@@ -1339,7 +1343,7 @@ pub async fn run_code_agent_with_options(
                 ..
             } => {
                 let remaining = progress_tool_running
-                    .fetch_update(Ordering::Relaxed, Ordering::Relaxed, |running| {
+                    .try_update(Ordering::Relaxed, Ordering::Relaxed, |running| {
                         Some(running.saturating_sub(1))
                     })
                     .unwrap_or(0)
@@ -1509,9 +1513,12 @@ pub async fn run_code_agent_with_options(
         }
     };
 
-    // Providers may still stream internally, but the CLI deliberately waits
-    // for AgentResult.summary so it can render one complete Markdown document.
-    let on_chunk = |_summary: String| {};
+    let chunk_tui = options.tui.clone();
+    let on_chunk = move |delta: String| {
+        if let Some(tui) = &chunk_tui {
+            tui.append_assistant_delta(&delta);
+        }
+    };
 
     let user_name = MemoryStore::open_default()
         .ok()
@@ -1628,17 +1635,18 @@ pub async fn run_code_agent_with_options(
     let worked_line = format!("{DIM}{label} {}{RESET}", "─".repeat(fill_len));
 
     if let Some(tui) = &options.tui {
-        tui.push_assistant(res.summary.clone());
+        let mut post_notices = Vec::new();
         if let Ok(mut status) = live_status.lock()
             && !status.web_sources.is_empty()
         {
             let sources = status.web_sources.drain(..).collect::<Vec<_>>();
             let text = format_tui_web_sources(&sources, MAX_TUI_WEB_SOURCES);
             if !text.is_empty() {
-                tui.push_notice(text);
+                post_notices.push(text);
             }
         }
-        tui.push_notice(worked_line);
+        post_notices.push(worked_line);
+        tui.begin_assistant_reveal(res.summary.clone(), post_notices);
         avatar_bridge.on_talking(false);
         return Ok(res);
     }
@@ -1783,7 +1791,14 @@ mod format_markdown_bold_tests {
             strip_ansi(&out).contains("print(1)"),
             "code content dropped: {out}"
         );
-        assert!(out.contains('│'), "missing gutter bar: {out}");
+        assert!(
+            !out.contains('│'),
+            "code block should not have vertical pipe gutter: {out}"
+        );
+        assert!(
+            strip_ansi(&out).contains("  print(1)"),
+            "code block should be indented with 2 spaces: {out}"
+        );
     }
 
     #[test]