Add metadata display and optimize CPU usage

Metadata features:
- Display artist, album, title in bottom status bar (left-aligned)
- Display bitrate, codec, sample rate in bottom status bar (right-aligned)
- Fetch metadata from MPV using metadata/by-key properties
- Support both lowercase and uppercase metadata tags

Performance optimizations:
- Split property updates: fast updates (position/duration) vs slow (metadata)
- Update metadata only every 2 seconds instead of every 100ms
- Skip MPV property updates entirely when stopped
- Conditional UI redraws - only when state actually changes
- Variable poll rate: 200ms when stopped, 100ms when playing
- Position update throttling (0.5s minimum change)
- Reduces CPU usage from constant 10 FPS to ~0.1 FPS when idle

.gitea/workflows/release.yml

@@ -93,19 +93,14 @@ jobs:
         run: |
           VERSION="${{ steps.version.outputs.VERSION }}"
 
+          # Get hash from the local tarball (already built)
+          NEW_HASH=$(sha256sum release/cm-player-linux-x86_64.tar.gz | cut -d' ' -f1)
+          NIX_HASH="sha256-$(python3 -c "import base64, binascii; print(base64.b64encode(binascii.unhexlify('$NEW_HASH')).decode())")"
+
           # Clone nixosbox repository
           git clone https://$GITEA_TOKEN@gitea.cmtec.se/cm/nixosbox.git nixosbox-update
           cd nixosbox-update
 
-          # Get hash for the new release tarball
-          TARBALL_URL="https://gitea.cmtec.se/cm/cm-player/releases/download/$VERSION/cm-player-linux-x86_64.tar.gz"
-
-          # Download tarball to get correct hash
-          curl -L -o cm-player.tar.gz "$TARBALL_URL"
-          # Convert sha256 hex to base64 for Nix hash format using Python
-          NEW_HASH=$(sha256sum cm-player.tar.gz | cut -d' ' -f1)
-          NIX_HASH="sha256-$(python3 -c "import base64, binascii; print(base64.b64encode(binascii.unhexlify('$NEW_HASH')).decode())")"
-
           # Update the NixOS configuration
           sed -i "s|version = \"v[^\"]*\"|version = \"$VERSION\"|" hosts/common/cm-player.nix
           sed -i "s|sha256 = \"sha256-[^\"]*\"|sha256 = \"$NIX_HASH\"|" hosts/common/cm-player.nix

Cargo.toml

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

README.md

@@ -1,2 +1,278 @@
 # cm-player
 
+A high-performance terminal UI music and video player written in Rust, designed for low-bandwidth VPN environments with cache-only operation.
+
+## Features
+
+- **Cache-only architecture**: Scans media directories once and operates from cache, ideal for low-bandwidth VPN connections
+- **Vim-style navigation**: Familiar keybindings (j/k/h/l) for efficient navigation
+- **Incremental fuzzy search**: Real-time search with Tab completion, similar to vim's command-line search
+- **Directory tree browsing**: Collapsible folder structure with lazy scrolling
+- **Playlist management**: Mark multiple files (vim-style 'v' key) to create custom playlists
+- **MPV integration**: Video and audio playback via MPV subprocess with IPC control
+- **Dual-panel layout**: File browser on left, playlist on right
+- **Auto-advance**: Automatically plays next track when current track ends
+
+## Architecture
+
+### Core Components
+
+**State Management** (`src/state/mod.rs`)
+- Maintains flattened file tree from cache for efficient rendering
+- Handles directory expansion/collapse state
+- Manages playlist and playback position
+- Implements fuzzy search with folder priority boost
+
+**MPV IPC Integration** (`src/player/mod.rs`)
+- Spawns MPV as subprocess with Unix socket IPC
+- Automatic process respawn when MPV exits (user closes window)
+- Non-blocking socket communication with JSON protocol
+- Tracks playback state, position, duration via property observation
+
+**Cache System** (`src/cache/mod.rs`)
+- XDG-compliant cache storage: `~/.cache/cm-player/`
+- Serializes directory tree structure with serde_json
+- Supports manual refresh with 'r' key
+- Scans multiple configured paths
+
+**UI Rendering** (`src/ui/mod.rs`)
+- Three-section layout: title bar (1 line) | content | status bar (1 line)
+- Ratatui framework with crossterm backend
+- Theme matching cm-dashboard color scheme
+- Real-time playback progress in title bar
+
+### Technical Details
+
+**Fuzzy Search Algorithm**
+```rust
+// Scoring system:
+// - Characters must appear in order (not necessarily consecutive)
+// - Consecutive matches: +10 bonus per character
+// - Word boundary matches: +15 bonus
+// - Gap penalty: -1 per character between matches
+// - Folder priority: +50 score boost
+// - Length bonus: 100 - text_length
+```
+
+**MPV Communication**
+- IPC socket: `/tmp/cm-player-{pid}.sock`
+- Commands: `{ "command": ["loadfile", "path"] }`
+- Property observation: `time-pos`, `duration`, `pause`, `idle-active`
+- Process lifecycle: spawn -> connect -> command -> observe -> respawn on exit
+
+**Lazy Scrolling**
+- Selection stays in place until reaching viewport edge
+- Scroll offset only updates when necessary
+- Page navigation with Ctrl-D/U (half-page jumps)
+
+## Installation
+
+### Pre-built Binary (NixOS)
+
+```nix
+# hosts/common/cm-player.nix is automatically included
+# mpv is installed as dependency
+```
+
+### From Release
+
+```bash
+curl -L https://gitea.cmtec.se/cm/cm-player/releases/latest/download/cm-player-linux-x86_64 -o cm-player
+chmod +x cm-player
+sudo mv cm-player /usr/local/bin/
+```
+
+### Build from Source
+
+```bash
+git clone https://gitea.cmtec.se/cm/cm-player.git
+cd cm-player
+cargo build --release
+./target/release/cm-player
+```
+
+**Static linking** (for portability):
+```bash
+export RUSTFLAGS="-C target-feature=+crt-static"
+cargo build --release --target x86_64-unknown-linux-gnu
+```
+
+## Configuration
+
+### Config File
+
+Location: `~/.config/cm-player/config.toml`
+
+```toml
+[scan_paths]
+paths = [
+    "/mnt/music",
+    "/mnt/movie",
+    "/mnt/tv"
+]
+```
+
+### First Run
+
+1. Create config file with media paths
+2. Launch cm-player
+3. Press 'r' to scan directories and build cache
+4. Cache stored at `~/.cache/cm-player/cache.json`
+
+## Keybindings
+
+### Navigation
+- `j` / `k` / `↓` / `↑` - Move selection down/up
+- `h` - Collapse directory
+- `l` - Expand directory
+- `Ctrl-D` - Page down (half page)
+- `Ctrl-U` - Page up (half page)
+
+### Search
+- `/` - Enter search mode (fuzzy find)
+- `Tab` - Next search result
+- `Shift-Tab` - Previous search result
+- `Enter` - Execute search and enable n/N cycling
+- `n` - Next search match (after Enter) or next track
+- `N` - Previous search match
+- `Esc` - Clear search results
+
+### Playlist
+- `v` - Mark/unmark file or directory
+- `a` - Add marked files to playlist
+- `c` - Clear playlist
+
+### Playback
+- `Enter` - Play selected file/folder (uses marks if any)
+- `Space` - Pause/Resume
+- `s` - Stop playback
+- `p` - Previous track
+- `n` - Next track (when not in search results)
+- `←` / `→` - Seek backward/forward 10 seconds
+- `+` / `=` - Increase volume
+- `-` - Decrease volume
+
+### System
+- `r` - Rescan media directories and rebuild cache
+- `q` - Quit
+
+## Development
+
+### Project Structure
+
+```
+cm-player/
+├── src/
+│   ├── main.rs           # Event loop and key handling
+│   ├── state/mod.rs      # App state and search logic
+│   ├── player/mod.rs     # MPV IPC integration
+│   ├── ui/
+│   │   ├── mod.rs        # TUI rendering
+│   │   └── theme.rs      # Color scheme
+│   ├── cache/mod.rs      # Cache serialization
+│   ├── scanner/mod.rs    # Directory scanning
+│   └── config/mod.rs     # Config file handling
+├── .gitea/workflows/
+│   └── release.yml       # CI/CD pipeline
+└── Cargo.toml
+```
+
+### Dependencies
+
+- **ratatui** - Terminal UI framework
+- **crossterm** - Terminal backend
+- **tokio** - Async runtime for event loop
+- **serde/serde_json** - Cache serialization
+- **walkdir** - Directory traversal
+- **anyhow/thiserror** - Error handling
+
+### Logging
+
+Logs written to `/tmp/cm-player.log` to avoid interfering with TUI:
+
+```rust
+tracing::info!("Playing: {:?}", path);
+tail -f /tmp/cm-player.log
+```
+
+## Release Process
+
+### Automated CI/CD
+
+Releases are fully automated via Gitea Actions:
+
+```bash
+# Update version in Cargo.toml
+vim Cargo.toml
+
+# Commit and tag
+git add Cargo.toml
+git commit -m "Bump version to v0.1.X"
+git push
+git tag v0.1.X
+git push origin v0.1.X
+```
+
+**Workflow steps**:
+1. Build static binary with `RUSTFLAGS="-C target-feature=+crt-static"`
+2. Create GitHub-style release on Gitea
+3. Upload binary and tarball as release assets
+4. Calculate SHA256 hash from local tarball
+5. Clone nixosbox repository
+6. Update `hosts/common/cm-player.nix` with new version and hash
+7. Commit and push to nixosbox
+
+### Manual NixOS Update
+
+If workflow fails, update manually:
+
+```bash
+cd ~/projects/nixosbox
+
+# Download and hash the tarball
+curl -L https://gitea.cmtec.se/cm/cm-player/releases/download/v0.1.X/cm-player-linux-x86_64.tar.gz -o /tmp/cm-player.tar.gz
+sha256sum /tmp/cm-player.tar.gz | cut -d' ' -f1
+# Convert hex to base64: python3 -c "import base64, binascii; print(base64.b64encode(binascii.unhexlify('HEX_HASH')).decode())"
+
+# Edit hosts/common/cm-player.nix
+vim hosts/common/cm-player.nix
+# Update version and sha256
+
+git add hosts/common/cm-player.nix
+git commit -m "Update cm-player to v0.1.X"
+git push
+```
+
+## MPV Configuration
+
+Default MPV flags:
+- `--idle` - Keep MPV running between tracks
+- `--no-terminal` - Disable MPV's terminal output
+- `--profile=fast` - Use fast decoding profile
+- `--audio-display=no` - Disable cover art for audio files
+- `--input-ipc-server=/tmp/cm-player-{pid}.sock` - Enable IPC
+
+## Troubleshooting
+
+### MPV window closes immediately
+Check MPV installation: `mpv --version`
+
+### Scan shows no files
+- Verify paths in `~/.config/cm-player/config.toml`
+- Press 'r' to rescan
+- Check logs: `tail -f /tmp/cm-player.log`
+
+### Hash mismatch on NixOS rebuild
+- Wait for workflow to complete before rebuilding
+- Workflow calculates hash from local tarball, not downloaded
+- Check release assets are fully uploaded: https://gitea.cmtec.se/cm/cm-player/releases
+
+### Video playback issues
+MPV process respawns automatically if closed. If issues persist:
+1. Stop playback with 's'
+2. Restart cm-player
+3. Check `/tmp/cm-player.log` for errors
+
+## License
+
+Copyright (c) 2025 CM Tech

src/main.rs

@@ -7,7 +7,7 @@ mod ui;
 
 use anyhow::{Context, Result};
 use crossterm::{
-    event::{self, DisableMouseCapture, EnableMouseCapture, Event, KeyCode, KeyEvent, KeyEventKind, KeyModifiers},
+    event::{self, Event, KeyCode, KeyEvent, KeyEventKind, KeyModifiers},
     execute,
     terminal::{disable_raw_mode, enable_raw_mode, EnterAlternateScreen, LeaveAlternateScreen},
 };
@@ -56,7 +56,7 @@ async fn main() -> Result<()> {
     // Setup terminal
     enable_raw_mode()?;
     let mut stdout = io::stdout();
-    execute!(stdout, EnterAlternateScreen, EnableMouseCapture)?;
+    execute!(stdout, EnterAlternateScreen)?;
     let backend = CrosstermBackend::new(stdout);
     let mut terminal = Terminal::new(backend)?;
 
@@ -67,8 +67,7 @@ async fn main() -> Result<()> {
     disable_raw_mode()?;
     execute!(
         terminal.backend_mut(),
-        LeaveAlternateScreen,
+        LeaveAlternateScreen
-        DisableMouseCapture
     )?;
     terminal.show_cursor()?;
 
@@ -80,32 +79,85 @@ async fn run_app<B: ratatui::backend::Backend>(
     state: &mut AppState,
     player: &mut player::Player,
 ) -> Result<()> {
+    let mut metadata_update_counter = 0u32;
+    let mut last_position = 0.0f64;
+    let mut needs_redraw = true;
+
     loop {
-        // Update player properties from MPV
+        let mut state_changed = false;
-        player.update_properties();
 
-        // Update position and duration from player
+        // Check if mpv process died (e.g., user closed video window)
-        state.current_position = player.get_position().unwrap_or(0.0);
+        if !player.is_process_alive() && state.player_state != PlayerState::Stopped {
-        state.current_duration = player.get_duration().unwrap_or(0.0);
+            state.player_state = PlayerState::Stopped;
+            state.current_position = 0.0;
+            state.current_duration = 0.0;
+            state_changed = true;
+        }
 
-        // Check if track ended and play next
+        // Only update properties when playing or paused (not when stopped)
-        if player.is_idle() && state.player_state == PlayerState::Playing {
+        if state.player_state != PlayerState::Stopped {
-            if state.playlist_index + 1 < state.playlist.len() {
+            player.update_properties();
-                state.play_next();
+
-                if let Some(ref path) = state.current_file {
+            // Update metadata only every 20 iterations (~2 seconds) to reduce IPC calls
-                    player.play(path)?;
+            metadata_update_counter += 1;
+            if metadata_update_counter >= 20 {
+                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);
+            let new_duration = player.get_duration().unwrap_or(0.0);
+
+            // Only mark as changed if position moved by at least 0.5 seconds
+            if (new_position - last_position).abs() >= 0.5 {
+                state.current_position = new_position;
+                last_position = new_position;
+                state_changed = true;
+            }
+
+            if state.current_duration != new_duration {
+                state.current_duration = new_duration;
+                state_changed = true;
+            }
+
+            // Check if track ended and play next (but only if track was actually loaded)
+            if player.is_idle() && state.player_state == PlayerState::Playing && state.current_duration > 0.0 {
+                if state.playlist_index + 1 < state.playlist.len() {
+                    state.play_next();
+                    if let Some(ref path) = state.current_file {
+                        player.play(path)?;
+                    }
+                    // Update metadata immediately when track changes
+                    player.update_metadata();
+                    metadata_update_counter = 0;
+                    state_changed = true;
+                } else {
+                    state.player_state = PlayerState::Stopped;
+                    state_changed = true;
                 }
-            } else {
-                state.player_state = PlayerState::Stopped;
             }
         }
 
-        terminal.draw(|f| ui::render(f, state))?;
+        // Only redraw if something changed or forced
+        if needs_redraw || state_changed {
+            terminal.draw(|f| ui::render(f, state, player))?;
+            needs_redraw = false;
+        }
 
-        if event::poll(std::time::Duration::from_millis(100))? {
+        // Poll for events - use longer timeout when stopped to reduce CPU
+        let poll_duration = if state.player_state == PlayerState::Stopped {
+            std::time::Duration::from_millis(200) // 5 FPS when stopped
+        } else {
+            std::time::Duration::from_millis(100) // 10 FPS when playing/paused
+        };
+
+        if event::poll(poll_duration)? {
             if let Event::Key(key) = event::read()? {
                 if key.kind == KeyEventKind::Press {
-                    handle_key_event(state, player, key).await?;
+                    handle_key_event(terminal, state, player, key).await?;
+                    needs_redraw = true; // Force redraw after key event
                 }
             }
         }
@@ -118,7 +170,7 @@ async fn run_app<B: ratatui::backend::Backend>(
     Ok(())
 }
 
-async fn handle_key_event(state: &mut AppState, player: &mut player::Player, key: KeyEvent) -> Result<()> {
+async fn handle_key_event<B: ratatui::backend::Backend>(terminal: &mut Terminal<B>, state: &mut AppState, player: &mut player::Player, key: KeyEvent) -> Result<()> {
     // Handle search mode separately
     if state.search_mode {
         match key.code {
@@ -150,34 +202,93 @@ async fn handle_key_event(state: &mut AppState, player: &mut player::Player, key
             state.should_quit = true;
         }
         (KeyCode::Char('/'), _) => {
-            state.enter_search_mode();
+            if state.search_mode && state.search_query.is_empty() {
+                // Exit search mode only if search query is blank
+                state.exit_search_mode();
+            } else if !state.search_mode {
+                state.enter_search_mode();
+            }
         }
         (KeyCode::Esc, _) => {
-            state.search_matches.clear();
+            if !state.search_matches.is_empty() {
+                state.search_matches.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 stopped, start from current index (0), otherwise go to next
+        }
-                if state.player_state == PlayerState::Stopped && !state.playlist.is_empty() {
+        (KeyCode::Char('N'), KeyModifiers::SHIFT) => {
-                    state.current_file = Some(state.playlist[state.playlist_index].clone());
+            if !state.search_matches.is_empty() {
-                    state.player_state = PlayerState::Playing;
+                state.prev_search_match();
-                    if let Some(ref path) = state.current_file {
+            }
-                        player.play(path)?;
+        }
-                        tracing::info!("Starting playlist: {:?}", path);
+        (KeyCode::Char('J'), KeyModifiers::SHIFT) => {
+            // Next track
+            if !state.playlist.is_empty() && state.playlist_index + 1 < state.playlist.len() {
+                state.playlist_index += 1;
+                state.current_file = Some(state.playlist[state.playlist_index].clone());
+
+                match state.player_state {
+                    PlayerState::Playing => {
+                        // Keep playing
+                        if let Some(ref path) = state.current_file {
+                            player.play(path)?;
+                            player.update_metadata(); // Update metadata immediately
+                            tracing::info!("Next track: {:?}", path);
+                        }
                     }
-                } else {
+                    PlayerState::Paused => {
-                    state.play_next();
+                        // Load but stay paused
-                    if let Some(ref path) = state.current_file {
+                        if let Some(ref path) = state.current_file {
-                        player.play(path)?;
+                            player.play(path)?;
-                        tracing::info!("Next track: {:?}", path);
+                            player.update_metadata(); // Update metadata immediately
+                            player.pause()?;
+                            tracing::info!("Next track (paused): {:?}", path);
+                        }
+                    }
+                    PlayerState::Stopped => {
+                        // Just update current file, stay stopped
+                        tracing::info!("Next track selected (stopped): {:?}", state.current_file);
                     }
                 }
             }
         }
-        (KeyCode::Char('N'), KeyModifiers::SHIFT) => {
+        (KeyCode::Char('K'), KeyModifiers::SHIFT) => {
-            state.prev_search_match();
+            // Previous track
+            if !state.playlist.is_empty() && state.playlist_index > 0 {
+                state.playlist_index -= 1;
+                state.current_file = Some(state.playlist[state.playlist_index].clone());
+
+                match state.player_state {
+                    PlayerState::Playing => {
+                        // Keep playing
+                        if let Some(ref path) = state.current_file {
+                            player.play(path)?;
+                            player.update_metadata(); // Update metadata immediately
+                            tracing::info!("Previous track: {:?}", path);
+                        }
+                    }
+                    PlayerState::Paused => {
+                        // Load but stay paused
+                        if let Some(ref path) = state.current_file {
+                            player.play(path)?;
+                            player.update_metadata(); // Update metadata immediately
+                            player.pause()?;
+                            tracing::info!("Previous track (paused): {:?}", path);
+                        }
+                    }
+                    PlayerState::Stopped => {
+                        // Just update current file, stay stopped
+                        tracing::info!("Previous track selected (stopped): {:?}", state.current_file);
+                    }
+                }
+            }
         }
         (KeyCode::Char('d'), KeyModifiers::CONTROL) => {
             state.page_down();
@@ -202,23 +313,33 @@ async fn handle_key_event(state: &mut AppState, player: &mut player::Player, key
         }
         (KeyCode::Char('a'), _) => {
             state.add_to_playlist();
+            if state.visual_mode {
+                state.visual_mode = false;
+                state.marked_files.clear();
+            }
         }
         (KeyCode::Char('c'), _) => {
             state.clear_playlist();
         }
-        (KeyCode::Char('p'), _) => {
-            state.play_previous();
-            if let Some(ref path) = state.current_file {
-                player.play(path)?;
-                tracing::info!("Previous track: {:?}", path);
-            }
-        }
         (KeyCode::Enter, _) => {
             state.play_selection();
             if let Some(ref path) = state.current_file {
                 player.play(path)?;
+                player.update_metadata(); // Update metadata immediately when playing new file
                 tracing::info!("Playing: {:?} (playlist: {} tracks)", path, state.playlist.len());
             }
+            if state.visual_mode {
+                state.visual_mode = false;
+                state.marked_files.clear();
+            }
+        }
+        (KeyCode::Char('s'), _) => {
+            // s: Stop playback
+            player.stop()?;
+            state.player_state = PlayerState::Stopped;
+            state.current_position = 0.0;
+            state.current_duration = 0.0;
+            tracing::info!("Stopped");
         }
         (KeyCode::Char(' '), _) => {
             match state.player_state {
@@ -232,16 +353,27 @@ async fn handle_key_event(state: &mut AppState, player: &mut player::Player, key
                     state.player_state = PlayerState::Playing;
                     tracing::info!("Resumed");
                 }
-                PlayerState::Stopped => {}
+                PlayerState::Stopped => {
+                    // Restart playback from current playlist position
+                    if !state.playlist.is_empty() {
+                        state.current_file = Some(state.playlist[state.playlist_index].clone());
+                        state.player_state = PlayerState::Playing;
+                        if let Some(ref path) = state.current_file {
+                            player.play(path)?;
+                            player.update_metadata(); // Update metadata immediately
+                            tracing::info!("Restarting playback: {:?}", path);
+                        }
+                    }
+                }
             }
         }
-        (KeyCode::Left, _) => {
+        (KeyCode::Char('H'), KeyModifiers::SHIFT) => {
             if state.player_state != PlayerState::Stopped {
                 player.seek(-10.0)?;
                 tracing::info!("Seek backward 10s");
             }
         }
-        (KeyCode::Right, _) => {
+        (KeyCode::Char('L'), KeyModifiers::SHIFT) => {
             if state.player_state != PlayerState::Stopped {
                 player.seek(10.0)?;
                 tracing::info!("Seek forward 10s");
@@ -261,6 +393,7 @@ async fn handle_key_event(state: &mut AppState, player: &mut player::Player, key
         }
         (KeyCode::Char('r'), _) => {
             state.is_refreshing = true;
+            terminal.draw(|f| ui::render(f, state, player))?;  // Show "Refreshing library..." immediately
             tracing::info!("Rescanning...");
             let cache_dir = cache::get_cache_dir()?;
             let new_cache = scanner::scan_paths(&state.config.scan_paths.paths)?;

src/player/mod.rs

@@ -15,6 +15,12 @@ pub struct Player {
     duration: f64,
     is_paused: bool,
     is_idle: bool,
+    pub media_title: Option<String>,
+    pub artist: Option<String>,
+    pub album: Option<String>,
+    pub audio_codec: Option<String>,
+    pub audio_bitrate: Option<f64>,
+    pub sample_rate: Option<i64>,
 }
 
 impl Player {
@@ -27,8 +33,9 @@ impl Player {
         // Spawn MPV with IPC server
         let process = Command::new("mpv")
             .arg("--idle")
-            .arg("--no-video")
             .arg("--no-terminal")
+            .arg("--profile=fast")
+            .arg("--audio-display=no")  // Don't show cover art for audio files
             .arg(format!("--input-ipc-server={}", socket_path.display()))
             .stdin(Stdio::null())
             .stdout(Stdio::null())
@@ -49,19 +56,77 @@ impl Player {
             duration: 0.0,
             is_paused: false,
             is_idle: true,
+            media_title: None,
+            artist: None,
+            album: None,
+            audio_codec: None,
+            audio_bitrate: None,
+            sample_rate: None,
         })
     }
 
     fn connect(&mut self) -> Result<()> {
         if self.socket.is_none() {
-            let stream = UnixStream::connect(&self.socket_path)
+            // Try to connect, if it fails, respawn mpv
-                .context("Failed to connect to MPV IPC socket")?;
+            match UnixStream::connect(&self.socket_path) {
-            stream.set_nonblocking(true).ok();
+                Ok(stream) => {
-            self.socket = Some(stream);
+                    stream.set_nonblocking(true).ok();
+                    self.socket = Some(stream);
+                }
+                Err(_) => {
+                    // MPV probably died, respawn it
+                    self.respawn()?;
+                    let stream = UnixStream::connect(&self.socket_path)
+                        .context("Failed to connect to MPV IPC socket after respawn")?;
+                    stream.set_nonblocking(true).ok();
+                    self.socket = Some(stream);
+                }
+            }
         }
         Ok(())
     }
 
+    fn respawn(&mut self) -> Result<()> {
+        // Kill old process if still running
+        self.process.kill().ok();
+        self.process.wait().ok();
+
+        // Clean up old socket
+        std::fs::remove_file(&self.socket_path).ok();
+
+        // Spawn new MPV process
+        let process = Command::new("mpv")
+            .arg("--idle")
+            .arg("--no-terminal")
+            .arg("--profile=fast")
+            .arg("--audio-display=no")
+            .arg(format!("--input-ipc-server={}", self.socket_path.display()))
+            .stdin(Stdio::null())
+            .stdout(Stdio::null())
+            .stderr(Stdio::null())
+            .spawn()
+            .context("Failed to respawn MPV process")?;
+
+        self.process = process;
+        self.socket = None;
+        self.is_idle = true;
+        self.position = 0.0;
+        self.duration = 0.0;
+        self.is_paused = false;
+        self.media_title = None;
+        self.artist = None;
+        self.album = None;
+        self.audio_codec = None;
+        self.audio_bitrate = None;
+        self.sample_rate = None;
+
+        // Wait for socket to be created and mpv to be ready
+        std::thread::sleep(Duration::from_millis(800));
+
+        tracing::info!("MPV process respawned");
+        Ok(())
+    }
+
     fn send_command(&mut self, command: &str, args: &[Value]) -> Result<()> {
         self.connect()?;
 
@@ -74,7 +139,17 @@ impl Player {
 
         if let Some(ref mut socket) = self.socket {
             let msg = format!("{}\n", cmd);
-            socket.write_all(msg.as_bytes()).context("Failed to write to socket")?;
+            // Ignore broken pipe errors (mpv closed)
+            if let Err(e) = socket.write_all(msg.as_bytes()) {
+                if e.kind() == std::io::ErrorKind::BrokenPipe {
+                    self.socket = None;
+                    self.is_idle = true;
+                    // Clean up dead process
+                    self.process.kill().ok();
+                    return Ok(());
+                }
+                return Err(e).context("Failed to write to socket");
+            }
         }
 
         Ok(())
@@ -130,6 +205,13 @@ impl Player {
         Ok(())
     }
 
+    pub fn stop(&mut self) -> Result<()> {
+        self.send_command("stop", &[])?;
+        self.is_idle = true;
+        self.position = 0.0;
+        self.duration = 0.0;
+        Ok(())
+    }
 
     pub fn set_volume(&mut self, volume: i64) -> Result<()> {
         self.send_command("set_property", &[json!("volume"), json!(volume)])?;
@@ -166,6 +248,63 @@ impl Player {
         }
     }
 
+    pub fn update_metadata(&mut self) {
+        // Try to get artist directly
+        if let Some(val) = self.get_property("metadata/by-key/artist") {
+            self.artist = val.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
+        if let Some(val) = self.get_property("metadata/by-key/album") {
+            self.album = val.as_str().map(|s| s.to_string());
+        }
+        // Fallback to ALBUM (uppercase)
+        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
+        if let Some(val) = self.get_property("metadata/by-key/title") {
+            self.media_title = val.as_str().map(|s| s.to_string());
+        }
+        // Fallback to TITLE (uppercase)
+        if self.media_title.is_none() {
+            if let Some(val) = self.get_property("metadata/by-key/TITLE") {
+                self.media_title = val.as_str().map(|s| s.to_string());
+            }
+        }
+
+        // Final fallback to media-title if metadata doesn't have title
+        if self.media_title.is_none() {
+            if let Some(val) = self.get_property("media-title") {
+                self.media_title = val.as_str().map(|s| s.to_string());
+            }
+        }
+
+        // Update audio codec
+        if let Some(val) = self.get_property("audio-codec-name") {
+            self.audio_codec = val.as_str().map(|s| s.to_string());
+        }
+
+        // Update audio bitrate (convert from bps to kbps)
+        if let Some(val) = self.get_property("audio-bitrate") {
+            self.audio_bitrate = val.as_f64().map(|b| b / 1000.0);
+        }
+
+        // Update sample rate
+        if let Some(val) = self.get_property("audio-params/samplerate") {
+            self.sample_rate = val.as_i64();
+        }
+    }
+
     pub fn get_position(&self) -> Option<f64> {
         Some(self.position)
     }
@@ -178,6 +317,25 @@ impl Player {
         self.is_idle
     }
 
+    pub fn is_process_alive(&mut self) -> bool {
+        // Check if mpv process is still running
+        match self.process.try_wait() {
+            Ok(Some(_)) => {
+                // Process has exited - clean up socket
+                self.socket = None;
+                self.is_idle = true;
+                false
+            }
+            Ok(None) => true,     // Process is still running
+            Err(_) => {
+                // Error checking, assume dead and clean up
+                self.socket = None;
+                self.is_idle = true;
+                false
+            }
+        }
+    }
+
     pub fn seek(&mut self, seconds: f64) -> Result<()> {
         self.send_command("seek", &[json!(seconds), json!("relative")])?;
         Ok(())

src/state/mod.rs

@@ -29,10 +29,13 @@ pub struct AppState {
     pub is_refreshing: bool,
     pub search_mode: bool,
     pub search_query: String,
-    pub search_matches: Vec<usize>,
+    pub search_matches: Vec<PathBuf>,
     pub search_match_index: usize,
     pub tab_search_results: Vec<PathBuf>,
     pub tab_search_index: usize,
+    pub visual_mode: bool,
+    pub visual_anchor: usize,
+    pub saved_expanded_dirs: HashSet<PathBuf>,
 }
 
 #[derive(Debug, Clone)]
@@ -71,6 +74,9 @@ impl AppState {
             search_match_index: 0,
             tab_search_results: Vec::new(),
             tab_search_index: 0,
+            visual_mode: false,
+            visual_anchor: 0,
+            saved_expanded_dirs: HashSet::new(),
         }
     }
 
@@ -81,12 +87,20 @@ impl AppState {
             if self.selected_index < self.scroll_offset {
                 self.scroll_offset = self.selected_index;
             }
+            // Update visual selection if in visual mode
+            if self.visual_mode {
+                self.update_visual_selection();
+            }
         }
     }
 
     pub fn move_selection_down(&mut self) {
         if self.selected_index < self.flattened_items.len().saturating_sub(1) {
             self.selected_index += 1;
+            // Update visual selection if in visual mode
+            if self.visual_mode {
+                self.update_visual_selection();
+            }
         }
     }
 
@@ -120,11 +134,43 @@ impl AppState {
     }
 
     pub fn collapse_selected(&mut self) {
-        if let Some(item) = self.get_selected_item() {
+        let item = self.get_selected_item().cloned();
+        if let Some(item) = item {
             if item.node.is_dir {
                 let path = item.node.path.clone();
-                self.expanded_dirs.remove(&path);
+                let was_expanded = self.expanded_dirs.contains(&path);
-                self.rebuild_flattened_items();
+
+                if was_expanded {
+                    // Close the expanded folder and keep selection on it
+                    self.expanded_dirs.remove(&path);
+                    self.rebuild_flattened_items();
+                    // Find the collapsed folder and select it
+                    if let Some(idx) = self.flattened_items.iter().position(|i| i.node.path == path) {
+                        self.selected_index = idx;
+                    }
+                } else {
+                    // Folder is collapsed, close parent instead and jump to it
+                    if let Some(parent) = path.parent() {
+                        let parent_buf = parent.to_path_buf();
+                        self.expanded_dirs.remove(&parent_buf);
+                        self.rebuild_flattened_items();
+                        // Jump to parent folder
+                        if let Some(parent_idx) = self.flattened_items.iter().position(|i| i.node.path == parent_buf) {
+                            self.selected_index = parent_idx;
+                        }
+                    }
+                }
+            } else {
+                // Close parent folder when on a file and jump to it
+                if let Some(parent) = item.node.path.parent() {
+                    let parent_buf = parent.to_path_buf();
+                    self.expanded_dirs.remove(&parent_buf);
+                    self.rebuild_flattened_items();
+                    // Jump to parent folder
+                    if let Some(parent_idx) = self.flattened_items.iter().position(|i| i.node.path == parent_buf) {
+                        self.selected_index = parent_idx;
+                    }
+                }
             }
         }
     }
@@ -140,13 +186,37 @@ impl AppState {
     }
 
     pub fn toggle_mark(&mut self) {
-        if let Some(item) = self.get_selected_item() {
+        if self.visual_mode {
-            if !item.node.is_dir {
+            // Exit visual mode and mark all files in range
-                let path = item.node.path.clone();
+            self.update_visual_selection();
-                if self.marked_files.contains(&path) {
+            self.visual_mode = false;
-                    self.marked_files.remove(&path);
+        } else {
-                } else {
+            // Enter visual mode
-                    self.marked_files.insert(path);
+            self.visual_mode = true;
+            self.visual_anchor = self.selected_index;
+            // Clear previous marks when entering visual mode
+            self.marked_files.clear();
+            // Mark current file
+            if let Some(item) = self.get_selected_item() {
+                if !item.node.is_dir {
+                    self.marked_files.insert(item.node.path.clone());
+                }
+            }
+        }
+    }
+
+    fn update_visual_selection(&mut self) {
+        // Clear marks
+        self.marked_files.clear();
+
+        // Mark all files between anchor and current position
+        let start = self.visual_anchor.min(self.selected_index);
+        let end = self.visual_anchor.max(self.selected_index);
+
+        for i in start..=end {
+            if let Some(item) = self.flattened_items.get(i) {
+                if !item.node.is_dir {
+                    self.marked_files.insert(item.node.path.clone());
                 }
             }
         }
@@ -229,20 +299,12 @@ impl AppState {
         }
     }
 
-    pub fn play_previous(&mut self) {
-        if self.playlist_index > 0 {
-            self.playlist_index -= 1;
-            self.current_file = Some(self.playlist[self.playlist_index].clone());
-            self.player_state = PlayerState::Playing;
-        }
-    }
-
     pub fn refresh_flattened_items(&mut self) {
         // Keep current expanded state after rescan
         self.rebuild_flattened_items();
     }
 
-    fn rebuild_flattened_items(&mut self) {
+    pub fn rebuild_flattened_items(&mut self) {
         self.flattened_items = flatten_tree(&self.cache.file_tree, 0, &self.expanded_dirs);
         if self.selected_index >= self.flattened_items.len() {
             self.selected_index = self.flattened_items.len().saturating_sub(1);
@@ -256,12 +318,17 @@ impl AppState {
         self.search_match_index = 0;
         self.tab_search_results.clear();
         self.tab_search_index = 0;
+        // Save current folder state
+        self.saved_expanded_dirs = self.expanded_dirs.clone();
     }
 
     pub fn exit_search_mode(&mut self) {
         self.search_mode = false;
         self.tab_search_results.clear();
         self.tab_search_index = 0;
+        // Restore folder state from before search
+        self.expanded_dirs = self.saved_expanded_dirs.clone();
+        self.rebuild_flattened_items();
     }
 
     pub fn append_search_char(&mut self, c: char) {
@@ -291,29 +358,34 @@ impl AppState {
             return;
         }
 
-        // Sort by score (highest first)
+        // Add index to preserve original tree order when scores are equal
-        matching_paths_with_scores.sort_by(|a, b| b.1.cmp(&a.1));
+        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)));
 
         // Store all matches for tab completion
-        self.tab_search_results = matching_paths_with_scores.iter().map(|(path, _)| path.clone()).collect();
+        self.tab_search_results = indexed_matches.iter().map(|(path, _, _)| path.clone()).collect();
         self.tab_search_index = 0;
 
-        // Expand parent directories of ALL matches (not just best match)
+        // Close all folders and expand only for the best match
-        // This ensures folders deep in the tree become visible
+        self.expanded_dirs.clear();
-        for (path, _) in &matching_paths_with_scores {
+        let best_match = self.tab_search_results[0].clone();
-            let mut parent = path.parent();
+        let mut parent = best_match.parent();
-            while let Some(p) = parent {
+        while let Some(p) = parent {
-                self.expanded_dirs.insert(p.to_path_buf());
+            self.expanded_dirs.insert(p.to_path_buf());
-                parent = p.parent();
+            parent = p.parent();
-            }
         }
 
         // Rebuild flattened items
         self.rebuild_flattened_items();
 
         // Find the best match in the flattened list and jump to it
-        let best_match = &self.tab_search_results[0];
+        if let Some(idx) = self.flattened_items.iter().position(|item| item.node.path == best_match) {
-        if let Some(idx) = self.flattened_items.iter().position(|item| &item.node.path == best_match) {
             self.selected_index = idx;
         }
     }
@@ -324,7 +396,7 @@ impl AppState {
             return;
         }
 
-        // Collect all matching paths with scores
+        // 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);
 
@@ -333,35 +405,43 @@ impl AppState {
             return;
         }
 
-        // Sort by score (highest first)
+        // Add index to preserve original tree order when scores are equal
-        matching_paths_with_scores.sort_by(|a, b| b.1.cmp(&a.1));
+        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();
 
-        // Expand all parent directories
+        // Store matching paths (not indices, as they change when folders collapse)
-        for path in &matching_paths {
+        self.search_matches = matching_paths;
-            let mut parent = path.parent();
+
+        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
+            // Rebuild flattened items
-        self.rebuild_flattened_items();
+            self.rebuild_flattened_items();
 
-        // Find indices of matches in the flattened list
+            // Find first match in flattened list
-        self.search_matches = matching_paths
+            if let Some(idx) = self.flattened_items.iter().position(|item| item.node.path == first_match) {
-            .iter()
+                self.selected_index = idx;
-            .filter_map(|path| {
+            }
-                self.flattened_items
-                    .iter()
-                    .position(|item| &item.node.path == path)
-            })
-            .collect();
-
-        if !self.search_matches.is_empty() {
-            self.search_match_index = 0;
-            self.selected_index = self.search_matches[0];
         }
 
         self.search_mode = false;
@@ -370,7 +450,23 @@ impl AppState {
     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();
-            self.selected_index = self.search_matches[self.search_match_index];
+            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.node.path == target_path) {
+                self.selected_index = idx;
+            }
         }
     }
 
@@ -381,7 +477,23 @@ impl AppState {
             } else {
                 self.search_match_index -= 1;
             }
-            self.selected_index = self.search_matches[self.search_match_index];
+            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.node.path == target_path) {
+                self.selected_index = idx;
+            }
         }
     }
 
@@ -394,7 +506,8 @@ impl AppState {
         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();
 
-        // Expand parent directories
+        // 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());
@@ -423,7 +536,8 @@ impl AppState {
         }
         let prev_match = self.tab_search_results[self.tab_search_index].clone();
 
-        // Expand parent directories
+        // 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());
@@ -514,9 +628,6 @@ fn fuzzy_match(text: &str, query: &str) -> Option<i32> {
         }
     }
 
-    // Bonus for shorter strings (better matches)
-    score += 100 - text_lower.len() as i32;
-
     Some(score)
 }
 

src/ui/mod.rs

@@ -1,5 +1,6 @@
 mod theme;
 
+use crate::player::Player;
 use crate::state::{AppState, PlayerState};
 use ratatui::{
     layout::{Alignment, Constraint, Direction, Layout, Rect},
@@ -10,7 +11,7 @@ use ratatui::{
 };
 use theme::Theme;
 
-pub fn render(frame: &mut Frame, state: &mut AppState) {
+pub fn render(frame: &mut Frame, state: &mut AppState, player: &Player) {
     // Clear background
     frame.render_widget(
         Block::default().style(Theme::secondary()),
@@ -36,7 +37,69 @@ pub fn render(frame: &mut Frame, state: &mut AppState) {
     render_title_bar(frame, state, main_chunks[0]);
     render_file_panel(frame, state, content_chunks[0]);
     render_right_panel(frame, state, content_chunks[1]);
-    render_status_bar(frame, state, main_chunks[2]);
+    render_status_bar(frame, state, player, main_chunks[2]);
+}
+
+fn highlight_search_matches<'a>(text: &str, query: &str, search_typing: bool, is_selected: bool) -> Vec<Span<'a>> {
+    let query_lower = query.to_lowercase();
+
+    let mut spans = Vec::new();
+    let mut query_chars = query_lower.chars();
+    let mut current_query_char = query_chars.next();
+    let mut current_segment = String::new();
+
+    for ch in text.chars() {
+        let ch_lower = ch.to_lowercase().next().unwrap();
+
+        if let Some(query_ch) = current_query_char {
+            if ch_lower == query_ch {
+                // Found a match - flush current segment
+                if !current_segment.is_empty() {
+                    spans.push(Span::raw(current_segment.clone()));
+                    current_segment.clear();
+                }
+                // Add matched character with styling based on mode
+                if search_typing && is_selected {
+                    // While typing on selected row: green bg with black fg (inverted)
+                    spans.push(Span::styled(
+                        ch.to_string(),
+                        Style::default()
+                            .fg(Theme::background())
+                            .bg(Theme::success()),
+                    ));
+                } else if !search_typing && is_selected {
+                    // After Enter on selected row: bold black text on blue selection bar
+                    spans.push(Span::styled(
+                        ch.to_string(),
+                        Style::default()
+                            .fg(Theme::background())
+                            .add_modifier(Modifier::BOLD),
+                    ));
+                } else {
+                    // Other rows: just green text
+                    spans.push(Span::styled(
+                        ch.to_string(),
+                        Style::default().fg(Theme::success()),
+                    ));
+                }
+                // Move to next query character
+                current_query_char = query_chars.next();
+            } else {
+                // No match - add to current segment
+                current_segment.push(ch);
+            }
+        } else {
+            // No more query characters to match
+            current_segment.push(ch);
+        }
+    }
+
+    // Flush remaining segment
+    if !current_segment.is_empty() {
+        spans.push(Span::raw(current_segment));
+    }
+
+    spans
 }
 
 fn render_file_panel(frame: &mut Frame, state: &mut AppState, area: Rect) {
@@ -44,6 +107,10 @@ fn render_file_panel(frame: &mut Frame, state: &mut AppState, area: Rect) {
     let visible_height = area.height.saturating_sub(2) as usize;
     state.update_scroll_offset(visible_height);
 
+    let in_search = state.search_mode || !state.search_matches.is_empty();
+    let search_typing = state.search_mode; // True when actively typing search
+    let search_query = if in_search { state.search_query.to_lowercase() } else { String::new() };
+
     let items: Vec<ListItem> = state
         .flattened_items
         .iter()
@@ -51,20 +118,56 @@ fn render_file_panel(frame: &mut Frame, state: &mut AppState, area: Rect) {
         .map(|(idx, item)| {
             let indent = "  ".repeat(item.depth);
             let mark = if state.marked_files.contains(&item.node.path) { "* " } else { "" };
-            let suffix = if item.node.is_dir { "/" } else { "" };
-            let text = format!("{}{}{}{}", indent, mark, item.node.name, suffix);
 
-            let style = if idx == state.selected_index {
+            // Build name with search highlighting
+            let is_selected = idx == state.selected_index;
+
+            // Add folder icon for directories
+            let icon = if item.node.is_dir {
+                // Bold black icon on selection bar, blue otherwise
+                if !search_typing && is_selected {
+                    Span::styled("▸ ", Style::default().fg(Theme::background()).add_modifier(Modifier::BOLD))
+                } else {
+                    Span::styled("▸ ", Style::default().fg(Theme::highlight()))
+                }
+            } else {
+                Span::raw("  ")
+            };
+            let name_spans = if in_search && !search_query.is_empty() {
+                highlight_search_matches(&item.node.name, &search_query, search_typing, is_selected)
+            } else {
+                vec![Span::raw(&item.node.name)]
+            };
+
+            let suffix = if item.node.is_dir { "/" } else { "" };
+
+            let base_style = if search_typing {
+                // While typing search: no selection bar, just normal colors
+                if state.marked_files.contains(&item.node.path) {
+                    Theme::marked()
+                } else {
+                    Theme::secondary()
+                }
+            } else if is_selected {
+                // After pressing Enter or normal mode: normal blue selection bar
                 Theme::selected()
-            } else if item.node.is_dir {
-                Theme::directory()
             } else if state.marked_files.contains(&item.node.path) {
                 Theme::marked()
             } else {
                 Theme::secondary()
             };
 
-            ListItem::new(text).style(style)
+            let mut line_spans = vec![
+                Span::raw(indent),
+                Span::raw(mark),
+                icon,
+            ];
+            line_spans.extend(name_spans);
+            line_spans.push(Span::raw(suffix));
+
+            let line = Line::from(line_spans);
+
+            ListItem::new(line).style(base_style)
         })
         .collect();
 
@@ -78,7 +181,11 @@ fn render_file_panel(frame: &mut Frame, state: &mut AppState, area: Rect) {
         );
 
     let mut list_state = ListState::default();
-    list_state.select(Some(state.selected_index));
+    // Don't show selection bar widget while typing search - we use inverted colors instead
+    // Show it in normal mode and after executing search (Enter)
+    if !search_typing {
+        list_state.select(Some(state.selected_index));
+    }
     *list_state.offset_mut() = state.scroll_offset;
     frame.render_stateful_widget(list, area, &mut list_state);
 }
@@ -95,8 +202,12 @@ fn render_right_panel(frame: &mut Frame, state: &AppState, area: Rect) {
                 .map(|n| n.to_string_lossy().to_string())
                 .unwrap_or_else(|| path.to_string_lossy().to_string());
 
-            let style = if idx == state.playlist_index && state.player_state != PlayerState::Stopped {
+            let style = if idx == state.playlist_index {
-                Theme::selected()
+                // Current file: white bold
+                Style::default()
+                    .fg(Theme::bright_foreground())
+                    .bg(Theme::background())
+                    .add_modifier(Modifier::BOLD)
             } else {
                 Theme::secondary()
             };
@@ -121,14 +232,16 @@ fn render_right_panel(frame: &mut Frame, state: &AppState, area: Rect) {
         );
 
     let mut playlist_state = ListState::default();
-    if state.player_state != PlayerState::Stopped && !state.playlist.is_empty() {
+    // Don't set selection - use bold text instead
-        playlist_state.select(Some(state.playlist_index));
-    }
     frame.render_stateful_widget(playlist_widget, area, &mut playlist_state);
 }
 
 fn render_title_bar(frame: &mut Frame, state: &AppState, area: Rect) {
-    let background_color = Theme::success(); // Green for normal operation
+    let background_color = match state.player_state {
+        PlayerState::Playing => Theme::success(),     // Green for playing
+        PlayerState::Paused => Theme::highlight(),    // Blue for paused
+        PlayerState::Stopped => Theme::dim_foreground(),   // Gray for stopped
+    };
 
     // Split the title bar into left and right sections
     let chunks = Layout::default()
@@ -205,29 +318,11 @@ fn render_title_bar(frame: &mut Frame, state: &AppState, area: Rect) {
 
         // Volume
         right_spans.push(Span::styled(
-            format!(" • Vol: {}%", state.volume),
+            format!(" • Vol: {}% ", state.volume),
             Style::default()
                 .fg(Theme::background())
                 .bg(background_color)
         ));
-
-        // Add search info if active
-        if !state.search_matches.is_empty() {
-            right_spans.push(Span::styled(
-                format!(" • Search: {}/{} ", state.search_match_index + 1, state.search_matches.len()),
-                Style::default()
-                    .fg(Theme::background())
-                    .bg(background_color)
-                    .add_modifier(Modifier::BOLD)
-            ));
-        } else {
-            right_spans.push(Span::styled(
-                " ",
-                Style::default()
-                    .fg(Theme::background())
-                    .bg(background_color)
-            ));
-        }
     }
 
     let right_title = Paragraph::new(Line::from(right_spans))
@@ -236,7 +331,7 @@ fn render_title_bar(frame: &mut Frame, state: &AppState, area: Rect) {
     frame.render_widget(right_title, chunks[1]);
 }
 
-fn render_status_bar(frame: &mut Frame, state: &AppState, area: Rect) {
+fn render_status_bar(frame: &mut Frame, state: &AppState, player: &Player, area: Rect) {
     if state.search_mode {
         // Show search prompt with current query and match count - LEFT aligned
         let search_text = if !state.tab_search_results.is_empty() {
@@ -249,12 +344,79 @@ fn render_status_bar(frame: &mut Frame, state: &AppState, area: Rect) {
         let status_bar = Paragraph::new(search_text)
             .style(Style::default().fg(Theme::foreground()).bg(Theme::background()));
         frame.render_widget(status_bar, area);
-    } else {
+    } else if !state.search_matches.is_empty() {
-        // Normal mode shortcuts (always shown when not in search mode)
+        // Show search navigation when search results are active
-        let shortcuts = "/: Search • v: Mark • a: Add to Playlist • c: Clear Playlist • Enter: Play • Space: Pause • ←→: Seek • +/-: Volume • n/p: Next/Prev • r: Rescan • q: Quit";
+        let search_text = format!("Search: {}/{} • n: Next • N: Prev • Esc: Clear", state.search_match_index + 1, state.search_matches.len());
-        let status_bar = Paragraph::new(shortcuts)
+        let status_bar = Paragraph::new(search_text)
-            .style(Style::default().fg(Theme::muted_text()).bg(Theme::background()))
+            .style(Style::default().fg(Theme::foreground()).bg(Theme::background()));
-            .alignment(Alignment::Center);
         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());
+        let status_bar = Paragraph::new(visual_text)
+            .style(Style::default().fg(Theme::foreground()).bg(Theme::background()));
+        frame.render_widget(status_bar, area);
+    } else {
+        // Normal mode: show media metadata if playing
+        // Split into left (artist/album/title) and right (technical info)
+
+        let mut left_parts = Vec::new();
+        let mut right_parts = Vec::new();
+
+        // Left side: Artist | Album | Title
+        if let Some(ref artist) = player.artist {
+            left_parts.push(artist.clone());
+        }
+
+        if let Some(ref album) = player.album {
+            left_parts.push(album.clone());
+        }
+
+        if let Some(ref title) = player.media_title {
+            left_parts.push(title.clone());
+        }
+
+        // Right side: Bitrate | Codec | Sample rate
+        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));
+        }
+
+        // Create layout for left and right sections
+        let chunks = Layout::default()
+            .direction(Direction::Horizontal)
+            .constraints([Constraint::Percentage(50), Constraint::Percentage(50)])
+            .split(area);
+
+        // Left side text
+        let left_text = if !left_parts.is_empty() {
+            format!(" {}", left_parts.join(" | "))
+        } else {
+            String::new()
+        };
+
+        let left_bar = Paragraph::new(left_text)
+            .style(Style::default().fg(Theme::muted_text()).bg(Theme::background()))
+            .alignment(Alignment::Left);
+        frame.render_widget(left_bar, chunks[0]);
+
+        // Right side text
+        let right_text = if !right_parts.is_empty() {
+            format!("{} ", right_parts.join(" | "))
+        } else {
+            String::new()
+        };
+
+        let right_bar = Paragraph::new(right_text)
+            .style(Style::default().fg(Theme::muted_text()).bg(Theme::background()))
+            .alignment(Alignment::Right);
+        frame.render_widget(right_bar, chunks[1]);
     }
 }

src/ui/theme.rs

@@ -86,12 +86,6 @@ impl Theme {
             .bg(Self::highlight())
     }
 
-    pub fn directory() -> Style {
-        Style::default()
-            .fg(Self::normal_blue())
-            .bg(Self::background())
-    }
-
     pub fn marked() -> Style {
         Style::default()
             .fg(Self::warning())