better answer parsing

.gitignore

@@ -1,3 +1,4 @@
 /target
 .env
 /tantivy_indexes
+server/tantivy_indexes

client/config.toml

@@ -17,6 +17,7 @@ toggle_buffer_list = ["ctrl+b"]
 next_field = ["Tab"]
 prev_field = ["Shift+Tab"]
 exit_table_scroll = ["esc"]
+open_search = ["ctrl+f"]
 
 [keybindings.common]
 save = ["ctrl+s"]
@@ -69,10 +70,11 @@ prev_field = ["shift+enter"]
 exit = ["esc", "ctrl+e"]
 delete_char_forward = ["delete"]
 delete_char_backward = ["backspace"]
-move_left = ["left"]
+move_left = [""]
 move_right = ["right"]
 suggestion_down = ["ctrl+n", "tab"]
 suggestion_up = ["ctrl+p", "shift+tab"]
+trigger_autocomplete = ["left"]
 
 [keybindings.command]
 exit_command_mode = ["ctrl+g", "esc"]

client/src/components/common.rs

@@ -5,6 +5,7 @@ pub mod text_editor;
 pub mod background;
 pub mod dialog;
 pub mod autocomplete;
+pub mod search_palette;
 pub mod find_file_palette;
 
 pub use command_line::*;
@@ -13,4 +14,5 @@ pub use text_editor::*;
 pub use background::*;
 pub use dialog::*;
 pub use autocomplete::*;
+pub use search_palette::*;
 pub use find_file_palette::*;

client/src/components/common/autocomplete.rs

@@ -1,5 +1,6 @@
 // src/components/common/autocomplete.rs
 
+use common::proto::multieko2::search::search_response::Hit;
 use crate::config::colors::themes::Theme;
 use ratatui::{
     layout::Rect,
@@ -7,9 +8,23 @@ use ratatui::{
     widgets::{Block, List, ListItem, ListState},
     Frame,
 };
+use std::collections::HashMap;
 use unicode_width::UnicodeWidthStr;
 
-/// Renders an opaque dropdown list for autocomplete suggestions.
+/// Converts a serde_json::Value into a displayable String.
+/// Handles String, Number, and Bool variants. Returns an empty string for Null and others.
+fn json_value_to_string(value: &serde_json::Value) -> String {
+    match value {
+        serde_json::Value::String(s) => s.clone(),
+        serde_json::Value::Number(n) => n.to_string(),
+        serde_json::Value::Bool(b) => b.to_string(),
+        // Return an empty string for Null, Array, or Object so we can filter them out.
+        _ => String::new(),
+    }
+}
+
+/// Renders an opaque dropdown list for simple string-based suggestions.
+/// This function remains unchanged.
 pub fn render_autocomplete_dropdown(
     f: &mut Frame,
     input_rect: Rect,
@@ -21,39 +36,32 @@ pub fn render_autocomplete_dropdown(
     if suggestions.is_empty() {
         return;
     }
-    // --- Calculate Dropdown Size & Position ---
+    let max_suggestion_width =
-    let max_suggestion_width = suggestions.iter().map(|s| s.width()).max().unwrap_or(0) as u16;
+        suggestions.iter().map(|s| s.width()).max().unwrap_or(0) as u16;
     let horizontal_padding: u16 = 2;
     let dropdown_width = (max_suggestion_width + horizontal_padding).max(10);
     let dropdown_height = (suggestions.len() as u16).min(5);
 
     let mut dropdown_area = Rect {
-        x: input_rect.x, // Align horizontally with input
+        x: input_rect.x,
-        y: input_rect.y + 1, // Position directly below input
+        y: input_rect.y + 1,
         width: dropdown_width,
         height: dropdown_height,
     };
 
-    // --- Clamping Logic (prevent rendering off-screen) ---
-    // Clamp vertically (if it goes below the frame)
     if dropdown_area.bottom() > frame_area.height {
-        dropdown_area.y = input_rect.y.saturating_sub(dropdown_height); // Try rendering above
+        dropdown_area.y = input_rect.y.saturating_sub(dropdown_height);
     }
-    // Clamp horizontally (if it goes past the right edge)
     if dropdown_area.right() > frame_area.width {
         dropdown_area.x = frame_area.width.saturating_sub(dropdown_width);
     }
-    // Ensure x is not negative (if clamping pushes it left)
     dropdown_area.x = dropdown_area.x.max(0);
-    // Ensure y is not negative (if clamping pushes it up)
     dropdown_area.y = dropdown_area.y.max(0);
-    // --- End Clamping ---
 
-    // Render a solid background block first to ensure opacity
+    let background_block =
-    let background_block = Block::default().style(Style::default().bg(Color::DarkGray));
+        Block::default().style(Style::default().bg(Color::DarkGray));
     f.render_widget(background_block, dropdown_area);
 
-    // Create list items, ensuring each has a defined background
     let items: Vec<ListItem> = suggestions
         .iter()
         .enumerate()
@@ -61,30 +69,140 @@ pub fn render_autocomplete_dropdown(
             let is_selected = selected_index == Some(i);
             let s_width = s.width() as u16;
             let padding_needed = dropdown_width.saturating_sub(s_width);
-            let padded_s = format!("{}{}", s, " ".repeat(padding_needed as usize));
+            let padded_s =
+                format!("{}{}", s, " ".repeat(padding_needed as usize));
 
             ListItem::new(padded_s).style(if is_selected {
                 Style::default()
-                    .fg(theme.bg) // Text color on highlight
+                    .fg(theme.bg)
-                    .bg(theme.highlight) // Highlight background
+                    .bg(theme.highlight)
                     .add_modifier(Modifier::BOLD)
             } else {
-                // Style for non-selected items (matching background block)
+                Style::default().fg(theme.fg).bg(Color::DarkGray)
-                Style::default()
-                    .fg(theme.fg) // Text color on gray
-                    .bg(Color::DarkGray) // Explicit gray background
             })
         })
         .collect();
 
-    // Create the list widget (without its own block)
     let list = List::new(items);
-
-    // State for managing selection highlight (still needed for logic)
     let mut profile_list_state = ListState::default();
     profile_list_state.select(selected_index);
 
-    // Render the list statefully *over* the background block
     f.render_stateful_widget(list, dropdown_area, &mut profile_list_state);
 }
 
+// --- MODIFIED FUNCTION FOR RICH SUGGESTIONS ---
+/// Renders an opaque dropdown list for rich `Hit`-based suggestions.
+/// Displays the value of the first meaningful column, followed by the Hit ID.
+pub fn render_rich_autocomplete_dropdown(
+    f: &mut Frame,
+    input_rect: Rect,
+    frame_area: Rect,
+    theme: &Theme,
+    suggestions: &[Hit],
+    selected_index: Option<usize>,
+) {
+    if suggestions.is_empty() {
+        return;
+    }
+
+    let display_names: Vec<String> = suggestions
+        .iter()
+        .map(|hit| {
+            // Use serde_json::Value to handle mixed types (string, null, etc.)
+            if let Ok(content_map) =
+                serde_json::from_str::<HashMap<String, serde_json::Value>>(
+                    &hit.content_json,
+                )
+            {
+                // Define keys to ignore for a cleaner display
+                const IGNORED_KEYS: &[&str] = &["id", "deleted", "created_at"];
+
+                // Get keys, filter out ignored ones, and sort for consistency
+                let mut keys: Vec<_> = content_map
+                    .keys()
+                    .filter(|k| !IGNORED_KEYS.contains(&k.as_str()))
+                    .cloned()
+                    .collect();
+                keys.sort();
+
+                // Get only the first non-empty value from the sorted keys
+                let values: Vec<_> = keys
+                    .iter()
+                    .map(|key| {
+                        content_map
+                            .get(key)
+                            .map(json_value_to_string)
+                            .unwrap_or_default()
+                    })
+                    .filter(|s| !s.is_empty()) // Filter out null/empty values
+                    .take(1) // Changed from take(2) to take(1)
+                    .collect();
+
+                let display_part = values.first().cloned().unwrap_or_default(); // Get the first value
+                if display_part.is_empty() {
+                    format!("ID: {}", hit.id)
+                } else {
+                    format!("{} | ID: {}", display_part, hit.id) // ID at the end
+                }
+            } else {
+                format!("ID: {} (parse error)", hit.id)
+            }
+        })
+        .collect();
+
+    // --- Calculate Dropdown Size & Position ---
+    let max_suggestion_width =
+        display_names.iter().map(|s| s.width()).max().unwrap_or(0) as u16;
+    let horizontal_padding: u16 = 2;
+    let dropdown_width = (max_suggestion_width + horizontal_padding).max(10);
+    let dropdown_height = (suggestions.len() as u16).min(5);
+
+    let mut dropdown_area = Rect {
+        x: input_rect.x,
+        y: input_rect.y + 1,
+        width: dropdown_width,
+        height: dropdown_height,
+    };
+
+    // --- Clamping Logic ---
+    if dropdown_area.bottom() > frame_area.height {
+        dropdown_area.y = input_rect.y.saturating_sub(dropdown_height);
+    }
+    if dropdown_area.right() > frame_area.width {
+        dropdown_area.x = frame_area.width.saturating_sub(dropdown_width);
+    }
+    dropdown_area.x = dropdown_area.x.max(0);
+    dropdown_area.y = dropdown_area.y.max(0);
+
+    // --- Rendering Logic ---
+    let background_block =
+        Block::default().style(Style::default().bg(Color::DarkGray));
+    f.render_widget(background_block, dropdown_area);
+
+    let items: Vec<ListItem> = display_names
+        .iter()
+        .enumerate()
+        .map(|(i, s)| {
+            let is_selected = selected_index == Some(i);
+            let s_width = s.width() as u16;
+            let padding_needed = dropdown_width.saturating_sub(s_width);
+            let padded_s =
+                format!("{}{}", s, " ".repeat(padding_needed as usize));
+
+            ListItem::new(padded_s).style(if is_selected {
+                Style::default()
+                    .fg(theme.bg)
+                    .bg(theme.highlight)
+                    .add_modifier(Modifier::BOLD)
+            } else {
+                Style::default().fg(theme.fg).bg(Color::DarkGray)
+            })
+        })
+        .collect();
+
+    let list = List::new(items);
+    let mut list_state = ListState::default();
+    list_state.select(selected_index);
+
+    f.render_stateful_widget(list, dropdown_area, &mut list_state);
+}

client/src/components/common/search_palette.rs

@@ -0,0 +1,121 @@
+// src/components/common/search_palette.rs
+
+use crate::config::colors::themes::Theme;
+use crate::state::app::search::SearchState;
+use ratatui::{
+    layout::{Constraint, Direction, Layout, Rect},
+    style::{Modifier, Style},
+    text::{Line, Span},
+    widgets::{Block, Borders, Clear, List, ListItem, Paragraph},
+    Frame,
+};
+
+/// Renders the search palette dialog over the main UI.
+pub fn render_search_palette(
+    f: &mut Frame,
+    area: Rect,
+    theme: &Theme,
+    state: &SearchState,
+) {
+    // --- Dialog Area Calculation ---
+    let height = (area.height as f32 * 0.7).min(30.0) as u16;
+    let width = (area.width as f32 * 0.6).min(100.0) as u16;
+    let dialog_area = Rect {
+        x: area.x + (area.width - width) / 2,
+        y: area.y + (area.height - height) / 4,
+        width,
+        height,
+    };
+
+    f.render_widget(Clear, dialog_area); // Clear background
+
+    let block = Block::default()
+        .title(format!(" Search in '{}' ", state.table_name))
+        .borders(Borders::ALL)
+        .border_style(Style::default().fg(theme.accent));
+    f.render_widget(block.clone(), dialog_area);
+
+    // --- Inner Layout (Input + Results) ---
+    let inner_chunks = Layout::default()
+        .direction(Direction::Vertical)
+        .margin(1)
+        .constraints([
+            Constraint::Length(3), // For input box
+            Constraint::Min(0),    // For results list
+        ])
+        .split(dialog_area);
+
+    // --- Render Input Box ---
+    let input_block = Block::default()
+        .title("Query")
+        .borders(Borders::ALL)
+        .border_style(Style::default().fg(theme.border));
+    let input_text = Paragraph::new(state.input.as_str())
+        .block(input_block)
+        .style(Style::default().fg(theme.fg));
+    f.render_widget(input_text, inner_chunks[0]);
+    // Set cursor position
+    f.set_cursor(
+        inner_chunks[0].x + state.cursor_position as u16 + 1,
+        inner_chunks[0].y + 1,
+    );
+
+    // --- Render Results List ---
+    if state.is_loading {
+        let loading_p = Paragraph::new("Searching...")
+            .style(Style::default().fg(theme.fg).add_modifier(Modifier::ITALIC));
+        f.render_widget(loading_p, inner_chunks[1]);
+    } else {
+        let list_items: Vec<ListItem> = state
+            .results
+            .iter()
+            .map(|hit| {
+                // Parse the JSON string to make it readable
+                let content_summary = match serde_json::from_str::<
+                    serde_json::Value,
+                >(&hit.content_json)
+                {
+                    Ok(json) => {
+                        if let Some(obj) = json.as_object() {
+                            // Create a summary from the first few non-null string values
+                            obj.values()
+                                .filter_map(|v| v.as_str())
+                                .filter(|s| !s.is_empty())
+                                .take(3)
+                                .collect::<Vec<_>>()
+                                .join(" | ")
+                        } else {
+                            "Non-object JSON".to_string()
+                        }
+                    }
+                    Err(_) => "Invalid JSON content".to_string(),
+                };
+
+                let line = Line::from(vec![
+                    Span::styled(
+                        format!("{:<4.2} ", hit.score),
+                        Style::default().fg(theme.accent),
+                    ),
+                    Span::raw(content_summary),
+                ]);
+                ListItem::new(line)
+            })
+            .collect();
+
+        let results_list = List::new(list_items)
+            .block(Block::default().title("Results"))
+            .highlight_style(
+                Style::default()
+                    .bg(theme.highlight)
+                    .fg(theme.bg)
+                    .add_modifier(Modifier::BOLD),
+            )
+            .highlight_symbol(">> ");
+
+        // We need a mutable ListState to render the selection
+        let mut list_state =
+            ratatui::widgets::ListState::default().with_selected(Some(state.selected_index));
+
+        f.render_stateful_widget(results_list, inner_chunks[1], &mut list_state);
+    }
+}

client/src/components/common/status_line.rs

@@ -1,11 +1,11 @@
-// src/components/common/status_line.rs
+// client/src/components/common/status_line.rs
 use crate::config::colors::themes::Theme;
 use crate::state::app::state::AppState;
 use ratatui::{
     layout::Rect,
     style::Style,
-    text::{Line, Span},
+    text::{Line, Span, Text},
-    widgets::Paragraph,
+    widgets::{Paragraph, Wrap}, // Make sure Wrap is imported
     Frame,
 };
 use std::path::Path;
@@ -20,22 +20,39 @@ pub fn render_status_line(
     current_fps: f64,
     app_state: &AppState,
 ) {
-    // --- START FIX ---
-    // Ensure debug_text is always a &str, which implements UnicodeWidthStr.
     #[cfg(feature = "ui-debug")]
-    let debug_text = app_state.debug_info.as_str();
+    {
-    #[cfg(not(feature = "ui-debug"))]
+        if let Some(debug_state) = &app_state.debug_state {
-    let debug_text = "";
+            let paragraph = if debug_state.is_error {
-    // --- END FIX ---
+                // --- THIS IS THE CRITICAL LOGIC FOR ERRORS ---
+                // 1. Create a `Text` object, which can contain multiple lines.
+                let error_text = Text::from(debug_state.displayed_message.clone());
 
-    let debug_width = UnicodeWidthStr::width(debug_text);
+                // 2. Create a Paragraph from the Text and TELL IT TO WRAP.
-    let debug_separator_width = if !debug_text.is_empty() { UnicodeWidthStr::width(" | ") } else { 0 };
+                Paragraph::new(error_text)
+                    .wrap(Wrap { trim: true }) // This line makes the text break into new rows.
+                    .style(Style::default().bg(theme.highlight).fg(theme.bg))
+            } else {
+                // --- This is for normal, single-line info messages ---
+                Paragraph::new(debug_state.displayed_message.as_str())
+                    .style(Style::default().fg(theme.accent).bg(theme.bg))
+            };
+            f.render_widget(paragraph, area);
+        } else {
+            // Fallback for when debug state is None
+            let paragraph = Paragraph::new("").style(Style::default().bg(theme.bg));
+            f.render_widget(paragraph, area);
+        }
+        return; // Stop here and don't render the normal status line.
+    }
 
+    // --- The normal status line rendering logic (unchanged) ---
     let program_info = format!("multieko2 v{}", env!("CARGO_PKG_VERSION"));
     let mode_text = if is_edit_mode { "[EDIT]" } else { "[READ-ONLY]" };
 
-    let home_dir =
+    let home_dir = dirs::home_dir()
-        dirs::home_dir().map(|p| p.to_string_lossy().into_owned()).unwrap_or_default();
+        .map(|p| p.to_string_lossy().into_owned())
+        .unwrap_or_default();
     let display_dir = if current_dir.starts_with(&home_dir) {
         current_dir.replacen(&home_dir, "~", 1)
     } else {
@@ -50,19 +67,30 @@ pub fn render_status_line(
     let separator = " | ";
     let separator_width = UnicodeWidthStr::width(separator);
 
-    let fixed_width_with_fps = mode_width + separator_width + separator_width +
+    let fixed_width_with_fps = mode_width
-        program_info_width + separator_width + fps_width +
+        + separator_width
-        debug_separator_width + debug_width;
+        + separator_width
+        + program_info_width
+        + separator_width
+        + fps_width;
+
     let show_fps = fixed_width_with_fps <= available_width;
 
     let remaining_width_for_dir = available_width.saturating_sub(
-        mode_width + separator_width +
+        mode_width
-        separator_width + program_info_width +
+            + separator_width
-        (if show_fps { separator_width + fps_width } else { 0 }) +
+            + separator_width
-        debug_separator_width + debug_width,
+            + program_info_width
+            + (if show_fps {
+                separator_width + fps_width
+            } else {
+                0
+            }),
     );
 
-    let dir_display_text_str = if UnicodeWidthStr::width(display_dir.as_str()) <= remaining_width_for_dir {
+    let dir_display_text_str = if UnicodeWidthStr::width(display_dir.as_str())
+        <= remaining_width_for_dir
+    {
         display_dir
     } else {
         let dir_name = Path::new(current_dir)
@@ -72,14 +100,18 @@ pub fn render_status_line(
         if UnicodeWidthStr::width(dir_name) <= remaining_width_for_dir {
             dir_name.to_string()
         } else {
-            dir_name.chars().take(remaining_width_for_dir).collect::<String>()
+            dir_name
+                .chars()
+                .take(remaining_width_for_dir)
+                .collect::<String>()
         }
     };
 
-    let mut current_content_width = mode_width + separator_width +
+    let mut current_content_width = mode_width
-                                    UnicodeWidthStr::width(dir_display_text_str.as_str()) +
+        + separator_width
-                                    separator_width + program_info_width +
+        + UnicodeWidthStr::width(dir_display_text_str.as_str())
-                                    debug_separator_width + debug_width;
+        + separator_width
+        + program_info_width;
     if show_fps {
         current_content_width += separator_width + fps_width;
     }
@@ -87,20 +119,24 @@ pub fn render_status_line(
     let mut line_spans = vec![
         Span::styled(mode_text, Style::default().fg(theme.accent)),
         Span::styled(separator, Style::default().fg(theme.border)),
-        Span::styled(dir_display_text_str.as_str(), Style::default().fg(theme.fg)),
+        Span::styled(
+            dir_display_text_str.as_str(),
+            Style::default().fg(theme.fg),
+        ),
         Span::styled(separator, Style::default().fg(theme.border)),
-        Span::styled(program_info.as_str(), Style::default().fg(theme.secondary)),
+        Span::styled(
+            program_info.as_str(),
+            Style::default().fg(theme.secondary),
+        ),
     ];
 
     if show_fps {
-        line_spans.push(Span::styled(separator, Style::default().fg(theme.border)));
+        line_spans
-        line_spans.push(Span::styled(fps_text.as_str(), Style::default().fg(theme.secondary)));
+            .push(Span::styled(separator, Style::default().fg(theme.border)));
-    }
+        line_spans.push(Span::styled(
-
+            fps_text.as_str(),
-    #[cfg(feature = "ui-debug")]
+            Style::default().fg(theme.secondary),
-    {
+        ));
-        line_spans.push(Span::styled(separator, Style::default().fg(theme.border)));
-        line_spans.push(Span::styled(debug_text, Style::default().fg(theme.accent)));
     }
 
     let padding_needed = available_width.saturating_sub(current_content_width);
@@ -111,8 +147,8 @@ pub fn render_status_line(
         ));
     }
 
-    let paragraph = Paragraph::new(Line::from(line_spans))
+    let paragraph =
-        .style(Style::default().bg(theme.bg));
+        Paragraph::new(Line::from(line_spans)).style(Style::default().bg(theme.bg));
 
     f.render_widget(paragraph, area);
 }

client/src/components/form/form.rs

@@ -1,36 +1,37 @@
 // src/components/form/form.rs
+use crate::components::common::autocomplete; // <--- ADD THIS IMPORT
+use crate::components::handlers::canvas::render_canvas;
+use crate::config::colors::themes::Theme;
+use crate::state::app::highlight::HighlightState;
+use crate::state::pages::canvas_state::CanvasState;
+use crate::state::pages::form::FormState; // <--- CHANGE THIS IMPORT
 use ratatui::{
-    widgets::{Paragraph, Block, Borders},
+    layout::{Alignment, Constraint, Direction, Layout, Margin, Rect},
-    layout::{Layout, Constraint, Direction, Rect, Margin, Alignment},
     style::Style,
+    widgets::{Block, Borders, Paragraph},
     Frame,
 };
-use crate::config::colors::themes::Theme;
-use crate::state::pages::canvas_state::CanvasState;
-use crate::state::app::highlight::HighlightState;
-use crate::components::handlers::canvas::render_canvas;
 
 pub fn render_form(
     f: &mut Frame,
     area: Rect,
-    form_state_param: &impl CanvasState,
+    form_state: &FormState, // <--- CHANGE THIS to the concrete type
     fields: &[&str],
     current_field_idx: &usize,
     inputs: &[&String],
-    table_name: &str, // This parameter receives the correct table name
+    table_name: &str,
     theme: &Theme,
     is_edit_mode: bool,
     highlight_state: &HighlightState,
     total_count: u64,
     current_position: u64,
 ) {
-    // Use the dynamic `table_name` parameter for the title instead of a hardcoded string.
     let card_title = format!(" {} ", table_name);
 
     let adresar_card = Block::default()
         .borders(Borders::ALL)
         .border_style(Style::default().fg(theme.border))
-        .title(card_title) // Use the dynamic title
+        .title(card_title)
         .style(Style::default().bg(theme.bg).fg(theme.fg));
 
     f.render_widget(adresar_card, area);
@@ -42,10 +43,7 @@ pub fn render_form(
 
     let main_layout = Layout::default()
         .direction(Direction::Vertical)
-        .constraints([
+        .constraints([Constraint::Length(1), Constraint::Min(1)])
-            Constraint::Length(1),
-            Constraint::Min(1),
-        ])
         .split(inner_area);
 
     let count_position_text = if total_count == 0 && current_position == 1 {
@@ -54,19 +52,22 @@ pub fn render_form(
         format!("Total: {} | New Entry ({})", total_count, current_position)
     } else if total_count == 0 && current_position > 1 {
         format!("Total: 0 | New Entry ({})", current_position)
-    }
+    } else {
-    else {
+        format!(
-        format!("Total: {} | Position: {}/{}", total_count, current_position, total_count)
+            "Total: {} | Position: {}/{}",
+            total_count, current_position, total_count
+        )
     };
     let count_para = Paragraph::new(count_position_text)
         .style(Style::default().fg(theme.fg))
         .alignment(Alignment::Left);
     f.render_widget(count_para, main_layout[0]);
 
-    render_canvas(
+    // Get the active field's rect from render_canvas
+    let active_field_rect = render_canvas(
         f,
         main_layout[1],
-        form_state_param,
+        form_state,
         fields,
         current_field_idx,
         inputs,
@@ -74,4 +75,40 @@ pub fn render_form(
         is_edit_mode,
         highlight_state,
     );
+
+    // --- NEW: RENDER AUTOCOMPLETE ---
+    if form_state.autocomplete_active {
+        // Use the Rect of the active field that render_canvas found for us.
+        if let Some(active_rect) = active_field_rect {
+            let selected_index = form_state.get_selected_suggestion_index();
+
+            // THE DECIDER LOGIC:
+            // 1. Check for rich suggestions first.
+            if let Some(rich_suggestions) = form_state.get_rich_suggestions() {
+                if !rich_suggestions.is_empty() {
+                    autocomplete::render_rich_autocomplete_dropdown(
+                        f,
+                        active_rect,
+                        f.area(), // Use f.area() for clamping, not f.size()
+                        theme,
+                        rich_suggestions,
+                        selected_index,
+                    );
+                }
+            }
+            // 2. Fallback to simple suggestions if rich ones aren't available.
+            else if let Some(simple_suggestions) = form_state.get_suggestions() {
+                if !simple_suggestions.is_empty() {
+                    autocomplete::render_autocomplete_dropdown(
+                        f,
+                        active_rect,
+                        f.area(),
+                        theme,
+                        simple_suggestions,
+                        selected_index,
+                    );
+                }
+            }
+        }
+    }
 }

client/src/main.rs

@@ -1,5 +1,7 @@
 // client/src/main.rs
 use client::run_ui;
+#[cfg(feature = "ui-debug")]
+use client::utils::debug_logger::UiDebugWriter;
 use dotenvy::dotenv;
 use anyhow::Result;
 use tracing_subscriber;
@@ -7,9 +9,23 @@ use std::env;
 
 #[tokio::main]
 async fn main() -> Result<()> {
+    #[cfg(feature = "ui-debug")]
+    {
+        // If ui-debug is on, set up our custom writer.
+        let writer = UiDebugWriter::new();
+        tracing_subscriber::fmt()
+            .with_level(false) // Don't show INFO, ERROR, etc.
+            .with_target(false) // Don't show the module path.
+            .without_time() // This is the correct and simpler method.
+            .with_writer(move || writer.clone())
+            .init();
+    }
+    #[cfg(not(feature = "ui-debug"))]
+    {
         if env::var("ENABLE_TRACING").is_ok() {
             tracing_subscriber::fmt::init();
         }
+    }
 
     dotenv().ok();
     run_ui().await

client/src/modes/canvas/edit.rs

@@ -1,20 +1,22 @@
 // src/modes/canvas/edit.rs
 use crate::config::binds::config::Config;
+use crate::functions::modes::edit::{
+    add_logic_e, add_table_e, auth_e, form_e,
+};
+use crate::modes::handlers::event::EventHandler;
 use crate::services::grpc_client::GrpcClient;
+use crate::state::app::state::AppState;
+use crate::state::pages::admin::AdminState;
 use crate::state::pages::{
     auth::{LoginState, RegisterState},
     canvas_state::CanvasState,
+    form::FormState,
 };
-use crate::state::pages::form::FormState; // <<< ADD THIS LINE
-// AddLogicState is already imported
-// AddTableState is already imported
-use crate::state::pages::admin::AdminState;
-use crate::modes::handlers::event::EventOutcome;
-use crate::functions::modes::edit::{add_logic_e, auth_e, form_e, add_table_e};
-use crate::state::app::state::AppState;
 use anyhow::Result;
-use crossterm::event::KeyEvent; // Removed KeyCode, KeyModifiers as they were unused
+use common::proto::multieko2::search::search_response::Hit;
-use tracing::debug;
+use crossterm::event::{KeyCode, KeyEvent};
+use tokio::sync::mpsc;
+use tracing::{debug, info};
 
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub enum EditEventOutcome {
@@ -22,231 +24,302 @@ pub enum EditEventOutcome {
     ExitEditMode,
 }
 
+/// Helper function to spawn a non-blocking search task for autocomplete.
+async fn trigger_form_autocomplete_search(
+    form_state: &mut FormState,
+    grpc_client: &mut GrpcClient,
+    sender: mpsc::UnboundedSender<Vec<Hit>>,
+) {
+    if let Some(field_def) = form_state.fields.get(form_state.current_field) {
+        if field_def.is_link {
+            if let Some(target_table) = &field_def.link_target_table {
+                // 1. Update state for immediate UI feedback
+                form_state.autocomplete_loading = true;
+                form_state.autocomplete_active = true;
+                form_state.autocomplete_suggestions.clear();
+                form_state.selected_suggestion_index = None;
+
+                // 2. Clone everything needed for the background task
+                let query = form_state.get_current_input().to_string();
+                let table_to_search = target_table.clone();
+                let mut grpc_client_clone = grpc_client.clone();
+
+                info!(
+                    "[Autocomplete] Spawning search in '{}' for query: '{}'",
+                    table_to_search, query
+                );
+
+                // 3. Spawn the non-blocking task
+                tokio::spawn(async move {
+                    match grpc_client_clone
+                        .search_table(table_to_search, query)
+                        .await
+                    {
+                        Ok(response) => {
+                            // Send results back through the channel
+                            let _ = sender.send(response.hits);
+                        }
+                        Err(e) => {
+                            tracing::error!(
+                                "[Autocomplete] Search failed: {:?}",
+                                e
+                            );
+                            // Send an empty vec on error so the UI can stop loading
+                            let _ = sender.send(vec![]);
+                        }
+                    }
+                });
+            }
+        }
+    }
+}
+
+
+#[allow(clippy::too_many_arguments)]
 pub async fn handle_edit_event(
     key: KeyEvent,
     config: &Config,
-    form_state: &mut FormState, // Now FormState is in scope
+    form_state: &mut FormState,
     login_state: &mut LoginState,
     register_state: &mut RegisterState,
     admin_state: &mut AdminState,
-    ideal_cursor_column: &mut usize,
     current_position: &mut u64,
     total_count: u64,
-    grpc_client: &mut GrpcClient,
+    event_handler: &mut EventHandler,
     app_state: &AppState,
 ) -> Result<EditEventOutcome> {
-    // --- Global command mode check ---
+    // --- AUTOCOMPLETE-SPECIFIC KEY HANDLING ---
-    if let Some("enter_command_mode") = config.get_action_for_key_in_mode(
+    if app_state.ui.show_form && form_state.autocomplete_active {
-        &config.keybindings.global, // Assuming command mode can be entered globally
+        if let Some(action) =
-        key.code,
+            config.get_edit_action_for_key(key.code, key.modifiers)
-        key.modifiers,
+        {
-    ) {
+            match action {
-        // This check might be redundant if EventHandler already prevents entering Edit mode
+                "suggestion_down" => {
-        // when command_mode is true. However, it's a safeguard.
+                    if !form_state.autocomplete_suggestions.is_empty() {
+                        let current =
+                            form_state.selected_suggestion_index.unwrap_or(0);
+                        let next = (current + 1)
+                            % form_state.autocomplete_suggestions.len();
+                        form_state.selected_suggestion_index = Some(next);
+                    }
+                    return Ok(EditEventOutcome::Message(String::new()));
+                }
+                "suggestion_up" => {
+                    if !form_state.autocomplete_suggestions.is_empty() {
+                        let current =
+                            form_state.selected_suggestion_index.unwrap_or(0);
+                        let prev = if current == 0 {
+                            form_state.autocomplete_suggestions.len() - 1
+                        } else {
+                            current - 1
+                        };
+                        form_state.selected_suggestion_index = Some(prev);
+                    }
+                    return Ok(EditEventOutcome::Message(String::new()));
+                }
+                "exit" => {
+                    form_state.deactivate_autocomplete();
                     return Ok(EditEventOutcome::Message(
-            "Cannot enter command mode from edit mode here.".to_string(),
+                        "Autocomplete cancelled".to_string(),
                     ));
                 }
-
+                "enter_decider" => {
-    // --- Common actions (save, revert) ---
+                    if let Some(selected_idx) =
-    if let Some(action) = config.get_action_for_key_in_mode(
+                        form_state.selected_suggestion_index
-        &config.keybindings.common,
+                    {
-        key.code,
+                        if let Some(selection) = form_state
-        key.modifiers,
+                            .autocomplete_suggestions
-    ).as_deref() {
+                            .get(selected_idx)
-        if matches!(action, "save" | "revert") {
+                            .cloned()
-            let message_string: String = if app_state.ui.show_login {
+                        {
-                auth_e::execute_common_action(action, login_state, grpc_client, current_position, total_count).await?
+                            let current_input =
-            } else if app_state.ui.show_register {
+                                form_state.get_current_input_mut();
-                auth_e::execute_common_action(action, register_state, grpc_client, current_position, total_count).await?
+                            *current_input = selection.id.to_string();
-            } else if app_state.ui.show_add_table {
+                            let new_cursor_pos = current_input.len();
-                // TODO: Implement common actions for AddTable if needed
+                            form_state.set_current_cursor_pos(new_cursor_pos);
-                format!("Action '{}' not implemented for Add Table in edit mode.", action)
+                            // FIX: Access ideal_cursor_column through event_handler
-            } else if app_state.ui.show_add_logic {
+                            event_handler.ideal_cursor_column = new_cursor_pos;
-                // TODO: Implement common actions for AddLogic if needed
+                            form_state.deactivate_autocomplete();
-                format!("Action '{}' not implemented for Add Logic in edit mode.", action)
+                            form_state.set_has_unsaved_changes(true);
-            } else { // Assuming Form view
+                            return Ok(EditEventOutcome::Message(
-                let outcome = form_e::execute_common_action(action, form_state, grpc_client).await?;
+                                "Selection made".to_string(),
-                match outcome {
+                            ));
-                    EventOutcome::Ok(msg) | EventOutcome::DataSaved(_, msg) => msg,
-                    _ => format!("Unexpected outcome from common action: {:?}", outcome),
                         }
+                    }
+                    form_state.deactivate_autocomplete();
+                    // Fall through to default 'enter' behavior
+                }
+                _ => {} // Let other keys fall through to the live search logic
+            }
+        }
+    }
+
+    // --- LIVE AUTOCOMPLETE TRIGGER LOGIC ---
+    let mut trigger_search = false;
+
+    if app_state.ui.show_form {
+        // Manual trigger
+        if let Some("trigger_autocomplete") =
+            config.get_edit_action_for_key(key.code, key.modifiers)
+        {
+            if !form_state.autocomplete_active {
+                trigger_search = true;
+            }
+        }
+        // Live search trigger while typing
+        else if form_state.autocomplete_active {
+            if let KeyCode::Char(_) | KeyCode::Backspace = key.code {
+                let action = if let KeyCode::Backspace = key.code {
+                    "delete_char_backward"
+                } else {
+                    "insert_char"
                 };
-            return Ok(EditEventOutcome::Message(message_string));
+                // FIX: Pass &mut event_handler.ideal_cursor_column
+                form_e::execute_edit_action(
+                    action,
+                    key,
+                    form_state,
+                    &mut event_handler.ideal_cursor_column,
+                )
+                .await?;
+                trigger_search = true;
+            }
         }
     }
 
-    // --- Edit-specific actions ---
+    if trigger_search {
-    if let Some(action_str) = config.get_edit_action_for_key(key.code, key.modifiers).as_deref() {
+        trigger_form_autocomplete_search(
-        // --- Handle "enter_decider" (Enter key) ---
+            form_state,
+            &mut event_handler.grpc_client,
+            event_handler.autocomplete_result_sender.clone(),
+        )
+        .await;
+        return Ok(EditEventOutcome::Message("Searching...".to_string()));
+    }
+
+    // --- GENERAL EDIT MODE EVENT HANDLING (IF NOT AUTOCOMPLETE) ---
+
+    if let Some(action_str) =
+        config.get_edit_action_for_key(key.code, key.modifiers)
+    {
+        // Handle Enter key (next field)
         if action_str == "enter_decider" {
-            let effective_action = if app_state.ui.show_register
+            // FIX: Pass &mut event_handler.ideal_cursor_column
-                && register_state.in_suggestion_mode
+            let msg = form_e::execute_edit_action(
-                && register_state.current_field() == 4 { // Role field
+                "next_field",
-                "select_suggestion"
+                key,
-            } else if app_state.ui.show_add_logic
+                form_state,
-                && admin_state.add_logic_state.in_target_column_suggestion_mode
+                &mut event_handler.ideal_cursor_column,
-                && admin_state.add_logic_state.current_field() == 1 { // Target Column field
+            )
-                "select_suggestion"
+            .await?;
-            } else {
-                "next_field" // Default action for Enter
-            };
-
-            let msg = if app_state.ui.show_login {
-                auth_e::execute_edit_action(effective_action, key, login_state, ideal_cursor_column).await?
-            } else if app_state.ui.show_add_table {
-                add_table_e::execute_edit_action(effective_action, key, &mut admin_state.add_table_state, ideal_cursor_column).await?
-            } else if app_state.ui.show_add_logic {
-                add_logic_e::execute_edit_action(effective_action, key, &mut admin_state.add_logic_state, ideal_cursor_column).await?
-            } else if app_state.ui.show_register {
-                auth_e::execute_edit_action(effective_action, key, register_state, ideal_cursor_column).await?
-            } else { // Form view
-                form_e::execute_edit_action(effective_action, key, form_state, ideal_cursor_column).await?
-            };
             return Ok(EditEventOutcome::Message(msg));
         }
 
-        // --- Handle "exit" (Escape key) ---
+        // Handle exiting edit mode
         if action_str == "exit" {
-            if app_state.ui.show_register && register_state.in_suggestion_mode {
-                let msg = auth_e::execute_edit_action("exit_suggestion_mode", key, register_state, ideal_cursor_column).await?;
-                return Ok(EditEventOutcome::Message(msg));
-            } else if app_state.ui.show_add_logic && admin_state.add_logic_state.in_target_column_suggestion_mode {
-                admin_state.add_logic_state.in_target_column_suggestion_mode = false;
-                admin_state.add_logic_state.show_target_column_suggestions = false;
-                admin_state.add_logic_state.selected_target_column_suggestion_index = None;
-                return Ok(EditEventOutcome::Message("Exited column suggestions".to_string()));
-            } else {
             return Ok(EditEventOutcome::ExitEditMode);
         }
-        }
 
-        // --- Autocomplete for AddLogicState Target Column ---
+        // Handle all other edit actions
-        if app_state.ui.show_add_logic && admin_state.add_logic_state.current_field() == 1 { // Target Column field
-            if action_str == "suggestion_down" { // "Tab" is mapped to suggestion_down
-                if !admin_state.add_logic_state.in_target_column_suggestion_mode {
-                    // Attempt to open suggestions
-                    if let Some(profile_name) = admin_state.add_logic_state.profile_name.clone().into() {
-                        if let Some(table_name) = admin_state.add_logic_state.selected_table_name.clone() {
-                            debug!("Fetching table structure for autocomplete: Profile='{}', Table='{}'", profile_name, table_name);
-                            match grpc_client.get_table_structure(profile_name, table_name).await {
-                                Ok(ts_response) => {
-                                    admin_state.add_logic_state.table_columns_for_suggestions =
-                                        ts_response.columns.into_iter().map(|c| c.name).collect();
-                                    admin_state.add_logic_state.update_target_column_suggestions();
-                                    if !admin_state.add_logic_state.target_column_suggestions.is_empty() {
-                                        admin_state.add_logic_state.in_target_column_suggestion_mode = true;
-                                        // update_target_column_suggestions handles initial selection
-                                        return Ok(EditEventOutcome::Message("Column suggestions shown".to_string()));
-                                    } else {
-                                        return Ok(EditEventOutcome::Message("No column suggestions for current input".to_string()));
-                                    }
-                                }
-                                Err(e) => {
-                                    debug!("Error fetching table structure: {}", e);
-                                    admin_state.add_logic_state.table_columns_for_suggestions.clear(); // Clear old data on error
-                                    admin_state.add_logic_state.update_target_column_suggestions();
-                                    return Ok(EditEventOutcome::Message(format!("Error fetching columns: {}", e)));
-                                }
-                            }
-                        } else {
-                             return Ok(EditEventOutcome::Message("No table selected for column suggestions".to_string()));
-                        }
-                    } else { // Should not happen if AddLogic is properly initialized
-                        return Ok(EditEventOutcome::Message("Profile name missing for column suggestions".to_string()));
-                    }
-                } else { // Already in suggestion mode, navigate down
-                    let msg = add_logic_e::execute_edit_action(action_str, key, &mut admin_state.add_logic_state, ideal_cursor_column).await?;
-                    return Ok(EditEventOutcome::Message(msg));
-                }
-            } else if admin_state.add_logic_state.in_target_column_suggestion_mode && action_str == "suggestion_up" {
-                 let msg = add_logic_e::execute_edit_action(action_str, key, &mut admin_state.add_logic_state, ideal_cursor_column).await?;
-                return Ok(EditEventOutcome::Message(msg));
-            }
-        }
-
-        // --- Autocomplete for RegisterState Role Field ---
-        if app_state.ui.show_register && register_state.current_field() == 4 { // Role field
-            if !register_state.in_suggestion_mode && action_str == "suggestion_down" { // Tab
-                register_state.update_role_suggestions();
-                if !register_state.role_suggestions.is_empty() {
-                    register_state.in_suggestion_mode = true;
-                    // update_role_suggestions should handle initial selection
-                    return Ok(EditEventOutcome::Message("Role suggestions shown".to_string()));
-                } else {
-                    // If Tab doesn't open suggestions, it might fall through to "next_field"
-                    // or you might want specific behavior. For now, let it fall through.
-                }
-            }
-            if register_state.in_suggestion_mode && matches!(action_str, "suggestion_down" | "suggestion_up") {
-                let msg = auth_e::execute_edit_action(action_str, key, register_state, ideal_cursor_column).await?;
-                return Ok(EditEventOutcome::Message(msg));
-            }
-        }
-
-        // --- Dispatch other edit actions ---
         let msg = if app_state.ui.show_login {
-            auth_e::execute_edit_action(action_str, key, login_state, ideal_cursor_column).await?
+            // FIX: Pass &mut event_handler.ideal_cursor_column
+            auth_e::execute_edit_action(
+                action_str,
+                key,
+                login_state,
+                &mut event_handler.ideal_cursor_column,
+            )
+            .await?
         } else if app_state.ui.show_add_table {
-            add_table_e::execute_edit_action(action_str, key, &mut admin_state.add_table_state, ideal_cursor_column).await?
+            // FIX: Pass &mut event_handler.ideal_cursor_column
+            add_table_e::execute_edit_action(
+                action_str,
+                key,
+                &mut admin_state.add_table_state,
+                &mut event_handler.ideal_cursor_column,
+            )
+            .await?
         } else if app_state.ui.show_add_logic {
-            // If not a suggestion action handled above for AddLogic
+            // FIX: Pass &mut event_handler.ideal_cursor_column
-             if !(admin_state.add_logic_state.in_target_column_suggestion_mode && matches!(action_str, "suggestion_down" | "suggestion_up")) {
+            add_logic_e::execute_edit_action(
-                add_logic_e::execute_edit_action(action_str, key, &mut admin_state.add_logic_state, ideal_cursor_column).await?
+                action_str,
-            } else { String::new() /* Already handled */ }
+                key,
+                &mut admin_state.add_logic_state,
+                &mut event_handler.ideal_cursor_column,
+            )
+            .await?
         } else if app_state.ui.show_register {
-            if !(register_state.in_suggestion_mode && matches!(action_str, "suggestion_down" | "suggestion_up")) {
+            // FIX: Pass &mut event_handler.ideal_cursor_column
-                auth_e::execute_edit_action(action_str, key, register_state, ideal_cursor_column).await?
+            auth_e::execute_edit_action(
-            } else { String::new() /* Already handled */ }
+                action_str,
-        } else { // Form view
+                key,
-            form_e::execute_edit_action(action_str, key, form_state, ideal_cursor_column).await?
+                register_state,
+                &mut event_handler.ideal_cursor_column,
+            )
+            .await?
+        } else {
+            // FIX: Pass &mut event_handler.ideal_cursor_column
+            form_e::execute_edit_action(
+                action_str,
+                key,
+                form_state,
+                &mut event_handler.ideal_cursor_column,
+            )
+            .await?
         };
         return Ok(EditEventOutcome::Message(msg));
     }
 
-    // --- Character insertion ---
+    // --- FALLBACK FOR CHARACTER INSERTION (IF NO OTHER BINDING MATCHED) ---
-    // If character insertion happens while in suggestion mode, exit suggestion mode first.
+    if let KeyCode::Char(_) = key.code {
-    let mut exited_suggestion_mode_for_typing = false;
+        let msg = if app_state.ui.show_login {
-    if app_state.ui.show_register && register_state.in_suggestion_mode {
+            // FIX: Pass &mut event_handler.ideal_cursor_column
-        register_state.in_suggestion_mode = false;
+            auth_e::execute_edit_action(
-        register_state.show_role_suggestions = false;
+                "insert_char",
-        register_state.selected_suggestion_index = None;
+                key,
-        exited_suggestion_mode_for_typing = true;
+                login_state,
-    }
+                &mut event_handler.ideal_cursor_column,
-    if app_state.ui.show_add_logic && admin_state.add_logic_state.in_target_column_suggestion_mode {
+            )
-        admin_state.add_logic_state.in_target_column_suggestion_mode = false;
+            .await?
-        admin_state.add_logic_state.show_target_column_suggestions = false;
-        admin_state.add_logic_state.selected_target_column_suggestion_index = None;
-        exited_suggestion_mode_for_typing = true;
-    }
-
-    let mut char_insert_msg = if app_state.ui.show_login {
-        auth_e::execute_edit_action("insert_char", key, login_state, ideal_cursor_column).await?
         } else if app_state.ui.show_add_table {
-        add_table_e::execute_edit_action("insert_char", key, &mut admin_state.add_table_state, ideal_cursor_column).await?
+            // FIX: Pass &mut event_handler.ideal_cursor_column
+            add_table_e::execute_edit_action(
+                "insert_char",
+                key,
+                &mut admin_state.add_table_state,
+                &mut event_handler.ideal_cursor_column,
+            )
+            .await?
         } else if app_state.ui.show_add_logic {
-        add_logic_e::execute_edit_action("insert_char", key, &mut admin_state.add_logic_state, ideal_cursor_column).await?
+            // FIX: Pass &mut event_handler.ideal_cursor_column
+            add_logic_e::execute_edit_action(
+                "insert_char",
+                key,
+                &mut admin_state.add_logic_state,
+                &mut event_handler.ideal_cursor_column,
+            )
+            .await?
         } else if app_state.ui.show_register {
-        auth_e::execute_edit_action("insert_char", key, register_state, ideal_cursor_column).await?
+            // FIX: Pass &mut event_handler.ideal_cursor_column
-    } else { // Form view
+            auth_e::execute_edit_action(
-        form_e::execute_edit_action("insert_char", key, form_state, ideal_cursor_column).await?
+                "insert_char",
+                key,
+                register_state,
+                &mut event_handler.ideal_cursor_column,
+            )
+            .await?
+        } else {
+            // FIX: Pass &mut event_handler.ideal_cursor_column
+            form_e::execute_edit_action(
+                "insert_char",
+                key,
+                form_state,
+                &mut event_handler.ideal_cursor_column,
+            )
+            .await?
         };
-
+        return Ok(EditEventOutcome::Message(msg));
-    // After character insertion, update suggestions if applicable
-    if app_state.ui.show_register && register_state.current_field() == 4 {
-        register_state.update_role_suggestions();
-        // If we just exited suggestion mode by typing, don't immediately show them again unless Tab is pressed.
-        // However, update_role_suggestions will set show_role_suggestions if matches are found.
-        // This is fine, as the render logic checks in_suggestion_mode.
-    }
-    if app_state.ui.show_add_logic && admin_state.add_logic_state.current_field() == 1 {
-        admin_state.add_logic_state.update_target_column_suggestions();
     }
 
-    if exited_suggestion_mode_for_typing && char_insert_msg.is_empty() {
+    Ok(EditEventOutcome::Message(String::new())) // No action taken
-        char_insert_msg = "Suggestions hidden".to_string();
-    }
-
-
-    Ok(EditEventOutcome::Message(char_insert_msg))
 }

client/src/modes/handlers/event.rs

@@ -21,6 +21,7 @@ use crate::state::{
     app::{
         buffer::{AppView, BufferState},
         highlight::HighlightState,
+        search::SearchState, // Correctly imported
         state::AppState,
     },
     pages::{
@@ -41,10 +42,12 @@ use crate::tui::{
 use crate::ui::handlers::context::UiContext;
 use crate::ui::handlers::rat_state::UiStateHandler;
 use anyhow::Result;
+use common::proto::multieko2::search::search_response::Hit;
 use crossterm::cursor::SetCursorStyle;
-use crossterm::event::KeyCode;
+use crossterm::event::{Event, KeyCode, KeyEvent};
-use crossterm::event::{Event, KeyEvent};
 use tokio::sync::mpsc;
+use tokio::sync::mpsc::unbounded_channel;
+use tracing::{error, info};
 
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub enum EventOutcome {
@@ -74,11 +77,17 @@ pub struct EventHandler {
     pub ideal_cursor_column: usize,
     pub key_sequence_tracker: KeySequenceTracker,
     pub auth_client: AuthClient,
+    pub grpc_client: GrpcClient,
     pub login_result_sender: mpsc::Sender<LoginResult>,
     pub register_result_sender: mpsc::Sender<RegisterResult>,
     pub save_table_result_sender: SaveTableResultSender,
     pub save_logic_result_sender: SaveLogicResultSender,
     pub navigation_state: NavigationState,
+    pub search_result_sender: mpsc::UnboundedSender<Vec<Hit>>,
+    pub search_result_receiver: mpsc::UnboundedReceiver<Vec<Hit>>,
+    // --- ADDED FOR LIVE AUTOCOMPLETE ---
+    pub autocomplete_result_sender: mpsc::UnboundedSender<Vec<Hit>>,
+    pub autocomplete_result_receiver: mpsc::UnboundedReceiver<Vec<Hit>>,
 }
 
 impl EventHandler {
@@ -87,7 +96,10 @@ impl EventHandler {
         register_result_sender: mpsc::Sender<RegisterResult>,
         save_table_result_sender: SaveTableResultSender,
         save_logic_result_sender: SaveLogicResultSender,
+        grpc_client: GrpcClient,
     ) -> Result<Self> {
+        let (search_tx, search_rx) = unbounded_channel();
+        let (autocomplete_tx, autocomplete_rx) = unbounded_channel(); // ADDED
         Ok(EventHandler {
             command_mode: false,
             command_input: String::new(),
@@ -98,11 +110,17 @@ impl EventHandler {
             ideal_cursor_column: 0,
             key_sequence_tracker: KeySequenceTracker::new(400),
             auth_client: AuthClient::new().await?,
+            grpc_client,
             login_result_sender,
             register_result_sender,
             save_table_result_sender,
             save_logic_result_sender,
             navigation_state: NavigationState::new(),
+            search_result_sender: search_tx,
+            search_result_receiver: search_rx,
+            // --- ADDED ---
+            autocomplete_result_sender: autocomplete_tx,
+            autocomplete_result_receiver: autocomplete_rx,
         })
     }
 
@@ -114,13 +132,122 @@ impl EventHandler {
         self.navigation_state.activate_find_file(options);
     }
 
+    // This function handles state changes.
+    async fn handle_search_palette_event(
+        &mut self,
+        key_event: KeyEvent,
+        form_state: &mut FormState,
+        app_state: &mut AppState,
+    ) -> Result<EventOutcome> {
+        let mut should_close = false;
+        let mut outcome_message = String::new();
+        let mut trigger_search = false;
+
+        if let Some(search_state) = app_state.search_state.as_mut() {
+            match key_event.code {
+                KeyCode::Esc => {
+                    should_close = true;
+                    outcome_message = "Search cancelled".to_string();
+                }
+                KeyCode::Enter => {
+                    if let Some(selected_hit) =
+                        search_state.results.get(search_state.selected_index)
+                    {
+                        if let Ok(data) = serde_json::from_str::<
+                            std::collections::HashMap<String, String>,
+                        >(&selected_hit.content_json)
+                        {
+                            let detached_pos = form_state.total_count + 2;
+                            form_state
+                                .update_from_response(&data, detached_pos);
+                        }
+                        should_close = true;
+                        outcome_message =
+                            format!("Loaded record ID {}", selected_hit.id);
+                    }
+                }
+                KeyCode::Up => search_state.previous_result(),
+                KeyCode::Down => search_state.next_result(),
+                KeyCode::Char(c) => {
+                    search_state
+                        .input
+                        .insert(search_state.cursor_position, c);
+                    search_state.cursor_position += 1;
+                    trigger_search = true;
+                }
+                KeyCode::Backspace => {
+                    if search_state.cursor_position > 0 {
+                        search_state.cursor_position -= 1;
+                        search_state.input.remove(search_state.cursor_position);
+                        trigger_search = true;
+                    }
+                }
+                KeyCode::Left => {
+                    search_state.cursor_position =
+                        search_state.cursor_position.saturating_sub(1);
+                }
+                KeyCode::Right => {
+                    if search_state.cursor_position < search_state.input.len()
+                    {
+                        search_state.cursor_position += 1;
+                    }
+                }
+                _ => {}
+            }
+
+            // --- START CORRECTED LOGIC ---
+            if trigger_search {
+                search_state.is_loading = true;
+                search_state.results.clear();
+                search_state.selected_index = 0;
+
+                let query = search_state.input.clone();
+                let table_name = search_state.table_name.clone();
+                let sender = self.search_result_sender.clone();
+                let mut grpc_client = self.grpc_client.clone();
+
+                info!(
+                    "--- 1. Spawning search task for query: '{}' ---",
+                    query
+                );
+                // We now move the grpc_client into the task, just like with login.
+                tokio::spawn(async move {
+                    info!("--- 2. Background task started. ---");
+                    match grpc_client.search_table(table_name, query).await {
+                        Ok(response) => {
+                            info!(
+                                "--- 3a. gRPC call successful. Found {} hits. ---",
+                                response.hits.len()
+                            );
+                            let _ = sender.send(response.hits);
+                        }
+                        Err(e) => {
+                            // THE FIX: Use the debug formatter `{:?}` to print the full error chain.
+                            error!("--- 3b. gRPC call failed: {:?} ---", e);
+                            let _ = sender.send(vec![]);
+                        }
+                    }
+                });
+            }
+        }
+
+        // The borrow on `app_state.search_state` ends here.
+        // Now we can safely modify the Option itself.
+        if should_close {
+            app_state.search_state = None;
+            app_state.ui.show_search_palette = false;
+            app_state.ui.focus_outside_canvas = false;
+        }
+
+        Ok(EventOutcome::Ok(outcome_message))
+    }
+
     #[allow(clippy::too_many_arguments)]
     pub async fn handle_event(
         &mut self,
         event: Event,
         config: &Config,
         terminal: &mut TerminalCore,
-        grpc_client: &mut GrpcClient,
         command_handler: &mut CommandHandler,
         form_state: &mut FormState,
         auth_state: &mut AuthState,
@@ -131,17 +258,36 @@ impl EventHandler {
         buffer_state: &mut BufferState,
         app_state: &mut AppState,
     ) -> Result<EventOutcome> {
-        let mut current_mode = ModeManager::derive_mode(app_state, self, admin_state);
+        if app_state.ui.show_search_palette {
+            if let Event::Key(key_event) = event {
+                // The call no longer passes grpc_client
+                return self
+                    .handle_search_palette_event(
+                        key_event,
+                        form_state,
+                        app_state,
+                    )
+                    .await;
+            }
+            return Ok(EventOutcome::Ok(String::new()));
+        }
+
+        let mut current_mode =
+            ModeManager::derive_mode(app_state, self, admin_state);
 
         if current_mode == AppMode::General && self.navigation_state.active {
             if let Event::Key(key_event) = event {
-                let outcome =
+                let outcome = handle_command_navigation_event(
-                    handle_command_navigation_event(&mut self.navigation_state, key_event, config)
+                    &mut self.navigation_state,
+                    key_event,
+                    config,
+                )
                 .await?;
 
                 if !self.navigation_state.active {
                     self.command_message = outcome.get_message_if_ok();
-                    current_mode = ModeManager::derive_mode(app_state, self, admin_state);
+                    current_mode =
+                        ModeManager::derive_mode(app_state, self, admin_state);
                 }
                 app_state.update_mode(current_mode);
                 return Ok(outcome);
@@ -154,23 +300,39 @@ impl EventHandler {
 
         let current_view = {
             let ui = &app_state.ui;
-            if ui.show_intro { AppView::Intro }
+            if ui.show_intro {
-            else if ui.show_login { AppView::Login }
+                AppView::Intro
-            else if ui.show_register { AppView::Register }
+            } else if ui.show_login {
-            else if ui.show_admin { AppView::Admin }
+                AppView::Login
-            else if ui.show_add_logic { AppView::AddLogic }
+            } else if ui.show_register {
-            else if ui.show_add_table { AppView::AddTable }
+                AppView::Register
-            else if ui.show_form { AppView::Form }
+            } else if ui.show_admin {
-            else { AppView::Scratch }
+                AppView::Admin
+            } else if ui.show_add_logic {
+                AppView::AddLogic
+            } else if ui.show_add_table {
+                AppView::AddTable
+            } else if ui.show_form {
+                AppView::Form
+            } else {
+                AppView::Scratch
+            }
         };
         buffer_state.update_history(current_view);
 
         if app_state.ui.dialog.dialog_show {
             if let Event::Key(key_event) = event {
                 if let Some(dialog_result) = dialog::handle_dialog_event(
-                    &Event::Key(key_event), config, app_state, login_state,
+                    &Event::Key(key_event),
-                    register_state, buffer_state, admin_state,
+                    config,
-                ).await {
+                    app_state,
+                    login_state,
+                    register_state,
+                    buffer_state,
+                    admin_state,
+                )
+                .await
+                {
                     return dialog_result;
                 }
             } else if let Event::Resize(_, _) = event {
@@ -182,99 +344,227 @@ impl EventHandler {
             let key_code = key_event.code;
             let modifiers = key_event.modifiers;
 
-            if UiStateHandler::toggle_sidebar(&mut app_state.ui, config, key_code, modifiers) {
+            if UiStateHandler::toggle_sidebar(
-                let message = format!("Sidebar {}", if app_state.ui.show_sidebar { "shown" } else { "hidden" });
+                &mut app_state.ui,
+                config,
+                key_code,
+                modifiers,
+            ) {
+                let message = format!(
+                    "Sidebar {}",
+                    if app_state.ui.show_sidebar {
+                        "shown"
+                    } else {
+                        "hidden"
+                    }
+                );
                 return Ok(EventOutcome::Ok(message));
             }
-            if UiStateHandler::toggle_buffer_list(&mut app_state.ui, config, key_code, modifiers) {
+            if UiStateHandler::toggle_buffer_list(
-                let message = format!("Buffer {}", if app_state.ui.show_buffer_list { "shown" } else { "hidden" });
+                &mut app_state.ui,
+                config,
+                key_code,
+                modifiers,
+            ) {
+                let message = format!(
+                    "Buffer {}",
+                    if app_state.ui.show_buffer_list {
+                        "shown"
+                    } else {
+                        "hidden"
+                    }
+                );
                 return Ok(EventOutcome::Ok(message));
             }
 
             if !matches!(current_mode, AppMode::Edit | AppMode::Command) {
-                if let Some(action) = config.get_action_for_key_in_mode(&config.keybindings.global, key_code, modifiers) {
+                if let Some(action) = config.get_action_for_key_in_mode(
+                    &config.keybindings.global,
+                    key_code,
+                    modifiers,
+                ) {
                     match action {
                         "next_buffer" => {
                             if buffer::switch_buffer(buffer_state, true) {
-                                return Ok(EventOutcome::Ok("Switched to next buffer".to_string()));
+                                return Ok(EventOutcome::Ok(
+                                    "Switched to next buffer".to_string(),
+                                ));
                             }
                         }
                         "previous_buffer" => {
                             if buffer::switch_buffer(buffer_state, false) {
-                                return Ok(EventOutcome::Ok("Switched to previous buffer".to_string()));
+                                return Ok(EventOutcome::Ok(
+                                    "Switched to previous buffer".to_string(),
+                                ));
                             }
                         }
                         "close_buffer" => {
-                            let current_table_name = app_state.current_view_table_name.as_deref();
+                            let current_table_name =
-                            let message = buffer_state.close_buffer_with_intro_fallback(current_table_name);
+                                app_state.current_view_table_name.as_deref();
+                            let message = buffer_state
+                                .close_buffer_with_intro_fallback(
+                                    current_table_name,
+                                );
                             return Ok(EventOutcome::Ok(message));
                         }
                         _ => {}
                     }
                 }
+
+                if let Some(action) =
+                    config.get_general_action(key_code, modifiers)
+                {
+                    if action == "open_search" {
+                        if app_state.ui.show_form {
+                            if let Some(table_name) =
+                                app_state.current_view_table_name.clone()
+                            {
+                                app_state.ui.show_search_palette = true;
+                                app_state.search_state =
+                                    Some(SearchState::new(table_name));
+                                app_state.ui.focus_outside_canvas = true;
+                                return Ok(EventOutcome::Ok(
+                                    "Search palette opened".to_string(),
+                                ));
+                            }
+                        }
+                    }
+                }
             }
 
             match current_mode {
                 AppMode::General => {
-                    if app_state.ui.show_admin && auth_state.role.as_deref() == Some("admin") {
+                    if app_state.ui.show_admin
-                        if admin_nav::handle_admin_navigation(key_event, config, app_state, admin_state, buffer_state, &mut self.command_message) {
+                        && auth_state.role.as_deref() == Some("admin")
-                            return Ok(EventOutcome::Ok(self.command_message.clone()));
+                    {
+                        if admin_nav::handle_admin_navigation(
+                            key_event,
+                            config,
+                            app_state,
+                            admin_state,
+                            buffer_state,
+                            &mut self.command_message,
+                        ) {
+                            return Ok(EventOutcome::Ok(
+                                self.command_message.clone(),
+                            ));
                         }
                     }
 
                     if app_state.ui.show_add_logic {
-                        let client_clone = grpc_client.clone();
+                        let client_clone = self.grpc_client.clone();
                         let sender_clone = self.save_logic_result_sender.clone();
                         if add_logic_nav::handle_add_logic_navigation(
-                            key_event, config, app_state, &mut admin_state.add_logic_state,
+                            key_event,
-                            &mut self.is_edit_mode, buffer_state, client_clone, sender_clone, &mut self.command_message,
+                            config,
+                            app_state,
+                            &mut admin_state.add_logic_state,
+                            &mut self.is_edit_mode,
+                            buffer_state,
+                            client_clone,
+                            sender_clone,
+                            &mut self.command_message,
                         ) {
-                            return Ok(EventOutcome::Ok(self.command_message.clone()));
+                            return Ok(EventOutcome::Ok(
+                                self.command_message.clone(),
+                            ));
                         }
                     }
 
                     if app_state.ui.show_add_table {
-                        let client_clone = grpc_client.clone();
+                        let client_clone = self.grpc_client.clone();
                         let sender_clone = self.save_table_result_sender.clone();
                         if add_table_nav::handle_add_table_navigation(
-                            key_event, config, app_state, &mut admin_state.add_table_state,
+                            key_event,
-                            client_clone, sender_clone, &mut self.command_message,
+                            config,
+                            app_state,
+                            &mut admin_state.add_table_state,
+                            client_clone,
+                            sender_clone,
+                            &mut self.command_message,
                         ) {
-                            return Ok(EventOutcome::Ok(self.command_message.clone()));
+                            return Ok(EventOutcome::Ok(
+                                self.command_message.clone(),
+                            ));
                         }
                     }
 
                     let nav_outcome = navigation::handle_navigation_event(
-                        key_event, config, form_state, app_state, login_state, register_state,
+                        key_event,
-                        intro_state, admin_state, &mut self.command_mode, &mut self.command_input,
+                        config,
-                        &mut self.command_message, &mut self.navigation_state,
+                        form_state,
-                    ).await;
+                        app_state,
+                        login_state,
+                        register_state,
+                        intro_state,
+                        admin_state,
+                        &mut self.command_mode,
+                        &mut self.command_input,
+                        &mut self.command_message,
+                        &mut self.navigation_state,
+                    )
+                    .await;
 
                     match nav_outcome {
                         Ok(EventOutcome::ButtonSelected { context, index }) => {
                             let message = match context {
                                 UiContext::Intro => {
-                                    intro::handle_intro_selection(app_state, buffer_state, index);
+                                    intro::handle_intro_selection(
-                                    if app_state.ui.show_admin && !app_state.profile_tree.profiles.is_empty() {
+                                        app_state,
-                                        admin_state.profile_list_state.select(Some(0));
+                                        buffer_state,
+                                        index,
+                                    );
+                                    if app_state.ui.show_admin
+                                        && !app_state
+                                            .profile_tree
+                                            .profiles
+                                            .is_empty()
+                                    {
+                                        admin_state
+                                            .profile_list_state
+                                            .select(Some(0));
                                     }
                                     format!("Intro Option {} selected", index)
                                 }
                                 UiContext::Login => match index {
-                                    0 => login::initiate_login(login_state, app_state, self.auth_client.clone(), self.login_result_sender.clone()),
+                                    0 => login::initiate_login(
-                                    1 => login::back_to_main(login_state, app_state, buffer_state).await,
+                                        login_state,
+                                        app_state,
+                                        self.auth_client.clone(),
+                                        self.login_result_sender.clone(),
+                                    ),
+                                    1 => login::back_to_main(
+                                        login_state,
+                                        app_state,
+                                        buffer_state,
+                                    )
+                                    .await,
                                     _ => "Invalid Login Option".to_string(),
                                 },
                                 UiContext::Register => match index {
-                                    0 => register::initiate_registration(register_state, app_state, self.auth_client.clone(), self.register_result_sender.clone()),
+                                    0 => register::initiate_registration(
-                                    1 => register::back_to_login(register_state, app_state, buffer_state).await,
+                                        register_state,
+                                        app_state,
+                                        self.auth_client.clone(),
+                                        self.register_result_sender.clone(),
+                                    ),
+                                    1 => register::back_to_login(
+                                        register_state,
+                                        app_state,
+                                        buffer_state,
+                                    )
+                                    .await,
                                     _ => "Invalid Login Option".to_string(),
                                 },
                                 UiContext::Admin => {
-                                    admin::handle_admin_selection(app_state, admin_state);
+                                    admin::handle_admin_selection(
+                                        app_state,
+                                        admin_state,
+                                    );
                                     format!("Admin Option {} selected", index)
                                 }
-                                UiContext::Dialog => "Internal error: Unexpected dialog state".to_string(),
+                                UiContext::Dialog => "Internal error: Unexpected dialog state"
+                                    .to_string(),
                             };
                             return Ok(EventOutcome::Ok(message));
                         }
@@ -326,19 +616,31 @@ impl EventHandler {
                         return Ok(EventOutcome::Ok(String::new()));
                     }
 
-                    if let Some(action) = config.get_common_action(key_code, modifiers) {
+                    if let Some(action) =
+                        config.get_common_action(key_code, modifiers)
+                    {
                         match action {
-                            "save" | "force_quit" | "save_and_quit" | "revert" => {
+                            "save" | "force_quit" | "save_and_quit"
+                            | "revert" => {
                                 return common_mode::handle_core_action(
-                                    action, form_state, auth_state, login_state, register_state,
+                                    action,
-                                    grpc_client, &mut self.auth_client, terminal, app_state,
+                                    form_state,
-                                ).await;
+                                    auth_state,
+                                    login_state,
+                                    register_state,
+                                    &mut self.grpc_client,
+                                    &mut self.auth_client,
+                                    terminal,
+                                    app_state,
+                                )
+                                .await;
                             }
                             _ => {}
                         }
                     }
 
-                    let (_should_exit, message) = read_only::handle_read_only_event(
+                    let (_should_exit, message) =
+                        read_only::handle_read_only_event(
                             app_state,
                             key_event,
                             config,
@@ -348,8 +650,7 @@ impl EventHandler {
                             &mut admin_state.add_table_state,
                             &mut admin_state.add_logic_state,
                             &mut self.key_sequence_tracker,
-                        // No more current_position or total_count arguments
+                            &mut self.grpc_client, // <-- FIX 1
-                        grpc_client,
                             &mut self.command_message,
                             &mut self.edit_mode_cooldown,
                             &mut self.ideal_cursor_column,
@@ -373,7 +674,8 @@ impl EventHandler {
                         return Ok(EventOutcome::Ok("".to_string()));
                     }
 
-                    let (_should_exit, message) = read_only::handle_read_only_event(
+                    let (_should_exit, message) =
+                        read_only::handle_read_only_event(
                             app_state,
                             key_event,
                             config,
@@ -383,7 +685,7 @@ impl EventHandler {
                             &mut admin_state.add_table_state,
                             &mut admin_state.add_logic_state,
                             &mut self.key_sequence_tracker,
-                        grpc_client,
+                            &mut self.grpc_client, // <-- FIX 2
                             &mut self.command_message,
                             &mut self.edit_mode_cooldown,
                             &mut self.ideal_cursor_column,
@@ -393,13 +695,24 @@ impl EventHandler {
                 }
 
                 AppMode::Edit => {
-                    if let Some(action) = config.get_common_action(key_code, modifiers) {
+                    if let Some(action) =
+                        config.get_common_action(key_code, modifiers)
+                    {
                         match action {
-                            "save" | "force_quit" | "save_and_quit" | "revert" => {
+                            "save" | "force_quit" | "save_and_quit"
+                            | "revert" => {
                                 return common_mode::handle_core_action(
-                                    action, form_state, auth_state, login_state, register_state,
+                                    action,
-                                    grpc_client, &mut self.auth_client, terminal, app_state,
+                                    form_state,
-                                ).await;
+                                    auth_state,
+                                    login_state,
+                                    register_state,
+                                    &mut self.grpc_client,
+                                    &mut self.auth_client,
+                                    terminal,
+                                    app_state,
+                                )
+                                .await;
                             }
                             _ => {}
                         }
@@ -407,11 +720,20 @@ impl EventHandler {
 
                     let mut current_position = form_state.current_position;
                     let total_count = form_state.total_count;
+                    // --- MODIFIED: Pass `self` instead of `grpc_client` ---
                     let edit_result = edit::handle_edit_event(
-                        key_event, config, form_state, login_state, register_state, admin_state,
+                        key_event,
-                        &mut self.ideal_cursor_column, &mut current_position, total_count,
+                        config,
-                        grpc_client, app_state,
+                        form_state,
-                    ).await;
+                        login_state,
+                        register_state,
+                        admin_state,
+                        &mut current_position,
+                        total_count,
+                        self,
+                        app_state,
+                    )
+                    .await;
 
                     match edit_result {
                         Ok(edit::EditEventOutcome::ExitEditMode) => {
@@ -428,14 +750,22 @@ impl EventHandler {
                                 target_state.set_current_cursor_pos(new_pos);
                                 self.ideal_cursor_column = new_pos;
                             }
-                            return Ok(EventOutcome::Ok(self.command_message.clone()));
+                            return Ok(EventOutcome::Ok(
+                                self.command_message.clone(),
+                            ));
                         }
                         Ok(edit::EditEventOutcome::Message(msg)) => {
-                            if !msg.is_empty() { self.command_message = msg; }
+                            if !msg.is_empty() {
-                            self.key_sequence_tracker.reset();
+                                self.command_message = msg;
-                            return Ok(EventOutcome::Ok(self.command_message.clone()));
+                            }
+                            self.key_sequence_tracker.reset();
+                            return Ok(EventOutcome::Ok(
+                                self.command_message.clone(),
+                            ));
+                        }
+                        Err(e) => {
+                            return Err(e.into());
                         }
-                        Err(e) => { return Err(e.into()); }
                     }
                 }
 
@@ -445,21 +775,38 @@ impl EventHandler {
                         self.command_message.clear();
                         self.command_mode = false;
                         self.key_sequence_tracker.reset();
-                        return Ok(EventOutcome::Ok("Exited command mode".to_string()));
+                        return Ok(EventOutcome::Ok(
+                            "Exited command mode".to_string(),
+                        ));
                     }
 
                     if config.is_command_execute(key_code, modifiers) {
                         let mut current_position = form_state.current_position;
                         let total_count = form_state.total_count;
                         let outcome = command_mode::handle_command_event(
-                            key_event, config, app_state, login_state, register_state, form_state,
+                            key_event,
-                            &mut self.command_input, &mut self.command_message, grpc_client,
+                            config,
-                            command_handler, terminal, &mut current_position, total_count,
+                            app_state,
-                        ).await?;
+                            login_state,
+                            register_state,
+                            form_state,
+                            &mut self.command_input,
+                            &mut self.command_message,
+                            &mut self.grpc_client, // <-- FIX 5
+                            command_handler,
+                            terminal,
+                            &mut current_position,
+                            total_count,
+                        )
+                        .await?;
                         form_state.current_position = current_position;
                         self.command_mode = false;
                         self.key_sequence_tracker.reset();
-                        let new_mode = ModeManager::derive_mode(app_state, self, admin_state);
+                        let new_mode = ModeManager::derive_mode(
+                            app_state,
+                            self,
+                            admin_state,
+                        );
                         app_state.update_mode(new_mode);
                         return Ok(outcome);
                     }
@@ -473,39 +820,59 @@ impl EventHandler {
                     if let KeyCode::Char(c) = key_code {
                         if c == 'f' {
                             self.key_sequence_tracker.add_key(key_code);
-                            let sequence = self.key_sequence_tracker.get_sequence();
+                            let sequence =
+                                self.key_sequence_tracker.get_sequence();
 
-                            if config.matches_key_sequence_generalized(&sequence) == Some("find_file_palette_toggle") {
+                            if config.matches_key_sequence_generalized(
-                                if app_state.ui.show_form || app_state.ui.show_intro {
+                                &sequence,
-                                    // --- START FIX ---
+                            ) == Some("find_file_palette_toggle")
-                                    let mut all_table_paths: Vec<String> = app_state
+                            {
+                                if app_state.ui.show_form
+                                    || app_state.ui.show_intro
+                                {
+                                    let mut all_table_paths: Vec<String> =
+                                        app_state
                                             .profile_tree
                                             .profiles
                                             .iter()
                                             .flat_map(|profile| {
-                                            profile.tables.iter().map(move |table| {
+                                                profile.tables.iter().map(
-                                                format!("{}/{}", profile.name, table.name)
+                                                    move |table| {
-                                            })
+                                                        format!(
+                                                            "{}/{}",
+                                                            profile.name,
+                                                            table.name
+                                                        )
+                                                    },
+                                                )
                                             })
                                             .collect();
                                     all_table_paths.sort();
 
-                                    self.navigation_state.activate_find_file(all_table_paths);
+                                    self.navigation_state
-                                    // --- END FIX ---
+                                        .activate_find_file(all_table_paths);
 
                                     self.command_mode = false;
                                     self.command_input.clear();
                                     self.command_message.clear();
                                     self.key_sequence_tracker.reset();
-                                    return Ok(EventOutcome::Ok("Table selection palette activated".to_string()));
+                                    return Ok(EventOutcome::Ok(
+                                        "Table selection palette activated"
+                                            .to_string(),
+                                    ));
                                 } else {
                                     self.key_sequence_tracker.reset();
                                     self.command_input.push('f');
-                                    if sequence.len() > 1 && sequence[0] == KeyCode::Char('f') {
+                                    if sequence.len() > 1
+                                        && sequence[0] == KeyCode::Char('f')
+                                    {
                                         self.command_input.push('f');
                                     }
-                                    self.command_message = "Find File not available in this view.".to_string();
+                                    self.command_message = "Find File not available in this view."
-                                    return Ok(EventOutcome::Ok(self.command_message.clone()));
+                                        .to_string();
+                                    return Ok(EventOutcome::Ok(
+                                        self.command_message.clone(),
+                                    ));
                                 }
                             }
 
@@ -514,7 +881,9 @@ impl EventHandler {
                             }
                         }
 
-                        if c != 'f' && !self.key_sequence_tracker.current_sequence.is_empty() {
+                        if c != 'f'
+                            && !self.key_sequence_tracker.current_sequence.is_empty()
+                        {
                             self.key_sequence_tracker.reset();
                         }
 

client/src/services/grpc_client.rs

@@ -20,6 +20,9 @@ use common::proto::multieko2::tables_data::{
     PostTableDataRequest, PostTableDataResponse, PutTableDataRequest,
     PutTableDataResponse,
 };
+use common::proto::multieko2::search::{
+    searcher_client::SearcherClient, SearchRequest, SearchResponse,
+};
 use anyhow::{Context, Result}; // Added Context
 use std::collections::HashMap; // NEW
 
@@ -28,36 +31,32 @@ pub struct GrpcClient {
     table_structure_client: TableStructureServiceClient<Channel>,
     table_definition_client: TableDefinitionClient<Channel>,
     table_script_client: TableScriptClient<Channel>,
-    tables_data_client: TablesDataClient<Channel>, // NEW
+    tables_data_client: TablesDataClient<Channel>,
+    search_client: SearcherClient<Channel>,
 }
 
 impl GrpcClient {
     pub async fn new() -> Result<Self> {
-        let table_structure_client = TableStructureServiceClient::connect(
+        let channel = Channel::from_static("http://[::1]:50051")
-            "http://[::1]:50051",
+            .connect()
-        )
             .await
-        .context("Failed to connect to TableStructureService")?;
+            .context("Failed to create gRPC channel")?;
-        let table_definition_client = TableDefinitionClient::connect(
+
-            "http://[::1]:50051",
+        let table_structure_client =
-        )
+            TableStructureServiceClient::new(channel.clone());
-        .await
+        let table_definition_client =
-        .context("Failed to connect to TableDefinitionService")?;
+            TableDefinitionClient::new(channel.clone());
-        let table_script_client =
+        let table_script_client = TableScriptClient::new(channel.clone());
-            TableScriptClient::connect("http://[::1]:50051")
+        let tables_data_client = TablesDataClient::new(channel.clone());
-                .await
+        // NEW: Instantiate the search client
-                .context("Failed to connect to TableScriptService")?;
+        let search_client = SearcherClient::new(channel.clone());
-        let tables_data_client =
-            TablesDataClient::connect("http://[::1]:50051")
-                .await
-                .context("Failed to connect to TablesDataService")?; // NEW
 
         Ok(Self {
-            // adresar_client, // REMOVE
             table_structure_client,
             table_definition_client,
             table_script_client,
-            tables_data_client, // NEW
+            tables_data_client,
+            search_client, // NEW
         })
     }
 
@@ -197,4 +196,17 @@ impl GrpcClient {
             .context("gRPC PutTableData call failed")?;
         Ok(response.into_inner())
     }
+
+    pub async fn search_table(
+        &mut self,
+        table_name: String,
+        query: String,
+    ) -> Result<SearchResponse> {
+        let request = tonic::Request::new(SearchRequest { table_name, query });
+        let response = self
+            .search_client
+            .search_table(request)
+            .await?;
+        Ok(response.into_inner())
+    }
 }

client/src/state/app.rs

@@ -2,4 +2,5 @@
 
 pub mod state;
 pub mod buffer;
+pub mod search;
 pub mod highlight;

client/src/state/app/search.rs

@@ -0,0 +1,56 @@
+// src/state/app/search.rs
+
+use common::proto::multieko2::search::search_response::Hit;
+
+/// Holds the complete state for the search palette.
+pub struct SearchState {
+    /// The name of the table being searched.
+    pub table_name: String,
+    /// The current text entered by the user.
+    pub input: String,
+    /// The position of the cursor within the input text.
+    pub cursor_position: usize,
+    /// The search results returned from the server.
+    pub results: Vec<Hit>,
+    /// The index of the currently selected search result.
+    pub selected_index: usize,
+    /// A flag to indicate if a search is currently in progress.
+    pub is_loading: bool,
+}
+
+impl SearchState {
+    /// Creates a new SearchState for a given table.
+    pub fn new(table_name: String) -> Self {
+        Self {
+            table_name,
+            input: String::new(),
+            cursor_position: 0,
+            results: Vec::new(),
+            selected_index: 0,
+            is_loading: false,
+        }
+    }
+
+    /// Moves the selection to the next item, wrapping around if at the end.
+    pub fn next_result(&mut self) {
+        if !self.results.is_empty() {
+            let next = self.selected_index + 1;
+            self.selected_index = if next >= self.results.len() {
+                0 // Wrap to the start
+            } else {
+                next
+            };
+        }
+    }
+
+    /// Moves the selection to the previous item, wrapping around if at the beginning.
+    pub fn previous_result(&mut self) {
+        if !self.results.is_empty() {
+            self.selected_index = if self.selected_index == 0 {
+                self.results.len() - 1 // Wrap to the end
+            } else {
+                self.selected_index - 1
+            };
+        }
+    }
+}

client/src/state/app/state.rs

@@ -1,11 +1,15 @@
-// src/state/state.rs
+// src/state/app/state.rs
 
 use std::env;
 use common::proto::multieko2::table_definition::ProfileTreeResponse;
 use crate::modes::handlers::mode_manager::AppMode;
 use crate::ui::handlers::context::DialogPurpose;
+use crate::state::app::search::SearchState; // ADDED
 use anyhow::Result;
+#[cfg(feature = "ui-debug")]
+use std::time::Instant;
 
+// --- YOUR EXISTING DIALOGSTATE IS UNTOUCHED ---
 pub struct DialogState {
     pub dialog_show: bool,
     pub dialog_title: String,
@@ -26,10 +30,19 @@ pub struct UiState {
     pub show_form: bool,
     pub show_login: bool,
     pub show_register: bool,
+    pub show_search_palette: bool, // ADDED
     pub focus_outside_canvas: bool,
     pub dialog: DialogState,
 }
 
+#[cfg(feature = "ui-debug")]
+#[derive(Debug, Clone)]
+pub struct DebugState {
+    pub displayed_message: String,
+    pub is_error: bool,
+    pub display_start_time: Instant,
+}
+
 pub struct AppState {
     // Core editor state
     pub current_dir: String,
@@ -42,11 +55,14 @@ pub struct AppState {
     pub focused_button_index: usize,
     pub pending_table_structure_fetch: Option<(String, String)>,
 
+    // ADDED: State for the search palette
+    pub search_state: Option<SearchState>,
+
     // UI preferences
     pub ui: UiState,
 
     #[cfg(feature = "ui-debug")]
-    pub debug_info: String,
+    pub debug_state: Option<DebugState>,
 }
 
 impl AppState {
@@ -63,13 +79,16 @@ impl AppState {
             current_mode: AppMode::General,
             focused_button_index: 0,
             pending_table_structure_fetch: None,
+            search_state: None, // ADDED
             ui: UiState::default(),
 
             #[cfg(feature = "ui-debug")]
-            debug_info: String::new(),
+            debug_state: None,
         })
     }
 
+    // --- ALL YOUR EXISTING METHODS ARE UNTOUCHED ---
+
     pub fn update_mode(&mut self, mode: AppMode) {
         self.current_mode = mode;
     }
@@ -79,9 +98,6 @@ impl AppState {
         self.current_view_table_name = Some(table_name);
     }
 
-    // Add dialog helper methods
-    /// Shows a dialog with the given title, message, and buttons.
-    /// The first button (index 0) is active by default.
     pub fn show_dialog(
         &mut self,
         title: &str,
@@ -99,19 +115,17 @@ impl AppState {
         self.ui.focus_outside_canvas = true;
     }
 
-    /// Shows a dialog specifically for loading states.
     pub fn show_loading_dialog(&mut self, title: &str, message: &str) {
         self.ui.dialog.dialog_title = title.to_string();
         self.ui.dialog.dialog_message = message.to_string();
-        self.ui.dialog.dialog_buttons.clear(); // No buttons during loading
+        self.ui.dialog.dialog_buttons.clear();
         self.ui.dialog.dialog_active_button_index = 0;
-        self.ui.dialog.purpose = None; // Purpose is set when loading finishes
+        self.ui.dialog.purpose = None;
         self.ui.dialog.is_loading = true;
         self.ui.dialog.dialog_show = true;
-        self.ui.focus_outside_canvas = true; // Keep focus management consistent
+        self.ui.focus_outside_canvas = true;
     }
 
-    /// Updates the content of an existing dialog, typically after loading.
     pub fn update_dialog_content(
         &mut self,
         message: &str,
@@ -121,16 +135,12 @@ impl AppState {
         if self.ui.dialog.dialog_show {
             self.ui.dialog.dialog_message = message.to_string();
             self.ui.dialog.dialog_buttons = buttons;
-            self.ui.dialog.dialog_active_button_index = 0; // Reset focus
+            self.ui.dialog.dialog_active_button_index = 0;
             self.ui.dialog.purpose = Some(purpose);
-            self.ui.dialog.is_loading = false; // Loading finished
+            self.ui.dialog.is_loading = false;
-                                               // Keep dialog_show = true
-                                               // Keep focus_outside_canvas = true
         }
     }
 
-
-    /// Hides the dialog and clears its content.
     pub fn hide_dialog(&mut self) {
         self.ui.dialog.dialog_show = false;
         self.ui.dialog.dialog_title.clear();
@@ -142,30 +152,27 @@ impl AppState {
         self.ui.dialog.is_loading = false;
     }
 
-    /// Sets the active button index, wrapping around if necessary.
     pub fn next_dialog_button(&mut self) {
         if !self.ui.dialog.dialog_buttons.is_empty() {
             let next_index = (self.ui.dialog.dialog_active_button_index + 1)
                 % self.ui.dialog.dialog_buttons.len();
-            self.ui.dialog.dialog_active_button_index = next_index; // Use new name
+            self.ui.dialog.dialog_active_button_index = next_index;
         }
     }
 
-    /// Sets the active button index, wrapping around if necessary.
     pub fn previous_dialog_button(&mut self) {
         if !self.ui.dialog.dialog_buttons.is_empty() {
             let len = self.ui.dialog.dialog_buttons.len();
             let prev_index =
                 (self.ui.dialog.dialog_active_button_index + len - 1) % len;
-            self.ui.dialog.dialog_active_button_index = prev_index; // Use new name
+            self.ui.dialog.dialog_active_button_index = prev_index;
         }
     }
 
-    /// Gets the label of the currently active button, if any.
     pub fn get_active_dialog_button_label(&self) -> Option<&str> {
         self.ui.dialog
-            .dialog_buttons // Use new name
+            .dialog_buttons
-            .get(self.ui.dialog.dialog_active_button_index) // Use new name
+            .get(self.ui.dialog.dialog_active_button_index)
             .map(|s| s.as_str())
     }
 }
@@ -182,13 +189,13 @@ impl Default for UiState {
             show_login: false,
             show_register: false,
             show_buffer_list: true,
+            show_search_palette: false, // ADDED
             focus_outside_canvas: false,
             dialog: DialogState::default(),
         }
     }
 }
 
-// Update the Default implementation for DialogState itself
 impl Default for DialogState {
     fn default() -> Self {
         Self {

client/src/state/pages/canvas_state.rs

@@ -1,5 +1,6 @@
-// src/state/canvas_state.rs
+// src/state/pages/canvas_state.rs
 
+use common::proto::multieko2::search::search_response::Hit;
 
 pub trait CanvasState {
     fn current_field(&self) -> usize;
@@ -17,4 +18,7 @@ pub trait CanvasState {
     // --- Autocomplete Support ---
     fn get_suggestions(&self) -> Option<&[String]>;
     fn get_selected_suggestion_index(&self) -> Option<usize>;
+    fn get_rich_suggestions(&self) -> Option<&[Hit]> {
+        None
+    }
 }

client/src/state/pages/form.rs

@@ -1,49 +1,65 @@
 // src/state/pages/form.rs
 
-use std::collections::HashMap; // NEW
 use crate::config::colors::themes::Theme;
-use ratatui::layout::Rect;
-use ratatui::Frame;
 use crate::state::app::highlight::HighlightState;
 use crate::state::pages::canvas_state::CanvasState;
+use common::proto::multieko2::search::search_response::Hit; // Import Hit
+use ratatui::layout::Rect;
+use ratatui::Frame;
+use std::collections::HashMap;
 
+// A struct to bridge the display name (label) to the data key from the server.
+#[derive(Debug, Clone)]
+pub struct FieldDefinition {
+    pub display_name: String,
+    pub data_key: String,
+    pub is_link: bool,
+    pub link_target_table: Option<String>,                       
+}
+
+#[derive(Clone)]
 pub struct FormState {
     pub id: i64,
-    // NEW fields for dynamic table context
     pub profile_name: String,
     pub table_name: String,
     pub total_count: u64,
-    pub current_position: u64, // 1-based index, 0 or total_count + 1 for new entry
+    pub current_position: u64,
-
+    pub fields: Vec<FieldDefinition>,
-    pub fields: Vec<String>, // Already dynamic, which is good
     pub values: Vec<String>,
     pub current_field: usize,
     pub has_unsaved_changes: bool,
     pub current_cursor_pos: usize,
+
+    // --- MODIFIED AUTOCOMPLETE STATE ---
+    pub autocomplete_active: bool,
+    pub autocomplete_suggestions: Vec<Hit>, // Changed to use the Hit struct
+    pub selected_suggestion_index: Option<usize>,
+    pub autocomplete_loading: bool, // To show a loading indicator
 }
 
 impl FormState {
-    /// Creates a new, empty FormState for a given table.
-    /// The position defaults to 1, representing either the first record
-    /// or the position for a new entry if the table is empty.
     pub fn new(
         profile_name: String,
         table_name: String,
-        fields: Vec<String>,
+        fields: Vec<FieldDefinition>,
     ) -> Self {
         let values = vec![String::new(); fields.len()];
         FormState {
-            id: 0, // Default to 0, indicating a new or unloaded record
+            id: 0,
             profile_name,
             table_name,
-            total_count: 0, // Will be fetched after initialization
+            total_count: 0,
-            // FIX: Default to 1. A position of 0 is an invalid state.
             current_position: 1,
             fields,
             values,
             current_field: 0,
             has_unsaved_changes: false,
             current_cursor_pos: 0,
+            // --- INITIALIZE NEW STATE ---
+            autocomplete_active: false,
+            autocomplete_suggestions: Vec::new(),
+            selected_suggestion_index: None,
+            autocomplete_loading: false, // Initialize loading state
         }
     }
 
@@ -56,13 +72,13 @@ impl FormState {
         highlight_state: &HighlightState,
     ) {
         let fields_str_slice: Vec<&str> =
-            self.fields.iter().map(|s| s.as_str()).collect();
+            self.fields().iter().map(|s| *s).collect();
         let values_str_slice: Vec<&String> = self.values.iter().collect();
 
         crate::components::form::form::render_form(
             f,
             area,
-            self, // Pass self as CanvasState
+            self, // <--- This now correctly passes the concrete &FormState
             &fields_str_slice,
             &self.current_field,
             &values_str_slice,
@@ -75,20 +91,18 @@ impl FormState {
         );
     }
 
-    /// Resets the form to a state for creating a new entry.
-    /// It clears all values and sets the position to be one after the last record.
     pub fn reset_to_empty(&mut self) {
         self.id = 0;
         self.values.iter_mut().for_each(|v| v.clear());
         self.current_field = 0;
         self.current_cursor_pos = 0;
         self.has_unsaved_changes = false;
-        // Set the position for a new entry.
         if self.total_count > 0 {
             self.current_position = self.total_count + 1;
         } else {
-            self.current_position = 1; // If table is empty, new record is at position 1
+            self.current_position = 1;
         }
+        self.deactivate_autocomplete(); // Deactivate on reset
     }
 
     pub fn get_current_input(&self) -> &str {
@@ -104,26 +118,22 @@ impl FormState {
             .expect("Invalid current_field index")
     }
 
-    /// Updates the form's values from a data response and sets its position.
-    /// This is the single source of truth for populating the form after a data fetch.
     pub fn update_from_response(
         &mut self,
         response_data: &HashMap<String, String>,
-        // FIX: Add new_position to make this method authoritative.
         new_position: u64,
     ) {
-        // Create a new vector for the values, ensuring they are in the correct order.
+        self.values = self
-        self.values = self.fields.iter().map(|field_from_schema| {
+            .fields
-            // For each field from our schema, find the corresponding key in the
-            // response data by doing a case-insensitive comparison.
-            response_data
             .iter()
-                .find(|(key_from_data, _)| key_from_data.eq_ignore_ascii_case(field_from_schema))
+            .map(|field_def| {
-                .map(|(_, value)| value.clone()) // If found, clone its value.
+                response_data
-                .unwrap_or_default() // If not found, use an empty string.
+                    .get(&field_def.data_key)
-        }).collect();
+                    .cloned()
+                    .unwrap_or_default()
+            })
+            .collect();
 
-        // Now, do the same case-insensitive lookup for the 'id' field.
         let id_str_opt = response_data
             .iter()
             .find(|(k, _)| k.eq_ignore_ascii_case("id"))
@@ -133,18 +143,32 @@ impl FormState {
             if let Ok(parsed_id) = id_str.parse::<i64>() {
                 self.id = parsed_id;
             } else {
-                tracing::error!( "Failed to parse 'id' field '{}' for table {}.{}", id_str, self.profile_name, self.table_name);
+                tracing::error!(
+                    "Failed to parse 'id' field '{}' for table {}.{}",
+                    id_str,
+                    self.profile_name,
+                    self.table_name
+                );
                 self.id = 0;
             }
         } else {
             self.id = 0;
         }
 
-        // FIX: Set the position from the provided parameter.
         self.current_position = new_position;
         self.has_unsaved_changes = false;
         self.current_field = 0;
         self.current_cursor_pos = 0;
+        self.deactivate_autocomplete(); // Deactivate on update
+    }
+
+    // --- NEW HELPER METHOD ---
+    /// Deactivates autocomplete and clears its state.
+    pub fn deactivate_autocomplete(&mut self) {
+        self.autocomplete_active = false;
+        self.autocomplete_suggestions.clear();
+        self.selected_suggestion_index = None;
+        self.autocomplete_loading = false;
     }
 }
 
@@ -166,23 +190,26 @@ impl CanvasState for FormState {
     }
 
     fn get_current_input(&self) -> &str {
-        // Re-use the struct's own method
         FormState::get_current_input(self)
     }
 
     fn get_current_input_mut(&mut self) -> &mut String {
-        // Re-use the struct's own method
         FormState::get_current_input_mut(self)
     }
 
     fn fields(&self) -> Vec<&str> {
-        self.fields.iter().map(|s| s.as_str()).collect()
+        self.fields
+            .iter()
+            .map(|f| f.display_name.as_str())
+            .collect()
     }
 
     fn set_current_field(&mut self, index: usize) {
         if index < self.fields.len() {
             self.current_field = index;
         }
+        // Deactivate autocomplete when changing fields
+        self.deactivate_autocomplete();
     }
 
     fn set_current_cursor_pos(&mut self, pos: usize) {
@@ -193,11 +220,27 @@ impl CanvasState for FormState {
         self.has_unsaved_changes = changed;
     }
 
+    // --- MODIFIED: Implement autocomplete trait methods ---
+
+    /// Returns None because this state uses rich suggestions.
     fn get_suggestions(&self) -> Option<&[String]> {
         None
     }
 
-    fn get_selected_suggestion_index(&self) -> Option<usize> {
+    /// Returns rich suggestions.
+    fn get_rich_suggestions(&self) -> Option<&[Hit]> {
+        if self.autocomplete_active {
+            Some(&self.autocomplete_suggestions)
+        } else {
             None
         }
     }
+
+    fn get_selected_suggestion_index(&self) -> Option<usize> {
+        if self.autocomplete_active {
+            self.selected_suggestion_index
+        } else {
+            None
+        }
+    }
+}

client/src/tui/functions/common/form.rs

@@ -23,7 +23,7 @@ pub async fn save(
 
     let data_map: HashMap<String, String> = form_state.fields.iter()
         .zip(form_state.values.iter())
-        .map(|(field, value)| (field.clone(), value.clone()))
+        .map(|(field_def, value)| (field_def.data_key.clone(), value.clone()))
         .collect();
 
     let outcome: SaveOutcome;

client/src/ui/handlers/render.rs

@@ -1,34 +1,36 @@
-// client/src/ui/handlers/render.rs
+// src/ui/handlers/render.rs
 
 use crate::components::{
+    admin::add_logic::render_add_logic,
+    admin::render_add_table,
+    auth::{login::render_login, register::render_register},
+    common::dialog::render_dialog,
+    common::find_file_palette,
+    common::search_palette::render_search_palette,
+    form::form::render_form,
+    handlers::sidebar::{self, calculate_sidebar_layout},
+    intro::intro::render_intro,
     render_background,
     render_buffer_list,
     render_command_line,
     render_status_line,
-    intro::intro::render_intro,
-    handlers::sidebar::{self, calculate_sidebar_layout},
-    form::form::render_form,
-    admin::render_add_table,
-    admin::add_logic::render_add_logic,
-    auth::{login::render_login, register::render_register},
-    common::find_file_palette,
 };
 use crate::config::colors::themes::Theme;
+use crate::modes::general::command_navigation::NavigationState;
+use crate::state::pages::canvas_state::CanvasState;
+use crate::state::app::buffer::BufferState;
+use crate::state::app::highlight::HighlightState;
+use crate::state::app::state::AppState;
+use crate::state::pages::admin::AdminState;
+use crate::state::pages::auth::AuthState;
+use crate::state::pages::auth::LoginState;
+use crate::state::pages::auth::RegisterState;
+use crate::state::pages::form::FormState;
+use crate::state::pages::intro::IntroState;
 use ratatui::{
     layout::{Constraint, Direction, Layout},
     Frame,
 };
-use crate::state::pages::canvas_state::CanvasState;
-use crate::state::pages::form::FormState;
-use crate::state::pages::auth::AuthState;
-use crate::state::pages::auth::LoginState;
-use crate::state::pages::auth::RegisterState;
-use crate::state::pages::intro::IntroState;
-use crate::state::app::buffer::BufferState;
-use crate::state::app::state::AppState;
-use crate::state::pages::admin::AdminState;
-use crate::state::app::highlight::HighlightState;
-use crate::modes::general::command_navigation::NavigationState;
 
 #[allow(clippy::too_many_arguments)]
 pub fn render_ui(
@@ -53,16 +55,28 @@ pub fn render_ui(
 ) {
     render_background(f, f.area(), theme);
 
+    // --- START DYNAMIC LAYOUT LOGIC ---
+    let mut status_line_height = 1;
+    #[cfg(feature = "ui-debug")]
+    {
+        if let Some(debug_state) = &app_state.debug_state {
+            if debug_state.is_error {
+                status_line_height = 4;
+            }
+        }
+    }
+    // --- END DYNAMIC LAYOUT LOGIC ---
+
     const PALETTE_OPTIONS_HEIGHT_FOR_LAYOUT: u16 = 15;
 
-    let mut bottom_area_constraints: Vec<Constraint> = vec![Constraint::Length(1)];
 
+    let mut bottom_area_constraints: Vec<Constraint> = vec![Constraint::Length(status_line_height)];
     let command_palette_area_height = if navigation_state.active {
         1 + PALETTE_OPTIONS_HEIGHT_FOR_LAYOUT
     } else if event_handler_command_mode_active {
         1
     } else {
-        0 // Neither is active
+        0
     };
 
     if command_palette_area_height > 0 {
@@ -75,7 +89,6 @@ pub fn render_ui(
     }
     main_layout_constraints.extend(bottom_area_constraints);
 
-
     let root_chunks = Layout::default()
         .direction(Direction::Vertical)
         .constraints(main_layout_constraints)
@@ -106,77 +119,95 @@ pub fn render_ui(
         None
     };
 
-
     if app_state.ui.show_intro {
         render_intro(f, intro_state, main_content_area, theme);
     } else if app_state.ui.show_register {
         render_register(
-            f, main_content_area, theme, register_state, app_state,
+            f,
+            main_content_area,
+            theme,
+            register_state,
+            app_state,
             register_state.current_field() < 4,
             highlight_state,
         );
     } else if app_state.ui.show_add_table {
         render_add_table(
-            f, main_content_area, theme, app_state, &mut admin_state.add_table_state,
+            f,
+            main_content_area,
+            theme,
+            app_state,
+            &mut admin_state.add_table_state,
             is_event_handler_edit_mode,
             highlight_state,
         );
     } else if app_state.ui.show_add_logic {
         render_add_logic(
-            f, main_content_area, theme, app_state, &mut admin_state.add_logic_state,
+            f,
-            is_event_handler_edit_mode, highlight_state,
+            main_content_area,
+            theme,
+            app_state,
+            &mut admin_state.add_logic_state,
+            is_event_handler_edit_mode,
+            highlight_state,
         );
     } else if app_state.ui.show_login {
         render_login(
-            f, main_content_area, theme, login_state, app_state,
+            f,
+            main_content_area,
+            theme,
+            login_state,
+            app_state,
             login_state.current_field() < 2,
             highlight_state,
         );
     } else if app_state.ui.show_admin {
         crate::components::admin::admin_panel::render_admin_panel(
-            f, app_state, auth_state, admin_state, main_content_area, theme,
+            f,
-            &app_state.profile_tree, &app_state.selected_profile,
+            app_state,
+            auth_state,
+            admin_state,
+            main_content_area,
+            theme,
+            &app_state.profile_tree,
+            &app_state.selected_profile,
         );
-
     } else if app_state.ui.show_form {
-        let (sidebar_area, form_actual_area) = calculate_sidebar_layout(
+        let (sidebar_area, form_actual_area) =
-            app_state.ui.show_sidebar, main_content_area
+            calculate_sidebar_layout(app_state.ui.show_sidebar, main_content_area);
-        );
         if let Some(sidebar_rect) = sidebar_area {
             sidebar::render_sidebar(
-                f, sidebar_rect, theme, &app_state.profile_tree, &app_state.selected_profile
+                f,
+                sidebar_rect,
+                theme,
+                &app_state.profile_tree,
+                &app_state.selected_profile,
             );
         }
         let available_width = form_actual_area.width;
         let form_render_area = if available_width >= 80 {
-            Layout::default().direction(Direction::Horizontal)
+            Layout::default()
+                .direction(Direction::Horizontal)
                 .constraints([Constraint::Min(0), Constraint::Length(80), Constraint::Min(0)])
                 .split(form_actual_area)[1]
         } else {
-            Layout::default().direction(Direction::Horizontal)
+            Layout::default()
-                .constraints([Constraint::Min(0), Constraint::Length(available_width), Constraint::Min(0)])
+                .direction(Direction::Horizontal)
+                .constraints([
+                    Constraint::Min(0),
+                    Constraint::Length(available_width),
+                    Constraint::Min(0),
+                ])
                 .split(form_actual_area)[1]
         };
-        let fields_vec: Vec<&str> = form_state.fields.iter().map(AsRef::as_ref).collect();
-        let values_vec: Vec<&String> = form_state.values.iter().collect();
         
-        // --- START FIX ---
+        form_state.render(
-        // Add the missing `&form_state.table_name` argument to this function call.
-        render_form(
             f,
             form_render_area,
-            form_state,
-            &fields_vec,
-            &form_state.current_field,
-            &values_vec,
-            &form_state.table_name, // <-- THIS ARGUMENT WAS MISSING
             theme,
             is_event_handler_edit_mode,
             highlight_state,
-            form_state.total_count,
-            form_state.current_position,
         );
-        // --- END FIX ---
     }
 
     if let Some(area) = buffer_list_area {
@@ -193,23 +224,41 @@ pub fn render_ui(
         app_state,
     );
 
-    if let Some(palette_or_command_area) = command_render_area { // Use the calculated area
+    if let Some(palette_or_command_area) = command_render_area {
         if navigation_state.active {
             find_file_palette::render_find_file_palette(
                 f,
-                palette_or_command_area, // Use the correct area
+                palette_or_command_area,
                 theme,
-                navigation_state, // Pass the navigation_state directly
+                navigation_state,
             );
         } else if event_handler_command_mode_active {
             render_command_line(
                 f,
-                palette_or_command_area, // Use the correct area
+                palette_or_command_area,
                 event_handler_command_input,
-                true, // Assuming it's always active when this branch is hit
+                true,
                 theme,
                 event_handler_command_message,
             );
         }
     }
+
+    // This block now correctly handles drawing popups over any view.
+    if app_state.ui.show_search_palette {
+        if let Some(search_state) = &app_state.search_state {
+            render_search_palette(f, f.area(), theme, search_state);
+        }
+    } else if app_state.ui.dialog.dialog_show {
+        render_dialog(
+            f,
+            f.area(),
+            theme,
+            &app_state.ui.dialog.dialog_title,
+            &app_state.ui.dialog.dialog_message,
+            &app_state.ui.dialog.dialog_buttons,
+            app_state.ui.dialog.dialog_active_button_index,
+            app_state.ui.dialog.is_loading,
+        );
+    }
 }

client/src/ui/handlers/ui.rs

@@ -9,7 +9,7 @@ use crate::modes::common::commands::CommandHandler;
 use crate::modes::handlers::event::{EventHandler, EventOutcome};
 use crate::modes::handlers::mode_manager::{AppMode, ModeManager};
 use crate::state::pages::canvas_state::CanvasState;
-use crate::state::pages::form::FormState;
+use crate::state::pages::form::{FormState, FieldDefinition}; // Import FieldDefinition
 use crate::state::pages::auth::AuthState;
 use crate::state::pages::auth::LoginState;
 use crate::state::pages::auth::RegisterState;
@@ -27,12 +27,16 @@ use crate::ui::handlers::context::DialogPurpose;
 use crate::tui::functions::common::login;
 use crate::tui::functions::common::register;
 use crate::utils::columns::filter_user_columns;
-use std::time::Instant;
 use anyhow::{anyhow, Context, Result};
 use crossterm::cursor::SetCursorStyle;
 use crossterm::event as crossterm_event;
 use tracing::{error, info, warn};
 use tokio::sync::mpsc;
+use std::time::{Duration, Instant};
+#[cfg(feature = "ui-debug")]
+use crate::state::app::state::DebugState;
+#[cfg(feature = "ui-debug")]
+use crate::utils::debug_logger::pop_next_debug_message;
 
 pub async fn run_ui() -> Result<()> {
     let config = Config::load().context("Failed to load configuration")?;
@@ -51,6 +55,7 @@ pub async fn run_ui() -> Result<()> {
         register_result_sender.clone(),
         save_table_result_sender.clone(),
         save_logic_result_sender.clone(),
+        grpc_client.clone(),
     )
     .await
     .context("Failed to create event handler")?;
@@ -87,12 +92,20 @@ pub async fn run_ui() -> Result<()> {
             .await
             .context("Failed to initialize app state and form")?;
 
-    let filtered_columns = filter_user_columns(initial_columns_from_service);
+    let initial_field_defs: Vec<FieldDefinition> = filter_user_columns(initial_columns_from_service)
+        .into_iter()
+        .map(|col_name| FieldDefinition {
+            display_name: col_name.clone(),
+            data_key: col_name,
+            is_link: false,
+            link_target_table: None,
+        })
+        .collect();
 
     let mut form_state = FormState::new(
         initial_profile.clone(),
         initial_table.clone(),
-        filtered_columns,
+        initial_field_defs,
     );
 
     UiService::fetch_and_set_table_count(&mut grpc_client, &mut form_state)
@@ -126,6 +139,51 @@ pub async fn run_ui() -> Result<()> {
     loop {
         let position_before_event = form_state.current_position;
         let mut event_processed = false;
+
+        // --- CHANNEL RECEIVERS ---
+
+        // For main search palette
+        match event_handler.search_result_receiver.try_recv() {
+            Ok(hits) => {
+                info!("--- 4. Main loop received message from channel. ---");
+                if let Some(search_state) = app_state.search_state.as_mut() {
+                    search_state.results = hits;
+                    search_state.is_loading = false;
+                }
+                needs_redraw = true;
+            }
+            Err(mpsc::error::TryRecvError::Empty) => {
+            }
+            Err(mpsc::error::TryRecvError::Disconnected) => {
+                error!("Search result channel disconnected!");
+            }
+        }
+
+        // --- ADDED: For live form autocomplete ---
+        match event_handler.autocomplete_result_receiver.try_recv() {
+            Ok(hits) => {
+                if form_state.autocomplete_active {
+                    form_state.autocomplete_suggestions = hits;
+                    form_state.autocomplete_loading = false;
+                    if !form_state.autocomplete_suggestions.is_empty() {
+                        form_state.selected_suggestion_index = Some(0);
+                    } else {
+                        form_state.selected_suggestion_index = None;
+                    }
+                    event_handler.command_message = format!("Found {} suggestions.", form_state.autocomplete_suggestions.len());
+                }
+                needs_redraw = true;
+            }
+            Err(mpsc::error::TryRecvError::Empty) => {}
+            Err(mpsc::error::TryRecvError::Disconnected) => {
+                error!("Autocomplete result channel disconnected!");
+            }
+        }
+
+
+        if app_state.ui.show_search_palette {
+            needs_redraw = true;
+        }
         if crossterm_event::poll(std::time::Duration::from_millis(1))? {
             let event = event_reader.read_event().context("Failed to read terminal event")?;
             event_processed = true;
@@ -133,7 +191,6 @@ pub async fn run_ui() -> Result<()> {
                 event,
                 &config,
                 &mut terminal,
-                &mut grpc_client,
                 &mut command_handler,
                 &mut form_state,
                 &mut auth_state,
@@ -310,17 +367,56 @@ pub async fn run_ui() -> Result<()> {
                         .await
                     {
                         Ok(structure_response) => {
-                            let new_columns: Vec<String> = structure_response
+                            // --- START OF MODIFIED LOGIC ---
+                            let all_columns: Vec<String> = structure_response
                                 .columns
                                 .iter()
                                 .map(|c| c.name.clone())
                                 .collect();
 
-                            let filtered_columns = filter_user_columns(new_columns);
+                            let mut field_definitions: Vec<FieldDefinition> =
+                                filter_user_columns(all_columns)
+                                    .into_iter()
+                                    .filter(|col_name| !col_name.ends_with("_id"))
+                                    .map(|col_name| FieldDefinition {
+                                        display_name: col_name.clone(),
+                                        data_key: col_name,
+                                        is_link: false,
+                                        link_target_table: None, // Regular fields have no target
+                                    })
+                                    .collect();
+
+                            let linked_tables: Vec<String> = app_state
+                                .profile_tree
+                                .profiles
+                                .iter()
+                                .find(|p| p.name == *prof_name)
+                                .and_then(|profile| {
+                                    profile.tables.iter().find(|t| t.name == *tbl_name)
+                                })
+                                .map_or(vec![], |table| table.depends_on.clone());
+
+                            for linked_table_name in linked_tables {
+                                let base_name = linked_table_name
+                                    .split_once('_')
+                                    .map_or(linked_table_name.as_str(), |(_, rest)| rest);
+                                let data_key = format!("{}_id", base_name);
+                                let display_name = linked_table_name.clone(); // Clone for use below
+
+                                field_definitions.push(FieldDefinition {
+                                    display_name,
+                                    data_key,
+                                    is_link: true,
+                                    // --- POPULATE THE NEW FIELD ---
+                                    link_target_table: Some(linked_table_name),
+                                });
+                            }
+                            // --- END OF MODIFIED LOGIC ---
+
                             form_state = FormState::new(
                                 prof_name.clone(),
                                 tbl_name.clone(),
-                                filtered_columns,
+                                field_definitions, // This now contains the complete definitions
                             );
 
                             if let Err(e) = UiService::fetch_and_set_table_count(
@@ -358,6 +454,7 @@ pub async fn run_ui() -> Result<()> {
                             prev_view_table_name = current_view_table;
                             table_just_switched = true;
                         }
+
                         Err(e) => {
                             app_state.update_dialog_content(
                                 &format!("Error fetching table structure: {}", e),
@@ -499,10 +596,20 @@ pub async fn run_ui() -> Result<()> {
 
         #[cfg(feature = "ui-debug")]
         {
-            app_state.debug_info = format!(
+            let can_display_next = match &app_state.debug_state {
-                "Redraw -> event: {}, needs_redraw: {}, pos_changed: {}",
+                Some(current) => current.display_start_time.elapsed() >= Duration::from_secs(2),
-                event_processed, needs_redraw, position_changed
+                None => true,
-            );
+            };
+
+            if can_display_next {
+                if let Some((new_message, is_error)) = pop_next_debug_message() {
+                    app_state.debug_state = Some(DebugState {
+                        displayed_message: new_message,
+                        is_error,
+                        display_start_time: Instant::now(),
+                    });
+                }
+            }
         }
 
         if event_processed || needs_redraw || position_changed {

client/src/utils/debug_logger.rs

@@ -0,0 +1,46 @@
+// client/src/utils/debug_logger.rs
+use lazy_static::lazy_static;
+use std::collections::VecDeque; // <-- FIX: Import VecDeque
+use std::io;
+use std::sync::{Arc, Mutex}; // <-- FIX: Import Mutex
+
+lazy_static! {
+    static ref UI_DEBUG_BUFFER: Arc<Mutex<VecDeque<(String, bool)>>> =
+        Arc::new(Mutex::new(VecDeque::from([(String::from("Logger initialized..."), false)])));
+}
+
+#[derive(Clone)]
+pub struct UiDebugWriter;
+
+impl Default for UiDebugWriter {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+impl UiDebugWriter {
+    pub fn new() -> Self {
+        Self
+    }
+}
+
+impl io::Write for UiDebugWriter {
+    fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
+        let mut buffer = UI_DEBUG_BUFFER.lock().unwrap();
+        let message = String::from_utf8_lossy(buf);
+        let trimmed_message = message.trim().to_string();
+        let is_error = trimmed_message.starts_with("ERROR");
+        // Add the new message to the back of the queue
+        buffer.push_back((trimmed_message, is_error));
+        Ok(buf.len())
+    }
+
+    fn flush(&mut self) -> io::Result<()> {
+        Ok(())
+    }
+}
+
+// A public function to pop the next message from the front of the queue.
+pub fn pop_next_debug_message() -> Option<(String, bool)> {
+    UI_DEBUG_BUFFER.lock().unwrap().pop_front()
+}

client/src/utils/mod.rs

@@ -1,4 +1,6 @@
 // src/utils/mod.rs
 
 pub mod columns;
+pub mod debug_logger;
 pub use columns::*;
+pub use debug_logger::*;

search/src/lib.rs

@@ -17,14 +17,15 @@ use common::proto::multieko2::search::{
 pub use common::proto::multieko2::search::searcher_server::SearcherServer;
 use common::proto::multieko2::search::searcher_server::Searcher;
 use common::search::register_slovak_tokenizers;
-use sqlx::{PgPool, Row}; // <-- Import PgPool and Row
+use sqlx::{PgPool, Row};
+use tracing::info;
 
 // We need to hold the database pool in our service struct.
 pub struct SearcherService {
     pub pool: PgPool,
 }
 
-// Normalize diacritics in queries (no changes here)
+// normalize_slovak_text function remains unchanged...
 fn normalize_slovak_text(text: &str) -> String {
     // ... function content is unchanged ...
     text.chars()
@@ -72,9 +73,48 @@ impl Searcher for SearcherService {
         let table_name = req.table_name;
         let query_str = req.query;
 
+        // --- MODIFIED LOGIC ---
+        // If the query is empty, fetch the 5 most recent records.
         if query_str.trim().is_empty() {
-            return Err(Status::invalid_argument("Query cannot be empty"));
+            info!(
+                "Empty query for table '{}'. Fetching default results.",
+                table_name
+            );
+            let qualified_table = format!("gen.\"{}\"", table_name);
+            let sql = format!(
+                "SELECT id, to_jsonb(t) AS data FROM {} t ORDER BY id DESC LIMIT 5",
+                qualified_table
+            );
+
+            let rows = sqlx::query(&sql)
+                .fetch_all(&self.pool)
+                .await
+                .map_err(|e| {
+                    Status::internal(format!(
+                        "DB query for default results failed: {}",
+                        e
+                    ))
+                })?;
+
+            let hits: Vec<Hit> = rows
+                .into_iter()
+                .map(|row| {
+                    let id: i64 = row.try_get("id").unwrap_or_default();
+                    let json_data: serde_json::Value =
+                        row.try_get("data").unwrap_or_default();
+                    Hit {
+                        id,
+                        // Score is 0.0 as this is not a relevance-ranked search
+                        score: 0.0,
+                        content_json: json_data.to_string(),
                     }
+                })
+                .collect();
+
+            info!("--- SERVER: Successfully processed empty query. Returning {} default hits. ---", hits.len());
+            return Ok(Response::new(SearchResponse { hits }));
+        }
+        // --- END OF MODIFIED LOGIC ---
 
         let index_path = Path::new("./tantivy_indexes").join(&table_name);
         if !index_path.exists() {
@@ -97,15 +137,6 @@ impl Searcher for SearcherService {
         let searcher = reader.searcher();
         let schema = index.schema();
 
-        let prefix_edge_field = schema.get_field("prefix_edge").map_err(|_| {
-            Status::internal("Schema is missing the 'prefix_edge' field.")
-        })?;
-        let prefix_full_field = schema.get_field("prefix_full").map_err(|_| {
-            Status::internal("Schema is missing the 'prefix_full' field.")
-        })?;
-        let text_ngram_field = schema.get_field("text_ngram").map_err(|_| {
-            Status::internal("Schema is missing the 'text_ngram' field.")
-        })?;
         let pg_id_field = schema.get_field("pg_id").map_err(|_| {
             Status::internal("Schema is missing the 'pg_id' field.")
         })?;
@@ -263,6 +294,8 @@ impl Searcher for SearcherService {
             })
             .collect();
 
+        info!("--- SERVER: Successfully processed search. Returning {} hits. ---", hits.len());
+
         let response = SearchResponse { hits };
         Ok(Response::new(response))
     }

server/src/tables_data/handlers/get_table_data.rs

@@ -1,9 +1,10 @@
 // src/tables_data/handlers/get_table_data.rs
+
 use tonic::Status;
 use sqlx::{PgPool, Row};
 use std::collections::HashMap;
 use common::proto::multieko2::tables_data::{GetTableDataRequest, GetTableDataResponse};
-use crate::shared::schema_qualifier::qualify_table_name_for_data; // Import schema qualifier
+use crate::shared::schema_qualifier::qualify_table_name_for_data;
 
 pub async fn get_table_data(
     db_pool: &PgPool,
@@ -48,27 +49,44 @@ pub async fn get_table_data(
             return Err(Status::internal("Invalid column format"));
         }
         let name = parts[0].trim_matches('"').to_string();
-        let sql_type = parts[1].to_string();
+        user_columns.push(name);
-        user_columns.push((name, sql_type));
     }
 
-    // Prepare all columns (system + user-defined)
+    // --- START OF FIX ---
-    let system_columns = vec![
-        ("id".to_string(), "BIGINT".to_string()),
-        ("deleted".to_string(), "BOOLEAN".to_string()),
-    ];
-    let all_columns: Vec<(String, String)> = system_columns
-        .into_iter()
-        .chain(user_columns.into_iter())
-        .collect();
 
-    // Build SELECT clause with COALESCE and type casting
+    // 1. Get all foreign key columns for this table
-    let columns_clause = all_columns
+    let fk_columns_query = sqlx::query!(
+        r#"SELECT ltd.table_name
+        FROM table_definition_links tdl
+        JOIN table_definitions ltd ON tdl.linked_table_id = ltd.id
+        WHERE tdl.source_table_id = $1"#,
+        table_def.id
+    )
+    .fetch_all(db_pool)
+    .await
+    .map_err(|e| Status::internal(format!("Foreign key lookup error: {}", e)))?;
+
+    // 2. Build the list of foreign key column names
+    let mut foreign_key_columns = Vec::new();
+    for fk in fk_columns_query {
+        let base_name = fk.table_name.split_once('_').map_or(fk.table_name.as_str(), |(_, rest)| rest);
+        foreign_key_columns.push(format!("{}_id", base_name));
+    }
+
+    // 3. Prepare a complete list of all columns to select
+    let mut all_column_names = vec!["id".to_string(), "deleted".to_string()];
+    all_column_names.extend(user_columns);
+    all_column_names.extend(foreign_key_columns);
+
+    // 4. Build the SELECT clause with all columns
+    let columns_clause = all_column_names
         .iter()
-        .map(|(name, _)| format!("COALESCE(\"{0}\"::TEXT, '') AS \"{0}\"", name))
+        .map(|name| format!("COALESCE(\"{0}\"::TEXT, '') AS \"{0}\"", name))
         .collect::<Vec<_>>()
         .join(", ");
 
+    // --- END OF FIX ---
+
     // Qualify table name with schema
     let qualified_table = qualify_table_name_for_data(&table_name)?;
 
@@ -87,7 +105,6 @@ pub async fn get_table_data(
         Ok(row) => row,
         Err(sqlx::Error::RowNotFound) => return Err(Status::not_found("Record not found")),
         Err(e) => {
-            // Handle "relation does not exist" error specifically
             if let Some(db_err) = e.as_database_error() {
                 if db_err.code() == Some(std::borrow::Cow::Borrowed("42P01")) {
                     return Err(Status::internal(format!(
@@ -100,9 +117,9 @@ pub async fn get_table_data(
         }
     };
 
-    // Build response data
+    // Build response data from the complete list of columns
     let mut data = HashMap::new();
-    for (column_name, _) in &all_columns {
+    for column_name in &all_column_names {
         let value: String = row
             .try_get(column_name.as_str())
             .map_err(|e| Status::internal(format!("Failed to get column {}: {}", column_name, e)))?;

server/src/tables_data/handlers/post_table_data.rs

@@ -85,7 +85,7 @@ pub async fn post_table_data(
     // Build system columns with foreign keys
     let mut system_columns = vec!["deleted".to_string()];
     for fk in fk_columns {
-        let base_name = fk.table_name.split('_').last().unwrap_or(&fk.table_name);
+        let base_name = fk.table_name.split_once('_').map_or(fk.table_name.as_str(), |(_, rest)| rest);
         system_columns.push(format!("{}_id", base_name));
     }