Move refresh status to centered popup

Display "Refreshing library..." in a centered popup overlay instead
of showing it in the title bar. This makes the refresh status more
prominent and cleaner.

Cargo.toml

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

src/api/mod.rs

@@ -50,22 +50,6 @@ impl ApiResponse {
             data: None,
         }
     }
-
-    pub fn success_with_data(data: serde_json::Value) -> Self {
-        Self {
-            success: true,
-            message: None,
-            data: Some(data),
-        }
-    }
-
-    pub fn error(message: String) -> Self {
-        Self {
-            success: false,
-            message: Some(message),
-            data: None,
-        }
-    }
 }
 
 /// Start the API server on a Unix socket

src/main.rs

@@ -19,9 +19,8 @@ use std::os::unix::net::UnixStream;
 use tracing_subscriber;
 
 // UI update intervals and thresholds
-const METADATA_UPDATE_INTERVAL: u32 = 20; // Update metadata every N iterations (~2 seconds)
 const POLL_DURATION_STOPPED_MS: u64 = 200; // 5 FPS when stopped
-const POLL_DURATION_ACTIVE_MS: u64 = 100; // 10 FPS when playing/paused
+const POLL_DURATION_ACTIVE_MS: u64 = 200; // 5 FPS when playing/paused - single batch poll
 const DOUBLE_CLICK_MS: u128 = 500; // Double-click detection threshold
 
 fn main() -> Result<()> {
@@ -219,13 +218,14 @@ fn action_toggle_folder(state: &mut AppState) {
     }
 }
 
-fn action_play_selection(state: &mut AppState, player: &mut player::Player) -> Result<()> {
+fn action_play_selection(state: &mut AppState, player: &mut player::Player, skip_position_update: &mut bool) -> Result<()> {
     state.play_selection();
     if let Some(ref path) = state.current_file {
+        *skip_position_update = true; // Skip position update after track change
         player.play(path)?;
         // Explicitly resume playback in case MPV was paused
         player.resume()?;
-        player.update_metadata();
+        // Metadata will be fetched by periodic update once MPV has it ready
         tracing::info!("Playing: {:?} (playlist: {} tracks)", path, state.playlist.len());
     }
     if state.visual_mode {
@@ -253,7 +253,6 @@ fn action_toggle_play_pause(state: &mut AppState, player: &mut player::Player) -
                     if let Some(ref path) = state.current_file {
                         player.play(path)?;
                         player.resume()?;
-                        player.update_metadata();
                         tracing::info!("Restarting playback: {:?}", path);
                     }
                 }
@@ -286,13 +285,13 @@ fn action_remove_from_playlist(state: &mut AppState, player: &mut player::Player
             player.play(path)?;
             // Explicitly resume playback in case MPV was paused
             player.resume()?;
-            player.update_metadata();
+                // Metadata will be fetched by periodic update
         }
     }
     Ok(())
 }
 
-fn action_navigate_track(state: &mut AppState, player: &mut player::Player, direction: i32) -> Result<()> {
+fn action_navigate_track(state: &mut AppState, player: &mut player::Player, direction: i32, skip_position_update: &mut bool) -> Result<()> {
     // direction: 1 for next, -1 for previous
     let new_index = if direction > 0 {
         state.playlist_index.saturating_add(1)
@@ -315,17 +314,19 @@ fn action_navigate_track(state: &mut AppState, player: &mut player::Player, dire
             PlayerState::Playing => {
                 // Keep playing
                 if let Some(ref path) = state.current_file {
+                    *skip_position_update = true; // Skip position update after track change
                     player.play(path)?;
                     player.resume()?;
-                    player.update_metadata();
+                    // Metadata will be fetched by periodic update
                     tracing::info!("{} track: {:?}", track_name, path);
                 }
             }
             PlayerState::Paused => {
                 // Load but stay paused
                 if let Some(ref path) = state.current_file {
+                    *skip_position_update = true; // Skip position update after track change
                     player.play_paused(path)?;
-                    player.update_metadata();
+                    // Metadata will be fetched by periodic update
                     tracing::info!("{} track (paused): {:?}", track_name, path);
                 }
             }
@@ -344,33 +345,37 @@ fn action_navigate_track(state: &mut AppState, player: &mut player::Player, dire
     Ok(())
 }
 
-fn action_play_from_playlist(state: &mut AppState, player: &mut player::Player, preserve_pause: bool) -> Result<()> {
+fn action_play_from_playlist(state: &mut AppState, player: &mut player::Player, preserve_pause: bool, skip_position_update: &mut bool) -> Result<()> {
     state.playlist_index = state.selected_playlist_index;
     state.current_file = Some(state.playlist[state.playlist_index].clone());
 
+
     if preserve_pause {
         if let Some(player_state) = player.get_player_state() {
             match player_state {
                 PlayerState::Playing => {
                     if let Some(ref path) = state.current_file {
+                        *skip_position_update = true; // Skip position update after track change
                         player.play(path)?;
                         player.resume()?;
-                        player.update_metadata();
+                        // Metadata will be fetched by periodic update
                         tracing::info!("Jumped to track: {:?}", path);
                     }
                 }
                 PlayerState::Paused => {
                     if let Some(ref path) = state.current_file {
+                        *skip_position_update = true; // Skip position update after track change
                         player.play_paused(path)?;
-                        player.update_metadata();
+                        // Metadata will be fetched by periodic update
                         tracing::info!("Jumped to track (paused): {:?}", path);
                     }
                 }
                 PlayerState::Stopped => {
                     if let Some(ref path) = state.current_file {
+                        *skip_position_update = true; // Skip position update after track change
                         player.play(path)?;
                         player.resume()?;
-                        player.update_metadata();
+                        // Metadata will be fetched by periodic update
                         tracing::info!("Started playing track: {:?}", path);
                     }
                 }
@@ -378,21 +383,22 @@ fn action_play_from_playlist(state: &mut AppState, player: &mut player::Player,
         }
     } else {
         if let Some(ref path) = state.current_file {
+            *skip_position_update = true; // Skip position update after track change
             player.play(path)?;
             // Explicitly resume playback in case MPV was paused
             player.resume()?;
-            player.update_metadata();
+            // Metadata will be fetched by periodic update
             tracing::info!("Playing from playlist: {:?}", path);
         }
     }
     Ok(())
 }
 
-fn handle_context_menu_action(menu_type: state::ContextMenuType, selected: usize, state: &mut AppState, player: &mut player::Player) -> Result<()> {
+fn handle_context_menu_action(menu_type: state::ContextMenuType, selected: usize, state: &mut AppState, player: &mut player::Player, skip_position_update: &mut bool) -> Result<()> {
     match menu_type {
         state::ContextMenuType::FilePanel => {
             match selected {
-                0 => action_play_selection(state, player)?,
+                0 => action_play_selection(state, player, skip_position_update)?,
                 1 => state.add_to_playlist(),
                 _ => {}
             }
@@ -431,9 +437,9 @@ fn run_app<B: ratatui::backend::Backend>(
     player: &mut player::Player,
     api_rx: std::sync::mpsc::Receiver<api::ApiCommand>,
 ) -> Result<()> {
-    let mut metadata_update_counter = 0u32;
     let mut last_position = 0.0f64;
     let mut needs_redraw = true;
+    let mut skip_position_update = false;
     let mut title_bar_area = ratatui::layout::Rect::default();
     let mut file_panel_area = ratatui::layout::Rect::default();
     let mut playlist_area = ratatui::layout::Rect::default();
@@ -470,11 +476,11 @@ fn run_app<B: ratatui::backend::Backend>(
                     state_changed = true;
                 }
                 api::ApiCommand::Next => {
-                    action_navigate_track(state, player, 1)?;
+                    action_navigate_track(state, player, 1, &mut skip_position_update)?;
                     state_changed = true;
                 }
                 api::ApiCommand::Prev => {
-                    action_navigate_track(state, player, -1)?;
+                    action_navigate_track(state, player, -1, &mut skip_position_update)?;
                     state_changed = true;
                 }
                 api::ApiCommand::VolumeUp => {
@@ -521,8 +527,8 @@ fn run_app<B: ratatui::backend::Backend>(
             }
         }
 
-        // Always update properties to keep state synchronized with MPV
+        // Always update all properties in one batch to keep state synchronized with MPV
-        player.update_properties();
+        player.update_all_properties();
 
         // Only proceed if we can successfully query player state
         let Some(player_state) = player.get_player_state() else {
@@ -531,12 +537,12 @@ fn run_app<B: ratatui::backend::Backend>(
                 match event::read()? {
                     Event::Key(key) => {
                         if key.kind == KeyEventKind::Press {
-                            handle_key_event(terminal, state, player, key)?;
+                            handle_key_event(terminal, state, player, key, &mut skip_position_update)?;
                             needs_redraw = true;
                         }
                     }
                     Event::Mouse(mouse) => {
-                        handle_mouse_event(state, mouse, title_bar_area, file_panel_area, playlist_area, player)?;
+                        handle_mouse_event(state, mouse, title_bar_area, file_panel_area, playlist_area, player, &mut skip_position_update)?;
                         needs_redraw = true;
                     }
                     _ => {}
@@ -559,13 +565,11 @@ fn run_app<B: ratatui::backend::Backend>(
                     state.current_position = 0.0;
                     state.current_duration = 0.0;
                     last_position = 0.0;
+                    skip_position_update = true; // Skip position update this iteration
 
                     player.play(path)?;
                     player.resume()?;
                 }
-                // Update metadata immediately when track changes
-                player.update_metadata();
-                metadata_update_counter = 0;
                 // Auto-scroll playlist to show current track (only if user is not browsing playlist)
                 if !state.focus_playlist {
                     let playlist_visible_height = playlist_area.height.saturating_sub(2) as usize;
@@ -578,32 +582,29 @@ fn run_app<B: ratatui::backend::Backend>(
             state_changed = true;
         }
 
-        // Only update metadata and track playback when not stopped
+        // Only update playback position when not stopped
         if player_state != PlayerState::Stopped {
-            // Update metadata periodically to reduce IPC calls
-            metadata_update_counter += 1;
-            if metadata_update_counter >= METADATA_UPDATE_INTERVAL {
-                player.update_metadata();
-                metadata_update_counter = 0;
-                state_changed = true;
-            }
-
             // Update position and duration from player
-            let new_position = player.get_position().unwrap_or(0.0);
+            // Skip this iteration if we just started a new track to avoid stale MPV values
-            let new_duration = player.get_duration().unwrap_or(0.0);
+            if skip_position_update {
+                skip_position_update = false;
+            } else {
+                let new_position = player.get_position().unwrap_or(0.0);
+                let new_duration = player.get_duration().unwrap_or(0.0);
 
-            // Only update if displayed value (rounded to seconds) changed
+                // Only update if displayed value (rounded to seconds) changed
-            let old_display_secs = last_position as u32;
+                let old_display_secs = last_position as u32;
-            let new_display_secs = new_position as u32;
+                let new_display_secs = new_position as u32;
-            if new_display_secs != old_display_secs {
+                if new_display_secs != old_display_secs {
-                state.current_position = new_position;
+                    state.current_position = new_position;
-                last_position = new_position;
+                    last_position = new_position;
-                state_changed = true;
+                    state_changed = true;
-            }
+                }
 
-            if state.current_duration != new_duration {
+                if state.current_duration != new_duration {
-                state.current_duration = new_duration;
+                    state.current_duration = new_duration;
-                state_changed = true;
+                    state_changed = true;
+                }
             }
         }
 
@@ -632,12 +633,12 @@ fn run_app<B: ratatui::backend::Backend>(
             match event::read()? {
                 Event::Key(key) => {
                     if key.kind == KeyEventKind::Press {
-                        handle_key_event(terminal, state, player, key)?;
+                        handle_key_event(terminal, state, player, key, &mut skip_position_update)?;
                         needs_redraw = true; // Force redraw after key event
                     }
                 }
                 Event::Mouse(mouse) => {
-                    handle_mouse_event(state, mouse, title_bar_area, file_panel_area, playlist_area, player)?;
+                    handle_mouse_event(state, mouse, title_bar_area, file_panel_area, playlist_area, player, &mut skip_position_update)?;
                     needs_redraw = true; // Force redraw after mouse event
                 }
                 _ => {}
@@ -652,7 +653,7 @@ fn run_app<B: ratatui::backend::Backend>(
     Ok(())
 }
 
-fn handle_key_event<B: ratatui::backend::Backend>(terminal: &mut Terminal<B>, state: &mut AppState, player: &mut player::Player, key: KeyEvent) -> Result<()> {
+fn handle_key_event<B: ratatui::backend::Backend>(terminal: &mut Terminal<B>, state: &mut AppState, player: &mut player::Player, key: KeyEvent, skip_position_update: &mut bool) -> Result<()> {
     // Handle confirmation popup
     if state.show_refresh_confirm {
         match key.code {
@@ -660,14 +661,29 @@ fn handle_key_event<B: ratatui::backend::Backend>(terminal: &mut Terminal<B>, st
                 state.show_refresh_confirm = false;
                 state.is_refreshing = true;
                 terminal.draw(|f| { let _ = ui::render(f, state, player); })?;  // Show "Refreshing library..." immediately
-                tracing::info!("Rescanning...");
+
                 let cache_dir = cache::get_cache_dir()?;
+
+                // Delete old cache files to ensure fresh scan
+                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)?;
                 new_cache.save(&cache_dir)?;
+
+                // Replace old cache completely
                 state.cache = new_cache;
-                state.refresh_flattened_items();
+                state.refresh_flattened_items(); // This also cleans up playlist and expanded_dirs
+
+                // If current file was removed, stop playback
+                if state.current_file.is_none() {
+                    player.stop()?;
+                    state.current_position = 0.0;
+                    state.current_duration = 0.0;
+                }
+
                 state.is_refreshing = false;
-                tracing::info!("Rescan complete");
             }
             KeyCode::Char('n') | KeyCode::Char('N') | KeyCode::Esc => {
                 state.show_refresh_confirm = false;
@@ -747,7 +763,7 @@ fn handle_key_event<B: ratatui::backend::Backend>(terminal: &mut Terminal<B>, st
                 let menu_type = menu.menu_type;
                 let selected = menu.selected_index;
                 state.context_menu = None;
-                handle_context_menu_action(menu_type, selected, state, player)?;
+                handle_context_menu_action(menu_type, selected, state, player, skip_position_update)?;
             }
             KeyCode::Esc => {
                 state.context_menu = None;
@@ -798,11 +814,11 @@ fn handle_key_event<B: ratatui::backend::Backend>(terminal: &mut Terminal<B>, st
         }
         (KeyCode::Char('J'), KeyModifiers::SHIFT) => {
             // Next track
-            action_navigate_track(state, player, 1)?;
+            action_navigate_track(state, player, 1, skip_position_update)?;
         }
         (KeyCode::Char('K'), KeyModifiers::SHIFT) => {
             // Previous track
-            action_navigate_track(state, player, -1)?;
+            action_navigate_track(state, player, -1, skip_position_update)?;
         }
         (KeyCode::Char('d'), KeyModifiers::CONTROL) => {
             if state.focus_playlist {
@@ -871,10 +887,10 @@ fn handle_key_event<B: ratatui::backend::Backend>(terminal: &mut Terminal<B>, st
         (KeyCode::Enter, _) => {
             if state.focus_playlist {
                 if state.selected_playlist_index < state.playlist.len() {
-                    action_play_from_playlist(state, player, false)?;
+                    action_play_from_playlist(state, player, false, skip_position_update)?;
                 }
             } else {
-                action_play_selection(state, player)?;
+                action_play_selection(state, player, skip_position_update)?;
             }
         }
         (KeyCode::Char('s'), _) => {
@@ -924,7 +940,7 @@ fn handle_key_event<B: ratatui::backend::Backend>(terminal: &mut Terminal<B>, st
     Ok(())
 }
 
-fn handle_mouse_event(state: &mut AppState, mouse: MouseEvent, title_bar_area: ratatui::layout::Rect, file_panel_area: ratatui::layout::Rect, playlist_area: ratatui::layout::Rect, player: &mut player::Player) -> Result<()> {
+fn handle_mouse_event(state: &mut AppState, mouse: MouseEvent, title_bar_area: ratatui::layout::Rect, file_panel_area: ratatui::layout::Rect, playlist_area: ratatui::layout::Rect, player: &mut player::Player, skip_position_update: &mut bool) -> Result<()> {
     use crossterm::event::MouseButton;
     use crate::state::ContextMenuType;
 
@@ -993,7 +1009,7 @@ fn handle_mouse_event(state: &mut AppState, mouse: MouseEvent, title_bar_area: r
                     let menu_type = menu.menu_type;
                     let selected = relative_y;
                     state.context_menu = None;
-                    handle_context_menu_action(menu_type, selected, state, player)?;
+                    handle_context_menu_action(menu_type, selected, state, player, skip_position_update)?;
                 }
                 return Ok(());
             } else {
@@ -1083,15 +1099,55 @@ fn handle_mouse_event(state: &mut AppState, mouse: MouseEvent, title_bar_area: r
                     _ => {}
                 }
             }
+            // Check if click is on the panel title border (to switch focus)
+            // The visible area is whichever one is not Rect::default()
+            else if (file_panel_area.width > 0 && y == file_panel_area.y) ||
+                    (playlist_area.width > 0 && y == playlist_area.y) {
+                // Click is on the top border line where "Files | Playlist" is shown
+                // Get the actual visible area (not the default one)
+                let area = if file_panel_area.width > 0 { file_panel_area } else { playlist_area };
+
+                // Build title text to calculate positions
+                let playlist_text = if !state.playlist.is_empty() {
+                    format!("Playlist [{}/{}]", state.playlist_index + 1, state.playlist.len())
+                } else {
+                    "Playlist (empty)".to_string()
+                };
+
+                // Title is left-aligned by default in ratatui, starts after left border
+                // Border character takes 1 position, then title starts
+                let title_start_x = area.x + 1;
+
+                // Calculate where "Files" and "Playlist" text are
+                let files_start = title_start_x;
+                let files_end = files_start + 5; // "Files" is 5 chars
+                let separator_start = files_end;
+                let separator_end = separator_start + 3; // " | " is 3 chars
+                let playlist_start = separator_end;
+                let playlist_end = playlist_start + playlist_text.len() as u16;
+
+                match button {
+                    MouseButton::Left => {
+                        if x >= files_start && x < files_end {
+                            // Clicked on "Files" - switch to file panel
+                            state.focus_playlist = false;
+                        } else if x >= playlist_start && x < playlist_end {
+                            // Clicked on "Playlist" - switch to playlist
+                            state.focus_playlist = true;
+                        }
+                    }
+                    _ => {}
+                }
+            }
             // Check if click is within file panel area
             else if x >= file_panel_area.x
                 && x < file_panel_area.x + file_panel_area.width
                 && y >= file_panel_area.y
                 && y < file_panel_area.y + file_panel_area.height
             {
-                // Calculate which item was clicked (accounting for borders and scroll offset)
+                // Calculate which item was clicked (accounting for scroll offset and outer border)
-                // Border takes 1 line at top, so subtract 1 from y position
+                // Outer border takes 1 line at top, content starts at file_panel_area.y + 1
-                let relative_y = (y - file_panel_area.y).saturating_sub(1);
+                let relative_y = y.saturating_sub(file_panel_area.y + 1);
                 let clicked_index = state.scroll_offset + relative_y as usize;
 
                 // Set selection to clicked item if valid
@@ -1117,7 +1173,7 @@ fn handle_mouse_event(state: &mut AppState, mouse: MouseEvent, title_bar_area: r
                                     if item.is_dir {
                                         action_toggle_folder(state);
                                     } else {
-                                        action_play_selection(state, player)?;
+                                        action_play_selection(state, player, skip_position_update)?;
                                     }
                                 }
                                 // Reset click tracking after action
@@ -1150,8 +1206,9 @@ fn handle_mouse_event(state: &mut AppState, mouse: MouseEvent, title_bar_area: r
                 && y >= playlist_area.y
                 && y < playlist_area.y + playlist_area.height
             {
-                // Calculate which track was clicked (accounting for borders)
+                // Calculate which track was clicked (accounting for outer border)
-                let relative_y = (y - playlist_area.y).saturating_sub(1);
+                // Outer border takes 1 line at top, content starts at playlist_area.y + 1
+                let relative_y = y.saturating_sub(playlist_area.y + 1);
                 let clicked_track = relative_y as usize;
 
                 // Add scroll offset to get actual index
@@ -1175,7 +1232,7 @@ fn handle_mouse_event(state: &mut AppState, mouse: MouseEvent, title_bar_area: r
                             if is_double_click {
                                 // Double click = play the track (preserve pause state)
                                 state.selected_playlist_index = actual_track;
-                                action_play_from_playlist(state, player, true)?;
+                                action_play_from_playlist(state, player, true, skip_position_update)?;
                                 // Reset click tracking after action
                                 state.last_click_time = None;
                                 state.last_click_index = None;

src/player/mod.rs

@@ -119,88 +119,82 @@ impl Player {
         Ok(())
     }
 
-    fn get_property(&mut self, property: &str) -> Option<Value> {
+    fn get_properties_batch(&mut self, properties: &[&str]) -> std::collections::HashMap<String, Value> {
-        // Try to connect - if respawning or connection fails, return None
+        let mut results = std::collections::HashMap::new();
-        if let Err(e) = self.connect() {
+
-            tracing::debug!("Failed to connect for property '{}': {}", property, e);
+        // Try to connect
-            return None;
+        if self.connect().is_err() {
+            return results;
         }
 
-        let cmd = json!({
-            "command": ["get_property", property],
-            "request_id": 1
-        });
-
         if let Some(ref mut socket) = self.socket {
-            let msg = format!("{}\n", cmd);
+            // Send all property requests at once with unique request_ids
-
+            for (idx, property) in properties.iter().enumerate() {
-            // Write command
+                let cmd = json!({
-            if let Err(e) = socket.write_all(msg.as_bytes()) {
+                    "command": ["get_property", property],
-                tracing::warn!("Failed to write get_property command for '{}': {}", property, e);
+                    "request_id": idx + 1
-                self.socket = None;
+                });
-                return None;
+                let msg = format!("{}\n", cmd);
+                if socket.write_all(msg.as_bytes()).is_err() {
+                    return results;
+                }
             }
 
-            // Try to read response with timeout
+            // Read all responses
+            // IMPORTANT: Socket is non-blocking, need to set blocking mode for read
             socket.set_nonblocking(false).ok();
-            socket.set_read_timeout(Some(Duration::from_millis(100))).ok();
 
             let cloned_socket = match socket.try_clone() {
                 Ok(s) => s,
-                Err(e) => {
+                Err(_) => {
-                    tracing::warn!("Failed to clone socket for '{}': {}", property, e);
                     socket.set_nonblocking(true).ok();
-                    return None;
+                    return results;
                 }
             };
 
-            // Set timeout on cloned socket too (clone doesn't copy settings)
             cloned_socket.set_nonblocking(false).ok();
-            cloned_socket.set_read_timeout(Some(Duration::from_millis(100))).ok();
 
             let mut reader = BufReader::new(cloned_socket);
-            let mut response = String::new();
+
-            if let Err(e) = reader.read_line(&mut response) {
+            // Read responses - stop if we timeout or hit an error
-                tracing::debug!("Failed to read response for '{}': {}", property, e);
+            for _ in 0..properties.len() {
-                socket.set_nonblocking(true).ok();
+                let mut response = String::new();
-                return None;
+                if reader.read_line(&mut response).is_err() {
+                    // Timeout or error - stop reading
+                    break;
+                }
+
+                // Parse response
+                if let Ok(parsed) = serde_json::from_str::<Value>(&response) {
+                    // Check for success
+                    if let Some(error) = parsed.get("error").and_then(|e| e.as_str()) {
+                        if error == "success" {
+                            // Get request_id to match with property
+                            if let Some(req_id) = parsed.get("request_id").and_then(|id| id.as_i64()) {
+                                let idx = (req_id - 1) as usize;
+                                if idx < properties.len() {
+                                    if let Some(data) = parsed.get("data") {
+                                        results.insert(properties[idx].to_string(), data.clone());
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
             }
 
+            // Restore non-blocking mode
             socket.set_nonblocking(true).ok();
-
-            // Parse and validate response
-            let parsed: Value = match serde_json::from_str(&response) {
-                Ok(v) => v,
-                Err(e) => {
-                    tracing::warn!("Failed to parse JSON response for '{}': {} (response: {})", property, e, response.trim());
-                    return None;
-                }
-            };
-
-            // Check for errors in response
-            // MPV returns {"error": "success"} when there's NO error
-            if let Some(error) = parsed.get("error").and_then(|e| e.as_str()) {
-                if error != "success" {
-                    tracing::debug!("MPV returned error for '{}': {}", property, error);
-                    return None;
-                }
-            }
-
-            // Validate request_id matches (should be 1)
-            if let Some(req_id) = parsed.get("request_id").and_then(|id| id.as_i64()) {
-                if req_id != 1 {
-                    tracing::warn!("Request ID mismatch for '{}': expected 1, got {}", property, req_id);
-                }
-            }
-
-            return parsed.get("data").cloned();
         }
 
-        None
+        results
     }
 
     pub fn play(&mut self, path: &Path) -> Result<()> {
         let path_str = path.to_string_lossy();
+        // Reset position/duration before loading new file to avoid showing stale values
+        self.position = 0.0;
+        self.duration = 0.0;
         self.send_command("loadfile", &[json!(path_str), json!("replace")])?;
         tracing::info!("Playing: {}", path_str);
         Ok(())
@@ -208,6 +202,9 @@ impl Player {
 
     pub fn play_paused(&mut self, path: &Path) -> Result<()> {
         let path_str = path.to_string_lossy();
+        // Reset position/duration before loading new file to avoid showing stale values
+        self.position = 0.0;
+        self.duration = 0.0;
         // Load file but start paused - avoids audio blip when jumping tracks while paused
         self.send_command("loadfile", &[json!(path_str), json!("replace"), json!({"pause": true})])?;
         tracing::info!("Playing (paused): {}", path_str);
@@ -236,84 +233,73 @@ impl Player {
         Ok(())
     }
 
-    pub fn update_properties(&mut self) {
+    pub fn update_all_properties(&mut self) {
-        // Update position
+        // Fetch ALL properties in one batch
-        if let Some(val) = self.get_property("time-pos") {
+        let results = self.get_properties_batch(&[
+            "time-pos",
+            "duration",
+            "metadata/by-key/artist",
+            "metadata/by-key/ARTIST",
+            "metadata/by-key/album",
+            "metadata/by-key/ALBUM",
+            "metadata/by-key/title",
+            "metadata/by-key/TITLE",
+            "media-title",
+            "audio-codec-name",
+            "audio-bitrate",
+            "audio-params/samplerate",
+            "demuxer-cache-duration",
+        ]);
+
+        // Position
+        if let Some(val) = results.get("time-pos") {
             if let Some(pos) = val.as_f64() {
                 self.position = pos;
             }
         }
 
-        // Update duration
+        // Duration
-        if let Some(val) = self.get_property("duration") {
+        if let Some(val) = results.get("duration") {
             if let Some(dur) = val.as_f64() {
                 self.duration = dur;
             }
         }
-    }
 
-    pub fn update_metadata(&mut self) {
+        // Artist - try lowercase first, then uppercase
-        // Try to get artist directly
+        self.artist = results.get("metadata/by-key/artist")
-        if let Some(val) = self.get_property("metadata/by-key/artist") {
+            .and_then(|v| v.as_str().map(|s| s.to_string()))
-            self.artist = val.as_str().map(|s| s.to_string());
+            .or_else(|| results.get("metadata/by-key/ARTIST")
-        }
+                .and_then(|v| v.as_str().map(|s| s.to_string())));
-        // Fallback to ARTIST (uppercase)
-        if self.artist.is_none() {
-            if let Some(val) = self.get_property("metadata/by-key/ARTIST") {
-                self.artist = val.as_str().map(|s| s.to_string());
-            }
-        }
 
-        // Try to get album directly
+        // Album - try lowercase first, then uppercase
-        if let Some(val) = self.get_property("metadata/by-key/album") {
+        self.album = results.get("metadata/by-key/album")
-            self.album = val.as_str().map(|s| s.to_string());
+            .and_then(|v| v.as_str().map(|s| s.to_string()))
-        }
+            .or_else(|| results.get("metadata/by-key/ALBUM")
-        // Fallback to ALBUM (uppercase)
+                .and_then(|v| v.as_str().map(|s| s.to_string())));
-        if self.album.is_none() {
-            if let Some(val) = self.get_property("metadata/by-key/ALBUM") {
-                self.album = val.as_str().map(|s| s.to_string());
-            }
-        }
 
-        // Try to get title directly
+        // Title - try lowercase, then uppercase, then media-title
-        if let Some(val) = self.get_property("metadata/by-key/title") {
+        self.media_title = results.get("metadata/by-key/title")
-            self.media_title = val.as_str().map(|s| s.to_string());
+            .and_then(|v| v.as_str().map(|s| s.to_string()))
-        }
+            .or_else(|| results.get("metadata/by-key/TITLE")
-        // Fallback to TITLE (uppercase)
+                .and_then(|v| v.as_str().map(|s| s.to_string())))
-        if self.media_title.is_none() {
+            .or_else(|| results.get("media-title")
-            if let Some(val) = self.get_property("metadata/by-key/TITLE") {
+                .and_then(|v| v.as_str().map(|s| s.to_string())));
-                self.media_title = val.as_str().map(|s| s.to_string());
-            }
-        }
 
-        // Final fallback to media-title if metadata doesn't have title
+        // Audio codec
-        if self.media_title.is_none() {
+        self.audio_codec = results.get("audio-codec-name")
-            if let Some(val) = self.get_property("media-title") {
+            .and_then(|v| v.as_str().map(|s| s.to_string()));
-                self.media_title = val.as_str().map(|s| s.to_string());
-            }
-        }
 
-        // Update audio codec
+        // Audio bitrate (convert from bps to kbps)
-        if let Some(val) = self.get_property("audio-codec-name") {
+        self.audio_bitrate = results.get("audio-bitrate")
-            self.audio_codec = val.as_str().map(|s| s.to_string());
+            .and_then(|v| v.as_f64().map(|b| b / 1000.0));
-        }
 
-        // Update audio bitrate (convert from bps to kbps)
+        // Sample rate
-        if let Some(val) = self.get_property("audio-bitrate") {
+        self.sample_rate = results.get("audio-params/samplerate")
-            self.audio_bitrate = val.as_f64().map(|b| b / 1000.0);
+            .and_then(|v| v.as_i64());
-        }
 
-        // Update sample rate
+        // Cache duration
-        if let Some(val) = self.get_property("audio-params/samplerate") {
+        self.cache_duration = results.get("demuxer-cache-duration")
-            self.sample_rate = val.as_i64();
+            .and_then(|v| v.as_f64());
-        }
-
-        // Update cache duration (how many seconds are buffered ahead)
-        if let Some(val) = self.get_property("demuxer-cache-duration") {
-            self.cache_duration = val.as_f64();
-        } else {
-            self.cache_duration = None;
-        }
     }
 
     pub fn get_position(&self) -> Option<f64> {
@@ -324,20 +310,14 @@ impl Player {
         Some(self.duration)
     }
 
-    pub fn is_idle(&mut self) -> Option<bool> {
-        self.get_property("idle-active")
-            .and_then(|v| v.as_bool())
-    }
-
-    pub fn is_paused(&mut self) -> Option<bool> {
-        self.get_property("pause")
-            .and_then(|v| v.as_bool())
-    }
-
     pub fn get_player_state(&mut self) -> Option<crate::state::PlayerState> {
         use crate::state::PlayerState;
-        let is_idle = self.is_idle()?;
+
-        let is_paused = self.is_paused()?;
+        // Batch fetch both properties at once
+        let results = self.get_properties_batch(&["idle-active", "pause"]);
+
+        let is_idle = results.get("idle-active").and_then(|v| v.as_bool())?;
+        let is_paused = results.get("pause").and_then(|v| v.as_bool())?;
 
         Some(if is_idle {
             PlayerState::Stopped

src/scanner/mod.rs

@@ -63,7 +63,10 @@ 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) {
-                node.children.push(child_node);
+                // 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) {
             // Add media file

src/state/mod.rs

@@ -587,8 +587,84 @@ impl AppState {
     }
 
     pub fn refresh_flattened_items(&mut self) {
-        // Keep current expanded state after rescan
+        // Clean up expanded_dirs - remove paths that no longer exist in new cache
+        self.cleanup_expanded_dirs();
+
+        // Rebuild view with cleaned expanded state
         self.rebuild_flattened_items();
+
+        // Clean up playlist - remove files that no longer exist in cache
+        self.cleanup_playlist();
+    }
+
+    fn cleanup_expanded_dirs(&mut self) {
+        // Build a set of valid directory paths from the cache
+        let mut valid_dirs = std::collections::HashSet::new();
+        fn collect_dirs(node: &crate::cache::FileTreeNode, dirs: &mut std::collections::HashSet<std::path::PathBuf>) {
+            if node.is_dir {
+                dirs.insert(node.path.clone());
+            }
+            for child in &node.children {
+                collect_dirs(child, dirs);
+            }
+        }
+        for root in &self.cache.file_tree {
+            collect_dirs(root, &mut valid_dirs);
+        }
+
+        // Remove invalid paths from expanded_dirs
+        let original_len = self.expanded_dirs.len();
+        self.expanded_dirs.retain(|path| valid_dirs.contains(path));
+
+        if self.expanded_dirs.len() < original_len {
+            tracing::info!("Cleaned up expanded_dirs: removed {} invalid paths", original_len - self.expanded_dirs.len());
+        }
+    }
+
+    fn cleanup_playlist(&mut self) {
+        // Build a set of valid paths from the cache for fast lookup
+        let mut valid_paths = std::collections::HashSet::new();
+        fn collect_paths(node: &crate::cache::FileTreeNode, paths: &mut std::collections::HashSet<std::path::PathBuf>) {
+            if !node.is_dir {
+                paths.insert(node.path.clone());
+            }
+            for child in &node.children {
+                collect_paths(child, paths);
+            }
+        }
+        for root in &self.cache.file_tree {
+            collect_paths(root, &mut valid_paths);
+        }
+
+        // Check if current file is invalid
+        let current_file_invalid = if let Some(ref current) = self.current_file {
+            !valid_paths.contains(current)
+        } else {
+            false
+        };
+
+        if current_file_invalid {
+            self.current_file = None;
+            tracing::info!("Current playing file was deleted, cleared current_file");
+        }
+
+        // Remove files from playlist that don't exist in cache
+        let original_len = self.playlist.len();
+        self.playlist.retain(|path| valid_paths.contains(path));
+
+        // Adjust indices if playlist was modified
+        if self.playlist.len() < original_len {
+            // Ensure playlist_index is valid
+            if self.playlist_index >= self.playlist.len() && !self.playlist.is_empty() {
+                self.playlist_index = self.playlist.len() - 1;
+            }
+            // Ensure selected_playlist_index is valid
+            if self.selected_playlist_index >= self.playlist.len() && !self.playlist.is_empty() {
+                self.selected_playlist_index = self.playlist.len() - 1;
+            }
+
+            tracing::info!("Cleaned up playlist: removed {} deleted files", original_len - self.playlist.len());
+        }
     }
 
     pub fn rebuild_flattened_items(&mut self) {

src/ui/mod.rs

@@ -28,17 +28,60 @@ pub fn render(frame: &mut Frame, state: &mut AppState, player: &mut Player) -> (
         ])
         .split(frame.area());
 
-    // Main content: left (files) | right (status + playlist)
+    // Always use tab mode - show only the focused panel
-    let content_chunks = Layout::default()
+    let tab_mode = true;
-        .direction(Direction::Horizontal)
+
-        .constraints([Constraint::Percentage(50), Constraint::Percentage(50)])
+    // Build the title with focused panel in bold
-        .split(main_chunks[1]);
+    let file_style = if !state.focus_playlist {
+        Style::default().fg(Theme::bright_foreground()).add_modifier(Modifier::BOLD)
+    } else {
+        Style::default().fg(Theme::bright_foreground())
+    };
+
+    let playlist_style = if state.focus_playlist {
+        Style::default().fg(Theme::bright_foreground()).add_modifier(Modifier::BOLD)
+    } else {
+        Style::default().fg(Theme::bright_foreground())
+    };
+
+    // Add playlist counter
+    let playlist_text = if !state.playlist.is_empty() {
+        format!("Playlist [{}/{}]", state.playlist_index + 1, state.playlist.len())
+    } else {
+        "Playlist (empty)".to_string()
+    };
+
+    let title = Line::from(vec![
+        Span::styled("Files", file_style),
+        Span::raw(" | "),
+        Span::styled(playlist_text, playlist_style),
+    ]);
+
+    // Create one border around the entire content area
+    let main_block = Block::default()
+        .borders(Borders::ALL)
+        .title(title)
+        .style(Theme::widget_border_style());
+
+    let inner_area = main_block.inner(main_chunks[1]);
 
     render_title_bar(frame, state, player, main_chunks[0]);
-    render_file_panel(frame, state, content_chunks[0]);
+    frame.render_widget(main_block, main_chunks[1]);
-    render_right_panel(frame, state, content_chunks[1]);
+
+    // Tab mode - show only focused panel
+    if state.focus_playlist {
+        render_right_panel(frame, state, inner_area, tab_mode);
+    } else {
+        render_file_panel(frame, state, inner_area, tab_mode);
+    }
+
     render_status_bar(frame, state, player, main_chunks[2]);
 
+    // Show refreshing popup if scanning
+    if state.is_refreshing {
+        render_info_popup(frame, "Refreshing library...");
+    }
+
     // Show confirmation popup if needed
     if state.show_refresh_confirm {
         render_confirm_popup(frame, "Refresh library?", "This may take a while");
@@ -50,7 +93,12 @@ pub fn render(frame: &mut Frame, state: &mut AppState, player: &mut Player) -> (
     }
 
     // Return title bar area, file panel area, and playlist area for mouse event handling
-    (main_chunks[0], content_chunks[0], content_chunks[1])
+    // Use main_chunks[1] (full area) so mouse coordinates align properly
+    if state.focus_playlist {
+        (main_chunks[0], Rect::default(), main_chunks[1])
+    } else {
+        (main_chunks[0], main_chunks[1], Rect::default())
+    }
 }
 
 fn highlight_search_matches<'a>(text: &str, query: &str, is_selected: bool) -> Vec<Span<'a>> {
@@ -108,9 +156,9 @@ fn highlight_search_matches<'a>(text: &str, query: &str, is_selected: bool) -> V
     spans
 }
 
-fn render_file_panel(frame: &mut Frame, state: &mut AppState, area: Rect) {
+fn render_file_panel(frame: &mut Frame, state: &mut AppState, area: Rect, _tab_mode: bool) {
-    // Calculate visible height (subtract 2 for borders)
+    // Calculate visible height (no borders on individual panels now)
-    let visible_height = area.height.saturating_sub(2) as usize;
+    let visible_height = area.height as usize;
     // Store visible height for keyboard navigation scroll calculations
     state.file_panel_visible_height = visible_height;
 
@@ -226,14 +274,7 @@ fn render_file_panel(frame: &mut Frame, state: &mut AppState, area: Rect) {
         items.push(more_item);
     }
 
-    let list = List::new(items)
+    let list = List::new(items);
-        .block(
-            Block::default()
-                .borders(Borders::ALL)
-                .title("files")
-                .style(Theme::widget_border_style())
-                .title_style(Theme::title_style()),
-        );
 
     let mut list_state = ListState::default();
     // Don't set selection to avoid automatic scrolling - we manage scroll manually
@@ -242,9 +283,9 @@ fn render_file_panel(frame: &mut Frame, state: &mut AppState, area: Rect) {
     frame.render_stateful_widget(list, area, &mut list_state);
 }
 
-fn render_right_panel(frame: &mut Frame, state: &mut AppState, area: Rect) {
+fn render_right_panel(frame: &mut Frame, state: &mut AppState, area: Rect, _tab_mode: bool) {
-    // Calculate visible height (subtract 2 for borders)
+    // Calculate visible height (no borders on individual panels now)
-    let visible_height = area.height.saturating_sub(2) as usize;
+    let visible_height = area.height as usize;
     // Store visible height for keyboard navigation scroll calculations
     state.playlist_visible_height = visible_height;
 
@@ -285,12 +326,17 @@ fn render_right_panel(frame: &mut Frame, state: &mut AppState, area: Rect) {
             let is_selected = state.focus_playlist && idx == state.selected_playlist_index;
             let is_playing = idx == state.playlist_index;
 
+            // Add playing indicator arrow
+            let indicator = if is_playing { "▸ " } else { "  " };
+
             // Build line with search highlighting if searching
-            let line = if in_playlist_search && !playlist_search_query.is_empty() {
+            let mut line_spans = vec![Span::raw(indicator)];
-                Line::from(highlight_search_matches(&filename, &playlist_search_query, is_selected))
+            if in_playlist_search && !playlist_search_query.is_empty() {
+                line_spans.extend(highlight_search_matches(&filename, &playlist_search_query, is_selected));
             } else {
-                Line::from(filename)
+                line_spans.push(Span::raw(filename));
-            };
+            }
+            let line = Line::from(line_spans);
 
             let style = if is_selected && is_playing {
                 // Both selected and playing: selection bar with bold
@@ -328,20 +374,7 @@ fn render_right_panel(frame: &mut Frame, state: &mut AppState, area: Rect) {
         playlist_items.push(more_item);
     }
 
-    let playlist_title = if !state.playlist.is_empty() {
+    let playlist_widget = List::new(playlist_items);
-        format!("playlist [{}/{}]", state.playlist_index + 1, state.playlist.len())
-    } else {
-        "playlist (empty)".to_string()
-    };
-
-    let playlist_widget = List::new(playlist_items)
-        .block(
-            Block::default()
-                .borders(Borders::ALL)
-                .title(playlist_title)
-                .style(Theme::widget_border_style())
-                .title_style(Theme::title_style()),
-        );
 
     let mut playlist_state = ListState::default();
     // Don't set selection to avoid automatic scrolling - we manage scroll manually
@@ -381,16 +414,7 @@ fn render_title_bar(frame: &mut Frame, state: &AppState, player: &mut Player, ar
     // Right side: Status • Progress • Volume • Search (if active)
     let mut right_spans = Vec::new();
 
-    if state.is_refreshing {
+    {
-        // Show only "Refreshing library..." when refreshing
-        right_spans.push(Span::styled(
-            "Refreshing library... ",
-            Style::default()
-                .fg(Theme::background())
-                .bg(background_color)
-                .add_modifier(Modifier::BOLD)
-        ));
-    } else {
         // Status (bold when playing)
         let status_text = match player_state {
             PlayerState::Stopped => "Stopped",
@@ -462,9 +486,21 @@ fn render_title_bar(frame: &mut Frame, state: &AppState, player: &mut Player, ar
 }
 
 fn render_status_bar(frame: &mut Frame, state: &AppState, player: &mut Player, area: Rect) {
-    if state.search_mode {
+    // Calculate progress percentage for progress bar
+    let progress_percent = if state.current_duration > 0.0 {
+        (state.current_position / state.current_duration).clamp(0.0, 1.0)
+    } else {
+        0.0
+    };
+
+    // If playing and has duration, show progress bar with overlaid text
+    let player_state = player.get_player_state().unwrap_or(PlayerState::Stopped);
+    let show_progress_bar = player_state != PlayerState::Stopped && state.current_duration > 0.0;
+
+    // Determine text content based on mode
+    let status_text = if state.search_mode {
         // Show search prompt with current query and match count - LEFT aligned
-        let search_text = if state.focus_playlist {
+        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())
@@ -482,28 +518,28 @@ fn render_status_bar(frame: &mut Frame, state: &AppState, player: &mut Player, a
             } else {
                 format!("/{}_", state.search_query)
             }
-        };
+        }
-        let status_bar = Paragraph::new(search_text)
-            .style(Style::default().fg(Color::White).bg(Theme::background()));
-        frame.render_widget(status_bar, area);
     } else if !state.search_matches.is_empty() {
         // Show search navigation when file search results are active
-        let search_text = format!("/{}  Search: {}/{}", state.search_query, state.search_match_index + 1, state.search_matches.len());
+        format!("/{}  Search: {}/{}", state.search_query, state.search_match_index + 1, state.search_matches.len())
-        let status_bar = Paragraph::new(search_text)
-            .style(Style::default().fg(Color::White).bg(Theme::background()));
-        frame.render_widget(status_bar, area);
     } else if !state.playlist_search_matches.is_empty() {
         // Show search navigation when playlist search results are active
-        let search_text = format!("/{}  Playlist Search: {}/{}", state.search_query, state.playlist_search_match_index + 1, state.playlist_search_matches.len());
+        format!("/{}  Playlist Search: {}/{}", state.search_query, state.playlist_search_match_index + 1, state.playlist_search_matches.len())
-        let status_bar = Paragraph::new(search_text)
-            .style(Style::default().fg(Color::White).bg(Theme::background()));
-        frame.render_widget(status_bar, area);
     } else if state.visual_mode {
         // Show visual mode indicator
-        let visual_text = format!("-- VISUAL -- {} files marked", state.marked_files.len());
+        format!("-- VISUAL -- {} files marked", state.marked_files.len())
-        let status_bar = Paragraph::new(visual_text)
+    } else {
-            .style(Style::default().fg(Theme::foreground()).bg(Theme::background()));
+        String::new()
+    };
+
+    // If we have status text (search/visual mode), show it without progress bar
+    if !status_text.is_empty() {
+        let status_bar = Paragraph::new(status_text)
+            .style(Style::default().fg(Color::White).bg(Theme::background()));
         frame.render_widget(status_bar, area);
+    } else if show_progress_bar {
+        // Show progress bar with metadata text overlay
+        render_progress_bar(frame, state, player, area, progress_percent);
     } else {
         // Normal mode: show media metadata if playing
         // Split into left (artist/album/title) and right (technical info)
@@ -537,12 +573,6 @@ fn render_status_bar(frame: &mut Frame, state: &AppState, player: &mut Player, a
             right_parts.push(format!("{} Hz", samplerate));
         }
 
-        if let Some(cache_dur) = player.cache_duration {
-            if cache_dur > 0.0 {
-                right_parts.push(format!("{:.1}s", cache_dur));
-            }
-        }
-
         // Create layout for left and right sections
         let chunks = Layout::default()
             .direction(Direction::Horizontal)
@@ -575,6 +605,157 @@ fn render_status_bar(frame: &mut Frame, state: &AppState, player: &mut Player, a
     }
 }
 
+fn render_progress_bar(frame: &mut Frame, _state: &AppState, player: &mut Player, area: Rect, progress_percent: f64) {
+    // Get metadata to display
+    let mut right_parts = Vec::new();
+
+    // Right side: Bitrate | Codec | Sample rate (metrics that must always be visible)
+    if let Some(bitrate) = player.audio_bitrate {
+        right_parts.push(format!("{:.0} kbps", bitrate));
+    }
+
+    if let Some(ref codec) = player.audio_codec {
+        right_parts.push(codec.to_uppercase());
+    }
+
+    if let Some(samplerate) = player.sample_rate {
+        right_parts.push(format!("{} Hz", samplerate));
+    }
+
+    // Build right text
+    let right_text = if !right_parts.is_empty() {
+        format!("{} ", right_parts.join(" | "))
+    } else {
+        String::new()
+    };
+
+    // Calculate available space
+    let total_width = area.width as usize;
+    let right_text_len = right_text.chars().count();
+
+    // Reserve space: 1 char at start, gap between left and right
+    let available_for_left = total_width.saturating_sub(right_text_len).saturating_sub(2);
+
+    // Collect left side metadata
+    let mut left_fields = Vec::new();
+    if let Some(ref artist) = player.artist {
+        left_fields.push(("artist", artist.as_str()));
+    }
+    if let Some(ref album) = player.album {
+        left_fields.push(("album", album.as_str()));
+    }
+    if let Some(ref title) = player.media_title {
+        left_fields.push(("title", title.as_str()));
+    }
+
+    // Calculate space per field (divide available space among fields)
+    let left_text = if !left_fields.is_empty() {
+        let num_fields = left_fields.len();
+        let separator_space = (num_fields - 1) * 3; // " | " between fields
+        let available_for_fields = available_for_left.saturating_sub(separator_space);
+        let max_per_field = available_for_fields / num_fields;
+
+        // Truncate each field individually
+        let truncated_fields: Vec<String> = left_fields.iter().map(|(_name, value)| {
+            if value.chars().count() > max_per_field && max_per_field > 3 {
+                let mut s: String = value.chars().take(max_per_field - 3).collect();
+                s.push_str("...");
+                s
+            } else if value.chars().count() > max_per_field {
+                // Very tight space, just cut hard
+                value.chars().take(max_per_field).collect()
+            } else {
+                value.to_string()
+            }
+        }).collect();
+
+        format!(" {}", truncated_fields.join(" | "))
+    } else {
+        String::new()
+    };
+
+    // Calculate filled width based on progress
+    let filled_width = (total_width as f64 * progress_percent) as usize;
+
+    // Build the full line character by character with proper spacing
+    let left_chars: Vec<char> = left_text.chars().collect();
+    let right_chars: Vec<char> = right_text.chars().collect();
+    let right_start_pos = total_width.saturating_sub(right_chars.len());
+
+    // Build spans with progress bar background
+    let mut spans = Vec::new();
+
+    for i in 0..total_width {
+        // Determine which character to show
+        let ch = if i < left_chars.len() {
+            left_chars[i].to_string()
+        } else if i >= right_start_pos && i - right_start_pos < right_chars.len() {
+            right_chars[i - right_start_pos].to_string()
+        } else {
+            " ".to_string()
+        };
+
+        // Apply progress bar background
+        if i < filled_width {
+            // Filled portion - border color background with black text
+            spans.push(Span::styled(
+                ch,
+                Style::default()
+                    .fg(Color::Black)
+                    .bg(Theme::border())
+            ));
+        } else {
+            // Unfilled portion - normal background
+            spans.push(Span::styled(
+                ch,
+                Style::default()
+                    .fg(Theme::muted_text())
+                    .bg(Theme::background())
+            ));
+        }
+    }
+
+    let progress_line = Line::from(spans);
+    let progress_widget = Paragraph::new(progress_line);
+    frame.render_widget(progress_widget, area);
+}
+
+fn render_info_popup(frame: &mut Frame, message: &str) {
+    // Create centered popup area - smaller than confirm popup
+    let area = frame.area();
+    let popup_width = 40;
+    let popup_height = 3;
+
+    let popup_area = Rect {
+        x: (area.width.saturating_sub(popup_width)) / 2,
+        y: (area.height.saturating_sub(popup_height)) / 2,
+        width: popup_width.min(area.width),
+        height: popup_height.min(area.height),
+    };
+
+    // Use Clear widget to completely erase the background
+    frame.render_widget(Clear, popup_area);
+
+    // Render the popup block with solid background
+    let block = Block::default()
+        .borders(Borders::ALL)
+        .style(Style::default()
+            .bg(Theme::background())
+            .fg(Theme::bright_foreground()));
+
+    let inner = block.inner(popup_area);
+    frame.render_widget(block, popup_area);
+
+    // Render message centered
+    let message_widget = Paragraph::new(message)
+        .alignment(Alignment::Center)
+        .style(Style::default()
+            .fg(Theme::bright_foreground())
+            .bg(Theme::background()));
+
+    frame.render_widget(message_widget, inner);
+}
+
 fn render_confirm_popup(frame: &mut Frame, title: &str, message: &str) {
     // Create centered popup area
     let area = frame.area();

src/ui/theme.rs

@@ -47,10 +47,6 @@ impl Theme {
         Self::dim_foreground()
     }
 
-    pub fn border_title() -> Color {
-        Self::bright_foreground()
-    }
-
     pub fn highlight() -> Color {
         Self::normal_blue()
     }
@@ -68,12 +64,6 @@ impl Theme {
         Style::default().fg(Self::border()).bg(Self::background())
     }
 
-    pub fn title_style() -> Style {
-        Style::default()
-            .fg(Self::border_title())
-            .bg(Self::background())
-    }
-
     pub fn secondary() -> Style {
         Style::default()
             .fg(Self::secondary_text())