fix(tui): slash autocomplete rows accept click and wheel

Painted slash-menu rows were key-only (ops clickability map). Record
row hitboxes during ComposerWidget paint and route composer mouse over
those rows like the command palette: click moves highlight, click the
highlighted row applies, wheel moves selection. Mouse == keys for the
first-run slash surface.

Author: CodeWhale Bot

crates/tui/src/tui/app.rs

@@ -909,6 +909,11 @@ pub struct ViewportState {
     /// Vertical padding above the first text line in the composer,
     /// stored at render time for mouse coordinate mapping.
     pub last_composer_top_padding: usize,
+    /// Slash-autocomplete rows painted inside the composer on the latest
+    /// frame. Cleared and rewritten during `ComposerWidget::render` so a
+    /// resized or closed menu cannot swallow a click. Index is the entry
+    /// index into the visible slash menu (same as `slash_menu_selected`).
+    pub last_slash_menu_hitboxes: RefCell<Vec<(usize, Rect)>>,
 }
 
 impl Default for ViewportState {
@@ -940,6 +945,7 @@ impl Default for ViewportState {
             last_composer_content: None,
             last_composer_scroll_offset: 0,
             last_composer_top_padding: 0,
+            last_slash_menu_hitboxes: RefCell::new(Vec::new()),
         }
     }
 }

crates/tui/src/tui/app/init.rs

@@ -722,7 +722,7 @@ impl App {
                 selected_attachment_index: None,
                 slash_menu_selected: 0,
                 slash_menu_hidden: false,
-                mention_menu_selected: 0,
+                    mention_menu_selected: 0,
                 mention_menu_hidden: false,
                 mention_completion_cache: None,
                 mention_discovery: crate::tui::mention_completion::MentionDiscovery::default(),

crates/tui/src/tui/mouse_ui.rs

@@ -339,6 +339,72 @@ fn handle_plugin_cta_mouse(app: &mut App, mouse: MouseEvent) -> Option<Vec<ViewE
 
 /// Handle mouse events within the composer area.
 /// Returns true if the event was consumed.
+
+/// Slash-autocomplete rows painted inside the composer. Click selects
+/// (second click on the same row applies, matching the command palette);
+/// wheel moves the highlight. Returns true when the event was consumed so
+/// the composer caret / draft-scroll path does not also handle it.
+fn handle_slash_autocomplete_mouse(app: &mut App, mouse: MouseEvent) -> bool {
+    let hitboxes = app.viewport.last_slash_menu_hitboxes.borrow();
+    if hitboxes.is_empty() {
+        return false;
+    }
+    let over_row = hitboxes.iter().find_map(|(idx, rect)| {
+        mouse_hits_rect(mouse, Some(*rect)).then_some(*idx)
+    });
+    let over_menu = over_row.is_some()
+        || hitboxes.iter().any(|(_, rect)| {
+            mouse.row >= rect.y && mouse.row < rect.y.saturating_add(rect.height)
+                && mouse.column >= rect.x
+                && mouse.column < rect.x.saturating_add(rect.width)
+        });
+    // Wheel over any painted slash row moves selection (mouse == keys).
+    // Clicks only fire when the pointer is on a row rect.
+    match mouse.kind {
+        MouseEventKind::ScrollUp if over_menu => {
+            drop(hitboxes);
+            let entries = crate::tui::slash_menu::visible_slash_menu_entries(app, 128);
+            if entries.is_empty() {
+                return false;
+            }
+            crate::tui::composer_ui::select_previous_slash_menu_entry(app, entries.len());
+            app.needs_redraw = true;
+            true
+        }
+        MouseEventKind::ScrollDown if over_menu => {
+            drop(hitboxes);
+            let entries = crate::tui::slash_menu::visible_slash_menu_entries(app, 128);
+            if entries.is_empty() {
+                return false;
+            }
+            crate::tui::composer_ui::select_next_slash_menu_entry(app, entries.len());
+            app.needs_redraw = true;
+            true
+        }
+        MouseEventKind::Down(MouseButton::Left) => {
+            let Some(idx) = over_row else {
+                return false;
+            };
+            drop(hitboxes);
+            let entries = crate::tui::slash_menu::visible_slash_menu_entries(app, 128);
+            if entries.is_empty() || idx >= entries.len() {
+                return false;
+            }
+            // Same as command palette: click the highlighted row to apply;
+            // click another row to move the highlight (mouse == keys).
+            if app.slash_menu_selected == idx {
+                let _ = crate::tui::slash_menu::apply_slash_menu_selection(app, &entries, true);
+            } else {
+                app.slash_menu_selected = idx;
+                app.slash_menu_hidden = false;
+            }
+            app.needs_redraw = true;
+            true
+        }
+        _ => false,
+    }
+}
+
 pub(crate) fn handle_composer_mouse(app: &mut App, mouse: MouseEvent) -> bool {
     // Use outer area for hit-testing (includes border).
     let Some(area) = app.viewport.last_composer_area else {
@@ -351,6 +417,11 @@ pub(crate) fn handle_composer_mouse(app: &mut App, mouse: MouseEvent) -> bool {
     {
         return false;
     }
+    // Slash autocomplete owns its painted rows before caret placement or
+    // draft scroll — otherwise a click on `/model` would only move the caret.
+    if handle_slash_autocomplete_mouse(app, mouse) {
+        return true;
+    }
     // Resolve the border- and submit-aware input plane through the same
     // persistent prompt geometry used by rendering, cursor placement, and
     // viewport bookkeeping. The frame records it after reserving `[↑]`.
@@ -1776,7 +1847,8 @@ pub(crate) fn selection_to_text(app: &App) -> Option<String> {
 #[cfg(test)]
 mod tests {
     use super::{
-        agent_transcript_text, build_context_menu_entries, handle_mouse_event, sidebar_click_action,
+        agent_transcript_text, build_context_menu_entries, handle_composer_mouse,
+        handle_mouse_event, sidebar_click_action,
     };
     use crate::config::Config;
     use crate::models::Role;
@@ -1901,6 +1973,82 @@ mod tests {
         crate::tui::hover_layer::clear_pointer();
     }
 
+
+
+    #[test]
+    fn slash_autocomplete_click_selects_and_second_click_applies() {
+        let mut app = create_test_app();
+        app.launch.visible = false;
+        app.work_surface.last_area = None;
+        app.input = "/he".to_string();
+        app.cursor_position = app.input.chars().count();
+        app.slash_menu_hidden = false;
+        app.slash_menu_selected = 0;
+        // Simulate two painted rows from ComposerWidget.
+        app.viewport.last_composer_area = Some(Rect::new(0, 18, 80, 6));
+        *app.viewport.last_slash_menu_hitboxes.borrow_mut() = vec![
+            (0, Rect::new(1, 20, 78, 1)),
+            (1, Rect::new(1, 21, 78, 1)),
+        ];
+
+        assert!(
+            handle_composer_mouse(&mut app, left_click(5, 21)),
+            "slash row click must be consumed by the composer"
+        );
+        assert_eq!(app.slash_menu_selected, 1, "click on another row highlights it");
+        let before = app.input.clone();
+        assert_eq!(before, "/he", "select-only click must not rewrite the composer");
+
+        assert!(handle_composer_mouse(&mut app, left_click(5, 21)));
+        assert_ne!(app.input, before, "click on the highlighted row applies it");
+        assert!(
+            app.input.starts_with('/'),
+            "applied slash entry must replace the composer: {:?}",
+            app.input
+        );
+    }
+
+    #[test]
+    fn slash_autocomplete_wheel_moves_selection() {
+        let mut app = create_test_app();
+        app.launch.visible = false;
+        app.work_surface.last_area = None;
+        app.input = "/he".to_string();
+        app.cursor_position = app.input.chars().count();
+        app.slash_menu_hidden = false;
+        app.slash_menu_selected = 0;
+        app.viewport.last_composer_area = Some(Rect::new(0, 18, 80, 6));
+        *app.viewport.last_slash_menu_hitboxes.borrow_mut() = vec![
+            (0, Rect::new(1, 20, 78, 1)),
+            (1, Rect::new(1, 21, 78, 1)),
+        ];
+        let entries = crate::tui::slash_menu::visible_slash_menu_entries(&app, 128);
+        assert!(entries.len() >= 2, "prefix must offer multiple entries");
+
+        assert!(handle_composer_mouse(
+            &mut app,
+            MouseEvent {
+                kind: MouseEventKind::ScrollDown,
+                column: 5,
+                row: 20,
+                modifiers: KeyModifiers::NONE,
+            },
+        ));
+        assert_eq!(app.slash_menu_selected, 1);
+
+        assert!(handle_composer_mouse(
+            &mut app,
+            MouseEvent {
+                kind: MouseEventKind::ScrollUp,
+                column: 5,
+                row: 20,
+                modifiers: KeyModifiers::NONE,
+            },
+        ));
+        assert_eq!(app.slash_menu_selected, 0);
+    }
+
+
     #[test]
     fn send_click_matches_the_keyboard_submit_and_focus_never_leaves_the_composer() {
         let mut app = create_test_app();

crates/tui/src/tui/widgets/mod.rs

@@ -1357,6 +1357,9 @@ impl<'a> ComposerWidget<'a> {
 
 impl Renderable for ComposerWidget<'_> {
     fn render(&self, area: Rect, buf: &mut Buffer) {
+        // Slash rows are re-recorded below; clear first so a closed or
+        // resized menu cannot keep stale hitboxes from the prior frame.
+        self.app.viewport.last_slash_menu_hitboxes.borrow_mut().clear();
         let background = Style::default().bg(self.app.ui_theme.composer_bg);
         let has_panel = self.has_panel(area);
         let inner_area = self.inner_area(area);
@@ -1815,15 +1818,26 @@ impl Renderable for ComposerWidget<'_> {
                     Span::styled(desc_display, desc_style),
                 ]));
 
+                let row_y = inner_area
+                    .y
+                    .saturating_add(u16::try_from(row_line_index).unwrap_or(u16::MAX));
+                if row_y < inner_area.bottom() && inner_area.width > 0 {
+                    self.app
+                        .viewport
+                        .last_slash_menu_hitboxes
+                        .borrow_mut()
+                        .push((
+                            idx,
+                            Rect::new(inner_area.x, row_y, inner_area.width, 1),
+                        ));
+                }
+
                 if name_was_truncated || description_was_truncated {
                     let full_text = if entry.description.trim().is_empty() {
                         display_name
                     } else {
                         format!("{display_name}  {}", entry.description)
                     };
-                    let row_y = inner_area
-                        .y
-                        .saturating_add(u16::try_from(row_line_index).unwrap_or(u16::MAX));
                     if row_y < inner_area.bottom() {
                         crate::tui::hover_layer::register_rect(
                             crate::tui::hover_hit::HoverTargetKind::TruncatedText,