anveesa 0.3.7 → 0.3.9

package/src/tui.rs

@@ -1,11 +1,15 @@
 use std::{path::PathBuf, time::Duration};
 
 use anyhow::{Context, Result};
+use crossterm::event::{
+    DisableMouseCapture, EnableMouseCapture, Event, KeyCode, KeyEvent, KeyModifiers,
+    MouseEvent, MouseEventKind,
+};
 use ratatui::{
     DefaultTerminal, Frame,
     layout::{Constraint, Layout, Rect},
     style::{Color, Modifier, Style},
-    text::{Line, Span, Text},
+    text::{Line, Span},
     widgets::{Block, Borders, Paragraph, Wrap},
 };
 use tokio::sync::{mpsc, oneshot};
@@ -15,32 +19,40 @@ use crate::{
     config::AppConfig,
     provider::{
         ApprovalDecision, ApprovalPolicy, ChatMessage, ChatRole, ImageAttachment, PromptRequest,
-        StreamEvent, ToolConfirmPreview, TurnResult, Usage,
+        StreamEvent, ToolConfirmPreview, Usage,
     },
 };
 
-// ── Public event type sent from render_stream → TUI ──────────────────────────
+// ── Public stream event type ──────────────────────────────────────────────────
 
 pub enum TuiEvent {
     Token(String),
     Status(String),
     ToolCall(String),
-    ToolDone { summary: String, ok: bool, elapsed_ms: u128 },
+    ToolDone { summary: String, ok: bool },
     FileOp { verb: String, path: String, added: usize, removed: usize },
     Confirm { summary: String, reply: oneshot::Sender<ApprovalDecision> },
     Usage(Usage),
+    Error(String),
     PlanSet(Vec<String>),
     PlanTaskDone(usize),
 }
 
-// ── Message types stored in conversation ─────────────────────────────────────
+// ── Display message types ─────────────────────────────────────────────────────
 
 #[derive(Debug)]
 enum Msg {
     User { text: String },
     Assistant { text: String },
-    Tool { icon: &'static str, text: String, ok: bool },
-    System { text: String },
+    Tool { done: bool, ok: bool, text: String },
+    FileOp { verb: String, path: String, added: usize, removed: usize },
+    Error(String),
+    System(String),
+}
+
+#[derive(Debug)]
+struct PendingTool {
+    summary: String,
 }
 
 #[derive(Debug)]
@@ -56,16 +68,21 @@ enum Mode {
     Confirming,
 }
 
-// ── App state ─────────────────────────────────────────────────────────────────
+// ── Application state ─────────────────────────────────────────────────────────
 
 pub struct App {
-    // conversation
+    // conversation display
     messages: Vec<Msg>,
     streaming_buf: String,
+    accumulated_response: String,
+    pending_tool: Option<PendingTool>, // currently-running tool (not yet committed)
     tool_status: String,
     plan_tasks: Vec<String>,
     plan_done: Vec<bool>,
 
+    // pending turn tracking
+    pending_prompt: String,
+
     // input
     input: String,
     input_cursor: usize,
@@ -73,14 +90,15 @@ pub struct App {
     hist_idx: Option<usize>,
     hist_saved: String,
     pending_image: Option<ImageAttachment>,
+    last_image_fp: Option<String>,
     images_available: bool,
 
-    // display
+    // scroll
     scroll: usize,
     auto_scroll: bool,
     total_lines: usize,
 
-    // status
+    // status info
     provider: String,
     model: String,
     usage: Usage,
@@ -90,12 +108,12 @@ pub struct App {
     mode: Mode,
     confirm: Option<PendingConfirm>,
 
-    // session
+    // history & session
     history: Vec<ChatMessage>,
     session_path: Option<PathBuf>,
     pub last_saved_at: u64,
 
-    // provider config
+    // request params
     pub config: AppConfig,
     pub options: AskOptions,
     pub workspace_context: Option<String>,
@@ -103,8 +121,8 @@ pub struct App {
 
     // channels
     stream_rx: mpsc::UnboundedReceiver<TuiEvent>,
-    stream_tx_proto: Option<mpsc::UnboundedSender<TuiEvent>>,
-    key_rx: mpsc::UnboundedReceiver<crossterm::event::Event>,
+    stream_tx: mpsc::UnboundedSender<TuiEvent>,
+    key_rx: mpsc::UnboundedReceiver<Event>,
 
     quit: bool,
     spinner_frame: usize,
@@ -115,7 +133,7 @@ impl App {
         provider: String,
         model: String,
         cwd: String,
-        messages: Vec<ChatMessage>,
+        history: Vec<ChatMessage>,
         images_available: bool,
         session_path: Option<PathBuf>,
         last_saved_at: u64,
@@ -124,10 +142,10 @@ impl App {
         options: AskOptions,
         workspace_context: Option<String>,
         policy: ApprovalPolicy,
-        key_rx: mpsc::UnboundedReceiver<crossterm::event::Event>,
+        key_rx: mpsc::UnboundedReceiver<Event>,
     ) -> Self {
         let (stream_tx, stream_rx) = mpsc::unbounded_channel();
-        let msgs: Vec<Msg> = messages
+        let messages = history
             .iter()
             .map(|m| match m.role {
                 ChatRole::User => Msg::User { text: m.content.clone() },
@@ -136,11 +154,14 @@ impl App {
             .collect();
 
         Self {
-            messages: msgs,
+            messages,
             streaming_buf: String::new(),
+            accumulated_response: String::new(),
+            pending_tool: None,
             tool_status: String::new(),
             plan_tasks: vec![],
             plan_done: vec![],
+            pending_prompt: String::new(),
 
             input: String::new(),
             input_cursor: 0,
@@ -148,6 +169,7 @@ impl App {
             hist_idx: None,
             hist_saved: String::new(),
             pending_image: None,
+            last_image_fp: None,
             images_available,
 
             scroll: usize::MAX,
@@ -162,7 +184,7 @@ impl App {
             mode: Mode::Input,
             confirm: None,
 
-            history: messages,
+            history,
             session_path,
             last_saved_at,
 
@@ -172,43 +194,36 @@ impl App {
             policy,
 
             stream_rx,
-            stream_tx_proto: Some(stream_tx),
+            stream_tx,
             key_rx,
 
             quit: false,
             spinner_frame: 0,
         }
     }
-
-    pub fn take_stream_sender(&mut self) -> Option<mpsc::UnboundedSender<TuiEvent>> {
-        self.stream_tx_proto.take()
-    }
 }
 
 // ── Main TUI loop ─────────────────────────────────────────────────────────────
 
 pub async fn run(mut app: App) -> Result<Vec<ChatMessage>> {
+    crossterm::execute!(std::io::stdout(), EnableMouseCapture)?;
     let mut terminal = ratatui::init();
     terminal.clear()?;
     let result = event_loop(&mut terminal, &mut app).await;
     ratatui::restore();
+    crossterm::execute!(std::io::stdout(), DisableMouseCapture)?;
     result
 }
 
-async fn event_loop(
-    terminal: &mut DefaultTerminal,
-    app: &mut App,
-) -> Result<Vec<ChatMessage>> {
+async fn event_loop(terminal: &mut DefaultTerminal, app: &mut App) -> Result<Vec<ChatMessage>> {
     loop {
         terminal.draw(|f| render(f, app))?;
-
         if app.quit {
             break;
         }
-
         tokio::select! {
             Some(ev) = app.key_rx.recv() => {
-                handle_key_event(app, ev).await?;
+                handle_event(app, ev).await?;
             }
             Some(tui_ev) = app.stream_rx.recv() => {
                 handle_stream_event(app, tui_ev).await;
@@ -220,23 +235,39 @@ async fn event_loop(
             }
         }
     }
-
     Ok(app.history.clone())
 }
 
-// ── Key handling ──────────────────────────────────────────────────────────────
+// ── Event handling ────────────────────────────────────────────────────────────
 
-async fn handle_key_event(
-    app: &mut App,
-    event: crossterm::event::Event,
-) -> Result<()> {
-    use crossterm::event::{Event, KeyCode, KeyEvent, KeyModifiers};
+async fn handle_event(app: &mut App, event: Event) -> Result<()> {
+    match event {
+        Event::Mouse(MouseEvent { kind, .. }) => handle_mouse(app, kind),
+        Event::Key(key) => handle_key(app, key).await?,
+        Event::Resize(_, _) => {}
+        _ => {}
+    }
+    Ok(())
+}
 
-    let Event::Key(KeyEvent { code, modifiers, .. }) = event else {
-        return Ok(());
-    };
+fn handle_mouse(app: &mut App, kind: MouseEventKind) {
+    match kind {
+        MouseEventKind::ScrollUp => {
+            app.auto_scroll = false;
+            app.scroll = app.scroll.saturating_sub(3);
+        }
+        MouseEventKind::ScrollDown => {
+            app.scroll = app.scroll.saturating_add(3);
+            if app.scroll >= app.total_lines {
+                app.auto_scroll = true;
+            }
+        }
+        _ => {}
+    }
+}
 
-    // Confirmation mode: only y/n/Enter/Esc
+async fn handle_key(app: &mut App, KeyEvent { code, modifiers, .. }: KeyEvent) -> Result<()> {
+    // ── Confirming mode: y/a/n only ───────────────────────────────────────────
     if app.mode == Mode::Confirming {
         if let Some(confirm) = app.confirm.take() {
             let decision = match code {
@@ -250,113 +281,128 @@ async fn handle_key_event(
         return Ok(());
     }
 
-    // Streaming mode: only Ctrl+C
+    // ── Streaming mode: scroll only ───────────────────────────────────────────
     if app.mode == Mode::Streaming {
-        // Allow scrolling during stream
         match code {
-            KeyCode::PageUp => { app.auto_scroll = false; app.scroll = app.scroll.saturating_sub(10); }
-            KeyCode::PageDown => { app.scroll = app.scroll.saturating_add(10); if app.scroll >= app.total_lines { app.auto_scroll = true; } }
-            KeyCode::Up if modifiers.contains(KeyModifiers::ALT) => { app.auto_scroll = false; app.scroll = app.scroll.saturating_sub(1); }
-            KeyCode::Down if modifiers.contains(KeyModifiers::ALT) => { app.scroll = app.scroll.saturating_add(1); }
+            KeyCode::PageUp => {
+                app.auto_scroll = false;
+                app.scroll = app.scroll.saturating_sub(10);
+            }
+            KeyCode::PageDown => {
+                app.scroll = app.scroll.saturating_add(10);
+                if app.scroll >= app.total_lines {
+                    app.auto_scroll = true;
+                }
+            }
             _ => {}
         }
         return Ok(());
     }
 
+    // ── Input mode ────────────────────────────────────────────────────────────
     match code {
+        // Submit (Enter) or newline (Shift+Enter)
+        KeyCode::Enter if modifiers.contains(KeyModifiers::SHIFT) => {
+            app.input.insert(app.input_cursor, '\n');
+            app.input_cursor += 1;
+            app.hist_idx = None;
+        }
         KeyCode::Enter => {
             let text = app.input.trim().to_string();
             if text.is_empty() {
                 return Ok(());
             }
-            submit_prompt(app, text).await?;
+            if !handle_slash_command(app, &text) {
+                submit_prompt(app, text).await?;
+            }
         }
 
+        // Ctrl shortcuts
         KeyCode::Char('c') if modifiers.contains(KeyModifiers::CONTROL) => {
             if app.input.is_empty() {
                 app.quit = true;
             } else {
                 app.input.clear();
                 app.input_cursor = 0;
+                app.hist_idx = None;
             }
         }
-
         KeyCode::Char('d') if modifiers.contains(KeyModifiers::CONTROL) && app.input.is_empty() => {
             app.quit = true;
         }
-
         KeyCode::Char('u') if modifiers.contains(KeyModifiers::CONTROL) => {
             app.input.drain(..app.input_cursor);
             app.input_cursor = 0;
             app.hist_idx = None;
         }
-
         KeyCode::Char('w') if modifiers.contains(KeyModifiers::CONTROL) => {
             delete_word_before(&mut app.input, &mut app.input_cursor);
             app.hist_idx = None;
         }
-
         KeyCode::Char('v') if modifiers.contains(KeyModifiers::CONTROL) && app.images_available => {
             if let Some(img) = crate::grab_clipboard_image() {
                 app.pending_image = Some(img);
+                app.last_image_fp = None; // force re-attach
             }
         }
 
+        // Editing
         KeyCode::Backspace => {
             if app.input_cursor > 0 {
-                let ch_len = prev_char_len(&app.input, app.input_cursor);
-                let start = app.input_cursor - ch_len;
+                let len = prev_char_len(&app.input, app.input_cursor);
+                let start = app.input_cursor - len;
                 app.input.drain(start..app.input_cursor);
                 app.input_cursor = start;
                 app.hist_idx = None;
             }
         }
-
         KeyCode::Delete => {
             if app.input_cursor < app.input.len() {
-                let ch_len = next_char_len(&app.input, app.input_cursor);
-                app.input.drain(app.input_cursor..app.input_cursor + ch_len);
+                let len = next_char_len(&app.input, app.input_cursor);
+                app.input.drain(app.input_cursor..app.input_cursor + len);
                 app.hist_idx = None;
             }
         }
 
-        KeyCode::Left => move_cursor_left(&mut app.input, &mut app.input_cursor),
-        KeyCode::Right => move_cursor_right(&mut app.input, &mut app.input_cursor),
+        // Cursor movement
+        KeyCode::Left => move_cursor_left(&app.input.clone(), &mut app.input_cursor),
+        KeyCode::Right => move_cursor_right(&app.input.clone(), &mut app.input_cursor),
         KeyCode::Home => app.input_cursor = 0,
         KeyCode::End => app.input_cursor = app.input.len(),
 
+        // History navigation
         KeyCode::Up => {
-            if app.hist_idx.is_none() && !app.input_history.is_empty() {
-                app.hist_saved = app.input.clone();
-                app.hist_idx = Some(app.input_history.len() - 1);
-                let text = app.input_history[app.input_history.len() - 1].clone();
-                app.input = text;
+            if !app.input_history.is_empty() {
+                let new_idx = match app.hist_idx {
+                    None => {
+                        app.hist_saved = app.input.clone();
+                        app.input_history.len() - 1
+                    }
+                    Some(0) => 0,
+                    Some(i) => i - 1,
+                };
+                app.hist_idx = Some(new_idx);
+                app.input = app.input_history[new_idx].clone();
                 app.input_cursor = app.input.len();
-            } else if let Some(i) = app.hist_idx {
-                if i > 0 {
-                    app.hist_idx = Some(i - 1);
-                    let text = app.input_history[i - 1].clone();
-                    app.input = text;
-                    app.input_cursor = app.input.len();
-                }
             }
         }
-
         KeyCode::Down => {
-            if let Some(i) = app.hist_idx {
-                if i + 1 < app.input_history.len() {
-                    app.hist_idx = Some(i + 1);
-                    let text = app.input_history[i + 1].clone();
-                    app.input = text;
-                    app.input_cursor = app.input.len();
-                } else {
+            match app.hist_idx {
+                None => {}
+                Some(i) if i + 1 >= app.input_history.len() => {
                     app.hist_idx = None;
                     app.input = std::mem::take(&mut app.hist_saved);
                     app.input_cursor = app.input.len();
                 }
+                Some(i) => {
+                    app.hist_idx = Some(i + 1);
+                    app.input = app.input_history[i + 1].clone();
+                    app.input_cursor = app.input.len();
+                }
             }
         }
 
+        // Scroll
         KeyCode::PageUp => {
             app.auto_scroll = false;
             app.scroll = app.scroll.saturating_sub(10);
@@ -368,6 +414,7 @@ async fn handle_key_event(
             }
         }
 
+        // Printable characters
         KeyCode::Char(c) => {
             let s = c.to_string();
             app.input.insert_str(app.input_cursor, &s);
@@ -377,30 +424,55 @@ async fn handle_key_event(
 
         _ => {}
     }
-
-    // Handle slash commands typed into input
-    handle_slash_command(app);
-
     Ok(())
 }
 
-fn handle_slash_command(app: &mut App) {
-    let trimmed = app.input.trim();
-    match trimmed {
+// Returns true if the command was consumed (don't send to AI).
+fn handle_slash_command(app: &mut App, text: &str) -> bool {
+    match text {
         "/exit" | "/quit" | ":q" => {
             app.quit = true;
+            true
         }
         "/clear" => {
             app.messages.clear();
             app.history.clear();
             app.streaming_buf.clear();
+            app.accumulated_response.clear();
             app.usage = Usage::default();
             app.pending_image = None;
+            app.input.clear();
+            app.input_cursor = 0;
             if let Some(path) = &app.session_path {
                 let _ = std::fs::remove_file(path);
             }
+            true
+        }
+        "/help" => {
+            app.messages.push(Msg::System(
+                "Commands: /clear  /export [path]  /model [name]  /provider [name]  /status  /exit\n\
+                 Keys: ↑/↓ history  ←/→ cursor  Home/End  Shift+Enter newline\n\
+                 Ctrl+W delete-word  Ctrl+U clear-line  Ctrl+V paste image\n\
+                 PageUp/Dn or scroll wheel to scroll history".into(),
+            ));
+            app.input.clear();
+            app.input_cursor = 0;
+            true
+        }
+        "/status" => {
+            let u = &app.usage;
+            app.messages.push(Msg::System(format!(
+                "provider: {}  model: {}  turns: {}  tokens: {}↓ {}↑ {} total",
+                app.provider,
+                app.model,
+                app.history.len() / 2,
+                u.prompt_tokens,
+                u.completion_tokens,
+                u.total_tokens,
+            )));
             app.input.clear();
             app.input_cursor = 0;
+            true
         }
         s if s.starts_with("/export") => {
             let arg = s.strip_prefix("/export").unwrap().trim();
@@ -409,14 +481,55 @@ fn handle_slash_command(app: &mut App) {
             } else {
                 std::path::PathBuf::from(arg)
             };
-            let _ = crate::export_conversation(&path, &app.history);
-            app.messages.push(Msg::System {
-                text: format!("Exported to {}", path.display()),
-            });
+            match crate::export_conversation(&path, &app.history) {
+                Ok(()) => app.messages.push(Msg::System(format!("Exported → {}", path.display()))),
+                Err(e) => app.messages.push(Msg::Error(format!("export failed: {e:#}"))),
+            }
             app.input.clear();
             app.input_cursor = 0;
+            true
         }
-        _ => {}
+        s if s.starts_with("/model") => {
+            let arg = s.strip_prefix("/model").unwrap().trim();
+            if arg.is_empty() {
+                let current = app.model.clone();
+                app.messages.push(Msg::System(format!("current model: {current}")));
+            } else {
+                app.model = arg.to_string();
+                app.options.model = Some(arg.to_string());
+                app.messages.push(Msg::System(format!("switched to model: {arg}")));
+            }
+            app.input.clear();
+            app.input_cursor = 0;
+            true
+        }
+        s if s.starts_with("/provider") => {
+            let arg = s.strip_prefix("/provider").unwrap().trim();
+            if arg.is_empty() {
+                let current = app.provider.clone();
+                app.messages.push(Msg::System(format!("current provider: {current}")));
+            } else {
+                // Validate provider exists
+                if app.config.providers.contains_key(arg) {
+                    app.provider = arg.to_string();
+                    app.options.provider = Some(arg.to_string());
+                    // Update model to provider default
+                    if let Some(m) = app.config.providers.get(arg)
+                        .and_then(|p| p.default_model())
+                    {
+                        app.model = m.to_string();
+                        app.options.model = Some(m.to_string());
+                    }
+                    app.messages.push(Msg::System(format!("switched to provider: {arg}")));
+                } else {
+                    app.messages.push(Msg::Error(format!("unknown provider '{arg}'")));
+                }
+            }
+            app.input.clear();
+            app.input_cursor = 0;
+            true
+        }
+        _ => false,
     }
 }
 
@@ -426,10 +539,22 @@ async fn submit_prompt(app: &mut App, text: String) -> Result<()> {
         app.input_history.push(text.clone());
     }
     app.hist_idx = None;
-
-    app.messages.push(Msg::User {
-        text: text.clone(),
+    app.pending_prompt = text.clone();
+    app.accumulated_response.clear();
+
+    // Auto-attach clipboard image if nothing was explicitly Ctrl+V'd
+    let image = app.pending_image.take().or_else(|| {
+        if !app.images_available { return None; }
+        let img = crate::grab_clipboard_image()?;
+        let fp = crate::image_fingerprint(&img);
+        if app.last_image_fp.as_deref() == Some(&fp) {
+            return None; // same image as last time
+        }
+        app.last_image_fp = Some(fp);
+        Some(img)
     });
+
+    app.messages.push(Msg::User { text: text.clone() });
     app.input.clear();
     app.input_cursor = 0;
     app.auto_scroll = true;
@@ -437,83 +562,72 @@ async fn submit_prompt(app: &mut App, text: String) -> Result<()> {
     app.tool_status = "Thinking".to_string();
     app.spinner_frame = 0;
 
-    let image = app.pending_image.take();
     let provider_name = app
         .config
         .provider_name(app.options.provider.as_deref())
         .context("unknown provider")?
         .to_string();
 
-    let (tx, rx) = mpsc::unbounded_channel::<StreamEvent>();
+    let (stream_tx_inner, stream_rx_inner) = mpsc::unbounded_channel::<StreamEvent>();
 
-    // Clone what we need for the spawned task
+    // Clone everything needed for the spawned tasks
     let config = app.config.clone();
     let options = app.options.clone();
     let history = app.history.clone();
     let workspace_context = app.workspace_context.clone();
     let policy = app.policy;
-    let tui_tx = app.stream_tx_proto.clone();
+    let tui_tx = app.stream_tx.clone();
+    let tui_tx2 = app.stream_tx.clone();
 
+    // Task 1: call the provider
     tokio::spawn(async move {
         let request = PromptRequest {
             prompt: text,
             model: options.model.clone(),
             system: options.system.clone(),
-            workspace_context: workspace_context.map(|s| s.to_string()),
+            workspace_context,
             history,
             image,
         };
-
-        let result = crate::provider::ask(&config, &provider_name, request, policy, &tx).await;
-        drop(tx);
-
-        if let Some(tui_tx) = tui_tx {
-            match result {
-                Ok(turn) => {
-                    let _ = tui_tx.send(TuiEvent::Usage(turn.usage.unwrap_or_default()));
-                }
-                Err(e) => {
-                    // Error will be communicated via the stream events already sent
-                    let _ = tui_tx.send(TuiEvent::Status(format!("Error: {e:#}")));
-                }
+        let result = crate::provider::ask(&config, &provider_name, request, policy, &stream_tx_inner).await;
+        drop(stream_tx_inner);
+        match result {
+            Ok(turn) => {
+                let _ = tui_tx.send(TuiEvent::Usage(turn.usage.unwrap_or_default()));
+            }
+            Err(e) => {
+                let _ = tui_tx.send(TuiEvent::Error(format!("{e:#}")));
             }
         }
     });
 
-    // Relay StreamEvents → TuiEvents
-    if let Some(tui_tx) = &app.stream_tx_proto {
-        let tui_tx = tui_tx.clone();
-        tokio::spawn(async move {
-            let mut rx = rx;
-            while let Some(ev) = rx.recv().await {
-                match ev {
-                    StreamEvent::Token(t) => { let _ = tui_tx.send(TuiEvent::Token(t)); }
-                    StreamEvent::Status { message } => { let _ = tui_tx.send(TuiEvent::Status(message)); }
-                    StreamEvent::ToolCall { summary } => { let _ = tui_tx.send(TuiEvent::ToolCall(summary)); }
-                    StreamEvent::ToolResult { summary, ok, elapsed_ms, .. } => {
-                        let _ = tui_tx.send(TuiEvent::ToolDone { summary, ok, elapsed_ms });
-                    }
-                    StreamEvent::FileOp { verb, path, added, removed, .. } => {
-                        let _ = tui_tx.send(TuiEvent::FileOp { verb, path, added, removed });
-                    }
-                    StreamEvent::Confirm { preview, reply } => {
-                        let summary = match &preview {
-                            ToolConfirmPreview::FileOp { verb, path, added, removed, .. } =>
-                                format!("{verb} {path}  +{added} -{removed}"),
-                            ToolConfirmPreview::CreateDir { path } =>
-                                format!("create dir {path}"),
-                            ToolConfirmPreview::Generic { summary } =>
-                                summary.clone(),
-                        };
-                        let _ = tui_tx.send(TuiEvent::Confirm { summary, reply });
-                    }
-                    StreamEvent::Usage(u) => { let _ = tui_tx.send(TuiEvent::Usage(u)); }
-                    StreamEvent::PlanSet { tasks } => { let _ = tui_tx.send(TuiEvent::PlanSet(tasks)); }
-                    StreamEvent::PlanTaskDone { index } => { let _ = tui_tx.send(TuiEvent::PlanTaskDone(index)); }
+    // Task 2: relay StreamEvents → TuiEvents
+    tokio::spawn(async move {
+        let mut rx = stream_rx_inner;
+        while let Some(ev) = rx.recv().await {
+            let tui_ev = match ev {
+                StreamEvent::Token(t) => TuiEvent::Token(t),
+                StreamEvent::Status { message } => TuiEvent::Status(message),
+                StreamEvent::ToolCall { summary } => TuiEvent::ToolCall(summary),
+                StreamEvent::ToolResult { summary, ok, .. } => TuiEvent::ToolDone { summary, ok },
+                StreamEvent::FileOp { verb, path, added, removed, .. } =>
+                    TuiEvent::FileOp { verb, path, added, removed },
+                StreamEvent::Confirm { preview, reply } => {
+                    let summary = match &preview {
+                        ToolConfirmPreview::FileOp { verb, path, added, removed, .. } =>
+                            format!("{verb} {path}  +{added} -{removed}"),
+                        ToolConfirmPreview::CreateDir { path } => format!("mkdir {path}"),
+                        ToolConfirmPreview::Generic { summary } => summary.clone(),
+                    };
+                    TuiEvent::Confirm { summary, reply }
                 }
-            }
-        });
-    }
+                StreamEvent::Usage(u) => TuiEvent::Usage(u),
+                StreamEvent::PlanSet { tasks } => TuiEvent::PlanSet(tasks),
+                StreamEvent::PlanTaskDone { index } => TuiEvent::PlanTaskDone(index),
+            };
+            if tui_tx2.send(tui_ev).is_err() { break; }
+        }
+    });
 
     Ok(())
 }
@@ -528,41 +642,26 @@ async fn handle_stream_event(app: &mut App, ev: TuiEvent) {
             app.tool_status = msg;
         }
         TuiEvent::ToolCall(summary) => {
-            if !app.streaming_buf.is_empty() {
-                let text = std::mem::take(&mut app.streaming_buf);
-                app.messages.push(Msg::Assistant { text });
-            }
-            app.messages.push(Msg::Tool {
-                icon: "⚙",
-                text: summary,
-                ok: true,
-            });
-            app.tool_status = "Running tool".to_string();
+            flush_streaming_buf(app);
+            // Commit any previous pending tool (shouldn't happen, but be safe)
+            commit_pending_tool(app, true);
+            app.pending_tool = Some(PendingTool { summary: summary.clone() });
+            app.tool_status = summary;
         }
-        TuiEvent::ToolDone { summary, ok, .. } => {
-            // Update the last tool message to reflect result
-            if let Some(Msg::Tool { text, ok: tool_ok, .. }) = app.messages.last_mut() {
-                *text = summary;
-                *tool_ok = ok;
-            }
+        TuiEvent::ToolDone { summary, ok } => {
+            // Commit the pending tool with its final status
+            app.pending_tool = Some(PendingTool { summary });
+            commit_pending_tool(app, ok);
             app.tool_status = "Thinking".to_string();
         }
         TuiEvent::FileOp { verb, path, added, removed } => {
-            if !app.streaming_buf.is_empty() {
-                let text = std::mem::take(&mut app.streaming_buf);
-                app.messages.push(Msg::Assistant { text });
-            }
-            app.messages.push(Msg::Tool {
-                icon: "📄",
-                text: format!("{verb} {path}  \x1b[32m+{added}\x1b[0m \x1b[31m-{removed}\x1b[0m"),
-                ok: true,
-            });
+            flush_streaming_buf(app);
+            commit_pending_tool(app, true);
+            app.messages.push(Msg::FileOp { verb, path, added, removed });
         }
         TuiEvent::Confirm { summary, reply } => {
-            if !app.streaming_buf.is_empty() {
-                let text = std::mem::take(&mut app.streaming_buf);
-                app.messages.push(Msg::Assistant { text });
-            }
+            flush_streaming_buf(app);
+            commit_pending_tool(app, true);
             app.confirm = Some(PendingConfirm { summary, reply });
             app.mode = Mode::Confirming;
         }
@@ -572,28 +671,11 @@ async fn handle_stream_event(app: &mut App, ev: TuiEvent) {
             app.usage.total_tokens += u.total_tokens;
             app.usage.cache_read_tokens += u.cache_read_tokens;
             app.usage.cache_write_tokens += u.cache_write_tokens;
-
-            // Streaming finished — commit the buffered text
-            if !app.streaming_buf.is_empty() {
-                let text = std::mem::take(&mut app.streaming_buf);
-                let prompt = app.messages.iter().rev()
-                    .find_map(|m| if let Msg::User { text } = m { Some(text.clone()) } else { None })
-                    .unwrap_or_default();
-                let assistant_text = text.clone();
-                app.history.push(ChatMessage::user(prompt));
-                app.history.push(ChatMessage::assistant(assistant_text.clone()));
-                app.messages.push(Msg::Assistant { text });
-                // Save session
-                if let Some(path) = &app.session_path {
-                    if let Ok(cwd) = std::env::current_dir() {
-                        let _ = crate::save_interactive_session_pub(
-                            path, &cwd, &app.provider,
-                            &app.options, &app.history,
-                        );
-                        app.last_saved_at = crate::unix_now();
-                    }
-                }
-            }
+            finish_turn(app);
+        }
+        TuiEvent::Error(msg) => {
+            flush_streaming_buf(app);
+            app.messages.push(Msg::Error(msg));
             app.mode = Mode::Input;
             app.tool_status.clear();
         }
@@ -602,25 +684,61 @@ async fn handle_stream_event(app: &mut App, ev: TuiEvent) {
             app.plan_tasks = tasks;
         }
         TuiEvent::PlanTaskDone(i) => {
-            if i < app.plan_done.len() {
-                app.plan_done[i] = true;
+            if i < app.plan_done.len() { app.plan_done[i] = true; }
+        }
+    }
+}
+
+/// Flush streaming_buf to messages and accumulated_response.
+fn flush_streaming_buf(app: &mut App) {
+    if !app.streaming_buf.is_empty() {
+        let text = std::mem::take(&mut app.streaming_buf);
+        app.accumulated_response.push_str(&text);
+        app.messages.push(Msg::Assistant { text });
+    }
+}
+
+/// Commit a pending tool call to the message history with its final status.
+fn commit_pending_tool(app: &mut App, ok: bool) {
+    if let Some(tool) = app.pending_tool.take() {
+        app.messages.push(Msg::Tool { done: true, ok, text: tool.summary });
+    }
+}
+
+/// Commit the completed turn to history and save session.
+fn finish_turn(app: &mut App) {
+    commit_pending_tool(app, true);
+    flush_streaming_buf(app);
+    let response = std::mem::take(&mut app.accumulated_response);
+    if !response.is_empty() {
+        let prompt = std::mem::take(&mut app.pending_prompt);
+        app.history.push(ChatMessage::user(prompt));
+        app.history.push(ChatMessage::assistant(response));
+        if let Some(path) = &app.session_path {
+            if let Ok(cwd) = std::env::current_dir() {
+                let _ = crate::save_interactive_session_pub(
+                    path, &cwd, &app.provider, &app.options, &app.history,
+                );
+                app.last_saved_at = crate::unix_now();
             }
         }
     }
+    app.mode = Mode::Input;
+    app.tool_status.clear();
 }
 
 // ── Rendering ─────────────────────────────────────────────────────────────────
 
 fn render(frame: &mut Frame, app: &mut App) {
     let area = frame.area();
-
-    let input_height = (app.input.len() / area.width.max(1) as usize + 1).clamp(1, 5) as u16 + 2;
+    let input_lines = app.input.lines().count().max(1);
+    let input_height = (input_lines as u16).clamp(1, 5) + 2;
 
     let chunks = Layout::vertical([
-        Constraint::Length(1),          // header
-        Constraint::Min(3),             // messages
-        Constraint::Length(input_height), // input box
-        Constraint::Length(1),          // status bar
+        Constraint::Length(1),
+        Constraint::Min(3),
+        Constraint::Length(input_height),
+        Constraint::Length(1),
     ])
     .split(area);
 
@@ -632,98 +750,116 @@ fn render(frame: &mut Frame, app: &mut App) {
 
 fn render_header(frame: &mut Frame, area: Rect, app: &App) {
     let version = env!("CARGO_PKG_VERSION");
-    let left = format!(" anveesa v{version}");
+    let token_str = if app.usage.total_tokens > 0 {
+        format!("  {}↓ {}↑", app.usage.prompt_tokens, app.usage.completion_tokens)
+    } else {
+        String::new()
+    };
+    let left = format!(" anveesa v{version}{token_str}");
     let right = format!("{} · {}  ", app.provider, app.model);
-    let gap = (area.width as usize)
-        .saturating_sub(left.chars().count() + right.chars().count());
+    let gap = (area.width as usize).saturating_sub(left.chars().count() + right.chars().count());
     let title = format!("{left}{}{right}", " ".repeat(gap));
-    let p = Paragraph::new(title).style(
-        Style::default()
-            .fg(Color::Black)
-            .bg(Color::Rgb(97, 175, 239)),
+    frame.render_widget(
+        Paragraph::new(title).style(Style::default().fg(Color::Black).bg(Color::Rgb(97, 175, 239))),
+        area,
     );
-    frame.render_widget(p, area);
 }
 
 fn render_messages(frame: &mut Frame, area: Rect, app: &mut App) {
     let width = area.width.saturating_sub(4) as usize;
-
     let mut lines: Vec<Line<'static>> = vec![Line::from("")];
 
     for msg in &app.messages {
         match msg {
             Msg::User { text } => {
-                lines.push(Line::from(vec![
-                    Span::styled("  ● You", Style::default().fg(Color::Rgb(97, 175, 239)).add_modifier(Modifier::BOLD)),
-                ]));
+                lines.push(user_header());
                 for l in wrap_text(text, width) {
                     lines.push(Line::from(format!("    {l}")));
                 }
                 lines.push(Line::from(""));
             }
             Msg::Assistant { text } => {
-                lines.push(Line::from(vec![
-                    Span::styled(
-                        format!("  ● {}", app.model),
-                        Style::default().fg(Color::Rgb(152, 195, 121)).add_modifier(Modifier::BOLD),
-                    ),
-                ]));
+                lines.push(assistant_header(&app.model));
                 for l in format_assistant_lines(text, width) {
                     lines.push(l);
                 }
                 lines.push(Line::from(""));
             }
-            Msg::Tool { icon, text, ok } => {
-                let color = if *ok { Color::Rgb(229, 192, 123) } else { Color::Rgb(224, 108, 117) };
+            Msg::Tool { done, ok, text } => {
+                let (icon, color) = if !done {
+                    ("⠋", Color::DarkGray)
+                } else if *ok {
+                    ("✓", Color::Rgb(152, 195, 121))
+                } else {
+                    ("✗", Color::Rgb(224, 108, 117))
+                };
+                lines.push(Line::from(Span::styled(
+                    format!("  {icon} {text}"),
+                    Style::default().fg(color),
+                )));
+                lines.push(Line::from(""));
+            }
+            Msg::FileOp { verb, path, added, removed } => {
                 lines.push(Line::from(vec![
-                    Span::styled(
-                        format!("  {icon} {text}"),
-                        Style::default().fg(color),
-                    ),
+                    Span::styled("  📄 ", Style::default().fg(Color::Rgb(229, 192, 123))),
+                    Span::styled(format!("{verb} "), Style::default().fg(Color::White)),
+                    Span::styled(path.clone(), Style::default().fg(Color::Rgb(97, 175, 239))),
+                    Span::styled(format!("  +{added}"), Style::default().fg(Color::Rgb(152, 195, 121))),
+                    Span::styled(format!(" -{removed}"), Style::default().fg(Color::Rgb(224, 108, 117))),
                 ]));
                 lines.push(Line::from(""));
             }
-            Msg::System { text } => {
-                lines.push(Line::from(vec![
-                    Span::styled(
-                        format!("  ─ {text}"),
+            Msg::Error(msg) => {
+                lines.push(Line::from(Span::styled(
+                    format!("  ✗ {msg}"),
+                    Style::default().fg(Color::Rgb(224, 108, 117)),
+                )));
+                lines.push(Line::from(""));
+            }
+            Msg::System(msg) => {
+                for l in msg.lines() {
+                    lines.push(Line::from(Span::styled(
+                        format!("  · {l}"),
                         Style::default().fg(Color::DarkGray),
-                    ),
-                ]));
+                    )));
+                }
                 lines.push(Line::from(""));
             }
         }
     }
 
-    // Streaming in-progress
-    if !app.streaming_buf.is_empty() || app.mode == Mode::Streaming {
-        lines.push(Line::from(vec![
-            Span::styled(
-                format!("  ● {}", app.model),
-                Style::default().fg(Color::Rgb(152, 195, 121)).add_modifier(Modifier::BOLD),
-            ),
-        ]));
+    // Live pending tool (running, not yet committed)
+    if let Some(tool) = &app.pending_tool {
+        let dots = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
+        let dot = dots[app.spinner_frame % dots.len()];
+        lines.push(Line::from(Span::styled(
+            format!("  {dot} {}", tool.summary),
+            Style::default().fg(Color::DarkGray),
+        )));
+        lines.push(Line::from(""));
+    }
+
+    // In-progress streaming
+    if !app.streaming_buf.is_empty() || (app.mode == Mode::Streaming && app.pending_tool.is_none()) {
+        lines.push(assistant_header(&app.model));
         if !app.streaming_buf.is_empty() {
             for l in format_assistant_lines(&app.streaming_buf, width) {
                 lines.push(l);
             }
-        } else if app.mode == Mode::Streaming {
+        } else {
             let dots = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
             let dot = dots[app.spinner_frame % dots.len()];
             let status = if app.tool_status.is_empty() { "Thinking" } else { &app.tool_status };
-            lines.push(Line::from(vec![
-                Span::styled(
-                    format!("    {dot} {status}"),
-                    Style::default().fg(Color::DarkGray),
-                ),
-            ]));
+            lines.push(Line::from(Span::styled(
+                format!("    {dot} {status}"),
+                Style::default().fg(Color::DarkGray),
+            )));
         }
         lines.push(Line::from(""));
     }
 
     let total = lines.len();
     app.total_lines = total;
-
     let visible = area.height as usize;
     let scroll = if app.auto_scroll || app.scroll == usize::MAX {
         total.saturating_sub(visible)
@@ -732,82 +868,79 @@ fn render_messages(frame: &mut Frame, area: Rect, app: &mut App) {
     };
     app.scroll = scroll;
 
-    let text = Text::from(lines);
-    let p = Paragraph::new(text)
-        .scroll((scroll as u16, 0));
-    frame.render_widget(p, area);
+    frame.render_widget(
+        Paragraph::new(lines).scroll((scroll as u16, 0)),
+        area,
+    );
+}
+
+fn user_header() -> Line<'static> {
+    Line::from(Span::styled(
+        "  ● You",
+        Style::default().fg(Color::Rgb(97, 175, 239)).add_modifier(Modifier::BOLD),
+    ))
+}
+
+fn assistant_header(model: &str) -> Line<'static> {
+    Line::from(Span::styled(
+        format!("  ● {model}"),
+        Style::default().fg(Color::Rgb(152, 195, 121)).add_modifier(Modifier::BOLD),
+    ))
 }
 
 fn render_input(frame: &mut Frame, area: Rect, app: &App) {
     let block = Block::default()
         .borders(Borders::TOP)
         .border_style(Style::default().fg(Color::Rgb(60, 60, 80)));
-
     let inner = block.inner(area);
     frame.render_widget(block, area);
 
     let label = if app.pending_image.is_some() { "  [📎] ❯ " } else { "  ❯ " };
-    let label_width = label.chars().count();
+    let label_w = label.chars().count();
     let display = format!("{label}{}", app.input);
 
-    let p = Paragraph::new(display.clone())
-        .style(Style::default().fg(Color::White))
-        .wrap(Wrap { trim: false });
-    frame.render_widget(p, inner);
+    frame.render_widget(
+        Paragraph::new(display).style(Style::default().fg(Color::White)).wrap(Wrap { trim: false }),
+        inner,
+    );
 
     // Position cursor
-    let cursor_char = label_width + app.input[..app.input_cursor].chars().count();
-    let cursor_col = cursor_char % inner.width.max(1) as usize;
-    let cursor_row = cursor_char / inner.width.max(1) as usize;
+    let cursor_chars = label_w + app.input[..app.input_cursor].chars().count();
+    let w = inner.width.max(1) as usize;
     frame.set_cursor_position((
-        inner.x + cursor_col as u16,
-        inner.y + cursor_row as u16,
+        inner.x + (cursor_chars % w) as u16,
+        inner.y + (cursor_chars / w) as u16,
     ));
 }
 
 fn render_status(frame: &mut Frame, area: Rect, app: &App) {
-    let mode_str = match app.mode {
-        Mode::Confirming => {
-            let summary = app.confirm.as_ref().map(|c| c.summary.as_str()).unwrap_or("?");
-            format!(" ⚠  Allow: {summary}  [y]es  [a]ll  [n]o ")
-        }
-        _ => {
-            let cwd = &app.cwd;
-            let tokens = if app.usage.total_tokens > 0 {
-                format!("{}↓ {}↑  ", app.usage.prompt_tokens, app.usage.completion_tokens)
-            } else {
-                String::new()
-            };
-            let hints = "PageUp/Dn scroll  /help";
-            let left = format!(" {tokens}{cwd}");
-            let right = format!("{hints} ");
-            let gap = (area.width as usize)
-                .saturating_sub(left.chars().count() + right.chars().count());
-            format!("{left}{}{right}", " ".repeat(gap))
-        }
-    };
-
-    let style = if app.mode == Mode::Confirming {
-        Style::default().fg(Color::Black).bg(Color::Rgb(229, 192, 123))
+    let (text, style) = if app.mode == Mode::Confirming {
+        let summary = app.confirm.as_ref().map(|c| c.summary.as_str()).unwrap_or("?");
+        (
+            format!(" ⚠  Allow: {summary}   [y]es  [a]ll  [n]o "),
+            Style::default().fg(Color::Black).bg(Color::Rgb(229, 192, 123)),
+        )
     } else {
-        Style::default().fg(Color::DarkGray).bg(Color::Rgb(30, 30, 46))
+        let hints = "PageUp/Dn · scroll · /help";
+        let left = format!(" {}", app.cwd);
+        let right = format!("{hints} ");
+        let gap = (area.width as usize)
+            .saturating_sub(left.chars().count() + right.chars().count());
+        (
+            format!("{left}{}{right}", " ".repeat(gap)),
+            Style::default().fg(Color::DarkGray).bg(Color::Rgb(30, 30, 46)),
+        )
     };
-
-    frame.render_widget(Paragraph::new(mode_str).style(style), area);
+    frame.render_widget(Paragraph::new(text).style(style), area);
 }
 
 // ── Text formatting ───────────────────────────────────────────────────────────
 
 fn wrap_text(text: &str, width: usize) -> Vec<String> {
-    if width == 0 {
-        return vec![text.to_string()];
-    }
+    if width == 0 { return vec![text.to_string()]; }
     let mut out = Vec::new();
     for line in text.lines() {
-        if line.is_empty() {
-            out.push(String::new());
-            continue;
-        }
+        if line.is_empty() { out.push(String::new()); continue; }
         let mut current = String::new();
         let mut col = 0usize;
         for word in line.split_whitespace() {
@@ -817,44 +950,35 @@ fn wrap_text(text: &str, width: usize) -> Vec<String> {
                 current.clear();
                 col = 0;
             }
-            if col > 0 {
-                current.push(' ');
-                col += 1;
-            }
+            if col > 0 { current.push(' '); col += 1; }
             current.push_str(word);
             col += wlen;
         }
-        if !current.is_empty() || line.starts_with(' ') {
-            out.push(current);
-        }
+        out.push(current);
     }
     out
 }
 
 fn format_assistant_lines(text: &str, width: usize) -> Vec<Line<'static>> {
-    let mut out: Vec<Line<'static>> = Vec::new();
+    let mut out = Vec::new();
     let mut in_code = false;
     let mut code_lang = String::new();
 
-    for raw_line in text.lines() {
-        if raw_line.starts_with("```") {
+    for raw in text.lines() {
+        if raw.starts_with("```") {
             if in_code {
                 in_code = false;
                 code_lang.clear();
                 out.push(Line::from(Span::styled(
-                    "    └─────────────────────".to_string(),
+                    "    └──────────────────────".to_string(),
                     Style::default().fg(Color::Rgb(50, 50, 70)),
                 )));
             } else {
                 in_code = true;
-                code_lang = raw_line[3..].trim().to_string();
-                let lang_display = if code_lang.is_empty() {
-                    String::new()
-                } else {
-                    format!(" {code_lang} ")
-                };
+                code_lang = raw[3..].trim().to_string();
+                let lang = if code_lang.is_empty() { String::new() } else { format!(" {} ", code_lang) };
                 out.push(Line::from(Span::styled(
-                    format!("    ┌─{lang_display}"),
+                    format!("    ┌─{lang}"),
                     Style::default().fg(Color::Rgb(50, 50, 70)),
                 )));
             }
@@ -862,30 +986,24 @@ fn format_assistant_lines(text: &str, width: usize) -> Vec<Line<'static>> {
         }
 
         if in_code {
-            let highlighted = highlight_code_line(raw_line, &code_lang);
-            out.push(highlighted);
+            out.push(highlight_code_line(raw, &code_lang));
         } else {
-            // Prose line — basic inline markdown
-            let lines = if width > 0 && raw_line.chars().count() + 4 > width {
-                wrap_text(raw_line, width.saturating_sub(4))
+            let wrapped = if width > 4 && raw.chars().count() + 4 > width {
+                wrap_text(raw, width.saturating_sub(4))
             } else {
-                vec![raw_line.to_string()]
+                vec![raw.to_string()]
             };
-            for l in lines {
+            for l in wrapped {
                 out.push(format_prose_line(&l));
             }
         }
     }
-
     out
 }
 
 fn format_prose_line(line: &str) -> Line<'static> {
-    if line.is_empty() {
-        return Line::from("");
-    }
+    if line.is_empty() { return Line::from(""); }
 
-    // Headings
     if line.starts_with("### ") {
         return Line::from(Span::styled(
             format!("    {}", &line[4..]),
@@ -905,45 +1023,29 @@ fn format_prose_line(line: &str) -> Line<'static> {
         ));
     }
 
-    // List items
-    let (prefix, rest) = if line.starts_with("- ") || line.starts_with("* ") {
-        ("    • ", &line[2..])
-    } else if line.len() > 2 && line.chars().next().map_or(false, |c| c.is_ascii_digit()) && &line[1..3] == ". " {
-        ("    ", line)
+    let (prefix, rest) = if let Some(s) = line.strip_prefix("- ").or_else(|| line.strip_prefix("* ")) {
+        ("    • ", s)
     } else {
         ("    ", line)
     };
 
-    // Parse inline spans (bold, italic, code)
-    let spans = parse_inline_spans(&format!("{prefix}{rest}"));
-    Line::from(spans)
+    Line::from(parse_inline(&format!("{prefix}{rest}")))
 }
 
-fn parse_inline_spans(text: &str) -> Vec<Span<'static>> {
+fn parse_inline(text: &str) -> Vec<Span<'static>> {
     let mut spans = Vec::new();
     let mut chars = text.chars().peekable();
     let mut buf = String::new();
 
     while let Some(c) = chars.next() {
         if c == '`' {
-            // Inline code
-            if !buf.is_empty() {
-                spans.push(Span::raw(buf.clone()));
-                buf.clear();
-            }
+            if !buf.is_empty() { spans.push(Span::raw(buf.clone())); buf.clear(); }
             let mut code = String::new();
-            for ch in chars.by_ref() {
-                if ch == '`' { break; }
-                code.push(ch);
-            }
+            for ch in chars.by_ref() { if ch == '`' { break; } code.push(ch); }
             spans.push(Span::styled(code, Style::default().fg(Color::Rgb(229, 192, 123)).bg(Color::Rgb(40, 40, 55))));
         } else if c == '*' && chars.peek() == Some(&'*') {
-            // Bold
             chars.next();
-            if !buf.is_empty() {
-                spans.push(Span::raw(buf.clone()));
-                buf.clear();
-            }
+            if !buf.is_empty() { spans.push(Span::raw(buf.clone())); buf.clear(); }
             let mut bold = String::new();
             loop {
                 match chars.next() {
@@ -954,24 +1056,15 @@ fn parse_inline_spans(text: &str) -> Vec<Span<'static>> {
             }
             spans.push(Span::styled(bold, Style::default().add_modifier(Modifier::BOLD)));
         } else if c == '*' {
-            // Italic
-            if !buf.is_empty() {
-                spans.push(Span::raw(buf.clone()));
-                buf.clear();
-            }
+            if !buf.is_empty() { spans.push(Span::raw(buf.clone())); buf.clear(); }
             let mut italic = String::new();
-            for ch in chars.by_ref() {
-                if ch == '*' { break; }
-                italic.push(ch);
-            }
+            for ch in chars.by_ref() { if ch == '*' { break; } italic.push(ch); }
             spans.push(Span::styled(italic, Style::default().add_modifier(Modifier::ITALIC)));
         } else {
             buf.push(c);
         }
     }
-    if !buf.is_empty() {
-        spans.push(Span::raw(buf));
-    }
+    if !buf.is_empty() { spans.push(Span::raw(buf)); }
     spans
 }
 
@@ -981,66 +1074,56 @@ fn highlight_code_line(line: &str, _lang: &str) -> Line<'static> {
         "mod", "return", "if", "else", "for", "while", "loop", "match", "async", "await",
         "self", "Self", "true", "false", "Some", "None", "Ok", "Err", "type", "where",
         "def", "class", "import", "from", "pass", "with", "as", "in", "not", "and", "or",
-        "var", "let", "const", "function", "new", "this", "typeof", "instanceof",
-        "int", "str", "bool", "float", "None", "True", "False",
+        "var", "function", "new", "this", "typeof", "instanceof", "yield", "break", "continue",
+        "int", "str", "bool", "float", "None", "True", "False", "null", "undefined",
+        "interface", "extends", "implements", "static", "final", "void", "package",
     ];
 
-    let mut spans = Vec::new();
-    let indent = "      ";
-    spans.push(Span::styled(
-        indent.to_string(),
-        Style::default().bg(Color::Rgb(28, 28, 40)),
-    ));
+    let bg = Color::Rgb(28, 28, 40);
+    let mut spans: Vec<Span<'static>> = vec![
+        Span::styled("      ".to_string(), Style::default().bg(bg)),
+    ];
 
-    // Tokenize the line simply
     let mut chars = line.chars().peekable();
     let mut buf = String::new();
-    let base_style = Style::default().fg(Color::Rgb(171, 178, 191)).bg(Color::Rgb(28, 28, 40));
+    let mut in_string = false;
+    let mut string_char = '"';
 
-    let flush_buf = |buf: &mut String, spans: &mut Vec<Span<'static>>| {
-        if !buf.is_empty() {
-            let s = buf.clone();
-            let style = if KEYWORDS.contains(&s.as_str()) {
-                Style::default().fg(Color::Rgb(198, 120, 221)).bg(Color::Rgb(28, 28, 40))
-            } else {
-                Style::default().fg(Color::Rgb(171, 178, 191)).bg(Color::Rgb(28, 28, 40))
-            };
-            spans.push(Span::styled(s, style));
-            buf.clear();
-        }
+    let flush = |buf: &mut String, spans: &mut Vec<Span<'static>>| {
+        if buf.is_empty() { return; }
+        let s = buf.clone();
+        let style = if KEYWORDS.contains(&s.as_str()) {
+            Style::default().fg(Color::Rgb(198, 120, 221)).bg(bg)
+        } else {
+            Style::default().fg(Color::Rgb(171, 178, 191)).bg(bg)
+        };
+        spans.push(Span::styled(s, style));
+        buf.clear();
     };
 
-    let mut in_string = false;
-    let mut string_char = '"';
     while let Some(c) = chars.next() {
         if in_string {
             buf.push(c);
-            if c == string_char && !buf.ends_with("\\\"") {
+            if c == string_char {
                 let s = buf.clone();
-                spans.push(Span::styled(s, Style::default().fg(Color::Rgb(152, 195, 121)).bg(Color::Rgb(28, 28, 40))));
+                spans.push(Span::styled(s, Style::default().fg(Color::Rgb(152, 195, 121)).bg(bg)));
                 buf.clear();
                 in_string = false;
             }
             continue;
         }
 
-        // Line comment
-        if c == '/' && chars.peek() == Some(&'/') {
-            flush_buf(&mut buf, &mut spans);
+        // Line comments
+        if (c == '/' && chars.peek() == Some(&'/')) || c == '#' {
+            flush(&mut buf, &mut spans);
             let rest: String = std::iter::once(c).chain(chars.by_ref()).collect();
-            spans.push(Span::styled(rest, Style::default().fg(Color::Rgb(92, 99, 112)).bg(Color::Rgb(28, 28, 40))));
-            break;
-        }
-        if c == '#' {
-            flush_buf(&mut buf, &mut spans);
-            let rest: String = std::iter::once(c).chain(chars.by_ref()).collect();
-            spans.push(Span::styled(rest, Style::default().fg(Color::Rgb(92, 99, 112)).bg(Color::Rgb(28, 28, 40))));
+            spans.push(Span::styled(rest, Style::default().fg(Color::Rgb(92, 99, 112)).bg(bg)));
             break;
         }
 
         // String start
         if c == '"' || c == '\'' {
-            flush_buf(&mut buf, &mut spans);
+            flush(&mut buf, &mut spans);
             in_string = true;
             string_char = c;
             buf.push(c);
@@ -1049,44 +1132,35 @@ fn highlight_code_line(line: &str, _lang: &str) -> Line<'static> {
 
         // Numbers
         if c.is_ascii_digit() && buf.is_empty() {
-            flush_buf(&mut buf, &mut spans);
-            let mut num = String::new();
-            num.push(c);
+            flush(&mut buf, &mut spans);
+            let mut num = c.to_string();
             while let Some(&n) = chars.peek() {
-                if n.is_ascii_alphanumeric() || n == '.' || n == '_' {
-                    num.push(n);
-                    chars.next();
-                } else {
-                    break;
-                }
+                if n.is_ascii_alphanumeric() || n == '.' || n == '_' { num.push(n); chars.next(); }
+                else { break; }
             }
-            spans.push(Span::styled(num, Style::default().fg(Color::Rgb(209, 154, 102)).bg(Color::Rgb(28, 28, 40))));
+            spans.push(Span::styled(num, Style::default().fg(Color::Rgb(209, 154, 102)).bg(bg)));
             continue;
         }
 
-        // Word boundary
         if c.is_alphanumeric() || c == '_' {
             buf.push(c);
         } else {
-            flush_buf(&mut buf, &mut spans);
-            spans.push(Span::styled(c.to_string(), base_style));
+            flush(&mut buf, &mut spans);
+            spans.push(Span::styled(c.to_string(), Style::default().fg(Color::Rgb(171, 178, 191)).bg(bg)));
         }
     }
-    flush_buf(&mut buf, &mut spans);
-
-    // Pad to fill the line visually
-    let total_content_len: usize = spans.iter().map(|s| s.content.chars().count()).sum();
-    if total_content_len < 80 {
-        spans.push(Span::styled(
-            " ".repeat(80 - total_content_len),
-            Style::default().bg(Color::Rgb(28, 28, 40)),
-        ));
+    flush(&mut buf, &mut spans);
+
+    // Fill remainder with bg color
+    let content_len: usize = spans.iter().map(|s| s.content.chars().count()).sum();
+    if content_len < 84 {
+        spans.push(Span::styled(" ".repeat(84 - content_len), Style::default().bg(bg)));
     }
 
     Line::from(spans)
 }
 
-// ── Cursor / string helpers ───────────────────────────────────────────────────
+// ── String/cursor helpers ─────────────────────────────────────────────────────
 
 fn prev_char_len(s: &str, pos: usize) -> usize {
     s[..pos].chars().next_back().map(|c| c.len_utf8()).unwrap_or(0)
@@ -1097,23 +1171,21 @@ fn next_char_len(s: &str, pos: usize) -> usize {
 }
 
 fn move_cursor_left(s: &str, pos: &mut usize) {
-    let len = prev_char_len(s, *pos);
-    *pos = pos.saturating_sub(len);
+    *pos = pos.saturating_sub(prev_char_len(s, *pos));
 }
 
 fn move_cursor_right(s: &str, pos: &mut usize) {
-    let len = next_char_len(s, *pos);
-    *pos = (*pos + len).min(s.len());
+    *pos = (*pos + next_char_len(s, *pos)).min(s.len());
 }
 
 fn delete_word_before(s: &mut String, pos: &mut usize) {
-    while *pos > 0 && s[..*pos].ends_with(' ') {
+    while *pos > 0 && s[..*pos].ends_with(|c: char| c == ' ' || c == '\n') {
         let len = prev_char_len(s, *pos);
         let start = *pos - len;
         s.drain(start..*pos);
         *pos = start;
     }
-    while *pos > 0 && !s[..*pos].ends_with(' ') {
+    while *pos > 0 && !s[..*pos].ends_with(|c: char| c == ' ' || c == '\n') {
         let len = prev_char_len(s, *pos);
         let start = *pos - len;
         s.drain(start..*pos);