Use lowercase for panel labels

Change "Files" to "files" and "Playlist" to "playlist" in the title bar
for consistent lowercase styling. Also remove unused render_info_popup
function.

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "cm-player"
-version = "0.1.33"
+version = "0.1.37"
 edition = "2021"
 
 [dependencies]

src/main.rs

@@ -16,6 +16,10 @@ use ratatui::{backend::CrosstermBackend, Terminal};
 use state::{AppState, PlayerState};
 use std::io::{self, BufRead, BufReader, Write};
 use std::os::unix::net::UnixStream;
+use std::sync::atomic::{AtomicUsize, Ordering};
+use std::sync::Arc;
+use std::thread;
+use std::time::Duration;
 use tracing_subscriber;
 
 // UI update intervals and thresholds
@@ -528,15 +532,18 @@ fn run_app<B: ratatui::backend::Backend>(
             }
         }
 
-        // Check if mpv process died (e.g., user closed video window)
+        // Check if mpv process died (e.g., user closed video window or force killed)
         if !player.is_process_alive() {
-            if let Some(player_state) = player.get_player_state() {
-                if player_state != PlayerState::Stopped {
+            tracing::info!("MPV process died, recreating...");
             state.current_position = 0.0;
             state.current_duration = 0.0;
+            state.current_file = None;
             state_changed = true;
-                }
-            }
+            skip_position_update = true; // Prevent auto-advance when MPV was killed
+
+            // Recreate player for next playback
+            *player = player::Player::new()?;
+            previous_player_state = Some(PlayerState::Stopped);
         }
 
         // Always update all properties in one batch to keep state synchronized with MPV
@@ -674,7 +681,8 @@ fn handle_key_event<B: ratatui::backend::Backend>(terminal: &mut Terminal<B>, st
             KeyCode::Char('y') | KeyCode::Char('Y') => {
                 state.show_refresh_confirm = false;
                 state.is_refreshing = true;
-                terminal.draw(|f| { let _ = ui::render(f, state, player); })?;  // Show "Refreshing library..." immediately
+                state.refresh_file_count = 0;
+                terminal.draw(|f| { let _ = ui::render(f, state, player); })?;
 
                 let cache_dir = cache::get_cache_dir()?;
 
@@ -682,8 +690,26 @@ fn handle_key_event<B: ratatui::backend::Backend>(terminal: &mut Terminal<B>, st
                 let _ = std::fs::remove_file(cache_dir.join("file_tree.json"));
                 let _ = std::fs::remove_file(cache_dir.join("metadata.json"));
 
-                // Perform fresh scan
-                let new_cache = scanner::scan_paths(&state.config.scan_paths.paths)?;
+                // Create atomic counter for file count
+                let counter = Arc::new(AtomicUsize::new(0));
+                let counter_clone = Arc::clone(&counter);
+
+                // Spawn background thread to perform scan
+                let paths = state.config.scan_paths.paths.clone();
+                let scan_thread = thread::spawn(move || {
+                    scanner::scan_paths(&paths, &counter_clone)
+                });
+
+                // Poll counter and update UI while scanning
+                while !scan_thread.is_finished() {
+                    state.refresh_file_count = counter.load(Ordering::Relaxed);
+                    terminal.draw(|f| { let _ = ui::render(f, state, player); })?;
+                    thread::sleep(Duration::from_millis(100));
+                }
+
+                // Get the result
+                let new_cache = scan_thread.join().map_err(|_| anyhow::anyhow!("Scan thread panicked"))??;
+
                 new_cache.save(&cache_dir)?;
 
                 // Replace old cache completely
@@ -698,6 +724,7 @@ fn handle_key_event<B: ratatui::backend::Backend>(terminal: &mut Terminal<B>, st
                 }
 
                 state.is_refreshing = false;
+                state.refresh_file_count = 0;
             }
             KeyCode::Char('n') | KeyCode::Char('N') | KeyCode::Esc => {
                 state.show_refresh_confirm = false;
@@ -710,6 +737,20 @@ fn handle_key_event<B: ratatui::backend::Backend>(terminal: &mut Terminal<B>, st
     // Handle search mode separately
     if state.search_mode {
         match key.code {
+            KeyCode::Char('n') => {
+                if state.focus_playlist {
+                    state.next_playlist_search_result();
+                } else {
+                    state.next_search_result();
+                }
+            }
+            KeyCode::Char('N') => {
+                if state.focus_playlist {
+                    state.prev_playlist_search_result();
+                } else {
+                    state.prev_search_result();
+                }
+            }
             KeyCode::Char(c) => {
                 if state.focus_playlist {
                     state.append_playlist_search_char(c);
@@ -724,20 +765,6 @@ fn handle_key_event<B: ratatui::backend::Backend>(terminal: &mut Terminal<B>, st
                     state.backspace_search();
                 }
             }
-            KeyCode::Tab => {
-                if state.focus_playlist {
-                    state.playlist_tab_search_next();
-                } else {
-                    state.tab_search_next();
-                }
-            }
-            KeyCode::BackTab => {
-                if state.focus_playlist {
-                    state.playlist_tab_search_prev();
-                } else {
-                    state.tab_search_prev();
-                }
-            }
             KeyCode::Enter => {
                 if state.focus_playlist {
                     state.execute_playlist_search();
@@ -800,32 +827,11 @@ fn handle_key_event<B: ratatui::backend::Backend>(terminal: &mut Terminal<B>, st
             }
         }
         (KeyCode::Esc, _) => {
-            if !state.search_matches.is_empty() {
-                state.search_matches.clear();
-            }
-            if !state.playlist_search_matches.is_empty() {
-                state.playlist_search_matches.clear();
-                state.playlist_tab_search_results.clear();
-            }
             if state.visual_mode {
                 state.visual_mode = false;
                 state.marked_files.clear();
             }
         }
-        (KeyCode::Char('n'), _) => {
-            if !state.search_matches.is_empty() {
-                state.next_search_match();
-            } else if !state.playlist_search_matches.is_empty() {
-                state.next_playlist_search_match();
-            }
-        }
-        (KeyCode::Char('N'), KeyModifiers::SHIFT) => {
-            if !state.search_matches.is_empty() {
-                state.prev_search_match();
-            } else if !state.playlist_search_matches.is_empty() {
-                state.prev_playlist_search_match();
-            }
-        }
         (KeyCode::Char('J'), KeyModifiers::SHIFT) => {
             // Next track
             action_navigate_track(state, player, 1, skip_position_update)?;

src/player/mod.rs

@@ -76,8 +76,10 @@ impl Player {
             let stream = match UnixStream::connect(&self.socket_path) {
                 Ok(s) => s,
                 Err(e) => {
-                    // Connection failed - MPV probably not ready yet
-                    return Err(anyhow::anyhow!("Failed to connect: {}", e));
+                    // Connection failed - MPV probably not ready yet or has been killed
+                    // Don't propagate error - just leave socket as None
+                    tracing::debug!("Failed to connect to MPV socket: {}", e);
+                    return Ok(());
                 }
             };
 

src/scanner/mod.rs

@@ -1,6 +1,7 @@
 use crate::cache::{Cache, FileMetadata, FileTreeNode};
 use anyhow::Result;
 use std::path::{Path, PathBuf};
+use std::sync::atomic::{AtomicUsize, Ordering};
 use walkdir::WalkDir;
 
 const AUDIO_EXTENSIONS: &[&str] = &["mp3", "flac", "wav", "ogg", "m4a", "aac", "opus", "wma"];
@@ -33,7 +34,7 @@ pub fn is_video_file(path: &Path) -> bool {
     }
 }
 
-pub fn scan_directory(root_path: &Path) -> Result<FileTreeNode> {
+fn scan_directory_internal(root_path: &Path, counter: &AtomicUsize) -> Result<FileTreeNode> {
     let name = root_path
         .file_name()
         .unwrap_or_default()
@@ -62,13 +63,16 @@ pub fn scan_directory(root_path: &Path) -> Result<FileTreeNode> {
 
         if entry.file_type().is_dir() {
             // Recursively scan subdirectories
-            if let Ok(child_node) = scan_directory(path) {
+            if let Ok(child_node) = scan_directory_internal(path, counter) {
                 // Only add directory if it contains media files or non-empty subdirectories
                 if !child_node.children.is_empty() {
                     node.children.push(child_node);
                 }
             }
         } else if is_media_file(path) {
+            // Increment counter for each media file found
+            counter.fetch_add(1, Ordering::Relaxed);
+
             // Add media file
             let file_name = path
                 .file_name()
@@ -100,13 +104,13 @@ pub fn scan_directory(root_path: &Path) -> Result<FileTreeNode> {
     Ok(node)
 }
 
-pub fn scan_paths(paths: &[PathBuf]) -> Result<Cache> {
+pub fn scan_paths(paths: &[PathBuf], counter: &AtomicUsize) -> Result<Cache> {
     let mut cache = Cache::new();
 
     for path in paths {
         if path.exists() {
             tracing::info!("Scanning path: {:?}", path);
-            let tree_node = scan_directory(path)?;
+            let tree_node = scan_directory_internal(path, counter)?;
 
             // Collect all metadata from the tree
             collect_metadata(&tree_node, &mut cache);

src/state/mod.rs

@@ -74,14 +74,10 @@ pub struct AppState {
     pub is_refreshing: bool,
     pub search_mode: bool,
     pub search_query: String,
-    pub search_matches: Vec<PathBuf>,
-    pub search_match_index: usize,
-    pub tab_search_results: Vec<PathBuf>,
-    pub tab_search_index: usize,
-    pub playlist_search_matches: Vec<usize>,
-    pub playlist_search_match_index: usize,
-    pub playlist_tab_search_results: Vec<usize>,
-    pub playlist_tab_search_index: usize,
+    pub search_results: Vec<PathBuf>,
+    pub search_result_index: usize,
+    pub playlist_search_results: Vec<usize>,
+    pub playlist_search_result_index: usize,
     pub visual_mode: bool,
     pub visual_anchor: usize,
     pub saved_expanded_dirs: HashSet<PathBuf>,
@@ -92,6 +88,8 @@ pub struct AppState {
     pub last_click_is_playlist: bool,
     pub context_menu: Option<ContextMenu>,
     pub play_mode: PlayMode,
+    pub last_error: Option<String>,
+    pub refresh_file_count: usize,
 }
 
 #[derive(Debug, Clone)]
@@ -131,14 +129,10 @@ impl AppState {
             is_refreshing: false,
             search_mode: false,
             search_query: String::new(),
-            search_matches: Vec::new(),
-            search_match_index: 0,
-            tab_search_results: Vec::new(),
-            tab_search_index: 0,
-            playlist_search_matches: Vec::new(),
-            playlist_search_match_index: 0,
-            playlist_tab_search_results: Vec::new(),
-            playlist_tab_search_index: 0,
+            search_results: Vec::new(),
+            search_result_index: 0,
+            playlist_search_results: Vec::new(),
+            playlist_search_result_index: 0,
             visual_mode: false,
             visual_anchor: 0,
             saved_expanded_dirs: HashSet::new(),
@@ -149,6 +143,8 @@ impl AppState {
             last_click_is_playlist: false,
             context_menu: None,
             play_mode: PlayMode::Normal,
+            last_error: None,
+            refresh_file_count: 0,
         }
     }
 
@@ -680,16 +676,12 @@ impl AppState {
 
         if self.focus_playlist {
             // Clear playlist search state
-            self.playlist_search_matches.clear();
-            self.playlist_search_match_index = 0;
-            self.playlist_tab_search_results.clear();
-            self.playlist_tab_search_index = 0;
+            self.playlist_search_results.clear();
+            self.playlist_search_result_index = 0;
         } else {
             // Clear file search state
-            self.search_matches.clear();
-            self.search_match_index = 0;
-            self.tab_search_results.clear();
-            self.tab_search_index = 0;
+            self.search_results.clear();
+            self.search_result_index = 0;
             // Save current folder state
             self.saved_expanded_dirs = self.expanded_dirs.clone();
         }
@@ -697,15 +689,16 @@ impl AppState {
 
     pub fn exit_search_mode(&mut self) {
         self.search_mode = false;
+        self.search_query.clear();
 
         if self.focus_playlist {
             // Clear playlist search state
-            self.playlist_tab_search_results.clear();
-            self.playlist_tab_search_index = 0;
+            self.playlist_search_results.clear();
+            self.playlist_search_result_index = 0;
         } else {
             // Clear file search state
-            self.tab_search_results.clear();
-            self.tab_search_index = 0;
+            self.search_results.clear();
+            self.search_result_index = 0;
             // Restore folder state from before search
             self.expanded_dirs = self.saved_expanded_dirs.clone();
             self.rebuild_flattened_items();
@@ -724,9 +717,8 @@ impl AppState {
 
     fn perform_incremental_search(&mut self) {
         if self.search_query.is_empty() {
-            self.tab_search_results.clear();
-            self.tab_search_index = 0;
-            // Don't rebuild tree on every keystroke - only when exiting search
+            self.search_results.clear();
+            self.search_result_index = 0;
             return;
         }
 
@@ -735,8 +727,8 @@ impl AppState {
         collect_matching_paths(&self.cache.file_tree, &self.search_query, &mut matching_paths_with_scores);
 
         if matching_paths_with_scores.is_empty() {
-            self.tab_search_results.clear();
-            self.tab_search_index = 0;
+            self.search_results.clear();
+            self.search_result_index = 0;
             return;
         }
 
@@ -750,22 +742,30 @@ impl AppState {
         // Sort by score (highest first), then by original index to prefer first occurrence
         indexed_matches.sort_by(|a, b| b.1.cmp(&a.1).then_with(|| a.2.cmp(&b.2)));
 
-        // Store all matches for tab completion
-        self.tab_search_results = indexed_matches.iter().map(|(path, _, _)| path.clone()).collect();
-        self.tab_search_index = 0;
+        // Store all matches
+        self.search_results = indexed_matches.iter().map(|(path, _, _)| path.clone()).collect();
+        self.search_result_index = 0;
 
-        // Only expand and rebuild if this is a new best match
-        let best_match = self.tab_search_results[0].clone();
+        // Jump to first match
+        self.jump_to_current_search_result();
+    }
+
+    fn jump_to_current_search_result(&mut self) {
+        if self.search_results.is_empty() {
+            return;
+        }
+
+        let current_match = self.search_results[self.search_result_index].clone();
 
         // Check if we need to expand folders for this match
-        let needs_expand = best_match.ancestors()
+        let needs_expand = current_match.ancestors()
             .skip(1) // Skip the file itself
             .any(|p| !self.expanded_dirs.contains(p));
 
         if needs_expand {
-            // Close all folders and expand only for the best match
+            // Close all folders and expand only for the current match
             self.expanded_dirs.clear();
-            let mut parent = best_match.parent();
+            let mut parent = current_match.parent();
             while let Some(p) = parent {
                 self.expanded_dirs.insert(p.to_path_buf());
                 parent = p.parent();
@@ -775,8 +775,8 @@ impl AppState {
             self.rebuild_flattened_items();
         }
 
-        // Find the best match in the flattened list and jump to it
-        if let Some(idx) = self.flattened_items.iter().position(|item| item.path == best_match) {
+        // Find the match in the flattened list and jump to it
+        if let Some(idx) = self.flattened_items.iter().position(|item| item.path == current_match) {
             self.selected_index = idx;
 
             // Scroll to show the match
@@ -794,233 +794,26 @@ impl AppState {
         }
     }
 
+    pub fn next_search_result(&mut self) {
+        if !self.search_results.is_empty() {
+            self.search_result_index = (self.search_result_index + 1) % self.search_results.len();
+            self.jump_to_current_search_result();
+        }
+    }
+
+    pub fn prev_search_result(&mut self) {
+        if !self.search_results.is_empty() {
+            self.search_result_index = if self.search_result_index == 0 {
+                self.search_results.len() - 1
+            } else {
+                self.search_result_index - 1
+            };
+            self.jump_to_current_search_result();
+        }
+    }
+
     pub fn execute_search(&mut self) {
-        if self.search_query.is_empty() {
-            self.search_mode = false;
-            return;
-        }
-
-        // Collect all matching paths with scores and preserve order
-        let mut matching_paths_with_scores = Vec::new();
-        collect_matching_paths(&self.cache.file_tree, &self.search_query, &mut matching_paths_with_scores);
-
-        if matching_paths_with_scores.is_empty() {
-            self.search_mode = false;
-            return;
-        }
-
-        // Add index to preserve original tree order when scores are equal
-        let mut indexed_matches: Vec<(PathBuf, i32, usize)> = matching_paths_with_scores
-            .into_iter()
-            .enumerate()
-            .map(|(idx, (path, score))| (path, score, idx))
-            .collect();
-
-        // Sort by score (highest first), then by original index to prefer first occurrence
-        indexed_matches.sort_by(|a, b| b.1.cmp(&a.1).then_with(|| a.2.cmp(&b.2)));
-
-        let matching_paths_with_scores: Vec<(PathBuf, i32)> = indexed_matches
-            .into_iter()
-            .map(|(path, score, _)| (path, score))
-            .collect();
-        let matching_paths: Vec<PathBuf> = matching_paths_with_scores.iter().map(|(path, _)| path.clone()).collect();
-
-        // Store matching paths (not indices, as they change when folders collapse)
-        self.search_matches = matching_paths;
-
-        if !self.search_matches.is_empty() {
-            self.search_match_index = 0;
-            // Close all folders and expand only for first match
-            self.expanded_dirs.clear();
-            let first_match = self.search_matches[0].clone();
-            let mut parent = first_match.parent();
-            while let Some(p) = parent {
-                self.expanded_dirs.insert(p.to_path_buf());
-                parent = p.parent();
-            }
-
-            // Rebuild flattened items
-            self.rebuild_flattened_items();
-
-            // Find first match in flattened list
-            if let Some(idx) = self.flattened_items.iter().position(|item| item.path == first_match) {
-                self.selected_index = idx;
-            }
-        }
-
-        self.search_mode = false;
-    }
-
-    pub fn next_search_match(&mut self) {
-        if !self.search_matches.is_empty() {
-            self.search_match_index = (self.search_match_index + 1) % self.search_matches.len();
-            let target_path = self.search_matches[self.search_match_index].clone();
-
-            // Close all folders and expand only for this match
-            self.expanded_dirs.clear();
-            let mut parent = target_path.parent();
-            while let Some(p) = parent {
-                self.expanded_dirs.insert(p.to_path_buf());
-                parent = p.parent();
-            }
-
-            // Rebuild flattened items
-            self.rebuild_flattened_items();
-
-            // Find the path in current flattened items
-            if let Some(idx) = self.flattened_items.iter().position(|item| item.path == target_path) {
-                self.selected_index = idx;
-
-                // Scroll to show the match
-                // Account for "... X more below" indicator which takes one line
-                let visible_end = self.scroll_offset + self.file_panel_visible_height;
-                let items_below = if visible_end < self.flattened_items.len() {
-                    self.flattened_items.len() - visible_end
-                } else {
-                    0
-                };
-                let effective_height = if items_below > 0 {
-                    self.file_panel_visible_height.saturating_sub(1)
-                } else {
-                    self.file_panel_visible_height
-                };
-
-                if self.selected_index < self.scroll_offset {
-                    self.scroll_offset = self.selected_index;
-                } else if self.selected_index >= self.scroll_offset + effective_height {
-                    self.scroll_offset = self.selected_index - effective_height + 1;
-                }
-            }
-        }
-    }
-
-    pub fn prev_search_match(&mut self) {
-        if !self.search_matches.is_empty() {
-            if self.search_match_index == 0 {
-                self.search_match_index = self.search_matches.len() - 1;
-            } else {
-                self.search_match_index -= 1;
-            }
-            let target_path = self.search_matches[self.search_match_index].clone();
-
-            // Close all folders and expand only for this match
-            self.expanded_dirs.clear();
-            let mut parent = target_path.parent();
-            while let Some(p) = parent {
-                self.expanded_dirs.insert(p.to_path_buf());
-                parent = p.parent();
-            }
-
-            // Rebuild flattened items
-            self.rebuild_flattened_items();
-
-            // Find the path in current flattened items
-            if let Some(idx) = self.flattened_items.iter().position(|item| item.path == target_path) {
-                self.selected_index = idx;
-
-                // Scroll to show the match
-                // Account for "... X more below" indicator which takes one line
-                let visible_end = self.scroll_offset + self.file_panel_visible_height;
-                let items_below = if visible_end < self.flattened_items.len() {
-                    self.flattened_items.len() - visible_end
-                } else {
-                    0
-                };
-                let effective_height = if items_below > 0 {
-                    self.file_panel_visible_height.saturating_sub(1)
-                } else {
-                    self.file_panel_visible_height
-                };
-
-                if self.selected_index < self.scroll_offset {
-                    self.scroll_offset = self.selected_index;
-                } else if self.selected_index >= self.scroll_offset + effective_height {
-                    self.scroll_offset = self.selected_index - effective_height + 1;
-                }
-            }
-        }
-    }
-
-    pub fn tab_search_next(&mut self) {
-        if self.tab_search_results.is_empty() {
-            return;
-        }
-
-        // Cycle to next match
-        self.tab_search_index = (self.tab_search_index + 1) % self.tab_search_results.len();
-        let next_match = self.tab_search_results[self.tab_search_index].clone();
-
-        // Close all folders and expand only for this match
-        self.expanded_dirs.clear();
-        let mut parent = next_match.parent();
-        while let Some(p) = parent {
-            self.expanded_dirs.insert(p.to_path_buf());
-            parent = p.parent();
-        }
-
-        // Rebuild flattened items
-        self.rebuild_flattened_items();
-
-        // Find and select the match
-        if let Some(idx) = self.flattened_items.iter().position(|item| item.path == next_match) {
-            self.selected_index = idx;
-
-            // Scroll to show the match
-            let effective_height = calculate_effective_height(
-                self.scroll_offset,
-                self.file_panel_visible_height,
-                self.flattened_items.len()
-            );
-
-            if self.selected_index < self.scroll_offset {
-                self.scroll_offset = self.selected_index;
-            } else if self.selected_index >= self.scroll_offset + effective_height {
-                self.scroll_offset = self.selected_index - effective_height + 1;
-            }
-        }
-    }
-
-    pub fn tab_search_prev(&mut self) {
-        if self.tab_search_results.is_empty() {
-            return;
-        }
-
-        // Cycle to previous match
-        if self.tab_search_index == 0 {
-            self.tab_search_index = self.tab_search_results.len() - 1;
-        } else {
-            self.tab_search_index -= 1;
-        }
-        let prev_match = self.tab_search_results[self.tab_search_index].clone();
-
-        // Close all folders and expand only for this match
-        self.expanded_dirs.clear();
-        let mut parent = prev_match.parent();
-        while let Some(p) = parent {
-            self.expanded_dirs.insert(p.to_path_buf());
-            parent = p.parent();
-        }
-
-        // Rebuild flattened items
-        self.rebuild_flattened_items();
-
-        // Find and select the match
-        if let Some(idx) = self.flattened_items.iter().position(|item| item.path == prev_match) {
-            self.selected_index = idx;
-
-            // Scroll to show the match
-            let effective_height = calculate_effective_height(
-                self.scroll_offset,
-                self.file_panel_visible_height,
-                self.flattened_items.len()
-            );
-
-            if self.selected_index < self.scroll_offset {
-                self.scroll_offset = self.selected_index;
-            } else if self.selected_index >= self.scroll_offset + effective_height {
-                self.scroll_offset = self.selected_index - effective_height + 1;
-            }
-        }
+        self.exit_search_mode();
     }
 
     pub fn append_playlist_search_char(&mut self, c: char) {
@@ -1035,8 +828,8 @@ impl AppState {
 
     fn perform_playlist_incremental_search(&mut self) {
         if self.search_query.is_empty() {
-            self.playlist_tab_search_results.clear();
-            self.playlist_tab_search_index = 0;
+            self.playlist_search_results.clear();
+            self.playlist_search_result_index = 0;
             return;
         }
 
@@ -1053,21 +846,29 @@ impl AppState {
             .collect();
 
         if matching_indices_with_scores.is_empty() {
-            self.playlist_tab_search_results.clear();
-            self.playlist_tab_search_index = 0;
+            self.playlist_search_results.clear();
+            self.playlist_search_result_index = 0;
             return;
         }
 
         // Sort by score (highest first)
         matching_indices_with_scores.sort_by(|a, b| b.1.cmp(&a.1));
 
-        // Store all matches for tab completion
-        self.playlist_tab_search_results = matching_indices_with_scores.iter().map(|(idx, _)| *idx).collect();
-        self.playlist_tab_search_index = 0;
+        // Store all matches
+        self.playlist_search_results = matching_indices_with_scores.iter().map(|(idx, _)| *idx).collect();
+        self.playlist_search_result_index = 0;
 
-        // Jump to best match
-        let best_match_idx = self.playlist_tab_search_results[0];
-        self.selected_playlist_index = best_match_idx;
+        // Jump to first match
+        self.jump_to_current_playlist_search_result();
+    }
+
+    fn jump_to_current_playlist_search_result(&mut self) {
+        if self.playlist_search_results.is_empty() {
+            return;
+        }
+
+        let match_idx = self.playlist_search_results[self.playlist_search_result_index];
+        self.selected_playlist_index = match_idx;
 
         // Scroll to show the match
         let effective_height = calculate_effective_height(
@@ -1083,174 +884,26 @@ impl AppState {
         }
     }
 
-    pub fn playlist_tab_search_next(&mut self) {
-        if self.playlist_tab_search_results.is_empty() {
-            return;
-        }
-
-        // Cycle to next match
-        self.playlist_tab_search_index = (self.playlist_tab_search_index + 1) % self.playlist_tab_search_results.len();
-        let next_match_idx = self.playlist_tab_search_results[self.playlist_tab_search_index];
-        self.selected_playlist_index = next_match_idx;
-
-        // Scroll to show the match
-        let effective_height = calculate_effective_height(
-            self.playlist_scroll_offset,
-            self.playlist_visible_height,
-            self.playlist.len()
-        );
-
-        if self.selected_playlist_index < self.playlist_scroll_offset {
-            self.playlist_scroll_offset = self.selected_playlist_index;
-        } else if self.selected_playlist_index >= self.playlist_scroll_offset + effective_height {
-            self.playlist_scroll_offset = self.selected_playlist_index - effective_height + 1;
+    pub fn next_playlist_search_result(&mut self) {
+        if !self.playlist_search_results.is_empty() {
+            self.playlist_search_result_index = (self.playlist_search_result_index + 1) % self.playlist_search_results.len();
+            self.jump_to_current_playlist_search_result();
         }
     }
 
-    pub fn playlist_tab_search_prev(&mut self) {
-        if self.playlist_tab_search_results.is_empty() {
-            return;
-        }
-
-        // Cycle to previous match
-        if self.playlist_tab_search_index == 0 {
-            self.playlist_tab_search_index = self.playlist_tab_search_results.len() - 1;
+    pub fn prev_playlist_search_result(&mut self) {
+        if !self.playlist_search_results.is_empty() {
+            self.playlist_search_result_index = if self.playlist_search_result_index == 0 {
+                self.playlist_search_results.len() - 1
             } else {
-            self.playlist_tab_search_index -= 1;
-        }
-        let prev_match_idx = self.playlist_tab_search_results[self.playlist_tab_search_index];
-        self.selected_playlist_index = prev_match_idx;
-
-        // Scroll to show the match
-        let effective_height = calculate_effective_height(
-            self.playlist_scroll_offset,
-            self.playlist_visible_height,
-            self.playlist.len()
-        );
-
-        if self.selected_playlist_index < self.playlist_scroll_offset {
-            self.playlist_scroll_offset = self.selected_playlist_index;
-        } else if self.selected_playlist_index >= self.playlist_scroll_offset + effective_height {
-            self.playlist_scroll_offset = self.selected_playlist_index - effective_height + 1;
+                self.playlist_search_result_index - 1
+            };
+            self.jump_to_current_playlist_search_result();
         }
     }
 
     pub fn execute_playlist_search(&mut self) {
-        if self.search_query.is_empty() {
-            self.search_mode = false;
-            return;
-        }
-
-        // Collect all matching indices with scores
-        let mut matching_indices_with_scores: Vec<(usize, i32)> = self.playlist
-            .iter()
-            .enumerate()
-            .filter_map(|(idx, path)| {
-                let filename = path.file_name()
-                    .and_then(|n| n.to_str())
-                    .unwrap_or("");
-                fuzzy_match(filename, &self.search_query).map(|score| (idx, score))
-            })
-            .collect();
-
-        if matching_indices_with_scores.is_empty() {
-            self.search_mode = false;
-            return;
-        }
-
-        // Sort by score (highest first)
-        matching_indices_with_scores.sort_by(|a, b| b.1.cmp(&a.1));
-
-        // Store matching indices
-        self.playlist_search_matches = matching_indices_with_scores.iter().map(|(idx, _)| *idx).collect();
-
-        if !self.playlist_search_matches.is_empty() {
-            self.playlist_search_match_index = 0;
-            let first_match_idx = self.playlist_search_matches[0];
-            self.selected_playlist_index = first_match_idx;
-
-            // Scroll to show the match
-            // Account for "... X more below" indicator which takes one line
-            let visible_end = self.playlist_scroll_offset + self.playlist_visible_height;
-            let items_below = if visible_end < self.playlist.len() {
-                self.playlist.len() - visible_end
-            } else {
-                0
-            };
-            let effective_height = if items_below > 0 {
-                self.playlist_visible_height.saturating_sub(1)
-            } else {
-                self.playlist_visible_height
-            };
-
-            if self.selected_playlist_index < self.playlist_scroll_offset {
-                self.playlist_scroll_offset = self.selected_playlist_index;
-            } else if self.selected_playlist_index >= self.playlist_scroll_offset + effective_height {
-                self.playlist_scroll_offset = self.selected_playlist_index - effective_height + 1;
-            }
-        }
-
-        self.search_mode = false;
-    }
-
-    pub fn next_playlist_search_match(&mut self) {
-        if !self.playlist_search_matches.is_empty() {
-            self.playlist_search_match_index = (self.playlist_search_match_index + 1) % self.playlist_search_matches.len();
-            let match_idx = self.playlist_search_matches[self.playlist_search_match_index];
-            self.selected_playlist_index = match_idx;
-
-            // Scroll to show the match
-            // Account for "... X more below" indicator which takes one line
-            let visible_end = self.playlist_scroll_offset + self.playlist_visible_height;
-            let items_below = if visible_end < self.playlist.len() {
-                self.playlist.len() - visible_end
-            } else {
-                0
-            };
-            let effective_height = if items_below > 0 {
-                self.playlist_visible_height.saturating_sub(1)
-            } else {
-                self.playlist_visible_height
-            };
-
-            if self.selected_playlist_index < self.playlist_scroll_offset {
-                self.playlist_scroll_offset = self.selected_playlist_index;
-            } else if self.selected_playlist_index >= self.playlist_scroll_offset + effective_height {
-                self.playlist_scroll_offset = self.selected_playlist_index - effective_height + 1;
-            }
-        }
-    }
-
-    pub fn prev_playlist_search_match(&mut self) {
-        if !self.playlist_search_matches.is_empty() {
-            if self.playlist_search_match_index == 0 {
-                self.playlist_search_match_index = self.playlist_search_matches.len() - 1;
-            } else {
-                self.playlist_search_match_index -= 1;
-            }
-            let match_idx = self.playlist_search_matches[self.playlist_search_match_index];
-            self.selected_playlist_index = match_idx;
-
-            // Scroll to show the match
-            // Account for "... X more below" indicator which takes one line
-            let visible_end = self.playlist_scroll_offset + self.playlist_visible_height;
-            let items_below = if visible_end < self.playlist.len() {
-                self.playlist.len() - visible_end
-            } else {
-                0
-            };
-            let effective_height = if items_below > 0 {
-                self.playlist_visible_height.saturating_sub(1)
-            } else {
-                self.playlist_visible_height
-            };
-
-            if self.selected_playlist_index < self.playlist_scroll_offset {
-                self.playlist_scroll_offset = self.selected_playlist_index;
-            } else if self.selected_playlist_index >= self.playlist_scroll_offset + effective_height {
-                self.playlist_scroll_offset = self.selected_playlist_index - effective_height + 1;
-            }
-        }
+        self.exit_search_mode();
     }
 
 }

src/ui/mod.rs

@@ -46,18 +46,18 @@ pub fn render(frame: &mut Frame, state: &mut AppState, player: &mut Player) -> (
 
     // Add playlist counter
     let playlist_text = if !state.playlist.is_empty() {
-        format!("Playlist [{}/{}]", state.playlist_index + 1, state.playlist.len())
+        format!("playlist [{}/{}]", state.playlist_index + 1, state.playlist.len())
     } else {
-        "Playlist (empty)".to_string()
+        "playlist (empty)".to_string()
     };
 
     let title = Line::from(vec![
-        Span::styled("Files", file_style),
+        Span::styled("files", file_style),
         Span::raw(" | "),
         Span::styled(playlist_text, playlist_style),
     ]);
 
-    // Create one border around the entire content area
+    // Create one border around the entire content area with fixed gray border
     let main_block = Block::default()
         .borders(Borders::ALL)
         .title(title)
@@ -79,7 +79,7 @@ pub fn render(frame: &mut Frame, state: &mut AppState, player: &mut Player) -> (
 
     // Show refreshing popup if scanning
     if state.is_refreshing {
-        render_info_popup(frame, "Refreshing library...");
+        render_refresh_popup(frame, state.refresh_file_count);
     }
 
     // Show confirmation popup if needed
@@ -162,7 +162,7 @@ fn render_file_panel(frame: &mut Frame, state: &mut AppState, area: Rect, _tab_m
     // Store visible height for keyboard navigation scroll calculations
     state.file_panel_visible_height = visible_height;
 
-    let in_search = !state.focus_playlist && (state.search_mode || !state.search_matches.is_empty());
+    let in_search = !state.focus_playlist && state.search_mode;
     let search_query = if in_search { state.search_query.to_lowercase() } else { String::new() };
 
     // Calculate how many items are below the visible area
@@ -306,7 +306,7 @@ fn render_right_panel(frame: &mut Frame, state: &mut AppState, area: Rect, _tab_
     };
 
     // Check if in playlist search mode
-    let in_playlist_search = state.focus_playlist && (state.search_mode || !state.playlist_tab_search_results.is_empty() || !state.playlist_search_matches.is_empty());
+    let in_playlist_search = state.focus_playlist && state.search_mode;
     let playlist_search_query = if in_playlist_search { state.search_query.to_lowercase() } else { String::new() };
 
     // Playlist panel (no longer need the player status box)
@@ -384,12 +384,17 @@ fn render_right_panel(frame: &mut Frame, state: &mut AppState, area: Rect, _tab_
 }
 
 fn render_title_bar(frame: &mut Frame, state: &AppState, player: &mut Player, area: Rect) {
-    // Default to stopped if we can't query MPV
+    // Get player state
     let player_state = player.get_player_state().unwrap_or(PlayerState::Stopped);
-    let background_color = match player_state {
+
+    // Title bar background color: red for error, gray for stopped/paused, green for playing
+    let background_color = if state.last_error.is_some() {
+        Theme::error()
+    } else {
+        match player_state {
             PlayerState::Playing => Theme::success(),     // Green for playing
-        PlayerState::Paused => Theme::highlight(),    // Blue for paused
-        PlayerState::Stopped => Theme::dim_foreground(),   // Gray for stopped
+            PlayerState::Paused | PlayerState::Stopped => Theme::border(),    // Gray for paused/stopped
+        }
     };
 
     // Split the title bar into left and right sections
@@ -502,8 +507,8 @@ fn render_status_bar(frame: &mut Frame, state: &AppState, player: &mut Player, a
         // Show search prompt with current query and match count - LEFT aligned
         if state.focus_playlist {
             // Searching in playlist
-            if !state.playlist_tab_search_results.is_empty() {
-                format!("/{}_  Playlist Search: {}/{}", state.search_query, state.playlist_tab_search_index + 1, state.playlist_tab_search_results.len())
+            if !state.playlist_search_results.is_empty() {
+                format!("/{}_  Playlist Search: {}/{}", state.search_query, state.playlist_search_result_index + 1, state.playlist_search_results.len())
             } else if !state.search_query.is_empty() {
                 format!("/{}_  [no matches]", state.search_query)
             } else {
@@ -511,20 +516,14 @@ fn render_status_bar(frame: &mut Frame, state: &AppState, player: &mut Player, a
             }
         } else {
             // Searching in file panel
-            if !state.tab_search_results.is_empty() {
-                format!("/{}_  Search: {}/{}", state.search_query, state.tab_search_index + 1, state.tab_search_results.len())
+            if !state.search_results.is_empty() {
+                format!("/{}_  Search: {}/{}", state.search_query, state.search_result_index + 1, state.search_results.len())
             } else if !state.search_query.is_empty() {
                 format!("/{}_  [no matches]", state.search_query)
             } else {
                 format!("/{}_", state.search_query)
             }
         }
-    } else if !state.search_matches.is_empty() {
-        // Show search navigation when file search results are active
-        format!("/{}  Search: {}/{}", state.search_query, state.search_match_index + 1, state.search_matches.len())
-    } else if !state.playlist_search_matches.is_empty() {
-        // Show search navigation when playlist search results are active
-        format!("/{}  Playlist Search: {}/{}", state.search_query, state.playlist_search_match_index + 1, state.playlist_search_matches.len())
     } else if state.visual_mode {
         // Show visual mode indicator
         format!("-- VISUAL -- {} files marked", state.marked_files.len())
@@ -720,11 +719,11 @@ fn render_progress_bar(frame: &mut Frame, _state: &AppState, player: &mut Player
     frame.render_widget(progress_widget, area);
 }
 
-fn render_info_popup(frame: &mut Frame, message: &str) {
-    // Create centered popup area - smaller than confirm popup
+fn render_refresh_popup(frame: &mut Frame, file_count: usize) {
+    // Create centered popup area - bigger for two lines
     let area = frame.area();
-    let popup_width = 40;
-    let popup_height = 3;
+    let popup_width = 50;
+    let popup_height = 5;
 
     let popup_area = Rect {
         x: (area.width.saturating_sub(popup_width)) / 2,
@@ -746,8 +745,22 @@ fn render_info_popup(frame: &mut Frame, message: &str) {
     let inner = block.inner(popup_area);
     frame.render_widget(block, popup_area);
 
+    // Build two-line message
+    let lines = if file_count > 0 {
+        vec![
+            Line::from("Refreshing library..."),
+            Line::from(""),
+            Line::from(format!("{} files found", file_count))
+                .style(Style::default().fg(Theme::highlight())),
+        ]
+    } else {
+        vec![
+            Line::from("Refreshing library..."),
+        ]
+    };
+
     // Render message centered
-    let message_widget = Paragraph::new(message)
+    let message_widget = Paragraph::new(lines)
         .alignment(Alignment::Center)
         .style(Style::default()
             .fg(Theme::bright_foreground())

src/ui/theme.rs

@@ -34,6 +34,10 @@ impl Theme {
         Color::Rgb(215, 175, 95) // #d7af5f
     }
 
+    pub fn normal_red() -> Color {
+        Color::Rgb(215, 95, 95) // #d75f5f
+    }
+
     // Semantic mappings
     pub fn secondary_text() -> Color {
         Self::foreground()
@@ -59,6 +63,10 @@ impl Theme {
         Self::normal_yellow()
     }
 
+    pub fn error() -> Color {
+        Self::normal_red()
+    }
+
     // Styles
     pub fn widget_border_style() -> Style {
         Style::default().fg(Self::border()).bg(Self::background())