fix(app): resolve the playing item through the owner (#511)

# Summary

The four actions on "the item playing now" (jump to album `a`, jump to
artist `A`, jump to context `o`, add the playing track to a playlist
`w`/`W`) read the cached Spotify playback context directly. While a
decoded source (Local Files, Subsonic, Qobuz, Internet Radio, YouTube)
or the native queue slot owns the sink, that context names the
*suspended* Spotify track, so the keys fetched or staged the wrong item:
with a Qobuz track audible, `a` opened the suspended track's album with
a real `albums/{id}/tracks` request, and `W` offered to add a song the
user was not hearing to a Spotify playlist.

They now resolve through one `App::playing_item()` in
`core/app/playback_routing.rs`, which folds `playback_owner()` and the
queue slot into one answer, the way Like already did. Like goes through
the same resolver, so its own predicate and
`queue_now_spotify_track_uri` are gone. A queued Spotify track resolves
through the slot: its URI for the picker, its album id (or the album
lookup from the track id when the slot track carries none), its first
artist. A decoded owner answers with a status message.

A new ratchet counter, `direct_playback_context_reads`, counts every
read of `App::current_playback_context` outside the ownership resolver
and the snapshot builder, pins at 93 (97 before this PR), and may only
fall.

Deliberate behaviour changes:

1. With a decoded source or a decoded queue item playing, the five keys
show a status message instead of acting on the suspended Spotify track.
2. A queued Spotify track now jumps to its own album and artist and
stages itself in the picker. `o` on a queued track says the slot has no
play context.
3. The three jump keys say "Nothing is playing" where they were silent
(no session, no item, or no context). A context with no item (an ad
plays) still opens.
4. Jump to artist on a Spotify track with no artist id says so instead
of doing nothing.

The copy-URL keys keep their handler-side guard and still refuse a
queued Spotify track; converting them needs the resolver outside
`core/app/` and is a follow-up.

# Testing

- `cargo fmt --all -- --check`
- `cargo clippy -- -D warnings` on slim, headless, headless-streaming,
mcp-only, ai-dj-only, default, and the Windows stand-in for all-sources
(`audio-viz-cpal,windows-media` in place of `audio-viz,mpris`): clean.
- `cargo test` on slim (953), headless (588), mcp-only (1076),
ai-dj-only (1230), default (1260), five sources without cover-art (1730,
plus the pre-existing Windows-only `uri_round_trip` failure).
- `tools/check_gates_ratchet.sh main`: ok.
`direct_playback_context_reads` new at 93, `test_attribute_total` 1816
-> 1826, the rest unchanged.
- New tests: the queue slot beats the suspended context for album,
artist, context and the picker; the album lookup fallback; no context
and a context without an item; a pure test over all five owners; the
counter matcher.
- Not run here: the Linux `all-sources` leg and macOS.

# Additional notes

Follow-ups, not in this PR: under native streaming with a client-side
shuffle session or a direct URI-list load,
`current_playback_context.context` is `None` or stale, so `o` can open
the wrong context; the copy-URL asymmetry above; the stale Like clause
in the playbar-controls comment in `tui/ui/player.rs`.

---
<sub>💬 Questions or want to chat with other contributors? Join the
[spotatui Discord](https://spotatui.com/discord).</sub>


<!-- This is an auto-generated comment: release notes by coderabbit.ai
-->
## Summary by CodeRabbit

- **New Features**
- Jump-to-album, artist, and context actions now correctly handle queued
Spotify tracks.
- Playlist and save actions use the currently playing queued track when
applicable.
- Actions provide clear status messages when nothing is playing or the
source is not Spotify.

- **Bug Fixes**
- Improved track resolution across native queue and Spotify playback,
preventing stale playback information.

- **Documentation**
- Updated the unreleased changelog and playback guidance to reflect
source-aware playback actions.
<!-- end of auto-generated comment: release notes by coderabbit.ai -->

Author: LargeModGames

.github/copilot-instructions.md

@@ -217,8 +217,12 @@ session exists.
   librespot - the native flag stays true, so driving librespot directly resumes
   the wrong player.
 - While the native queue slot owns the sink, `current_playback_context` names the
-  *suspended* context's track; resolve track-level actions through
-  `queue_now_spotify_track_uri()` / `queue_now_track()`.
+  *suspended* context's track. Inside `core/app/`, resolve the playing *track*
+  through `App::playing_item()` (`core/app/playback_routing.rs`): it answers
+  with the slot's `TrackInfo` (`uri`, `album_id`, `artist_refs`; a slot has
+  no play context) and refuses a decoded owner. Outside `core/app/` read the
+  `PlaybackSnapshot` (`infra/media_metadata.rs`), never the field:
+  `direct_playback_context_reads` counts every other reader and may only fall.
 - Radio is in `active_decoded_source` but deliberately out of
   `active_queueable_decoded_source` (repeat/shuffle) and
   `active_source_position_ms` (seek).

AGENTS.md

@@ -219,8 +219,12 @@ session exists.
   librespot - the native flag stays true, so driving librespot directly resumes
   the wrong player.
 - While the native queue slot owns the sink, `current_playback_context` names the
-  *suspended* context's track; resolve track-level actions through
-  `queue_now_spotify_track_uri()` / `queue_now_track()`.
+  *suspended* context's track. Inside `core/app/`, resolve the playing *track*
+  through `App::playing_item()` (`core/app/playback_routing.rs`): it answers
+  with the slot's `TrackInfo` (`uri`, `album_id`, `artist_refs`; a slot has
+  no play context) and refuses a decoded owner. Outside `core/app/` read the
+  `PlaybackSnapshot` (`infra/media_metadata.rs`), never the field:
+  `direct_playback_context_reads` counts every other reader and may only fall.
 - Radio is in `active_decoded_source` but deliberately out of
   `active_queueable_decoded_source` (repeat/shuffle) and
   `active_source_position_ms` (seek).

CHANGELOG.md

@@ -10,6 +10,8 @@
 
 ### Fixed
 
+- **The jump and add-to-playlist keys follow the track that plays**: with a Spotify track playing from the cross-source queue, jump to album (`a`), jump to artist (`A`) and add the playing track to a playlist (`w`/`W`) acted on the track of the *suspended* Spotify context, so they opened the album, the artist and the picker for a song you were not hearing; they now use the queued track itself, and jump to context (`o`) says the queue slot has no play context. Under Local Files, Subsonic, Internet Radio, YouTube or Qobuz those five keys (`a`, `A`, `o`, `w`, `W`) say they need a Spotify track playing instead of acting on the suspended one, and with nothing playing the three jump keys say so instead of doing nothing. Like (`F`) already followed the queued track and keeps doing so; it now shares the same resolution.
+
 - **Spotify's rate limit no longer crashes spotatui at startup**: with a cached login, startup verifies the token with one `/me` request, and that request went straight through rspotify with none of the pacing and `Retry-After` retries every other Spotify call gets. A 429 there ended the process with `Error: http error: status code 429 Too Many Requests` before the UI existed, and relaunching only added more unpaced hits on a rate limit that is shared by everyone using the same client ID. The check now goes through the same paced, retrying request path as the rest of the app, and when Spotify still answers with anything other than a rejected token (a rate limit that outlasts the retries, an outage, no network) spotatui keeps the cached token and starts instead of quitting; the native-streaming account check asks again with its own retries ([#504](https://github.com/LargeModGames/spotatui/issues/504)).
 
 - **Logging in to Spotify no longer fails with "Unable to connect" when the browser was not already running**: both login flows (the startup wizard and `d` then Spotify in the app) opened the browser first and only then started listening for the OAuth redirect on `127.0.0.1:8989`. On Linux desktops where `xdg-open` runs the browser in the foreground (Hyprland and other sessions it does not recognise), a browser that was not already open kept that launch call from returning until the browser was closed, so the listener never started and the redirect landed on a closed port; inside the app, the network layer was stuck for the same time. The listener is now bound before the browser opens, and every browser launch (Spotify login, Qobuz login, the listening recap) is detached so a launcher that waits can never stall spotatui.

CLAUDE.md

@@ -219,8 +219,12 @@ session exists.
   librespot - the native flag stays true, so driving librespot directly resumes
   the wrong player.
 - While the native queue slot owns the sink, `current_playback_context` names the
-  *suspended* context's track; resolve track-level actions through
-  `queue_now_spotify_track_uri()` / `queue_now_track()`.
+  *suspended* context's track. Inside `core/app/`, resolve the playing *track*
+  through `App::playing_item()` (`core/app/playback_routing.rs`): it answers
+  with the slot's `TrackInfo` (`uri`, `album_id`, `artist_refs`; a slot has
+  no play context) and refuses a decoded owner. Outside `core/app/` read the
+  `PlaybackSnapshot` (`infra/media_metadata.rs`), never the field:
+  `direct_playback_context_reads` counts every other reader and may only fall.
 - Radio is in `active_decoded_source` but deliberately out of
   `active_queueable_decoded_source` (repeat/shuffle) and
   `active_source_position_ms` (seek).

src/core/action/mod.rs

@@ -259,19 +259,20 @@ pub enum Action {
     track_id: Option<String>,
     track_name: String,
   },
-  /// The picker for the item playing now, resolved at apply time.
+  /// The picker for the item playing now, resolved through the ownership
+  /// order at apply time.
   OpenAddPlayingTrackDialog,
   /// Stage a remove-track-from-playlist confirmation for the track table's
   /// current selection; resolved from the selection at apply time.
   OpenRemoveTrackDialog,
-  /// Open the album page of the item that is playing now; resolved from the
-  /// current playback context at apply time (episodes open their show).
+  /// Open the album page of the item that is playing now; resolved through
+  /// the ownership order at apply time (episodes open their show).
   JumpToAlbum,
   /// Open the album list of the first artist of the track that is playing
-  /// now; resolved from the current playback context at apply time.
+  /// now; resolved through the ownership order at apply time.
   JumpToArtist,
   /// Open the context (album/artist/playlist) that playback runs in;
-  /// resolved from the current playback context at apply time.
+  /// resolved through the ownership order at apply time.
   JumpToContext,
   /// Copy a share URL for the item playing now to the clipboard; a silent
   /// no-op without playback or a clipboard.

src/core/action/tests.rs

@@ -345,12 +345,13 @@ fn jump_to_album_opens_the_current_tracks_album() {
 }
 
 #[test]
-fn jump_to_album_without_playback_is_a_noop() {
+fn jump_to_album_without_playback_reports_nothing_playing() {
   let (mut app, rx) = app_with_channel();
 
   app.apply(Action::JumpToAlbum);
 
   assert!(rx.try_recv().is_err(), "expected no IoEvent dispatched");
+  assert_eq!(app.status_message(), Some(NOTHING_PLAYING_STATUS));
 }
 
 #[test]

src/core/app/library.rs

@@ -490,42 +490,18 @@ impl App {
 
   /// Save or unsave the item playing right now, through the ownership order.
   pub fn toggle_save_current_item(&mut self) {
-    let queue_now_is_spotify = self.queue_now_is_spotify();
-    let queued_spotify_track_uri = queue_now_is_spotify
-      .then(|| self.queue_now_spotify_track_uri())
-      .flatten();
-
-    if spotify_context_is_suspended(
-      self.queue_owns_playback(),
-      queue_now_is_spotify,
-      self.active_decoded_source(),
-    ) {
-      self.set_status_message("The current playback source cannot be liked", 4);
-      return;
-    }
-
-    // A queued Spotify track plays via a direct `player.load` outside the Spirc
-    // context, so the cached playback context still names the suspended context's
-    // track — resolve the queue slot's own track instead of falling through.
-    if queue_now_is_spotify {
-      match queued_spotify_track_uri {
-        Some(uri) => self.dispatch(IoEvent::ToggleSaveTrack(uri)),
-        None => self.set_status_message("The current playback source cannot be liked", 4),
-      }
-      return;
-    }
-
-    let uri = match self
-      .current_playback_context
-      .as_ref()
-      .and_then(|context| context.item.as_ref())
-    {
-      Some(PlayableItem::Track(track)) => track.id.as_ref().map(|id| id.uri()),
-      Some(PlayableItem::Episode(episode)) => Some(episode.id.uri()),
-      _ => None,
+    const REFUSED: &str = "The current playback source cannot be liked";
+    let uri = match self.playing_item() {
+      PlayingItem::Spotify(PlayableItem::Track(track)) => Ok(track.id.as_ref().map(|id| id.uri())),
+      PlayingItem::Spotify(PlayableItem::Episode(episode)) => Ok(Some(episode.id.uri())),
+      PlayingItem::Spotify(_) | PlayingItem::Nothing => Ok(None),
+      PlayingItem::QueuedSpotify(track) => track.uri.clone().ok_or(REFUSED).map(Some),
+      PlayingItem::NotSpotify => Err(REFUSED),
     };
-    if let Some(uri) = uri {
-      self.dispatch(IoEvent::ToggleSaveTrack(uri));
+    match uri {
+      Ok(Some(uri)) => self.dispatch(IoEvent::ToggleSaveTrack(uri)),
+      Ok(None) => {}
+      Err(status) => self.set_status_message(status, 4),
     }
   }
 
@@ -615,18 +591,6 @@ impl App {
   }
 }
 
-/// Whether Like must not consult the cached Spotify playback context. A queue
-/// slot playing a *decoded* item (or any decoded per-source playback) suspends
-/// the context; a queue slot playing a *Spotify* track stays eligible — it is
-/// liked via the slot's own track, never the cached context.
-fn spotify_context_is_suspended(
-  queue_owns_playback: bool,
-  queue_now_is_spotify: bool,
-  decoded_source_active: bool,
-) -> bool {
-  (queue_owns_playback && !queue_now_is_spotify) || decoded_source_active
-}
-
 #[cfg(test)]
 mod tests {
   use super::*;
@@ -699,17 +663,6 @@ mod tests {
     );
   }
 
-  #[test]
-  fn non_spotify_playback_cannot_use_cached_spotify_item_for_like() {
-    // A decoded queue slot or any decoded per-source playback suspends Like.
-    assert!(spotify_context_is_suspended(true, false, false));
-    assert!(spotify_context_is_suspended(false, false, true));
-    // A queue slot playing a *Spotify* track stays eligible.
-    assert!(!spotify_context_is_suspended(true, true, false));
-    // Plain Spotify context playback.
-    assert!(!spotify_context_is_suspended(false, false, false));
-  }
-
   #[cfg(feature = "streaming")]
   mod queued_spotify_like {
     use super::*;

src/core/app/playback_routing.rs

@@ -22,7 +22,55 @@ pub enum PlaybackOwner {
   None,
 }
 
+/// The item a track-level action on "what is playing now" can act on.
+pub(super) enum PlayingItem<'a> {
+  /// Spotify owns playback and the cached context names the item. Under
+  /// native streaming it lags the player after a skip until the next poll.
+  Spotify(&'a PlayableItem),
+  /// A Spotify track plays through the native queue slot; the cached context
+  /// names the suspended context's track, so the slot's own track is the item.
+  QueuedSpotify(&'a TrackInfo),
+  /// A decoded source or a decoded queue item owns the sink.
+  NotSpotify,
+  /// No owner, or a Spotify owner with no item.
+  Nothing,
+}
+
+/// The pure half of [`App::playing_item`], so every owner is testable without
+/// an audio device.
+fn resolve_playing_item<'a>(
+  owner: PlaybackOwner,
+  slot_track: Option<&'a TrackInfo>,
+  slot_is_spotify: bool,
+  cached_item: Option<&'a PlayableItem>,
+) -> PlayingItem<'a> {
+  match owner {
+    PlaybackOwner::Queue => match slot_track {
+      Some(track) if slot_is_spotify => PlayingItem::QueuedSpotify(track),
+      _ => PlayingItem::NotSpotify,
+    },
+    PlaybackOwner::Decoded => PlayingItem::NotSpotify,
+    PlaybackOwner::NativeSpotify | PlaybackOwner::Spotify => {
+      cached_item.map_or(PlayingItem::Nothing, PlayingItem::Spotify)
+    }
+    PlaybackOwner::None => PlayingItem::Nothing,
+  }
+}
+
 impl App {
+  /// Resolve the item playing now through the ownership order.
+  pub(super) fn playing_item(&self) -> PlayingItem<'_> {
+    resolve_playing_item(
+      self.playback_owner(),
+      self.queue_now_track(),
+      self.queue_now_is_spotify(),
+      self
+        .current_playback_context
+        .as_ref()
+        .and_then(|context| context.item.as_ref()),
+    )
+  }
+
   pub(crate) fn playback_owner(&self) -> PlaybackOwner {
     if self.queue_owns_playback() {
       return PlaybackOwner::Queue;
@@ -396,6 +444,37 @@ mod tests {
     assert!(app.active_decoded_player().is_none());
   }
 
+  #[test]
+  fn playing_item_follows_the_owner() {
+    let slot = queue_track(Some("spotify:track:queued"), "Queued");
+    let cached = PlayableItem::Track(full_track("0000000000000000000001", "Cached"));
+
+    assert!(matches!(
+      resolve_playing_item(PlaybackOwner::Decoded, None, false, Some(&cached)),
+      PlayingItem::NotSpotify
+    ));
+    assert!(matches!(
+      resolve_playing_item(PlaybackOwner::Queue, Some(&slot), false, Some(&cached)),
+      PlayingItem::NotSpotify
+    ));
+    assert!(matches!(
+      resolve_playing_item(PlaybackOwner::Queue, Some(&slot), true, Some(&cached)),
+      PlayingItem::QueuedSpotify(track) if track.name == "Queued"
+    ));
+    assert!(matches!(
+      resolve_playing_item(PlaybackOwner::Spotify, None, false, Some(&cached)),
+      PlayingItem::Spotify(PlayableItem::Track(track)) if track.name == "Cached"
+    ));
+    assert!(matches!(
+      resolve_playing_item(PlaybackOwner::NativeSpotify, None, false, None),
+      PlayingItem::Nothing
+    ));
+    assert!(matches!(
+      resolve_playing_item(PlaybackOwner::None, None, false, Some(&cached)),
+      PlayingItem::Nothing
+    ));
+  }
+
   #[test]
   fn playback_owner_is_none_without_a_session() {
     let (app, _rx) = session_free_app();

src/core/app/playlists.rs

@@ -239,25 +239,28 @@ impl App {
     self.begin_add_track_to_playlist_flow(track_id, track_name);
   }
 
-  /// Open the add-to-playlist picker for the item playing now. Reads only
-  /// `current_playback_context`, so a native queue slot stages the suspended
-  /// context's track.
+  /// Open the add-to-playlist picker for the item playing now, through the
+  /// ownership order. A queued Spotify track stages the slot's own track.
   pub fn begin_add_playing_track_to_playlist_flow(&mut self) {
-    match self
-      .current_playback_context
-      .as_ref()
-      .and_then(|context| context.item.as_ref())
-    {
-      Some(PlayableItem::Track(track)) => {
+    match self.playing_item() {
+      PlayingItem::Spotify(PlayableItem::Track(track)) => {
         let track_id = track.id.as_ref().map(|id| id.uri());
         let name = track.name.clone();
         self.begin_add_track_to_playlist_flow(track_id, name);
       }
-      Some(PlayableItem::Episode(_)) => {
+      PlayingItem::Spotify(PlayableItem::Episode(_)) => {
         self.set_status_message("Only tracks can be added to playlists".to_string(), 4);
       }
-      Some(_) => {}
-      None => {
+      PlayingItem::Spotify(_) => {}
+      PlayingItem::QueuedSpotify(track) => {
+        let track_id = track.uri.clone();
+        let name = track.name.clone();
+        self.begin_add_track_to_playlist_flow(track_id, name);
+      }
+      PlayingItem::NotSpotify => {
+        self.set_status_message("Add to playlist needs a Spotify track playing", 4);
+      }
+      PlayingItem::Nothing => {
         self.set_status_message("No track currently playing".to_string(), 4);
       }
     }
@@ -410,6 +413,36 @@ impl App {
 mod tests {
   use super::*;
 
+  #[cfg(feature = "streaming")]
+  #[test]
+  fn add_playing_track_stages_the_queued_track_not_the_suspended_one() {
+    use crate::core::app::test_support::*;
+    let (tx, rx) = channel();
+    let mut app = App::new(tx, UserConfig::new(), Some(SystemTime::now()));
+    app.active_source = Source::YouTube;
+    app.youtube_playlists = vec![PlaylistInfo {
+      uri: "youtube:playlist:y1".to_string(),
+      ..playlist_info("y1", "Local List", "owner", false)
+    }];
+    app.current_playback_context = Some(playing_track_context(full_track(
+      "0000000000000000000001",
+      "Suspended",
+    )));
+    app.queue_now = Some(crate::infra::queue::QueueNowPlaying::Spotify {
+      track: queue_track(Some("spotify:track:queued"), "Queued"),
+    });
+
+    app.begin_add_playing_track_to_playlist_flow();
+
+    let pending = app
+      .pending_playlist_track_add
+      .as_ref()
+      .expect("staged for the picker");
+    assert_eq!(pending.track_id, "spotify:track:queued");
+    assert_eq!(pending.track_name, "Queued");
+    assert!(rx.try_recv().is_err());
+  }
+
   #[test]
   fn editable_playlists_include_owned_and_collaborative_only() {
     let (tx, _rx) = channel();

src/core/app/queue.rs

@@ -150,32 +150,6 @@ impl App {
     }
   }
 
-  /// The Spotify URI of the track playing through the queue slot, when the slot
-  /// holds a native-streamed Spotify track. `None` for a decoded slot, an empty
-  /// slot, or a slot whose track carries no URI. This is the resolution target
-  /// for track-level actions (e.g. Like) while the slot owns playback: the
-  /// cached `current_playback_context` still names the suspended context's
-  /// track, so it must not be consulted.
-  pub(crate) fn queue_now_spotify_track_uri(&self) -> Option<String> {
-    #[cfg(feature = "streaming")]
-    {
-      match self.queue_now.as_ref()? {
-        #[cfg(any(
-          feature = "local-files",
-          feature = "subsonic",
-          feature = "qobuz",
-          feature = "youtube"
-        ))]
-        QueueNowPlaying::Decoded(_) => None,
-        QueueNowPlaying::Spotify { track } => track.uri.clone(),
-      }
-    }
-    #[cfg(not(feature = "streaming"))]
-    {
-      None
-    }
-  }
-
   /// The queue slot's player when it is playing a *decoded* queued track (local /
   /// Subsonic / Qobuz / YouTube). `None` for a Spotify slot or an empty slot. Gated
   /// on exactly those four sources: they are the decoded ones a queue item can