From 3e544180d0a32e904040ce01a03395f80402a3de Mon Sep 17 00:00:00 2001
From: Felipe Coury <felipe.coury@gmail.com>
Date: Fri, 8 May 2026 01:12:54 -0300
Subject: [PATCH 01/37] fix(tui): route tests through editor actions

Remove the duplicate test-only action reducer so integration tests execute the same editor dispatch path as production.

Tighten cursor, line-boundary, and Unicode handling around grapheme-aware editing so movement, deletion, and diagnostics avoid byte-index assumptions.
---
 src/buffer.rs                  |  54 +-
 src/editor.rs                  | 939 ++++++---------------------------
 src/editor/render_buffer.rs    |   2 +-
 src/editor/rendering.rs        |  25 +-
 src/test_utils.rs              |   5 +-
 src/unicode_utils.rs           |  79 +++
 tests/common/editor_harness.rs |   6 +-
 7 files changed, 300 insertions(+), 810 deletions(-)

diff --git a/src/buffer.rs b/src/buffer.rs
index 6cac8a8..10ebddc 100644
--- a/src/buffer.rs
+++ b/src/buffer.rs
@@ -164,11 +164,11 @@ impl Buffer {
 
     /// Sets the content of a line
     pub fn set(&mut self, line: usize, content: String) {
-        if line >= self.len() {
+        if line > self.len() {
             return;
         }
         let start_char = self.content.line_to_char(line);
-        let end_char = if line + 1 < self.len() {
+        let end_char = if line + 1 < self.content.len_lines() {
             self.content.line_to_char(line + 1)
         } else {
             self.content.len_chars()
@@ -270,11 +270,11 @@ impl Buffer {
 
     /// Replaces a line with new content
     pub fn replace_line(&mut self, line: usize, new_line: String) {
-        if line >= self.len() {
+        if line > self.len() {
             return;
         }
         let start_char = self.content.line_to_char(line);
-        let end_char = if line + 1 < self.len() {
+        let end_char = if line + 1 < self.content.len_lines() {
             self.content.line_to_char(line + 1)
         } else {
             self.content.len_chars()
@@ -315,11 +315,11 @@ impl Buffer {
 
         loop {
             let line = self.get(y)?;
-            if x >= line.len() {
+            if x >= line.chars().count() {
                 // Move to next line if at end
                 y += 1;
                 x = 0;
-                if y >= self.len() {
+                if y > self.len() {
                     return None;
                 }
                 continue;
@@ -329,7 +329,8 @@ impl Buffer {
             let current_type = Self::get_char_type(current_char);
 
             // Skip current word/sequence
-            while x < line.len() {
+            let line_len = line.chars().count();
+            while x < line_len {
                 let c = line.chars().nth(x)?;
                 if Self::get_char_type(c) != current_type {
                     break;
@@ -338,7 +339,7 @@ impl Buffer {
             }
 
             // Skip whitespace
-            while x < line.len() {
+            while x < line_len {
                 let c = line.chars().nth(x)?;
                 if !c.is_whitespace() {
                     return Some((x, y));
@@ -347,10 +348,10 @@ impl Buffer {
             }
 
             // If we reach end of line, continue to next line
-            if x >= line.len() {
+            if x >= line_len {
                 y += 1;
                 x = 0;
-                if y >= self.len() {
+                if y > self.len() {
                     return None;
                 }
             }
@@ -362,8 +363,9 @@ impl Buffer {
         let line = self.get(y)?;
         let mut x = x;
         let chars = line.chars().skip(x);
+        let line_len = line.chars().count();
         for c in chars {
-            if x >= line.len() {
+            if x >= line_len {
                 return Some((x, y));
             }
             if !c.is_alphanumeric() && c != '_' {
@@ -380,7 +382,8 @@ impl Buffer {
         let line = self.get(y)?;
 
         // Check if we're at the last character of the buffer
-        if y >= self.len().saturating_sub(1) && x >= line.len().saturating_sub(1) {
+        let line_len = line.chars().count();
+        if y >= self.len() && x >= line_len.saturating_sub(1) {
             return None;
         }
 
@@ -388,7 +391,7 @@ impl Buffer {
         // without doing anything else
         if line.is_empty() {
             y += 1;
-            if y >= self.len() {
+            if y > self.len() {
                 return None;
             }
             return Some((0, y));
@@ -399,7 +402,7 @@ impl Buffer {
         // If we're at the end of current line, move to next line
         if x >= chars.len() {
             y += 1;
-            if y >= self.len() {
+            if y > self.len() {
                 return None;
             }
             x = 0;
@@ -450,7 +453,7 @@ impl Buffer {
         }
 
         y += 1;
-        if y >= self.len() {
+        if y > self.len() {
             return None;
         }
 
@@ -559,13 +562,15 @@ impl Buffer {
         let (mut x, mut y) = self.find_word_end((x, y))?;
 
         loop {
-            if y >= self.len() {
+            if y > self.len() {
                 return None;
             }
 
             let line = self.get(y)?;
-            if let Some(pos) = line[x..].find(query) {
-                return Some((pos + x, y));
+            let suffix = crate::unicode_utils::char_suffix(&line, x);
+            if let Some(pos) = suffix.find(query) {
+                let prefix_chars = suffix[..pos].chars().count();
+                return Some((prefix_chars + x, y));
             }
 
             x = 0;
@@ -578,13 +583,14 @@ impl Buffer {
         let (mut x, mut y) = self.find_word_start((x, y))?;
 
         loop {
-            if y >= self.len() {
+            if y > self.len() {
                 return None;
             }
 
             let line = self.get(y)?;
-            if let Some(pos) = line[..x].rfind(query) {
-                return Some((pos, y));
+            let prefix = crate::unicode_utils::char_prefix(&line, x);
+            if let Some(pos) = prefix.rfind(query) {
+                return Some((prefix[..pos].chars().count(), y));
             }
 
             if y == 0 {
@@ -592,7 +598,7 @@ impl Buffer {
             }
 
             y -= 1;
-            x = self.get(y)?.len();
+            x = self.get(y)?.chars().count();
         }
     }
 
@@ -605,11 +611,9 @@ impl Buffer {
         let end_char = self.xy_to_char_idx(end.0, end.1);
 
         // Get the text before removing (need to use byte indices for slice)
-        let start_byte = self.content.char_to_byte(start_char);
-        let end_byte = self.content.char_to_byte(end_char);
         let result = self
             .content
-            .get_slice(start_byte..end_byte)
+            .get_slice(start_char..end_char)
             .map(|s| s.to_string());
 
         self.content.remove(start_char..end_char);
diff --git a/src/editor.rs b/src/editor.rs
index 42fbf75..0cfa3d4 100644
--- a/src/editor.rs
+++ b/src/editor.rs
@@ -10,7 +10,10 @@ use std::{
     time::{Duration, Instant},
 };
 
-use crate::unicode_utils::{display_width, next_grapheme_boundary, prev_grapheme_boundary};
+use crate::unicode_utils::{
+    char_prefix, char_slice, char_suffix, display_width, grapheme_len, grapheme_to_byte,
+    grapheme_to_char, next_grapheme_boundary, prev_grapheme_boundary,
+};
 
 /// Editor is the main component that handles:
 /// - Text editing operations
@@ -37,6 +40,7 @@ use nix::unistd::Pid;
 use once_cell::sync::Lazy;
 use serde::{Deserialize, Serialize};
 use serde_json::{json, Map, Value};
+use unicode_segmentation::UnicodeSegmentation;
 
 pub use render_buffer::RenderBuffer;
 
@@ -397,6 +401,9 @@ pub struct Editor {
     /// Terminal output handle
     stdout: std::io::Stdout,
 
+    /// Whether render operations should write terminal escape sequences
+    terminal_output_enabled: bool,
+
     /// Terminal size (width, height)
     size: (u16, u16),
 
@@ -602,6 +609,7 @@ impl Editor {
             current_buffer_index: 0,
             window_manager,
             stdout,
+            terminal_output_enabled: true,
             size,
             vtop: 0,
             vleft: 0,
@@ -758,11 +766,18 @@ impl Editor {
     fn line_length(&self) -> usize {
         if let Some(line) = self.viewport_line(self.cy) {
             let line = line.trim_end_matches('\n');
-            return line.chars().count();
+            return grapheme_len(line);
         }
         0
     }
 
+    fn grapheme_to_char_on_line(&self, x: usize, y: usize) -> usize {
+        self.current_buffer()
+            .get(y)
+            .map(|line| grapheme_to_char(line.trim_end_matches('\n'), x))
+            .unwrap_or(x)
+    }
+
     /// Returns the display width of the current line in columns
     #[allow(dead_code)]
     fn line_display_width(&self) -> usize {
@@ -877,7 +892,7 @@ impl Editor {
             return;
         };
 
-        let x = self.gutter_width() + line.len() + 5;
+        let x = self.gutter_width() + display_width(line.trim_end_matches('\n')) + 5;
 
         // otherwise, clear the line
         let text = " ".repeat(self.vwidth().saturating_sub(x));
@@ -1010,9 +1025,9 @@ impl Editor {
     fn check_bounds(&mut self) {
         let line_length = self.line_length();
 
-        if self.cx >= line_length && self.is_normal() {
+        if self.cx > line_length && self.is_normal() {
             if line_length > 0 {
-                self.cx = self.line_length() - 1;
+                self.cx = self.line_length();
             } else if self.is_normal() {
                 self.cx = 0;
             }
@@ -1024,8 +1039,8 @@ impl Editor {
         // check if cy is after the end of the buffer
         // the end of the buffer is less than vtop + cy
         let line_on_buffer = self.cy + self.vtop;
-        if line_on_buffer > self.current_buffer().len().saturating_sub(1) {
-            self.cy = self.current_buffer().len() - self.vtop - 1;
+        if line_on_buffer > self.current_buffer().len() {
+            self.cy = self.current_buffer().len().saturating_sub(self.vtop);
         }
     }
 
@@ -1142,7 +1157,7 @@ impl Editor {
                             }
                             PluginRequest::BufferInsert { x, y, text } => {
                                 // Track undo action
-                                self.undo_actions.push(Action::DeleteRange(x, y, x + text.len(), y));
+                                self.undo_actions.push(Action::DeleteRange(x, y, x + text.chars().count(), y));
 
                                 self.current_buffer_mut().insert_str(x, y, &text);
                                 self.notify_change(&mut runtime).await?;
@@ -1154,7 +1169,7 @@ impl Editor {
                                 let mut deleted_text = String::new();
                                 for i in 0..length {
                                     if let Some(line) = current_buf.get(y) {
-                                        if x + i < line.len() {
+                                        if x + i < line.chars().count() {
                                             deleted_text.push(line.chars().nth(x + i).unwrap_or(' '));
                                         }
                                     }
@@ -1180,14 +1195,14 @@ impl Editor {
                                 let mut replaced_text = String::new();
                                 for i in 0..length {
                                     if let Some(line) = current_buf.get(y) {
-                                        if x + i < line.len() {
+                                        if x + i < line.chars().count() {
                                             replaced_text.push(line.chars().nth(x + i).unwrap_or(' '));
                                         }
                                     }
                                 }
                                 // For undo, we need to delete the new text and insert the old
                                 self.undo_actions.push(Action::UndoMultiple(vec![
-                                    Action::DeleteRange(x, y, x + text.len(), y),
+                                    Action::DeleteRange(x, y, x + text.chars().count(), y),
                                     Action::InsertText {
                                         x,
                                         y,
@@ -1219,7 +1234,7 @@ impl Editor {
                             PluginRequest::GetCursorDisplayColumn => {
                                 let display_col = if let Some(line) = self.current_line_contents() {
                                     let line = line.trim_end_matches('\n');
-                                    crate::unicode_utils::char_to_column(line, self.cx)
+                                    crate::unicode_utils::grapheme_to_column(line, self.cx)
                                 } else {
                                     self.cx
                                 };
@@ -1249,7 +1264,7 @@ impl Editor {
                                 // Convert display column to character index
                                 if let Some(line) = self.viewport_line(y - self.vtop) {
                                     let line = line.trim_end_matches('\n');
-                                    self.cx = crate::unicode_utils::column_to_char(line, column);
+                                    self.cx = crate::unicode_utils::column_to_grapheme(line, column);
                                 }
                                 // Adjust viewport if needed
                                 if y < self.vtop {
@@ -2010,7 +2025,7 @@ impl Editor {
                 }
             }
             Action::MoveDown => {
-                if self.vtop + self.cy < self.current_buffer().len() - 1 {
+                if self.vtop + self.cy < self.current_buffer().len() {
                     self.cy += 1;
                     if self.cy >= self.vheight() {
                         // scroll if possible
@@ -2028,17 +2043,11 @@ impl Editor {
                 if let Some(line) = self.current_line_contents() {
                     let line = line.trim_end_matches('\n');
 
-                    // Convert current position to byte offset
-                    let current_byte = self
-                        .current_buffer()
-                        .column_to_char_index(self.cx, self.buffer_line());
-                    let byte_offset = crate::unicode_utils::char_to_byte(line, current_byte);
+                    let byte_offset = grapheme_to_byte(line, self.cx);
 
                     // Find previous grapheme boundary
                     if let Some(prev_byte) = prev_grapheme_boundary(line, byte_offset) {
-                        // Convert back to character index
-                        let char_idx = crate::unicode_utils::byte_to_char(line, prev_byte);
-                        self.cx = char_idx;
+                        self.cx = crate::unicode_utils::byte_to_grapheme(line, prev_byte);
                     } else if self.cx > 0 {
                         self.cx = 0;
                     }
@@ -2053,19 +2062,17 @@ impl Editor {
                 // Move by grapheme clusters
                 if let Some(line) = self.current_line_contents() {
                     let line = line.trim_end_matches('\n');
-                    let max_chars = line.chars().count();
+                    let max_graphemes = grapheme_len(line);
 
-                    if self.cx < max_chars {
-                        // Convert current position to byte offset
-                        let current_byte = crate::unicode_utils::char_to_byte(line, self.cx);
+                    if self.cx < max_graphemes {
+                        let current_byte = grapheme_to_byte(line, self.cx);
 
                         // Find next grapheme boundary
                         if let Some(next_byte) = next_grapheme_boundary(line, current_byte) {
-                            // Convert back to character index
-                            let char_idx = crate::unicode_utils::byte_to_char(line, next_byte);
-                            self.cx = char_idx.min(max_chars);
+                            self.cx = crate::unicode_utils::byte_to_grapheme(line, next_byte)
+                                .min(max_graphemes);
                         } else {
-                            self.cx = max_chars;
+                            self.cx = max_graphemes;
                         }
                     }
                 }
@@ -2075,21 +2082,26 @@ impl Editor {
                 self.cx = 0;
             }
             Action::MoveToLineEnd => {
-                self.cx = self.line_length().saturating_sub(1);
+                self.cx = self.line_length();
             }
             Action::MoveToFirstLineChar => {
                 if let Some(line) = self.current_line_contents() {
-                    self.cx = line.chars().position(|c| !c.is_whitespace()).unwrap_or(0);
+                    self.cx = line
+                        .trim_end_matches('\n')
+                        .graphemes(true)
+                        .position(|g| !g.chars().all(char::is_whitespace))
+                        .unwrap_or(0);
                 }
             }
             Action::MoveToLastLineChar => {
                 if let Some(line) = self.current_line_contents() {
-                    self.cx = line.len().saturating_sub(
-                        line.chars()
-                            .rev()
-                            .position(|c| !c.is_whitespace())
-                            .unwrap_or(0),
-                    );
+                    let line = line.trim_end_matches('\n');
+                    let trailing = line
+                        .graphemes(true)
+                        .rev()
+                        .position(|g| !g.chars().all(char::is_whitespace))
+                        .unwrap_or(0);
+                    self.cx = grapheme_len(line).saturating_sub(trailing + 1);
                 }
             }
             Action::PageUp => {
@@ -2170,6 +2182,7 @@ impl Editor {
                     .push(Action::DeleteCharAt(self.cx, self.buffer_line()));
                 let line = self.buffer_line();
                 let cx = self.cx;
+                let char_cx = self.grapheme_to_char_on_line(cx, line);
 
                 log!(
                     "InsertCharAtCursorPos - char: '{}' (U+{:04X}), cx: {}, line: {}",
@@ -2185,11 +2198,11 @@ impl Editor {
                     log!("Line char count: {}", line_content.chars().count());
                 }
 
-                self.current_buffer_mut().insert(cx, line, *c);
+                self.current_buffer_mut().insert(char_cx, line, *c);
                 self.notify_change(runtime).await?;
 
                 // Move cursor by one character position (not display width)
-                self.cx += 1;
+                self.cx += grapheme_len(&c.to_string());
 
                 log!("Cursor after insert: cx = {}", self.cx);
 
@@ -2209,9 +2222,30 @@ impl Editor {
                 let cx = self.cx;
                 let line = self.buffer_line();
 
-                self.current_buffer_mut().remove(cx, line);
-                self.notify_change(runtime).await?;
-                self.draw_line(buffer);
+                let deleted = self.current_buffer().get(line).and_then(|line_content| {
+                    let line_content = line_content.trim_end_matches('\n');
+                    line_content
+                        .graphemes(true)
+                        .nth(cx)
+                        .map(|grapheme| grapheme.to_string())
+                });
+
+                if let Some(deleted) = deleted {
+                    let start = self.grapheme_to_char_on_line(cx, line);
+                    let end = self.grapheme_to_char_on_line(cx + 1, line);
+                    self.current_buffer_mut()
+                        .remove_range(start, line, end, line);
+                    self.notify_change(runtime).await?;
+                    self.undo_actions.push(Action::InsertText {
+                        x: cx,
+                        y: line,
+                        content: Content {
+                            kind: ContentKind::Charwise,
+                            text: deleted,
+                        },
+                    });
+                    self.draw_line(buffer);
+                }
             }
             Action::ReplaceLineAt(y, contents) => {
                 self.current_buffer_mut()
@@ -2232,11 +2266,13 @@ impl Editor {
 
                 let current_line = self.current_line_contents().unwrap_or_default();
                 let current_line = current_line.trim_end();
-                if self.cx > current_line.len() {
-                    self.cx = current_line.len();
+                let current_line_len = grapheme_len(current_line);
+                if self.cx > current_line_len {
+                    self.cx = current_line_len;
                 }
-                let before_cursor = current_line[..self.cx].to_string();
-                let after_cursor = current_line[self.cx..].to_string();
+                let cursor_char = grapheme_to_char(current_line, self.cx);
+                let before_cursor = char_prefix(current_line, cursor_char).to_string();
+                let after_cursor = char_suffix(current_line, cursor_char).to_string();
 
                 let line = self.buffer_line();
                 self.current_buffer_mut().replace_line(line, before_cursor);
@@ -2266,6 +2302,10 @@ impl Editor {
                 self.current_buffer_mut().remove_line(line);
                 self.notify_change(runtime).await?;
                 self.undo_actions.push(Action::InsertLineAt(line, contents));
+                let target_line = line.min(self.current_buffer().len());
+                self.vtop = self.vtop.min(target_line);
+                self.cy = target_line.saturating_sub(self.vtop);
+                self.cx = 0;
                 self.render(buffer)?;
             }
             Action::Undo => {
@@ -2343,6 +2383,7 @@ impl Editor {
                 self.notify_change(runtime).await?;
                 self.cy += 1;
                 self.cx = leading_spaces;
+                self.mode = Mode::Insert;
 
                 if self.cy >= self.vheight() {
                     self.vtop += 1;
@@ -2371,6 +2412,7 @@ impl Editor {
                     .insert_line(line, " ".repeat(leading_spaces));
                 self.notify_change(runtime).await?;
                 self.cx = leading_spaces;
+                self.mode = Mode::Insert;
                 self.render(buffer)?;
             }
             Action::MoveToTop => {
@@ -2379,12 +2421,14 @@ impl Editor {
                 self.render(buffer)?;
             }
             Action::MoveToBottom => {
-                if self.current_buffer().len() > self.vheight() {
+                let last_line = self.current_buffer().len();
+                let line_count = last_line + 1;
+                if line_count > self.vheight() {
                     self.cy = self.vheight() - 1;
-                    self.vtop = self.current_buffer().len() - self.vheight();
+                    self.vtop = line_count - self.vheight();
                     self.render(buffer)?;
                 } else {
-                    self.cy = self.current_buffer().len() - 1;
+                    self.cy = last_line;
                 }
             }
             Action::DeleteLineAt(y) => {
@@ -2397,25 +2441,19 @@ impl Editor {
                     // Get the current line to find the previous grapheme boundary
                     if let Some(line) = self.current_line_contents() {
                         let line = line.trim_end_matches('\n');
-                        let current_byte = crate::unicode_utils::char_to_byte(line, self.cx);
+                        let current_byte = grapheme_to_byte(line, self.cx);
 
                         if let Some(prev_byte) =
                             crate::unicode_utils::prev_grapheme_boundary(line, current_byte)
                         {
-                            let prev_char_idx = crate::unicode_utils::byte_to_char(line, prev_byte);
-
-                            // Calculate how many characters to remove
-                            let chars_to_remove = self.cx - prev_char_idx;
-
-                            // Move cursor to the previous grapheme boundary
-                            self.cx = prev_char_idx;
-
-                            // Remove all characters in the grapheme cluster
+                            let prev_grapheme_idx =
+                                crate::unicode_utils::byte_to_grapheme(line, prev_byte);
+                            let start_char = crate::unicode_utils::byte_to_char(line, prev_byte);
+                            let end_char = crate::unicode_utils::byte_to_char(line, current_byte);
                             let line_num = self.buffer_line();
-                            let cx = self.cx;
-                            for _ in 0..chars_to_remove {
-                                self.current_buffer_mut().remove(cx, line_num);
-                            }
+                            self.current_buffer_mut()
+                                .remove_range(start_char, line_num, end_char, line_num);
+                            self.cx = prev_grapheme_idx;
 
                             self.notify_change(runtime).await?;
                             self.draw_line(buffer);
@@ -2951,9 +2989,10 @@ impl Editor {
             Action::InsertString(text) => {
                 let line = self.buffer_line();
                 let cx = self.cx;
-                self.current_buffer_mut().insert_str(cx, line, text);
+                let char_cx = self.grapheme_to_char_on_line(cx, line);
+                self.current_buffer_mut().insert_str(char_cx, line, text);
                 self.notify_change(runtime).await?;
-                self.cx += text.len();
+                self.cx += grapheme_len(text);
                 self.draw_line(buffer);
             }
             Action::RequestCompletion => {
@@ -3299,10 +3338,11 @@ impl Editor {
 
         // truncate the message if it's too long
         let overflow = x.unsigned_abs() as usize;
-        let (x, text) = if overflow + 3 >= text.len() {
+        let text_len = text.chars().count();
+        let (x, text) = if overflow + 3 >= text_len {
             (x, text.to_string())
         } else {
-            (0, format!("...{}", &text[overflow..]))
+            (0, format!("...{}", char_suffix(text, overflow)))
         };
 
         self.render_commands.push_back(RenderCommand::BufferText {
@@ -3462,14 +3502,15 @@ impl Editor {
 
                         for y in y0..=y1 {
                             if let Some(line) = self.current_buffer().get(y) {
-                                if min_x >= line.len() {
+                                let line_len = line.chars().count();
+                                if min_x >= line_len {
                                     continue;
                                 }
-                                let before = line[..min_x].to_string();
-                                let after = if max_x + 1 >= line.len() {
+                                let before = char_prefix(&line, min_x).to_string();
+                                let after = if max_x + 1 >= line_len {
                                     String::new()
                                 } else {
-                                    line[max_x + 1..].to_string()
+                                    char_suffix(&line, max_x + 1).to_string()
                                 };
                                 self.current_buffer_mut()
                                     .replace_line(y, format!("{}{}", before, after));
@@ -3479,8 +3520,8 @@ impl Editor {
                     Mode::Visual => {
                         if y0 == y1 {
                             let line = self.current_buffer().get(y0).unwrap();
-                            let before = line[..x0].to_string();
-                            let after = line[x1 + 1..].to_string();
+                            let before = char_prefix(&line, x0).to_string();
+                            let after = char_suffix(&line, x1 + 1).to_string();
                             self.current_buffer_mut()
                                 .replace_line(y0, format!("{}{}", before, after));
                         } else {
@@ -3489,8 +3530,8 @@ impl Editor {
                             let last_line = self.current_buffer().get(y1).unwrap();
 
                             // Combine the parts before and after the selection
-                            let before = first_line[..x0].to_string();
-                            let after = last_line[x1 + 1..].to_string();
+                            let before = char_prefix(&first_line, x0).to_string();
+                            let after = char_suffix(&last_line, x1 + 1).to_string();
                             let new_line = format!("{}{}", before, after);
 
                             // Replace the first line with the combined text
@@ -3557,12 +3598,13 @@ impl Editor {
             let mut new_line = current_line.clone();
 
             // Extend the line with spaces if needed
-            while new_line.len() < paste_x {
+            while grapheme_len(&new_line) < paste_x {
                 new_line.push(' ');
             }
 
             // Insert the block text
-            new_line.insert_str(paste_x, line);
+            let paste_byte = grapheme_to_byte(&new_line, paste_x);
+            new_line.insert_str(paste_byte, line);
             self.current_buffer_mut().replace_line(y, new_line);
         }
     }
@@ -3570,25 +3612,28 @@ impl Editor {
     fn insert_charwise(&mut self, x: usize, y: usize, contents: &Content, before: bool) {
         let lines = contents.text.lines().collect::<Vec<_>>();
         let count = lines.len();
+        let insert_x = self.grapheme_to_char_on_line(x, y);
 
         if count == 1 {
             let line = lines[0];
             if before {
-                self.current_buffer_mut().insert_str(x, y, line);
+                self.current_buffer_mut().insert_str(insert_x, y, line);
             } else {
-                self.current_buffer_mut().insert_str(x + 1, y, line);
+                let after_x = self.grapheme_to_char_on_line(x + 1, y);
+                self.current_buffer_mut().insert_str(after_x, y, line);
                 self.cx += 1;
             }
             return;
         }
 
         let line_contents = self.current_line_contents().unwrap_or_default();
-        let (text_before, text_after) = line_contents.split_at(x);
+        let text_before = char_prefix(&line_contents, insert_x).to_string();
+        let text_after = char_suffix(&line_contents, insert_x).to_string();
 
         for (n, line) in lines.iter().enumerate() {
             if n == 0 {
-                self.current_buffer_mut().set(y, text_before.to_string());
-                self.current_buffer_mut().insert_str(x, y, line);
+                self.current_buffer_mut().set(y, text_before.clone());
+                self.current_buffer_mut().insert_str(insert_x, y, line);
             } else if n == count - 1 {
                 let new_text = format!("{}{}", line, text_after);
                 self.current_buffer_mut()
@@ -3698,7 +3743,7 @@ impl Editor {
             return Ok(());
         }
 
-        if line <= self.current_buffer().len() {
+        if line <= self.current_buffer().len() + 1 {
             let y = line - 1;
 
             if self.is_within_viewport(y) {
@@ -3708,7 +3753,7 @@ impl Editor {
                 self.cy = y;
                 self.render(buffer)?;
             } else if self.is_within_last_page(y) {
-                self.vtop = self.current_buffer().len() - self.vheight();
+                self.vtop = (self.current_buffer().len() + 1).saturating_sub(self.vheight());
                 self.cy = y - self.vtop;
                 self.render(buffer)?;
             } else {
@@ -3763,7 +3808,7 @@ impl Editor {
     }
 
     fn is_within_last_page(&self, y: usize) -> bool {
-        y > self.current_buffer().len() - self.vheight()
+        y >= (self.current_buffer().len() + 1).saturating_sub(self.vheight())
     }
 
     fn is_within_first_page(&self, y: usize) -> bool {
@@ -3961,9 +4006,10 @@ impl Editor {
 
                 for y in y0..=y1 {
                     if let Some(line) = self.current_buffer().get(y) {
-                        let end = std::cmp::min(max_x + 1, line.len());
-                        if min_x <= line.len() {
-                            text.push_str(&line[min_x..end]);
+                        let line_len = line.chars().count();
+                        let end = std::cmp::min(max_x + 1, line_len);
+                        if min_x <= line_len {
+                            text.push_str(char_slice(&line, min_x, end));
                         }
                         text.push('\n');
                     }
@@ -3975,8 +4021,15 @@ impl Editor {
                 for y in y0..=y1 {
                     let line = self.current_buffer().get(y).unwrap();
                     let start = if y == y0 { x0 } else { 0 };
-                    let end = if y == y1 { x1 } else { line.len() - 1 };
-                    text.push_str(&line[start..=end]);
+                    let end = if y == y1 {
+                        x1
+                    } else {
+                        line.trim_end_matches('\n')
+                            .chars()
+                            .count()
+                            .saturating_sub(1)
+                    };
+                    text.push_str(char_slice(&line, start, end + 1));
                     if y != y1 {
                         text.push('\n');
                     }
@@ -3990,13 +4043,9 @@ impl Editor {
     fn fix_cursor_pos(&mut self) {
         let line_len = self.line_length();
 
-        if self.is_normal() && line_len > 0 {
-            // In normal mode, cursor can't be on the newline character
-            if self.cx >= line_len {
-                self.cx = line_len.saturating_sub(1);
-            }
-        } else if self.cx > line_len {
-            // In other modes, cursor can be at the end of line
+        if self.cx > line_len {
+            // Cursor positions are character indices and may sit one past the
+            // final character for append-style editing.
             self.cx = line_len;
         }
     }
@@ -4130,682 +4179,8 @@ fn adjust_color_brightness(color: Option<Color>, percentage: i32) -> Option<Colo
     }
 }
 
-// Public methods for test utilities (hidden from docs)
+// These methods are made public for test utilities but hidden from docs.
 impl Editor {
-    /// Core action logic without side effects
-    /// Returns (should_quit, needs_render, needs_lsp_notify)
-    #[doc(hidden)]
-    pub fn apply_action_core(&mut self, action: &Action) -> anyhow::Result<(bool, bool, bool)> {
-        let mut needs_render = false;
-        let mut needs_lsp_notify = false;
-        let should_quit;
-
-        match action {
-            Action::EnterMode(mode) => {
-                self.mode = *mode;
-                // Set selection start when entering visual mode
-                if matches!(mode, Mode::Visual | Mode::VisualLine | Mode::VisualBlock) {
-                    self.selection_start = Some(Point::new(self.cx, self.buffer_line()));
-                }
-                needs_render = true;
-                should_quit = false;
-            }
-            Action::InsertCharAtCursorPos(c) => {
-                let line = self.buffer_line();
-                let cx = self.cx;
-
-                #[cfg(test)]
-                {
-                    println!(
-                        "InsertCharAtCursorPos: char='{}', cx={}, line={}",
-                        c, cx, line
-                    );
-                    if let Some(line_content) = self.current_buffer().get(line) {
-                        println!("  Line content before: {:?}", line_content);
-                    }
-                }
-
-                self.current_buffer_mut().insert(cx, line, *c);
-                if self.mode == Mode::Insert {
-                    self.cx += 1;
-                }
-                needs_lsp_notify = true;
-                needs_render = true;
-                should_quit = false;
-            }
-            Action::MoveRight => {
-                let line = self.current_buffer().get(self.buffer_line());
-                if let Some(line) = line {
-                    let line = line.trim_end_matches('\n');
-                    let line_len = line.chars().count();
-                    if self.cx < line_len {
-                        self.cx += 1;
-                    }
-                }
-                should_quit = false;
-            }
-            Action::MoveLeft => {
-                if self.cx > 0 {
-                    self.cx -= 1;
-                }
-                should_quit = false;
-            }
-            Action::MoveDown => {
-                let buffer_lines = self.current_buffer().len();
-                let current_line = self.vtop + self.cy;
-                if current_line < buffer_lines {
-                    self.cy += 1;
-                    if self.cy >= self.vheight() {
-                        // Need to scroll
-                        self.vtop += 1;
-                        self.cy -= 1;
-                        needs_render = true;
-                    }
-                }
-                should_quit = false;
-            }
-            Action::MoveUp => {
-                if self.cy == 0 {
-                    // Need to scroll up
-                    if self.vtop > 0 {
-                        self.vtop -= 1;
-                        needs_render = true;
-                    }
-                } else {
-                    self.cy = self.cy.saturating_sub(1);
-                }
-                should_quit = false;
-            }
-            Action::MoveToBottom => {
-                // buffer.len() returns the number of lines minus 1
-                // For a 2-line buffer, it returns 1, which is the index of the last line
-                let last_line = self.current_buffer().len();
-                self.set_cursor_line(last_line);
-                should_quit = false;
-            }
-            Action::MoveToLineStart => {
-                self.cx = 0;
-                should_quit = false;
-            }
-            Action::MoveToLineEnd => {
-                let line = self.buffer_line();
-                if let Some(content) = self.current_buffer().get(line) {
-                    self.cx = content.trim_end_matches('\n').len();
-                }
-                should_quit = false;
-            }
-            Action::MoveToFirstLineChar => {
-                if let Some(line) = self.current_line_contents() {
-                    self.cx = line.chars().position(|c| !c.is_whitespace()).unwrap_or(0);
-                }
-                should_quit = false;
-            }
-            Action::MoveToLastLineChar => {
-                if let Some(line) = self.current_line_contents() {
-                    let trimmed = line.trim_end();
-                    if let Some(pos) = trimmed.rfind(|c: char| !c.is_whitespace()) {
-                        self.cx = pos;
-                    } else {
-                        self.cx = 0;
-                    }
-                }
-                should_quit = false;
-            }
-            Action::Quit(force) => {
-                if *force || self.modified_buffers().is_empty() {
-                    should_quit = true;
-                } else {
-                    self.last_error = Some("Unsaved changes".to_string());
-                    should_quit = false;
-                }
-            }
-            Action::DeleteCharAtCursorPos => {
-                let line = self.buffer_line();
-                let cx = self.cx;
-                self.current_buffer_mut().remove(cx, line);
-                needs_lsp_notify = true;
-                needs_render = true;
-                should_quit = false;
-            }
-            Action::DeleteCurrentLine => {
-                let line = self.buffer_line();
-                self.current_buffer_mut().remove_line(line);
-                self.cx = 0;
-                needs_lsp_notify = true;
-                needs_render = true;
-                should_quit = false;
-            }
-            Action::InsertLineBelowCursor => {
-                let line = self.buffer_line();
-                self.current_buffer_mut()
-                    .insert_line(line + 1, "".to_string());
-                self.cy += 1;
-                self.cx = 0;
-                self.mode = Mode::Insert;
-                needs_lsp_notify = true;
-                needs_render = true;
-                should_quit = false;
-            }
-            Action::InsertLineAtCursor => {
-                let line = self.buffer_line();
-                self.current_buffer_mut().insert_line(line, "".to_string());
-                self.cx = 0;
-                self.mode = Mode::Insert;
-                needs_lsp_notify = true;
-                needs_render = true;
-                should_quit = false;
-            }
-            Action::MoveToNextWord => {
-                if let Some((x, y)) = self
-                    .current_buffer()
-                    .find_next_word((self.cx, self.buffer_line()))
-                {
-                    self.cx = x;
-                    if y != self.buffer_line() {
-                        // TODO: Handle moving to next line
-                    }
-                }
-                should_quit = false;
-            }
-            Action::MoveToPreviousWord => {
-                if let Some((x, y)) = self
-                    .current_buffer()
-                    .find_prev_word((self.cx, self.buffer_line()))
-                {
-                    self.cx = x;
-                    if y != self.buffer_line() {
-                        // TODO: Handle moving to previous line
-                    }
-                }
-                should_quit = false;
-            }
-            Action::DeleteWord => {
-                let pos = (self.cx, self.buffer_line());
-                self.current_buffer_mut().delete_word(pos);
-                needs_lsp_notify = true;
-                needs_render = true;
-                should_quit = false;
-            }
-            Action::Undo => {
-                // For test harness - simple undo that restores 'H'
-                let line = self.buffer_line();
-                self.current_buffer_mut().insert(0, line, 'H');
-                needs_render = true;
-                should_quit = false;
-            }
-            // ===== File Operations =====
-            Action::Save => {
-                match self.current_buffer_mut().save() {
-                    Ok(_msg) => {
-                        // In production code, this message would be displayed
-                        needs_render = true;
-                    }
-                    Err(e) => {
-                        self.last_error = Some(e.to_string());
-                    }
-                }
-                should_quit = false;
-            }
-            Action::SaveAs(path) => {
-                match self.current_buffer_mut().save_as(path) {
-                    Ok(_msg) => {
-                        // In production code, this message would be displayed
-                        needs_render = true;
-                    }
-                    Err(e) => {
-                        self.last_error = Some(e.to_string());
-                    }
-                }
-                should_quit = false;
-            }
-
-            // ===== Line Operations =====
-            Action::InsertNewLine => {
-                let spaces = self.current_line_indentation();
-                let current_line = self.current_line_contents().unwrap_or_default();
-                let current_line = current_line.trim_end();
-
-                let cx = if self.cx > current_line.len() {
-                    current_line.len()
-                } else {
-                    self.cx
-                };
-
-                let before_cursor = current_line[..cx].to_string();
-                let after_cursor = current_line[cx..].to_string();
-
-                let line = self.buffer_line();
-                self.current_buffer_mut().replace_line(line, before_cursor);
-
-                self.cx = spaces;
-                self.cy += 1;
-
-                if self.cy >= self.vheight() {
-                    self.vtop += 1;
-                    self.cy -= 1;
-                }
-
-                let new_line = format!("{}{}", " ".repeat(spaces), &after_cursor);
-                let line = self.buffer_line();
-                self.current_buffer_mut().insert_line(line, new_line);
-
-                needs_lsp_notify = true;
-                needs_render = true;
-                should_quit = false;
-            }
-
-            // ===== Page Movement =====
-            Action::PageUp => {
-                if self.vtop > 0 {
-                    self.vtop = self.vtop.saturating_sub(self.vheight());
-                    needs_render = true;
-                }
-                should_quit = false;
-            }
-            Action::PageDown => {
-                if self.current_buffer().len() > self.vtop + self.vheight() {
-                    self.vtop += self.vheight();
-                    needs_render = true;
-                }
-                should_quit = false;
-            }
-
-            // ===== Search Actions =====
-            Action::FindNext => {
-                if !self.search_term.is_empty() {
-                    if let Some((x, y)) = self
-                        .current_buffer()
-                        .find_next(&self.search_term, (self.cx, self.buffer_line()))
-                    {
-                        self.cx = x;
-                        let new_line = y;
-                        if new_line != self.buffer_line() {
-                            self.set_cursor_line(new_line);
-                            needs_render = true;
-                        }
-                    }
-                }
-                should_quit = false;
-            }
-            Action::FindPrevious => {
-                if !self.search_term.is_empty() {
-                    if let Some((x, y)) = self
-                        .current_buffer()
-                        .find_prev(&self.search_term, (self.cx, self.buffer_line()))
-                    {
-                        self.cx = x;
-                        let new_line = y;
-                        if new_line != self.buffer_line() {
-                            self.set_cursor_line(new_line);
-                            needs_render = true;
-                        }
-                    }
-                }
-                should_quit = false;
-            }
-
-            // ===== Buffer Management =====
-            Action::NextBuffer => {
-                if self.buffers.len() > 1 {
-                    self.current_buffer_index =
-                        (self.current_buffer_index + 1) % self.buffers.len();
-                    needs_render = true;
-                }
-                should_quit = false;
-            }
-            Action::PreviousBuffer => {
-                if self.buffers.len() > 1 {
-                    self.current_buffer_index = if self.current_buffer_index == 0 {
-                        self.buffers.len() - 1
-                    } else {
-                        self.current_buffer_index - 1
-                    };
-                    needs_render = true;
-                }
-                should_quit = false;
-            }
-
-            // ===== Clipboard Operations =====
-            Action::Yank => {
-                // Store current line in default register
-                if let Some(line) = self.current_line_contents() {
-                    let content = Content {
-                        kind: ContentKind::Linewise, // Yank line is linewise
-                        text: line.to_string(),
-                    };
-                    self.registers.insert('"', content);
-                }
-                should_quit = false;
-            }
-            Action::Paste => {
-                if let Some(content) = self.registers.get(&'"').cloned() {
-                    let line = self.buffer_line();
-                    let text = content.text.trim_end_matches('\n');
-                    let cx = self.cx;
-                    self.current_buffer_mut().insert_str(cx, line, text);
-                    needs_lsp_notify = true;
-                    needs_render = true;
-                }
-                should_quit = false;
-            }
-            Action::PasteBefore => {
-                if let Some(content) = self.registers.get(&'"').cloned() {
-                    let line = self.buffer_line();
-                    let text = content.text.trim_end_matches('\n');
-                    let cx = if self.cx > 0 { self.cx - 1 } else { 0 };
-                    self.current_buffer_mut().insert_str(cx, line, text);
-                    needs_lsp_notify = true;
-                    needs_render = true;
-                }
-                should_quit = false;
-            }
-
-            // ===== Other Movement Actions =====
-            Action::MoveToTop => {
-                self.set_cursor_line(0);
-                self.cx = 0;
-                should_quit = false;
-            }
-            Action::MoveTo(x, y) => {
-                self.cx = *x;
-                // Convert 1-based line number to 0-based
-                let target_line = y.saturating_sub(1);
-                self.set_cursor_line(target_line);
-                should_quit = false;
-            }
-            Action::GoToLine(line) => {
-                let target_line = line.saturating_sub(1); // Convert 1-based to 0-based
-                let max_line = self.current_buffer().len(); // This is already the last valid line index
-                let target_line = target_line.min(max_line);
-                self.set_cursor_line(target_line);
-                self.cx = 0;
-                needs_render = true;
-                should_quit = false;
-            }
-
-            // ===== Editing Operations =====
-            Action::DeletePreviousChar => {
-                if self.cx > 0 {
-                    // Get the current line to find the previous grapheme boundary
-                    if let Some(line) = self.current_line_contents() {
-                        let line = line.trim_end_matches('\n');
-                        let current_byte = crate::unicode_utils::char_to_byte(line, self.cx);
-
-                        if let Some(prev_byte) =
-                            crate::unicode_utils::prev_grapheme_boundary(line, current_byte)
-                        {
-                            let prev_char_idx = crate::unicode_utils::byte_to_char(line, prev_byte);
-
-                            // Find the actual grapheme cluster to determine its length in characters
-                            use unicode_segmentation::UnicodeSegmentation;
-                            let graphemes: Vec<(usize, &str)> =
-                                line.grapheme_indices(true).collect();
-
-                            // Find the grapheme that starts at prev_byte
-                            let mut chars_to_remove = 1; // Default to 1 if we can't find it
-                            for (byte_pos, grapheme) in graphemes {
-                                if byte_pos == prev_byte {
-                                    // Count the actual characters in this grapheme
-                                    chars_to_remove = grapheme.chars().count();
-                                    break;
-                                }
-                            }
-
-                            // Move cursor to the previous grapheme boundary
-                            self.cx = prev_char_idx;
-
-                            // Remove all characters in the grapheme cluster
-                            let line_num = self.buffer_line();
-                            let cx = self.cx;
-                            for _ in 0..chars_to_remove {
-                                self.current_buffer_mut().remove(cx, line_num);
-                            }
-
-                            needs_lsp_notify = true;
-                            needs_render = true;
-                        }
-                    }
-                } else if self.buffer_line() > 0 {
-                    // Join with previous line
-                    let prev_line = self.buffer_line() - 1;
-                    let current_line = self.buffer_line();
-                    if let Some(prev_content) = self.current_buffer().get(prev_line) {
-                        let prev_len = prev_content.trim_end_matches('\n').len();
-                        let current_content = self.current_line_contents().unwrap_or_default();
-                        let joined =
-                            format!("{}{}", prev_content.trim_end(), current_content.trim_end());
-
-                        self.current_buffer_mut().replace_line(prev_line, joined);
-                        self.current_buffer_mut().remove_line(current_line);
-
-                        self.set_cursor_line(prev_line);
-                        self.cx = prev_len;
-                        needs_lsp_notify = true;
-                        needs_render = true;
-                    }
-                }
-                should_quit = false;
-            }
-            Action::InsertTab => {
-                let spaces = "    "; // 4 spaces for tab
-                let line = self.buffer_line();
-                let cx = self.cx;
-                self.current_buffer_mut().insert_str(cx, line, spaces);
-                self.cx += 4;
-                needs_lsp_notify = true;
-                needs_render = true;
-                should_quit = false;
-            }
-
-            // ===== Visual Mode Operations =====
-            // Visual mode is entered via Action::EnterMode(Mode::Visual)
-            // which is already handled above
-
-            // ===== Other Operations =====
-            Action::Refresh => {
-                needs_render = true;
-                should_quit = false;
-            }
-            Action::RequestCompletion => {
-                // This would trigger LSP completion request
-                // For now, just mark as needing render
-                needs_render = true;
-                should_quit = false;
-            }
-
-            // Window management actions
-            Action::SplitHorizontal => {
-                let current_buffer = self.current_buffer_index;
-                if self
-                    .window_manager
-                    .split_horizontal(current_buffer)
-                    .is_some()
-                {
-                    self.sync_with_window();
-                    needs_render = true;
-                }
-                should_quit = false;
-            }
-            Action::SplitVertical => {
-                let current_buffer = self.current_buffer_index;
-                if self.window_manager.split_vertical(current_buffer).is_some() {
-                    self.sync_with_window();
-                    needs_render = true;
-                }
-                should_quit = false;
-            }
-            Action::SplitHorizontalWithFile(_) | Action::SplitVerticalWithFile(_) => {
-                // These are handled in execute_with_tracking
-                should_quit = false;
-            }
-            Action::CloseWindow => {
-                if self.window_manager.close_window().is_some() {
-                    self.sync_with_window();
-                    needs_render = true;
-                }
-                should_quit = false;
-            }
-            Action::NextWindow => {
-                let window_count = self.window_manager.windows().len();
-                if window_count > 1 {
-                    self.sync_to_window(); // Save current window state
-                    let next_id = (self.window_manager.active_window_id() + 1) % window_count;
-                    self.window_manager.set_active(next_id);
-                    self.sync_with_window(); // Load new window state
-                    needs_render = true;
-                }
-                should_quit = false;
-            }
-            Action::PreviousWindow => {
-                let window_count = self.window_manager.windows().len();
-                if window_count > 1 {
-                    self.sync_to_window(); // Save current window state
-                    let current_id = self.window_manager.active_window_id();
-                    let prev_id = if current_id == 0 {
-                        window_count - 1
-                    } else {
-                        current_id - 1
-                    };
-                    self.window_manager.set_active(prev_id);
-                    self.sync_with_window(); // Load new window state
-                    needs_render = true;
-                }
-                should_quit = false;
-            }
-            Action::MoveWindowUp => {
-                self.sync_to_window(); // Save current window state
-                if let Some(target_id) = self
-                    .window_manager
-                    .find_window_in_direction(crate::window::Direction::Up)
-                {
-                    self.window_manager.set_active(target_id);
-                    self.sync_with_window(); // Load new window state
-                    needs_render = true;
-                }
-                should_quit = false;
-            }
-            Action::MoveWindowDown => {
-                self.sync_to_window(); // Save current window state
-                if let Some(target_id) = self
-                    .window_manager
-                    .find_window_in_direction(crate::window::Direction::Down)
-                {
-                    self.window_manager.set_active(target_id);
-                    self.sync_with_window(); // Load new window state
-                    needs_render = true;
-                }
-                should_quit = false;
-            }
-            Action::MoveWindowLeft => {
-                self.sync_to_window(); // Save current window state
-                if let Some(target_id) = self
-                    .window_manager
-                    .find_window_in_direction(crate::window::Direction::Left)
-                {
-                    self.window_manager.set_active(target_id);
-                    self.sync_with_window(); // Load new window state
-                    needs_render = true;
-                }
-                should_quit = false;
-            }
-            Action::MoveWindowRight => {
-                self.sync_to_window(); // Save current window state
-                if let Some(target_id) = self
-                    .window_manager
-                    .find_window_in_direction(crate::window::Direction::Right)
-                {
-                    self.window_manager.set_active(target_id);
-                    self.sync_with_window(); // Load new window state
-                    needs_render = true;
-                }
-                should_quit = false;
-            }
-            Action::ResizeWindowUp(amount) => {
-                self.sync_to_window(); // Save current window state
-                if self
-                    .window_manager
-                    .resize_window(crate::window::Direction::Up, *amount)
-                    .is_some()
-                {
-                    self.sync_with_window(); // Load new window state
-                    needs_render = true;
-                }
-                should_quit = false;
-            }
-            Action::ResizeWindowDown(amount) => {
-                self.sync_to_window(); // Save current window state
-                if self
-                    .window_manager
-                    .resize_window(crate::window::Direction::Down, *amount)
-                    .is_some()
-                {
-                    self.sync_with_window(); // Load new window state
-                    needs_render = true;
-                }
-                should_quit = false;
-            }
-            Action::ResizeWindowLeft(amount) => {
-                self.sync_to_window(); // Save current window state
-                if self
-                    .window_manager
-                    .resize_window(crate::window::Direction::Left, *amount)
-                    .is_some()
-                {
-                    self.sync_with_window(); // Load new window state
-                    needs_render = true;
-                }
-                should_quit = false;
-            }
-            Action::ResizeWindowRight(amount) => {
-                self.sync_to_window(); // Save current window state
-                if self
-                    .window_manager
-                    .resize_window(crate::window::Direction::Right, *amount)
-                    .is_some()
-                {
-                    self.sync_with_window(); // Load new window state
-                    needs_render = true;
-                }
-                should_quit = false;
-            }
-            Action::BalanceWindows => {
-                // TODO: Implement window balancing
-                should_quit = false;
-            }
-            Action::MaximizeWindow => {
-                // TODO: Implement window maximizing
-                should_quit = false;
-            }
-
-            _ => {
-                // Other actions not yet migrated
-                should_quit = false;
-            }
-        }
-
-        Ok((should_quit, needs_render, needs_lsp_notify))
-    }
-
-    /// Helper to set cursor line and handle viewport scrolling
-    fn set_cursor_line(&mut self, new_line: usize) {
-        let viewport_height = self.vheight();
-
-        if new_line < self.vtop {
-            // Scroll up
-            self.vtop = new_line;
-            self.cy = 0;
-        } else if new_line >= self.vtop + viewport_height {
-            // Scroll down
-            self.vtop = new_line - viewport_height + 1;
-            self.cy = viewport_height - 1;
-        } else {
-            // Just move cursor within viewport
-            self.cy = new_line - self.vtop;
-        }
-    }
-
-    // These methods are made public for test utilities but hidden from docs
-
     #[doc(hidden)]
     pub fn test_cx(&self) -> usize {
         self.cx
@@ -4855,6 +4230,24 @@ impl Editor {
     pub fn test_set_size(&mut self, width: u16, height: u16) {
         self.size = (width, height);
     }
+
+    #[doc(hidden)]
+    pub fn test_disable_terminal_output(&mut self) {
+        self.terminal_output_enabled = false;
+    }
+
+    #[doc(hidden)]
+    pub async fn test_execute_production_action(&mut self, action: Action) -> anyhow::Result<()> {
+        let mut render_buffer = RenderBuffer::new(
+            self.size.0 as usize,
+            self.size.1 as usize,
+            &Style::default(),
+        );
+        let mut runtime = Runtime::new();
+        self.execute(&action, &mut render_buffer, &mut runtime)
+            .await?;
+        Ok(())
+    }
 }
 
 #[cfg(test)]
diff --git a/src/editor/render_buffer.rs b/src/editor/render_buffer.rs
index d50cb21..d19f571 100644
--- a/src/editor/render_buffer.rs
+++ b/src/editor/render_buffer.rs
@@ -231,7 +231,7 @@ impl RenderBuffer {
         s
     }
 
-    pub fn diff(&self, other: &RenderBuffer) -> Vec<Change> {
+    pub fn diff(&self, other: &RenderBuffer) -> Vec<Change<'_>> {
         let mut changes = vec![];
         for (pos, cell) in self.cells.iter().enumerate() {
             if *cell != other.cells[pos] {
diff --git a/src/editor/rendering.rs b/src/editor/rendering.rs
index a2feba5..d1c7b34 100644
--- a/src/editor/rendering.rs
+++ b/src/editor/rendering.rs
@@ -11,7 +11,7 @@ use crate::{
     log,
     lsp::Diagnostic,
     theme::Style,
-    unicode_utils::char_display_width,
+    unicode_utils::{char_display_width, display_width, truncate_chars},
 };
 
 use super::{
@@ -712,7 +712,7 @@ impl Editor {
 
         // Truncate message if needed and add ellipsis
         let display_message = if message.chars().count() > max_msg_length {
-            format!("{}…", &message[..max_msg_length - 1])
+            format!("{}…", truncate_chars(message, max_msg_length - 1))
         } else {
             message.to_string()
         };
@@ -779,7 +779,7 @@ impl Editor {
 
             // Calculate diagnostic indicator position within window
             let gutter_width = self.gutter_width();
-            let content_end = gutter_width + line.len();
+            let content_end = gutter_width + display_width(line.trim_end_matches('\n'));
             let indicator_x = content_end + 5; // Add some padding
 
             // Skip if diagnostic would be outside window
@@ -888,6 +888,10 @@ impl Editor {
     }
 
     pub fn render_diff(&mut self, change_set: Vec<Change<'_>>) -> anyhow::Result<()> {
+        if !self.terminal_output_enabled {
+            return Ok(());
+        }
+
         self.stdout.queue(cursor::Hide)?;
 
         // Debug: Log number of changes and emoji changes
@@ -1158,9 +1162,14 @@ impl Editor {
 
     pub fn draw_cursor(&mut self) -> anyhow::Result<()> {
         self.fix_cursor_pos();
-        self.set_cursor_style()?;
         self.check_bounds();
 
+        if !self.terminal_output_enabled {
+            return Ok(());
+        }
+
+        self.set_cursor_style()?;
+
         // TODO: refactor this out to allow for dynamic setting of the cursor "target",
         // so we could transition from the editor to dialogs, to searches, etc.
         let cursor_pos = if let Some(current_dialog) = &self.current_dialog {
@@ -1177,7 +1186,7 @@ impl Editor {
                 // Calculate the actual display column for the cursor
                 let display_col = if let Some(line) = self.viewport_line(window.vtop + window_cy) {
                     let line = line.trim_end_matches('\n');
-                    crate::unicode_utils::char_to_column(line, window_cx)
+                    crate::unicode_utils::grapheme_to_column(line, window_cx)
                 } else {
                     window_cx
                 };
@@ -1191,7 +1200,7 @@ impl Editor {
                 // Fallback to old behavior if no active window
                 let display_col = if let Some(line) = self.viewport_line(self.cy) {
                     let line = line.trim_end_matches('\n');
-                    crate::unicode_utils::char_to_column(line, self.cx)
+                    crate::unicode_utils::grapheme_to_column(line, self.cx)
                 } else {
                     self.cx
                 };
@@ -1209,6 +1218,10 @@ impl Editor {
     }
 
     fn set_cursor_style(&mut self) -> anyhow::Result<()> {
+        if !self.terminal_output_enabled {
+            return Ok(());
+        }
+
         self.stdout.queue(match self.waiting_key_action {
             Some(_) => cursor::SetCursorStyle::SteadyUnderScore,
             _ => match self.mode {
diff --git a/src/test_utils.rs b/src/test_utils.rs
index 4448b01..3b9fd49 100644
--- a/src/test_utils.rs
+++ b/src/test_utils.rs
@@ -11,7 +11,7 @@ pub trait EditorTestExt {
     /// Get current mode for testing
     fn test_mode(&self) -> Mode;
 
-    /// Execute an action for testing - uses core logic only
+    /// Execute an action for testing using the production dispatcher.
     async fn test_execute_action(&mut self, action: Action) -> anyhow::Result<()>;
 
     /// Get buffer contents for testing
@@ -52,8 +52,7 @@ impl EditorTestExt for Editor {
     }
 
     async fn test_execute_action(&mut self, action: Action) -> anyhow::Result<()> {
-        self.apply_action_core(&action)?;
-        Ok(())
+        self.test_execute_production_action(action).await
     }
 
     fn test_buffer_contents(&self) -> String {
diff --git a/src/unicode_utils.rs b/src/unicode_utils.rs
index ff535fe..b9b29d0 100644
--- a/src/unicode_utils.rs
+++ b/src/unicode_utils.rs
@@ -46,6 +46,53 @@ pub fn char_to_byte(line: &str, char_idx: usize) -> usize {
         .unwrap_or(line.len())
 }
 
+/// Convert a grapheme cluster index to a byte offset.
+pub fn grapheme_to_byte(line: &str, grapheme_idx: usize) -> usize {
+    line.grapheme_indices(true)
+        .nth(grapheme_idx)
+        .map(|(idx, _)| idx)
+        .unwrap_or(line.len())
+}
+
+/// Convert a byte offset to a grapheme cluster index.
+pub fn byte_to_grapheme(line: &str, byte_offset: usize) -> usize {
+    let byte_offset = byte_offset.min(line.len());
+    line[..byte_offset].graphemes(true).count()
+}
+
+/// Convert a grapheme cluster index to Ropey's character index.
+pub fn grapheme_to_char(line: &str, grapheme_idx: usize) -> usize {
+    byte_to_char(line, grapheme_to_byte(line, grapheme_idx))
+}
+
+/// Convert Ropey's character index to a grapheme cluster index.
+pub fn char_to_grapheme(line: &str, char_idx: usize) -> usize {
+    byte_to_grapheme(line, char_to_byte(line, char_idx))
+}
+
+/// Slice a string by character indices.
+pub fn char_slice(line: &str, start: usize, end: usize) -> &str {
+    let start_byte = char_to_byte(line, start);
+    let end_byte = char_to_byte(line, end);
+    &line[start_byte..end_byte]
+}
+
+/// Return the prefix before a character index.
+pub fn char_prefix(line: &str, end: usize) -> &str {
+    char_slice(line, 0, end)
+}
+
+/// Return the suffix starting at a character index.
+pub fn char_suffix(line: &str, start: usize) -> &str {
+    let start_byte = char_to_byte(line, start);
+    &line[start_byte..]
+}
+
+/// Truncate a string to at most `max_chars` Unicode scalar values.
+pub fn truncate_chars(line: &str, max_chars: usize) -> &str {
+    char_prefix(line, max_chars)
+}
+
 /// Convert a byte offset to a character index
 pub fn byte_to_char(line: &str, byte_offset: usize) -> usize {
     let byte_offset = byte_offset.min(line.len());
@@ -124,6 +171,29 @@ pub fn column_to_char(line: &str, target_column: usize) -> usize {
     line.chars().count()
 }
 
+/// Calculate the display column of a grapheme at a given grapheme index.
+pub fn grapheme_to_column(line: &str, grapheme_idx: usize) -> usize {
+    line.graphemes(true)
+        .take(grapheme_idx)
+        .map(display_width)
+        .sum()
+}
+
+/// Find the grapheme index that contains the given display column.
+pub fn column_to_grapheme(line: &str, target_column: usize) -> usize {
+    let mut current_column = 0;
+
+    for (idx, grapheme) in line.graphemes(true).enumerate() {
+        let grapheme_width = display_width(grapheme);
+        if current_column + grapheme_width > target_column {
+            return idx;
+        }
+        current_column += grapheme_width;
+    }
+
+    line.graphemes(true).count()
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -206,4 +276,13 @@ mod tests {
         assert_eq!(column_to_char(line, 7), 6);
         assert_eq!(column_to_char(line, 9), 7);
     }
+
+    #[test]
+    fn test_char_slicing() {
+        let line = "a👋世界";
+        assert_eq!(char_slice(line, 1, 3), "👋世");
+        assert_eq!(char_prefix(line, 2), "a👋");
+        assert_eq!(char_suffix(line, 3), "界");
+        assert_eq!(truncate_chars(line, 3), "a👋世");
+    }
 }
diff --git a/tests/common/editor_harness.rs b/tests/common/editor_harness.rs
index 548e566..cfdc7d3 100644
--- a/tests/common/editor_harness.rs
+++ b/tests/common/editor_harness.rs
@@ -36,7 +36,8 @@ impl EditorHarness {
         let lsp = Box::new(MockLsp) as Box<dyn LspClient + Send>;
         let config = Config::default();
         let theme = Theme::default();
-        let editor = Editor::with_size(lsp, 80, 24, config, theme, vec![buffer]).unwrap();
+        let mut editor = Editor::with_size(lsp, 80, 24, config, theme, vec![buffer]).unwrap();
+        editor.test_disable_terminal_output();
 
         Self { editor }
     }
@@ -45,7 +46,8 @@ impl EditorHarness {
     pub fn with_config(buffer: Buffer, config: Config) -> Self {
         let lsp = Box::new(MockLsp) as Box<dyn LspClient + Send>;
         let theme = Theme::default();
-        let editor = Editor::with_size(lsp, 80, 24, config, theme, vec![buffer]).unwrap();
+        let mut editor = Editor::with_size(lsp, 80, 24, config, theme, vec![buffer]).unwrap();
+        editor.test_disable_terminal_output();
 
         Self { editor }
     }

From 39c65237416aeff95eaccc83283bdd3b9f57faff Mon Sep 17 00:00:00 2001
From: Felipe Coury <felipe.coury@gmail.com>
Date: Fri, 8 May 2026 01:17:23 -0300
Subject: [PATCH 02/37] refactor(tui): centralize active window sync

Route window switching and layout mutations through editor helpers so active-window state is saved and reloaded consistently.

Add coverage that verifies split window navigation preserves each window cursor independently.
---
 src/editor.rs                  | 152 ++++++++++++++-------------------
 tests/common/editor_harness.rs |  26 ++++++
 2 files changed, 92 insertions(+), 86 deletions(-)

diff --git a/src/editor.rs b/src/editor.rs
index 0cfa3d4..7ea7beb 100644
--- a/src/editor.rs
+++ b/src/editor.rs
@@ -693,6 +693,36 @@ impl Editor {
         }
     }
 
+    fn set_active_window(&mut self, window_id: usize) -> bool {
+        if window_id == self.window_manager.active_window_id() {
+            return false;
+        }
+
+        self.sync_to_window();
+        self.window_manager.set_active(window_id);
+        self.sync_with_window();
+        true
+    }
+
+    fn update_window_layout(
+        &mut self,
+        update: impl FnOnce(&mut WindowManager) -> Option<()>,
+    ) -> bool {
+        self.sync_to_window();
+        if update(&mut self.window_manager).is_some() {
+            self.sync_with_window();
+            true
+        } else {
+            false
+        }
+    }
+
+    fn resize_window_layout(&mut self, terminal_size: (usize, usize)) {
+        self.sync_to_window();
+        self.window_manager.resize(terminal_size);
+        self.sync_with_window();
+    }
+
     fn indentation(&self) -> Indentation {
         let file_type = self.current_buffer().file_type();
 
@@ -1388,9 +1418,7 @@ impl Editor {
                                 if self.cy > max_y - 1 {
                                     self.cy = max_y - 1;
                                 }
-                                // Resize window manager
-                                self.window_manager.resize((width as usize, height as usize));
-                                self.sync_to_window();
+                                self.resize_window_layout((width as usize, height as usize));
                                 buffer = RenderBuffer::new(
                                     self.size.0 as usize,
                                     self.size.1 as usize,
@@ -3086,13 +3114,8 @@ impl Editor {
             Action::SplitHorizontal => {
                 log!("SplitHorizontal action triggered");
                 let current_buffer = self.current_buffer_index;
-                if self
-                    .window_manager
-                    .split_horizontal(current_buffer)
-                    .is_some()
-                {
+                if self.update_window_layout(|windows| windows.split_horizontal(current_buffer)) {
                     log!("Window split successful");
-                    self.sync_with_window();
                     self.render(buffer)?;
                 } else {
                     log!("Window split failed");
@@ -3101,9 +3124,8 @@ impl Editor {
             Action::SplitVertical => {
                 log!("SplitVertical action triggered");
                 let current_buffer = self.current_buffer_index;
-                if self.window_manager.split_vertical(current_buffer).is_some() {
+                if self.update_window_layout(|windows| windows.split_vertical(current_buffer)) {
                     log!("Vertical split successful");
-                    self.sync_with_window();
                     self.render(buffer)?;
                 } else {
                     log!("Vertical split failed");
@@ -3119,13 +3141,10 @@ impl Editor {
                     Ok(new_buffer) => {
                         self.buffers.push(new_buffer);
                         let new_buffer_index = self.buffers.len() - 1;
-                        if self
-                            .window_manager
-                            .split_horizontal(new_buffer_index)
-                            .is_some()
-                        {
+                        if self.update_window_layout(|windows| {
+                            windows.split_horizontal(new_buffer_index)
+                        }) {
                             log!("Window split with new file successful");
-                            self.sync_with_window();
                             self.render(buffer)?;
                         } else {
                             log!("Window split failed");
@@ -3145,13 +3164,10 @@ impl Editor {
                     Ok(new_buffer) => {
                         self.buffers.push(new_buffer);
                         let new_buffer_index = self.buffers.len() - 1;
-                        if self
-                            .window_manager
-                            .split_vertical(new_buffer_index)
-                            .is_some()
-                        {
+                        if self.update_window_layout(|windows| {
+                            windows.split_vertical(new_buffer_index)
+                        }) {
                             log!("Vertical split with new file successful");
-                            self.sync_with_window();
                             self.render(buffer)?;
                         } else {
                             log!("Vertical split failed");
@@ -3165,121 +3181,92 @@ impl Editor {
                 }
             }
             Action::CloseWindow => {
-                if self.window_manager.close_window().is_some() {
-                    self.sync_with_window();
+                if self.update_window_layout(WindowManager::close_window) {
                     self.render(buffer)?;
                 }
             }
             Action::NextWindow => {
                 let window_count = self.window_manager.windows().len();
                 if window_count > 1 {
-                    self.sync_to_window(); // Save current window state
                     let next_id = (self.window_manager.active_window_id() + 1) % window_count;
-                    self.window_manager.set_active(next_id);
-                    self.sync_with_window(); // Load new window state
+                    self.set_active_window(next_id);
                     self.render(buffer)?;
                 }
             }
             Action::PreviousWindow => {
                 let window_count = self.window_manager.windows().len();
                 if window_count > 1 {
-                    self.sync_to_window(); // Save current window state
                     let current_id = self.window_manager.active_window_id();
                     let prev_id = if current_id == 0 {
                         window_count - 1
                     } else {
                         current_id - 1
                     };
-                    self.window_manager.set_active(prev_id);
-                    self.sync_with_window(); // Load new window state
+                    self.set_active_window(prev_id);
                     self.render(buffer)?;
                 }
             }
             Action::MoveWindowUp => {
-                self.sync_to_window(); // Save current window state
                 if let Some(target_id) = self
                     .window_manager
                     .find_window_in_direction(crate::window::Direction::Up)
                 {
-                    self.window_manager.set_active(target_id);
-                    self.sync_with_window(); // Load new window state
+                    self.set_active_window(target_id);
                     self.render(buffer)?;
                 }
             }
             Action::MoveWindowDown => {
-                self.sync_to_window(); // Save current window state
                 if let Some(target_id) = self
                     .window_manager
                     .find_window_in_direction(crate::window::Direction::Down)
                 {
-                    self.window_manager.set_active(target_id);
-                    self.sync_with_window(); // Load new window state
+                    self.set_active_window(target_id);
                     self.render(buffer)?;
                 }
             }
             Action::MoveWindowLeft => {
-                self.sync_to_window(); // Save current window state
                 if let Some(target_id) = self
                     .window_manager
                     .find_window_in_direction(crate::window::Direction::Left)
                 {
-                    self.window_manager.set_active(target_id);
-                    self.sync_with_window(); // Load new window state
+                    self.set_active_window(target_id);
                     self.render(buffer)?;
                 }
             }
             Action::MoveWindowRight => {
-                self.sync_to_window(); // Save current window state
                 if let Some(target_id) = self
                     .window_manager
                     .find_window_in_direction(crate::window::Direction::Right)
                 {
-                    self.window_manager.set_active(target_id);
-                    self.sync_with_window(); // Load new window state
+                    self.set_active_window(target_id);
                     self.render(buffer)?;
                 }
             }
             Action::ResizeWindowUp(amount) => {
-                self.sync_to_window(); // Save current window state
-                if self
-                    .window_manager
-                    .resize_window(crate::window::Direction::Up, *amount)
-                    .is_some()
-                {
-                    self.sync_with_window(); // Load new window state
+                if self.update_window_layout(|windows| {
+                    windows.resize_window(crate::window::Direction::Up, *amount)
+                }) {
                     self.render(buffer)?;
                 }
             }
             Action::ResizeWindowDown(amount) => {
-                self.sync_to_window(); // Save current window state
-                if self
-                    .window_manager
-                    .resize_window(crate::window::Direction::Down, *amount)
-                    .is_some()
-                {
-                    self.sync_with_window(); // Load new window state
+                if self.update_window_layout(|windows| {
+                    windows.resize_window(crate::window::Direction::Down, *amount)
+                }) {
                     self.render(buffer)?;
                 }
             }
             Action::ResizeWindowLeft(amount) => {
-                self.sync_to_window(); // Save current window state
-                if self
-                    .window_manager
-                    .resize_window(crate::window::Direction::Left, *amount)
-                    .is_some()
-                {
-                    self.sync_with_window(); // Load new window state
+                if self.update_window_layout(|windows| {
+                    windows.resize_window(crate::window::Direction::Left, *amount)
+                }) {
                     self.render(buffer)?;
                 }
             }
             Action::ResizeWindowRight(amount) => {
-                self.sync_to_window(); // Save current window state
-                if self
-                    .window_manager
-                    .resize_window(crate::window::Direction::Right, *amount)
-                    .is_some()
-                {
-                    self.sync_with_window(); // Load new window state
+                if self.update_window_layout(|windows| {
+                    windows.resize_window(crate::window::Direction::Right, *amount)
+                }) {
                     self.render(buffer)?;
                 }
             }
@@ -3860,11 +3847,7 @@ impl Editor {
                             let window_vtop = window.vtop;
 
                             // Switch to the clicked window if it's not already active
-                            if window_id != self.window_manager.active_window_id() {
-                                self.sync_to_window(); // Save current window state
-                                self.window_manager.set_active(window_id);
-                                self.sync_with_window(); // Load new window state
-                            }
+                            self.set_active_window(window_id);
 
                             // Convert terminal coordinates to window-local coordinates
                             if let Some((local_x, local_y)) =
@@ -3904,11 +3887,7 @@ impl Editor {
                         if let Some((window_id, _window)) =
                             self.window_manager.window_at_position(click_x, click_y)
                         {
-                            if window_id != self.window_manager.active_window_id() {
-                                self.sync_to_window(); // Save current window state
-                                self.window_manager.set_active(window_id);
-                                self.sync_with_window(); // Load new window state
-                            }
+                            self.set_active_window(window_id);
                         }
 
                         Some(KeyAction::Single(Action::ScrollUp))
@@ -3921,11 +3900,7 @@ impl Editor {
                         if let Some((window_id, _window)) =
                             self.window_manager.window_at_position(click_x, click_y)
                         {
-                            if window_id != self.window_manager.active_window_id() {
-                                self.sync_to_window(); // Save current window state
-                                self.window_manager.set_active(window_id);
-                                self.sync_with_window(); // Load new window state
-                            }
+                            self.set_active_window(window_id);
                         }
 
                         Some(KeyAction::Single(Action::ScrollDown))
@@ -4216,6 +4191,11 @@ impl Editor {
         self.vtop
     }
 
+    #[doc(hidden)]
+    pub fn test_active_window_id(&self) -> usize {
+        self.window_manager.active_window_id()
+    }
+
     #[doc(hidden)]
     pub fn test_current_line_contents(&self) -> Option<String> {
         self.current_line_contents()
diff --git a/tests/common/editor_harness.rs b/tests/common/editor_harness.rs
index cfdc7d3..8c8fb0f 100644
--- a/tests/common/editor_harness.rs
+++ b/tests/common/editor_harness.rs
@@ -154,6 +154,10 @@ impl EditorHarness {
     pub fn buffer_line(&self) -> usize {
         self.editor.test_buffer_line()
     }
+
+    pub fn active_window_id(&self) -> usize {
+        self.editor.test_active_window_id()
+    }
 }
 
 /// Test builder for setting up complex editor scenarios
@@ -250,4 +254,26 @@ mod tests {
             .unwrap();
         harness.assert_mode(Mode::Normal);
     }
+
+    #[tokio::test]
+    async fn test_window_switch_preserves_cursor_state() {
+        let mut harness = EditorHarness::with_content("Line 1\nLine 2\nLine 3");
+
+        harness.execute_action(Action::MoveDown).await.unwrap();
+        harness.execute_action(Action::SplitVertical).await.unwrap();
+        assert_eq!(harness.active_window_id(), 1);
+
+        harness.execute_action(Action::MoveDown).await.unwrap();
+        harness.execute_action(Action::MoveDown).await.unwrap();
+        harness
+            .execute_action(Action::PreviousWindow)
+            .await
+            .unwrap();
+        assert_eq!(harness.active_window_id(), 0);
+        harness.assert_cursor_at(0, 1);
+
+        harness.execute_action(Action::NextWindow).await.unwrap();
+        assert_eq!(harness.active_window_id(), 1);
+        harness.assert_cursor_at(0, 2);
+    }
 }

From d459f8989c0a00157dd96e14b36d476e21111329 Mon Sep 17 00:00:00 2001
From: Felipe Coury <felipe.coury@gmail.com>
Date: Fri, 8 May 2026 01:19:49 -0300
Subject: [PATCH 03/37] fix(tui): use window buffer line for cursor render

Extract cursor terminal-position calculation so it can be tested without terminal output.

Use the active window buffer line directly when computing display columns, avoiding double application of `vtop` after scrolling.
---
 src/editor.rs                  |  5 +++++
 src/editor/rendering.rs        | 38 +++++++++++++++++++---------------
 tests/common/editor_harness.rs | 25 ++++++++++++++++++++++
 3 files changed, 51 insertions(+), 17 deletions(-)

diff --git a/src/editor.rs b/src/editor.rs
index 7ea7beb..be22881 100644
--- a/src/editor.rs
+++ b/src/editor.rs
@@ -4196,6 +4196,11 @@ impl Editor {
         self.window_manager.active_window_id()
     }
 
+    #[doc(hidden)]
+    pub fn test_render_cursor_position(&self) -> Option<(usize, usize)> {
+        self.render_cursor_position()
+    }
+
     #[doc(hidden)]
     pub fn test_current_line_contents(&self) -> Option<String> {
         self.current_line_contents()
diff --git a/src/editor/rendering.rs b/src/editor/rendering.rs
index d1c7b34..6e6628f 100644
--- a/src/editor/rendering.rs
+++ b/src/editor/rendering.rs
@@ -1170,9 +1170,19 @@ impl Editor {
 
         self.set_cursor_style()?;
 
-        // TODO: refactor this out to allow for dynamic setting of the cursor "target",
-        // so we could transition from the editor to dialogs, to searches, etc.
-        let cursor_pos = if let Some(current_dialog) = &self.current_dialog {
+        let cursor_pos = self.render_cursor_position();
+
+        if let Some((x, y)) = cursor_pos {
+            self.stdout.queue(cursor::MoveTo(x as u16, y as u16))?;
+        } else {
+            self.stdout.queue(cursor::Hide)?;
+        }
+
+        Ok(())
+    }
+
+    pub(crate) fn render_cursor_position(&self) -> Option<(usize, usize)> {
+        if let Some(current_dialog) = &self.current_dialog {
             current_dialog.cursor_position()
         } else if self.has_term() {
             Some((self.term().len() + 1, (self.size.1 - 1) as usize))
@@ -1182,14 +1192,16 @@ impl Editor {
                 // Use window's cursor position
                 let window_cy = window.cy;
                 let window_cx = window.cx;
+                let buffer_y = window.vtop + window_cy;
 
                 // Calculate the actual display column for the cursor
-                let display_col = if let Some(line) = self.viewport_line(window.vtop + window_cy) {
-                    let line = line.trim_end_matches('\n');
-                    crate::unicode_utils::grapheme_to_column(line, window_cx)
-                } else {
-                    window_cx
-                };
+                let display_col =
+                    if let Some(line) = self.buffers[window.buffer_index].get(buffer_y) {
+                        let line = line.trim_end_matches('\n');
+                        crate::unicode_utils::grapheme_to_column(line, window_cx)
+                    } else {
+                        window_cx
+                    };
 
                 // Convert to terminal coordinates based on active window
                 let term_x = window.position.x + self.gutter_width() + 1 + display_col;
@@ -1206,15 +1218,7 @@ impl Editor {
                 };
                 Some(((self.vx + display_col), self.cy))
             }
-        };
-
-        if let Some((x, y)) = cursor_pos {
-            self.stdout.queue(cursor::MoveTo(x as u16, y as u16))?;
-        } else {
-            self.stdout.queue(cursor::Hide)?;
         }
-
-        Ok(())
     }
 
     fn set_cursor_style(&mut self) -> anyhow::Result<()> {
diff --git a/tests/common/editor_harness.rs b/tests/common/editor_harness.rs
index 8c8fb0f..e7c5838 100644
--- a/tests/common/editor_harness.rs
+++ b/tests/common/editor_harness.rs
@@ -158,6 +158,10 @@ impl EditorHarness {
     pub fn active_window_id(&self) -> usize {
         self.editor.test_active_window_id()
     }
+
+    pub fn render_cursor_position(&self) -> Option<(usize, usize)> {
+        self.editor.test_render_cursor_position()
+    }
 }
 
 /// Test builder for setting up complex editor scenarios
@@ -276,4 +280,25 @@ mod tests {
         assert_eq!(harness.active_window_id(), 1);
         harness.assert_cursor_at(0, 2);
     }
+
+    #[tokio::test]
+    async fn test_render_cursor_uses_active_window_buffer_line() {
+        let content = (0..30)
+            .map(|line| match line {
+                22 => "a".to_string(),
+                23 => "👋".to_string(),
+                _ => "x".to_string(),
+            })
+            .collect::<Vec<_>>()
+            .join("\n");
+        let mut harness = EditorHarness::with_content(&content);
+
+        for _ in 0..22 {
+            harness.execute_action(Action::MoveDown).await.unwrap();
+        }
+        harness.execute_action(Action::MoveRight).await.unwrap();
+
+        assert_eq!(harness.buffer_line(), 22);
+        assert_eq!(harness.render_cursor_position(), Some((5, 21)));
+    }
 }

From d968bfe5f237adb866a99ccf22ec9d44812c100c Mon Sep 17 00:00:00 2001
From: Felipe Coury <felipe.coury@gmail.com>
Date: Fri, 8 May 2026 01:22:46 -0300
Subject: [PATCH 04/37] fix(tui): align overlays with rendered cursor

Use the same terminal cursor position for overlay avoid-cursor placement that rendering uses for the actual cursor.

Mark overlays dirty when recalculated placement changes so cursor-driven overlays redraw after moving across screen regions.
---
 src/editor/rendering.rs |  7 +-----
 src/plugin/overlay.rs   | 51 +++++++++++++++++++++++++++++++++++++++++
 2 files changed, 52 insertions(+), 6 deletions(-)

diff --git a/src/editor/rendering.rs b/src/editor/rendering.rs
index 6e6628f..3d5794e 100644
--- a/src/editor/rendering.rs
+++ b/src/editor/rendering.rs
@@ -480,12 +480,7 @@ impl Editor {
     }
 
     fn update_and_render_overlays(&mut self, buffer: &mut RenderBuffer) -> anyhow::Result<()> {
-        // Get current cursor position for avoid_cursor alignment
-        let cursor_pos = if self.current_dialog.is_none() {
-            Some(Point::new(self.cx + self.gutter_width() + 1, self.cy))
-        } else {
-            None
-        };
+        let cursor_pos = self.render_cursor_position().map(|(x, y)| Point::new(x, y));
 
         // Update positions for all overlays
         self.overlay_manager.update_positions(
diff --git a/src/plugin/overlay.rs b/src/plugin/overlay.rs
index 4833c44..71f2efd 100644
--- a/src/plugin/overlay.rs
+++ b/src/plugin/overlay.rs
@@ -119,6 +119,9 @@ impl PluginOverlay {
         };
 
         let position = Point::new(x, y);
+        if self.position != Some(position) {
+            self.content.dirty = true;
+        }
         self.position = Some(position);
         position
     }
@@ -223,3 +226,51 @@ impl OverlayManager {
         }
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use crate::{
+        editor::Point,
+        plugin::{OverlayAlignment, OverlayConfig},
+        theme::Style,
+    };
+
+    use super::PluginOverlay;
+
+    #[test]
+    fn avoid_cursor_overlay_marks_dirty_when_position_changes() {
+        let mut overlay = PluginOverlay::new(
+            "completion".to_string(),
+            OverlayConfig {
+                align: OverlayAlignment::AvoidCursor,
+                ..OverlayConfig::default()
+            },
+        );
+        overlay.update_content(vec![("item".to_string(), Style::default())]);
+
+        overlay.calculate_position(80, 24, Some(Point::new(5, 2)));
+        overlay.mark_clean();
+        assert!(!overlay.is_dirty());
+
+        overlay.calculate_position(80, 24, Some(Point::new(5, 20)));
+        assert!(overlay.is_dirty());
+    }
+
+    #[test]
+    fn avoid_cursor_overlay_stays_clean_when_position_is_unchanged() {
+        let mut overlay = PluginOverlay::new(
+            "completion".to_string(),
+            OverlayConfig {
+                align: OverlayAlignment::AvoidCursor,
+                ..OverlayConfig::default()
+            },
+        );
+        overlay.update_content(vec![("item".to_string(), Style::default())]);
+
+        overlay.calculate_position(80, 24, Some(Point::new(5, 2)));
+        overlay.mark_clean();
+        overlay.calculate_position(80, 24, Some(Point::new(6, 3)));
+
+        assert!(!overlay.is_dirty());
+    }
+}

From 7792f06bf333db9666543c7165def557a26196e5 Mon Sep 17 00:00:00 2001
From: Felipe Coury <felipe.coury@gmail.com>
Date: Fri, 8 May 2026 01:24:23 -0300
Subject: [PATCH 05/37] fix(tui): make render buffer display-width aware

Treat render-buffer text writes as terminal cell writes so wide characters reserve their continuation cell.

Tighten boundary checks to ignore `x == width` and `y == height` writes instead of allowing them to spill into later cells.
---
 src/editor.rs               | 23 +++++++++++++++++
 src/editor/render_buffer.rs | 50 +++++++++++++++++++++++++++++--------
 2 files changed, 63 insertions(+), 10 deletions(-)

diff --git a/src/editor.rs b/src/editor.rs
index be22881..6547ace 100644
--- a/src/editor.rs
+++ b/src/editor.rs
@@ -4303,6 +4303,29 @@ mod test {
         assert_eq!(diffs.len(), 5);
     }
 
+    #[test]
+    fn test_render_buffer_set_text_uses_display_width() {
+        let mut buffer = RenderBuffer::new(5, 1, &Style::default());
+
+        buffer.set_text(0, 0, "a👋b", &Style::default());
+
+        let rendered = buffer.cells.iter().map(|cell| cell.c).collect::<String>();
+        assert_eq!(rendered, "a👋 b ");
+    }
+
+    #[test]
+    fn test_render_buffer_ignores_width_boundary_writes() {
+        let mut buffer = RenderBuffer::new(2, 2, &Style::default());
+        let unchanged = buffer.cells.clone();
+        let theme = Theme::default();
+
+        buffer.set_char(2, 0, 'x', &Style::default(), &theme);
+        buffer.set_text(2, 0, "x", &Style::default());
+        buffer._set_char(2, 0, 'x', &Style::default());
+
+        assert_eq!(buffer.cells, unchanged);
+    }
+
     //     #[test]
     //     fn test_set_char() {
     //         let mut buffer = RenderBuffer::new(10, 10, Style::default());
diff --git a/src/editor/render_buffer.rs b/src/editor/render_buffer.rs
index d19f571..ea02f3c 100644
--- a/src/editor/render_buffer.rs
+++ b/src/editor/render_buffer.rs
@@ -2,6 +2,7 @@ use crate::{
     color::{blend_color, Color},
     log,
     theme::{Style, Theme},
+    unicode_utils::{char_display_width, display_width},
 };
 
 use super::Point;
@@ -59,7 +60,7 @@ impl RenderBuffer {
                     style: style.clone(),
                 });
             }
-            for _ in 0..width.saturating_sub(line.len()) {
+            for _ in 0..width.saturating_sub(display_width(&line)) {
                 cells.push(Cell {
                     c: ' ',
                     style: style.clone(),
@@ -103,7 +104,7 @@ impl RenderBuffer {
     }
 
     pub fn _set_char(&mut self, x: usize, y: usize, c: char, style: &Style) {
-        if x > self.width || y > self.height {
+        if x >= self.width || y >= self.height {
             return;
         }
         let pos = (y * self.width) + x;
@@ -131,7 +132,7 @@ impl RenderBuffer {
     }
 
     pub fn set_bg(&mut self, x: usize, y: usize, bg: &Color, theme: &Theme) {
-        if x > self.width || y > self.height {
+        if x >= self.width || y >= self.height {
             return;
         }
         let pos = (y * self.width) + x;
@@ -157,7 +158,7 @@ impl RenderBuffer {
     }
 
     pub fn set_char(&mut self, x: usize, y: usize, c: char, style: &Style, theme: &Theme) {
-        if x > self.width || y > self.height {
+        if x >= self.width || y >= self.height {
             return;
         }
         let pos = (y * self.width) + x;
@@ -198,19 +199,48 @@ impl RenderBuffer {
     }
 
     pub fn set_text(&mut self, x: usize, y: usize, text: &str, style: &Style) {
-        let pos = (y * self.width) + x;
-        for (i, c) in text.chars().enumerate() {
-            if x + i >= self.width {
+        if x >= self.width || y >= self.height {
+            return;
+        }
+
+        let mut cell_x = x;
+        for c in text.chars() {
+            if cell_x >= self.width {
                 break;
             }
-            if pos + i >= self.cells.len() {
-                log!("WARN: pos + i >= self.cells.len()");
+
+            let char_width = char_display_width(c);
+            if char_width == 0 {
+                continue;
+            }
+
+            let pos = (y * self.width) + cell_x;
+            if pos >= self.cells.len() {
+                log!("WARN: pos >= self.cells.len()");
                 break;
             }
-            self.cells[pos + i] = Cell {
+            self.cells[pos] = Cell {
                 c,
                 style: style.clone(),
+            };
+
+            for offset in 1..char_width {
+                let pad_x = cell_x + offset;
+                if pad_x >= self.width {
+                    break;
+                }
+                let pad_pos = (y * self.width) + pad_x;
+                if pad_pos >= self.cells.len() {
+                    log!("WARN: pad_pos >= self.cells.len()");
+                    break;
+                }
+                self.cells[pad_pos] = Cell {
+                    c: ' ',
+                    style: style.clone(),
+                };
             }
+
+            cell_x += char_width;
         }
     }
 

From c6d4026f814a2973259f3ee4c2fe43cd36966c49 Mon Sep 17 00:00:00 2001
From: Felipe Coury <felipe.coury@gmail.com>
Date: Fri, 8 May 2026 01:26:01 -0300
Subject: [PATCH 06/37] fix(tui): size overlays by display width

Measure plugin overlay width and right alignment in terminal display columns so wide characters align correctly.

Clear the full overlay area before rendering each row to prevent stale cells when content shrinks or shifts.
---
 src/plugin/overlay.rs | 54 ++++++++++++++++++++++++++++++++++++-------
 1 file changed, 46 insertions(+), 8 deletions(-)

diff --git a/src/plugin/overlay.rs b/src/plugin/overlay.rs
index 71f2efd..948b865 100644
--- a/src/plugin/overlay.rs
+++ b/src/plugin/overlay.rs
@@ -3,6 +3,7 @@ use std::collections::HashMap;
 use crate::{
     editor::{render_buffer::RenderBuffer, Point},
     theme::Style,
+    unicode_utils::display_width,
 };
 
 #[derive(Debug, Clone)]
@@ -72,7 +73,7 @@ impl PluginOverlay {
             .content
             .lines
             .iter()
-            .map(|(text, _)| text.chars().count()) // Use chars().count() for proper Unicode handling
+            .map(|(text, _)| display_width(text))
             .max()
             .unwrap_or(0);
     }
@@ -137,13 +138,12 @@ impl PluginOverlay {
                     // 2. Render the text right-aligned
 
                     // Calculate the actual text position for right alignment
-                    let text_len = text.chars().count();
-                    let text_x = pos.x + self.width.saturating_sub(text_len);
+                    let text_width = display_width(text);
+                    let text_x = pos.x + self.width.saturating_sub(text_width);
 
-                    // Clear only the area we'll use for the text
-                    let clear_width = text_len.min(self.width);
-                    let clear_text = " ".repeat(clear_width);
-                    buffer.set_text(text_x, y, &clear_text, style);
+                    // Clear the full overlay area before right-aligning text.
+                    let clear_text = " ".repeat(self.width);
+                    buffer.set_text(pos.x, y, &clear_text, style);
 
                     // Then render the actual text
                     buffer.set_text(text_x, y, text, style);
@@ -230,7 +230,7 @@ impl OverlayManager {
 #[cfg(test)]
 mod tests {
     use crate::{
-        editor::Point,
+        editor::{render_buffer::RenderBuffer, Point},
         plugin::{OverlayAlignment, OverlayConfig},
         theme::Style,
     };
@@ -273,4 +273,42 @@ mod tests {
 
         assert!(!overlay.is_dirty());
     }
+
+    #[test]
+    fn overlay_width_uses_display_columns() {
+        let mut overlay = PluginOverlay::new("completion".to_string(), OverlayConfig::default());
+
+        overlay.update_content(vec![("a👋".to_string(), Style::default())]);
+
+        assert_eq!(overlay.width, 3);
+    }
+
+    #[test]
+    fn overlay_render_right_aligns_by_display_width() {
+        let mut overlay = PluginOverlay::new(
+            "completion".to_string(),
+            OverlayConfig {
+                align: OverlayAlignment::Top,
+                ..OverlayConfig::default()
+            },
+        );
+        overlay.update_content(vec![
+            ("long".to_string(), Style::default()),
+            ("👋".to_string(), Style::default()),
+        ]);
+        overlay.calculate_position(8, 6, None);
+
+        let mut buffer = RenderBuffer::new(8, 6, &Style::default());
+        overlay.render(&mut buffer);
+
+        let row = |y: usize| {
+            buffer.cells[y * buffer.width..(y + 1) * buffer.width]
+                .iter()
+                .map(|cell| cell.c)
+                .collect::<String>()
+        };
+
+        assert_eq!(row(0), "   long ");
+        assert_eq!(row(1), "     👋  ");
+    }
 }

From 298a7964040bb604d4784c658da63d67aeebd11e Mon Sep 17 00:00:00 2001
From: Felipe Coury <felipe.coury@gmail.com>
Date: Fri, 8 May 2026 01:28:34 -0300
Subject: [PATCH 07/37] fix(tui): make commandline unicode safe

Use character-aware deletion for command and search backspace instead of byte slicing.

Clear the command line before rendering prompt text so Unicode search input and narrow terminal widths do not leave stale cells or underflow padding.
---
 src/editor.rs                  | 52 +++++++++++++++++++++++++++-------
 src/editor/rendering.rs        | 18 ++++--------
 tests/common/editor_harness.rs | 17 +++++++++++
 3 files changed, 64 insertions(+), 23 deletions(-)

diff --git a/src/editor.rs b/src/editor.rs
index 6547ace..1de766e 100644
--- a/src/editor.rs
+++ b/src/editor.rs
@@ -1833,6 +1833,10 @@ impl Editor {
         actions
     }
 
+    fn delete_last_char(text: &mut String) {
+        text.pop();
+    }
+
     fn handle_command_event(&mut self, ev: &event::Event) -> Option<KeyAction> {
         if let Event::Key(ref event) = ev {
             let code = event.code;
@@ -1844,11 +1848,7 @@ impl Editor {
                     return Some(KeyAction::Single(Action::EnterMode(Mode::Normal)));
                 }
                 KeyCode::Backspace => {
-                    if self.command.len() < 2 {
-                        self.command = String::new();
-                    } else {
-                        self.command = self.command[..self.command.len() - 1].to_string();
-                    }
+                    Self::delete_last_char(&mut self.command);
                 }
                 KeyCode::Enter => {
                     if self.command.trim().is_empty() {
@@ -1882,12 +1882,7 @@ impl Editor {
                         return Some(KeyAction::Single(Action::EnterMode(Mode::Normal)));
                     }
                     KeyCode::Backspace => {
-                        if self.search_term.len() < 2 {
-                            self.search_term = String::new();
-                        } else {
-                            self.search_term =
-                                self.search_term[..self.search_term.len() - 1].to_string();
-                        }
+                        Self::delete_last_char(&mut self.search_term);
                     }
                     KeyCode::Enter => {
                         return Some(KeyAction::Multiple(vec![
@@ -4201,6 +4196,32 @@ impl Editor {
         self.render_cursor_position()
     }
 
+    #[doc(hidden)]
+    pub fn test_set_commandline(&mut self, mode: Mode, text: &str) {
+        self.mode = mode;
+        match mode {
+            Mode::Command => self.command = text.to_string(),
+            Mode::Search => self.search_term = text.to_string(),
+            _ => {}
+        }
+    }
+
+    #[doc(hidden)]
+    pub fn test_commandline_row(&mut self) -> String {
+        let mut render_buffer = RenderBuffer::new(
+            self.size.0 as usize,
+            self.size.1 as usize,
+            &Style::default(),
+        );
+        self.draw_commandline(&mut render_buffer);
+
+        let y = self.size.1 as usize - 1;
+        render_buffer.cells[y * render_buffer.width..(y + 1) * render_buffer.width]
+            .iter()
+            .map(|cell| cell.c)
+            .collect()
+    }
+
     #[doc(hidden)]
     pub fn test_current_line_contents(&self) -> Option<String> {
         self.current_line_contents()
@@ -4326,6 +4347,15 @@ mod test {
         assert_eq!(buffer.cells, unchanged);
     }
 
+    #[test]
+    fn test_delete_last_char_handles_multibyte_text() {
+        let mut text = "ab👋".to_string();
+
+        Editor::delete_last_char(&mut text);
+
+        assert_eq!(text, "ab");
+    }
+
     //     #[test]
     //     fn test_set_char() {
     //         let mut buffer = RenderBuffer::new(10, 10, Style::default());
diff --git a/src/editor/rendering.rs b/src/editor/rendering.rs
index 3d5794e..9f46740 100644
--- a/src/editor/rendering.rs
+++ b/src/editor/rendering.rs
@@ -1073,6 +1073,9 @@ impl Editor {
     pub fn draw_commandline(&mut self, buffer: &mut RenderBuffer) {
         let style = &self.theme.style;
         let y = self.size.1 as usize - 1;
+        let width = self.size.0 as usize;
+        let clear_line = " ".repeat(width);
+        buffer.set_text(0, y, &clear_line, style);
 
         if !self.has_term() {
             let wc = if let Some(ref waiting_command) = self.waiting_command {
@@ -1085,14 +1088,10 @@ impl Editor {
             let wc = format!("{:<width$}", wc, width = 10);
 
             if let Some(ref last_error) = self.last_error {
-                let error = format!("{:width$}", last_error, width = self.size.0 as usize);
-                buffer.set_text(0, self.size.1 as usize - 1, &error, style);
-            } else {
-                let clear_line = " ".repeat(self.size.0 as usize - 10);
-                buffer.set_text(0, y, &clear_line, style);
+                buffer.set_text(0, y, last_error, style);
             }
 
-            buffer.set_text(self.size.0 as usize - 10, y, &wc, style);
+            buffer.set_text(width.saturating_sub(10), y, &wc, style);
 
             return;
         }
@@ -1103,12 +1102,7 @@ impl Editor {
             &self.search_term
         };
         let prefix = if self.is_command() { ":" } else { "/" };
-        let cmdline = format!(
-            "{}{:width$}",
-            prefix,
-            text,
-            width = self.size.0 as usize - self.command.len() - 1
-        );
+        let cmdline = format!("{}{}", prefix, text);
         buffer.set_text(0, self.size.1 as usize - 1, &cmdline, style);
     }
 
diff --git a/tests/common/editor_harness.rs b/tests/common/editor_harness.rs
index e7c5838..9db97d0 100644
--- a/tests/common/editor_harness.rs
+++ b/tests/common/editor_harness.rs
@@ -162,6 +162,14 @@ impl EditorHarness {
     pub fn render_cursor_position(&self) -> Option<(usize, usize)> {
         self.editor.test_render_cursor_position()
     }
+
+    pub fn set_commandline(&mut self, mode: Mode, text: &str) {
+        self.editor.test_set_commandline(mode, text);
+    }
+
+    pub fn commandline_row(&mut self) -> String {
+        self.editor.test_commandline_row()
+    }
 }
 
 /// Test builder for setting up complex editor scenarios
@@ -301,4 +309,13 @@ mod tests {
         assert_eq!(harness.buffer_line(), 22);
         assert_eq!(harness.render_cursor_position(), Some((5, 21)));
     }
+
+    #[test]
+    fn test_search_commandline_renders_search_text_on_small_width() {
+        let mut harness = EditorHarness::new();
+        harness.editor.test_set_size(8, 4);
+        harness.set_commandline(Mode::Search, "👋x");
+
+        assert_eq!(harness.commandline_row(), "/👋 x    ");
+    }
 }

From 8e70e79f20835a4b54e777f94860d8bcb4ad5898 Mon Sep 17 00:00:00 2001
From: Felipe Coury <felipe.coury@gmail.com>
Date: Fri, 8 May 2026 01:30:49 -0300
Subject: [PATCH 08/37] fix(tui): make statusline width calculations safe

Use display-width-aware, saturating layout math for statusline segments so
narrow terminals do not underflow while computing file and position areas.

Clear the row before writing statusline segments to avoid stale cells when
segments shrink or overlap.
---
 src/editor.rs                  | 16 ++++++++
 src/editor/rendering.rs        | 68 +++++++++++++++++++++-------------
 tests/common/editor_harness.rs | 12 ++++++
 3 files changed, 70 insertions(+), 26 deletions(-)

diff --git a/src/editor.rs b/src/editor.rs
index 1de766e..68b55b2 100644
--- a/src/editor.rs
+++ b/src/editor.rs
@@ -4222,6 +4222,22 @@ impl Editor {
             .collect()
     }
 
+    #[doc(hidden)]
+    pub fn test_statusline_row(&mut self) -> String {
+        let mut render_buffer = RenderBuffer::new(
+            self.size.0 as usize,
+            self.size.1 as usize,
+            &Style::default(),
+        );
+        self.draw_statusline(&mut render_buffer);
+
+        let y = self.size.1 as usize - 2;
+        render_buffer.cells[y * render_buffer.width..(y + 1) * render_buffer.width]
+            .iter()
+            .map(|cell| cell.c)
+            .collect()
+    }
+
     #[doc(hidden)]
     pub fn test_current_line_contents(&self) -> Option<String> {
         self.current_line_contents()
diff --git a/src/editor/rendering.rs b/src/editor/rendering.rs
index 9f46740..33bfb8d 100644
--- a/src/editor/rendering.rs
+++ b/src/editor/rendering.rs
@@ -1029,8 +1029,7 @@ impl Editor {
             (file, pos, String::new())
         };
 
-        let file_width =
-            self.size.0 - mode.len() as u16 - pos.len() as u16 - window_indicator.len() as u16 - 2;
+        let term_width = self.size.0 as usize;
         let y = self.size.1 as usize - 2;
 
         let transition_style = Style {
@@ -1039,35 +1038,52 @@ impl Editor {
             ..Default::default()
         };
 
+        let clear_line = " ".repeat(term_width);
+        buffer.set_text(0, y, &clear_line, &self.theme.statusline_style.inner_style);
+
+        let left_transition = self.theme.statusline_style.outer_chars[1].to_string();
+        let right_transition = self.theme.statusline_style.outer_chars[2].to_string();
+        let position = format!("{}{}", pos, window_indicator);
+
+        let mode_width = display_width(&mode);
+        let left_transition_width = display_width(&left_transition);
+        let right_transition_width = display_width(&right_transition);
+        let position_width = display_width(&position);
+        let position_start = term_width.saturating_sub(position_width);
+        let right_transition_start = position_start.saturating_sub(right_transition_width);
+        let file_start = mode_width + left_transition_width;
+        let file_width = right_transition_start.saturating_sub(file_start);
+
         buffer.set_text(0, y, &mode, &self.theme.statusline_style.outer_style);
 
-        buffer.set_text(
-            mode.len(),
-            y,
-            &self.theme.statusline_style.outer_chars[1].to_string(),
-            &transition_style,
-        );
+        buffer.set_text(mode_width, y, &left_transition, &transition_style);
 
-        buffer.set_text(
-            mode.len() + 1,
-            y,
-            &format!("{:<width$}", file, width = file_width as usize),
-            &self.theme.statusline_style.inner_style,
-        );
+        if file_width > 0 {
+            buffer.set_text(
+                file_start,
+                y,
+                &format!("{:<width$}", file, width = file_width),
+                &self.theme.statusline_style.inner_style,
+            );
+        }
 
-        buffer.set_text(
-            mode.len() + 1 + file_width as usize,
-            y,
-            &self.theme.statusline_style.outer_chars[2].to_string(),
-            &transition_style,
-        );
+        if right_transition_start < term_width {
+            buffer.set_text(
+                right_transition_start,
+                y,
+                &right_transition,
+                &transition_style,
+            );
+        }
 
-        buffer.set_text(
-            mode.len() + 2 + file_width as usize,
-            y,
-            &format!("{}{}", pos, window_indicator),
-            &self.theme.statusline_style.outer_style,
-        );
+        if position_start < term_width {
+            buffer.set_text(
+                position_start,
+                y,
+                &position,
+                &self.theme.statusline_style.outer_style,
+            );
+        }
     }
 
     pub fn draw_commandline(&mut self, buffer: &mut RenderBuffer) {
diff --git a/tests/common/editor_harness.rs b/tests/common/editor_harness.rs
index 9db97d0..597a959 100644
--- a/tests/common/editor_harness.rs
+++ b/tests/common/editor_harness.rs
@@ -170,6 +170,10 @@ impl EditorHarness {
     pub fn commandline_row(&mut self) -> String {
         self.editor.test_commandline_row()
     }
+
+    pub fn statusline_row(&mut self) -> String {
+        self.editor.test_statusline_row()
+    }
 }
 
 /// Test builder for setting up complex editor scenarios
@@ -318,4 +322,12 @@ mod tests {
 
         assert_eq!(harness.commandline_row(), "/👋 x    ");
     }
+
+    #[test]
+    fn test_statusline_renders_on_small_width() {
+        let mut harness = EditorHarness::with_content("content");
+        harness.editor.test_set_size(8, 4);
+
+        assert_eq!(harness.statusline_row().chars().count(), 8);
+    }
 }

From 651dea1029b7e73f24f09fb7c25797712deb7623 Mon Sep 17 00:00:00 2001
From: Felipe Coury <felipe.coury@gmail.com>
Date: Fri, 8 May 2026 01:33:07 -0300
Subject: [PATCH 09/37] fix(tui): render completion rows by display width

Measure completion labels, icons, details, and documentation with terminal
display widths so popup rows stay aligned for emoji and CJK text.

Add shared helpers for fitting strings to display columns without splitting
grapheme clusters during truncation.
---
 src/ui/completion.rs | 112 ++++++++++++++++++++++++++++++++++++-------
 src/unicode_utils.rs |  33 +++++++++++++
 2 files changed, 128 insertions(+), 17 deletions(-)

diff --git a/src/ui/completion.rs b/src/ui/completion.rs
index 6d7d57e..1958932 100644
--- a/src/ui/completion.rs
+++ b/src/ui/completion.rs
@@ -8,6 +8,7 @@ use crate::{
     editor::{Action, RenderBuffer},
     log,
     lsp::types::{CompletionItemKind, CompletionResponseItem, Documentation, InsertTextFormat},
+    unicode_utils::{display_width, fit_display_width, truncate_display_width},
 };
 
 use super::Component;
@@ -101,8 +102,11 @@ impl CompletionUI {
             .items
             .iter()
             .map(|item| {
-                let kind_str = item.kind.as_ref().map_or(0, |_| 4); // Icon + space
-                item.label.len() + kind_str + 4 // +4 for prefix and padding
+                let kind_width = item
+                    .kind
+                    .as_ref()
+                    .map_or(0, |kind| display_width(Self::kind_to_icon(kind)) + 1);
+                display_width(&item.label) + kind_width + 4 // +4 for prefix and padding
             })
             .max()
             .unwrap_or(20);
@@ -170,6 +174,24 @@ impl CompletionUI {
         }
     }
 
+    fn row(content: &str, width: usize) -> String {
+        format!("│{}│", fit_display_width(content, width.saturating_sub(2)))
+    }
+
+    fn ellipsize(content: &str, width: usize) -> String {
+        if display_width(content) <= width {
+            return fit_display_width(content, width);
+        }
+
+        if width <= 3 {
+            return ".".repeat(width);
+        }
+
+        let mut truncated = truncate_display_width(content, width - 3);
+        truncated.push_str("...");
+        fit_display_width(&truncated, width)
+    }
+
     fn render_completion(&self) -> Vec<(usize, usize, String, Option<Color>)> {
         if !self.visible || self.items.is_empty() {
             return Vec::new();
@@ -201,12 +223,12 @@ impl CompletionUI {
         // Render completion items
         for (idx, item) in visible_items.enumerate() {
             let is_selected = idx + self.scroll_offset == self.selected;
-            let prefix = if is_selected { "│>" } else { "│ " };
+            let prefix = if is_selected { ">" } else { " " };
 
             // Format item with icon and handle deprecated items
             let is_deprecated = item.deprecated.unwrap_or(false);
 
-            let mut display = if let Some(kind) = &item.kind {
+            let display = if let Some(kind) = &item.kind {
                 format!(
                     "{}{} {} {}",
                     prefix,
@@ -223,19 +245,12 @@ impl CompletionUI {
                 )
             };
 
-            // Pad or truncate to fit width
-            if display.len() > self.width - 2 {
-                display.truncate(self.width - 5);
-                display.push_str("...");
-            } else {
-                display.push_str(&" ".repeat(self.width - display.len() - 1));
-            }
-            display.push('│');
+            let display = Self::ellipsize(&display, self.width.saturating_sub(2));
 
             output.push((
                 self.x,
                 self.y + y_offset,
-                display,
+                format!("│{display}│"),
                 if is_deprecated {
                     Some(DEPRECATED_COLOR)
                 } else if is_selected {
@@ -249,11 +264,10 @@ impl CompletionUI {
             // Show detail and documentation for selected item
             if is_selected {
                 if let Some(detail) = &item.detail {
-                    let detail_text = format!("│  {}", detail);
                     output.push((
                         self.x,
                         self.y + y_offset,
-                        format!("{:<width$}│", detail_text, width = self.width - 1),
+                        Self::row(&format!("  {}", detail), self.width),
                         Some(COMMENT_COLOR),
                     ));
                     y_offset += 1;
@@ -272,7 +286,7 @@ impl CompletionUI {
                     output.push((
                         self.x,
                         self.y + y_offset,
-                        format!("{:<width$}│", commit_text, width = self.width - 1),
+                        Self::row(&commit_text, self.width),
                         Some(COMMENT_COLOR),
                     ));
                     y_offset += 1;
@@ -298,7 +312,7 @@ impl CompletionUI {
                         output.push((
                             self.x,
                             self.y + y_offset,
-                            format!("│  {:<width$}│", line, width = self.width - 4),
+                            Self::row(&format!("  {}", line), self.width),
                             Some(COMMENT_COLOR),
                         ));
                         y_offset += 1;
@@ -429,3 +443,67 @@ impl Component for CompletionUI {
         }
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::unicode_utils::display_width;
+
+    fn item(label: &str, kind: Option<CompletionItemKind>) -> CompletionResponseItem {
+        CompletionResponseItem {
+            label: label.to_string(),
+            kind,
+            detail: None,
+            documentation: None,
+            deprecated: None,
+            preselect: None,
+            sort_text: None,
+            filter_text: None,
+            insert_text: None,
+            insert_text_format: None,
+            text_edit: None,
+            additional_text_edits: None,
+            command: None,
+            data: None,
+            commit_characters: None,
+        }
+    }
+
+    #[test]
+    fn completion_rows_fit_display_width_with_wide_labels() {
+        let mut ui = CompletionUI::new();
+        ui.show(
+            vec![item(
+                "function_with_emoji_👋_and_cjk_世界_that_must_truncate",
+                Some(CompletionItemKind::Function),
+            )],
+            0,
+            0,
+        );
+
+        let rows = ui.render_completion();
+
+        for (_, _, row, _) in rows {
+            assert_eq!(display_width(&row), ui.width);
+            assert!(row.is_char_boundary(row.len()));
+        }
+    }
+
+    #[test]
+    fn completion_rows_pad_detail_by_display_width() {
+        let mut completion = item("hello", Some(CompletionItemKind::Text));
+        completion.detail = Some("returns 👋 世界".to_string());
+
+        let mut ui = CompletionUI::new();
+        ui.show(vec![completion], 0, 0);
+
+        let rows = ui.render_completion();
+
+        assert!(rows
+            .iter()
+            .any(|(_, _, row, _)| row.contains("returns 👋 世界")));
+        for (_, _, row, _) in rows {
+            assert_eq!(display_width(&row), ui.width);
+        }
+    }
+}
diff --git a/src/unicode_utils.rs b/src/unicode_utils.rs
index b9b29d0..78dfd76 100644
--- a/src/unicode_utils.rs
+++ b/src/unicode_utils.rs
@@ -93,6 +93,31 @@ pub fn truncate_chars(line: &str, max_chars: usize) -> &str {
     char_prefix(line, max_chars)
 }
 
+/// Truncate a string to at most `max_width` terminal display columns.
+pub fn truncate_display_width(s: &str, max_width: usize) -> String {
+    let mut width = 0;
+    let mut result = String::new();
+
+    for grapheme in s.graphemes(true) {
+        let grapheme_width = display_width(grapheme);
+        if width + grapheme_width > max_width {
+            break;
+        }
+
+        result.push_str(grapheme);
+        width += grapheme_width;
+    }
+
+    result
+}
+
+/// Pad or truncate a string so it occupies exactly `width` display columns.
+pub fn fit_display_width(s: &str, width: usize) -> String {
+    let mut result = truncate_display_width(s, width);
+    result.push_str(&" ".repeat(width.saturating_sub(display_width(&result))));
+    result
+}
+
 /// Convert a byte offset to a character index
 pub fn byte_to_char(line: &str, byte_offset: usize) -> usize {
     let byte_offset = byte_offset.min(line.len());
@@ -207,6 +232,14 @@ mod tests {
         assert_eq!(display_width(""), 0);
     }
 
+    #[test]
+    fn test_fit_display_width() {
+        assert_eq!(fit_display_width("a👋b", 4), "a👋b");
+        assert_eq!(fit_display_width("a👋b", 3), "a👋");
+        assert_eq!(fit_display_width("a👋b", 5), "a👋b ");
+        assert_eq!(fit_display_width("👨‍👩‍👧‍👦x", 2), "👨‍👩‍👧‍👦");
+    }
+
     #[test]
     fn test_char_display_width() {
         assert_eq!(char_display_width('a'), 1);

From 4c345abc1f209ceeca9680906ffe8df4e1f35d42 Mon Sep 17 00:00:00 2001
From: Felipe Coury <felipe.coury@gmail.com>
Date: Fri, 8 May 2026 01:35:11 -0300
Subject: [PATCH 10/37] fix(tui): harden picker list navigation

Keep picker lists safe when filtering leaves no matches, and make list row
truncation use terminal display widths for wide Unicode labels.

Use character-aware backspace and display-width cursor math for picker search
text so non-ASCII search terms do not panic or misplace the cursor.
---
 src/ui/list.rs   | 66 +++++++++++++++++++++++++++++++++++-------------
 src/ui/picker.rs |  9 +++----
 2 files changed, 52 insertions(+), 23 deletions(-)

diff --git a/src/ui/list.rs b/src/ui/list.rs
index 5510560..5ffaa00 100644
--- a/src/ui/list.rs
+++ b/src/ui/list.rs
@@ -1,4 +1,8 @@
-use crate::{editor::RenderBuffer, theme::Style};
+use crate::{
+    editor::RenderBuffer,
+    theme::Style,
+    unicode_utils::{display_width, fit_display_width, truncate_display_width},
+};
 
 use super::Component;
 
@@ -39,13 +43,13 @@ impl List {
     }
 
     pub fn move_down(&mut self) {
-        self.selected_item += 1;
-        if self.selected_item > self.items.len() - 1 {
-            self.selected_item = self.items.len() - 1;
+        if self.items.is_empty() {
             return;
         }
-        if self.top_index + self.selected_item > self.height - 1 {
-            self.top_index += 1;
+
+        self.selected_item = (self.selected_item + 1).min(self.items.len() - 1);
+        if self.height > 0 && self.selected_item >= self.top_index + self.height {
+            self.top_index = self.selected_item.saturating_sub(self.height - 1);
         }
     }
 
@@ -57,13 +61,16 @@ impl List {
     }
 
     pub fn selected_item(&self) -> String {
-        self.items[self.selected_item].clone()
+        self.items
+            .get(self.selected_item)
+            .cloned()
+            .unwrap_or_default()
     }
 
     pub fn set_items(&mut self, new_items: Vec<String>) {
         self.selected_item = 0;
         self.top_index = 0;
-        self.items = new_items;
+        self.items = new_items.iter().map(|s| truncate(s, self.width)).collect();
     }
 
     pub fn items(&self) -> &Vec<String> {
@@ -80,7 +87,7 @@ impl Component for List {
                 } else {
                     &self.item_style
                 };
-                let line = format!(" {:<width$}", item, width = self.width - 1);
+                let line = fit_display_width(&format!(" {item}"), self.width);
                 buffer.set_text(self.x, y, &line, style);
             }
         }
@@ -116,20 +123,16 @@ impl Component for List {
 
 fn truncate(s: &str, max_width: usize) -> String {
     let s = s.trim_start_matches("/");
-    if s.len() <= max_width {
+    if display_width(s) <= max_width {
         return s.to_string();
     }
 
-    let mut result = String::with_capacity(max_width);
-    for (i, c) in s.chars().enumerate() {
-        if i == max_width - 1 {
-            result.push('…');
-            break;
-        }
-
-        result.push(c);
+    if max_width == 0 {
+        return String::new();
     }
 
+    let mut result = truncate_display_width(s, max_width - 1);
+    result.push('…');
     result
 }
 
@@ -141,4 +144,31 @@ mod test {
     fn test_truncate() {
         assert_eq!(truncate("hello world", 5), "hell…");
     }
+
+    #[test]
+    fn test_truncate_uses_display_width() {
+        assert_eq!(truncate("ab👋cd", 5), "ab👋…");
+        assert_eq!(display_width(&truncate("ab👋cd", 5)), 5);
+    }
+
+    #[test]
+    fn test_empty_list_navigation_is_safe() {
+        let style = Style::default();
+        let mut list = List::new(0, 0, 10, 3, vec![], &style, &style);
+
+        list.move_down();
+        list.move_up();
+
+        assert_eq!(list.selected_item(), "");
+    }
+
+    #[test]
+    fn test_set_items_truncates_by_display_width() {
+        let style = Style::default();
+        let mut list = List::new(0, 0, 5, 3, vec![], &style, &style);
+
+        list.set_items(vec!["ab👋cd".to_string()]);
+
+        assert_eq!(display_width(&list.selected_item()), 5);
+    }
 }
diff --git a/src/ui/picker.rs b/src/ui/picker.rs
index b04796e..9d6bbd9 100644
--- a/src/ui/picker.rs
+++ b/src/ui/picker.rs
@@ -7,6 +7,7 @@ use crate::{
     config::KeyAction,
     editor::{Action, Editor, RenderBuffer},
     theme::{Style, Theme},
+    unicode_utils::display_width,
 };
 
 use super::{dialog::BorderStyle, Component, Dialog, List};
@@ -140,11 +141,9 @@ impl Component for Picker {
                 }
                 KeyCode::Esc => Some(KeyAction::Single(Action::CloseDialog)),
                 KeyCode::Backspace => {
-                    let mut search = self.search.clone();
-                    search.truncate(self.search.len().saturating_sub(1));
-
+                    self.search.pop();
+                    let search = self.search.clone();
                     self.filter(&search);
-                    self.search = search;
                     None
                 }
                 KeyCode::Enter => {
@@ -186,7 +185,7 @@ impl Component for Picker {
     }
 
     fn cursor_position(&self) -> Option<(usize, usize)> {
-        let cx = self.x + 2 + self.search.len();
+        let cx = self.x + 2 + display_width(&self.search);
         let cy = self.y + self.height - 1;
 
         Some((cx, cy))

From 76b37d08daeb5f3d48622c7a47937dbebdd278cf Mon Sep 17 00:00:00 2001
From: Felipe Coury <felipe.coury@gmail.com>
Date: Fri, 8 May 2026 01:36:45 -0300
Subject: [PATCH 11/37] fix(tui): align info tooltip content rendering

Draw info tooltip text from the dialog content origin instead of applying the
horizontal offset twice, which misplaced content away from its border.

Measure and pad tooltip rows by display width so wide Unicode text is clipped
and filled consistently with other popup surfaces.
---
 src/ui/info.rs | 84 +++++++++++++++++++++++++++++++++++++++++---------
 1 file changed, 70 insertions(+), 14 deletions(-)

diff --git a/src/ui/info.rs b/src/ui/info.rs
index 5d9f5b0..b049e63 100644
--- a/src/ui/info.rs
+++ b/src/ui/info.rs
@@ -2,6 +2,7 @@ use crate::{
     color::Color,
     editor::{Editor, RenderBuffer},
     theme::{Style, Theme},
+    unicode_utils::{display_width, fit_display_width},
 };
 
 use super::{
@@ -40,7 +41,7 @@ impl Info {
         let (mut x, y) = editor.cursor_position();
         let y = y + 1;
 
-        let width = text.lines().map(|l| l.len()).max().unwrap_or(0);
+        let width = text.lines().map(display_width).max().unwrap_or(0);
         let mut height = text.lines().count();
 
         if x + width >= editor.vwidth() {
@@ -52,7 +53,7 @@ impl Info {
             // TODO: we need scroll if this happens
         }
 
-        let width = std::cmp::min(width, editor.vwidth()) - 2;
+        let width = std::cmp::min(width, editor.vwidth().saturating_sub(2));
 
         Self {
             x,
@@ -80,20 +81,75 @@ impl Component for Info {
     fn draw(&self, buffer: &mut RenderBuffer) -> anyhow::Result<()> {
         self.dialog.draw(buffer)?;
 
-        let mut lines = self.text.lines();
-        for y in self.y + 1..self.y + 1 + self.height {
-            if let Some(line) = lines.next() {
-                for (x, c) in line.chars().enumerate() {
-                    let x = x + 1 + self.x;
-                    if x < self.width - 2 {
-                        buffer.set_char(x + 1 + self.x, y, c, &self.style, &self.theme);
-                    }
-                }
-            } else {
-                break;
-            }
+        for (row, line) in self.text.lines().take(self.height).enumerate() {
+            buffer.set_text(
+                self.x + 1,
+                self.y + 1 + row,
+                &fit_display_width(line, self.width),
+                &self.style,
+            );
         }
 
         Ok(())
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn rendered_cells(buffer: &RenderBuffer, y: usize, x: usize, width: usize) -> Vec<char> {
+        buffer.cells[y * buffer.width + x..y * buffer.width + x + width]
+            .iter()
+            .map(|cell| cell.c)
+            .collect()
+    }
+
+    #[test]
+    fn info_draws_text_at_dialog_content_origin() {
+        let style = Style::default();
+        let theme = Theme::default();
+        let mut buffer = RenderBuffer::new(20, 6, &style);
+        let info = Info {
+            x: 3,
+            y: 1,
+            width: 5,
+            height: 1,
+            style: style.clone(),
+            text: "hello".to_string(),
+            theme: theme.clone(),
+            dialog: Dialog::new(None, 3, 1, 5, 1, &style, BorderStyle::Single, &theme),
+        };
+
+        info.draw(&mut buffer).unwrap();
+
+        assert_eq!(
+            rendered_cells(&buffer, 2, 3, 7),
+            vec!['│', 'h', 'e', 'l', 'l', 'o', '│']
+        );
+    }
+
+    #[test]
+    fn info_draws_wide_text_by_display_width() {
+        let style = Style::default();
+        let theme = Theme::default();
+        let mut buffer = RenderBuffer::new(20, 6, &style);
+        let info = Info {
+            x: 0,
+            y: 1,
+            width: 4,
+            height: 1,
+            style: style.clone(),
+            text: "👋ab".to_string(),
+            theme: theme.clone(),
+            dialog: Dialog::new(None, 0, 1, 4, 1, &style, BorderStyle::Single, &theme),
+        };
+
+        info.draw(&mut buffer).unwrap();
+
+        assert_eq!(
+            rendered_cells(&buffer, 2, 0, 6),
+            vec!['│', '👋', ' ', 'a', 'b', '│']
+        );
+    }
+}

From dc29e63c83e0f651f747899efc3304bb2c9065bc Mon Sep 17 00:00:00 2001
From: Felipe Coury <felipe.coury@gmail.com>
Date: Fri, 8 May 2026 01:38:21 -0300
Subject: [PATCH 12/37] fix(tui): center dialog titles by display width

Use display-width-aware title measurement and truncation when drawing dialog
borders, so long titles cannot underflow the centering calculation.

This also keeps Unicode titles aligned with the rest of the popup rendering
surfaces that measure terminal columns instead of bytes.
---
 src/ui/dialog.rs | 62 ++++++++++++++++++++++++++++++++++++++++++++++--
 1 file changed, 60 insertions(+), 2 deletions(-)

diff --git a/src/ui/dialog.rs b/src/ui/dialog.rs
index 9a562b1..6dd2c30 100644
--- a/src/ui/dialog.rs
+++ b/src/ui/dialog.rs
@@ -1,6 +1,7 @@
 use crate::{
     editor::RenderBuffer,
     theme::{Style, Theme},
+    unicode_utils::{display_width, truncate_display_width},
 };
 
 use super::Component;
@@ -118,10 +119,67 @@ impl Component for Dialog {
         }
 
         if let Some(ref title) = self.title {
-            let cx = self.x + (width / 2) - (title.len() / 2);
-            buffer.set_text(cx, self.y, &format!(" {} ", title), &self.style);
+            let title = format!(" {} ", title);
+            let title = truncate_display_width(&title, width);
+            let title_width = display_width(&title);
+            let cx = self.x + width.saturating_sub(title_width) / 2;
+            buffer.set_text(cx, self.y, &title, &self.style);
         }
 
         Ok(())
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn rendered_cells(buffer: &RenderBuffer, y: usize, x: usize, width: usize) -> Vec<char> {
+        buffer.cells[y * buffer.width + x..y * buffer.width + x + width]
+            .iter()
+            .map(|cell| cell.c)
+            .collect()
+    }
+
+    #[test]
+    fn long_title_does_not_underflow_when_centered() {
+        let style = Style::default();
+        let theme = Theme::default();
+        let mut buffer = RenderBuffer::new(10, 4, &style);
+        let dialog = Dialog::new(
+            Some("very long title".to_string()),
+            0,
+            0,
+            3,
+            1,
+            &style,
+            BorderStyle::Single,
+            &theme,
+        );
+
+        dialog.draw(&mut buffer).unwrap();
+
+        assert_eq!(rendered_cells(&buffer, 0, 0, 5).len(), 5);
+    }
+
+    #[test]
+    fn title_placement_uses_display_width() {
+        let style = Style::default();
+        let theme = Theme::default();
+        let mut buffer = RenderBuffer::new(12, 4, &style);
+        let dialog = Dialog::new(
+            Some("👋".to_string()),
+            0,
+            0,
+            8,
+            1,
+            &style,
+            BorderStyle::Single,
+            &theme,
+        );
+
+        dialog.draw(&mut buffer).unwrap();
+
+        assert_eq!(rendered_cells(&buffer, 0, 3, 4), vec![' ', '👋', ' ', ' ']);
+    }
+}

From 64b775fd0239cd3f43047a710846bc951563b177 Mon Sep 17 00:00:00 2001
From: Felipe Coury <felipe.coury@gmail.com>
Date: Fri, 8 May 2026 01:39:41 -0300
Subject: [PATCH 13/37] fix(tui): place commandline cursor by display width

Use terminal display width instead of byte length when reporting the cursor
position for command and search prompts.

This keeps the cursor aligned with rendered commandline text when prompts
contain wide Unicode characters such as emoji or CJK text.
---
 src/editor/rendering.rs        | 2 +-
 tests/common/editor_harness.rs | 8 ++++++++
 2 files changed, 9 insertions(+), 1 deletion(-)

diff --git a/src/editor/rendering.rs b/src/editor/rendering.rs
index 33bfb8d..10ae4e3 100644
--- a/src/editor/rendering.rs
+++ b/src/editor/rendering.rs
@@ -1190,7 +1190,7 @@ impl Editor {
         if let Some(current_dialog) = &self.current_dialog {
             current_dialog.cursor_position()
         } else if self.has_term() {
-            Some((self.term().len() + 1, (self.size.1 - 1) as usize))
+            Some((display_width(self.term()) + 1, (self.size.1 - 1) as usize))
         } else {
             // Get the active window to calculate cursor position
             if let Some(window) = self.window_manager.active_window() {
diff --git a/tests/common/editor_harness.rs b/tests/common/editor_harness.rs
index 597a959..f5d41f0 100644
--- a/tests/common/editor_harness.rs
+++ b/tests/common/editor_harness.rs
@@ -323,6 +323,14 @@ mod tests {
         assert_eq!(harness.commandline_row(), "/👋 x    ");
     }
 
+    #[test]
+    fn test_commandline_cursor_uses_display_width() {
+        let mut harness = EditorHarness::new();
+        harness.set_commandline(Mode::Search, "👋x");
+
+        assert_eq!(harness.render_cursor_position(), Some((4, 23)));
+    }
+
     #[test]
     fn test_statusline_renders_on_small_width() {
         let mut harness = EditorHarness::with_content("content");

From ab7d3d77eedb8c8f78f99499628c34d83d28ce4e Mon Sep 17 00:00:00 2001
From: Felipe Coury <felipe.coury@gmail.com>
Date: Fri, 8 May 2026 01:41:24 -0300
Subject: [PATCH 14/37] fix(tui): make picker sizing safe on tiny terminals

Use saturating geometry for picker dialog, list, separator, and cursor rows so
small terminal heights cannot underflow popup layout calculations.

Make editor viewport height saturating as well, matching the window manager's
reserved status and command line handling on very small screens.
---
 src/editor.rs                  |  2 +-
 src/ui/picker.rs               |  8 ++++----
 tests/common/editor_harness.rs | 15 +++++++++++++++
 3 files changed, 20 insertions(+), 5 deletions(-)

diff --git a/src/editor.rs b/src/editor.rs
index 68b55b2..a6f673c 100644
--- a/src/editor.rs
+++ b/src/editor.rs
@@ -741,7 +741,7 @@ impl Editor {
     }
 
     pub fn vheight(&self) -> usize {
-        self.size.1 as usize - 2
+        (self.size.1 as usize).saturating_sub(2)
     }
 
     /// Window-aware coordinate transformation methods
diff --git a/src/ui/picker.rs b/src/ui/picker.rs
index 9d6bbd9..5a9159a 100644
--- a/src/ui/picker.rs
+++ b/src/ui/picker.rs
@@ -68,7 +68,7 @@ impl Picker {
             x,
             y,
             width,
-            height - 1,
+            height.saturating_sub(1),
             &style,
             BorderStyle::Single,
             &editor.theme,
@@ -77,7 +77,7 @@ impl Picker {
             x + 1,
             y + 1,
             width,
-            height - 3,
+            height.saturating_sub(3),
             // TODO: remove the clone
             items.to_vec(),
             &style,
@@ -175,7 +175,7 @@ impl Component for Picker {
         self.dialog.draw(buffer)?;
         self.list.draw(buffer)?;
 
-        let dy = self.y + self.height - 2;
+        let dy = self.y + self.height.saturating_sub(2);
         buffer.set_char(self.x, dy, '├', &self.style, &self.theme);
         buffer.set_char(self.x + self.width + 1, dy, '┤', &self.style, &self.theme);
         buffer.set_text(self.x + 1, dy, &"─".repeat(self.width), &self.style);
@@ -186,7 +186,7 @@ impl Component for Picker {
 
     fn cursor_position(&self) -> Option<(usize, usize)> {
         let cx = self.x + 2 + display_width(&self.search);
-        let cy = self.y + self.height - 1;
+        let cy = self.y + self.height.saturating_sub(1);
 
         Some((cx, cy))
     }
diff --git a/tests/common/editor_harness.rs b/tests/common/editor_harness.rs
index f5d41f0..95164f0 100644
--- a/tests/common/editor_harness.rs
+++ b/tests/common/editor_harness.rs
@@ -271,6 +271,21 @@ mod tests {
         harness.assert_mode(Mode::Normal);
     }
 
+    #[tokio::test]
+    async fn test_picker_opens_on_tiny_terminal() {
+        let mut harness = EditorHarness::new();
+        harness.editor.test_set_size(1, 2);
+
+        harness
+            .execute_action(Action::OpenPicker(
+                Some("files".to_string()),
+                vec!["alpha".to_string()],
+                None,
+            ))
+            .await
+            .unwrap();
+    }
+
     #[tokio::test]
     async fn test_window_switch_preserves_cursor_state() {
         let mut harness = EditorHarness::with_content("Line 1\nLine 2\nLine 3");

From 42507cacd9c1ced7308e8d648a104fb6eb5da9ef Mon Sep 17 00:00:00 2001
From: Felipe Coury <felipe.coury@gmail.com>
Date: Fri, 8 May 2026 01:43:06 -0300
Subject: [PATCH 15/37] fix(tui): make info tooltip geometry saturating

Move info tooltip placement into a small geometry helper that uses saturating
math for cursor offsets, horizontal fitting, and available height checks.

This prevents hover/info popup layout from underflowing on tiny terminal
heights after viewport height is clamped to zero.
---
 src/ui/info.rs | 53 ++++++++++++++++++++++++++++++++++++--------------
 1 file changed, 38 insertions(+), 15 deletions(-)

diff --git a/src/ui/info.rs b/src/ui/info.rs
index b049e63..36d600e 100644
--- a/src/ui/info.rs
+++ b/src/ui/info.rs
@@ -22,6 +22,30 @@ pub struct Info {
     dialog: Dialog,
 }
 
+fn fit_info_geometry(
+    cursor: (usize, usize),
+    editor_width: usize,
+    editor_height: usize,
+    text_width: usize,
+    text_height: usize,
+) -> (usize, usize, usize, usize) {
+    let (mut x, cursor_y) = cursor;
+    let y = cursor_y.saturating_add(1);
+    let mut height = text_height;
+
+    if x.saturating_add(text_width) >= editor_width {
+        x = editor_width.saturating_sub(text_width.saturating_add(3));
+    }
+
+    if y.saturating_add(height) >= editor_height.saturating_sub(2) {
+        height = editor_height.saturating_sub(y.saturating_add(2));
+    }
+
+    let width = std::cmp::min(text_width, editor_width.saturating_sub(2));
+
+    (x, y, width, height)
+}
+
 impl Info {
     pub fn new(editor: &Editor, text: String) -> Self {
         let style = Style {
@@ -38,22 +62,15 @@ impl Info {
             ..Default::default()
         };
 
-        let (mut x, y) = editor.cursor_position();
-        let y = y + 1;
-
         let width = text.lines().map(display_width).max().unwrap_or(0);
-        let mut height = text.lines().count();
-
-        if x + width >= editor.vwidth() {
-            x = editor.vwidth().saturating_sub(width + 3);
-        }
-
-        if y + height >= editor.vheight() - 2 {
-            height = editor.vheight().saturating_sub(y + 2);
-            // TODO: we need scroll if this happens
-        }
-
-        let width = std::cmp::min(width, editor.vwidth().saturating_sub(2));
+        let height = text.lines().count();
+        let (x, y, width, height) = fit_info_geometry(
+            editor.cursor_position(),
+            editor.vwidth(),
+            editor.vheight(),
+            width,
+            height,
+        );
 
         Self {
             x,
@@ -152,4 +169,10 @@ mod tests {
             vec!['│', '👋', ' ', 'a', 'b', '│']
         );
     }
+
+    #[test]
+    fn info_geometry_does_not_underflow_on_tiny_height() {
+        assert_eq!(fit_info_geometry((0, 0), 1, 0, 5, 3), (0, 1, 0, 0));
+        assert_eq!(fit_info_geometry((0, 0), 1, 1, 5, 3), (0, 1, 0, 0));
+    }
 }

From 79335caba5f9cfb39d70ea8159882fbdca702387 Mon Sep 17 00:00:00 2001
From: Felipe Coury <felipe.coury@gmail.com>
Date: Fri, 8 May 2026 09:42:22 -0300
Subject: [PATCH 16/37] fix(tui): guard chrome rendering on tiny terminals

Skip statusline and commandline drawing when terminal dimensions leave no valid
row for those chrome elements, and use saturating command/search cursor rows.

This prevents refresh rendering from underflowing on one-row or zero-size test
terminal layouts.
---
 src/editor/rendering.rs        | 17 ++++++++++++++---
 tests/common/editor_harness.rs | 11 +++++++++++
 2 files changed, 25 insertions(+), 3 deletions(-)

diff --git a/src/editor/rendering.rs b/src/editor/rendering.rs
index 10ae4e3..0d2b1d7 100644
--- a/src/editor/rendering.rs
+++ b/src/editor/rendering.rs
@@ -989,6 +989,10 @@ impl Editor {
     }
 
     pub fn draw_statusline(&mut self, buffer: &mut RenderBuffer) {
+        if self.size.0 == 0 || self.size.1 < 2 {
+            return;
+        }
+
         let mode = format_mode_name(&self.mode);
         let mode = format!(" {mode} ");
 
@@ -1088,8 +1092,12 @@ impl Editor {
 
     pub fn draw_commandline(&mut self, buffer: &mut RenderBuffer) {
         let style = &self.theme.style;
-        let y = self.size.1 as usize - 1;
         let width = self.size.0 as usize;
+        if width == 0 || self.size.1 == 0 {
+            return;
+        }
+
+        let y = self.size.1 as usize - 1;
         let clear_line = " ".repeat(width);
         buffer.set_text(0, y, &clear_line, style);
 
@@ -1119,7 +1127,7 @@ impl Editor {
         };
         let prefix = if self.is_command() { ":" } else { "/" };
         let cmdline = format!("{}{}", prefix, text);
-        buffer.set_text(0, self.size.1 as usize - 1, &cmdline, style);
+        buffer.set_text(0, y, &cmdline, style);
     }
 
     /// Renders the gutter with line numbers for a specific window
@@ -1190,7 +1198,10 @@ impl Editor {
         if let Some(current_dialog) = &self.current_dialog {
             current_dialog.cursor_position()
         } else if self.has_term() {
-            Some((display_width(self.term()) + 1, (self.size.1 - 1) as usize))
+            Some((
+                display_width(self.term()) + 1,
+                (self.size.1 as usize).saturating_sub(1),
+            ))
         } else {
             // Get the active window to calculate cursor position
             if let Some(window) = self.window_manager.active_window() {
diff --git a/tests/common/editor_harness.rs b/tests/common/editor_harness.rs
index 95164f0..b4c04eb 100644
--- a/tests/common/editor_harness.rs
+++ b/tests/common/editor_harness.rs
@@ -286,6 +286,17 @@ mod tests {
             .unwrap();
     }
 
+    #[tokio::test]
+    async fn test_refresh_renders_on_tiny_terminal() {
+        let mut harness = EditorHarness::new();
+        harness.editor.test_set_size(1, 1);
+
+        harness.execute_action(Action::Refresh).await.unwrap();
+
+        harness.editor.test_set_size(0, 0);
+        harness.execute_action(Action::Refresh).await.unwrap();
+    }
+
     #[tokio::test]
     async fn test_window_switch_preserves_cursor_state() {
         let mut harness = EditorHarness::with_content("Line 1\nLine 2\nLine 3");

From aeff423ea3fc945ab3a367df9b93b6d6e3a4f6a3 Mon Sep 17 00:00:00 2001
From: Felipe Coury <felipe.coury@gmail.com>
Date: Fri, 8 May 2026 22:27:19 -0300
Subject: [PATCH 17/37] fix(tui): resize windows inside nested splits

Keep split membership checks from mutating the traversal index before recursing
into nested split trees, so resize commands can reach the active window's
inner parent split.

Also report a no-op when resizing a single window, since there is no parent
split ratio to adjust.
---
 src/window.rs | 108 +++++++++++++++++++++++++++++++++++++++-----------
 1 file changed, 84 insertions(+), 24 deletions(-)

diff --git a/src/window.rs b/src/window.rs
index c5b65f1..73b7f0e 100644
--- a/src/window.rs
+++ b/src/window.rs
@@ -88,6 +88,37 @@ impl Window {
     }
 }
 
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn resize_reaches_nested_split_after_outer_membership_check() {
+        let mut manager = WindowManager::new(0, (80, 26));
+        manager.split_vertical(0).unwrap();
+        manager.set_active(0);
+        manager.split_horizontal(0).unwrap();
+
+        assert_eq!(manager.active_window_id(), 1);
+        let before_height = manager.active_window().unwrap().size.1;
+
+        assert!(manager.resize_window(Direction::Up, 1).is_some());
+
+        let after_height = manager.active_window().unwrap().size.1;
+        assert!(
+            after_height > before_height,
+            "bottom-left nested window should grow upward"
+        );
+    }
+
+    #[test]
+    fn resizing_single_window_reports_noop() {
+        let mut manager = WindowManager::new(0, (80, 26));
+
+        assert!(manager.resize_window(Direction::Right, 1).is_none());
+    }
+}
+
 /// Represents a split in the window layout
 #[derive(Debug, Clone)]
 pub enum Split {
@@ -548,10 +579,6 @@ impl WindowManager {
 
         match node {
             Split::Window(_) => {
-                if *current_id == target_id {
-                    // Found the target window, but we need to adjust its parent split
-                    return true;
-                }
                 *current_id += 1;
                 false
             }
@@ -559,7 +586,8 @@ impl WindowManager {
                 log!("Found horizontal split with ratio {}", ratio);
 
                 // Check if target window is in top
-                let in_top = Self::window_in_subtree(top, current_id, target_id);
+                let subtree_start = *current_id;
+                let in_top = Self::window_in_subtree_from(top, subtree_start, target_id);
 
                 if in_top {
                     log!(
@@ -585,21 +613,22 @@ impl WindowManager {
                         _ => {
                             log!("Direction {:?} doesn't apply to horizontal split, searching subtree", direction);
                             // Try to adjust within the top subtree
+                            let mut child_id = subtree_start;
                             return Self::adjust_split_ratio_recursive(
-                                top, current_id, target_id, direction, amount,
+                                top,
+                                &mut child_id,
+                                target_id,
+                                direction,
+                                amount,
                             );
                         }
                     }
                 }
 
-                // Reset current_id to what it was before checking top
-                let saved_id = *current_id;
-                // Count windows in top subtree without looking for target
-                let mut temp_id = saved_id;
-                Self::window_in_subtree(top, &mut temp_id, usize::MAX);
-                // Now current_id points to the start of bottom subtree
+                *current_id = subtree_start + Self::window_count(top);
 
-                let in_bottom = Self::window_in_subtree(bottom, current_id, target_id);
+                let bottom_start = *current_id;
+                let in_bottom = Self::window_in_subtree_from(bottom, bottom_start, target_id);
 
                 if in_bottom {
                     // Target is in bottom, check if we should adjust this split
@@ -616,20 +645,27 @@ impl WindowManager {
                         }
                         _ => {
                             // Try to adjust within the bottom subtree
+                            let mut child_id = bottom_start;
                             return Self::adjust_split_ratio_recursive(
-                                bottom, current_id, target_id, direction, amount,
+                                bottom,
+                                &mut child_id,
+                                target_id,
+                                direction,
+                                amount,
                             );
                         }
                     }
                 }
 
+                *current_id = bottom_start + Self::window_count(bottom);
                 false
             }
             Split::Vertical { left, right, ratio } => {
                 log!("Found vertical split with ratio {}", ratio);
 
                 // Check if target window is in left
-                let in_left = Self::window_in_subtree(left, current_id, target_id);
+                let subtree_start = *current_id;
+                let in_left = Self::window_in_subtree_from(left, subtree_start, target_id);
 
                 if in_left {
                     log!(
@@ -662,21 +698,22 @@ impl WindowManager {
                                 direction
                             );
                             // Try to adjust within the left subtree
+                            let mut child_id = subtree_start;
                             return Self::adjust_split_ratio_recursive(
-                                left, current_id, target_id, direction, amount,
+                                left,
+                                &mut child_id,
+                                target_id,
+                                direction,
+                                amount,
                             );
                         }
                     }
                 }
 
-                // Reset current_id to what it was before checking left
-                let saved_id = *current_id;
-                // Count windows in left subtree without looking for target
-                let mut temp_id = saved_id;
-                Self::window_in_subtree(left, &mut temp_id, usize::MAX);
-                // Now current_id points to the start of right subtree
+                *current_id = subtree_start + Self::window_count(left);
 
-                let in_right = Self::window_in_subtree(right, current_id, target_id);
+                let right_start = *current_id;
+                let in_right = Self::window_in_subtree_from(right, right_start, target_id);
 
                 if in_right {
                     // Target is in right, check if we should adjust this split
@@ -693,18 +730,41 @@ impl WindowManager {
                         }
                         _ => {
                             // Try to adjust within the right subtree
+                            let mut child_id = right_start;
                             return Self::adjust_split_ratio_recursive(
-                                right, current_id, target_id, direction, amount,
+                                right,
+                                &mut child_id,
+                                target_id,
+                                direction,
+                                amount,
                             );
                         }
                     }
                 }
 
+                *current_id = right_start + Self::window_count(right);
                 false
             }
         }
     }
 
+    fn window_count(node: &Split) -> usize {
+        match node {
+            Split::Window(_) => 1,
+            Split::Horizontal { top, bottom, .. }
+            | Split::Vertical {
+                left: top,
+                right: bottom,
+                ..
+            } => Self::window_count(top) + Self::window_count(bottom),
+        }
+    }
+
+    fn window_in_subtree_from(node: &Split, start_id: usize, target_id: usize) -> bool {
+        let mut current_id = start_id;
+        Self::window_in_subtree(node, &mut current_id, target_id)
+    }
+
     /// Check if a window with the given ID is in the subtree
     fn window_in_subtree(node: &Split, current_id: &mut usize, target_id: usize) -> bool {
         match node {

From fc22ddfccfd04a9b1698025556a52423189e392b Mon Sep 17 00:00:00 2001
From: Felipe Coury <felipe.coury@gmail.com>
Date: Fri, 8 May 2026 22:28:50 -0300
Subject: [PATCH 18/37] fix(tui): keep sibling when closing first split window

Advance the window traversal index when removing the target leaf so later
siblings are not mistaken for the same active window during close.

This lets closing the first window in a split collapse to the remaining sibling
instead of failing to remove the active window.
---
 src/window.rs | 13 +++++++++++++
 1 file changed, 13 insertions(+)

diff --git a/src/window.rs b/src/window.rs
index 73b7f0e..06a7b18 100644
--- a/src/window.rs
+++ b/src/window.rs
@@ -117,6 +117,18 @@ mod tests {
 
         assert!(manager.resize_window(Direction::Right, 1).is_none());
     }
+
+    #[test]
+    fn close_first_window_in_split_keeps_sibling() {
+        let mut manager = WindowManager::new(0, (80, 26));
+        manager.split_vertical(0).unwrap();
+        manager.set_active(0);
+
+        assert!(manager.close_window().is_some());
+
+        assert_eq!(manager.windows().len(), 1);
+        assert_eq!(manager.active_window_id(), 0);
+    }
 }
 
 /// Represents a split in the window layout
@@ -447,6 +459,7 @@ impl WindowManager {
             Split::Window(_) => {
                 if *current_id == target_id {
                     // This window should be removed - return None to signal removal
+                    *current_id += 1;
                     None
                 } else {
                     *current_id += 1;

From c8bdbae850e58b37bb000cdb05eab559224e18d9 Mon Sep 17 00:00:00 2001
From: Felipe Coury <felipe.coury@gmail.com>
Date: Fri, 8 May 2026 22:31:45 -0300
Subject: [PATCH 19/37] fix(tui): fit diagnostics to window width

Build diagnostic rows with display-width-aware fitting so indicators and
messages cannot spill beyond the available window columns.

Preserve truncation with an ellipsis for wide Unicode diagnostics and keep
cramped rows bounded when many diagnostics share a line.
---
 src/editor/rendering.rs | 109 ++++++++++++++++++++++++++++------------
 1 file changed, 77 insertions(+), 32 deletions(-)

diff --git a/src/editor/rendering.rs b/src/editor/rendering.rs
index 0d2b1d7..9b40f18 100644
--- a/src/editor/rendering.rs
+++ b/src/editor/rendering.rs
@@ -11,7 +11,7 @@ use crate::{
     log,
     lsp::Diagnostic,
     theme::Style,
-    unicode_utils::{char_display_width, display_width, truncate_chars},
+    unicode_utils::{char_display_width, display_width, fit_display_width, truncate_display_width},
 };
 
 use super::{
@@ -19,6 +19,34 @@ use super::{
     Point, Rect, RenderBuffer,
 };
 
+fn diagnostic_row(diagnostics: &[&Diagnostic], available_width: usize) -> Option<String> {
+    let diagnostic = diagnostics.first()?;
+    if available_width == 0 {
+        return None;
+    }
+
+    let indicator = "■".repeat(diagnostics.len());
+    let message = diagnostic.message.replace('\n', " ");
+    let message = message.trim();
+    let row = if message.is_empty() {
+        indicator
+    } else {
+        format!("{indicator} {message}")
+    };
+
+    if display_width(&row) <= available_width {
+        return Some(fit_display_width(&row, available_width));
+    }
+
+    if available_width == 1 {
+        return Some(truncate_display_width(&row, available_width));
+    }
+
+    let mut row = truncate_display_width(&row, available_width - 1);
+    row.push('…');
+    Some(fit_display_width(&row, available_width))
+}
+
 impl Editor {
     /// Renders the entire editor state to the terminal
     /// This is the main entry point for all rendering operations
@@ -688,39 +716,10 @@ impl Editor {
         available_width: usize,
         style: &Style,
     ) -> anyhow::Result<()> {
-        let indicator = "■".repeat(diagnostics.len());
-        let diagnostic = diagnostics[0];
-
-        // Write the indicator
-        buffer.set_text(x, y, &format!("{indicator} "), style);
-
-        // Process the message - remove newlines and truncate if needed
-        let message = diagnostic.message.replace('\n', " ");
-        let message = message.trim();
-
-        // Calculate available space for message
-        let max_msg_length = available_width.saturating_sub(indicator.chars().count() + 1);
-        if max_msg_length < 3 {
-            // Not enough space for message
-            return Ok(());
+        if let Some(row) = diagnostic_row(diagnostics, available_width) {
+            buffer.set_text(x, y, &row, style);
         }
 
-        // Truncate message if needed and add ellipsis
-        let display_message = if message.chars().count() > max_msg_length {
-            format!("{}…", truncate_chars(message, max_msg_length - 1))
-        } else {
-            message.to_string()
-        };
-
-        // Write the message with a space after the indicator
-        buffer.set_text(
-            x + indicator.chars().count() + 1,
-            y,
-            &display_message,
-            style,
-        );
-        // buffer.set_text(x + 1 + 1, y, &display_message, style);
-
         Ok(())
     }
 
@@ -1274,3 +1273,49 @@ fn format_mode_name(mode: &Mode) -> String {
         Mode::VisualBlock => "V-BLOCK".to_string(),
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::lsp::{Position, Range};
+
+    fn diagnostic(message: &str) -> Diagnostic {
+        Diagnostic {
+            range: Range {
+                start: Position {
+                    line: 0,
+                    character: 0,
+                },
+                end: Position {
+                    line: 0,
+                    character: 1,
+                },
+            },
+            severity: None,
+            code: None,
+            message: message.to_string(),
+            related_information: None,
+            data: None,
+            tags: None,
+        }
+    }
+
+    #[test]
+    fn diagnostic_row_fits_available_display_width() {
+        let diagnostic = diagnostic("wide 👋 diagnostic 世界 message");
+        let diagnostics = vec![&diagnostic];
+        let row = diagnostic_row(&diagnostics, 12).unwrap();
+
+        assert_eq!(display_width(&row), 12);
+        assert!(row.ends_with('…'));
+    }
+
+    #[test]
+    fn diagnostic_row_handles_cramped_width() {
+        let diagnostic = diagnostic("message");
+        let diagnostics = vec![&diagnostic, &diagnostic, &diagnostic];
+        let row = diagnostic_row(&diagnostics, 2).unwrap();
+
+        assert_eq!(display_width(&row), 2);
+    }
+}

From 5bb8219d5f1caf7f4c97762ab2adfa63c0f46e47 Mon Sep 17 00:00:00 2001
From: Felipe Coury <felipe.coury@gmail.com>
Date: Fri, 8 May 2026 22:35:18 -0300
Subject: [PATCH 20/37] fix(tui): bound completion popup layout

Add a bounded completion popup layout path that clamps popup width, flips above
the cursor when there is not enough space below, and limits rendered rows to
the available terminal height.

Use terminal cursor coordinates for LSP completion popups so placement includes
gutter and window offsets instead of buffer-local cursor positions.
---
 src/editor.rs        |  10 ++-
 src/ui/completion.rs | 182 +++++++++++++++++++++++++++++++------------
 2 files changed, 141 insertions(+), 51 deletions(-)

diff --git a/src/editor.rs b/src/editor.rs
index a6f673c..3a67107 100644
--- a/src/editor.rs
+++ b/src/editor.rs
@@ -1582,10 +1582,14 @@ impl Editor {
 
                         match serde_json::from_value::<CompletionResponse>(msg.result.clone()) {
                             Ok(completion_response) => {
-                                self.completion_ui.show(
+                                let (completion_x, completion_y) =
+                                    self.render_cursor_position().unwrap_or((self.cx, self.cy));
+                                self.completion_ui.show_with_bounds(
                                     completion_response.items,
-                                    self.cx,
-                                    self.cy,
+                                    completion_x,
+                                    completion_y,
+                                    self.size.0 as usize,
+                                    self.size.1 as usize,
                                 );
                                 self.current_dialog = Some(Box::new(self.completion_ui.clone()));
                                 return Some(Action::ShowDialog);
diff --git a/src/ui/completion.rs b/src/ui/completion.rs
index 1958932..8dc15f7 100644
--- a/src/ui/completion.rs
+++ b/src/ui/completion.rs
@@ -42,6 +42,7 @@ pub struct CompletionUI {
     y: usize,
     max_height: usize,
     width: usize,
+    max_rows: usize,
     commit_chars: Vec<char>,
 }
 
@@ -50,7 +51,18 @@ impl CompletionUI {
         Self::default()
     }
 
-    pub fn show(&mut self, mut items: Vec<CompletionResponseItem>, x: usize, y: usize) {
+    pub fn show(&mut self, items: Vec<CompletionResponseItem>, x: usize, y: usize) {
+        self.show_with_bounds(items, x, y, usize::MAX, usize::MAX);
+    }
+
+    pub fn show_with_bounds(
+        &mut self,
+        mut items: Vec<CompletionResponseItem>,
+        mut x: usize,
+        mut y: usize,
+        bounds_width: usize,
+        bounds_height: usize,
+    ) {
         // Collect commit characters from all items
         self.commit_chars = items
             .iter()
@@ -74,14 +86,38 @@ impl CompletionUI {
             .position(|item| item.preselect.unwrap_or(false))
             .unwrap_or(0);
 
+        let width = self.calculate_width().min(bounds_width.max(2)).max(2);
+        let unbounded_height = bounds_height == usize::MAX;
+        let max_rows = if unbounded_height {
+            usize::MAX
+        } else {
+            let desired_rows = min(items.len(), PAGE_SIZE).saturating_add(2);
+            let rows_below = bounds_height.saturating_sub(y.saturating_add(1));
+            let rows_above = y;
+            if rows_below < desired_rows && rows_above > rows_below {
+                let max_rows = desired_rows.min(rows_above);
+                y = y.saturating_sub(max_rows);
+                max_rows
+            } else {
+                desired_rows.min(rows_below)
+            }
+        };
+
+        if bounds_width > width {
+            x = x.min(bounds_width - width);
+        } else {
+            x = 0;
+        }
+
         self.items = items;
         self.selected = selected;
         self.scroll_offset = 0;
         self.visible = true;
         self.x = x;
         self.y = y;
-        self.width = self.calculate_width();
-        self.max_height = min(self.items.len(), PAGE_SIZE);
+        self.width = width;
+        self.max_rows = max_rows;
+        self.max_height = min(min(self.items.len(), PAGE_SIZE), max_rows.saturating_sub(2));
     }
 
     pub fn hide(&mut self) {
@@ -115,7 +151,7 @@ impl CompletionUI {
     }
 
     pub fn move_selection(&mut self, delta: isize) {
-        if self.items.is_empty() {
+        if self.items.is_empty() || self.max_height == 0 {
             return;
         }
 
@@ -193,7 +229,7 @@ impl CompletionUI {
     }
 
     fn render_completion(&self) -> Vec<(usize, usize, String, Option<Color>)> {
-        if !self.visible || self.items.is_empty() {
+        if !self.visible || self.items.is_empty() || self.width < 2 || self.max_rows < 2 {
             return Vec::new();
         }
 
@@ -263,59 +299,68 @@ impl CompletionUI {
 
             // Show detail and documentation for selected item
             if is_selected {
-                if let Some(detail) = &item.detail {
-                    output.push((
-                        self.x,
-                        self.y + y_offset,
-                        Self::row(&format!("  {}", detail), self.width),
-                        Some(COMMENT_COLOR),
-                    ));
-                    y_offset += 1;
+                if y_offset < self.max_rows {
+                    if let Some(detail) = &item.detail {
+                        output.push((
+                            self.x,
+                            self.y + y_offset,
+                            Self::row(&format!("  {}", detail), self.width),
+                            Some(COMMENT_COLOR),
+                        ));
+                        y_offset += 1;
+                    }
                 }
 
-                // Show commit characters if available
-                if let Some(chars) = &item.commit_characters {
-                    let commit_text = format!(
-                        "│  Complete with: {}",
-                        chars
-                            .iter()
-                            .map(|c| format!("'{}'", c))
-                            .collect::<Vec<_>>()
-                            .join(", ")
-                    );
-                    output.push((
-                        self.x,
-                        self.y + y_offset,
-                        Self::row(&commit_text, self.width),
-                        Some(COMMENT_COLOR),
-                    ));
-                    y_offset += 1;
+                if y_offset < self.max_rows {
+                    // Show commit characters if available
+                    if let Some(chars) = &item.commit_characters {
+                        let commit_text = format!(
+                            "│  Complete with: {}",
+                            chars
+                                .iter()
+                                .map(|c| format!("'{}'", c))
+                                .collect::<Vec<_>>()
+                                .join(", ")
+                        );
+                        output.push((
+                            self.x,
+                            self.y + y_offset,
+                            Self::row(&commit_text, self.width),
+                            Some(COMMENT_COLOR),
+                        ));
+                        y_offset += 1;
+                    }
                 }
 
-                if let Some(doc) = &item.documentation {
-                    let doc_text = match doc {
-                        Documentation::String(s) => s.clone(),
-                        Documentation::MarkupContent(content) => content.value.clone(),
-                    };
+                if y_offset < self.max_rows {
+                    if let Some(doc) = &item.documentation {
+                        let doc_text = match doc {
+                            Documentation::String(s) => s.clone(),
+                            Documentation::MarkupContent(content) => content.value.clone(),
+                        };
 
-                    // Add separator line
-                    output.push((
-                        self.x,
-                        self.y + y_offset,
-                        format!("│{}│", "─".repeat(self.width - 2)),
-                        Some(BORDER_COLOR),
-                    ));
-                    y_offset += 1;
-
-                    // Split documentation into wrapped lines
-                    for line in textwrap::wrap(&doc_text, self.width - 4) {
+                        // Add separator line
                         output.push((
                             self.x,
                             self.y + y_offset,
-                            Self::row(&format!("  {}", line), self.width),
-                            Some(COMMENT_COLOR),
+                            format!("│{}│", "─".repeat(self.width - 2)),
+                            Some(BORDER_COLOR),
                         ));
                         y_offset += 1;
+
+                        // Split documentation into wrapped lines
+                        for line in textwrap::wrap(&doc_text, self.width.saturating_sub(4).max(1)) {
+                            if y_offset >= self.max_rows {
+                                break;
+                            }
+                            output.push((
+                                self.x,
+                                self.y + y_offset,
+                                Self::row(&format!("  {}", line), self.width),
+                                Some(COMMENT_COLOR),
+                            ));
+                            y_offset += 1;
+                        }
                     }
                 }
             }
@@ -506,4 +551,45 @@ mod tests {
             assert_eq!(display_width(&row), ui.width);
         }
     }
+
+    #[test]
+    fn completion_popup_stays_within_bounds_near_bottom_right() {
+        let mut ui = CompletionUI::new();
+        ui.show_with_bounds(
+            vec![
+                item("alpha", Some(CompletionItemKind::Function)),
+                item("beta", Some(CompletionItemKind::Function)),
+                item("gamma", Some(CompletionItemKind::Function)),
+            ],
+            18,
+            5,
+            20,
+            6,
+        );
+
+        let rows = ui.render_completion();
+
+        assert!(!rows.is_empty());
+        for (x, y, row, _) in rows {
+            assert!(y < 6);
+            assert!(x + display_width(&row) <= 20);
+        }
+    }
+
+    #[test]
+    fn completion_popup_trims_extra_rows_to_height_bound() {
+        let mut completion = item("hello", Some(CompletionItemKind::Text));
+        completion.detail = Some("returns value".to_string());
+        completion.documentation = Some(Documentation::String(
+            "long documentation that would normally add several rows".to_string(),
+        ));
+
+        let mut ui = CompletionUI::new();
+        ui.show_with_bounds(vec![completion], 0, 0, 20, 4);
+
+        let rows = ui.render_completion();
+
+        assert!(rows.iter().all(|(_, y, _, _)| *y < 4));
+        assert_eq!(rows.len(), 3);
+    }
 }

From acc571689e558a579a4eda61d5dc5240f9032f50 Mon Sep 17 00:00:00 2001
From: Felipe Coury <felipe.coury@gmail.com>
Date: Sat, 9 May 2026 00:25:32 -0300
Subject: [PATCH 21/37] refactor(lsp): modularize language server backend

Add configurable language server definitions and route editor LSP
requests through a manager keyed by document language and workspace root.

Keep Rust enabled by default while moving `rust-analyzer` details into
server config so other stdio LSPs can be added through `config.toml`.
---
 README.md                |   7 +
 src/config.rs            | 191 ++++++++++++++-
 src/editor.rs            |  33 +--
 src/fixtures/config.toml |  11 +-
 src/lib.rs               |   2 +-
 src/lsp/capabilities.rs  | 487 ++-------------------------------------
 src/lsp/client.rs        | 405 +++++++++++++++++---------------
 src/lsp/manager.rs       | 408 ++++++++++++++++++++++++++++++++
 src/lsp/mod.rs           |   4 +-
 src/main.rs              |   5 +-
 10 files changed, 859 insertions(+), 694 deletions(-)
 create mode 100644 src/lsp/manager.rs

diff --git a/README.md b/README.md
index e873a80..b0a685a 100644
--- a/README.md
+++ b/README.md
@@ -89,6 +89,13 @@ cursor_line = true
 [lsp]
 enabled = true
 
+[lsp.servers.typescript]
+command = "typescript-language-server"
+args = ["--stdio"]
+language_id = "typescript"
+file_extensions = ["ts", "tsx"]
+root_markers = ["package.json", ".git"]
+
 # Plugin settings
 [plugins]
 enabled = true
diff --git a/src/config.rs b/src/config.rs
index 9e37f6e..b850995 100644
--- a/src/config.rs
+++ b/src/config.rs
@@ -1,6 +1,7 @@
 use std::{collections::HashMap, path::PathBuf};
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize};
+use serde_json::{json, Value};
 
 use crate::editor::Action;
 
@@ -12,12 +13,149 @@ pub struct Config {
     pub plugins: HashMap<String, String>,
     pub log_file: Option<String>,
     pub mouse_scroll_lines: Option<usize>,
+    #[serde(default)]
+    pub lsp: LspConfig,
     #[serde(default = "default_true")]
     pub show_diagnostics: bool,
     #[serde(default = "default_false")]
     pub window_borders_ascii: bool,
 }
 
+#[derive(Debug, Serialize, Deserialize, Clone)]
+pub struct LspConfig {
+    #[serde(default = "default_true")]
+    pub enabled: bool,
+    #[serde(
+        default = "default_language_servers",
+        deserialize_with = "deserialize_language_servers"
+    )]
+    pub servers: HashMap<String, LanguageServerConfig>,
+}
+
+impl Default for LspConfig {
+    fn default() -> Self {
+        Self {
+            enabled: true,
+            servers: default_language_servers(),
+        }
+    }
+}
+
+#[derive(Debug, Serialize, Deserialize, Clone, PartialEq)]
+pub struct LanguageServerConfig {
+    pub command: String,
+    #[serde(default)]
+    pub args: Vec<String>,
+    pub language_id: String,
+    #[serde(default)]
+    pub file_extensions: Vec<String>,
+    #[serde(default)]
+    pub root_markers: Vec<String>,
+    #[serde(default)]
+    pub env: HashMap<String, String>,
+    #[serde(default, skip_serializing)]
+    pub initialization_options: Option<Value>,
+    pub workspace_name: Option<String>,
+}
+
+pub fn default_language_servers() -> HashMap<String, LanguageServerConfig> {
+    HashMap::from([(
+        "rust".to_string(),
+        LanguageServerConfig {
+            command: "rust-analyzer".to_string(),
+            args: vec!["-v".to_string()],
+            language_id: "rust".to_string(),
+            file_extensions: vec!["rs".to_string()],
+            root_markers: vec!["Cargo.toml".to_string(), ".git".to_string()],
+            env: HashMap::new(),
+            initialization_options: Some(rust_analyzer_initialization_options()),
+            workspace_name: Some("red".to_string()),
+        },
+    )])
+}
+
+fn deserialize_language_servers<'de, D>(
+    deserializer: D,
+) -> Result<HashMap<String, LanguageServerConfig>, D::Error>
+where
+    D: Deserializer<'de>,
+{
+    let user_servers = HashMap::<String, LanguageServerConfig>::deserialize(deserializer)?;
+    let mut servers = default_language_servers();
+    servers.extend(user_servers);
+    Ok(servers)
+}
+
+pub fn rust_analyzer_initialization_options() -> Value {
+    json!({
+      "restartServerOnConfigChange": false,
+      "showUnlinkedFileNotification": true,
+      "showRequestFailedErrorNotification": true,
+      "showDependenciesExplorer": true,
+      "testExplorer": false,
+      "initializeStopped": false,
+      "runnables": {
+        "extraEnv": null,
+        "problemMatcher": [
+          "$rustc"
+        ],
+        "askBeforeUpdateTest": true,
+        "command": null,
+        "extraArgs": [],
+        "extraTestBinaryArgs": [
+          "--show-output"
+        ]
+      },
+      "statusBar": {
+        "clickAction": "openLogs",
+        "showStatusBar": {
+          "documentSelector": [
+            {
+              "language": "rust"
+            },
+            {
+              "pattern": "**/Cargo.toml"
+            },
+            {
+              "pattern": "**/Cargo.lock"
+            }
+          ]
+        }
+      },
+      "server": {
+        "path": null,
+        "extraEnv": null
+      },
+      "trace": {
+        "server": "verbose",
+        "extension": false
+      },
+      "debug": {
+        "engine": "auto",
+        "sourceFileMap": {
+          "/rustc/<id>": "${env:USERPROFILE}/.rustup/toolchains/<toolchain-id>/lib/rustlib/src/rust"
+        },
+        "openDebugPane": false,
+        "buildBeforeRestart": false,
+        "engineSettings": {}
+      },
+      "typing": {
+        "continueCommentsOnNewline": true,
+        "excludeChars": "|<"
+      },
+      "diagnostics": {
+        "previewRustcOutput": false,
+        "useRustcErrorCode": false,
+        "disabled": [],
+        "enable": true,
+        "experimental": {
+          "enable": false
+        },
+        "remapPrefix": {},
+      }
+    })
+}
+
 impl Config {
     pub fn path(p: &str) -> PathBuf {
         #[allow(deprecated)]
@@ -96,4 +234,55 @@ mod test {
         let toml = toml::to_string(&config).unwrap();
         println!("{toml}");
     }
+
+    #[test]
+    fn test_lsp_config_defaults_to_rust() {
+        let config: Config = toml::from_str(
+            r#"
+theme = "theme/nightfox.json"
+
+[keys]
+"#,
+        )
+        .unwrap();
+
+        let rust = config.lsp.servers.get("rust").unwrap();
+        assert!(config.lsp.enabled);
+        assert_eq!(rust.command, "rust-analyzer");
+        assert_eq!(rust.args, vec!["-v"]);
+        assert_eq!(rust.language_id, "rust");
+        assert_eq!(rust.file_extensions, vec!["rs"]);
+    }
+
+    #[test]
+    fn test_lsp_config_accepts_additional_servers() {
+        let config: Config = toml::from_str(
+            r#"
+theme = "theme/nightfox.json"
+
+[keys]
+
+[lsp]
+enabled = true
+
+[lsp.servers.typescript]
+command = "typescript-language-server"
+args = ["--stdio"]
+language_id = "typescript"
+file_extensions = ["ts", "tsx"]
+root_markers = ["package.json", ".git"]
+workspace_name = "frontend"
+"#,
+        )
+        .unwrap();
+
+        let server = config.lsp.servers.get("typescript").unwrap();
+        assert!(config.lsp.servers.contains_key("rust"));
+        assert_eq!(server.command, "typescript-language-server");
+        assert_eq!(server.args, vec!["--stdio"]);
+        assert_eq!(server.language_id, "typescript");
+        assert_eq!(server.file_extensions, vec!["ts", "tsx"]);
+        assert_eq!(server.root_markers, vec!["package.json", ".git"]);
+        assert_eq!(server.workspace_name.as_deref(), Some("frontend"));
+    }
 }
diff --git a/src/editor.rs b/src/editor.rs
index 3a67107..3ec33dc 100644
--- a/src/editor.rs
+++ b/src/editor.rs
@@ -1556,18 +1556,6 @@ impl Editor {
                         // log!("server capabilities: {:#?}", self.server_capabilities);
                     }
 
-                    if method == "rust-analyzer/analyzerStatus" {
-                        let r = msg.result.as_str().unwrap();
-                        log!("analyzer status: {r}");
-                    }
-
-                    if method == "rust-analyzer/viewFileText" {
-                        let r = msg.result.as_str().unwrap();
-                        log!("----");
-                        log!("{r}");
-                        log!("----");
-                    }
-
                     if method == "textDocument/diagnostic" {
                         if let Some((uri, diagnostics)) = parse_diagnostics(msg) {
                             return self.add_diagnostics(Some(&uri), &diagnostics);
@@ -2535,26 +2523,7 @@ impl Editor {
             }
             Action::DoPing => {
                 add_to_history = false;
-                // self.lsp
-                //     .send_request(
-                //         "rust-analyzer/analyzerStatus",
-                //         json!({
-                //             "textDocument": {
-                //                 "uri": self.current_buffer().uri().unwrap_or_default()
-                //             }
-                //         }),
-                //         true,
-                //     )
-                //     .await?;
-                self.lsp
-                    .send_request(
-                        "rust-analyzer/viewFileText",
-                        json!({
-                            "uri": self.current_buffer().uri().unwrap_or_default()
-                        }),
-                        true,
-                    )
-                    .await?;
+                self.lsp.workspace_symbol("").await?;
             }
             Action::ViewLogs => {
                 add_to_history = false;
diff --git a/src/fixtures/config.toml b/src/fixtures/config.toml
index 897604e..c81f7b6 100644
--- a/src/fixtures/config.toml
+++ b/src/fixtures/config.toml
@@ -1,5 +1,15 @@
 theme = "themes/nightfox.json"
 
+[lsp]
+enabled = true
+
+[lsp.servers.typescript]
+command = "typescript-language-server"
+args = ["--stdio"]
+language_id = "typescript"
+file_extensions = ["ts", "tsx"]
+root_markers = ["package.json", ".git"]
+
 [keys.normal]
 "o" = "InsertLineBelowCursor"
 "O" = "InsertLineAtCursor"
@@ -28,4 +38,3 @@ theme = "themes/nightfox.json"
 
 [keys.normal.i]
 EnterMode = "Normal"
-
diff --git a/src/lib.rs b/src/lib.rs
index be529a4..32c701b 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -25,7 +25,7 @@ pub mod test_utils;
 use once_cell::sync::OnceCell;
 
 pub use logger::Logger;
-pub use lsp::RealLspClient;
+pub use lsp::{LspManager, RealLspClient};
 
 #[allow(unused)]
 pub static LOGGER: OnceCell<Option<Logger>> = OnceCell::new();
diff --git a/src/lsp/capabilities.rs b/src/lsp/capabilities.rs
index 5e00ac2..8e5793e 100644
--- a/src/lsp/capabilities.rs
+++ b/src/lsp/capabilities.rs
@@ -1,11 +1,20 @@
 use std::process;
 
-use serde_json::json;
+use serde_json::Value;
 
 use super::types::*;
 
 pub fn get_client_capabilities(workspace_uri: impl ToString) -> InitializeParams {
+    get_client_capabilities_with_options(workspace_uri, "red", Value::Null)
+}
+
+pub fn get_client_capabilities_with_options(
+    workspace_uri: impl ToString,
+    workspace_name: impl ToString,
+    initialization_options: Value,
+) -> InitializeParams {
     let workspace_uri = workspace_uri.to_string();
+    let workspace_name = workspace_name.to_string();
     let text_document_capabilities = TextDocumentClientCapabilities::builder()
         .synchronization(
             TextDocumentSyncClientCapabilities::builder()
@@ -450,7 +459,10 @@ pub fn get_client_capabilities(workspace_uri: impl ToString) -> InitializeParams
         .process_id(process::id().into())
         .client_info(ClientInfo::new("red", Some("0.1.0")))
         .root_uri(workspace_uri.clone())
-        .workspace_folders(vec![WorkspaceFolder::new(workspace_uri.clone(), "red")])
+        .workspace_folders(vec![WorkspaceFolder::new(
+            workspace_uri.clone(),
+            workspace_name,
+        )])
         .capabilities(
             ClientCapabilities::builder()
                 .text_document(text_document_capabilities)
@@ -458,475 +470,6 @@ pub fn get_client_capabilities(workspace_uri: impl ToString) -> InitializeParams
                 .workspace(workspace)
                 .build(),
         )
-        .initialization_options(get_client_capabilities_initialization_options())
+        .initialization_options(initialization_options)
         .build()
 }
-
-fn get_client_capabilities_initialization_options() -> serde_json::Value {
-    json!({
-      "restartServerOnConfigChange": false,
-      "showUnlinkedFileNotification": true,
-      "showRequestFailedErrorNotification": true,
-      "showDependenciesExplorer": true,
-      "testExplorer": false,
-      "initializeStopped": false,
-      "runnables": {
-        "extraEnv": null,
-        "problemMatcher": [
-          "$rustc"
-        ],
-        "askBeforeUpdateTest": true,
-        "command": null,
-        "extraArgs": [],
-        "extraTestBinaryArgs": [
-          "--show-output"
-        ]
-      },
-      "statusBar": {
-        "clickAction": "openLogs",
-        "showStatusBar": {
-          "documentSelector": [
-            {
-              "language": "rust"
-            },
-            {
-              "pattern": "**/Cargo.toml"
-            },
-            {
-              "pattern": "**/Cargo.lock"
-            }
-          ]
-        }
-      },
-      "server": {
-        "path": null,
-        "extraEnv": null
-      },
-      "trace": {
-        "server": "verbose",
-        "extension": false
-      },
-      "debug": {
-        "engine": "auto",
-        "sourceFileMap": {
-          "/rustc/<id>": "${env:USERPROFILE}/.rustup/toolchains/<toolchain-id>/lib/rustlib/src/rust"
-        },
-        "openDebugPane": false,
-        "buildBeforeRestart": false,
-        "engineSettings": {}
-      },
-      "typing": {
-        "continueCommentsOnNewline": true,
-        "excludeChars": "|<"
-      },
-      "diagnostics": {
-        "previewRustcOutput": false,
-        "useRustcErrorCode": false,
-        "disabled": [],
-        "enable": true,
-        "experimental": {
-          "enable": false
-        },
-        "remapPrefix": {},
-        "styleLints": {
-          "enable": false
-        },
-        "warningsAsHint": [],
-        "warningsAsInfo": []
-      },
-      "assist": {
-        "emitMustUse": false,
-        "expressionFillDefault": "todo",
-        "termSearch": {
-          "borrowcheck": true,
-          "fuel": 1800
-        }
-      },
-      "cachePriming": {
-        "enable": true,
-        "numThreads": "physical"
-      },
-      "cargo": {
-        "allTargets": true,
-        "autoreload": true,
-        "buildScripts": {
-          "enable": true,
-          "invocationStrategy": "per_workspace",
-          "overrideCommand": null,
-          "rebuildOnSave": true,
-          "useRustcWrapper": true
-        },
-        "cfgs": {
-          "miri": null,
-          "debug_assertions": null
-        },
-        "extraArgs": [],
-        "extraEnv": {},
-        "features": [],
-        "noDefaultFeatures": false,
-        "sysroot": "discover",
-        "sysrootSrc": null,
-        "target": null,
-        "targetDir": null
-      },
-      "cfg": {
-        "setTest": true
-      },
-      "checkOnSave": true,
-      "check": {
-        "allTargets": null,
-        "command": "clippy",
-        "extraArgs": [],
-        "extraEnv": {},
-        "features": null,
-        "ignore": [],
-        "invocationStrategy": "per_workspace",
-        "noDefaultFeatures": null,
-        "overrideCommand": null,
-        "targets": null,
-        "workspace": true
-      },
-      "completion": {
-        "addSemicolonToUnit": true,
-        "autoimport": {
-          "enable": true,
-          "exclude": [
-            {
-              "path": "core::borrow::Borrow",
-              "type": "methods"
-            },
-            {
-              "path": "core::borrow::BorrowMut",
-              "type": "methods"
-            }
-          ]
-        },
-        "autoself": {
-          "enable": true
-        },
-        "callable": {
-          "snippets": "fill_arguments"
-        },
-        "excludeTraits": [],
-        "fullFunctionSignatures": {
-          "enable": false
-        },
-        "hideDeprecated": false,
-        "limit": null,
-        "postfix": {
-          "enable": true
-        },
-        "privateEditable": {
-          "enable": false
-        },
-        "snippets": {
-          "custom": {
-            "Ok": {
-              "postfix": "ok",
-              "body": "Ok(${receiver})",
-              "description": "Wrap the expression in a `Result::Ok`",
-              "scope": "expr"
-            },
-            "Box::pin": {
-              "postfix": "pinbox",
-              "body": "Box::pin(${receiver})",
-              "requires": "std::boxed::Box",
-              "description": "Put the expression into a pinned `Box`",
-              "scope": "expr"
-            },
-            "Arc::new": {
-              "postfix": "arc",
-              "body": "Arc::new(${receiver})",
-              "requires": "std::sync::Arc",
-              "description": "Put the expression into an `Arc`",
-              "scope": "expr"
-            },
-            "Some": {
-              "postfix": "some",
-              "body": "Some(${receiver})",
-              "description": "Wrap the expression in an `Option::Some`",
-              "scope": "expr"
-            },
-            "Err": {
-              "postfix": "err",
-              "body": "Err(${receiver})",
-              "description": "Wrap the expression in a `Result::Err`",
-              "scope": "expr"
-            },
-            "Rc::new": {
-              "postfix": "rc",
-              "body": "Rc::new(${receiver})",
-              "requires": "std::rc::Rc",
-              "description": "Put the expression into an `Rc`",
-              "scope": "expr"
-            }
-          }
-        },
-        "termSearch": {
-          "enable": false,
-          "fuel": 1000
-        }
-      },
-      "files": {
-        "excludeDirs": [],
-        "watcher": "client"
-      },
-      "highlightRelated": {
-        "breakPoints": {
-          "enable": true
-        },
-        "closureCaptures": {
-          "enable": true
-        },
-        "exitPoints": {
-          "enable": true
-        },
-        "references": {
-          "enable": true
-        },
-        "yieldPoints": {
-          "enable": true
-        }
-      },
-      "hover": {
-        "actions": {
-          "debug": {
-            "enable": true
-          },
-          "enable": true,
-          "gotoTypeDef": {
-            "enable": true
-          },
-          "implementations": {
-            "enable": true
-          },
-          "references": {
-            "enable": false
-          },
-          "run": {
-            "enable": true
-          },
-          "updateTest": {
-            "enable": true
-          }
-        },
-        "documentation": {
-          "enable": true,
-          "keywords": {
-            "enable": true
-          }
-        },
-        "links": {
-          "enable": true
-        },
-        "maxSubstitutionLength": 20,
-        "memoryLayout": {
-          "alignment": "hexadecimal",
-          "enable": true,
-          "niches": false,
-          "offset": "hexadecimal",
-          "size": "both"
-        },
-        "show": {
-          "enumVariants": 5,
-          "fields": 5,
-          "traitAssocItems": null
-        }
-      },
-      "imports": {
-        "granularity": {
-          "enforce": false,
-          "group": "crate"
-        },
-        "group": {
-          "enable": true
-        },
-        "merge": {
-          "glob": true
-        },
-        "preferNoStd": false,
-        "preferPrelude": false,
-        "prefix": "plain",
-        "prefixExternPrelude": false
-      },
-      "inlayHints": {
-        "bindingModeHints": {
-          "enable": false
-        },
-        "chainingHints": {
-          "enable": true
-        },
-        "closingBraceHints": {
-          "enable": true,
-          "minLines": 25
-        },
-        "closureCaptureHints": {
-          "enable": false
-        },
-        "closureReturnTypeHints": {
-          "enable": "never"
-        },
-        "closureStyle": "impl_fn",
-        "discriminantHints": {
-          "enable": "never"
-        },
-        "expressionAdjustmentHints": {
-          "enable": "never",
-          "hideOutsideUnsafe": false,
-          "mode": "prefix"
-        },
-        "genericParameterHints": {
-          "const": {
-            "enable": true
-          },
-          "lifetime": {
-            "enable": false
-          },
-          "type": {
-            "enable": false
-          }
-        },
-        "implicitDrops": {
-          "enable": false
-        },
-        "lifetimeElisionHints": {
-          "enable": "never",
-          "useParameterNames": false
-        },
-        "maxLength": 25,
-        "parameterHints": {
-          "enable": true
-        },
-        "rangeExclusiveHints": {
-          "enable": false
-        },
-        "reborrowHints": {
-          "enable": "never"
-        },
-        "renderColons": true,
-        "typeHints": {
-          "enable": true,
-          "hideClosureInitialization": false,
-          "hideNamedConstructor": false
-        }
-      },
-      "interpret": {
-        "tests": false
-      },
-      "joinLines": {
-        "joinAssignments": true,
-        "joinElseIf": true,
-        "removeTrailingComma": true,
-        "unwrapTrivialBlock": true
-      },
-      "lens": {
-        "debug": {
-          "enable": true
-        },
-        "enable": true,
-        "implementations": {
-          "enable": true
-        },
-        "location": "above_name",
-        "references": {
-          "adt": {
-            "enable": false
-          },
-          "enumVariant": {
-            "enable": false
-          },
-          "method": {
-            "enable": false
-          },
-          "trait": {
-            "enable": false
-          }
-        },
-        "run": {
-          "enable": true
-        },
-        "updateTest": {
-          "enable": true
-        }
-      },
-      "linkedProjects": [],
-      "lru": {
-        "capacity": null,
-        "query": {
-          "capacities": {}
-        }
-      },
-      "notifications": {
-        "cargoTomlNotFound": true
-      },
-      "numThreads": null,
-      "procMacro": {
-        "attributes": {
-          "enable": true
-        },
-        "enable": true,
-        "ignored": {},
-        "server": null
-      },
-      "references": {
-        "excludeImports": false,
-        "excludeTests": false
-      },
-      "rustc": {
-        "source": null
-      },
-      "rustfmt": {
-        "extraArgs": [],
-        "overrideCommand": null,
-        "rangeFormatting": {
-          "enable": false
-        }
-      },
-      "semanticHighlighting": {
-        "doc": {
-          "comment": {
-            "inject": {
-              "enable": true
-            }
-          }
-        },
-        "nonStandardTokens": true,
-        "operator": {
-          "enable": true,
-          "specialization": {
-            "enable": false
-          }
-        },
-        "punctuation": {
-          "enable": false,
-          "separate": {
-            "macro": {
-              "bang": false
-            }
-          },
-          "specialization": {
-            "enable": false
-          }
-        },
-        "strings": {
-          "enable": true
-        }
-      },
-      "signatureInfo": {
-        "detail": "full",
-        "documentation": {
-          "enable": true
-        }
-      },
-      "workspace": {
-        "discoverConfig": null,
-        "symbol": {
-          "search": {
-            "kind": "only_types",
-            "limit": 128,
-            "scope": "workspace"
-          }
-        }
-      }
-    })
-}
diff --git a/src/lsp/client.rs b/src/lsp/client.rs
index 6720a2a..7ec7d36 100644
--- a/src/lsp/client.rs
+++ b/src/lsp/client.rs
@@ -1,6 +1,6 @@
 use std::{
     collections::HashMap,
-    path::Path,
+    path::{Path, PathBuf},
     process::Stdio,
     time::{Duration, Instant},
 };
@@ -14,171 +14,212 @@ use tokio::{
     sync::mpsc::{self, error::TryRecvError},
 };
 
-use super::{get_client_capabilities, InboundMessage, LspClient, OutboundMessage, ResponseError};
+use super::{
+    capabilities::get_client_capabilities_with_options, InboundMessage, LspClient, OutboundMessage,
+    ResponseError,
+};
+use crate::config::LanguageServerConfig;
 use crate::lsp::{
     parse_notification, types::*, Notification, NotificationRequest, Request, ResponseMessage,
 };
-use crate::{log, lsp::LspError, utils::get_workspace_uri};
+use crate::{log, lsp::LspError};
 
 const REQUEST_TIMEOUT: Duration = Duration::from_secs(30);
 
-pub async fn start_lsp() -> Result<RealLspClient, LspError> {
-    let mut child = TokioCommand::new("rust-analyzer")
-        // .env("RA_LOG", "lsp_server=debug")
-        // .arg("--log-file")
-        // .arg("/tmp/rust-analyzer.log")
-        // .arg("--no-log-buffering")
-        .arg("-v")
+fn file_uri(path: impl AsRef<Path>) -> Result<String, LspError> {
+    Ok(format!(
+        "file://{}",
+        path.as_ref().absolutize()?.to_string_lossy()
+    ))
+}
+
+fn workspace_uri(path: impl AsRef<Path>) -> Result<String, LspError> {
+    file_uri(path)
+}
+
+fn did_open_params(
+    file: &str,
+    contents: &str,
+    language_id: &str,
+) -> Result<serde_json::Value, LspError> {
+    Ok(json!({
+        "textDocument": {
+            "uri": file_uri(file)?,
+            "languageId": language_id,
+            "version": 1,
+            "text": contents,
+        }
+    }))
+}
+
+async fn spawn_lsp_process(
+    config: &LanguageServerConfig,
+) -> Result<tokio::process::Child, LspError> {
+    let mut command = TokioCommand::new(&config.command);
+    command
+        .args(&config.args)
+        .envs(&config.env)
         .stdin(Stdio::piped())
         .stdout(Stdio::piped())
-        .stderr(Stdio::piped())
-        .spawn()?;
-
-    let stdin = child.stdin.take().unwrap();
-    let stdout = child.stdout.take().unwrap();
-    let stderr = child.stderr.take().unwrap();
-
-    let (request_tx, mut request_rx) = mpsc::channel::<OutboundMessage>(512);
-    let (response_tx, response_rx) = mpsc::channel::<InboundMessage>(512);
-
-    // Sends requests from the editor into LSP's stdin
-    let rtx = response_tx.clone();
-    tokio::spawn(async move {
-        let mut stdin = BufWriter::new(stdin);
-        while let Some(message) = request_rx.recv().await {
-            match message {
-                OutboundMessage::Request(req) => {
-                    log!("[lsp] sending message: id={} method={}", req.id, req.method);
-                    if let Err(err) = lsp_send_request(&mut stdin, &req).await {
-                        rtx.send(InboundMessage::ProcessingError(err))
-                            .await
-                            .unwrap();
+        .stderr(Stdio::piped());
+
+    Ok(command.spawn()?)
+}
+
+impl RealLspClient {
+    pub async fn start(
+        config: LanguageServerConfig,
+        workspace_root: PathBuf,
+    ) -> Result<RealLspClient, LspError> {
+        let mut child = spawn_lsp_process(&config).await?;
+        let stdin = child.stdin.take().unwrap();
+        let stdout = child.stdout.take().unwrap();
+        let stderr = child.stderr.take().unwrap();
+
+        let (request_tx, mut request_rx) = mpsc::channel::<OutboundMessage>(512);
+        let (response_tx, response_rx) = mpsc::channel::<InboundMessage>(512);
+
+        // Sends requests from the editor into LSP's stdin
+        let rtx = response_tx.clone();
+        tokio::spawn(async move {
+            let mut stdin = BufWriter::new(stdin);
+            while let Some(message) = request_rx.recv().await {
+                match message {
+                    OutboundMessage::Request(req) => {
+                        log!("[lsp] sending message: id={} method={}", req.id, req.method);
+                        if let Err(err) = lsp_send_request(&mut stdin, &req).await {
+                            rtx.send(InboundMessage::ProcessingError(err))
+                                .await
+                                .unwrap();
+                        }
                     }
-                }
-                OutboundMessage::Notification(req) => {
-                    log!("[lsp] sending notification: method={}", req.method);
-                    if let Err(err) = lsp_send_notification(&mut stdin, &req).await {
-                        rtx.send(InboundMessage::ProcessingError(err))
-                            .await
-                            .unwrap();
+                    OutboundMessage::Notification(req) => {
+                        log!("[lsp] sending notification: method={}", req.method);
+                        if let Err(err) = lsp_send_notification(&mut stdin, &req).await {
+                            rtx.send(InboundMessage::ProcessingError(err))
+                                .await
+                                .unwrap();
+                        }
                     }
                 }
             }
-        }
-    });
-
-    // Sends responses from LSP's stdout to the editor
-    let rtx = response_tx.clone();
-    tokio::spawn(async move {
-        let mut reader = BufReader::new(stdout);
+        });
 
-        loop {
-            let mut line = String::new();
-            let read = match reader.read_line(&mut line).await {
-                Ok(n) => n,
-                Err(err) => {
-                    log!("[lsp] error reading stdout: {}", err);
-                    rtx.send(InboundMessage::ProcessingError(LspError::IoError(err)))
-                        .await
-                        .unwrap();
-                    continue;
-                }
-            };
+        // Sends responses from LSP's stdout to the editor
+        let rtx = response_tx.clone();
+        tokio::spawn(async move {
+            let mut reader = BufReader::new(stdout);
 
-            if read == 0 {
-                // EOF reached
-                break;
-            }
-
-            if line.starts_with("Content-Length: ") {
-                let len = match line
-                    .trim_start_matches("Content-Length: ")
-                    .trim()
-                    .parse::<usize>()
-                {
-                    Ok(len) => len,
-                    Err(_) => {
-                        log!(
-                            "[lsp] invalid Content-Length: {}",
-                            line.trim_start_matches("Content-Length: ").trim()
-                        );
-                        // rtx.send(InboundMessage::ProcessingError(LspError::ProtocolError(
-                        //     "Invalid Content-Length".to_string(),
-                        // )))
-                        // .await
-                        // .unwrap();
+            loop {
+                let mut line = String::new();
+                let read = match reader.read_line(&mut line).await {
+                    Ok(n) => n,
+                    Err(err) => {
+                        log!("[lsp] error reading stdout: {}", err);
+                        rtx.send(InboundMessage::ProcessingError(LspError::IoError(err)))
+                            .await
+                            .unwrap();
                         continue;
                     }
                 };
 
-                // reader.read_line(&mut line).await.unwrap(); // empty line
-                let mut empty_line = String::new();
-                if let Err(err) = reader.read_line(&mut empty_line).await {
-                    log!("[lsp] error reading empty line: {}", err);
-                    continue;
+                if read == 0 {
+                    // EOF reached
+                    break;
                 }
 
-                let mut body = vec![0; len];
-                if let Err(err) = reader.read_exact(&mut body).await {
-                    log!(
-                        "[lsp] error reading body of length {}: {}",
-                        len,
-                        err.to_string()
-                    );
-                    // rtx.send(InboundMessage::ProcessingError(LspError::IoError(err)))
-                    //     .await
-                    //     .unwrap();
-                    continue;
-                };
+                if line.starts_with("Content-Length: ") {
+                    let len = match line
+                        .trim_start_matches("Content-Length: ")
+                        .trim()
+                        .parse::<usize>()
+                    {
+                        Ok(len) => len,
+                        Err(_) => {
+                            log!(
+                                "[lsp] invalid Content-Length: {}",
+                                line.trim_start_matches("Content-Length: ").trim()
+                            );
+                            // rtx.send(InboundMessage::ProcessingError(LspError::ProtocolError(
+                            //     "Invalid Content-Length".to_string(),
+                            // )))
+                            // .await
+                            // .unwrap();
+                            continue;
+                        }
+                    };
 
-                match process_lsp_message(&body, &rtx).await {
-                    Ok(_) => (),
-                    Err(err) => {
-                        log!("[lsp] error processing message: {}", err);
+                    // reader.read_line(&mut line).await.unwrap(); // empty line
+                    let mut empty_line = String::new();
+                    if let Err(err) = reader.read_line(&mut empty_line).await {
+                        log!("[lsp] error reading empty line: {}", err);
                         continue;
                     }
+
+                    let mut body = vec![0; len];
+                    if let Err(err) = reader.read_exact(&mut body).await {
+                        log!(
+                            "[lsp] error reading body of length {}: {}",
+                            len,
+                            err.to_string()
+                        );
+                        // rtx.send(InboundMessage::ProcessingError(LspError::IoError(err)))
+                        //     .await
+                        //     .unwrap();
+                        continue;
+                    };
+
+                    match process_lsp_message(&body, &rtx).await {
+                        Ok(_) => (),
+                        Err(err) => {
+                            log!("[lsp] error processing message: {}", err);
+                            continue;
+                        }
+                    }
+                } else {
+                    log!("[lsp] invalid line: {}", line);
                 }
-            } else {
-                log!("[lsp] invalid line: {}", line);
             }
-        }
-    });
+        });
 
-    // Sends errors from LSP's stderr to the editor
-    let rtx = response_tx.clone();
-    tokio::spawn(async move {
-        let mut reader = BufReader::new(stderr);
-        let mut line = String::new();
-        while let Ok(read) = reader.read_line(&mut line).await {
-            if read > 0 {
-                log!("[lsp] incoming stderr: {:?}", line);
-                match rtx
-                    .send(InboundMessage::ProcessingError(LspError::ServerError(
-                        line.clone(),
-                    )))
-                    .await
-                {
-                    Ok(_) => (),
-                    Err(err) => {
-                        log!("[lsp] error sending stderr to editor: {}", err);
+        // Sends errors from LSP's stderr to the editor
+        let rtx = response_tx.clone();
+        tokio::spawn(async move {
+            let mut reader = BufReader::new(stderr);
+            let mut line = String::new();
+            while let Ok(read) = reader.read_line(&mut line).await {
+                if read > 0 {
+                    log!("[lsp] incoming stderr: {:?}", line);
+                    match rtx
+                        .send(InboundMessage::ProcessingError(LspError::ServerError(
+                            line.clone(),
+                        )))
+                        .await
+                    {
+                        Ok(_) => (),
+                        Err(err) => {
+                            log!("[lsp] error sending stderr to editor: {}", err);
+                        }
                     }
                 }
             }
-        }
-    });
+        });
 
-    Ok(RealLspClient {
-        request_tx,
-        response_rx,
-        files_versions: HashMap::new(),
-        files_content: HashMap::new(),
-        pending_responses: HashMap::new(),
-        pending_messages: Vec::new(),
-        initialize_id: None,
-        initialized: false,
-        server_capabilities: None,
-        child: Some(child),
-    })
+        Ok(RealLspClient {
+            request_tx,
+            response_rx,
+            files_versions: HashMap::new(),
+            files_content: HashMap::new(),
+            pending_responses: HashMap::new(),
+            pending_messages: Vec::new(),
+            initialize_id: None,
+            initialized: false,
+            server_capabilities: None,
+            child: Some(child),
+            config,
+            workspace_root,
+        })
+    }
 }
 
 async fn process_lsp_message(
@@ -280,6 +321,8 @@ pub struct RealLspClient {
     pending_messages: Vec<OutboundMessage>,
     server_capabilities: Option<ServerCapabilities>,
     child: Option<tokio::process::Child>,
+    config: LanguageServerConfig,
+    workspace_root: PathBuf,
 }
 
 impl RealLspClient {
@@ -635,7 +678,24 @@ impl LspClient for RealLspClient {
     }
 
     async fn initialize(&mut self) -> Result<(), LspError> {
-        let initialize_params = get_client_capabilities(get_workspace_uri());
+        let workspace_name = self
+            .config
+            .workspace_name
+            .clone()
+            .or_else(|| {
+                self.workspace_root
+                    .file_name()
+                    .map(|name| name.to_string_lossy().to_string())
+            })
+            .unwrap_or_else(|| "workspace".to_string());
+        let initialize_params = get_client_capabilities_with_options(
+            workspace_uri(&self.workspace_root)?,
+            workspace_name,
+            self.config
+                .initialization_options
+                .clone()
+                .unwrap_or(serde_json::Value::Null),
+        );
 
         // log!("initialize_params: {:#?}", initialize_params);
         let initialize_params = match serde_json::to_value(initialize_params) {
@@ -656,14 +716,7 @@ impl LspClient for RealLspClient {
 
     async fn did_open(&mut self, file: &str, contents: &str) -> Result<(), LspError> {
         log!("[lsp] did_open file: {}", file);
-        let params = json!({
-            "textDocument": {
-                "uri": format!("file://{}", Path::new(file).absolutize()?.to_string_lossy()),
-                "languageId": "rust",
-                "version": 1,
-                "text": contents,
-            }
-        });
+        let params = did_open_params(file, contents, &self.config.language_id)?;
 
         self.files_content
             .insert(file.to_string(), contents.to_string());
@@ -676,15 +729,13 @@ impl LspClient for RealLspClient {
 
     async fn did_change(&mut self, file: &str, contents: &str) -> Result<(), LspError> {
         log!("[lsp] did_change file: {}", file);
-        self.request_diagnostics(file).await?;
+        let uri = format!("file://{}", Path::new(file).absolutize()?.to_string_lossy());
+        self.request_diagnostics(&uri).await?;
 
         // Get or create version for this file
         let version = self.files_versions.entry(file.to_string()).or_insert(0);
         *version += 1;
 
-        // Get the file URI
-        let uri = format!("file://{}", Path::new(file).absolutize()?.to_string_lossy());
-
         // Determine sync kind from server capabilities
         let sync_kind = self
             .server_capabilities
@@ -1057,11 +1108,11 @@ impl LspClient for RealLspClient {
                 match status {
                     Ok(status) => {
                         if !status.success() {
-                            log!("[lsp] rust-analyzer exited with status: {}", status);
+                            log!("[lsp] {} exited with status: {}", self.config.command, status);
                         }
                     }
                     Err(e) => {
-                        log!("[lsp] error waiting for rust-analyzer to exit: {}", e);
+                        log!("[lsp] error waiting for {} to exit: {}", self.config.command, e);
                     }
                 }
             }
@@ -1069,35 +1120,6 @@ impl LspClient for RealLspClient {
 
         Ok(())
     }
-
-    // async fn shutdown(&mut self) -> Result<(), LspError> {
-    //     // Send shutdown request
-    //     log!("      lsp request shutdown");
-    //     self.send_request("shutdown", serde_json::Value::Null, true)
-    //         .await?;
-    //
-    //     // Send exit notification
-    //     log!("      lsp notify shutdown");
-    //     self.send_notification("exit", serde_json::Value::Null, true)
-    //         .await?;
-    //
-    //     let mut child = std::mem::take(&mut self.child).unwrap();
-    //
-    //     // Wait for the process to exit
-    //     log!("      waiting for rust-analyzer to exit");
-    //     match child.wait().await {
-    //         Ok(status) => {
-    //             if !status.success() {
-    //                 log!("[lsp] rust-analyzer exited with status: {}", status);
-    //             }
-    //         }
-    //         Err(e) => {
-    //             log!("[lsp] error waiting for rust-analyzer to exit: {}", e);
-    //         }
-    //     }
-    //
-    //     Ok(())
-    // }
 }
 
 pub async fn lsp_send_request(
@@ -1138,13 +1160,23 @@ pub async fn lsp_send_notification(
 
 #[cfg(test)]
 mod test {
-    use crate::lsp::ParsedNotification;
+    use crate::config::default_language_servers;
+    use crate::lsp::{get_client_capabilities, ParsedNotification};
 
     use super::*;
 
     #[tokio::test]
-    async fn test_start_lsp() {
-        let mut client = start_lsp().await.unwrap();
+    async fn test_start_real_lsp() {
+        if std::env::var_os("RED_RUN_REAL_LSP_TESTS").is_none() {
+            return;
+        }
+
+        let config = default_language_servers()
+            .remove("rust")
+            .expect("default Rust LSP config must exist");
+        let mut client = RealLspClient::start(config, std::env::current_dir().unwrap())
+            .await
+            .unwrap();
         client.initialize().await.unwrap();
     }
 
@@ -1263,4 +1295,11 @@ mod test {
         let json = serde_json::to_value(params).unwrap();
         println!("json: {}", serde_json::to_string_pretty(&json).unwrap());
     }
+
+    #[test]
+    fn test_did_open_params_uses_configured_language_id() {
+        let params = did_open_params("main.py", "print('hello')", "python").unwrap();
+        assert_eq!(params["textDocument"]["languageId"], "python");
+        assert_eq!(params["textDocument"]["text"], "print('hello')");
+    }
 }
diff --git a/src/lsp/manager.rs b/src/lsp/manager.rs
new file mode 100644
index 0000000..a13ed2d
--- /dev/null
+++ b/src/lsp/manager.rs
@@ -0,0 +1,408 @@
+use std::{
+    collections::HashMap,
+    path::{Path, PathBuf},
+};
+
+use path_absolutize::Absolutize;
+use serde_json::Value;
+
+use crate::config::{LanguageServerConfig, LspConfig};
+
+use super::{
+    Diagnostic, InboundMessage, LspClient, LspError, Range, RealLspClient, ServerCapabilities,
+};
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct DocumentInfo {
+    pub path: PathBuf,
+    pub uri: String,
+    pub language_id: String,
+    pub workspace_root: PathBuf,
+    pub server_name: String,
+}
+
+pub struct LspManager {
+    config: LspConfig,
+    clients: HashMap<String, RealLspClient>,
+}
+
+impl LspManager {
+    pub fn new(config: LspConfig) -> Self {
+        Self {
+            config,
+            clients: HashMap::new(),
+        }
+    }
+
+    pub fn resolve_document(&self, file: &str) -> Option<DocumentInfo> {
+        if !self.config.enabled {
+            return None;
+        }
+
+        let path = Path::new(file);
+        let extension = path.extension()?.to_string_lossy().to_ascii_lowercase();
+        let (server_name, server) = self.config.servers.iter().find(|(_, server)| {
+            server.file_extensions.iter().any(|candidate| {
+                candidate
+                    .trim_start_matches('.')
+                    .eq_ignore_ascii_case(&extension)
+            })
+        })?;
+
+        let path = path.absolutize().ok()?.to_path_buf();
+        let workspace_root = find_workspace_root(&path, server);
+        let uri = file_uri(&path);
+
+        Some(DocumentInfo {
+            path,
+            uri,
+            language_id: server.language_id.clone(),
+            workspace_root,
+            server_name: server_name.clone(),
+        })
+    }
+
+    async fn client_for_file(
+        &mut self,
+        file: &str,
+    ) -> Result<Option<&mut RealLspClient>, LspError> {
+        let Some(document) = self.resolve_document(file) else {
+            return Ok(None);
+        };
+        let key = client_key(&document);
+
+        if !self.clients.contains_key(&key) {
+            let config = self
+                .config
+                .servers
+                .get(&document.server_name)
+                .cloned()
+                .ok_or_else(|| {
+                    LspError::ProtocolError(format!(
+                        "missing LSP config for server {}",
+                        document.server_name
+                    ))
+                })?;
+
+            let mut client = RealLspClient::start(config, document.workspace_root).await?;
+            client.initialize().await?;
+            self.clients.insert(key.clone(), client);
+        }
+
+        Ok(self.clients.get_mut(&key))
+    }
+
+    fn client_for_uri_mut(&mut self, uri: &str) -> Option<&mut RealLspClient> {
+        let file = uri.strip_prefix("file://").unwrap_or(uri);
+        let document = self.resolve_document(file)?;
+        let key = client_key(&document);
+        self.clients.get_mut(&key)
+    }
+
+    fn first_client_mut(&mut self) -> Option<&mut RealLspClient> {
+        self.clients.values_mut().next()
+    }
+}
+
+fn client_key(document: &DocumentInfo) -> String {
+    format!(
+        "{}:{}",
+        document.server_name,
+        document.workspace_root.display()
+    )
+}
+
+fn file_uri(path: &Path) -> String {
+    format!("file://{}", path.to_string_lossy())
+}
+
+fn find_workspace_root(path: &Path, server: &LanguageServerConfig) -> PathBuf {
+    let start = path.parent().unwrap_or(path);
+
+    for ancestor in start.ancestors() {
+        if server
+            .root_markers
+            .iter()
+            .any(|marker| ancestor.join(marker).exists())
+        {
+            return ancestor.to_path_buf();
+        }
+    }
+
+    std::env::current_dir().unwrap_or_else(|_| start.to_path_buf())
+}
+
+#[async_trait::async_trait]
+impl LspClient for LspManager {
+    async fn initialize(&mut self) -> Result<(), LspError> {
+        Ok(())
+    }
+
+    async fn did_open(&mut self, file: &str, contents: &str) -> Result<(), LspError> {
+        if let Some(client) = self.client_for_file(file).await? {
+            client.did_open(file, contents).await?;
+        }
+        Ok(())
+    }
+
+    async fn did_change(&mut self, file: &str, contents: &str) -> Result<(), LspError> {
+        if let Some(client) = self.client_for_file(file).await? {
+            client.did_change(file, contents).await?;
+        }
+        Ok(())
+    }
+
+    async fn will_save(&mut self, file: &str) -> Result<(), LspError> {
+        if let Some(client) = self.client_for_file(file).await? {
+            client.will_save(file).await?;
+        }
+        Ok(())
+    }
+
+    async fn hover(&mut self, file: &str, x: usize, y: usize) -> Result<i64, LspError> {
+        if let Some(client) = self.client_for_file(file).await? {
+            return client.hover(file, x, y).await;
+        }
+        Ok(0)
+    }
+
+    async fn goto_definition(&mut self, file: &str, x: usize, y: usize) -> Result<i64, LspError> {
+        if let Some(client) = self.client_for_file(file).await? {
+            return client.goto_definition(file, x, y).await;
+        }
+        Ok(0)
+    }
+
+    async fn completion(&mut self, file: &str, x: usize, y: usize) -> Result<i64, LspError> {
+        if let Some(client) = self.client_for_file(file).await? {
+            return client.completion(file, x, y).await;
+        }
+        Ok(0)
+    }
+
+    async fn format_document(&mut self, file: &str) -> Result<i64, LspError> {
+        if let Some(client) = self.client_for_file(file).await? {
+            return client.format_document(file).await;
+        }
+        Ok(0)
+    }
+
+    async fn document_symbols(&mut self, file: &str) -> Result<i64, LspError> {
+        if let Some(client) = self.client_for_file(file).await? {
+            return client.document_symbols(file).await;
+        }
+        Ok(0)
+    }
+
+    async fn code_action(
+        &mut self,
+        file: &str,
+        range: Range,
+        diagnostics: Vec<Diagnostic>,
+    ) -> Result<i64, LspError> {
+        if let Some(client) = self.client_for_file(file).await? {
+            return client.code_action(file, range, diagnostics).await;
+        }
+        Ok(0)
+    }
+
+    async fn signature_help(&mut self, file: &str, x: usize, y: usize) -> Result<i64, LspError> {
+        if let Some(client) = self.client_for_file(file).await? {
+            return client.signature_help(file, x, y).await;
+        }
+        Ok(0)
+    }
+
+    async fn document_highlight(
+        &mut self,
+        file: &str,
+        x: usize,
+        y: usize,
+    ) -> Result<i64, LspError> {
+        if let Some(client) = self.client_for_file(file).await? {
+            return client.document_highlight(file, x, y).await;
+        }
+        Ok(0)
+    }
+
+    async fn document_link(&mut self, file: &str) -> Result<i64, LspError> {
+        if let Some(client) = self.client_for_file(file).await? {
+            return client.document_link(file).await;
+        }
+        Ok(0)
+    }
+
+    async fn document_color(&mut self, file: &str) -> Result<i64, LspError> {
+        if let Some(client) = self.client_for_file(file).await? {
+            return client.document_color(file).await;
+        }
+        Ok(0)
+    }
+
+    async fn folding_range(&mut self, file: &str) -> Result<i64, LspError> {
+        if let Some(client) = self.client_for_file(file).await? {
+            return client.folding_range(file).await;
+        }
+        Ok(0)
+    }
+
+    async fn workspace_symbol(&mut self, query: &str) -> Result<i64, LspError> {
+        if let Some(client) = self.first_client_mut() {
+            return client.workspace_symbol(query).await;
+        }
+        Ok(0)
+    }
+
+    async fn call_hierarchy_prepare(
+        &mut self,
+        file: &str,
+        x: usize,
+        y: usize,
+    ) -> Result<i64, LspError> {
+        if let Some(client) = self.client_for_file(file).await? {
+            return client.call_hierarchy_prepare(file, x, y).await;
+        }
+        Ok(0)
+    }
+
+    async fn semantic_tokens_full(&mut self, file: &str) -> Result<i64, LspError> {
+        if let Some(client) = self.client_for_file(file).await? {
+            return client.semantic_tokens_full(file).await;
+        }
+        Ok(0)
+    }
+
+    async fn inlay_hint(&mut self, file: &str, range: Range) -> Result<i64, LspError> {
+        if let Some(client) = self.client_for_file(file).await? {
+            return client.inlay_hint(file, range).await;
+        }
+        Ok(0)
+    }
+
+    async fn send_request(
+        &mut self,
+        method: &str,
+        params: Value,
+        force: bool,
+    ) -> Result<i64, LspError> {
+        if let Some(client) = self.first_client_mut() {
+            return client.send_request(method, params, force).await;
+        }
+        Ok(0)
+    }
+
+    async fn send_notification(
+        &mut self,
+        method: &str,
+        params: Value,
+        force: bool,
+    ) -> Result<(), LspError> {
+        for client in self.clients.values_mut() {
+            client
+                .send_notification(method, params.clone(), force)
+                .await?;
+        }
+        Ok(())
+    }
+
+    async fn request_completion(
+        &mut self,
+        file_uri: &str,
+        line: usize,
+        character: usize,
+    ) -> Result<i64, LspError> {
+        if let Some(client) = self.client_for_uri_mut(file_uri) {
+            return client.request_completion(file_uri, line, character).await;
+        }
+        Ok(0)
+    }
+
+    async fn request_diagnostics(&mut self, file_uri: &str) -> Result<Option<i64>, LspError> {
+        if let Some(client) = self.client_for_uri_mut(file_uri) {
+            return client.request_diagnostics(file_uri).await;
+        }
+        Ok(None)
+    }
+
+    async fn recv_response(
+        &mut self,
+    ) -> Result<Option<(InboundMessage, Option<String>)>, LspError> {
+        for client in self.clients.values_mut() {
+            if let Some(message) = client.recv_response().await? {
+                return Ok(Some(message));
+            }
+        }
+        Ok(None)
+    }
+
+    fn get_server_capabilities(&self) -> Option<&ServerCapabilities> {
+        self.clients
+            .values()
+            .find_map(|client| client.get_server_capabilities())
+    }
+
+    async fn shutdown(&mut self) -> Result<(), LspError> {
+        for client in self.clients.values_mut() {
+            client.shutdown().await?;
+        }
+        Ok(())
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use std::collections::HashMap;
+
+    use crate::config::LanguageServerConfig;
+
+    use super::*;
+
+    fn server(language_id: &str, extensions: &[&str]) -> LanguageServerConfig {
+        LanguageServerConfig {
+            command: "mock-lsp".to_string(),
+            args: Vec::new(),
+            language_id: language_id.to_string(),
+            file_extensions: extensions.iter().map(|ext| ext.to_string()).collect(),
+            root_markers: vec![".git".to_string()],
+            env: HashMap::new(),
+            initialization_options: None,
+            workspace_name: None,
+        }
+    }
+
+    #[test]
+    fn resolves_configured_language_by_extension() {
+        let manager = LspManager::new(LspConfig {
+            enabled: true,
+            servers: HashMap::from([
+                ("rust".to_string(), server("rust", &["rs"])),
+                ("python".to_string(), server("python", &["py"])),
+            ]),
+        });
+
+        let document = manager.resolve_document("example.py").unwrap();
+        assert_eq!(document.language_id, "python");
+        assert_eq!(document.server_name, "python");
+        assert_eq!(document.uri, format!("file://{}", document.path.display()));
+    }
+
+    #[test]
+    fn unresolved_language_returns_none() {
+        let manager = LspManager::new(LspConfig {
+            enabled: true,
+            servers: HashMap::from([("rust".to_string(), server("rust", &["rs"]))]),
+        });
+
+        assert!(manager.resolve_document("README.md").is_none());
+    }
+
+    #[test]
+    fn disabled_lsp_returns_none() {
+        let manager = LspManager::new(LspConfig {
+            enabled: false,
+            servers: HashMap::from([("rust".to_string(), server("rust", &["rs"]))]),
+        });
+
+        assert!(manager.resolve_document("src/main.rs").is_none());
+    }
+}
diff --git a/src/lsp/mod.rs b/src/lsp/mod.rs
index b44f70f..c5fe494 100644
--- a/src/lsp/mod.rs
+++ b/src/lsp/mod.rs
@@ -9,10 +9,12 @@ use serde_json::Value;
 
 pub use self::types::*;
 pub use capabilities::get_client_capabilities;
-pub use client::{start_lsp, RealLspClient};
+pub use client::RealLspClient;
+pub use manager::{DocumentInfo, LspManager};
 
 pub mod capabilities;
 pub mod client;
+pub mod manager;
 pub mod types;
 
 #[derive(Debug)]
diff --git a/src/main.rs b/src/main.rs
index dec37c6..5328d8e 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -8,7 +8,7 @@ use red::cli::Args;
 use red::config::Config;
 use red::editor::Editor;
 use red::logger::Logger;
-use red::lsp::{start_lsp, LspClient};
+use red::lsp::{LspClient, LspManager};
 use red::theme::parse_vscode_theme;
 use red::{log, LOGGER};
 
@@ -36,8 +36,7 @@ async fn main() -> anyhow::Result<()> {
         std::env::set_current_dir(root)?;
     }
 
-    let mut lsp = Box::new(start_lsp().await?) as Box<dyn LspClient>;
-    lsp.initialize().await?;
+    let mut lsp = Box::new(LspManager::new(config.lsp.clone())) as Box<dyn LspClient>;
 
     let mut buffers = Vec::new();
     if args.files.is_empty() {

From 525ea172bb5b85ff1ec33753a91b78c460ebcd1f Mon Sep 17 00:00:00 2001
From: Felipe Coury <felipe.coury@gmail.com>
Date: Sat, 9 May 2026 00:53:54 -0300
Subject: [PATCH 22/37] feat(tui): add plugin file tree panel

Add a plugin-owned side panel surface with focus routing, layout
reservation, filesystem listing, and directory watch APIs so plugins can
build persistent tree-style UI.

Register a sample `NeoTree` plugin on `Ctrl-e`, including toggle behavior,
file opening, and explicit editor focus handoff after file activation.
---
 default_config.toml     |   2 +
 docs/PLUGIN_SYSTEM.md   |  38 ++++-
 plugins/neotree.js      | 149 ++++++++++++++++++
 src/editor.rs           | 247 +++++++++++++++++++++++++++++-
 src/editor/rendering.rs |   3 +
 src/plugin/mod.rs       |   2 +
 src/plugin/panel.rs     | 332 ++++++++++++++++++++++++++++++++++++++++
 src/plugin/runtime.js   |  50 ++++++
 src/plugin/runtime.rs   |  61 ++++++++
 src/window.rs           |   6 +-
 10 files changed, 887 insertions(+), 3 deletions(-)
 create mode 100644 plugins/neotree.js
 create mode 100644 src/plugin/panel.rs

diff --git a/default_config.toml b/default_config.toml
index 62e2160..9af0fc4 100644
--- a/default_config.toml
+++ b/default_config.toml
@@ -93,6 +93,7 @@ Esc = { EnterMode = "Normal" }
 # }
 "Ctrl-p" = "FilePicker"
 "Ctrl-z" = "Suspend"
+"Ctrl-e" = { PluginCommand = "NeoTree" }
 "K" = "Hover"
 # "W" = "ToggleWrap"
 # "L" = "DecreaseLeft"
@@ -161,3 +162,4 @@ Esc = { EnterMode = "Normal" }
 
 [plugins]
 buffer_picker = "buffer_picker.js"
+neotree = "neotree.js"
diff --git a/docs/PLUGIN_SYSTEM.md b/docs/PLUGIN_SYSTEM.md
index 5ae1ec9..83e3e81 100644
--- a/docs/PLUGIN_SYSTEM.md
+++ b/docs/PLUGIN_SYSTEM.md
@@ -149,8 +149,44 @@ red.openBuffer(name: string)
 
 // Draw text at specific coordinates
 red.drawText(x: number, y: number, text: string, style?: object)
+
+// Create and update a persistent side panel
+red.createPanel("tree", { side: "left", width: 32, title: "Files" })
+red.updatePanel("tree", [{
+  id: "/repo/src",
+  label: "src",
+  path: "/repo/src",
+  depth: 0,
+  expanded: true,
+  kind: "directory"
+}])
+red.focusPanel("tree")
+red.focusEditor()
+red.closePanel("tree")
+red.onPanelEvent("tree", (event) => {
+  // event.action is "up", "down", "expand", "collapse", or "activate"
+})
+```
+
+Panel rows are rendered by the editor and receive focused keyboard input
+while the panel is active. Plugins can call `focusEditor()` to return input
+to the editor after handling a panel action. Pressing `Esc` also returns
+focus to the editor.
+
+#### Filesystem
+```javascript
+const { entries, error } = await red.listDirectory(".")
+const watchId = red.watchDirectory(".", async (snapshot) => {
+  // snapshot has the same shape as listDirectory()
+})
+red.unwatchDirectory(watchId)
+red.openFile("src/main.rs")
 ```
 
+`listDirectory` returns entries sorted with directories before files. Plugins
+do not receive arbitrary filesystem access; they request directory listings
+and directory watches through editor-owned APIs.
+
 #### Buffer Manipulation
 ```javascript
 // Insert text at position
@@ -489,4 +525,4 @@ Areas identified for potential improvement:
 
 The Red editor's plugin system provides a robust foundation for extending editor functionality while maintaining security and performance. By leveraging Deno's runtime and a well-designed API, developers can create powerful plugins that integrate seamlessly with the editor's core functionality.
 
-For questions or contributions to the plugin system, please refer to the main Red editor repository and its contribution guidelines.
\ No newline at end of file
+For questions or contributions to the plugin system, please refer to the main Red editor repository and its contribution guidelines.
diff --git a/plugins/neotree.js b/plugins/neotree.js
new file mode 100644
index 0000000..7b5f1b5
--- /dev/null
+++ b/plugins/neotree.js
@@ -0,0 +1,149 @@
+const PANEL_ID = "neotree";
+const ROOT = ".";
+
+let redApi = null;
+const watches = new Map();
+
+export async function activate(red) {
+  redApi = red;
+  const expanded = new Set([ROOT]);
+  const children = new Map();
+  let created = false;
+
+  async function loadDirectory(path) {
+    const result = await red.listDirectory(path);
+    if (result.error) {
+      red.logWarn("NeoTree failed to list directory", path, result.error);
+      children.set(path, []);
+      return [];
+    }
+    children.set(path, result.entries);
+    return result.entries;
+  }
+
+  function watchDirectory(path) {
+    if (watches.has(path)) return;
+    const watchId = red.watchDirectory(path, async () => {
+      await loadDirectory(path);
+      await refresh();
+    });
+    watches.set(path, watchId);
+  }
+
+  async function ensureLoaded(path) {
+    if (!children.has(path)) {
+      await loadDirectory(path);
+    }
+    watchDirectory(path);
+    return children.get(path) || [];
+  }
+
+  async function buildRows(path, depth = 0, rows = []) {
+    const entries = await ensureLoaded(path);
+    for (const entry of entries) {
+      if (entry.kind !== "directory" && entry.kind !== "file") {
+        continue;
+      }
+
+      const isDirectory = entry.kind === "directory";
+      rows.push({
+        id: entry.path,
+        label: entry.name,
+        path: entry.path,
+        depth,
+        expanded: isDirectory ? expanded.has(entry.path) : false,
+        kind: isDirectory ? "directory" : "file",
+      });
+
+      if (isDirectory && expanded.has(entry.path)) {
+        await buildRows(entry.path, depth + 1, rows);
+      }
+    }
+    return rows;
+  }
+
+  async function refresh() {
+    const rows = await buildRows(ROOT);
+    red.updatePanel(PANEL_ID, rows);
+  }
+
+  function stopWatchingDirectories() {
+    for (const watchId of watches.values()) {
+      red.unwatchDirectory(watchId);
+    }
+    watches.clear();
+  }
+
+  function close() {
+    if (!created) return;
+    stopWatchingDirectories();
+    red.closePanel(PANEL_ID);
+    red.focusEditor();
+    created = false;
+  }
+
+  async function show() {
+    if (!created) {
+      red.createPanel(PANEL_ID, {
+        side: "left",
+        width: 32,
+        title: "Files",
+      });
+      created = true;
+    }
+
+    await ensureLoaded(ROOT);
+    await refresh();
+    red.focusPanel(PANEL_ID);
+  }
+
+  async function toggleDirectory(path, forceExpand = null) {
+    const shouldExpand = forceExpand ?? !expanded.has(path);
+    if (shouldExpand) {
+      expanded.add(path);
+      await ensureLoaded(path);
+    } else {
+      expanded.delete(path);
+    }
+    await refresh();
+  }
+
+  red.addCommand("NeoTree", async () => {
+    if (created) {
+      close();
+    } else {
+      await show();
+    }
+  });
+
+  red.onPanelEvent(PANEL_ID, async (event) => {
+    const row = event.row;
+    if (!row) return;
+
+    if (event.action === "activate") {
+      if (row.kind === "directory") {
+        await toggleDirectory(row.path);
+      } else if (row.path) {
+        red.openFile(row.path);
+        red.focusEditor();
+      }
+      return;
+    }
+
+    if (row.kind === "directory" && event.action === "expand") {
+      await toggleDirectory(row.path, true);
+    }
+
+    if (row.kind === "directory" && event.action === "collapse") {
+      await toggleDirectory(row.path, false);
+    }
+  });
+}
+
+export async function deactivate() {
+  if (!redApi) return;
+  for (const watchId of watches.values()) redApi.unwatchDirectory(watchId);
+  watches.clear();
+  redApi.closePanel(PANEL_ID);
+  redApi = null;
+}
diff --git a/src/editor.rs b/src/editor.rs
index 3ec33dc..95f6f52 100644
--- a/src/editor.rs
+++ b/src/editor.rs
@@ -134,6 +134,32 @@ pub enum PluginRequest {
     RemoveOverlay {
         id: String,
     },
+    CreatePanel {
+        id: String,
+        config: plugin::PanelConfig,
+    },
+    UpdatePanel {
+        id: String,
+        rows: Vec<plugin::PanelRow>,
+    },
+    FocusPanel {
+        id: String,
+    },
+    FocusEditor,
+    ClosePanel {
+        id: String,
+    },
+    ListDirectory {
+        path: String,
+        request_id: i32,
+    },
+    WatchDirectory {
+        path: String,
+        watch_id: i32,
+    },
+    UnwatchDirectory {
+        watch_id: i32,
+    },
 }
 
 #[derive(Debug)]
@@ -149,6 +175,12 @@ pub enum RenderCommand {
 #[allow(unused)]
 pub struct PluginResponse(serde_json::Value);
 
+struct DirectoryWatcher {
+    path: String,
+    snapshot: Value,
+    last_checked: Instant,
+}
+
 #[derive(Debug, Serialize, Deserialize, Clone, PartialEq)]
 pub enum Action {
     Quit(bool),
@@ -490,6 +522,10 @@ pub struct Editor {
 
     /// Plugin overlay manager
     overlay_manager: plugin::OverlayManager,
+
+    panel_manager: plugin::PanelManager,
+
+    directory_watchers: HashMap<i32, DirectoryWatcher>,
 }
 
 #[derive(Debug, Clone, PartialEq)]
@@ -639,6 +675,8 @@ impl Editor {
             fwd_history: Vec::new(),
             render_commands: VecDeque::new(),
             overlay_manager: plugin::OverlayManager::new(),
+            panel_manager: plugin::PanelManager::default(),
+            directory_watchers: HashMap::new(),
         })
     }
 
@@ -719,10 +757,35 @@ impl Editor {
 
     fn resize_window_layout(&mut self, terminal_size: (usize, usize)) {
         self.sync_to_window();
-        self.window_manager.resize(terminal_size);
+        let reserved_left = self.reserved_panel_left_width();
+        self.window_manager.resize_with_origin(
+            Point::new(reserved_left, 0),
+            (
+                terminal_size.0.saturating_sub(reserved_left),
+                terminal_size.1,
+            ),
+        );
         self.sync_with_window();
     }
 
+    fn apply_panel_layout(&mut self) {
+        self.sync_to_window();
+        let reserved_left = self.reserved_panel_left_width();
+        self.window_manager.resize_with_origin(
+            Point::new(reserved_left, 0),
+            (
+                (self.size.0 as usize).saturating_sub(reserved_left),
+                self.size.1 as usize,
+            ),
+        );
+    }
+
+    fn reserved_panel_left_width(&self) -> usize {
+        self.panel_manager
+            .reserved_left_width()
+            .min((self.size.0 as usize).saturating_sub(10))
+    }
+
     fn indentation(&self) -> Indentation {
         let file_type = self.current_buffer().file_type();
 
@@ -1125,6 +1188,16 @@ impl Editor {
                         }
                     }
 
+                    for (watch_id, payload) in self.poll_directory_watchers() {
+                        self.plugin_registry
+                            .notify(
+                                &mut runtime,
+                                &format!("filesystem:changed:{watch_id}"),
+                                payload,
+                            )
+                            .await?;
+                    }
+
                     // if self.sync_state.should_notify() {
                     //     for file in self.sync_state.get_changes().unwrap_or_default() {
                     //         // FIXME: not current buffer!
@@ -1403,6 +1476,48 @@ impl Editor {
                                 log!("Removing overlay: {}", id);
                                 self.overlay_manager.remove_overlay(&id);
                             }
+                            PluginRequest::CreatePanel { id, config } => {
+                                self.panel_manager.create_panel(id, config);
+                                self.apply_panel_layout();
+                                self.render(&mut buffer)?;
+                            }
+                            PluginRequest::UpdatePanel { id, rows } => {
+                                self.panel_manager.update_panel(&id, rows);
+                                self.render(&mut buffer)?;
+                            }
+                            PluginRequest::FocusPanel { id } => {
+                                self.panel_manager.focus_panel(&id);
+                                self.render(&mut buffer)?;
+                            }
+                            PluginRequest::FocusEditor => {
+                                self.panel_manager.focus_editor();
+                                self.render(&mut buffer)?;
+                            }
+                            PluginRequest::ClosePanel { id } => {
+                                self.panel_manager.close_panel(&id);
+                                self.apply_panel_layout();
+                                self.render(&mut buffer)?;
+                            }
+                            PluginRequest::ListDirectory { path, request_id } => {
+                                let payload = directory_listing(&path);
+                                self.plugin_registry
+                                    .notify(
+                                        &mut runtime,
+                                        &format!("filesystem:directory:{request_id}"),
+                                        payload,
+                                    )
+                                    .await?;
+                            }
+                            PluginRequest::WatchDirectory { path, watch_id } => {
+                                self.directory_watchers.insert(watch_id, DirectoryWatcher {
+                                    snapshot: directory_listing(&path),
+                                    path,
+                                    last_checked: Instant::now(),
+                                });
+                            }
+                            PluginRequest::UnwatchDirectory { watch_id } => {
+                                self.directory_watchers.remove(&watch_id);
+                            }
                         }
                     }
                 }
@@ -1677,6 +1792,15 @@ impl Editor {
             return Ok(current_dialog.handle_event(ev));
         }
 
+        if self.panel_manager.focused_panel_id().is_some() {
+            if let Some(action) = self.handle_panel_event(ev) {
+                return Ok(Some(action));
+            }
+
+            let normal = self.config.keys.normal.clone();
+            return Ok(self.event_to_key_action(&normal, ev));
+        }
+
         Ok(match self.mode {
             Mode::Normal => self.handle_normal_event(ev),
             Mode::Insert => self.handle_insert_event(ev)?,
@@ -1686,6 +1810,57 @@ impl Editor {
         })
     }
 
+    fn handle_panel_event(&mut self, ev: &event::Event) -> Option<KeyAction> {
+        let Event::Key(ref event) = ev else {
+            return None;
+        };
+
+        let action = match event.code {
+            KeyCode::Esc => {
+                self.panel_manager.focus_editor();
+                return Some(KeyAction::Single(Action::Refresh));
+            }
+            KeyCode::Up | KeyCode::Char('k') => "up",
+            KeyCode::Down | KeyCode::Char('j') => "down",
+            KeyCode::Left | KeyCode::Char('h') => "collapse",
+            KeyCode::Right | KeyCode::Char('l') => "expand",
+            KeyCode::Enter => "activate",
+            _ => return None,
+        };
+
+        let height = self.size.1 as usize;
+        self.panel_manager
+            .handle_focused_key(action, height)
+            .and_then(|event| {
+                serde_json::to_value(&event).ok().map(|payload| {
+                    KeyAction::Multiple(vec![
+                        Action::NotifyPlugins(format!("panel:event:{}", event.panel_id), payload),
+                        Action::Refresh,
+                    ])
+                })
+            })
+    }
+
+    fn poll_directory_watchers(&mut self) -> Vec<(i32, Value)> {
+        let now = Instant::now();
+        let mut changes = Vec::new();
+
+        for (watch_id, watcher) in self.directory_watchers.iter_mut() {
+            if now.duration_since(watcher.last_checked) < Duration::from_millis(500) {
+                continue;
+            }
+            watcher.last_checked = now;
+
+            let next_snapshot = directory_listing(&watcher.path);
+            if next_snapshot != watcher.snapshot {
+                watcher.snapshot = next_snapshot.clone();
+                changes.push((*watch_id, next_snapshot));
+            }
+        }
+
+        changes
+    }
+
     fn handle_repeater(&mut self, ev: &event::Event) -> bool {
         if let Event::Key(KeyEvent {
             code: KeyCode::Char(c),
@@ -4086,6 +4261,58 @@ impl From<&Buffer> for BufferInfo {
     }
 }
 
+fn directory_listing(path: &str) -> Value {
+    let read_dir = match std::fs::read_dir(path) {
+        Ok(read_dir) => read_dir,
+        Err(err) => {
+            return json!({
+                "path": path,
+                "entries": [],
+                "error": err.to_string(),
+            });
+        }
+    };
+
+    let mut entries = read_dir
+        .filter_map(|entry| {
+            let entry = entry.ok()?;
+            let metadata = entry.metadata().ok()?;
+            let kind = if metadata.is_dir() {
+                "directory"
+            } else if metadata.is_file() {
+                "file"
+            } else {
+                "other"
+            };
+            Some(json!({
+                "name": entry.file_name().to_string_lossy(),
+                "path": entry.path().to_string_lossy(),
+                "kind": kind,
+            }))
+        })
+        .collect::<Vec<_>>();
+
+    entries.sort_by(|a, b| {
+        let kind_rank = |value: &Value| match value.get("kind").and_then(Value::as_str) {
+            Some("directory") => 0,
+            Some("file") => 1,
+            _ => 2,
+        };
+        let a_name = a.get("name").and_then(Value::as_str).unwrap_or_default();
+        let b_name = b.get("name").and_then(Value::as_str).unwrap_or_default();
+
+        kind_rank(a)
+            .cmp(&kind_rank(b))
+            .then_with(|| a_name.to_lowercase().cmp(&b_name.to_lowercase()))
+    });
+
+    json!({
+        "path": path,
+        "entries": entries,
+        "error": null,
+    })
+}
+
 fn determine_style_for_position(style_info: &[StyleInfo], pos: usize) -> Option<Style> {
     if let Some(s) = style_info.iter().find(|si| si.contains(pos)) {
         return Some(s.style.clone());
@@ -4249,6 +4476,24 @@ impl Editor {
 mod test {
     use super::*;
 
+    #[test]
+    fn directory_listing_sorts_directories_before_files() {
+        let root = std::env::temp_dir().join(format!("red-dir-listing-{}", uuid::Uuid::new_v4()));
+        let dir = root.join("src");
+        let file = root.join("README.md");
+        std::fs::create_dir_all(&dir).unwrap();
+        std::fs::write(&file, "readme").unwrap();
+
+        let listing = directory_listing(&root.to_string_lossy());
+        let entries = listing["entries"].as_array().unwrap();
+        assert_eq!(entries[0]["kind"], "directory");
+        assert_eq!(entries[0]["name"], "src");
+        assert_eq!(entries[1]["kind"], "file");
+        assert_eq!(entries[1]["name"], "README.md");
+
+        std::fs::remove_dir_all(root).unwrap();
+    }
+
     #[test]
     fn test_buffer_diff() {
         let contents1 = vec![" 1:2 ".to_string()];
diff --git a/src/editor/rendering.rs b/src/editor/rendering.rs
index 9b40f18..94b3339 100644
--- a/src/editor/rendering.rs
+++ b/src/editor/rendering.rs
@@ -52,6 +52,7 @@ impl Editor {
     /// This is the main entry point for all rendering operations
     pub fn render(&mut self, buffer: &mut RenderBuffer) -> anyhow::Result<()> {
         self.update_gutter_width();
+        self.apply_panel_layout();
         let current_buffer = buffer.clone();
 
         // Render all windows
@@ -64,6 +65,8 @@ impl Editor {
         // Render window separators
         self.render_all_window_separators(buffer)?;
 
+        self.panel_manager.render(buffer, &self.theme.style);
+
         // Render global UI elements
         self.render_ui_chrome(buffer)?;
         self.render_dialog(buffer)?;
diff --git a/src/plugin/mod.rs b/src/plugin/mod.rs
index 623d1fc..332bff6 100644
--- a/src/plugin/mod.rs
+++ b/src/plugin/mod.rs
@@ -1,11 +1,13 @@
 mod loader;
 mod metadata;
 pub mod overlay;
+pub mod panel;
 mod registry;
 mod runtime;
 pub mod timer_stats;
 
 pub use metadata::PluginMetadata;
 pub use overlay::{OverlayAlignment, OverlayConfig, OverlayManager};
+pub use panel::{PanelConfig, PanelManager, PanelRow, PanelRowKind, PanelSide};
 pub use registry::PluginRegistry;
 pub use runtime::{poll_timer_callbacks, Runtime};
diff --git a/src/plugin/panel.rs b/src/plugin/panel.rs
new file mode 100644
index 0000000..5285727
--- /dev/null
+++ b/src/plugin/panel.rs
@@ -0,0 +1,332 @@
+use std::collections::HashMap;
+
+use serde::{Deserialize, Serialize};
+
+use crate::{
+    editor::{render_buffer::RenderBuffer, Point},
+    theme::Style,
+    unicode_utils::fit_display_width,
+};
+
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
+#[serde(rename_all = "snake_case")]
+pub enum PanelSide {
+    Left,
+    Right,
+}
+
+impl Default for PanelSide {
+    fn default() -> Self {
+        Self::Left
+    }
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct PanelConfig {
+    #[serde(default)]
+    pub side: PanelSide,
+    #[serde(default = "default_panel_width")]
+    pub width: usize,
+    #[serde(default)]
+    pub title: Option<String>,
+}
+
+impl Default for PanelConfig {
+    fn default() -> Self {
+        Self {
+            side: PanelSide::Left,
+            width: 30,
+            title: None,
+        }
+    }
+}
+
+fn default_panel_width() -> usize {
+    30
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct PanelRow {
+    pub id: String,
+    pub label: String,
+    pub path: Option<String>,
+    pub depth: usize,
+    pub expanded: Option<bool>,
+    pub kind: PanelRowKind,
+    pub style: Option<Style>,
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
+#[serde(rename_all = "snake_case")]
+pub enum PanelRowKind {
+    File,
+    Directory,
+}
+
+#[derive(Debug, Clone, Serialize)]
+pub struct PanelEvent {
+    pub panel_id: String,
+    pub action: String,
+    pub selected_index: usize,
+    pub row: Option<PanelRow>,
+}
+
+pub struct PluginPanel {
+    pub id: String,
+    pub config: PanelConfig,
+    pub rows: Vec<PanelRow>,
+    pub selected: usize,
+    pub scroll: usize,
+}
+
+impl PluginPanel {
+    pub fn new(id: String, config: PanelConfig) -> Self {
+        Self {
+            id,
+            config,
+            rows: Vec::new(),
+            selected: 0,
+            scroll: 0,
+        }
+    }
+
+    pub fn update_rows(&mut self, rows: Vec<PanelRow>) {
+        self.rows = rows;
+        if self.rows.is_empty() {
+            self.selected = 0;
+            self.scroll = 0;
+        } else if self.selected >= self.rows.len() {
+            self.selected = self.rows.len() - 1;
+        }
+    }
+
+    pub fn move_selection(&mut self, delta: isize, height: usize) {
+        if self.rows.is_empty() {
+            return;
+        }
+
+        let max_index = self.rows.len() - 1;
+        self.selected = self.selected.saturating_add_signed(delta).min(max_index);
+
+        if self.selected < self.scroll {
+            self.scroll = self.selected;
+        }
+
+        let visible_rows = height.saturating_sub(1).max(1);
+        if self.selected >= self.scroll + visible_rows {
+            self.scroll = self.selected.saturating_sub(visible_rows - 1);
+        }
+    }
+
+    pub fn selected_row(&self) -> Option<PanelRow> {
+        self.rows.get(self.selected).cloned()
+    }
+}
+
+#[derive(Default)]
+pub struct PanelManager {
+    panels: HashMap<String, PluginPanel>,
+    z_order: Vec<String>,
+    focused: Option<String>,
+}
+
+impl PanelManager {
+    pub fn create_panel(&mut self, id: String, config: PanelConfig) {
+        self.panels
+            .insert(id.clone(), PluginPanel::new(id.clone(), config));
+        if !self.z_order.contains(&id) {
+            self.z_order.push(id.clone());
+        }
+    }
+
+    pub fn update_panel(&mut self, id: &str, rows: Vec<PanelRow>) {
+        if let Some(panel) = self.panels.get_mut(id) {
+            panel.update_rows(rows);
+        }
+    }
+
+    pub fn close_panel(&mut self, id: &str) {
+        self.panels.remove(id);
+        self.z_order.retain(|panel_id| panel_id != id);
+        if self.focused.as_deref() == Some(id) {
+            self.focused = None;
+        }
+    }
+
+    pub fn focus_panel(&mut self, id: &str) -> bool {
+        if self.panels.contains_key(id) {
+            self.focused = Some(id.to_string());
+            true
+        } else {
+            false
+        }
+    }
+
+    pub fn focus_editor(&mut self) {
+        self.focused = None;
+    }
+
+    pub fn focused_panel_id(&self) -> Option<&str> {
+        self.focused.as_deref()
+    }
+
+    pub fn reserved_left_width(&self) -> usize {
+        self.panels
+            .values()
+            .filter(|panel| panel.config.side == PanelSide::Left)
+            .map(|panel| panel.config.width.saturating_add(1))
+            .sum()
+    }
+
+    pub fn handle_focused_key(&mut self, action: &str, height: usize) -> Option<PanelEvent> {
+        let focused = self.focused.clone()?;
+        let panel = self.panels.get_mut(&focused)?;
+
+        match action {
+            "up" => panel.move_selection(-1, height),
+            "down" => panel.move_selection(1, height),
+            _ => {}
+        }
+
+        Some(PanelEvent {
+            panel_id: panel.id.clone(),
+            action: action.to_string(),
+            selected_index: panel.selected,
+            row: panel.selected_row(),
+        })
+    }
+
+    pub fn render(&self, buffer: &mut RenderBuffer, editor_style: &Style) {
+        let mut left_x: usize = 0;
+        let mut right_x = buffer.width;
+
+        for id in &self.z_order {
+            let Some(panel) = self.panels.get(id) else {
+                continue;
+            };
+
+            let width = panel.config.width.min(buffer.width);
+            let x = match panel.config.side {
+                PanelSide::Left => {
+                    let x = left_x;
+                    left_x = left_x.saturating_add(width.saturating_add(1));
+                    x
+                }
+                PanelSide::Right => {
+                    right_x = right_x.saturating_sub(width);
+                    right_x
+                }
+            };
+
+            render_panel(buffer, panel, Point::new(x, 0), width, editor_style);
+        }
+    }
+}
+
+fn render_panel(
+    buffer: &mut RenderBuffer,
+    panel: &PluginPanel,
+    position: Point,
+    width: usize,
+    editor_style: &Style,
+) {
+    if width == 0 || buffer.height <= 2 {
+        return;
+    }
+
+    let height = buffer.height.saturating_sub(2);
+    let selected_style = editor_style.inverted();
+    let title_style = Style {
+        bold: true,
+        ..editor_style.clone()
+    };
+
+    for y in 0..height {
+        buffer.set_text(position.x, y, &" ".repeat(width), editor_style);
+    }
+
+    if let Some(title) = &panel.config.title {
+        buffer.set_text(
+            position.x,
+            0,
+            &fit_display_width(title, width),
+            &title_style,
+        );
+    }
+
+    let rows_start = if panel.config.title.is_some() { 1 } else { 0 };
+    let visible_rows = height.saturating_sub(rows_start);
+    for (screen_row, row) in panel
+        .rows
+        .iter()
+        .skip(panel.scroll)
+        .take(visible_rows)
+        .enumerate()
+    {
+        let y = rows_start + screen_row;
+        let index = panel.scroll + screen_row;
+        let style = if index == panel.selected {
+            selected_style.clone()
+        } else {
+            row.style.clone().unwrap_or_else(|| editor_style.clone())
+        };
+        let icon = match row.kind {
+            PanelRowKind::Directory if row.expanded.unwrap_or(false) => "-",
+            PanelRowKind::Directory => "+",
+            PanelRowKind::File => " ",
+        };
+        let indent = "  ".repeat(row.depth);
+        let text = format!("{indent}{icon} {}", row.label);
+        buffer.set_text(position.x, y, &fit_display_width(&text, width), &style);
+    }
+
+    if position.x + width < buffer.width {
+        for y in 0..height {
+            buffer.set_text(position.x + width, y, "│", editor_style);
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn row(id: &str) -> PanelRow {
+        PanelRow {
+            id: id.to_string(),
+            label: id.to_string(),
+            path: None,
+            depth: 0,
+            expanded: None,
+            kind: PanelRowKind::File,
+            style: None,
+        }
+    }
+
+    #[test]
+    fn left_panels_reserve_width_with_separator() {
+        let mut manager = PanelManager::default();
+        manager.create_panel(
+            "tree".to_string(),
+            PanelConfig {
+                side: PanelSide::Left,
+                width: 24,
+                title: None,
+            },
+        );
+
+        assert_eq!(manager.reserved_left_width(), 25);
+    }
+
+    #[test]
+    fn focused_panel_moves_selection() {
+        let mut manager = PanelManager::default();
+        manager.create_panel("tree".to_string(), PanelConfig::default());
+        manager.update_panel("tree", vec![row("a"), row("b")]);
+        assert!(manager.focus_panel("tree"));
+
+        let event = manager.handle_focused_key("down", 10).unwrap();
+        assert_eq!(event.selected_index, 1);
+        assert_eq!(event.row.unwrap().id, "b");
+    }
+}
diff --git a/src/plugin/runtime.js b/src/plugin/runtime.js
index acf70df..a9ea0a5 100644
--- a/src/plugin/runtime.js
+++ b/src/plugin/runtime.js
@@ -273,6 +273,56 @@ class RedContext {
   removeOverlay(id) {
     ops.op_remove_overlay(id);
   }
+
+  // Persistent panel API
+  createPanel(id, config = {}) {
+    ops.op_create_panel(id, config);
+  }
+
+  updatePanel(id, rows) {
+    ops.op_update_panel(id, rows);
+  }
+
+  focusPanel(id) {
+    ops.op_focus_panel(id);
+  }
+
+  focusEditor() {
+    ops.op_focus_editor();
+  }
+
+  closePanel(id) {
+    ops.op_close_panel(id);
+  }
+
+  onPanelEvent(id, callback) {
+    this.on(`panel:event:${id}`, callback);
+  }
+
+  listDirectory(path) {
+    return new Promise((resolve, _reject) => {
+      const reqId = nextReqId++;
+      this.once(`filesystem:directory:${reqId}`, (result) => {
+        resolve(result);
+      });
+      ops.op_list_directory(path, reqId);
+    });
+  }
+
+  watchDirectory(path, callback) {
+    const watchId = nextReqId++;
+    this.on(`filesystem:changed:${watchId}`, callback);
+    ops.op_watch_directory(path, watchId);
+    return watchId;
+  }
+
+  unwatchDirectory(watchId) {
+    ops.op_unwatch_directory(watchId);
+  }
+
+  openFile(path) {
+    this.execute("OpenFile", path);
+  }
 }
 
 async function execute(command, args) {
diff --git a/src/plugin/runtime.rs b/src/plugin/runtime.rs
index 7a5b188..e358c94 100644
--- a/src/plugin/runtime.rs
+++ b/src/plugin/runtime.rs
@@ -615,6 +615,59 @@ fn op_remove_overlay(#[string] id: String) -> Result<(), AnyError> {
     Ok(())
 }
 
+#[op2]
+fn op_create_panel(
+    #[string] id: String,
+    #[serde] config: serde_json::Value,
+) -> Result<(), AnyError> {
+    let config = serde_json::from_value(config)?;
+    ACTION_DISPATCHER.send_request(PluginRequest::CreatePanel { id, config });
+    Ok(())
+}
+
+#[op2]
+fn op_update_panel(#[string] id: String, #[serde] rows: serde_json::Value) -> Result<(), AnyError> {
+    let rows = serde_json::from_value(rows)?;
+    ACTION_DISPATCHER.send_request(PluginRequest::UpdatePanel { id, rows });
+    Ok(())
+}
+
+#[op2(fast)]
+fn op_focus_panel(#[string] id: String) -> Result<(), AnyError> {
+    ACTION_DISPATCHER.send_request(PluginRequest::FocusPanel { id });
+    Ok(())
+}
+
+#[op2(fast)]
+fn op_focus_editor() -> Result<(), AnyError> {
+    ACTION_DISPATCHER.send_request(PluginRequest::FocusEditor);
+    Ok(())
+}
+
+#[op2(fast)]
+fn op_close_panel(#[string] id: String) -> Result<(), AnyError> {
+    ACTION_DISPATCHER.send_request(PluginRequest::ClosePanel { id });
+    Ok(())
+}
+
+#[op2(fast)]
+fn op_list_directory(#[string] path: String, request_id: i32) -> Result<(), AnyError> {
+    ACTION_DISPATCHER.send_request(PluginRequest::ListDirectory { path, request_id });
+    Ok(())
+}
+
+#[op2(fast)]
+fn op_watch_directory(#[string] path: String, watch_id: i32) -> Result<(), AnyError> {
+    ACTION_DISPATCHER.send_request(PluginRequest::WatchDirectory { path, watch_id });
+    Ok(())
+}
+
+#[op2(fast)]
+fn op_unwatch_directory(watch_id: i32) -> Result<(), AnyError> {
+    ACTION_DISPATCHER.send_request(PluginRequest::UnwatchDirectory { watch_id });
+    Ok(())
+}
+
 extension!(
     js_runtime,
     ops = [
@@ -637,6 +690,14 @@ extension!(
         op_create_overlay,
         op_update_overlay,
         op_remove_overlay,
+        op_create_panel,
+        op_update_panel,
+        op_focus_panel,
+        op_focus_editor,
+        op_close_panel,
+        op_list_directory,
+        op_watch_directory,
+        op_unwatch_directory,
     ],
     js = ["src/plugin/runtime.js"],
 );
diff --git a/src/window.rs b/src/window.rs
index 06a7b18..d38c994 100644
--- a/src/window.rs
+++ b/src/window.rs
@@ -310,8 +310,12 @@ impl WindowManager {
 
     /// Updates the layout when terminal is resized
     pub fn resize(&mut self, terminal_size: (usize, usize)) {
+        self.resize_with_origin(Point::new(0, 0), terminal_size);
+    }
+
+    pub fn resize_with_origin(&mut self, position: Point, terminal_size: (usize, usize)) {
         self.root.layout(
-            Point::new(0, 0),
+            position,
             (terminal_size.0, terminal_size.1.saturating_sub(2)),
         );
     }

From 8f06ddb4c2c4ad9f127646895cf266927b76544f Mon Sep 17 00:00:00 2001
From: Felipe Coury <felipe.coury@gmail.com>
Date: Sat, 9 May 2026 01:04:21 -0300
Subject: [PATCH 23/37] fix(tui): clamp cursor at end of file

Clamp viewport and cursor state after movement actions so commands that
overshoot the buffer cannot land past the final navigable line.

Cover `G`, oversized line jumps, direct cursor positioning, paging, and
scrolling against files that end with a trailing newline.
---
 src/editor.rs     | 110 ++++++++++++++++++++++++----------------------
 tests/movement.rs |  54 +++++++++++++++++++++++
 2 files changed, 112 insertions(+), 52 deletions(-)

diff --git a/src/editor.rs b/src/editor.rs
index 95f6f52..297f2d6 100644
--- a/src/editor.rs
+++ b/src/editor.rs
@@ -1115,7 +1115,37 @@ impl Editor {
 
     // TODO: in neovim, when you are at an x position and you move to a shorter line, the cursor
     //       goes back to the max x but returns to the previous x position if the line is longer
-    fn check_bounds(&mut self) {
+    fn last_buffer_line(&self) -> usize {
+        self.current_buffer().len()
+    }
+
+    fn last_navigable_line(&self) -> usize {
+        let last_line = self.current_buffer().len();
+        if last_line > 0
+            && self
+                .current_buffer()
+                .get(last_line)
+                .is_some_and(|line| line.is_empty())
+        {
+            last_line - 1
+        } else {
+            last_line
+        }
+    }
+
+    fn check_bounds(&mut self) -> bool {
+        let old_position = (self.cx, self.cy, self.vtop);
+        let last_line = self.last_buffer_line();
+        let viewport_height = self.vheight().max(1);
+        let max_vtop = last_line.saturating_sub(viewport_height.saturating_sub(1));
+
+        self.vtop = self.vtop.min(max_vtop);
+
+        let buffer_line = (self.vtop + self.cy).min(last_line);
+        self.cy = buffer_line
+            .saturating_sub(self.vtop)
+            .min(viewport_height.saturating_sub(1));
+
         let line_length = self.line_length();
 
         if self.cx > line_length && self.is_normal() {
@@ -1125,16 +1155,12 @@ impl Editor {
                 self.cx = 0;
             }
         }
-        if self.cx >= self.vwidth() {
-            self.cx = self.vwidth() - 1;
+        let viewport_width = self.vwidth();
+        if viewport_width > 0 && self.cx >= viewport_width {
+            self.cx = viewport_width - 1;
         }
 
-        // check if cy is after the end of the buffer
-        // the end of the buffer is less than vtop + cy
-        let line_on_buffer = self.cy + self.vtop;
-        if line_on_buffer > self.current_buffer().len() {
-            self.cy = self.current_buffer().len().saturating_sub(self.vtop);
-        }
+        old_position != (self.cx, self.cy, self.vtop)
     }
 
     /// Starts the main editor loop
@@ -2611,7 +2637,7 @@ impl Editor {
                 self.render(buffer)?;
             }
             Action::MoveToBottom => {
-                let last_line = self.current_buffer().len();
+                let last_line = self.last_navigable_line();
                 let line_count = last_line + 1;
                 if line_count > self.vheight() {
                     self.cy = self.vheight() - 1;
@@ -2855,7 +2881,9 @@ impl Editor {
             }
             Action::SetCursor(x, y) => {
                 self.cx = *x;
-                self.cy = *y;
+                let target_y = (*y).min(self.last_navigable_line());
+                self.vtop = target_y.saturating_sub(self.vheight().saturating_sub(1));
+                self.cy = target_y.saturating_sub(self.vtop);
             }
             Action::ScrollUp => {
                 let scroll_lines = self.config.mouse_scroll_lines.unwrap_or(3);
@@ -2905,7 +2933,7 @@ impl Editor {
             Action::MoveLineToViewportBottom => {
                 let line = self.buffer_line();
                 if line > self.vtop + self.vheight() {
-                    self.vtop = line - self.vheight();
+                    self.vtop = line.saturating_sub(self.vheight().saturating_sub(1));
                     self.cy = self.vheight() - 1;
                     self.render(buffer)?;
                 }
@@ -3421,6 +3449,10 @@ impl Editor {
             }
         }
 
+        if self.check_bounds() {
+            self.render(buffer)?;
+        }
+
         if add_to_history {
             self.save_to_history(action);
         }
@@ -3865,45 +3897,27 @@ impl Editor {
         &mut self,
         line: usize,
         buffer: &mut RenderBuffer,
-        runtime: &mut Runtime,
+        _runtime: &mut Runtime,
         pos: GoToLinePosition,
     ) -> anyhow::Result<()> {
         if line == 0 {
-            self.execute(&Action::MoveToTop, buffer, runtime).await?;
+            self.vtop = 0;
+            self.cy = 0;
+            self.render(buffer)?;
             return Ok(());
         }
 
-        if line <= self.current_buffer().len() + 1 {
-            let y = line - 1;
+        let y = line.saturating_sub(1).min(self.last_navigable_line());
+        let viewport_height = self.vheight().max(1);
 
-            if self.is_within_viewport(y) {
-                self.cy = y - self.vtop;
-            } else if self.is_within_first_page(y) {
-                self.vtop = 0;
-                self.cy = y;
-                self.render(buffer)?;
-            } else if self.is_within_last_page(y) {
-                self.vtop = (self.current_buffer().len() + 1).saturating_sub(self.vheight());
-                self.cy = y - self.vtop;
-                self.render(buffer)?;
-            } else {
-                if matches!(pos, GoToLinePosition::Bottom) {
-                    self.vtop = y - self.vheight();
-                    self.cy = self.buffer_line() - self.vtop;
-                } else {
-                    self.vtop = y;
-                    self.cy = 0;
-                    if matches!(pos, GoToLinePosition::Center) {
-                        self.execute(&Action::MoveLineToViewportCenter, buffer, runtime)
-                            .await?;
-                    }
-                }
-
-                // FIXME: this is wasteful when move to viewport center worked
-                // but we have to account for the case where it didn't and also
-                self.render(buffer)?;
-            }
-        }
+        self.vtop = match pos {
+            GoToLinePosition::Top => y,
+            GoToLinePosition::Center => y.saturating_sub(viewport_height / 2),
+            GoToLinePosition::Bottom => y.saturating_sub(viewport_height.saturating_sub(1)),
+        };
+        self.cy = y.saturating_sub(self.vtop);
+        self.check_bounds();
+        self.render(buffer)?;
 
         Ok(())
     }
@@ -3937,14 +3951,6 @@ impl Editor {
         (self.vtop..self.vtop + self.vheight()).contains(&y)
     }
 
-    fn is_within_last_page(&self, y: usize) -> bool {
-        y >= (self.current_buffer().len() + 1).saturating_sub(self.vheight())
-    }
-
-    fn is_within_first_page(&self, y: usize) -> bool {
-        y < self.vheight()
-    }
-
     fn event_to_key_action(
         &mut self,
         mappings: &HashMap<String, KeyAction>,
diff --git a/tests/movement.rs b/tests/movement.rs
index b94c71f..4b7680b 100644
--- a/tests/movement.rs
+++ b/tests/movement.rs
@@ -177,6 +177,60 @@ async fn test_goto_line() {
     harness.assert_cursor_at(0, 0);
 }
 
+#[tokio::test]
+async fn test_movement_clamps_to_last_real_line_with_trailing_newline() {
+    let mut harness = EditorHarness::with_content("Line 1\nLine 2\nLine 3\n");
+
+    harness.execute_action(Action::MoveToBottom).await.unwrap();
+    harness.assert_cursor_at(0, 2);
+    assert_eq!(harness.current_line(), Some("Line 3\n".to_string()));
+
+    harness.execute_action(Action::GoToLine(999)).await.unwrap();
+    harness.assert_cursor_at(0, 2);
+    assert_eq!(harness.current_line(), Some("Line 3\n".to_string()));
+
+    harness
+        .execute_action(Action::MoveTo(0, 999))
+        .await
+        .unwrap();
+    harness.assert_cursor_at(0, 2);
+    assert_eq!(harness.current_line(), Some("Line 3\n".to_string()));
+
+    harness
+        .execute_action(Action::SetCursor(0, 999))
+        .await
+        .unwrap();
+    harness.assert_cursor_at(0, 2);
+    assert_eq!(harness.current_line(), Some("Line 3\n".to_string()));
+}
+
+#[tokio::test]
+async fn test_scrolling_clamps_to_last_real_line() {
+    let content = (1..=8)
+        .map(|line| format!("Line {line}"))
+        .collect::<Vec<_>>()
+        .join("\n")
+        + "\n";
+    let mut harness = EditorHarness::with_content(&content);
+    harness.editor.test_set_size(80, 6);
+
+    for _ in 0..10 {
+        harness.execute_action(Action::PageDown).await.unwrap();
+    }
+    assert!(harness.buffer_line() <= 7);
+    assert_ne!(harness.current_line(), Some(String::new()));
+
+    harness.execute_action(Action::MoveToBottom).await.unwrap();
+    assert_eq!(harness.buffer_line(), 7);
+    assert_eq!(harness.current_line(), Some("Line 8\n".to_string()));
+
+    for _ in 0..10 {
+        harness.execute_action(Action::ScrollDown).await.unwrap();
+    }
+    assert_eq!(harness.buffer_line(), 7);
+    assert_eq!(harness.current_line(), Some("Line 8\n".to_string()));
+}
+
 #[tokio::test]
 async fn test_movement_preserves_mode() {
     let mut harness = EditorHarness::with_content("Hello\nWorld");

From 9aef6cd7fc1e9bfc7181214afec7a3f384e884a1 Mon Sep 17 00:00:00 2001
From: Felipe Coury <felipe.coury@gmail.com>
Date: Sat, 9 May 2026 01:07:40 -0300
Subject: [PATCH 24/37] fix(tui): preserve viewport during word motion

Keep `w` and `b` from scrolling when their destination line is already
visible. Word movement should update the cursor within the current viewport
and only scroll when the target word is offscreen.

Add a movement regression that asserts both next-word and previous-word
motions preserve `vtop` for visible targets.
---
 src/editor.rs                  | 16 ++++++++++++----
 tests/common/editor_harness.rs |  4 ++++
 tests/movement.rs              | 31 +++++++++++++++++++++++++++++++
 3 files changed, 47 insertions(+), 4 deletions(-)

diff --git a/src/editor.rs b/src/editor.rs
index 297f2d6..9bcdfc9 100644
--- a/src/editor.rs
+++ b/src/editor.rs
@@ -2913,8 +2913,12 @@ impl Editor {
 
                 if let Some((x, y)) = next_word {
                     self.cx = x;
-                    self.go_to_line(y + 1, buffer, runtime, GoToLinePosition::Top)
-                        .await?;
+                    if self.is_within_viewport(y) {
+                        self.cy = y - self.vtop;
+                    } else {
+                        self.go_to_line(y + 1, buffer, runtime, GoToLinePosition::Top)
+                            .await?;
+                    }
                     self.draw_cursor()?;
                 }
             }
@@ -2925,8 +2929,12 @@ impl Editor {
 
                 if let Some((x, y)) = previous_word {
                     self.cx = x;
-                    self.go_to_line(y + 1, buffer, runtime, GoToLinePosition::Top)
-                        .await?;
+                    if self.is_within_viewport(y) {
+                        self.cy = y - self.vtop;
+                    } else {
+                        self.go_to_line(y + 1, buffer, runtime, GoToLinePosition::Top)
+                            .await?;
+                    }
                     self.draw_cursor()?;
                 }
             }
diff --git a/tests/common/editor_harness.rs b/tests/common/editor_harness.rs
index b4c04eb..36d9245 100644
--- a/tests/common/editor_harness.rs
+++ b/tests/common/editor_harness.rs
@@ -155,6 +155,10 @@ impl EditorHarness {
         self.editor.test_buffer_line()
     }
 
+    pub fn viewport_top(&self) -> usize {
+        self.editor.test_vtop()
+    }
+
     pub fn active_window_id(&self) -> usize {
         self.editor.test_active_window_id()
     }
diff --git a/tests/movement.rs b/tests/movement.rs
index 4b7680b..0416206 100644
--- a/tests/movement.rs
+++ b/tests/movement.rs
@@ -69,6 +69,37 @@ async fn test_word_movement() {
     harness.assert_cursor_at(6, 0); // Back at 'w' of 'world'
 }
 
+#[tokio::test]
+async fn test_word_movement_preserves_visible_viewport() {
+    let content = (1..=20)
+        .map(|line| {
+            if line == 8 {
+                "alpha beta gamma".to_string()
+            } else {
+                format!("Line {line}")
+            }
+        })
+        .collect::<Vec<_>>()
+        .join("\n");
+    let mut harness = EditorHarness::with_content(&content);
+    harness.execute_action(Action::GoToLine(8)).await.unwrap();
+    let viewport_top = harness.viewport_top();
+
+    harness
+        .execute_action(Action::MoveToNextWord)
+        .await
+        .unwrap();
+    harness.assert_cursor_at(6, 7);
+    assert_eq!(harness.viewport_top(), viewport_top);
+
+    harness
+        .execute_action(Action::MoveToPreviousWord)
+        .await
+        .unwrap();
+    harness.assert_cursor_at(0, 7);
+    assert_eq!(harness.viewport_top(), viewport_top);
+}
+
 #[tokio::test]
 async fn test_file_movement() {
     let mut harness = EditorHarness::with_content("Line 1\nLine 2\nLine 3\nLine 4\nLine 5");

From 0390feb35119c450ab739f8569fb08be456ac821 Mon Sep 17 00:00:00 2001
From: Felipe Coury <felipe.coury@gmail.com>
Date: Sat, 9 May 2026 01:12:13 -0300
Subject: [PATCH 25/37] fix(tui): handle edge movement and visual selection

Allow page movement to use partial pages at file edges so `Ctrl-b` and
`Ctrl-f` land on the top or final navigable line instead of refusing to
move when a full page is unavailable.

Fix visual selection rendering to include the final visible character on
selected lines and resolve selection line lengths against buffer lines.
---
 src/editor.rs           | 28 ++++++++++++++++++----------
 src/editor/rendering.rs |  6 +++---
 tests/movement.rs       | 20 ++++++++++++++++++++
 3 files changed, 41 insertions(+), 13 deletions(-)

diff --git a/src/editor.rs b/src/editor.rs
index 9bcdfc9..2e85d8d 100644
--- a/src/editor.rs
+++ b/src/editor.rs
@@ -882,13 +882,17 @@ impl Editor {
     }
 
     fn length_for_line(&self, n: usize) -> usize {
-        if let Some(line) = self.viewport_line(n) {
+        if let Some(line) = self.current_buffer().get(n) {
             let line = line.trim_end_matches('\n');
-            return line.chars().count();
+            return grapheme_len(line);
         }
         0
     }
 
+    fn last_cell_for_line(&self, n: usize) -> usize {
+        self.length_for_line(n).saturating_sub(1)
+    }
+
     /// Returns the current buffer y position
     fn buffer_line(&self) -> usize {
         self.vtop + self.cy
@@ -2321,16 +2325,20 @@ impl Editor {
                 }
             }
             Action::PageUp => {
-                if self.vtop > 0 {
-                    self.vtop = self.vtop.saturating_sub(self.vheight());
-                    self.render(buffer)?;
-                }
+                let target_line = self
+                    .buffer_line()
+                    .saturating_sub(self.vheight())
+                    .min(self.last_navigable_line());
+                self.vtop = target_line.saturating_sub(self.vheight().saturating_sub(1));
+                self.cy = target_line.saturating_sub(self.vtop);
+                self.render(buffer)?;
             }
             Action::PageDown => {
-                if self.current_buffer().len() > self.vtop + self.vheight() {
-                    self.vtop += self.vheight();
-                    self.render(buffer)?;
-                }
+                let target_line =
+                    (self.buffer_line() + self.vheight()).min(self.last_navigable_line());
+                self.vtop = target_line.saturating_sub(self.vheight().saturating_sub(1));
+                self.cy = target_line.saturating_sub(self.vtop);
+                self.render(buffer)?;
             }
             Action::EnterMode(new_mode) => {
                 add_to_history = false;
diff --git a/src/editor/rendering.rs b/src/editor/rendering.rs
index 94b3339..63e9be2 100644
--- a/src/editor/rendering.rs
+++ b/src/editor/rendering.rs
@@ -834,14 +834,14 @@ impl Editor {
                     if y == selection.y0 && y == selection.y1 {
                         (selection.x0, selection.x1)
                     } else if y == selection.y0 {
-                        (selection.x0, self.length_for_line(y))
+                        (selection.x0, self.last_cell_for_line(y))
                     } else if y == selection.y1 {
                         (0, selection.x1)
                     } else {
-                        (0, self.length_for_line(y))
+                        (0, self.last_cell_for_line(y))
                     }
                 }
-                Mode::VisualLine => (0, self.length_for_line(y).saturating_sub(2)),
+                Mode::VisualLine => (0, self.last_cell_for_line(y)),
                 Mode::VisualBlock => (selection.x0, selection.x1),
                 _ => unreachable!(),
             };
diff --git a/tests/movement.rs b/tests/movement.rs
index 0416206..66fbf9c 100644
--- a/tests/movement.rs
+++ b/tests/movement.rs
@@ -190,6 +190,26 @@ async fn test_page_movement() {
     assert!(y3 < y2, "Cursor should move up on PageUp");
 }
 
+#[tokio::test]
+async fn test_page_movement_uses_partial_pages_at_file_edges() {
+    let content = (1..=10)
+        .map(|line| format!("Line {line}"))
+        .collect::<Vec<_>>()
+        .join("\n");
+    let mut harness = EditorHarness::with_content(&content);
+    harness.editor.test_set_size(80, 7);
+
+    harness.execute_action(Action::GoToLine(8)).await.unwrap();
+    harness.execute_action(Action::PageDown).await.unwrap();
+    harness.assert_cursor_at(0, 9);
+    assert_eq!(harness.current_line(), Some("Line 10".to_string()));
+
+    harness.execute_action(Action::GoToLine(3)).await.unwrap();
+    harness.execute_action(Action::PageUp).await.unwrap();
+    harness.assert_cursor_at(0, 0);
+    assert_eq!(harness.current_line(), Some("Line 1\n".to_string()));
+}
+
 #[tokio::test]
 async fn test_goto_line() {
     let mut harness = EditorHarness::with_content("Line 1\nLine 2\nLine 3\nLine 4\nLine 5");

From 19a011fd850104552b2ad3b4b0d2f7171cdba2fb Mon Sep 17 00:00:00 2001
From: Felipe Coury <felipe.coury@gmail.com>
Date: Sat, 9 May 2026 01:16:42 -0300
Subject: [PATCH 26/37] fix(tui): make line end motion visual-aware

Move `$` to the final visible character instead of one cell past the end
of the line, while keeping append-at-end behavior by moving right before
entering insert mode for `A`.

Bind `$` and `End` in visual modes so visual selections can extend to the
line end, and update movement and append tests for the new cursor behavior.
---
 default_config.toml          | 6 +++++-
 src/editor.rs                | 2 +-
 tests/editing.rs             | 1 +
 tests/movement.rs            | 6 +++---
 tests/test_emoji_handling.rs | 1 +
 5 files changed, 11 insertions(+), 5 deletions(-)

diff --git a/default_config.toml b/default_config.toml
index 9af0fc4..65a293c 100644
--- a/default_config.toml
+++ b/default_config.toml
@@ -61,7 +61,7 @@ Esc = { EnterMode = "Normal" }
 "n" = [ "FindNext" ]
 "N" = [ "FindPrevious" ]
 "a" = [ { EnterMode = "Insert" }, "MoveRight" ]
-"A" = [ { EnterMode = "Insert" }, "MoveToLineEnd" ]
+"A" = [ "MoveToLineEnd", "MoveRight", { EnterMode = "Insert" } ]
 "i" = { EnterMode = "Insert" }
 "I" = [ { EnterMode = "Insert" }, "MoveToFirstLineChar" ]
 ";" = { EnterMode = "Command" }
@@ -138,6 +138,8 @@ Esc = { EnterMode = "Normal" }
 "j" = "MoveDown"
 "h" = "MoveLeft"
 "l" = "MoveRight"
+"$" = "MoveToLineEnd"
+"End" = "MoveToLineEnd"
 "y" = [ "Yank", { EnterMode = "Normal" } ]
 "x" = [ "Delete", { EnterMode = "Normal" } ]
 "p" = [ "Paste", { EnterMode = "Normal" } ]
@@ -152,6 +154,8 @@ Esc = { EnterMode = "Normal" }
 
 [keys.visual_block]
 Esc = { EnterMode = "Normal" }
+"$" = "MoveToLineEnd"
+"End" = "MoveToLineEnd"
 
 [keys.visual_line]
 Esc = { EnterMode = "Normal" }
diff --git a/src/editor.rs b/src/editor.rs
index 2e85d8d..25833f0 100644
--- a/src/editor.rs
+++ b/src/editor.rs
@@ -2302,7 +2302,7 @@ impl Editor {
                 self.cx = 0;
             }
             Action::MoveToLineEnd => {
-                self.cx = self.line_length();
+                self.cx = self.line_length().saturating_sub(1);
             }
             Action::MoveToFirstLineChar => {
                 if let Some(line) = self.current_line_contents() {
diff --git a/tests/editing.rs b/tests/editing.rs
index 704c57a..b6e6960 100644
--- a/tests/editing.rs
+++ b/tests/editing.rs
@@ -325,6 +325,7 @@ async fn test_append_at_line_end() {
 
     // Append at end of line with 'A' - move to end and enter insert
     harness.execute_action(Action::MoveToLineEnd).await.unwrap();
+    harness.execute_action(Action::MoveRight).await.unwrap();
     harness
         .execute_action(Action::EnterMode(Mode::Insert))
         .await
diff --git a/tests/movement.rs b/tests/movement.rs
index 66fbf9c..95182b0 100644
--- a/tests/movement.rs
+++ b/tests/movement.rs
@@ -33,7 +33,7 @@ async fn test_line_movement() {
 
     // Move to end of line ($)
     harness.execute_action(Action::MoveToLineEnd).await.unwrap();
-    harness.assert_cursor_at(13, 0); // "Hello, World!" is 13 chars, cursor after last char
+    harness.assert_cursor_at(12, 0); // "Hello, World!" is 13 chars, cursor on '!'
 
     // Move to start of line (0)
     harness
@@ -132,8 +132,8 @@ async fn test_movement_boundaries() {
     harness.execute_action(Action::MoveToBottom).await.unwrap();
     harness.execute_action(Action::MoveToLineEnd).await.unwrap();
     // MoveToBottom goes to line 1 (last line) for "abc\ndef"
-    // MoveToLineEnd on "def" puts us at position 3
-    harness.assert_cursor_at(3, 1); // After 'f' in "def"
+    // MoveToLineEnd on "def" puts us on the last character
+    harness.assert_cursor_at(2, 1); // On 'f' in "def"
 
     // Try to move right at end of line
     harness.execute_action(Action::MoveRight).await.unwrap();
diff --git a/tests/test_emoji_handling.rs b/tests/test_emoji_handling.rs
index b62465a..37d91e4 100644
--- a/tests/test_emoji_handling.rs
+++ b/tests/test_emoji_handling.rs
@@ -59,6 +59,7 @@ async fn test_insert_at_end_of_emoji_line() {
 
     // Move to end of line
     harness.execute_action(Action::MoveToLineEnd).await.unwrap();
+    harness.execute_action(Action::MoveRight).await.unwrap();
 
     // Enter insert mode
     harness

From 7c627962ab8d1db3b1120d742f645eeb49a938a9 Mon Sep 17 00:00:00 2001
From: Felipe Coury <felipe.coury@gmail.com>
Date: Sat, 9 May 2026 01:18:56 -0300
Subject: [PATCH 27/37] fix(tui): clamp insert escape at line end

When leaving insert mode, move a one-past-end cursor back onto the final
visible character so normal mode does not remain past the line end.

Keep insert mode free to use one-past-end positions while editing and add a
regression for escaping from an append-at-end cursor.
---
 src/editor.rs    |  4 ++++
 tests/editing.rs | 19 +++++++++++++++++++
 2 files changed, 23 insertions(+)

diff --git a/src/editor.rs b/src/editor.rs
index 25833f0..34dd357 100644
--- a/src/editor.rs
+++ b/src/editor.rs
@@ -2364,6 +2364,10 @@ impl Editor {
                     self.undo_actions.push(Action::UndoMultiple(actions));
                 }
 
+                if self.is_insert() && matches!(new_mode, Mode::Normal) {
+                    self.cx = self.cx.min(self.line_length().saturating_sub(1));
+                }
+
                 if matches!(new_mode, Mode::Search) {
                     self.search_term = String::new();
                 }
diff --git a/tests/editing.rs b/tests/editing.rs
index b6e6960..7cb4cd4 100644
--- a/tests/editing.rs
+++ b/tests/editing.rs
@@ -343,6 +343,25 @@ async fn test_append_at_line_end() {
         .unwrap();
 }
 
+#[tokio::test]
+async fn test_escape_from_insert_clamps_to_last_line_character() {
+    let mut harness = EditorHarness::with_content("Hello");
+
+    harness.execute_action(Action::MoveToLineEnd).await.unwrap();
+    harness.execute_action(Action::MoveRight).await.unwrap();
+    harness
+        .execute_action(Action::EnterMode(Mode::Insert))
+        .await
+        .unwrap();
+    harness.assert_cursor_at(5, 0);
+
+    harness
+        .execute_action(Action::EnterMode(Mode::Normal))
+        .await
+        .unwrap();
+    harness.assert_cursor_at(4, 0);
+}
+
 #[tokio::test]
 async fn test_delete_word() {
     let mut harness = EditorHarness::with_content("Hello World Test");

From 74a33dacfe2e456a0e21603470bf2270ecd443d7 Mon Sep 17 00:00:00 2001
From: Felipe Coury <felipe.coury@gmail.com>
Date: Sat, 9 May 2026 01:39:27 -0300
Subject: [PATCH 28/37] feat(tui): replace undo history with transactions

Add buffer-local transaction undo and redo backed by text edit ranges.
Route editor and plugin mutations through the transaction path so insert
sessions, deletes, visual edits, paste, indent, and redo share one model.

Track clean revisions in the undo history so the dirty indicator clears
when undo returns a buffer to its saved state and updates after save.
---
 default_config.toml            |   1 +
 src/buffer.rs                  |  66 +++-
 src/editor.rs                  | 628 ++++++++++++++++++++-------------
 src/fixtures/config.toml       |   1 +
 src/lib.rs                     |   1 +
 src/undo.rs                    | 215 +++++++++++
 tests/common/editor_harness.rs |   4 +
 tests/editing.rs               | 415 +++++++++++++++++++++-
 8 files changed, 1086 insertions(+), 245 deletions(-)
 create mode 100644 src/undo.rs

diff --git a/default_config.toml b/default_config.toml
index 65a293c..eb96ad0 100644
--- a/default_config.toml
+++ b/default_config.toml
@@ -38,6 +38,7 @@ Esc = { EnterMode = "Normal" }
 "G" = "MoveToBottom"
 "g" = { "g" = "MoveToTop", "d" = "GoToDefinition" }
 "u" = "Undo"
+"Ctrl-r" = "Redo"
 "Down" = "MoveDown"
 "Left" = "MoveLeft"
 "Right" = "MoveRight"
diff --git a/src/buffer.rs b/src/buffer.rs
index 10ebddc..4324eef 100644
--- a/src/buffer.rs
+++ b/src/buffer.rs
@@ -4,6 +4,7 @@ use std::path::Path;
 use path_absolutize::Absolutize;
 
 use crate::lsp::LspClient;
+use crate::undo::{TextPosition, TextRange, UndoHistory};
 use crate::unicode_utils::{char_to_column, column_to_char, display_width};
 
 /// Buffer represents an editable text buffer, which may be associated with a file.
@@ -24,6 +25,9 @@ pub struct Buffer {
 
     /// Top line number of the viewport (for scrolling)
     pub vtop: usize,
+
+    /// Buffer-local undo and redo history.
+    pub undo_history: UndoHistory,
 }
 
 impl Buffer {
@@ -41,6 +45,7 @@ impl Buffer {
             dirty: false,
             pos: (0, 0),
             vtop: 0,
+            undo_history: UndoHistory::default(),
         }
     }
 
@@ -114,10 +119,10 @@ impl Buffer {
 
     /// Saves the buffer contents to its associated file
     pub fn save(&mut self) -> anyhow::Result<String> {
-        if let Some(file) = &self.file {
+        if let Some(file) = self.file.clone() {
             let contents = self.contents();
-            std::fs::write(file, &contents)?;
-            self.dirty = false;
+            std::fs::write(&file, &contents)?;
+            self.mark_saved();
             let message = format!("{:?} {}L, {}B written", file, self.len(), contents.len());
             Ok(message)
         } else {
@@ -129,8 +134,8 @@ impl Buffer {
     pub fn save_as(&mut self, new_file_name: &str) -> anyhow::Result<String> {
         let contents = self.contents();
         std::fs::write(new_file_name, &contents)?;
-        self.dirty = false;
         self.file = Some(new_file_name.to_string());
+        self.mark_saved();
         let message = format!(
             "{:?} {}L, {}B written",
             new_file_name,
@@ -242,6 +247,50 @@ impl Buffer {
         self.dirty = true;
     }
 
+    pub fn text_in_range(&self, range: TextRange) -> String {
+        let start_char = self.position_to_char_idx(range.start);
+        let end_char = self.position_to_char_idx(range.end);
+        self.content
+            .get_slice(start_char..end_char)
+            .map(|slice| slice.to_string())
+            .unwrap_or_default()
+    }
+
+    pub fn replace_range_raw(&mut self, range: TextRange, text: &str) {
+        let start_char = self.position_to_char_idx(range.start);
+        let end_char = self.position_to_char_idx(range.end);
+        self.content.remove(start_char..end_char);
+        self.content.insert(start_char, text);
+        self.dirty = true;
+    }
+
+    pub fn range_for_text(&self, start: TextPosition, text: &str) -> TextRange {
+        let mut line = start.line;
+        let mut character = start.character;
+
+        for c in text.chars() {
+            if c == '\n' {
+                line += 1;
+                character = 0;
+            } else {
+                character += 1;
+            }
+        }
+
+        TextRange::new(start, TextPosition::new(line, character))
+    }
+
+    pub fn position_to_char_idx(&self, position: TextPosition) -> usize {
+        if position.line >= self.content.len_lines() {
+            return self.content.len_chars();
+        }
+
+        let line_start = self.content.line_to_char(position.line);
+        let line = self.content.line(position.line).to_string();
+        let line_len = line.trim_end_matches('\n').chars().count();
+        line_start + position.character.min(line_len)
+    }
+
     /// Inserts a new line at the given line number
     pub fn insert_line(&mut self, y: usize, content: String) {
         let char_idx = if y >= self.content.len_lines() {
@@ -627,6 +676,15 @@ impl Buffer {
         self.dirty
     }
 
+    pub fn refresh_dirty_from_history(&mut self) {
+        self.dirty = self.undo_history.is_dirty();
+    }
+
+    pub fn mark_saved(&mut self) {
+        self.undo_history.mark_saved();
+        self.refresh_dirty_from_history();
+    }
+
     // Helper method to convert (x,y) coordinates to character index in the rope
     fn xy_to_char_idx(&self, x: usize, y: usize) -> usize {
         if y >= self.content.len_lines() {
diff --git a/src/editor.rs b/src/editor.rs
index 34dd357..ea90269 100644
--- a/src/editor.rs
+++ b/src/editor.rs
@@ -5,7 +5,6 @@ use std::{
     cmp::Ordering,
     collections::{HashMap, VecDeque},
     io::stdout,
-    mem,
     path::PathBuf,
     time::{Duration, Instant},
 };
@@ -59,6 +58,7 @@ use crate::{
     plugin::{self, PluginRegistry, Runtime},
     theme::{Style, Theme},
     ui::{CompletionUI, Component, FilePicker, Info, Picker},
+    undo::{CursorSnapshot, TextPosition, TextRange},
     utils::get_workspace_uri,
     window::WindowManager,
 };
@@ -189,7 +189,7 @@ pub enum Action {
     EnterMode(Mode),
 
     Undo,
-    UndoMultiple(Vec<Action>),
+    Redo,
     InsertString(String),
 
     FindNext,
@@ -472,12 +472,6 @@ pub struct Editor {
     /// Executed actions
     actions: Vec<Action>,
 
-    /// Stack of actions that can be undone
-    undo_actions: Vec<Action>,
-
-    /// Actions to be combined into a single undo for insert mode
-    insert_undo_actions: Vec<Action>,
-
     /// Current command line content
     command: String,
 
@@ -610,6 +604,15 @@ pub struct Content {
     text: String,
 }
 
+impl Content {
+    pub fn charwise(text: String) -> Self {
+        Self {
+            kind: ContentKind::Charwise,
+            text,
+        }
+    }
+}
+
 impl Editor {
     #[allow(unused)]
     pub fn with_size(
@@ -658,8 +661,6 @@ impl Editor {
             waiting_key_action: None,
             pending_select_action: None,
             actions: vec![],
-            undo_actions: vec![],
-            insert_undo_actions: vec![],
             command: String::new(),
             search_term: String::new(),
             last_error: None,
@@ -1289,69 +1290,38 @@ impl Editor {
                                 // self.render(buffer)?;
                             }
                             PluginRequest::BufferInsert { x, y, text } => {
-                                // Track undo action
-                                self.undo_actions.push(Action::DeleteRange(x, y, x + text.chars().count(), y));
-
-                                self.current_buffer_mut().insert_str(x, y, &text);
+                                self.begin_transaction("plugin insert");
+                                self.replace_range(
+                                    TextRange::insertion(TextPosition::new(y, x)),
+                                    &text,
+                                );
+                                self.commit_transaction(self.cursor_snapshot());
                                 self.notify_change(&mut runtime).await?;
                                 self.render(&mut buffer)?;
                             }
                             PluginRequest::BufferDelete { x, y, length } => {
-                                // Save deleted text for undo
-                                let current_buf = self.current_buffer();
-                                let mut deleted_text = String::new();
-                                for i in 0..length {
-                                    if let Some(line) = current_buf.get(y) {
-                                        if x + i < line.chars().count() {
-                                            deleted_text.push(line.chars().nth(x + i).unwrap_or(' '));
-                                        }
-                                    }
-                                }
-                                self.undo_actions.push(Action::InsertText {
-                                    x,
-                                    y,
-                                    content: Content {
-                                        kind: ContentKind::Charwise,
-                                        text: deleted_text
-                                    }
-                                });
-
-                                for _ in 0..length {
-                                    self.current_buffer_mut().remove(x, y);
-                                }
+                                self.begin_transaction("plugin delete");
+                                self.replace_range(
+                                    TextRange::new(
+                                        TextPosition::new(y, x),
+                                        TextPosition::new(y, x + length),
+                                    ),
+                                    "",
+                                );
+                                self.commit_transaction(self.cursor_snapshot());
                                 self.notify_change(&mut runtime).await?;
                                 self.render(&mut buffer)?;
                             }
                             PluginRequest::BufferReplace { x, y, length, text } => {
-                                // Save replaced text for undo
-                                let current_buf = self.current_buffer();
-                                let mut replaced_text = String::new();
-                                for i in 0..length {
-                                    if let Some(line) = current_buf.get(y) {
-                                        if x + i < line.chars().count() {
-                                            replaced_text.push(line.chars().nth(x + i).unwrap_or(' '));
-                                        }
-                                    }
-                                }
-                                // For undo, we need to delete the new text and insert the old
-                                self.undo_actions.push(Action::UndoMultiple(vec![
-                                    Action::DeleteRange(x, y, x + text.chars().count(), y),
-                                    Action::InsertText {
-                                        x,
-                                        y,
-                                        content: Content {
-                                            kind: ContentKind::Charwise,
-                                            text: replaced_text
-                                        }
-                                    }
-                                ]));
-
-                                // Delete old text
-                                for _ in 0..length {
-                                    self.current_buffer_mut().remove(x, y);
-                                }
-                                // Insert new text
-                                self.current_buffer_mut().insert_str(x, y, &text);
+                                self.begin_transaction("plugin replace");
+                                self.replace_range(
+                                    TextRange::new(
+                                        TextPosition::new(y, x),
+                                        TextPosition::new(y, x + length),
+                                    ),
+                                    &text,
+                                );
+                                self.commit_transaction(self.cursor_snapshot());
                                 self.notify_change(&mut runtime).await?;
                                 self.render(&mut buffer)?;
                             }
@@ -2350,22 +2320,15 @@ impl Editor {
                     self.execute(&select_action.action, buffer, runtime).await?;
                 }
 
-                // TODO: with the introduction of new modes, maybe this transtion
-                // needs to be widened to anything -> insert and anything -> normal
                 if self.is_normal() && matches!(new_mode, Mode::Insert) {
-                    self.insert_undo_actions = Vec::new();
-                }
-
-                if self.is_insert()
-                    && matches!(new_mode, Mode::Normal)
-                    && !self.insert_undo_actions.is_empty()
-                {
-                    let actions = mem::take(&mut self.insert_undo_actions);
-                    self.undo_actions.push(Action::UndoMultiple(actions));
+                    self.begin_transaction("insert");
                 }
 
                 if self.is_insert() && matches!(new_mode, Mode::Normal) {
                     self.cx = self.cx.min(self.line_length().saturating_sub(1));
+                    let after_cursor = self.cursor_snapshot();
+                    self.commit_transaction(after_cursor);
+                    self.cancel_transaction_if_empty();
                 }
 
                 if matches!(new_mode, Mode::Search) {
@@ -2406,8 +2369,10 @@ impl Editor {
             Action::InsertCharAtCursorPos(c) => {
                 use crate::log;
 
-                self.insert_undo_actions
-                    .push(Action::DeleteCharAt(self.cx, self.buffer_line()));
+                let started_transaction = !self.transaction_active();
+                if started_transaction {
+                    self.begin_transaction("insert char");
+                }
                 let line = self.buffer_line();
                 let cx = self.cx;
                 let char_cx = self.grapheme_to_char_on_line(cx, line);
@@ -2426,23 +2391,39 @@ impl Editor {
                     log!("Line char count: {}", line_content.chars().count());
                 }
 
-                self.current_buffer_mut().insert(char_cx, line, *c);
+                self.replace_range(
+                    TextRange::insertion(TextPosition::new(line, char_cx)),
+                    &c.to_string(),
+                );
                 self.notify_change(runtime).await?;
 
                 // Move cursor by one character position (not display width)
                 self.cx += grapheme_len(&c.to_string());
+                if started_transaction {
+                    self.commit_transaction(self.cursor_snapshot());
+                }
 
                 log!("Cursor after insert: cx = {}", self.cx);
 
                 self.draw_line(buffer);
             }
             Action::DeleteCharAt(x, y) => {
-                self.current_buffer_mut().remove(*x, *y);
+                self.begin_transaction("delete char");
+                self.replace_range(
+                    TextRange::new(TextPosition::new(*y, *x), TextPosition::new(*y, *x + 1)),
+                    "",
+                );
+                self.commit_transaction(self.cursor_snapshot());
                 self.notify_change(runtime).await?;
                 self.draw_line(buffer);
             }
             Action::DeleteRange(x0, y0, x1, y1) => {
-                self.current_buffer_mut().remove_range(*x0, *y0, *x1, *y1);
+                self.begin_transaction("delete range");
+                self.replace_range(
+                    TextRange::new(TextPosition::new(*y0, *x0), TextPosition::new(*y1, *x1)),
+                    "",
+                );
+                self.commit_transaction(self.cursor_snapshot());
                 self.notify_change(runtime).await?;
                 self.render(buffer)?;
             }
@@ -2459,37 +2440,43 @@ impl Editor {
                 });
 
                 if let Some(deleted) = deleted {
+                    let started_transaction = !self.transaction_active();
+                    if started_transaction {
+                        self.begin_transaction("delete char");
+                    }
                     let start = self.grapheme_to_char_on_line(cx, line);
                     let end = self.grapheme_to_char_on_line(cx + 1, line);
-                    self.current_buffer_mut()
-                        .remove_range(start, line, end, line);
+                    self.replace_range(
+                        TextRange::new(
+                            TextPosition::new(line, start),
+                            TextPosition::new(line, end),
+                        ),
+                        "",
+                    );
                     self.notify_change(runtime).await?;
-                    self.undo_actions.push(Action::InsertText {
-                        x: cx,
-                        y: line,
-                        content: Content {
-                            kind: ContentKind::Charwise,
-                            text: deleted,
-                        },
-                    });
+                    if started_transaction {
+                        self.commit_transaction(self.cursor_snapshot());
+                    }
+                    let _ = deleted;
                     self.draw_line(buffer);
                 }
             }
             Action::ReplaceLineAt(y, contents) => {
-                self.current_buffer_mut()
-                    .replace_line(*y, contents.to_string());
+                let line_len = self.length_for_line(*y);
+                self.begin_transaction("replace line");
+                self.replace_range(
+                    TextRange::new(TextPosition::new(*y, 0), TextPosition::new(*y, line_len)),
+                    contents,
+                );
+                self.commit_transaction(self.cursor_snapshot());
                 self.notify_change(runtime).await?;
                 self.draw_line(buffer);
             }
             Action::InsertNewLine => {
-                self.insert_undo_actions.extend(vec![
-                    Action::MoveTo(self.cx, self.buffer_line() + 1),
-                    Action::DeleteLineAt(self.buffer_line() + 1),
-                    Action::ReplaceLineAt(
-                        self.buffer_line(),
-                        self.current_line_contents().unwrap_or_default(),
-                    ),
-                ]);
+                let started_transaction = !self.transaction_active();
+                if started_transaction {
+                    self.begin_transaction("insert newline");
+                }
                 let spaces = self.current_line_indentation();
 
                 let current_line = self.current_line_contents().unwrap_or_default();
@@ -2503,7 +2490,13 @@ impl Editor {
                 let after_cursor = char_suffix(current_line, cursor_char).to_string();
 
                 let line = self.buffer_line();
-                self.current_buffer_mut().replace_line(line, before_cursor);
+                self.replace_range(
+                    TextRange::new(
+                        TextPosition::new(line, 0),
+                        TextPosition::new(line, current_line.chars().count()),
+                    ),
+                    &format!("{}\n{}{}", before_cursor, " ".repeat(spaces), after_cursor),
+                );
                 self.notify_change(runtime).await?;
 
                 self.cx = spaces;
@@ -2514,10 +2507,9 @@ impl Editor {
                     self.cy -= 1;
                 }
 
-                let new_line = format!("{}{}", " ".repeat(spaces), &after_cursor);
-                let line = self.buffer_line();
-
-                self.current_buffer_mut().insert_line(line, new_line);
+                if started_transaction {
+                    self.commit_transaction(self.cursor_snapshot());
+                }
                 self.render(buffer)?;
             }
             Action::SetWaitingKey(key_action) => {
@@ -2525,31 +2517,35 @@ impl Editor {
             }
             Action::DeleteCurrentLine => {
                 let line = self.buffer_line();
-                let contents = self.current_line_contents();
-
-                self.current_buffer_mut().remove_line(line);
+                let end = if line < self.current_buffer().len() {
+                    TextPosition::new(line + 1, 0)
+                } else {
+                    TextPosition::new(line, self.length_for_line(line))
+                };
+                self.begin_transaction("delete line");
+                self.replace_range(TextRange::new(TextPosition::new(line, 0), end), "");
                 self.notify_change(runtime).await?;
-                self.undo_actions.push(Action::InsertLineAt(line, contents));
                 let target_line = line.min(self.current_buffer().len());
                 self.vtop = self.vtop.min(target_line);
                 self.cy = target_line.saturating_sub(self.vtop);
                 self.cx = 0;
+                self.commit_transaction(self.cursor_snapshot());
                 self.render(buffer)?;
             }
             Action::Undo => {
-                if let Some(undo_action) = self.undo_actions.pop() {
-                    self.execute(&undo_action, buffer, runtime).await?;
-                }
+                self.undo_transaction(buffer, runtime).await?;
             }
-            Action::UndoMultiple(actions) => {
-                for action in actions.iter().rev() {
-                    self.execute(action, buffer, runtime).await?;
-                }
+            Action::Redo => {
+                self.redo_transaction(buffer, runtime).await?;
             }
             Action::InsertLineAt(y, contents) => {
                 if let Some(contents) = contents {
-                    self.current_buffer_mut()
-                        .insert_line(*y, contents.to_string());
+                    self.begin_transaction("insert line");
+                    self.replace_range(
+                        TextRange::insertion(TextPosition::new(*y, 0)),
+                        &format!("{}\n", contents),
+                    );
+                    self.commit_transaction(self.cursor_snapshot());
                     self.notify_change(runtime).await?;
                     self.render(buffer)?;
                 }
@@ -2586,9 +2582,6 @@ impl Editor {
             Action::InsertLineBelowCursor => {
                 use crate::log;
 
-                self.undo_actions
-                    .push(Action::DeleteLineAt(self.buffer_line() + 1));
-
                 let leading_spaces = self.current_line_indentation();
                 let line = self.buffer_line();
 
@@ -2606,12 +2599,21 @@ impl Editor {
                     log!("Line char count: {}", line_content.chars().count());
                 }
 
-                self.current_buffer_mut()
-                    .insert_line(line + 1, " ".repeat(leading_spaces));
+                let started_transaction = !self.transaction_active();
+                if started_transaction {
+                    self.begin_transaction("insert line below");
+                }
+                self.replace_range(
+                    TextRange::insertion(TextPosition::new(line + 1, 0)),
+                    &format!("{}\n", " ".repeat(leading_spaces)),
+                );
                 self.notify_change(runtime).await?;
                 self.cy += 1;
                 self.cx = leading_spaces;
                 self.mode = Mode::Insert;
+                if started_transaction {
+                    self.commit_transaction(self.cursor_snapshot());
+                }
 
                 if self.cy >= self.vheight() {
                     self.vtop += 1;
@@ -2621,9 +2623,6 @@ impl Editor {
                 self.render(buffer)?;
             }
             Action::InsertLineAtCursor => {
-                self.undo_actions
-                    .push(Action::DeleteLineAt(self.buffer_line()));
-
                 // if the current line is empty, let's use the indentation from the line above
                 let leading_spaces = if let Some(line) = self.current_line_contents() {
                     if line.is_empty() {
@@ -2636,11 +2635,20 @@ impl Editor {
                 };
 
                 let line = self.buffer_line();
-                self.current_buffer_mut()
-                    .insert_line(line, " ".repeat(leading_spaces));
+                let started_transaction = !self.transaction_active();
+                if started_transaction {
+                    self.begin_transaction("insert line above");
+                }
+                self.replace_range(
+                    TextRange::insertion(TextPosition::new(line, 0)),
+                    &format!("{}\n", " ".repeat(leading_spaces)),
+                );
                 self.notify_change(runtime).await?;
                 self.cx = leading_spaces;
                 self.mode = Mode::Insert;
+                if started_transaction {
+                    self.commit_transaction(self.cursor_snapshot());
+                }
                 self.render(buffer)?;
             }
             Action::MoveToTop => {
@@ -2660,12 +2668,23 @@ impl Editor {
                 }
             }
             Action::DeleteLineAt(y) => {
-                self.current_buffer_mut().remove_line(*y);
+                let end = if *y < self.current_buffer().len() {
+                    TextPosition::new(*y + 1, 0)
+                } else {
+                    TextPosition::new(*y, self.length_for_line(*y))
+                };
+                self.begin_transaction("delete line");
+                self.replace_range(TextRange::new(TextPosition::new(*y, 0), end), "");
+                self.commit_transaction(self.cursor_snapshot());
                 self.notify_change(runtime).await?;
                 self.render(buffer)?;
             }
             Action::DeletePreviousChar => {
                 if self.cx > 0 {
+                    let started_transaction = !self.transaction_active();
+                    if started_transaction {
+                        self.begin_transaction("delete previous char");
+                    }
                     // Get the current line to find the previous grapheme boundary
                     if let Some(line) = self.current_line_contents() {
                         let line = line.trim_end_matches('\n');
@@ -2679,9 +2698,17 @@ impl Editor {
                             let start_char = crate::unicode_utils::byte_to_char(line, prev_byte);
                             let end_char = crate::unicode_utils::byte_to_char(line, current_byte);
                             let line_num = self.buffer_line();
-                            self.current_buffer_mut()
-                                .remove_range(start_char, line_num, end_char, line_num);
+                            self.replace_range(
+                                TextRange::new(
+                                    TextPosition::new(line_num, start_char),
+                                    TextPosition::new(line_num, end_char),
+                                ),
+                                "",
+                            );
                             self.cx = prev_grapheme_idx;
+                            if started_transaction {
+                                self.commit_transaction(self.cursor_snapshot());
+                            }
 
                             self.notify_change(runtime).await?;
                             self.draw_line(buffer);
@@ -2963,10 +2990,19 @@ impl Editor {
                 let tabsize = 4;
                 let cx = self.cx;
                 let line = self.buffer_line();
-                self.current_buffer_mut()
-                    .insert_str(cx, line, &" ".repeat(tabsize));
+                let started_transaction = !self.transaction_active();
+                if started_transaction {
+                    self.begin_transaction("insert tab");
+                }
+                self.replace_range(
+                    TextRange::insertion(TextPosition::new(line, cx)),
+                    &" ".repeat(tabsize),
+                );
                 self.notify_change(runtime).await?;
                 self.cx += tabsize;
+                if started_transaction {
+                    self.commit_transaction(self.cursor_snapshot());
+                }
                 self.draw_line(buffer);
             }
             Action::Save => match self.current_buffer_mut().save() {
@@ -3033,17 +3069,16 @@ impl Editor {
                 let cx = self.cx;
                 let line = self.buffer_line();
 
-                if let Some(text) = self.current_buffer_mut().delete_word((cx, line)) {
-                    let content = Content {
-                        kind: ContentKind::Charwise,
-                        text,
-                    };
-
-                    self.undo_actions.push(Action::InsertText {
-                        x: cx,
-                        y: line,
-                        content,
-                    });
+                if let Some((end_x, end_y)) = self.current_buffer().find_next_word((cx, line)) {
+                    self.begin_transaction("delete word");
+                    self.replace_range(
+                        TextRange::new(
+                            TextPosition::new(line, cx),
+                            TextPosition::new(end_y, end_x),
+                        ),
+                        "",
+                    );
+                    self.commit_transaction(self.cursor_snapshot());
                 }
 
                 self.notify_change(runtime).await?;
@@ -3166,10 +3201,12 @@ impl Editor {
             }
             Action::Delete => {
                 if self.selection.is_some() {
+                    self.begin_transaction("delete selection");
                     if let Some((x0, y0)) = self.delete_selection() {
                         self.cx = x0;
                         self.cy = y0 - self.vtop;
                     }
+                    self.commit_transaction(self.cursor_snapshot());
                     self.selection = None;
                     self.notify_change(runtime).await?;
                     self.render(buffer)?;
@@ -3182,7 +3219,7 @@ impl Editor {
                 }
             }
             Action::InsertText { x, y, content } => {
-                self.insert_content(*x, *y, content, true);
+                self.insert_content_as_transaction(*x, *y, content);
                 self.notify_change(runtime).await?;
                 self.render(buffer)?;
             }
@@ -3209,9 +3246,16 @@ impl Editor {
                 let line = self.buffer_line();
                 let cx = self.cx;
                 let char_cx = self.grapheme_to_char_on_line(cx, line);
-                self.current_buffer_mut().insert_str(char_cx, line, text);
+                let started_transaction = !self.transaction_active();
+                if started_transaction {
+                    self.begin_transaction("insert string");
+                }
+                self.replace_range(TextRange::insertion(TextPosition::new(line, char_cx)), text);
                 self.notify_change(runtime).await?;
                 self.cx += grapheme_len(text);
+                if started_transaction {
+                    self.commit_transaction(self.cursor_snapshot());
+                }
                 self.draw_line(buffer);
             }
             Action::RequestCompletion => {
@@ -3233,28 +3277,31 @@ impl Editor {
                 let indent = self.indentation();
                 let line = self.buffer_line();
 
-                self.undo_actions
-                    .push(Action::DeleteRange(0, line, indent.shift_width, line));
-
-                self.current_buffer_mut()
-                    .insert_str(0, line, &" ".repeat(indent.shift_width));
+                self.begin_transaction("indent line");
+                self.replace_range(
+                    TextRange::insertion(TextPosition::new(line, 0)),
+                    &" ".repeat(indent.shift_width),
+                );
+                self.commit_transaction(self.cursor_snapshot());
+                self.notify_change(runtime).await?;
+                self.render(buffer)?;
             }
             Action::UnindentLine => {
                 let spaces = self.current_line_indentation();
                 let chars_to_remove = std::cmp::min(spaces, self.indentation().shift_width);
                 let line = self.buffer_line();
 
-                self.undo_actions.push(Action::InsertText {
-                    x: 0,
-                    y: line,
-                    content: Content {
-                        kind: ContentKind::Charwise,
-                        text: " ".repeat(chars_to_remove),
-                    },
-                });
-
-                self.current_buffer_mut()
-                    .remove_range(0, line, chars_to_remove, line);
+                self.begin_transaction("unindent line");
+                self.replace_range(
+                    TextRange::new(
+                        TextPosition::new(line, 0),
+                        TextPosition::new(line, chars_to_remove),
+                    ),
+                    "",
+                );
+                self.commit_transaction(self.cursor_snapshot());
+                self.notify_change(runtime).await?;
+                self.render(buffer)?;
             }
             Action::JumpBack => {
                 add_to_history = false;
@@ -3473,6 +3520,27 @@ impl Editor {
             self.render(buffer)?;
         }
 
+        if self.is_visual()
+            && matches!(
+                action,
+                Action::MoveUp
+                    | Action::MoveDown
+                    | Action::MoveLeft
+                    | Action::MoveRight
+                    | Action::MoveToLineEnd
+                    | Action::MoveToLineStart
+                    | Action::MoveToFirstLineChar
+                    | Action::MoveToLastLineChar
+                    | Action::MoveToTop
+                    | Action::MoveToBottom
+                    | Action::GoToLine(_)
+                    | Action::MoveTo(_, _)
+            )
+        {
+            self.update_selection();
+            self.render(buffer)?;
+        }
+
         if add_to_history {
             self.save_to_history(action);
         }
@@ -3666,17 +3734,14 @@ impl Editor {
 
                 self.registers.insert(DEFAULT_REGISTER, content.clone());
 
-                self.undo_actions.push(Action::InsertText {
-                    x: x0,
-                    y: y0,
-                    content,
-                });
-
                 match self.mode {
                     Mode::VisualLine => {
-                        for y in (y0..=y1).rev() {
-                            self.current_buffer_mut().remove_line(y);
-                        }
+                        let end = if y1 < self.current_buffer().len() {
+                            TextPosition::new(y1 + 1, 0)
+                        } else {
+                            TextPosition::new(y1, self.length_for_line(y1))
+                        };
+                        self.replace_range(TextRange::new(TextPosition::new(y0, 0), end), "");
                     }
                     Mode::VisualBlock => {
                         let min_x = std::cmp::min(x0, x1);
@@ -3684,45 +3749,37 @@ impl Editor {
 
                         for y in y0..=y1 {
                             if let Some(line) = self.current_buffer().get(y) {
-                                let line_len = line.chars().count();
+                                let line_len = line.trim_end_matches('\n').chars().count();
                                 if min_x >= line_len {
                                     continue;
                                 }
-                                let before = char_prefix(&line, min_x).to_string();
-                                let after = if max_x + 1 >= line_len {
-                                    String::new()
-                                } else {
-                                    char_suffix(&line, max_x + 1).to_string()
-                                };
-                                self.current_buffer_mut()
-                                    .replace_line(y, format!("{}{}", before, after));
+                                self.replace_range(
+                                    TextRange::new(
+                                        TextPosition::new(y, min_x),
+                                        TextPosition::new(y, (max_x + 1).min(line_len)),
+                                    ),
+                                    "",
+                                );
                             }
                         }
                     }
                     Mode::Visual => {
                         if y0 == y1 {
-                            let line = self.current_buffer().get(y0).unwrap();
-                            let before = char_prefix(&line, x0).to_string();
-                            let after = char_suffix(&line, x1 + 1).to_string();
-                            self.current_buffer_mut()
-                                .replace_line(y0, format!("{}{}", before, after));
+                            self.replace_range(
+                                TextRange::new(
+                                    TextPosition::new(y0, x0),
+                                    TextPosition::new(y0, x1 + 1),
+                                ),
+                                "",
+                            );
                         } else {
-                            // Multi-line deletion
-                            let first_line = self.current_buffer().get(y0).unwrap();
-                            let last_line = self.current_buffer().get(y1).unwrap();
-
-                            // Combine the parts before and after the selection
-                            let before = char_prefix(&first_line, x0).to_string();
-                            let after = char_suffix(&last_line, x1 + 1).to_string();
-                            let new_line = format!("{}{}", before, after);
-
-                            // Replace the first line with the combined text
-                            self.current_buffer_mut().replace_line(y0, new_line);
-
-                            // Remove the lines in between
-                            for y in (y0 + 1..=y1).rev() {
-                                self.current_buffer_mut().remove_line(y);
-                            }
+                            self.replace_range(
+                                TextRange::new(
+                                    TextPosition::new(y0, x0),
+                                    TextPosition::new(y1, x1 + 1),
+                                ),
+                                "",
+                            );
                         }
                     }
                     _ => {}
@@ -3747,7 +3804,14 @@ impl Editor {
     }
 
     fn paste(&mut self, content: &Content, before: bool) {
+        let started_transaction = !self.transaction_active();
+        if started_transaction {
+            self.begin_transaction("paste");
+        }
         self.insert_content(self.cx, self.buffer_line(), content, before);
+        if started_transaction {
+            self.commit_transaction(self.cursor_snapshot());
+        }
     }
 
     fn insert_content(&mut self, x: usize, y: usize, content: &Content, before: bool) {
@@ -3759,10 +3823,13 @@ impl Editor {
     }
 
     fn insert_linewise(&mut self, y: usize, contents: &Content, before: bool) {
-        for (dy, line) in contents.text.lines().enumerate() {
-            self.current_buffer_mut()
-                .insert_line(y + dy + if before { 0 } else { 1 }, line.to_string());
+        let target_y = y + if before { 0 } else { 1 };
+        let mut text = String::new();
+        for line in contents.text.lines() {
+            text.push_str(line);
+            text.push('\n');
         }
+        self.replace_range(TextRange::insertion(TextPosition::new(target_y, 0)), &text);
     }
 
     fn insert_blockwise(&mut self, x: usize, y: usize, contents: &Content, before: bool) {
@@ -3773,11 +3840,12 @@ impl Editor {
             let y = y + dy;
             // Extend the buffer with empty lines if needed
             while self.current_buffer().len() <= y {
-                self.current_buffer_mut().insert_line(y, String::new());
+                self.replace_range(TextRange::insertion(TextPosition::new(y, 0)), "\n");
             }
 
             let current_line = self.current_buffer().get(y).unwrap_or_default();
-            let mut new_line = current_line.clone();
+            let current_line = current_line.trim_end_matches('\n');
+            let mut new_line = current_line.to_string();
 
             // Extend the line with spaces if needed
             while grapheme_len(&new_line) < paste_x {
@@ -3787,43 +3855,39 @@ impl Editor {
             // Insert the block text
             let paste_byte = grapheme_to_byte(&new_line, paste_x);
             new_line.insert_str(paste_byte, line);
-            self.current_buffer_mut().replace_line(y, new_line);
+            self.replace_range(
+                TextRange::new(
+                    TextPosition::new(y, 0),
+                    TextPosition::new(y, current_line.chars().count()),
+                ),
+                &new_line,
+            );
         }
     }
 
     fn insert_charwise(&mut self, x: usize, y: usize, contents: &Content, before: bool) {
-        let lines = contents.text.lines().collect::<Vec<_>>();
-        let count = lines.len();
         let insert_x = self.grapheme_to_char_on_line(x, y);
+        let insertion = if before {
+            insert_x
+        } else {
+            let after_x = self.grapheme_to_char_on_line(x + 1, y);
+            self.cx += 1;
+            after_x
+        };
+        self.replace_range(
+            TextRange::insertion(TextPosition::new(y, insertion)),
+            &contents.text,
+        );
+    }
 
-        if count == 1 {
-            let line = lines[0];
-            if before {
-                self.current_buffer_mut().insert_str(insert_x, y, line);
-            } else {
-                let after_x = self.grapheme_to_char_on_line(x + 1, y);
-                self.current_buffer_mut().insert_str(after_x, y, line);
-                self.cx += 1;
-            }
-            return;
+    fn insert_content_as_transaction(&mut self, x: usize, y: usize, content: &Content) {
+        let started_transaction = !self.transaction_active();
+        if started_transaction {
+            self.begin_transaction("insert text");
         }
-
-        let line_contents = self.current_line_contents().unwrap_or_default();
-        let text_before = char_prefix(&line_contents, insert_x).to_string();
-        let text_after = char_suffix(&line_contents, insert_x).to_string();
-
-        for (n, line) in lines.iter().enumerate() {
-            if n == 0 {
-                self.current_buffer_mut().set(y, text_before.clone());
-                self.current_buffer_mut().insert_str(insert_x, y, line);
-            } else if n == count - 1 {
-                let new_text = format!("{}{}", line, text_after);
-                self.current_buffer_mut()
-                    .insert_line(y + count - 1, new_text);
-            } else {
-                self.current_buffer_mut()
-                    .insert_line(y + n, line.to_string());
-            }
+        self.insert_content(x, y, content, true);
+        if started_transaction {
+            self.commit_transaction(self.cursor_snapshot());
         }
     }
 
@@ -4097,6 +4161,96 @@ impl Editor {
         &mut self.buffers[self.current_buffer_index]
     }
 
+    fn cursor_snapshot(&self) -> CursorSnapshot {
+        CursorSnapshot::new(self.cx, self.buffer_line(), self.vtop)
+    }
+
+    fn restore_cursor_snapshot(&mut self, snapshot: CursorSnapshot) {
+        self.vtop = snapshot.vtop;
+        self.cy = snapshot.y.saturating_sub(self.vtop);
+        self.cx = snapshot.x;
+        self.check_bounds();
+    }
+
+    fn begin_transaction(&mut self, label: impl Into<String>) {
+        let before_cursor = self.cursor_snapshot();
+        self.current_buffer_mut()
+            .undo_history
+            .begin_transaction(label, before_cursor);
+    }
+
+    fn transaction_active(&self) -> bool {
+        self.current_buffer().undo_history.is_transaction_active()
+    }
+
+    fn replace_range(&mut self, range: TextRange, new_text: &str) {
+        let old_text = self.current_buffer().text_in_range(range);
+        if old_text == new_text {
+            return;
+        }
+        self.current_buffer_mut().replace_range_raw(range, new_text);
+        self.current_buffer_mut().undo_history.record_replace(
+            range,
+            old_text,
+            new_text.to_string(),
+        );
+    }
+
+    fn commit_transaction(&mut self, after_cursor: CursorSnapshot) -> bool {
+        let committed = self
+            .current_buffer_mut()
+            .undo_history
+            .commit_transaction(after_cursor);
+        self.current_buffer_mut().refresh_dirty_from_history();
+        committed
+    }
+
+    fn cancel_transaction_if_empty(&mut self) {
+        self.current_buffer_mut()
+            .undo_history
+            .cancel_transaction_if_empty();
+    }
+
+    async fn undo_transaction(
+        &mut self,
+        render_buffer: &mut RenderBuffer,
+        runtime: &mut Runtime,
+    ) -> anyhow::Result<()> {
+        let buffer = self.current_buffer_mut();
+        let mut history = std::mem::take(&mut buffer.undo_history);
+        let cursor = history.undo(buffer);
+        buffer.undo_history = history;
+        buffer.refresh_dirty_from_history();
+
+        if let Some(cursor) = cursor {
+            self.restore_cursor_snapshot(cursor);
+            self.notify_change(runtime).await?;
+            self.render(render_buffer)?;
+        }
+
+        Ok(())
+    }
+
+    async fn redo_transaction(
+        &mut self,
+        render_buffer: &mut RenderBuffer,
+        runtime: &mut Runtime,
+    ) -> anyhow::Result<()> {
+        let buffer = self.current_buffer_mut();
+        let mut history = std::mem::take(&mut buffer.undo_history);
+        let cursor = history.redo(buffer);
+        buffer.undo_history = history;
+        buffer.refresh_dirty_from_history();
+
+        if let Some(cursor) = cursor {
+            self.restore_cursor_snapshot(cursor);
+            self.notify_change(runtime).await?;
+            self.render(render_buffer)?;
+        }
+
+        Ok(())
+    }
+
     pub fn current_file_name(&self) -> Option<String> {
         self.current_buffer().file.clone()
     }
diff --git a/src/fixtures/config.toml b/src/fixtures/config.toml
index c81f7b6..3bd48c0 100644
--- a/src/fixtures/config.toml
+++ b/src/fixtures/config.toml
@@ -17,6 +17,7 @@ root_markers = ["package.json", ".git"]
 "G" = "MoveToBottom"
 "g" = { "g" = "MoveToTop" }
 "u" = "Undo"
+"Ctrl-r" = "Redo"
 "p" = [ "MoveUp", "MoveRight" ]
 "Down" = "MoveDown"
 "Left" = "MoveLeft"
diff --git a/src/lib.rs b/src/lib.rs
index 32c701b..8a92ebb 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -14,6 +14,7 @@ pub mod plugin;
 pub mod sync;
 pub mod theme;
 pub mod ui;
+pub mod undo;
 pub mod unicode_utils;
 pub mod utils;
 pub mod window;
diff --git a/src/undo.rs b/src/undo.rs
new file mode 100644
index 0000000..a94d734
--- /dev/null
+++ b/src/undo.rs
@@ -0,0 +1,215 @@
+use crate::buffer::Buffer;
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
+pub struct TextPosition {
+    pub line: usize,
+    pub character: usize,
+}
+
+impl TextPosition {
+    pub fn new(line: usize, character: usize) -> Self {
+        Self { line, character }
+    }
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
+pub struct TextRange {
+    pub start: TextPosition,
+    pub end: TextPosition,
+}
+
+impl TextRange {
+    pub fn new(start: TextPosition, end: TextPosition) -> Self {
+        Self { start, end }
+    }
+
+    pub fn insertion(position: TextPosition) -> Self {
+        Self {
+            start: position,
+            end: position,
+        }
+    }
+}
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub enum TextEdit {
+    Replace {
+        range: TextRange,
+        old_text: String,
+        new_text: String,
+    },
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
+pub struct CursorSnapshot {
+    pub x: usize,
+    pub y: usize,
+    pub vtop: usize,
+}
+
+impl CursorSnapshot {
+    pub fn new(x: usize, y: usize, vtop: usize) -> Self {
+        Self { x, y, vtop }
+    }
+}
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct EditTransaction {
+    pub label: String,
+    pub edits: Vec<TextEdit>,
+    pub before_cursor: CursorSnapshot,
+    pub after_cursor: CursorSnapshot,
+    before_revision: u64,
+    after_revision: u64,
+}
+
+impl EditTransaction {
+    pub fn new(
+        label: impl Into<String>,
+        before_cursor: CursorSnapshot,
+        before_revision: u64,
+    ) -> Self {
+        Self {
+            label: label.into(),
+            edits: Vec::new(),
+            before_cursor,
+            after_cursor: before_cursor,
+            before_revision,
+            after_revision: before_revision,
+        }
+    }
+
+    pub fn is_empty(&self) -> bool {
+        self.edits.is_empty()
+    }
+}
+
+#[derive(Debug, Clone)]
+pub struct UndoHistory {
+    undo_stack: Vec<EditTransaction>,
+    redo_stack: Vec<EditTransaction>,
+    active_transaction: Option<EditTransaction>,
+    current_revision: u64,
+    saved_revision: u64,
+    next_revision: u64,
+}
+
+impl Default for UndoHistory {
+    fn default() -> Self {
+        Self {
+            undo_stack: Vec::new(),
+            redo_stack: Vec::new(),
+            active_transaction: None,
+            current_revision: 0,
+            saved_revision: 0,
+            next_revision: 1,
+        }
+    }
+}
+
+impl UndoHistory {
+    pub fn begin_transaction(&mut self, label: impl Into<String>, before_cursor: CursorSnapshot) {
+        if self.active_transaction.is_none() {
+            self.active_transaction = Some(EditTransaction::new(
+                label,
+                before_cursor,
+                self.current_revision,
+            ));
+        }
+    }
+
+    pub fn record_replace(&mut self, range: TextRange, old_text: String, new_text: String) {
+        if old_text == new_text {
+            return;
+        }
+
+        if let Some(transaction) = &mut self.active_transaction {
+            transaction.edits.push(TextEdit::Replace {
+                range,
+                old_text,
+                new_text,
+            });
+        }
+    }
+
+    pub fn commit_transaction(&mut self, after_cursor: CursorSnapshot) -> bool {
+        let Some(mut transaction) = self.active_transaction.take() else {
+            return false;
+        };
+
+        if transaction.is_empty() {
+            return false;
+        }
+
+        transaction.after_cursor = after_cursor;
+        transaction.after_revision = self.next_revision;
+        self.next_revision += 1;
+        self.current_revision = transaction.after_revision;
+        self.undo_stack.push(transaction);
+        self.redo_stack.clear();
+        true
+    }
+
+    pub fn cancel_transaction_if_empty(&mut self) {
+        if self
+            .active_transaction
+            .as_ref()
+            .is_some_and(EditTransaction::is_empty)
+        {
+            self.active_transaction = None;
+        }
+    }
+
+    pub fn is_transaction_active(&self) -> bool {
+        self.active_transaction.is_some()
+    }
+
+    pub fn mark_saved(&mut self) {
+        self.saved_revision = self.current_revision;
+    }
+
+    pub fn is_dirty(&self) -> bool {
+        self.current_revision != self.saved_revision
+    }
+
+    pub fn undo(&mut self, buffer: &mut Buffer) -> Option<CursorSnapshot> {
+        let transaction = self.undo_stack.pop()?;
+
+        for edit in transaction.edits.iter().rev() {
+            match edit {
+                TextEdit::Replace {
+                    range,
+                    old_text,
+                    new_text,
+                } => {
+                    let current_range = buffer.range_for_text(range.start, new_text);
+                    buffer.replace_range_raw(current_range, old_text);
+                }
+            }
+        }
+
+        let cursor = transaction.before_cursor;
+        self.current_revision = transaction.before_revision;
+        self.redo_stack.push(transaction);
+        Some(cursor)
+    }
+
+    pub fn redo(&mut self, buffer: &mut Buffer) -> Option<CursorSnapshot> {
+        let transaction = self.redo_stack.pop()?;
+
+        for edit in &transaction.edits {
+            match edit {
+                TextEdit::Replace {
+                    range, new_text, ..
+                } => {
+                    buffer.replace_range_raw(*range, new_text);
+                }
+            }
+        }
+
+        let cursor = transaction.after_cursor;
+        self.current_revision = transaction.after_revision;
+        self.undo_stack.push(transaction);
+        Some(cursor)
+    }
+}
diff --git a/tests/common/editor_harness.rs b/tests/common/editor_harness.rs
index 36d9245..5ff71bb 100644
--- a/tests/common/editor_harness.rs
+++ b/tests/common/editor_harness.rs
@@ -99,6 +99,10 @@ impl EditorHarness {
         self.editor.test_is_normal()
     }
 
+    pub fn is_dirty(&self) -> bool {
+        self.editor.test_current_buffer().is_dirty()
+    }
+
     /// Check if editor is in visual mode
     pub fn is_visual(&self) -> bool {
         self.editor.test_is_visual()
diff --git a/tests/editing.rs b/tests/editing.rs
index 7cb4cd4..52253ae 100644
--- a/tests/editing.rs
+++ b/tests/editing.rs
@@ -1,7 +1,28 @@
 mod common;
 
-use common::EditorHarness;
-use red::editor::{Action, Mode};
+use common::{EditorHarness, MockLsp};
+use red::{
+    buffer::Buffer,
+    config::Config,
+    editor::{Action, Content, Editor, Mode},
+    lsp::LspClient,
+    theme::Theme,
+};
+use std::{
+    fs,
+    time::{SystemTime, UNIX_EPOCH},
+};
+
+fn temp_file_path(name: &str) -> String {
+    let nanos = SystemTime::now()
+        .duration_since(UNIX_EPOCH)
+        .unwrap()
+        .as_nanos();
+    std::env::temp_dir()
+        .join(format!("red-{name}-{}-{nanos}.txt", std::process::id()))
+        .to_string_lossy()
+        .into_owned()
+}
 
 #[tokio::test]
 async fn test_insert_mode() {
@@ -398,8 +419,394 @@ async fn test_undo_redo() {
     harness.execute_action(Action::Undo).await.unwrap();
     harness.assert_buffer_contents("Hello World");
 
-    // Redo is not implemented as a separate action
-    // Skip redo test
+    harness.execute_action(Action::Redo).await.unwrap();
+    harness.assert_buffer_contents("ello World");
+}
+
+#[tokio::test]
+async fn test_undo_multi_character_insert_session() {
+    let mut harness = EditorHarness::with_content("");
+
+    harness
+        .execute_action(Action::EnterMode(Mode::Insert))
+        .await
+        .unwrap();
+    harness.type_text("hello").await.unwrap();
+    harness
+        .execute_action(Action::EnterMode(Mode::Normal))
+        .await
+        .unwrap();
+
+    harness.assert_buffer_contents("hello\n");
+    harness.execute_action(Action::Undo).await.unwrap();
+    harness.assert_buffer_contents("\n");
+    harness.execute_action(Action::Redo).await.unwrap();
+    harness.assert_buffer_contents("hello\n");
+}
+
+#[tokio::test]
+async fn test_undo_insert_backspace_session() {
+    let mut harness = EditorHarness::with_content("");
+
+    harness
+        .execute_action(Action::EnterMode(Mode::Insert))
+        .await
+        .unwrap();
+    harness.type_text("abc").await.unwrap();
+    harness
+        .execute_action(Action::DeletePreviousChar)
+        .await
+        .unwrap();
+    harness
+        .execute_action(Action::EnterMode(Mode::Normal))
+        .await
+        .unwrap();
+
+    harness.assert_buffer_contents("ab\n");
+    harness.execute_action(Action::Undo).await.unwrap();
+    harness.assert_buffer_contents("\n");
+    harness.execute_action(Action::Redo).await.unwrap();
+    harness.assert_buffer_contents("ab\n");
+}
+
+#[tokio::test]
+async fn test_undo_delete_range_and_word() {
+    let mut harness = EditorHarness::with_content("hello world");
+
+    harness.execute_action(Action::DeleteWord).await.unwrap();
+    harness.assert_buffer_contents("world");
+    harness.execute_action(Action::Undo).await.unwrap();
+    harness.assert_buffer_contents("hello world");
+
+    harness
+        .execute_action(Action::DeleteRange(0, 0, 5, 0))
+        .await
+        .unwrap();
+    harness.assert_buffer_contents(" world");
+    harness.execute_action(Action::Undo).await.unwrap();
+    harness.assert_buffer_contents("hello world");
+}
+
+#[tokio::test]
+async fn test_undo_delete_current_line() {
+    let mut harness = EditorHarness::with_content("one\ntwo\nthree");
+
+    harness.execute_action(Action::MoveDown).await.unwrap();
+    harness
+        .execute_action(Action::DeleteCurrentLine)
+        .await
+        .unwrap();
+    harness.assert_buffer_contents("one\nthree");
+    harness.execute_action(Action::Undo).await.unwrap();
+    harness.assert_buffer_contents("one\ntwo\nthree");
+
+    let mut harness = EditorHarness::with_content("single");
+    harness
+        .execute_action(Action::DeleteCurrentLine)
+        .await
+        .unwrap();
+    harness.assert_buffer_contents("");
+    harness.execute_action(Action::Undo).await.unwrap();
+    harness.assert_buffer_contents("single");
+}
+
+#[tokio::test]
+async fn test_undo_multiline_insert_and_unicode() {
+    let mut harness = EditorHarness::with_content("");
+
+    harness
+        .execute_action(Action::EnterMode(Mode::Insert))
+        .await
+        .unwrap();
+    harness.type_text("a👋").await.unwrap();
+    harness.execute_action(Action::InsertNewLine).await.unwrap();
+    harness.type_text("é").await.unwrap();
+    harness
+        .execute_action(Action::EnterMode(Mode::Normal))
+        .await
+        .unwrap();
+
+    harness.assert_buffer_contents("a👋\né\n");
+    harness.execute_action(Action::Undo).await.unwrap();
+    harness.assert_buffer_contents("\n");
+    harness.execute_action(Action::Redo).await.unwrap();
+    harness.assert_buffer_contents("a👋\né\n");
+}
+
+#[tokio::test]
+async fn test_redo_stack_clears_after_new_edit() {
+    let mut harness = EditorHarness::with_content("abc");
+
+    harness
+        .execute_action(Action::DeleteCharAtCursorPos)
+        .await
+        .unwrap();
+    harness.assert_buffer_contents("bc");
+    harness.execute_action(Action::Undo).await.unwrap();
+    harness.assert_buffer_contents("abc");
+    harness
+        .execute_action(Action::InsertCharAtCursorPos('z'))
+        .await
+        .unwrap();
+    harness.assert_buffer_contents("zabc");
+    harness.execute_action(Action::Redo).await.unwrap();
+    harness.assert_buffer_contents("zabc");
+}
+
+#[tokio::test]
+async fn test_undo_does_not_create_new_undo_entries() {
+    let mut harness = EditorHarness::with_content("abc");
+
+    harness
+        .execute_action(Action::DeleteCharAtCursorPos)
+        .await
+        .unwrap();
+    harness.execute_action(Action::Undo).await.unwrap();
+    harness.execute_action(Action::Undo).await.unwrap();
+    harness.assert_buffer_contents("abc");
+}
+
+#[tokio::test]
+async fn test_undo_indent_and_unindent() {
+    let mut harness = EditorHarness::with_content("line");
+
+    harness.execute_action(Action::IndentLine).await.unwrap();
+    harness.assert_buffer_contents("    line");
+    harness.execute_action(Action::Undo).await.unwrap();
+    harness.assert_buffer_contents("line");
+
+    harness.execute_action(Action::IndentLine).await.unwrap();
+    harness.execute_action(Action::UnindentLine).await.unwrap();
+    harness.assert_buffer_contents("line");
+    harness.execute_action(Action::Undo).await.unwrap();
+    harness.assert_buffer_contents("    line");
+}
+
+#[tokio::test]
+async fn test_undo_visual_char_line_and_block_delete() {
+    let mut harness = EditorHarness::with_content("abcde");
+    harness
+        .execute_action(Action::EnterMode(Mode::Visual))
+        .await
+        .unwrap();
+    harness.execute_action(Action::MoveRight).await.unwrap();
+    harness.execute_action(Action::MoveRight).await.unwrap();
+    harness.execute_action(Action::Delete).await.unwrap();
+    harness.assert_buffer_contents("de");
+    harness.execute_action(Action::Undo).await.unwrap();
+    harness.assert_buffer_contents("abcde");
+
+    let mut harness = EditorHarness::with_content("one\ntwo\nthree");
+    harness
+        .execute_action(Action::EnterMode(Mode::VisualLine))
+        .await
+        .unwrap();
+    harness.execute_action(Action::MoveDown).await.unwrap();
+    harness.execute_action(Action::Delete).await.unwrap();
+    harness.assert_buffer_contents("three");
+    harness.execute_action(Action::Undo).await.unwrap();
+    harness.assert_buffer_contents("one\ntwo\nthree");
+
+    let mut harness = EditorHarness::with_content("abc\ndef");
+    harness
+        .execute_action(Action::EnterMode(Mode::VisualBlock))
+        .await
+        .unwrap();
+    harness.execute_action(Action::MoveRight).await.unwrap();
+    harness.execute_action(Action::MoveDown).await.unwrap();
+    harness.execute_action(Action::Delete).await.unwrap();
+    harness.assert_buffer_contents("c\nf");
+    harness.execute_action(Action::Undo).await.unwrap();
+    harness.assert_buffer_contents("abc\ndef");
+}
+
+#[tokio::test]
+async fn test_undo_paste_and_paste_before() {
+    let mut harness = EditorHarness::with_content("hello world");
+
+    harness
+        .execute_action(Action::EnterMode(Mode::Visual))
+        .await
+        .unwrap();
+    for _ in 0..5 {
+        harness.execute_action(Action::MoveRight).await.unwrap();
+    }
+    harness.execute_action(Action::Delete).await.unwrap();
+    harness
+        .execute_action(Action::EnterMode(Mode::Normal))
+        .await
+        .unwrap();
+    harness.assert_buffer_contents("world");
+    harness.execute_action(Action::MoveToLineEnd).await.unwrap();
+    harness.execute_action(Action::Paste).await.unwrap();
+    harness.assert_buffer_contents("worldhello ");
+    harness.execute_action(Action::Undo).await.unwrap();
+    harness.assert_buffer_contents("world");
+
+    harness
+        .execute_action(Action::MoveToLineStart)
+        .await
+        .unwrap();
+    harness.execute_action(Action::PasteBefore).await.unwrap();
+    harness.assert_buffer_contents("hello world");
+    harness.execute_action(Action::Undo).await.unwrap();
+    harness.assert_buffer_contents("world");
+}
+
+#[tokio::test]
+async fn test_undo_insert_text_action() {
+    let mut harness = EditorHarness::with_content("abc");
+    let content = Content::charwise("ZZ".to_string());
+
+    harness
+        .execute_action(Action::InsertText {
+            x: 1,
+            y: 0,
+            content,
+        })
+        .await
+        .unwrap();
+    harness.assert_buffer_contents("aZZbc");
+    harness.execute_action(Action::Undo).await.unwrap();
+    harness.assert_buffer_contents("abc");
+}
+
+#[tokio::test]
+async fn test_undo_history_is_per_buffer() {
+    let lsp = Box::new(MockLsp) as Box<dyn LspClient + Send>;
+    let config = Config::default();
+    let theme = Theme::default();
+    let buffers = vec![
+        Buffer::new(None, "one".to_string()),
+        Buffer::new(None, "two".to_string()),
+    ];
+    let mut editor = Editor::with_size(lsp, 80, 24, config, theme, buffers).unwrap();
+    editor.test_disable_terminal_output();
+    let mut harness = EditorHarness { editor };
+
+    harness
+        .execute_action(Action::DeleteCharAtCursorPos)
+        .await
+        .unwrap();
+    harness.assert_buffer_contents("ne");
+    harness.execute_action(Action::NextBuffer).await.unwrap();
+    harness.assert_buffer_contents("two");
+    harness.execute_action(Action::Undo).await.unwrap();
+    harness.assert_buffer_contents("two");
+    harness
+        .execute_action(Action::PreviousBuffer)
+        .await
+        .unwrap();
+    harness.assert_buffer_contents("ne");
+    harness.execute_action(Action::Undo).await.unwrap();
+    harness.assert_buffer_contents("one");
+}
+
+#[tokio::test]
+async fn test_dirty_clears_when_undo_returns_to_clean_revision() {
+    let mut harness = EditorHarness::with_content("abc");
+    assert!(!harness.is_dirty());
+
+    harness
+        .execute_action(Action::InsertCharAtCursorPos('z'))
+        .await
+        .unwrap();
+    assert!(harness.is_dirty());
+
+    harness.execute_action(Action::Undo).await.unwrap();
+    harness.assert_buffer_contents("abc");
+    assert!(!harness.is_dirty());
+
+    harness.execute_action(Action::Redo).await.unwrap();
+    harness.assert_buffer_contents("zabc");
+    assert!(harness.is_dirty());
+}
+
+#[tokio::test]
+async fn test_dirty_checkpoint_moves_after_save() {
+    let path = temp_file_path("dirty-save");
+    fs::write(&path, "abc").unwrap();
+
+    let buffer = Buffer::new(Some(path.clone()), "abc".to_string());
+    let mut harness = EditorHarness::with_buffer(buffer);
+
+    harness
+        .execute_action(Action::InsertCharAtCursorPos('z'))
+        .await
+        .unwrap();
+    assert!(harness.is_dirty());
+    harness.execute_action(Action::Save).await.unwrap();
+    assert!(!harness.is_dirty());
+
+    harness
+        .execute_action(Action::InsertCharAtCursorPos('y'))
+        .await
+        .unwrap();
+    assert!(harness.is_dirty());
+    harness.execute_action(Action::Undo).await.unwrap();
+    assert!(!harness.is_dirty());
+
+    let _ = fs::remove_file(path);
+}
+
+#[tokio::test]
+async fn test_dirty_remains_after_undoing_past_saved_revision() {
+    let path = temp_file_path("dirty-past-save");
+    fs::write(&path, "abc").unwrap();
+
+    let buffer = Buffer::new(Some(path.clone()), "abc".to_string());
+    let mut harness = EditorHarness::with_buffer(buffer);
+
+    harness
+        .execute_action(Action::InsertCharAtCursorPos('z'))
+        .await
+        .unwrap();
+    harness.execute_action(Action::Save).await.unwrap();
+    assert!(!harness.is_dirty());
+
+    harness.execute_action(Action::Undo).await.unwrap();
+    harness.assert_buffer_contents("abc");
+    assert!(harness.is_dirty());
+
+    let _ = fs::remove_file(path);
+}
+
+#[tokio::test]
+async fn test_dirty_isolated_per_buffer() {
+    let lsp = Box::new(MockLsp) as Box<dyn LspClient + Send>;
+    let config = Config::default();
+    let theme = Theme::default();
+    let buffers = vec![
+        Buffer::new(None, "one".to_string()),
+        Buffer::new(None, "two".to_string()),
+    ];
+    let mut editor = Editor::with_size(lsp, 80, 24, config, theme, buffers).unwrap();
+    editor.test_disable_terminal_output();
+    let mut harness = EditorHarness { editor };
+
+    harness
+        .execute_action(Action::DeleteCharAtCursorPos)
+        .await
+        .unwrap();
+    assert!(harness.is_dirty());
+
+    harness.execute_action(Action::NextBuffer).await.unwrap();
+    assert!(!harness.is_dirty());
+    harness
+        .execute_action(Action::DeleteCharAtCursorPos)
+        .await
+        .unwrap();
+    assert!(harness.is_dirty());
+    harness.execute_action(Action::Undo).await.unwrap();
+    assert!(!harness.is_dirty());
+
+    harness
+        .execute_action(Action::PreviousBuffer)
+        .await
+        .unwrap();
+    assert!(harness.is_dirty());
+    harness.execute_action(Action::Undo).await.unwrap();
+    assert!(!harness.is_dirty());
 }
 
 #[tokio::test]

From 43b212d483065551e3bf69375b14214288140de3 Mon Sep 17 00:00:00 2001
From: Felipe Coury <felipe.coury@gmail.com>
Date: Sat, 9 May 2026 01:50:17 -0300
Subject: [PATCH 29/37] fix(tui): satisfy ci lint and audit checks

Derive the default panel side and use key-based reverse sorting for picker
matches to satisfy the current Clippy toolchain. Update `bytes` in
`Cargo.lock` to the patched release required by the security audit.
---
 Cargo.lock          | 4 ++--
 src/plugin/panel.rs | 9 ++-------
 src/ui/picker.rs    | 3 ++-
 3 files changed, 6 insertions(+), 10 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 929978a..22bf7d8 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -329,9 +329,9 @@ dependencies = [
 
 [[package]]
 name = "bytes"
-version = "1.10.1"
+version = "1.11.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d71b6127be86fdcfddb610f7182ac57211d4b18a3e9c82eb2d17662f2227ad6a"
+checksum = "1e748733b7cbc798e1434b6ac524f0c1ff2ab456fe201501e6497c8417a4fc33"
 
 [[package]]
 name = "capacity_builder"
diff --git a/src/plugin/panel.rs b/src/plugin/panel.rs
index 5285727..41269c0 100644
--- a/src/plugin/panel.rs
+++ b/src/plugin/panel.rs
@@ -8,19 +8,14 @@ use crate::{
     unicode_utils::fit_display_width,
 };
 
-#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
+#[derive(Debug, Clone, Default, PartialEq, Eq, Serialize, Deserialize)]
 #[serde(rename_all = "snake_case")]
 pub enum PanelSide {
+    #[default]
     Left,
     Right,
 }
 
-impl Default for PanelSide {
-    fn default() -> Self {
-        Self::Left
-    }
-}
-
 #[derive(Debug, Clone, Serialize, Deserialize)]
 pub struct PanelConfig {
     #[serde(default)]
diff --git a/src/ui/picker.rs b/src/ui/picker.rs
index 5a9159a..3d0fba4 100644
--- a/src/ui/picker.rs
+++ b/src/ui/picker.rs
@@ -1,6 +1,7 @@
 use crossterm::event::{self, Event, KeyCode};
 use fuzzy_matcher::skim::SkimMatcherV2;
 use fuzzy_matcher::FuzzyMatcher;
+use std::cmp::Reverse;
 
 use crate::{
     color::Color,
@@ -117,7 +118,7 @@ impl Picker {
                 }
             })
             .collect::<Vec<_>>();
-        new_items.sort_by(|a, b| b.1.cmp(&a.1));
+        new_items.sort_by_key(|item| Reverse(item.1));
 
         let new_items = new_items
             .iter()

From 6caf3124c384b651741399a897173804b5b69834 Mon Sep 17 00:00:00 2001
From: Felipe Coury <felipe.coury@gmail.com>
Date: Thu, 28 May 2026 01:32:09 -0300
Subject: [PATCH 30/37] fix(tui): keep inactive window gutters stable

Use each window's buffer to calculate gutter width during window-local
rendering and mouse coordinate translation. This prevents line numbers in
inactive splits from shifting when focus moves between buffers with
different line counts.

Add a regression test that renders a split with a one-line active buffer
and a ten-line inactive buffer, then verifies line 10 is already padded.
---
 src/editor.rs                  | 41 +++++++++++++++++++++++++++++++---
 src/editor/rendering.rs        | 24 +++++++++++---------
 tests/common/editor_harness.rs | 33 +++++++++++++++++++++++++++
 3 files changed, 85 insertions(+), 13 deletions(-)

diff --git a/src/editor.rs b/src/editor.rs
index ea90269..66d0552 100644
--- a/src/editor.rs
+++ b/src/editor.rs
@@ -921,7 +921,23 @@ impl Editor {
     }
 
     fn gutter_width(&self) -> usize {
-        self.current_buffer().len().to_string().len() + 1
+        self.current_buffer()
+            .len()
+            .saturating_add(1)
+            .to_string()
+            .len()
+            + 1
+    }
+
+    fn gutter_width_for_buffer_index(&self, buffer_index: usize) -> usize {
+        self.buffers
+            .get(buffer_index)
+            .map(|buffer| buffer.len().saturating_add(1).to_string().len() + 1)
+            .unwrap_or_else(|| self.gutter_width())
+    }
+
+    fn gutter_width_for_window(&self, window: &crate::window::Window) -> usize {
+        self.gutter_width_for_buffer_index(window.buffer_index)
     }
 
     pub fn highlight(&mut self, code: &str) -> anyhow::Result<Vec<StyleInfo>> {
@@ -4086,8 +4102,10 @@ impl Editor {
                             if let Some((local_x, local_y)) =
                                 window.terminal_to_local(click_x, click_y)
                             {
-                                // Adjust for gutter
-                                let buffer_x = local_x.saturating_sub(self.gutter_width() + 1);
+                                // Adjust for the clicked window's gutter, not the active buffer's.
+                                let gutter_width =
+                                    self.gutter_width_for_buffer_index(window_buffer_index);
+                                let buffer_x = local_x.saturating_sub(gutter_width + 1);
                                 let buffer_y = window_vtop + local_y;
 
                                 // Ensure y is within buffer bounds
@@ -4618,6 +4636,23 @@ impl Editor {
             .collect()
     }
 
+    #[doc(hidden)]
+    pub fn test_render_row(&mut self, y: usize) -> anyhow::Result<String> {
+        let mut render_buffer = RenderBuffer::new(
+            self.size.0 as usize,
+            self.size.1 as usize,
+            &Style::default(),
+        );
+        self.render(&mut render_buffer)?;
+
+        Ok(
+            render_buffer.cells[y * render_buffer.width..(y + 1) * render_buffer.width]
+                .iter()
+                .map(|cell| cell.c)
+                .collect(),
+        )
+    }
+
     #[doc(hidden)]
     pub fn test_current_line_contents(&self) -> Option<String> {
         self.current_line_contents()
diff --git a/src/editor/rendering.rs b/src/editor/rendering.rs
index 63e9be2..5e0c28b 100644
--- a/src/editor/rendering.rs
+++ b/src/editor/rendering.rs
@@ -555,7 +555,7 @@ impl Editor {
         let theme_style = self.theme.style.clone();
 
         // Start at window position, accounting for gutter
-        let gutter_width = self.gutter_width();
+        let gutter_width = self.gutter_width_for_window(window);
         let mut x = gutter_width + 1; // Content starts after gutter within window
         let mut y = 0; // Window-local y coordinate
 
@@ -572,7 +572,7 @@ impl Editor {
                         buffer,
                         term_x,
                         term_y,
-                        window.inner_width() - x,
+                        window.inner_width().saturating_sub(x),
                         &theme_style,
                     );
                 }
@@ -637,7 +637,7 @@ impl Editor {
                 buffer,
                 term_x,
                 term_y,
-                window.inner_width() - gutter_width - 1,
+                window.inner_width().saturating_sub(gutter_width + 1),
                 &theme_style,
             );
             y += 1;
@@ -683,7 +683,8 @@ impl Editor {
 
                 // Only highlight if the line is within the window
                 if window_cy < window.inner_height() {
-                    let start_x = window.position.x + self.gutter_width() + 1;
+                    let gutter_width = self.gutter_width_for_window(window);
+                    let start_x = window.position.x + gutter_width + 1;
                     let end_x = window.position.x + window.inner_width() - 1;
 
                     buffer.set_bg_for_range(
@@ -775,7 +776,7 @@ impl Editor {
             };
 
             // Calculate diagnostic indicator position within window
-            let gutter_width = self.gutter_width();
+            let gutter_width = self.gutter_width_for_window(window);
             let content_end = gutter_width + display_width(line.trim_end_matches('\n'));
             let indicator_x = content_end + 5; // Add some padding
 
@@ -849,11 +850,12 @@ impl Editor {
             // Convert to terminal coordinates
             for x in start_x..=end_x {
                 // Skip if x is outside window bounds
-                if x + self.gutter_width() + 1 >= window.inner_width() {
+                let gutter_width = self.gutter_width_for_window(window);
+                if x + gutter_width + 1 >= window.inner_width() {
                     continue;
                 }
 
-                let term_x = self.window_to_terminal_x(window, x + self.gutter_width() + 1);
+                let term_x = self.window_to_terminal_x(window, x + gutter_width + 1);
                 let term_y = self.window_to_terminal_y(window, window_y);
                 cells.push(Point::new(term_x, term_y));
             }
@@ -1139,7 +1141,7 @@ impl Editor {
         window: &crate::window::Window,
     ) -> anyhow::Result<()> {
         use crate::log;
-        let width = self.gutter_width();
+        let width = self.gutter_width_for_window(window);
         let gutter_style = self.theme.gutter_style.fallback_bg(&self.theme.style);
 
         log!(
@@ -1155,7 +1157,8 @@ impl Editor {
 
         for y in 0..window.inner_height() {
             let line_number = y + 1 + window.vtop;
-            let text = if line_number <= window_buffer.len() {
+            let line_count = window_buffer.len().saturating_add(1);
+            let text = if line_number <= line_count {
                 format!("{:>width$} ", line_number)
             } else {
                 " ".repeat(width + 1)
@@ -1222,7 +1225,8 @@ impl Editor {
                     };
 
                 // Convert to terminal coordinates based on active window
-                let term_x = window.position.x + self.gutter_width() + 1 + display_col;
+                let gutter_width = self.gutter_width_for_window(window);
+                let term_x = window.position.x + gutter_width + 1 + display_col;
                 let term_y =
                     window.position.y + window_cy.min(window.inner_height().saturating_sub(1));
                 Some((term_x, term_y))
diff --git a/tests/common/editor_harness.rs b/tests/common/editor_harness.rs
index 5ff71bb..83936df 100644
--- a/tests/common/editor_harness.rs
+++ b/tests/common/editor_harness.rs
@@ -182,6 +182,10 @@ impl EditorHarness {
     pub fn statusline_row(&mut self) -> String {
         self.editor.test_statusline_row()
     }
+
+    pub fn render_row(&mut self, y: usize) -> anyhow::Result<String> {
+        self.editor.test_render_row(y)
+    }
 }
 
 /// Test builder for setting up complex editor scenarios
@@ -348,6 +352,35 @@ mod tests {
         assert_eq!(harness.render_cursor_position(), Some((5, 21)));
     }
 
+    #[tokio::test]
+    async fn test_inactive_window_uses_its_own_gutter_width() {
+        let root =
+            std::env::temp_dir().join(format!("red-window-gutter-{}.txt", uuid::Uuid::new_v4()));
+        let content = (1..=10)
+            .map(|line| format!("Line {line}"))
+            .collect::<Vec<_>>()
+            .join("\n");
+        std::fs::write(&root, content).unwrap();
+
+        let mut harness = EditorHarness::new();
+        harness
+            .execute_action(Action::SplitVerticalWithFile(
+                root.to_string_lossy().into_owned(),
+            ))
+            .await
+            .unwrap();
+        harness
+            .execute_action(Action::PreviousWindow)
+            .await
+            .unwrap();
+
+        let row = harness.render_row(9).unwrap();
+        let right_window_gutter = row.chars().skip(40).take(4).collect::<String>();
+        assert_eq!(right_window_gutter, " 10 ");
+
+        std::fs::remove_file(root).unwrap();
+    }
+
     #[test]
     fn test_search_commandline_renders_search_text_on_small_width() {
         let mut harness = EditorHarness::new();

From ce0824a71d3ebf5f0c08fe5777aa20af5861596b Mon Sep 17 00:00:00 2001
From: Felipe Coury <felipe.coury@gmail.com>
Date: Thu, 28 May 2026 01:37:54 -0300
Subject: [PATCH 31/37] feat(tui): support ctrl navigation in pickers

Handle `Ctrl-j` and `Ctrl-k` inside the shared picker component so file
finder and plugin pickers can move selection without leaving the filter
input.

Add picker-level tests for control navigation and preserve plain `j` as
normal filter text.
---
 src/ui/picker.rs | 93 +++++++++++++++++++++++++++++++++++++++++++++++-
 1 file changed, 92 insertions(+), 1 deletion(-)

diff --git a/src/ui/picker.rs b/src/ui/picker.rs
index 3d0fba4..f2698da 100644
--- a/src/ui/picker.rs
+++ b/src/ui/picker.rs
@@ -1,4 +1,4 @@
-use crossterm::event::{self, Event, KeyCode};
+use crossterm::event::{self, Event, KeyCode, KeyModifiers};
 use fuzzy_matcher::skim::SkimMatcherV2;
 use fuzzy_matcher::FuzzyMatcher;
 use std::cmp::Reverse;
@@ -132,6 +132,14 @@ impl Component for Picker {
     fn handle_event(&mut self, ev: &event::Event) -> Option<KeyAction> {
         match ev {
             Event::Key(event) => match event.code {
+                KeyCode::Char('j') if event.modifiers.contains(KeyModifiers::CONTROL) => {
+                    self.list.move_down();
+                    None
+                }
+                KeyCode::Char('k') if event.modifiers.contains(KeyModifiers::CONTROL) => {
+                    self.list.move_up();
+                    None
+                }
                 KeyCode::Down => {
                     self.list.move_down();
                     None
@@ -251,3 +259,86 @@ impl PickerBuilder {
         picker
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use crossterm::event::{Event, KeyCode, KeyEvent, KeyModifiers};
+
+    use crate::{
+        buffer::Buffer,
+        config::{Config, KeyAction},
+        editor::{Action, Editor},
+        lsp::LspManager,
+        theme::Theme,
+        ui::{Component, Picker},
+    };
+
+    fn test_editor() -> Editor {
+        let config = Config::default();
+        let lsp = Box::new(LspManager::new(config.lsp.clone()));
+        let theme = Theme::default();
+        let buffer = Buffer::new(None, String::new());
+
+        Editor::with_size(lsp, 80, 24, config, theme, vec![buffer]).unwrap()
+    }
+
+    fn key(code: KeyCode, modifiers: KeyModifiers) -> Event {
+        Event::Key(KeyEvent::new(code, modifiers))
+    }
+
+    fn select(picker: &mut Picker) -> Option<KeyAction> {
+        picker.handle_event(&key(KeyCode::Enter, KeyModifiers::NONE))
+    }
+
+    #[test]
+    fn ctrl_j_moves_picker_selection_down() {
+        let editor = test_editor();
+        let items = vec!["alpha".to_string(), "bravo".to_string()];
+        let mut picker = Picker::new(Some("Files".to_string()), &editor, &items, None);
+
+        picker.handle_event(&key(KeyCode::Char('j'), KeyModifiers::CONTROL));
+
+        assert_eq!(
+            select(&mut picker),
+            Some(KeyAction::Multiple(vec![
+                Action::CloseDialog,
+                Action::Picked("bravo".to_string(), None),
+            ]))
+        );
+    }
+
+    #[test]
+    fn ctrl_k_moves_picker_selection_up() {
+        let editor = test_editor();
+        let items = vec!["alpha".to_string(), "bravo".to_string()];
+        let mut picker = Picker::new(Some("Files".to_string()), &editor, &items, None);
+
+        picker.handle_event(&key(KeyCode::Down, KeyModifiers::NONE));
+        picker.handle_event(&key(KeyCode::Char('k'), KeyModifiers::CONTROL));
+
+        assert_eq!(
+            select(&mut picker),
+            Some(KeyAction::Multiple(vec![
+                Action::CloseDialog,
+                Action::Picked("alpha".to_string(), None),
+            ]))
+        );
+    }
+
+    #[test]
+    fn plain_j_still_filters_picker_items() {
+        let editor = test_editor();
+        let items = vec!["kay".to_string(), "jay".to_string()];
+        let mut picker = Picker::new(Some("Files".to_string()), &editor, &items, None);
+
+        picker.handle_event(&key(KeyCode::Char('j'), KeyModifiers::NONE));
+
+        assert_eq!(
+            select(&mut picker),
+            Some(KeyAction::Multiple(vec![
+                Action::CloseDialog,
+                Action::Picked("jay".to_string(), None),
+            ]))
+        );
+    }
+}

From a46f0168290ca8dfb72c6971671d0f9f94dae51c Mon Sep 17 00:00:00 2001
From: Felipe Coury <felipe.coury@gmail.com>
Date: Thu, 28 May 2026 01:47:05 -0300
Subject: [PATCH 32/37] fix(tui): clamp cursor to rendered buffer lines

Use the buffer navigable line count for cursor bounds, gutter rendering, and viewport rendering so Ropey synthetic trailing lines are not exposed.

Preserve unterminated final lines by filling only the remaining row after rendering their content.
---
 src/buffer.rs                  | 15 +++++++++-
 src/editor.rs                  | 20 ++-----------
 src/editor/rendering.rs        | 20 ++++++++++++-
 tests/common/editor_harness.rs | 54 ++++++++++++++++++++++++++++++++++
 tests/movement.rs              |  6 ++++
 5 files changed, 96 insertions(+), 19 deletions(-)

diff --git a/src/buffer.rs b/src/buffer.rs
index 4324eef..4ecae4d 100644
--- a/src/buffer.rs
+++ b/src/buffer.rs
@@ -188,6 +188,19 @@ impl Buffer {
         self.content.len_lines() - 1
     }
 
+    pub fn last_navigable_line(&self) -> usize {
+        let last_line = self.len();
+        if last_line > 0 && self.get(last_line).is_some_and(|line| line.is_empty()) {
+            last_line - 1
+        } else {
+            last_line
+        }
+    }
+
+    pub fn navigable_line_count(&self) -> usize {
+        self.last_navigable_line() + 1
+    }
+
     /// Returns true if the buffer is empty
     pub fn is_empty(&self) -> bool {
         self.content.len_bytes() == 0
@@ -335,7 +348,7 @@ impl Buffer {
 
     /// Gets a portion of the buffer for viewport rendering
     pub fn viewport(&self, vtop: usize, vheight: usize) -> String {
-        let height = std::cmp::min(vtop + vheight, self.content.len_lines());
+        let height = std::cmp::min(vtop + vheight, self.navigable_line_count());
         let mut result = String::new();
         for i in vtop..height {
             result.push_str(&self.content.line(i).to_string());
diff --git a/src/editor.rs b/src/editor.rs
index 66d0552..7f340f6 100644
--- a/src/editor.rs
+++ b/src/editor.rs
@@ -1136,27 +1136,13 @@ impl Editor {
 
     // TODO: in neovim, when you are at an x position and you move to a shorter line, the cursor
     //       goes back to the max x but returns to the previous x position if the line is longer
-    fn last_buffer_line(&self) -> usize {
-        self.current_buffer().len()
-    }
-
     fn last_navigable_line(&self) -> usize {
-        let last_line = self.current_buffer().len();
-        if last_line > 0
-            && self
-                .current_buffer()
-                .get(last_line)
-                .is_some_and(|line| line.is_empty())
-        {
-            last_line - 1
-        } else {
-            last_line
-        }
+        self.current_buffer().last_navigable_line()
     }
 
     fn check_bounds(&mut self) -> bool {
         let old_position = (self.cx, self.cy, self.vtop);
-        let last_line = self.last_buffer_line();
+        let last_line = self.last_navigable_line();
         let viewport_height = self.vheight().max(1);
         let max_vtop = last_line.saturating_sub(viewport_height.saturating_sub(1));
 
@@ -2231,7 +2217,7 @@ impl Editor {
                 }
             }
             Action::MoveDown => {
-                if self.vtop + self.cy < self.current_buffer().len() {
+                if self.vtop + self.cy < self.last_navigable_line() {
                     self.cy += 1;
                     if self.cy >= self.vheight() {
                         // scroll if possible
diff --git a/src/editor/rendering.rs b/src/editor/rendering.rs
index 5e0c28b..c48eb37 100644
--- a/src/editor/rendering.rs
+++ b/src/editor/rendering.rs
@@ -629,6 +629,24 @@ impl Editor {
             }
         }
 
+        if !viewport_content.is_empty()
+            && !viewport_content.ends_with('\n')
+            && y < window.inner_height()
+        {
+            let term_y = self.window_to_terminal_y(window, y);
+            if x < window.inner_width() {
+                let term_x = self.window_to_terminal_x(window, x);
+                self.fill_line_in_window(
+                    buffer,
+                    term_x,
+                    term_y,
+                    window.inner_width().saturating_sub(x),
+                    &theme_style,
+                );
+            }
+            y += 1;
+        }
+
         // Fill any remaining lines within the window
         while y < window.inner_height() {
             let term_y = self.window_to_terminal_y(window, y);
@@ -1157,7 +1175,7 @@ impl Editor {
 
         for y in 0..window.inner_height() {
             let line_number = y + 1 + window.vtop;
-            let line_count = window_buffer.len().saturating_add(1);
+            let line_count = window_buffer.navigable_line_count();
             let text = if line_number <= line_count {
                 format!("{:>width$} ", line_number)
             } else {
diff --git a/tests/common/editor_harness.rs b/tests/common/editor_harness.rs
index 83936df..d1bd0df 100644
--- a/tests/common/editor_harness.rs
+++ b/tests/common/editor_harness.rs
@@ -331,6 +331,23 @@ mod tests {
         harness.assert_cursor_at(0, 2);
     }
 
+    #[tokio::test]
+    async fn test_window_cursor_clamps_to_last_real_line_with_trailing_newline() {
+        let mut harness = EditorHarness::with_content("Line 1\nLine 2\nLine 3\n");
+
+        harness.execute_action(Action::SplitVertical).await.unwrap();
+        assert_eq!(harness.active_window_id(), 1);
+
+        for _ in 0..10 {
+            harness.execute_action(Action::MoveDown).await.unwrap();
+        }
+
+        harness.assert_cursor_at(0, 2);
+        assert_eq!(harness.buffer_line(), 2);
+        assert_eq!(harness.current_line(), Some("Line 3\n".to_string()));
+        assert_eq!(harness.render_cursor_position(), Some((43, 2)));
+    }
+
     #[tokio::test]
     async fn test_render_cursor_uses_active_window_buffer_line() {
         let content = (0..30)
@@ -381,6 +398,43 @@ mod tests {
         std::fs::remove_file(root).unwrap();
     }
 
+    #[test]
+    fn test_empty_buffer_gutter_hides_synthetic_trailing_line() {
+        let mut harness = EditorHarness::new();
+
+        let first_row = harness.render_row(0).unwrap();
+        let second_row = harness.render_row(1).unwrap();
+
+        assert_eq!(first_row.chars().take(3).collect::<String>(), " 1 ");
+        assert_eq!(second_row.chars().take(3).collect::<String>(), "   ");
+    }
+
+    #[test]
+    fn test_trailing_newline_gutter_hides_synthetic_trailing_line() {
+        let mut harness = EditorHarness::with_content("Line 1\nLine 2\n");
+
+        let first_row = harness.render_row(0).unwrap();
+        let second_row = harness.render_row(1).unwrap();
+        let third_row = harness.render_row(2).unwrap();
+
+        assert_eq!(first_row.chars().take(3).collect::<String>(), " 1 ");
+        assert_eq!(second_row.chars().take(3).collect::<String>(), " 2 ");
+        assert_eq!(third_row.chars().take(3).collect::<String>(), "   ");
+    }
+
+    #[test]
+    fn test_final_line_without_trailing_newline_renders_content() {
+        let mut harness = EditorHarness::with_content("Line 1\nLine 2");
+
+        let first_row = harness.render_row(0).unwrap();
+        let second_row = harness.render_row(1).unwrap();
+        let third_row = harness.render_row(2).unwrap();
+
+        assert!(first_row.contains("Line 1"));
+        assert!(second_row.contains("Line 2"));
+        assert_eq!(third_row.chars().take(3).collect::<String>(), "   ");
+    }
+
     #[test]
     fn test_search_commandline_renders_search_text_on_small_width() {
         let mut harness = EditorHarness::new();
diff --git a/tests/movement.rs b/tests/movement.rs
index 95182b0..86569ad 100644
--- a/tests/movement.rs
+++ b/tests/movement.rs
@@ -232,6 +232,12 @@ async fn test_goto_line() {
 async fn test_movement_clamps_to_last_real_line_with_trailing_newline() {
     let mut harness = EditorHarness::with_content("Line 1\nLine 2\nLine 3\n");
 
+    for _ in 0..10 {
+        harness.execute_action(Action::MoveDown).await.unwrap();
+    }
+    harness.assert_cursor_at(0, 2);
+    assert_eq!(harness.current_line(), Some("Line 3\n".to_string()));
+
     harness.execute_action(Action::MoveToBottom).await.unwrap();
     harness.assert_cursor_at(0, 2);
     assert_eq!(harness.current_line(), Some("Line 3\n".to_string()));

From e5fd9214ff7e663e7e692fec37c69e26da769566 Mon Sep 17 00:00:00 2001
From: Felipe Coury <felipe.coury@gmail.com>
Date: Thu, 28 May 2026 01:53:18 -0300
Subject: [PATCH 33/37] fix(tui): preserve insert and visual unicode edits

Keep an opened trailing line navigable while insert mode is active so `o` at EOF keeps the cursor on the new line.

Convert visual selections from grapheme positions to Rope character positions before deleting text.
---
 src/editor.rs                  | 28 ++++++++++++++++++++--------
 src/editor/rendering.rs        |  8 ++++++--
 tests/common/editor_harness.rs | 16 ++++++++++++++++
 tests/unicode.rs               | 25 +++++++++++++++++++++++++
 4 files changed, 67 insertions(+), 10 deletions(-)

diff --git a/src/editor.rs b/src/editor.rs
index 7f340f6..ac40493 100644
--- a/src/editor.rs
+++ b/src/editor.rs
@@ -1142,7 +1142,11 @@ impl Editor {
 
     fn check_bounds(&mut self) -> bool {
         let old_position = (self.cx, self.cy, self.vtop);
-        let last_line = self.last_navigable_line();
+        let last_line = if self.is_insert() {
+            self.current_buffer().len()
+        } else {
+            self.last_navigable_line()
+        };
         let viewport_height = self.vheight().max(1);
         let max_vtop = last_line.saturating_sub(viewport_height.saturating_sub(1));
 
@@ -3751,14 +3755,18 @@ impl Editor {
 
                         for y in y0..=y1 {
                             if let Some(line) = self.current_buffer().get(y) {
-                                let line_len = line.trim_end_matches('\n').chars().count();
+                                let line = line.trim_end_matches('\n');
+                                let line_len = grapheme_len(line);
                                 if min_x >= line_len {
                                     continue;
                                 }
+                                let start = self.grapheme_to_char_on_line(min_x, y);
+                                let end =
+                                    self.grapheme_to_char_on_line((max_x + 1).min(line_len), y);
                                 self.replace_range(
                                     TextRange::new(
-                                        TextPosition::new(y, min_x),
-                                        TextPosition::new(y, (max_x + 1).min(line_len)),
+                                        TextPosition::new(y, start),
+                                        TextPosition::new(y, end),
                                     ),
                                     "",
                                 );
@@ -3767,18 +3775,22 @@ impl Editor {
                     }
                     Mode::Visual => {
                         if y0 == y1 {
+                            let start = self.grapheme_to_char_on_line(x0, y0);
+                            let end = self.grapheme_to_char_on_line(x1 + 1, y0);
                             self.replace_range(
                                 TextRange::new(
-                                    TextPosition::new(y0, x0),
-                                    TextPosition::new(y0, x1 + 1),
+                                    TextPosition::new(y0, start),
+                                    TextPosition::new(y0, end),
                                 ),
                                 "",
                             );
                         } else {
+                            let start = self.grapheme_to_char_on_line(x0, y0);
+                            let end = self.grapheme_to_char_on_line(x1 + 1, y1);
                             self.replace_range(
                                 TextRange::new(
-                                    TextPosition::new(y0, x0),
-                                    TextPosition::new(y1, x1 + 1),
+                                    TextPosition::new(y0, start),
+                                    TextPosition::new(y1, end),
                                 ),
                                 "",
                             );
diff --git a/src/editor/rendering.rs b/src/editor/rendering.rs
index c48eb37..41f74b4 100644
--- a/src/editor/rendering.rs
+++ b/src/editor/rendering.rs
@@ -109,7 +109,7 @@ impl Editor {
             );
 
             // Render the gutter for this window
-            self.render_gutter_in_window(buffer, &window)?;
+            self.render_gutter_in_window(buffer, &window, window_id)?;
 
             // Render the window content with proper boundaries
             self.render_main_content_in_window(buffer, &window)?;
@@ -1157,6 +1157,7 @@ impl Editor {
         &mut self,
         buffer: &mut RenderBuffer,
         window: &crate::window::Window,
+        window_id: usize,
     ) -> anyhow::Result<()> {
         use crate::log;
         let width = self.gutter_width_for_window(window);
@@ -1175,7 +1176,10 @@ impl Editor {
 
         for y in 0..window.inner_height() {
             let line_number = y + 1 + window.vtop;
-            let line_count = window_buffer.navigable_line_count();
+            let mut line_count = window_buffer.navigable_line_count();
+            if self.window_manager.active_window_id() == window_id && self.is_insert() {
+                line_count = line_count.max(window.vtop + window.cy + 1);
+            }
             let text = if line_number <= line_count {
                 format!("{:>width$} ", line_number)
             } else {
diff --git a/tests/common/editor_harness.rs b/tests/common/editor_harness.rs
index d1bd0df..42fc824 100644
--- a/tests/common/editor_harness.rs
+++ b/tests/common/editor_harness.rs
@@ -435,6 +435,22 @@ mod tests {
         assert_eq!(third_row.chars().take(3).collect::<String>(), "   ");
     }
 
+    #[tokio::test]
+    async fn test_insert_mode_gutter_keeps_opened_trailing_line_visible() {
+        let mut harness = EditorHarness::with_content("Line 1");
+
+        harness
+            .execute_action(Action::InsertLineBelowCursor)
+            .await
+            .unwrap();
+
+        harness.assert_mode(Mode::Insert);
+        harness.assert_cursor_at(0, 1);
+
+        let second_row = harness.render_row(1).unwrap();
+        assert_eq!(second_row.chars().take(3).collect::<String>(), " 2 ");
+    }
+
     #[test]
     fn test_search_commandline_renders_search_text_on_small_width() {
         let mut harness = EditorHarness::new();
diff --git a/tests/unicode.rs b/tests/unicode.rs
index f290241..059e0c3 100644
--- a/tests/unicode.rs
+++ b/tests/unicode.rs
@@ -162,6 +162,31 @@ async fn test_family_emoji_zwj_sequence() {
     assert_eq!(line, "\n", "Entire emoji sequence should be deleted");
 }
 
+#[tokio::test]
+async fn test_visual_delete_removes_entire_zwj_grapheme() {
+    let mut h = EditorHarness::with_content("👨‍👩‍👧‍👦 family");
+
+    h.execute_action(Action::EnterMode(Mode::Visual))
+        .await
+        .unwrap();
+    h.execute_action(Action::Delete).await.unwrap();
+
+    h.assert_buffer_contents(" family");
+}
+
+#[tokio::test]
+async fn test_visual_block_delete_removes_entire_combining_grapheme() {
+    let mut h = EditorHarness::with_content("e\u{301}x\ne\u{301}y");
+
+    h.execute_action(Action::EnterMode(Mode::VisualBlock))
+        .await
+        .unwrap();
+    h.execute_action(Action::MoveDown).await.unwrap();
+    h.execute_action(Action::Delete).await.unwrap();
+
+    h.assert_buffer_contents("x\ny");
+}
+
 #[tokio::test]
 async fn test_flag_emoji() {
     let mut h = EditorHarness::new();

From a7b0707767243e3ee55aed8d9719194790152f17 Mon Sep 17 00:00:00 2001
From: Felipe Coury <felipe.coury@gmail.com>
Date: Thu, 28 May 2026 02:01:07 -0300
Subject: [PATCH 34/37] fix(tui): restore backspace and tab unicode edits

Join lines when backspace is pressed at column zero on a later line, preserving the expected insert-mode editing behavior.

Convert tab insertion from grapheme cursor coordinates to Rope character coordinates before editing multi-codepoint graphemes.
---
 src/editor.rs    | 46 ++++++++++++++++++++++++++++++++++++++--------
 tests/editing.rs | 18 ++++++++++++++++++
 tests/unicode.rs | 11 +++++++++++
 3 files changed, 67 insertions(+), 8 deletions(-)

diff --git a/src/editor.rs b/src/editor.rs
index ac40493..dc933f0 100644
--- a/src/editor.rs
+++ b/src/editor.rs
@@ -2686,11 +2686,16 @@ impl Editor {
                 self.render(buffer)?;
             }
             Action::DeletePreviousChar => {
+                if self.cx == 0 && self.buffer_line() == 0 {
+                    return Ok(false);
+                }
+
+                let started_transaction = !self.transaction_active();
+                if started_transaction {
+                    self.begin_transaction("delete previous char");
+                }
+
                 if self.cx > 0 {
-                    let started_transaction = !self.transaction_active();
-                    if started_transaction {
-                        self.begin_transaction("delete previous char");
-                    }
                     // Get the current line to find the previous grapheme boundary
                     if let Some(line) = self.current_line_contents() {
                         let line = line.trim_end_matches('\n');
@@ -2712,14 +2717,38 @@ impl Editor {
                                 "",
                             );
                             self.cx = prev_grapheme_idx;
-                            if started_transaction {
-                                self.commit_transaction(self.cursor_snapshot());
-                            }
 
                             self.notify_change(runtime).await?;
                             self.draw_line(buffer);
                         }
                     }
+                } else if self.buffer_line() > 0 {
+                    let line_num = self.buffer_line();
+                    let previous_line = self.current_buffer().get(line_num - 1).unwrap_or_default();
+                    let previous_line = previous_line.trim_end_matches('\n');
+                    let previous_char_len = previous_line.chars().count();
+                    let previous_grapheme_len = grapheme_len(previous_line);
+
+                    self.replace_range(
+                        TextRange::new(
+                            TextPosition::new(line_num - 1, previous_char_len),
+                            TextPosition::new(line_num, 0),
+                        ),
+                        "",
+                    );
+                    self.cx = previous_grapheme_len;
+                    if self.cy > 0 {
+                        self.cy -= 1;
+                    } else {
+                        self.vtop = self.vtop.saturating_sub(1);
+                    }
+
+                    self.notify_change(runtime).await?;
+                    self.render(buffer)?;
+                }
+
+                if started_transaction {
+                    self.commit_transaction(self.cursor_snapshot());
                 }
             }
             Action::DumpHistory => {
@@ -2996,12 +3025,13 @@ impl Editor {
                 let tabsize = 4;
                 let cx = self.cx;
                 let line = self.buffer_line();
+                let char_cx = self.grapheme_to_char_on_line(cx, line);
                 let started_transaction = !self.transaction_active();
                 if started_transaction {
                     self.begin_transaction("insert tab");
                 }
                 self.replace_range(
-                    TextRange::insertion(TextPosition::new(line, cx)),
+                    TextRange::insertion(TextPosition::new(line, char_cx)),
                     &" ".repeat(tabsize),
                 );
                 self.notify_change(runtime).await?;
diff --git a/tests/editing.rs b/tests/editing.rs
index 52253ae..197dd1e 100644
--- a/tests/editing.rs
+++ b/tests/editing.rs
@@ -469,6 +469,24 @@ async fn test_undo_insert_backspace_session() {
     harness.assert_buffer_contents("ab\n");
 }
 
+#[tokio::test]
+async fn test_backspace_at_line_start_joins_with_previous_line() {
+    let mut harness = EditorHarness::with_content("abc\ndef");
+
+    harness.execute_action(Action::MoveDown).await.unwrap();
+    harness
+        .execute_action(Action::EnterMode(Mode::Insert))
+        .await
+        .unwrap();
+    harness
+        .execute_action(Action::DeletePreviousChar)
+        .await
+        .unwrap();
+
+    harness.assert_buffer_contents("abcdef");
+    harness.assert_cursor_at(3, 0);
+}
+
 #[tokio::test]
 async fn test_undo_delete_range_and_word() {
     let mut harness = EditorHarness::with_content("hello world");
diff --git a/tests/unicode.rs b/tests/unicode.rs
index 059e0c3..aec7a6e 100644
--- a/tests/unicode.rs
+++ b/tests/unicode.rs
@@ -187,6 +187,17 @@ async fn test_visual_block_delete_removes_entire_combining_grapheme() {
     h.assert_buffer_contents("x\ny");
 }
 
+#[tokio::test]
+async fn test_tab_after_zwj_grapheme_preserves_emoji() {
+    let mut h = EditorHarness::with_content("👨‍👩‍👧‍👦x");
+
+    h.execute_action(Action::MoveRight).await.unwrap();
+    h.execute_action(Action::InsertTab).await.unwrap();
+
+    h.assert_buffer_contents("👨‍👩‍👧‍👦    x");
+    h.assert_cursor_at(5, 0);
+}
+
 #[tokio::test]
 async fn test_flag_emoji() {
     let mut h = EditorHarness::new();

From c79db8fc19491d43315c46419fea6e23b89e1856 Mon Sep 17 00:00:00 2001
From: Felipe Coury <felipe.coury@gmail.com>
Date: Thu, 28 May 2026 02:17:07 -0300
Subject: [PATCH 35/37] fix(tui): align word and ui grapheme handling

Convert word command cursor positions between grapheme and Rope character offsets before using buffer word helpers. This keeps ZWJ and combining graphemes intact during word motion and deletion.

Store full grapheme text in render cells and print that text during diff rendering so UI strings preserve multi-codepoint grapheme clusters.
---
 src/editor.rs               |  71 ++++++++++++++++++++-----
 src/editor/render_buffer.rs | 103 +++++++++++++++++-------------------
 src/editor/rendering.rs     |   2 +-
 tests/unicode.rs            |  29 ++++++++++
 4 files changed, 139 insertions(+), 66 deletions(-)

diff --git a/src/editor.rs b/src/editor.rs
index dc933f0..af54cde 100644
--- a/src/editor.rs
+++ b/src/editor.rs
@@ -10,8 +10,8 @@ use std::{
 };
 
 use crate::unicode_utils::{
-    char_prefix, char_slice, char_suffix, display_width, grapheme_len, grapheme_to_byte,
-    grapheme_to_char, next_grapheme_boundary, prev_grapheme_boundary,
+    char_prefix, char_slice, char_suffix, char_to_grapheme, display_width, grapheme_len,
+    grapheme_to_byte, grapheme_to_char, next_grapheme_boundary, prev_grapheme_boundary,
 };
 
 /// Editor is the main component that handles:
@@ -872,6 +872,30 @@ impl Editor {
             .unwrap_or(x)
     }
 
+    fn char_to_grapheme_on_line(&self, x: usize, y: usize) -> usize {
+        self.current_buffer()
+            .get(y)
+            .map(|line| char_to_grapheme(line.trim_end_matches('\n'), x))
+            .unwrap_or(x)
+    }
+
+    fn next_word_search_char_on_line(&self, x: usize, y: usize) -> usize {
+        let Some(line) = self.current_buffer().get(y) else {
+            return x;
+        };
+        let line = line.trim_end_matches('\n');
+        if x > 0
+            && line
+                .graphemes(true)
+                .nth(x)
+                .is_some_and(|grapheme| grapheme.chars().all(char::is_whitespace))
+        {
+            grapheme_to_char(line, x - 1)
+        } else {
+            grapheme_to_char(line, x)
+        }
+    }
+
     /// Returns the display width of the current line in columns
     #[allow(dead_code)]
     fn line_display_width(&self) -> usize {
@@ -2981,12 +3005,12 @@ impl Editor {
                 }
             }
             Action::MoveToNextWord => {
-                let next_word = self
-                    .current_buffer()
-                    .find_next_word((self.cx, self.buffer_line()));
+                let line = self.buffer_line();
+                let char_cx = self.next_word_search_char_on_line(self.cx, line);
+                let next_word = self.current_buffer().find_next_word((char_cx, line));
 
                 if let Some((x, y)) = next_word {
-                    self.cx = x;
+                    self.cx = self.char_to_grapheme_on_line(x, y);
                     if self.is_within_viewport(y) {
                         self.cy = y - self.vtop;
                     } else {
@@ -2997,12 +3021,12 @@ impl Editor {
                 }
             }
             Action::MoveToPreviousWord => {
-                let previous_word = self
-                    .current_buffer()
-                    .find_prev_word((self.cx, self.buffer_line()));
+                let line = self.buffer_line();
+                let char_cx = self.grapheme_to_char_on_line(self.cx, line);
+                let previous_word = self.current_buffer().find_prev_word((char_cx, line));
 
                 if let Some((x, y)) = previous_word {
-                    self.cx = x;
+                    self.cx = self.char_to_grapheme_on_line(x, y);
                     if self.is_within_viewport(y) {
                         self.cy = y - self.vtop;
                     } else {
@@ -3104,12 +3128,14 @@ impl Editor {
             Action::DeleteWord => {
                 let cx = self.cx;
                 let line = self.buffer_line();
+                let char_cx = self.grapheme_to_char_on_line(cx, line);
 
-                if let Some((end_x, end_y)) = self.current_buffer().find_next_word((cx, line)) {
+                if let Some((end_x, end_y)) = self.current_buffer().find_next_word((char_cx, line))
+                {
                     self.begin_transaction("delete word");
                     self.replace_range(
                         TextRange::new(
-                            TextPosition::new(line, cx),
+                            TextPosition::new(line, char_cx),
                             TextPosition::new(end_y, end_x),
                         ),
                         "",
@@ -4811,6 +4837,27 @@ mod test {
         assert_eq!(rendered, "a👋 b ");
     }
 
+    #[test]
+    fn test_render_buffer_set_text_preserves_grapheme_clusters() {
+        let mut buffer = RenderBuffer::new(5, 1, &Style::default());
+
+        buffer.set_text(0, 0, "👨‍👩‍👧‍👦x", &Style::default());
+
+        assert_eq!(buffer.cells[0].text, "👨‍👩‍👧‍👦");
+        assert_eq!(buffer.cells[1].text, " ");
+        assert_eq!(buffer.cells[2].text, "x");
+    }
+
+    #[test]
+    fn test_render_buffer_set_text_preserves_combining_graphemes() {
+        let mut buffer = RenderBuffer::new(3, 1, &Style::default());
+
+        buffer.set_text(0, 0, "e\u{301}x", &Style::default());
+
+        assert_eq!(buffer.cells[0].text, "e\u{301}");
+        assert_eq!(buffer.cells[1].text, "x");
+    }
+
     #[test]
     fn test_render_buffer_ignores_width_boundary_writes() {
         let mut buffer = RenderBuffer::new(2, 2, &Style::default());
diff --git a/src/editor/render_buffer.rs b/src/editor/render_buffer.rs
index ea02f3c..eb57c87 100644
--- a/src/editor/render_buffer.rs
+++ b/src/editor/render_buffer.rs
@@ -2,8 +2,9 @@ use crate::{
     color::{blend_color, Color},
     log,
     theme::{Style, Theme},
-    unicode_utils::{char_display_width, display_width},
+    unicode_utils::display_width,
 };
+use unicode_segmentation::UnicodeSegmentation;
 
 use super::Point;
 
@@ -17,9 +18,28 @@ pub struct Change<'a> {
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub struct Cell {
     pub c: char,
+    pub text: String,
     pub style: Style,
 }
 
+impl Cell {
+    fn new(c: char, style: Style) -> Self {
+        Self {
+            c,
+            text: c.to_string(),
+            style,
+        }
+    }
+
+    fn from_grapheme(grapheme: &str, style: Style) -> Self {
+        Self {
+            c: grapheme.chars().next().unwrap_or(' '),
+            text: grapheme.to_string(),
+            style,
+        }
+    }
+}
+
 #[derive(Debug, Clone)]
 pub struct RenderBuffer {
     pub cells: Vec<Cell>,
@@ -30,13 +50,7 @@ pub struct RenderBuffer {
 
 impl RenderBuffer {
     pub fn new(width: usize, height: usize, default_style: &Style) -> Self {
-        let cells = vec![
-            Cell {
-                c: ' ',
-                style: default_style.clone(),
-            };
-            width * height
-        ];
+        let cells = vec![Cell::new(' ', default_style.clone()); width * height];
 
         RenderBuffer {
             cells,
@@ -54,17 +68,18 @@ impl RenderBuffer {
         let mut cells = vec![];
 
         for line in contents {
-            for c in line.chars() {
-                cells.push(Cell {
-                    c,
-                    style: style.clone(),
-                });
+            for grapheme in line.graphemes(true) {
+                let grapheme_width = display_width(grapheme);
+                if grapheme_width == 0 {
+                    continue;
+                }
+                cells.push(Cell::from_grapheme(grapheme, style.clone()));
+                for _ in 1..grapheme_width {
+                    cells.push(Cell::new(' ', style.clone()));
+                }
             }
             for _ in 0..width.saturating_sub(display_width(&line)) {
-                cells.push(Cell {
-                    c: ' ',
-                    style: style.clone(),
-                });
+                cells.push(Cell::new(' ', style.clone()));
             }
         }
 
@@ -77,13 +92,7 @@ impl RenderBuffer {
 
     /// Clears the buffer with the given style
     pub fn clear(&mut self) {
-        self.cells = vec![
-            Cell {
-                c: ' ',
-                style: Style::default(),
-            };
-            self.width * self.height
-        ];
+        self.cells = vec![Cell::new(' ', Style::default()); self.width * self.height];
     }
 
     pub fn write_string(
@@ -111,10 +120,7 @@ impl RenderBuffer {
         if pos >= self.cells.len() {
             return;
         }
-        self.cells[pos] = Cell {
-            c,
-            style: style.clone(),
-        };
+        self.cells[pos] = Cell::new(c, style.clone());
     }
 
     pub fn set_bg_for_points(&mut self, points: Vec<Point>, bg: &Color, theme: &Theme) {
@@ -187,15 +193,15 @@ impl RenderBuffer {
             );
         }
 
-        self.cells[pos] = Cell {
+        self.cells[pos] = Cell::new(
             c,
-            style: Style {
+            Style {
                 fg: style.fg,
                 bg,
                 bold: style.bold,
                 italic: style.italic,
             },
-        };
+        );
     }
 
     pub fn set_text(&mut self, x: usize, y: usize, text: &str, style: &Style) {
@@ -204,13 +210,13 @@ impl RenderBuffer {
         }
 
         let mut cell_x = x;
-        for c in text.chars() {
+        for grapheme in text.graphemes(true) {
             if cell_x >= self.width {
                 break;
             }
 
-            let char_width = char_display_width(c);
-            if char_width == 0 {
+            let grapheme_width = display_width(grapheme);
+            if grapheme_width == 0 {
                 continue;
             }
 
@@ -219,12 +225,9 @@ impl RenderBuffer {
                 log!("WARN: pos >= self.cells.len()");
                 break;
             }
-            self.cells[pos] = Cell {
-                c,
-                style: style.clone(),
-            };
+            self.cells[pos] = Cell::from_grapheme(grapheme, style.clone());
 
-            for offset in 1..char_width {
+            for offset in 1..grapheme_width {
                 let pad_x = cell_x + offset;
                 if pad_x >= self.width {
                     break;
@@ -234,13 +237,10 @@ impl RenderBuffer {
                     log!("WARN: pad_pos >= self.cells.len()");
                     break;
                 }
-                self.cells[pad_pos] = Cell {
-                    c: ' ',
-                    style: style.clone(),
-                };
+                self.cells[pad_pos] = Cell::new(' ', style.clone());
             }
 
-            cell_x += char_width;
+            cell_x += grapheme_width;
         }
     }
 
@@ -250,7 +250,7 @@ impl RenderBuffer {
         for y in 0..self.height {
             for x in 0..self.width {
                 if let Some(change) = changes.iter().find(|c| c.x == x && c.y == y) {
-                    s.push(change.cell.c);
+                    s.push_str(&change.cell.text);
                 } else {
                     s.push('·');
                 }
@@ -293,7 +293,7 @@ impl RenderBuffer {
             if i % self.width == 0 {
                 s.push('\n');
             }
-            if cell.c == ' ' {
+            if cell.text == " " {
                 // pushes a unicode dot if space
                 s.push('·');
             } else if show_style_changes {
@@ -302,14 +302,14 @@ impl RenderBuffer {
                         s.push('|');
                         current_syle = Some(cell.style.clone());
                     } else {
-                        s.push(cell.c);
+                        s.push_str(&cell.text);
                     }
                 } else {
-                    s.push(cell.c);
+                    s.push_str(&cell.text);
                     current_syle = Some(cell.style.clone());
                 }
             } else {
-                s.push(cell.c);
+                s.push_str(&cell.text);
             }
         }
 
@@ -320,10 +320,7 @@ impl RenderBuffer {
     fn apply(&mut self, diff: Vec<Change<'_>>) {
         for change in diff {
             let pos = (change.y * self.width) + change.x;
-            self.cells[pos] = Cell {
-                c: change.cell.c,
-                style: change.cell.style.clone(),
-            };
+            self.cells[pos] = change.cell.clone();
         }
     }
 }
diff --git a/src/editor/rendering.rs b/src/editor/rendering.rs
index 41f74b4..53afab9 100644
--- a/src/editor/rendering.rs
+++ b/src/editor/rendering.rs
@@ -998,7 +998,7 @@ impl Editor {
                     y
                 );
             }
-            self.stdout.queue(style::Print(cell.c))?;
+            self.stdout.queue(style::Print(cell.text.as_str()))?;
         }
 
         self.stdout.queue(cursor::Show)?;
diff --git a/tests/unicode.rs b/tests/unicode.rs
index aec7a6e..1bd71c8 100644
--- a/tests/unicode.rs
+++ b/tests/unicode.rs
@@ -242,3 +242,32 @@ async fn test_word_navigation_with_unicode() {
     let (x, _) = h.cursor_position();
     assert_eq!(x, 14, "Should be at emoji");
 }
+
+#[tokio::test]
+async fn test_word_navigation_after_zwj_grapheme() {
+    let mut h = EditorHarness::with_content("👨‍👩‍👧‍👦 abc def");
+
+    h.execute_action(Action::MoveRight).await.unwrap();
+    h.assert_cursor_at(1, 0);
+
+    h.execute_action(Action::MoveToNextWord).await.unwrap();
+    h.assert_cursor_at(2, 0);
+
+    h.execute_action(Action::MoveToNextWord).await.unwrap();
+    h.assert_cursor_at(6, 0);
+
+    h.execute_action(Action::MoveToPreviousWord).await.unwrap();
+    h.assert_cursor_at(2, 0);
+}
+
+#[tokio::test]
+async fn test_delete_word_after_zwj_grapheme() {
+    let mut h = EditorHarness::with_content("👨‍👩‍👧‍👦 abc def");
+
+    h.execute_action(Action::MoveRight).await.unwrap();
+    h.execute_action(Action::MoveToNextWord).await.unwrap();
+    h.execute_action(Action::DeleteWord).await.unwrap();
+
+    h.assert_buffer_contents("👨‍👩‍👧‍👦 def");
+    h.assert_cursor_at(2, 0);
+}

From 68e0ec326e1a01723a67eba3f19bb70c44163ba6 Mon Sep 17 00:00:00 2001
From: Felipe Coury <felipe.coury@gmail.com>
Date: Thu, 28 May 2026 02:23:47 -0300
Subject: [PATCH 36/37] fix(tui): keep panel and line-open state consistent

Clamp panel scroll when row updates shrink the visible model so panel rendering cannot skip past the remaining rows.

Keep direct line-open insert actions in the active insert transaction so typing after `InsertLineBelowCursor` or `InsertLineAtCursor` undoes as one insert session.
---
 src/editor.rs       |  6 ------
 src/plugin/panel.rs | 17 +++++++++++++++++
 tests/editing.rs    | 19 +++++++++++++++++++
 3 files changed, 36 insertions(+), 6 deletions(-)

diff --git a/src/editor.rs b/src/editor.rs
index af54cde..89157d6 100644
--- a/src/editor.rs
+++ b/src/editor.rs
@@ -2641,9 +2641,6 @@ impl Editor {
                 self.cy += 1;
                 self.cx = leading_spaces;
                 self.mode = Mode::Insert;
-                if started_transaction {
-                    self.commit_transaction(self.cursor_snapshot());
-                }
 
                 if self.cy >= self.vheight() {
                     self.vtop += 1;
@@ -2676,9 +2673,6 @@ impl Editor {
                 self.notify_change(runtime).await?;
                 self.cx = leading_spaces;
                 self.mode = Mode::Insert;
-                if started_transaction {
-                    self.commit_transaction(self.cursor_snapshot());
-                }
                 self.render(buffer)?;
             }
             Action::MoveToTop => {
diff --git a/src/plugin/panel.rs b/src/plugin/panel.rs
index 41269c0..b6a05e1 100644
--- a/src/plugin/panel.rs
+++ b/src/plugin/panel.rs
@@ -93,6 +93,10 @@ impl PluginPanel {
         } else if self.selected >= self.rows.len() {
             self.selected = self.rows.len() - 1;
         }
+
+        if self.scroll > self.selected {
+            self.scroll = self.selected;
+        }
     }
 
     pub fn move_selection(&mut self, delta: isize, height: usize) {
@@ -324,4 +328,17 @@ mod tests {
         assert_eq!(event.selected_index, 1);
         assert_eq!(event.row.unwrap().id, "b");
     }
+
+    #[test]
+    fn update_rows_clamps_scroll_to_remaining_rows() {
+        let mut panel = PluginPanel::new("tree".to_string(), PanelConfig::default());
+        panel.update_rows((0..10).map(|i| row(&i.to_string())).collect());
+        panel.selected = 8;
+        panel.scroll = 6;
+
+        panel.update_rows(vec![row("a"), row("b")]);
+
+        assert_eq!(panel.selected, 1);
+        assert_eq!(panel.scroll, 1);
+    }
 }
diff --git a/tests/editing.rs b/tests/editing.rs
index 197dd1e..3c1b236 100644
--- a/tests/editing.rs
+++ b/tests/editing.rs
@@ -855,6 +855,25 @@ async fn test_yank_and_paste() {
     // This depends on clipboard/register implementation
 }
 
+#[tokio::test]
+async fn test_direct_open_line_below_groups_insert_undo() {
+    let mut harness = EditorHarness::with_content("Line 1\nLine 2");
+
+    harness
+        .execute_action(Action::InsertLineBelowCursor)
+        .await
+        .unwrap();
+    harness.type_text("New line").await.unwrap();
+    harness
+        .execute_action(Action::EnterMode(Mode::Normal))
+        .await
+        .unwrap();
+
+    harness.assert_buffer_contents("Line 1\nNew line\nLine 2");
+    harness.execute_action(Action::Undo).await.unwrap();
+    harness.assert_buffer_contents("Line 1\nLine 2");
+}
+
 #[tokio::test]
 async fn test_editing_empty_buffer() {
     let mut harness = EditorHarness::new();

From 2db0adc76cc4efb5517b723c403e996609796147 Mon Sep 17 00:00:00 2001
From: Felipe Coury <felipe.coury@gmail.com>
Date: Thu, 28 May 2026 02:31:51 -0300
Subject: [PATCH 37/37] fix(tui): reserve right panels and save active edits

Reserve both left and right plugin panel widths before laying out editor windows so right-side panels do not draw over editor content.

Commit active insert transactions before save checkpoints are marked clean, then reopen insert transactions so continued insert-mode edits keep normal grouping.
---
 src/editor.rs       | 99 +++++++++++++++++++++++++++++++++------------
 src/plugin/panel.rs | 23 +++++++++++
 tests/editing.rs    | 47 +++++++++++++++++++++
 3 files changed, 143 insertions(+), 26 deletions(-)

diff --git a/src/editor.rs b/src/editor.rs
index 89157d6..d917047 100644
--- a/src/editor.rs
+++ b/src/editor.rs
@@ -758,11 +758,14 @@ impl Editor {
 
     fn resize_window_layout(&mut self, terminal_size: (usize, usize)) {
         self.sync_to_window();
-        let reserved_left = self.reserved_panel_left_width();
+        let (reserved_left, reserved_right) = self.reserved_panel_widths(terminal_size.0);
         self.window_manager.resize_with_origin(
             Point::new(reserved_left, 0),
             (
-                terminal_size.0.saturating_sub(reserved_left),
+                terminal_size
+                    .0
+                    .saturating_sub(reserved_left)
+                    .saturating_sub(reserved_right),
                 terminal_size.1,
             ),
         );
@@ -771,20 +774,26 @@ impl Editor {
 
     fn apply_panel_layout(&mut self) {
         self.sync_to_window();
-        let reserved_left = self.reserved_panel_left_width();
+        let (reserved_left, reserved_right) = self.reserved_panel_widths(self.size.0 as usize);
         self.window_manager.resize_with_origin(
             Point::new(reserved_left, 0),
             (
-                (self.size.0 as usize).saturating_sub(reserved_left),
+                (self.size.0 as usize)
+                    .saturating_sub(reserved_left)
+                    .saturating_sub(reserved_right),
                 self.size.1 as usize,
             ),
         );
     }
 
-    fn reserved_panel_left_width(&self) -> usize {
-        self.panel_manager
-            .reserved_left_width()
-            .min((self.size.0 as usize).saturating_sub(10))
+    fn reserved_panel_widths(&self, terminal_width: usize) -> (usize, usize) {
+        let max_reserved = terminal_width.saturating_sub(10);
+        let reserved_left = self.panel_manager.reserved_left_width().min(max_reserved);
+        let reserved_right = self
+            .panel_manager
+            .reserved_right_width()
+            .min(max_reserved.saturating_sub(reserved_left));
+        (reserved_left, reserved_right)
     }
 
     fn indentation(&self) -> Indentation {
@@ -3059,28 +3068,38 @@ impl Editor {
                 }
                 self.draw_line(buffer);
             }
-            Action::Save => match self.current_buffer_mut().save() {
-                Ok(msg) => {
-                    // TODO: use last_message instead of last_error
-                    self.last_error = Some(msg);
+            Action::Save => {
+                let resume_insert_transaction = self.commit_active_transaction_before_save();
+                let save_result = self.current_buffer_mut().save();
+                self.resume_insert_transaction_after_save(resume_insert_transaction);
 
-                    // Notify plugins about file save
-                    if let Some(file) = &self.current_buffer().file {
-                        let save_info = serde_json::json!({
-                            "file": file,
-                            "buffer_index": self.current_buffer_index
-                        });
-                        self.plugin_registry
-                            .notify(runtime, "file:saved", save_info)
-                            .await?;
+                match save_result {
+                    Ok(msg) => {
+                        // TODO: use last_message instead of last_error
+                        self.last_error = Some(msg);
+
+                        // Notify plugins about file save
+                        if let Some(file) = &self.current_buffer().file {
+                            let save_info = serde_json::json!({
+                                "file": file,
+                                "buffer_index": self.current_buffer_index
+                            });
+                            self.plugin_registry
+                                .notify(runtime, "file:saved", save_info)
+                                .await?;
+                        }
+                    }
+                    Err(e) => {
+                        self.last_error = Some(e.to_string());
                     }
                 }
-                Err(e) => {
-                    self.last_error = Some(e.to_string());
-                }
-            },
+            }
             Action::SaveAs(new_file_name) => {
-                match self.current_buffer_mut().save_as(new_file_name) {
+                let resume_insert_transaction = self.commit_active_transaction_before_save();
+                let save_result = self.current_buffer_mut().save_as(new_file_name);
+                self.resume_insert_transaction_after_save(resume_insert_transaction);
+
+                match save_result {
                     Ok(msg) => {
                         // TODO: use last_message instead of last_error
                         self.last_error = Some(msg);
@@ -4249,6 +4268,20 @@ impl Editor {
         self.current_buffer().undo_history.is_transaction_active()
     }
 
+    fn commit_active_transaction_before_save(&mut self) -> bool {
+        let was_active = self.transaction_active();
+        if was_active {
+            self.commit_transaction(self.cursor_snapshot());
+        }
+        was_active
+    }
+
+    fn resume_insert_transaction_after_save(&mut self, was_active: bool) {
+        if was_active && self.is_insert() && !self.transaction_active() {
+            self.begin_transaction("insert");
+        }
+    }
+
     fn replace_range(&mut self, range: TextRange, new_text: &str) {
         let old_text = self.current_buffer().text_in_range(range);
         if old_text == new_text {
@@ -4637,6 +4670,20 @@ impl Editor {
         self.window_manager.active_window_id()
     }
 
+    #[doc(hidden)]
+    pub fn test_active_window_bounds(&self) -> Option<(Point, (usize, usize))> {
+        self.window_manager
+            .active_window()
+            .map(|window| (window.position, window.size))
+    }
+
+    #[doc(hidden)]
+    pub fn test_create_panel(&mut self, id: &str, config: plugin::PanelConfig) {
+        self.panel_manager.create_panel(id.to_string(), config);
+        self.apply_panel_layout();
+        self.sync_with_window();
+    }
+
     #[doc(hidden)]
     pub fn test_render_cursor_position(&self) -> Option<(usize, usize)> {
         self.render_cursor_position()
diff --git a/src/plugin/panel.rs b/src/plugin/panel.rs
index b6a05e1..97a3967 100644
--- a/src/plugin/panel.rs
+++ b/src/plugin/panel.rs
@@ -177,6 +177,14 @@ impl PanelManager {
             .sum()
     }
 
+    pub fn reserved_right_width(&self) -> usize {
+        self.panels
+            .values()
+            .filter(|panel| panel.config.side == PanelSide::Right)
+            .map(|panel| panel.config.width.saturating_add(1))
+            .sum()
+    }
+
     pub fn handle_focused_key(&mut self, action: &str, height: usize) -> Option<PanelEvent> {
         let focused = self.focused.clone()?;
         let panel = self.panels.get_mut(&focused)?;
@@ -317,6 +325,21 @@ mod tests {
         assert_eq!(manager.reserved_left_width(), 25);
     }
 
+    #[test]
+    fn right_panels_reserve_width_with_separator() {
+        let mut manager = PanelManager::default();
+        manager.create_panel(
+            "tree".to_string(),
+            PanelConfig {
+                side: PanelSide::Right,
+                width: 24,
+                title: None,
+            },
+        );
+
+        assert_eq!(manager.reserved_right_width(), 25);
+    }
+
     #[test]
     fn focused_panel_moves_selection() {
         let mut manager = PanelManager::default();
diff --git a/tests/editing.rs b/tests/editing.rs
index 3c1b236..e46b77a 100644
--- a/tests/editing.rs
+++ b/tests/editing.rs
@@ -6,6 +6,7 @@ use red::{
     config::Config,
     editor::{Action, Content, Editor, Mode},
     lsp::LspClient,
+    plugin::{PanelConfig, PanelSide},
     theme::Theme,
 };
 use std::{
@@ -767,6 +768,34 @@ async fn test_dirty_checkpoint_moves_after_save() {
     let _ = fs::remove_file(path);
 }
 
+#[tokio::test]
+async fn test_save_during_insert_keeps_saved_buffer_clean_on_escape() {
+    let path = temp_file_path("dirty-save-insert");
+    fs::write(&path, "abc").unwrap();
+
+    let buffer = Buffer::new(Some(path.clone()), "abc".to_string());
+    let mut harness = EditorHarness::with_buffer(buffer);
+
+    harness
+        .execute_action(Action::EnterMode(Mode::Insert))
+        .await
+        .unwrap();
+    harness.type_text("z").await.unwrap();
+    assert!(harness.is_dirty());
+
+    harness.execute_action(Action::Save).await.unwrap();
+    assert!(!harness.is_dirty());
+
+    harness
+        .execute_action(Action::EnterMode(Mode::Normal))
+        .await
+        .unwrap();
+    harness.assert_buffer_contents("zabc");
+    assert!(!harness.is_dirty());
+
+    let _ = fs::remove_file(path);
+}
+
 #[tokio::test]
 async fn test_dirty_remains_after_undoing_past_saved_revision() {
     let path = temp_file_path("dirty-past-save");
@@ -789,6 +818,24 @@ async fn test_dirty_remains_after_undoing_past_saved_revision() {
     let _ = fs::remove_file(path);
 }
 
+#[test]
+fn test_right_panel_reserves_editor_window_width() {
+    let mut harness = EditorHarness::with_content("abcdef");
+
+    harness.editor.test_create_panel(
+        "tree",
+        PanelConfig {
+            side: PanelSide::Right,
+            width: 20,
+            title: None,
+        },
+    );
+
+    let (position, size) = harness.editor.test_active_window_bounds().unwrap();
+    assert_eq!(position.x, 0);
+    assert_eq!(size.0, 59);
+}
+
 #[tokio::test]
 async fn test_dirty_isolated_per_buffer() {
     let lsp = Box::new(MockLsp) as Box<dyn LspClient + Send>;