3 files changed, 43 insertions, 48 deletions

diff --git a/src/audio.rs b/src/audio.rs
index 386c041..62afd93 100644
--- a/src/audio.rs
+++ b/src/audio.rs
@@ -199,30 +199,29 @@ fn audio_thread(
 
                         // Pre-decode some samples before starting playback to prevent buffer underrun
                         let channels = data.channels as usize;
-                        for _ in 0..50 {
+                        for _ in 0..100 {
                             match data.format.next_packet() {
-                                Ok(packet) => {
-                                    match data.decoder.decode(&packet) {
-                                        Ok(decoded) => {
-                                            let spec = *decoded.spec();
-                                            let mut sample_buf =
-                                                symphonia::core::audio::SampleBuffer::<f32>::new(
-                                                    decoded.capacity() as u64, spec
-                                                );
-                                            sample_buf.copy_interleaved_ref(decoded);
-                                            let samples = sample_buf.samples();
-
-                                            let resampled = if let Some(ratio) = data.resample_ratio {
-                                                resample_linear(samples, ratio, channels)
-                                            } else {
-                                                samples.to_vec()
-                                            };
-
-                                            data.sample_buffer.extend(resampled);
-                                        }
-                                        Err(_) => break,
+                                Ok(packet) => match data.decoder.decode(&packet) {
+                                    Ok(decoded) => {
+                                        let spec = *decoded.spec();
+                                        let mut sample_buf = symphonia::core::audio::SampleBuffer::<
+                                            f32,
+                                        >::new(
+                                            decoded.capacity() as u64, spec
+                                        );
+                                        sample_buf.copy_interleaved_ref(decoded);
+                                        let samples = sample_buf.samples();
+
+                                        let resampled = if let Some(ratio) = data.resample_ratio {
+                                            resample_linear(samples, ratio, channels)
+                                        } else {
+                                            samples.to_vec()
+                                        };
+
+                                        data.sample_buffer.extend(resampled);
                                     }
-                                }
+                                    Err(_) => break,
+                                },
                                 Err(_) => break,
                             }
                         }
diff --git a/src/daemon.rs b/src/daemon.rs
index 7488fc2..b79e67a 100644
--- a/src/daemon.rs
+++ b/src/daemon.rs
@@ -454,7 +454,10 @@ fn process_command(
                                     for file in &files {
                                         q.add_track(file.clone());
                                     }
-                                    if was_empty && !was_playing && let Some(track) = q.current() {
+                                    if was_empty
+                                        && !was_playing
+                                        && let Some(track) = q.current()
+                                    {
                                         audio.play(track.path.clone());
                                         notification::notify_track(track);
                                     }
@@ -519,24 +522,8 @@ fn process_command(
                             }
                         }
                     }
-                    // Use pager if queue is longer than terminal height
-                    let terminal_rows = terminal_size::terminal_size()
-                        .map(|(w, _)| w.0 as usize)
-                        .unwrap_or(24);
-                    if output.lines().count() > terminal_rows {
-                        use std::process::{Command, Stdio};
-                        let pager = Command::new("less").arg("-R").stdin(Stdio::piped()).spawn();
-                        if let Ok(mut child) = pager {
-                            use std::io::Write;
-                            let _ = child.stdin.as_mut().unwrap().write_all(output.as_bytes());
-                            let _ = child.wait();
-                            "".to_string()
-                        } else {
-                            output
-                        }
-                    } else {
-                        output
-                    }
+                    // Always return full output - client can pipe to pager if needed
+                    output
                 }
             } else {
                 "Error accessing queue\n".to_string()
diff --git a/src/queue.rs b/src/queue.rs
index db329c6..f556ed3 100644
--- a/src/queue.rs
+++ b/src/queue.rs
@@ -184,24 +184,29 @@ impl Queue {
 
     fn restore_from_original(&mut self) {
         if self.original_tracks.is_empty() {
+            eprintln!("DEBUG: original_tracks empty");
             self.shuffled_indices.clear();
             return;
         }
 
         let current_pos = self.position;
+        let indices_len = self.shuffled_indices.len().min(10);
+        eprintln!("DEBUG restore: current_pos={}, tracks.len={}, shuffled_indices={:?}",
+            current_pos, self.tracks.len(), &self.shuffled_indices[..indices_len]);
 
         // Find which tracks have been played (positions 0..=current_pos in shuffled order)
-        // These are tracks whose shuffled_indices value is <= current_pos
         let mut played_track_paths: Vec<std::path::PathBuf> = Vec::new();
         for i in 0..=current_pos {
-            if let Some(&idx) = self.shuffled_indices.get(i) {
-                if let Some(track) = self.tracks.get(idx) {
-                    played_track_paths.push(track.path.clone());
-                }
+            if let Some(&idx) = self.shuffled_indices.get(i)
+                && let Some(track) = self.tracks.get(idx)
+            {
+                eprintln!("DEBUG: played track at shuffled pos {} -> track idx {} = {:?}",
+                    i, idx, track.path.file_name());
+                played_track_paths.push(track.path.clone());
             }
         }
 
-        // Keep the played tracks in their current order (shuffled order)
+        // Keep the played tracks in their current order
         let mut new_tracks: Vec<Track> = Vec::new();
         for path in &played_track_paths {
             if let Some(track) = self.tracks.iter().find(|t| &t.path == path) {
@@ -209,14 +214,18 @@ impl Queue {
             }
         }
 
+        eprintln!("DEBUG: kept {} played tracks", new_tracks.len());
+
         // Add remaining tracks from original in original order
-        for orig_track in &self.original_tracks {
+        for (i, orig_track) in self.original_tracks.iter().enumerate() {
             let is_played = played_track_paths.iter().any(|p| p == &orig_track.path);
             if !is_played {
+                eprintln!("DEBUG: adding unplayed from original idx {}: {:?}", i, orig_track.path.file_name());
                 new_tracks.push(orig_track.clone());
             }
         }
 
+        eprintln!("DEBUG: final tracks.len={}", new_tracks.len());
         self.tracks = new_tracks;
         self.position = current_pos;
         self.shuffled_indices.clear();