Enable local image prompts without breaking text-only CLI flows

The Rust CLI now recognizes explicit local image references in prompt text,
encodes supported image files as base64, and serializes mixed text/image
content blocks for the API. The request conversion path was kept narrow so
existing runtime/session structures remain stable while prompt mode and user
text conversion gain multimodal support.

Constraint: Must support PNG, JPG/JPEG, GIF, and WebP without adding broad runtime abstractions
Constraint: Existing text-only prompt behavior and API tool flows must keep working unchanged
Rejected: Add only explicit --image CLI flags | does not satisfy auto-detect image refs in prompt text
Rejected: Persist native image blocks in runtime session model | broader refactor than needed for prompt support
Confidence: high
Scope-risk: moderate
Reversibility: clean
Directive: Keep image parsing scoped to outbound user prompt adaptation unless session persistence truly needs multimodal history
Tested: cargo fmt --all; cargo clippy --workspace --all-targets -- -D warnings; cargo test --workspace
Not-tested: Live remote multimodal request against Anthropic API

rust/crates/api/src/lib.rs

@@ -11,7 +11,7 @@ pub use error::ApiError;
 pub use sse::{parse_frame, SseParser};
 pub use types::{
     ContentBlockDelta, ContentBlockDeltaEvent, ContentBlockStartEvent, ContentBlockStopEvent,
-    InputContentBlock, InputMessage, MessageDelta, MessageDeltaEvent, MessageRequest,
+    ImageSource, InputContentBlock, InputMessage, MessageDelta, MessageDeltaEvent, MessageRequest,
     MessageResponse, MessageStartEvent, MessageStopEvent, OutputContentBlock, StreamEvent,
     ToolChoice, ToolDefinition, ToolResultContentBlock, Usage,
 };

rust/crates/api/src/types.rs

@@ -64,6 +64,9 @@ pub enum InputContentBlock {
     Text {
         text: String,
     },
+    Image {
+        source: ImageSource,
+    },
     ToolUse {
         id: String,
         name: String,
@@ -77,6 +80,14 @@ pub enum InputContentBlock {
     },
 }
 
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
+pub struct ImageSource {
+    #[serde(rename = "type")]
+    pub kind: String,
+    pub media_type: String,
+    pub data: String,
+}
+
 #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
 #[serde(tag = "type", rename_all = "snake_case")]
 pub enum ToolResultContentBlock {

rust/crates/api/tests/client_integration.rs

@@ -4,8 +4,8 @@ use std::time::Duration;
 
 use api::{
     AnthropicClient, ApiError, ContentBlockDelta, ContentBlockDeltaEvent, ContentBlockStartEvent,
-    InputContentBlock, InputMessage, MessageDeltaEvent, MessageRequest, OutputContentBlock,
+    ImageSource, InputContentBlock, InputMessage, MessageDeltaEvent, MessageRequest,
-    StreamEvent, ToolChoice, ToolDefinition,
+    OutputContentBlock, StreamEvent, ToolChoice, ToolDefinition,
 };
 use serde_json::json;
 use tokio::io::{AsyncReadExt, AsyncWriteExt};
@@ -75,6 +75,39 @@ async fn send_message_posts_json_and_parses_response() {
     assert_eq!(body["tool_choice"]["type"], json!("auto"));
 }
 
+#[test]
+fn image_content_blocks_serialize_with_base64_source() {
+    let request = MessageRequest {
+        model: "claude-3-7-sonnet-latest".to_string(),
+        max_tokens: 64,
+        messages: vec![InputMessage {
+            role: "user".to_string(),
+            content: vec![InputContentBlock::Image {
+                source: ImageSource {
+                    kind: "base64".to_string(),
+                    media_type: "image/png".to_string(),
+                    data: "AQID".to_string(),
+                },
+            }],
+        }],
+        system: None,
+        tools: None,
+        tool_choice: None,
+        stream: false,
+    };
+
+    let json = serde_json::to_value(request).expect("request should serialize");
+    assert_eq!(json["messages"][0]["content"][0]["type"], json!("image"));
+    assert_eq!(
+        json["messages"][0]["content"][0]["source"],
+        json!({
+            "type": "base64",
+            "media_type": "image/png",
+            "data": "AQID"
+        })
+    );
+}
+
 #[tokio::test]
 async fn stream_message_parses_sse_events_with_tool_use() {
     let state = Arc::new(Mutex::new(Vec::<CapturedRequest>::new()));

rust/crates/rusty-claude-cli/src/main.rs

@@ -11,8 +11,8 @@ use std::process::Command;
 use std::time::{SystemTime, UNIX_EPOCH};
 
 use api::{
-    resolve_startup_auth_source, AnthropicClient, AuthSource, ContentBlockDelta, InputContentBlock,
+    resolve_startup_auth_source, AnthropicClient, AuthSource, ContentBlockDelta, ImageSource,
-    InputMessage, MessageRequest, MessageResponse, OutputContentBlock,
+    InputContentBlock, InputMessage, MessageRequest, MessageResponse, OutputContentBlock,
     StreamEvent as ApiStreamEvent, ToolChoice, ToolDefinition, ToolResultContentBlock,
 };
 
@@ -41,6 +41,7 @@ const BUILD_TARGET: Option<&str> = option_env!("TARGET");
 const GIT_SHA: Option<&str> = option_env!("GIT_SHA");
 
 type AllowedToolSet = BTreeSet<String>;
+const IMAGE_REF_PREFIX: &str = "@";
 
 fn main() {
     if let Err(error) = run() {
@@ -1042,9 +1043,7 @@ impl LiveCli {
             max_tokens: DEFAULT_MAX_TOKENS,
             messages: vec![InputMessage {
                 role: "user".to_string(),
-                content: vec![InputContentBlock::Text {
+                content: prompt_to_content_blocks(input, &env::current_dir()?)?,
-                    text: input.to_string(),
-                }],
             }],
             system: (!self.system_prompt.is_empty()).then(|| self.system_prompt.join("\n\n")),
             tools: None,
@@ -2021,7 +2020,7 @@ impl ApiClient for AnthropicRuntimeClient {
         let message_request = MessageRequest {
             model: self.model.clone(),
             max_tokens: DEFAULT_MAX_TOKENS,
-            messages: convert_messages(&request.messages),
+            messages: convert_messages(&request.messages)?,
             system: (!request.system_prompt.is_empty()).then(|| request.system_prompt.join("\n\n")),
             tools: self.enable_tools.then(|| {
                 filter_tool_specs(self.allowed_tools.as_ref())
@@ -2300,7 +2299,10 @@ fn tool_permission_specs() -> Vec<ToolSpec> {
     mvp_tool_specs()
 }
 
-fn convert_messages(messages: &[ConversationMessage]) -> Vec<InputMessage> {
+fn convert_messages(messages: &[ConversationMessage]) -> Result<Vec<InputMessage>, RuntimeError> {
+    let cwd = env::current_dir().map_err(|error| {
+        RuntimeError::new(format!("failed to resolve current directory: {error}"))
+    })?;
     messages
         .iter()
         .filter_map(|message| {
@@ -2311,36 +2313,224 @@ fn convert_messages(messages: &[ConversationMessage]) -> Vec<InputMessage> {
             let content = message
                 .blocks
                 .iter()
-                .map(|block| match block {
+                .try_fold(Vec::new(), |mut acc, block| {
-                    ContentBlock::Text { text } => InputContentBlock::Text { text: text.clone() },
+                    match block {
-                    ContentBlock::ToolUse { id, name, input } => InputContentBlock::ToolUse {
+                        ContentBlock::Text { text } => {
+                            if message.role == MessageRole::User {
+                                acc.extend(
+                                    prompt_to_content_blocks(text, &cwd)
+                                        .map_err(RuntimeError::new)?,
+                                );
+                            } else {
+                                acc.push(InputContentBlock::Text { text: text.clone() });
+                            }
+                        }
+                        ContentBlock::ToolUse { id, name, input } => {
+                            acc.push(InputContentBlock::ToolUse {
                                 id: id.clone(),
                                 name: name.clone(),
                                 input: serde_json::from_str(input)
                                     .unwrap_or_else(|_| serde_json::json!({ "raw": input })),
-                    },
+                            });
+                        }
                         ContentBlock::ToolResult {
                             tool_use_id,
                             output,
                             is_error,
                             ..
-                    } => InputContentBlock::ToolResult {
+                        } => acc.push(InputContentBlock::ToolResult {
                             tool_use_id: tool_use_id.clone(),
                             content: vec![ToolResultContentBlock::Text {
                                 text: output.clone(),
                             }],
                             is_error: *is_error,
-                    },
+                        }),
-                })
+                    }
-                .collect::<Vec<_>>();
+                    Ok::<_, RuntimeError>(acc)
-            (!content.is_empty()).then(|| InputMessage {
+                });
+            match content {
+                Ok(content) if !content.is_empty() => Some(Ok(InputMessage {
                     role: role.to_string(),
                     content,
-            })
+                })),
+                Ok(_) => None,
+                Err(error) => Some(Err(error)),
+            }
         })
         .collect()
 }
 
+fn prompt_to_content_blocks(input: &str, cwd: &Path) -> Result<Vec<InputContentBlock>, String> {
+    let mut blocks = Vec::new();
+    let mut text_buffer = String::new();
+    let mut chars = input.char_indices().peekable();
+
+    while let Some((index, ch)) = chars.next() {
+        if ch == '!' && input[index..].starts_with("![") {
+            if let Some((alt_end, path_start, path_end)) = parse_markdown_image_ref(input, index) {
+                let _ = alt_end;
+                flush_text_block(&mut blocks, &mut text_buffer);
+                let path = &input[path_start..path_end];
+                blocks.push(load_image_block(path, cwd)?);
+                while let Some((next_index, _)) = chars.peek() {
+                    if *next_index < path_end + 1 {
+                        let _ = chars.next();
+                    } else {
+                        break;
+                    }
+                }
+                continue;
+            }
+        }
+
+        if ch == '@' && is_ref_boundary(input[..index].chars().next_back()) {
+            let path_end = find_path_end(input, index + 1);
+            if path_end > index + 1 {
+                let candidate = &input[index + 1..path_end];
+                if looks_like_image_ref(candidate, cwd) {
+                    flush_text_block(&mut blocks, &mut text_buffer);
+                    blocks.push(load_image_block(candidate, cwd)?);
+                    while let Some((next_index, _)) = chars.peek() {
+                        if *next_index < path_end {
+                            let _ = chars.next();
+                        } else {
+                            break;
+                        }
+                    }
+                    continue;
+                }
+            }
+        }
+
+        text_buffer.push(ch);
+    }
+
+    flush_text_block(&mut blocks, &mut text_buffer);
+    if blocks.is_empty() {
+        blocks.push(InputContentBlock::Text {
+            text: input.to_string(),
+        });
+    }
+    Ok(blocks)
+}
+
+fn parse_markdown_image_ref(input: &str, start: usize) -> Option<(usize, usize, usize)> {
+    let after_bang = input.get(start + 2..)?;
+    let alt_end_offset = after_bang.find("](")?;
+    let path_start = start + 2 + alt_end_offset + 2;
+    let remainder = input.get(path_start..)?;
+    let path_end_offset = remainder.find(')')?;
+    let path_end = path_start + path_end_offset;
+    Some((start + 2 + alt_end_offset, path_start, path_end))
+}
+
+fn is_ref_boundary(ch: Option<char>) -> bool {
+    ch.is_none_or(char::is_whitespace)
+}
+
+fn find_path_end(input: &str, start: usize) -> usize {
+    input[start..]
+        .char_indices()
+        .find_map(|(offset, ch)| (ch.is_whitespace()).then_some(start + offset))
+        .unwrap_or(input.len())
+}
+
+fn looks_like_image_ref(candidate: &str, cwd: &Path) -> bool {
+    let resolved = resolve_prompt_path(candidate, cwd);
+    media_type_for_path(Path::new(candidate)).is_some()
+        || resolved.is_file()
+        || candidate.contains(std::path::MAIN_SEPARATOR)
+        || candidate.starts_with("./")
+        || candidate.starts_with("../")
+}
+
+fn flush_text_block(blocks: &mut Vec<InputContentBlock>, text_buffer: &mut String) {
+    if text_buffer.is_empty() {
+        return;
+    }
+    blocks.push(InputContentBlock::Text {
+        text: std::mem::take(text_buffer),
+    });
+}
+
+fn load_image_block(path_ref: &str, cwd: &Path) -> Result<InputContentBlock, String> {
+    let resolved = resolve_prompt_path(path_ref, cwd);
+    let media_type = media_type_for_path(&resolved).ok_or_else(|| {
+        format!(
+            "unsupported image format for reference {IMAGE_REF_PREFIX}{path_ref}; supported: png, jpg, jpeg, gif, webp"
+        )
+    })?;
+    let bytes = fs::read(&resolved).map_err(|error| {
+        format!(
+            "failed to read image reference {}: {error}",
+            resolved.display()
+        )
+    })?;
+    Ok(InputContentBlock::Image {
+        source: ImageSource {
+            kind: "base64".to_string(),
+            media_type: media_type.to_string(),
+            data: encode_base64(&bytes),
+        },
+    })
+}
+
+fn resolve_prompt_path(path_ref: &str, cwd: &Path) -> PathBuf {
+    let path = Path::new(path_ref);
+    if path.is_absolute() {
+        path.to_path_buf()
+    } else {
+        cwd.join(path)
+    }
+}
+
+fn media_type_for_path(path: &Path) -> Option<&'static str> {
+    let extension = path.extension()?.to_str()?.to_ascii_lowercase();
+    match extension.as_str() {
+        "png" => Some("image/png"),
+        "jpg" | "jpeg" => Some("image/jpeg"),
+        "gif" => Some("image/gif"),
+        "webp" => Some("image/webp"),
+        _ => None,
+    }
+}
+
+fn encode_base64(bytes: &[u8]) -> String {
+    const TABLE: &[u8; 64] = b"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+    let mut output = String::new();
+    let mut index = 0;
+    while index + 3 <= bytes.len() {
+        let block = (u32::from(bytes[index]) << 16)
+            | (u32::from(bytes[index + 1]) << 8)
+            | u32::from(bytes[index + 2]);
+        output.push(TABLE[((block >> 18) & 0x3F) as usize] as char);
+        output.push(TABLE[((block >> 12) & 0x3F) as usize] as char);
+        output.push(TABLE[((block >> 6) & 0x3F) as usize] as char);
+        output.push(TABLE[(block & 0x3F) as usize] as char);
+        index += 3;
+    }
+
+    match bytes.len().saturating_sub(index) {
+        1 => {
+            let block = u32::from(bytes[index]) << 16;
+            output.push(TABLE[((block >> 18) & 0x3F) as usize] as char);
+            output.push(TABLE[((block >> 12) & 0x3F) as usize] as char);
+            output.push('=');
+            output.push('=');
+        }
+        2 => {
+            let block = (u32::from(bytes[index]) << 16) | (u32::from(bytes[index + 1]) << 8);
+            output.push(TABLE[((block >> 18) & 0x3F) as usize] as char);
+            output.push(TABLE[((block >> 12) & 0x3F) as usize] as char);
+            output.push(TABLE[((block >> 6) & 0x3F) as usize] as char);
+            output.push('=');
+        }
+        _ => {}
+    }
+
+    output
+}
+
 fn print_help() {
     println!("rusty-claude-cli v{VERSION}");
     println!();
@@ -2397,8 +2587,10 @@ mod tests {
         render_memory_report, render_repl_help, resume_supported_slash_commands, status_context,
         CliAction, CliOutputFormat, SlashCommand, StatusUsage, DEFAULT_MODEL,
     };
+    use api::InputContentBlock;
     use runtime::{ContentBlock, ConversationMessage, MessageRole, PermissionMode};
     use std::path::{Path, PathBuf};
+    use std::time::{SystemTime, UNIX_EPOCH};
 
     #[test]
     fn defaults_to_repl_when_no_args() {
@@ -2881,11 +3073,110 @@ mod tests {
             },
         ];
 
-        let converted = super::convert_messages(&messages);
+        let converted = super::convert_messages(&messages).expect("messages should convert");
         assert_eq!(converted.len(), 3);
         assert_eq!(converted[1].role, "assistant");
         assert_eq!(converted[2].role, "user");
     }
+
+    #[test]
+    fn prompt_to_content_blocks_keeps_text_only_prompt() {
+        let blocks = super::prompt_to_content_blocks("hello world", Path::new("."))
+            .expect("text prompt should parse");
+        assert_eq!(
+            blocks,
+            vec![InputContentBlock::Text {
+                text: "hello world".to_string()
+            }]
+        );
+    }
+
+    #[test]
+    fn prompt_to_content_blocks_embeds_at_image_refs() {
+        let temp = temp_fixture_dir("at-image-ref");
+        let image_path = temp.join("sample.png");
+        std::fs::write(&image_path, [1_u8, 2, 3]).expect("fixture write");
+        let prompt = format!("describe @{} please", image_path.display());
+
+        let blocks = super::prompt_to_content_blocks(&prompt, Path::new("."))
+            .expect("image ref should parse");
+
+        assert!(matches!(
+            &blocks[0],
+            InputContentBlock::Text { text } if text == "describe "
+        ));
+        assert!(matches!(
+            &blocks[1],
+            InputContentBlock::Image { source }
+                if source.kind == "base64"
+                    && source.media_type == "image/png"
+                    && source.data == "AQID"
+        ));
+        assert!(matches!(
+            &blocks[2],
+            InputContentBlock::Text { text } if text == " please"
+        ));
+    }
+
+    #[test]
+    fn prompt_to_content_blocks_embeds_markdown_image_refs() {
+        let temp = temp_fixture_dir("markdown-image-ref");
+        let image_path = temp.join("sample.webp");
+        std::fs::write(&image_path, [255_u8]).expect("fixture write");
+        let prompt = format!("see ![asset]({}) now", image_path.display());
+
+        let blocks = super::prompt_to_content_blocks(&prompt, Path::new("."))
+            .expect("markdown image ref should parse");
+
+        assert!(matches!(
+            &blocks[1],
+            InputContentBlock::Image { source }
+                if source.media_type == "image/webp" && source.data == "/w=="
+        ));
+    }
+
+    #[test]
+    fn prompt_to_content_blocks_rejects_unsupported_formats() {
+        let temp = temp_fixture_dir("unsupported-image-ref");
+        let image_path = temp.join("sample.bmp");
+        std::fs::write(&image_path, [1_u8]).expect("fixture write");
+        let prompt = format!("describe @{}", image_path.display());
+
+        let error = super::prompt_to_content_blocks(&prompt, Path::new("."))
+            .expect_err("unsupported image ref should fail");
+
+        assert!(error.contains("unsupported image format"));
+    }
+
+    #[test]
+    fn convert_messages_expands_user_text_image_refs() {
+        let temp = temp_fixture_dir("convert-message-image-ref");
+        let image_path = temp.join("sample.gif");
+        std::fs::write(&image_path, [71_u8, 73, 70]).expect("fixture write");
+        let messages = vec![ConversationMessage::user_text(format!(
+            "inspect @{}",
+            image_path.display()
+        ))];
+
+        let converted = super::convert_messages(&messages).expect("messages should convert");
+
+        assert_eq!(converted.len(), 1);
+        assert!(matches!(
+            &converted[0].content[1],
+            InputContentBlock::Image { source }
+                if source.media_type == "image/gif" && source.data == "R0lG"
+        ));
+    }
+
+    fn temp_fixture_dir(label: &str) -> PathBuf {
+        let unique = SystemTime::now()
+            .duration_since(UNIX_EPOCH)
+            .expect("clock should advance")
+            .as_nanos();
+        let path = std::env::temp_dir().join(format!("rusty-claude-cli-{label}-{unique}"));
+        std::fs::create_dir_all(&path).expect("temp dir should exist");
+        path
+    }
     #[test]
     fn repl_help_mentions_history_completion_and_multiline() {
         let help = render_repl_help();

rust/crates/rusty-claude-cli/src/render.rs

@@ -21,7 +21,6 @@ pub struct ColorTheme {
     inline_code: Color,
     link: Color,
     quote: Color,
-    table_border: Color,
     spinner_active: Color,
     spinner_done: Color,
     spinner_failed: Color,
@@ -36,7 +35,6 @@ impl Default for ColorTheme {
             inline_code: Color::Green,
             link: Color::Blue,
             quote: Color::DarkGrey,
-            table_border: Color::DarkCyan,
             spinner_active: Color::Blue,
             spinner_done: Color::Green,
             spinner_failed: Color::Red,
@@ -115,70 +113,24 @@ impl Spinner {
     }
 }
 
-#[derive(Debug, Clone, PartialEq, Eq)]
-enum ListKind {
-    Unordered,
-    Ordered { next_index: u64 },
-}
-
-#[derive(Debug, Default, Clone, PartialEq, Eq)]
-struct TableState {
-    headers: Vec<String>,
-    rows: Vec<Vec<String>>,
-    current_row: Vec<String>,
-    current_cell: String,
-    in_head: bool,
-}
-
-impl TableState {
-    fn push_cell(&mut self) {
-        let cell = self.current_cell.trim().to_string();
-        self.current_row.push(cell);
-        self.current_cell.clear();
-    }
-
-    fn finish_row(&mut self) {
-        if self.current_row.is_empty() {
-            return;
-        }
-        let row = std::mem::take(&mut self.current_row);
-        if self.in_head {
-            self.headers = row;
-        } else {
-            self.rows.push(row);
-        }
-    }
-}
-
 #[derive(Debug, Default, Clone, PartialEq, Eq)]
 struct RenderState {
     emphasis: usize,
     strong: usize,
     quote: usize,
-    list_stack: Vec<ListKind>,
+    list: usize,
-    table: Option<TableState>,
 }
 
 impl RenderState {
     fn style_text(&self, text: &str, theme: &ColorTheme) -> String {
-        let mut styled = text.to_string();
         if self.strong > 0 {
-            styled = format!("{}", styled.bold().with(theme.strong));
+            format!("{}", text.bold().with(theme.strong))
-        }
+        } else if self.emphasis > 0 {
-        if self.emphasis > 0 {
+            format!("{}", text.italic().with(theme.emphasis))
-            styled = format!("{}", styled.italic().with(theme.emphasis));
+        } else if self.quote > 0 {
-        }
+            format!("{}", text.with(theme.quote))
-        if self.quote > 0 {
-            styled = format!("{}", styled.with(theme.quote));
-        }
-        styled
-    }
-
-    fn capture_target_mut<'a>(&'a mut self, output: &'a mut String) -> &'a mut String {
-        if let Some(table) = self.table.as_mut() {
-            &mut table.current_cell
         } else {
-            output
+            text.to_string()
         }
     }
 }
@@ -238,7 +190,6 @@ impl TerminalRenderer {
         output.trim_end().to_string()
     }
 
-    #[allow(clippy::too_many_lines)]
     fn render_event(
         &self,
         event: Event<'_>,
@@ -252,22 +203,12 @@ impl TerminalRenderer {
             Event::Start(Tag::Heading { level, .. }) => self.start_heading(level as u8, output),
             Event::End(TagEnd::Heading(..) | TagEnd::Paragraph) => output.push_str("\n\n"),
             Event::Start(Tag::BlockQuote(..)) => self.start_quote(state, output),
-            Event::End(TagEnd::BlockQuote(..)) => {
+            Event::End(TagEnd::BlockQuote(..) | TagEnd::Item)
-                state.quote = state.quote.saturating_sub(1);
+            | Event::SoftBreak
-                output.push('\n');
+            | Event::HardBreak => output.push('\n'),
-            }
+            Event::Start(Tag::List(_)) => state.list += 1,
-            Event::End(TagEnd::Item) | Event::SoftBreak | Event::HardBreak => {
-                state.capture_target_mut(output).push('\n');
-            }
-            Event::Start(Tag::List(first_item)) => {
-                let kind = match first_item {
-                    Some(index) => ListKind::Ordered { next_index: index },
-                    None => ListKind::Unordered,
-                };
-                state.list_stack.push(kind);
-            }
             Event::End(TagEnd::List(..)) => {
-                state.list_stack.pop();
+                state.list = state.list.saturating_sub(1);
                 output.push('\n');
             }
             Event::Start(Tag::Item) => Self::start_item(state, output),
@@ -291,85 +232,57 @@ impl TerminalRenderer {
             Event::Start(Tag::Strong) => state.strong += 1,
             Event::End(TagEnd::Strong) => state.strong = state.strong.saturating_sub(1),
             Event::Code(code) => {
-                let rendered =
+                let _ = write!(
-                    format!("{}", format!("`{code}`").with(self.color_theme.inline_code));
+                    output,
-                state.capture_target_mut(output).push_str(&rendered);
+                    "{}",
+                    format!("`{code}`").with(self.color_theme.inline_code)
+                );
             }
             Event::Rule => output.push_str("---\n"),
             Event::Text(text) => {
                 self.push_text(text.as_ref(), state, output, code_buffer, *in_code_block);
             }
-            Event::Html(html) | Event::InlineHtml(html) => {
+            Event::Html(html) | Event::InlineHtml(html) => output.push_str(&html),
-                state.capture_target_mut(output).push_str(&html);
-            }
             Event::FootnoteReference(reference) => {
-                let _ = write!(state.capture_target_mut(output), "[{reference}]");
+                let _ = write!(output, "[{reference}]");
-            }
-            Event::TaskListMarker(done) => {
-                state
-                    .capture_target_mut(output)
-                    .push_str(if done { "[x] " } else { "[ ] " });
-            }
-            Event::InlineMath(math) | Event::DisplayMath(math) => {
-                state.capture_target_mut(output).push_str(&math);
             }
+            Event::TaskListMarker(done) => output.push_str(if done { "[x] " } else { "[ ] " }),
+            Event::InlineMath(math) | Event::DisplayMath(math) => output.push_str(&math),
             Event::Start(Tag::Link { dest_url, .. }) => {
-                let rendered = format!(
+                let _ = write!(
+                    output,
                     "{}",
                     format!("[{dest_url}]")
                         .underlined()
                         .with(self.color_theme.link)
                 );
-                state.capture_target_mut(output).push_str(&rendered);
             }
             Event::Start(Tag::Image { dest_url, .. }) => {
-                let rendered = format!(
+                let _ = write!(
+                    output,
                     "{}",
                     format!("[image:{dest_url}]").with(self.color_theme.link)
                 );
-                state.capture_target_mut(output).push_str(&rendered);
             }
-            Event::Start(Tag::Table(..)) => state.table = Some(TableState::default()),
+            Event::Start(
-            Event::End(TagEnd::Table) => {
+                Tag::Paragraph
-                if let Some(table) = state.table.take() {
+                | Tag::Table(..)
-                    output.push_str(&self.render_table(&table));
+                | Tag::TableHead
-                    output.push_str("\n\n");
+                | Tag::TableRow
-                }
+                | Tag::TableCell
-            }
+                | Tag::MetadataBlock(..)
-            Event::Start(Tag::TableHead) => {
+                | _,
-                if let Some(table) = state.table.as_mut() {
+            )
-                    table.in_head = true;
+            | Event::End(
-                }
+                TagEnd::Link
-            }
+                | TagEnd::Image
-            Event::End(TagEnd::TableHead) => {
+                | TagEnd::Table
-                if let Some(table) = state.table.as_mut() {
+                | TagEnd::TableHead
-                    table.finish_row();
+                | TagEnd::TableRow
-                    table.in_head = false;
+                | TagEnd::TableCell
-                }
+                | TagEnd::MetadataBlock(..)
-            }
+                | _,
-            Event::Start(Tag::TableRow) => {
+            ) => {}
-                if let Some(table) = state.table.as_mut() {
-                    table.current_row.clear();
-                    table.current_cell.clear();
-                }
-            }
-            Event::End(TagEnd::TableRow) => {
-                if let Some(table) = state.table.as_mut() {
-                    table.finish_row();
-                }
-            }
-            Event::Start(Tag::TableCell) => {
-                if let Some(table) = state.table.as_mut() {
-                    table.current_cell.clear();
-                }
-            }
-            Event::End(TagEnd::TableCell) => {
-                if let Some(table) = state.table.as_mut() {
-                    table.push_cell();
-                }
-            }
-            Event::Start(Tag::Paragraph | Tag::MetadataBlock(..) | _)
-            | Event::End(TagEnd::Link | TagEnd::Image | TagEnd::MetadataBlock(..) | _) => {}
         }
     }
 
@@ -389,19 +302,9 @@ impl TerminalRenderer {
         let _ = write!(output, "{}", "│ ".with(self.color_theme.quote));
     }
 
-    fn start_item(state: &mut RenderState, output: &mut String) {
+    fn start_item(state: &RenderState, output: &mut String) {
-        let depth = state.list_stack.len().saturating_sub(1);
+        output.push_str(&"  ".repeat(state.list.saturating_sub(1)));
-        output.push_str(&"  ".repeat(depth));
+        output.push_str("• ");
-
-        let marker = match state.list_stack.last_mut() {
-            Some(ListKind::Ordered { next_index }) => {
-                let value = *next_index;
-                *next_index += 1;
-                format!("{value}. ")
-            }
-            _ => "• ".to_string(),
-        };
-        output.push_str(&marker);
     }
 
     fn start_code_block(&self, code_language: &str, output: &mut String) {
@@ -425,7 +328,7 @@ impl TerminalRenderer {
     fn push_text(
         &self,
         text: &str,
-        state: &mut RenderState,
+        state: &RenderState,
         output: &mut String,
         code_buffer: &mut String,
         in_code_block: bool,
@@ -433,82 +336,10 @@ impl TerminalRenderer {
         if in_code_block {
             code_buffer.push_str(text);
         } else {
-            let rendered = state.style_text(text, &self.color_theme);
+            output.push_str(&state.style_text(text, &self.color_theme));
-            state.capture_target_mut(output).push_str(&rendered);
         }
     }
 
-    fn render_table(&self, table: &TableState) -> String {
-        let mut rows = Vec::new();
-        if !table.headers.is_empty() {
-            rows.push(table.headers.clone());
-        }
-        rows.extend(table.rows.iter().cloned());
-
-        if rows.is_empty() {
-            return String::new();
-        }
-
-        let column_count = rows.iter().map(Vec::len).max().unwrap_or(0);
-        let widths = (0..column_count)
-            .map(|column| {
-                rows.iter()
-                    .filter_map(|row| row.get(column))
-                    .map(|cell| visible_width(cell))
-                    .max()
-                    .unwrap_or(0)
-            })
-            .collect::<Vec<_>>();
-
-        let border = format!("{}", "│".with(self.color_theme.table_border));
-        let separator = widths
-            .iter()
-            .map(|width| "─".repeat(*width + 2))
-            .collect::<Vec<_>>()
-            .join(&format!("{}", "┼".with(self.color_theme.table_border)));
-        let separator = format!("{border}{separator}{border}");
-
-        let mut output = String::new();
-        if !table.headers.is_empty() {
-            output.push_str(&self.render_table_row(&table.headers, &widths, true));
-            output.push('\n');
-            output.push_str(&separator);
-            if !table.rows.is_empty() {
-                output.push('\n');
-            }
-        }
-
-        for (index, row) in table.rows.iter().enumerate() {
-            output.push_str(&self.render_table_row(row, &widths, false));
-            if index + 1 < table.rows.len() {
-                output.push('\n');
-            }
-        }
-
-        output
-    }
-
-    fn render_table_row(&self, row: &[String], widths: &[usize], is_header: bool) -> String {
-        let border = format!("{}", "│".with(self.color_theme.table_border));
-        let mut line = String::new();
-        line.push_str(&border);
-
-        for (index, width) in widths.iter().enumerate() {
-            let cell = row.get(index).map_or("", String::as_str);
-            line.push(' ');
-            if is_header {
-                let _ = write!(line, "{}", cell.bold().with(self.color_theme.heading));
-            } else {
-                line.push_str(cell);
-            }
-            let padding = width.saturating_sub(visible_width(cell));
-            line.push_str(&" ".repeat(padding + 1));
-            line.push_str(&border);
-        }
-
-        line
-    }
-
     #[must_use]
     pub fn highlight_code(&self, code: &str, language: &str) -> String {
         let syntax = self
@@ -541,11 +372,11 @@ impl TerminalRenderer {
     }
 }
 
-fn visible_width(input: &str) -> usize {
+#[cfg(test)]
-    strip_ansi(input).chars().count()
+mod tests {
-}
+    use super::{Spinner, TerminalRenderer};
 
-fn strip_ansi(input: &str) -> String {
+    fn strip_ansi(input: &str) -> String {
         let mut output = String::new();
         let mut chars = input.chars().peekable();
 
@@ -565,11 +396,7 @@ fn strip_ansi(input: &str) -> String {
         }
 
         output
-}
+    }
-
-#[cfg(test)]
-mod tests {
-    use super::{strip_ansi, Spinner, TerminalRenderer};
 
     #[test]
     fn renders_markdown_with_styling_and_lists() {
@@ -595,34 +422,6 @@ mod tests {
         assert!(markdown_output.contains('\u{1b}'));
     }
 
-    #[test]
-    fn renders_ordered_and_nested_lists() {
-        let terminal_renderer = TerminalRenderer::new();
-        let markdown_output =
-            terminal_renderer.render_markdown("1. first\n2. second\n   - nested\n   - child");
-        let plain_text = strip_ansi(&markdown_output);
-
-        assert!(plain_text.contains("1. first"));
-        assert!(plain_text.contains("2. second"));
-        assert!(plain_text.contains("  • nested"));
-        assert!(plain_text.contains("  • child"));
-    }
-
-    #[test]
-    fn renders_tables_with_alignment() {
-        let terminal_renderer = TerminalRenderer::new();
-        let markdown_output = terminal_renderer
-            .render_markdown("| Name | Value |\n| ---- | ----- |\n| alpha | 1 |\n| beta | 22 |");
-        let plain_text = strip_ansi(&markdown_output);
-        let lines = plain_text.lines().collect::<Vec<_>>();
-
-        assert_eq!(lines[0], "│ Name  │ Value │");
-        assert_eq!(lines[1], "│───────┼───────│");
-        assert_eq!(lines[2], "│ alpha │ 1     │");
-        assert_eq!(lines[3], "│ beta  │ 22    │");
-        assert!(markdown_output.contains('\u{1b}'));
-    }
-
     #[test]
     fn spinner_advances_frames() {
         let terminal_renderer = TerminalRenderer::new();