diff --git a/crates/qbz-core/src/core.rs b/crates/qbz-core/src/core.rs
index 2b6fbafec..880de3afd 100644
--- a/crates/qbz-core/src/core.rs
+++ b/crates/qbz-core/src/core.rs
@@ -3877,6 +3877,7 @@ mod tests {
             image: Default::default(),
             label: None,
             genre: None,
+            artist: None,
         });
         t
     }
diff --git a/crates/qbz-models/src/types.rs b/crates/qbz-models/src/types.rs
index e36b28799..f31249dae 100644
--- a/crates/qbz-models/src/types.rs
+++ b/crates/qbz-models/src/types.rs
@@ -672,6 +672,13 @@ pub struct AlbumSummary {
     pub label: Option<Label>,
     /// Genre (when returned, e.g. on favorites track album objects).
     pub genre: Option<Genre>,
+    /// The album's MAIN artist, when the track's embedded album carries it
+    /// (search results and favourites do — captured
+    /// `qobuz-api/search-results-response.json`). Distinct from the track's
+    /// `performer`, which is who is credited on THAT track; the artist page's
+    /// "In library" tab admits a track through either.
+    #[serde(default)]
+    pub artist: Option<Artist>,
 }
 
 /// Album model
diff --git a/crates/qbz-offline-cache/src/purchases_service.rs b/crates/qbz-offline-cache/src/purchases_service.rs
index 5e08c9f38..c6ae66df4 100644
--- a/crates/qbz-offline-cache/src/purchases_service.rs
+++ b/crates/qbz-offline-cache/src/purchases_service.rs
@@ -1594,6 +1594,7 @@ mod tests {
                 image: Default::default(),
                 label: None,
                 genre: None,
+                artist: None,
             }),
             ..Default::default()
         }
@@ -2011,6 +2012,7 @@ mod tests {
                 image: Default::default(),
                 label: None,
                 genre: None,
+                artist: None,
             }),
             ..Default::default()
         }
@@ -2948,6 +2950,7 @@ mod entitlement_index_tests {
                     image: Default::default(),
                     label: None,
                     genre: None,
+                    artist: None,
                 }),
                 ..Default::default()
             }],
diff --git a/crates/qbz-playlist-import/src/match_qobuz.rs b/crates/qbz-playlist-import/src/match_qobuz.rs
index 7f3263d52..65f5f07a7 100644
--- a/crates/qbz-playlist-import/src/match_qobuz.rs
+++ b/crates/qbz-playlist-import/src/match_qobuz.rs
@@ -428,6 +428,7 @@ mod tests {
             image: ImageSet::default(),
             label: None,
             genre: None,
+            artist: None,
         }
     }
 
diff --git a/crates/qbz-qt/src/artist_qt.rs b/crates/qbz-qt/src/artist_qt.rs
index b462e77a1..4f539044d 100644
--- a/crates/qbz-qt/src/artist_qt.rs
+++ b/crates/qbz-qt/src/artist_qt.rs
@@ -46,6 +46,7 @@ use serde_json::json;
 
 use crate::album_qt::{truncate_words, AlbumCardData, TrackRow};
 use crate::home_qt;
+use crate::library_qt::FeedItem;
 
 pub const RELEASE_PAGE_SIZE: u32 = 20;
 
@@ -358,6 +359,15 @@ pub struct ArtistViewData {
     pub is_blacklisted: bool,
     #[serde(rename = "libraryCount")]
     pub library_count: i64,
+    /// The user's OWN rows for this artist — favourites ∪ purchases, one row
+    /// per entity (`library_qt::artist_library_items`, contract §3). Published
+    /// INSIDE this document rather than read off `QbzLibrary.libraryJson` by
+    /// the view: the view used to `JSON.parse` the whole ~10k-row feed per
+    /// binding evaluation, and this is also what lets a heart change
+    /// (`apply_favorite_change`) and a late feed load (`refresh_library_items`)
+    /// repaint the tab through `publish_patch`, the page's one transport.
+    #[serde(rename = "libraryItems")]
+    pub library_items: Vec<FeedItem>,
     #[serde(rename = "topTracks")]
     pub top_tracks: Vec<TrackRow>,
     #[serde(rename = "appearsOn")]
@@ -835,20 +845,19 @@ fn map_artist(page: PageArtistResponse) -> ArtistViewData {
         });
     }
 
-    // The library COUNT is feed-only by nature (it counts owned items), but the
-    // follow state must not be: the feed is empty until the Library view is
-    // opened, so this drew an un-followed heart on artists the user follows —
-    // and `toggle_favorite` then read the same false and re-added the follow.
-    // `library_qt::is_favorite` checks the favourite-id cache first.
-    let library_count = crate::library_qt::with_library(|d| {
-        d.feed
-            .iter()
-            .filter(|i| {
-                (i.kind == "album" || i.kind == "track") && i.artist_id == page.id.to_string()
-            })
-            .count() as i64
-    })
-    .unwrap_or(0);
+    // The library rows are feed-only by nature (they ARE the owned items), but
+    // the follow state must not be: the feed is empty until the Library view
+    // is opened, so this drew an un-followed heart on artists the user follows
+    // — and `toggle_favorite` then read the same false and re-added the
+    // follow. `library_qt::is_favorite` checks the favourite-id cache first.
+    //
+    // The feed's coldness is handled one level up: `main::open_artist` warms
+    // it in the background and `refresh_library_items` repaints this pair
+    // when it lands, so a fresh session (or a fresh account) no longer opens
+    // every artist with an invisible "In library" toggle.
+    let library_items = crate::library_qt::artist_library_items(&page.id.to_string());
+    let library_count = library_items.len() as i64;
+    log_library_membership(&page.id.to_string(), &library_items);
     let is_following = crate::library_qt::is_favorite("artist", &page.id.to_string());
 
     ArtistViewData {
@@ -870,6 +879,7 @@ fn map_artist(page: PageArtistResponse) -> ArtistViewData {
         is_pinned: crate::sidebar_qt::is_pinned("artist", &page.id.to_string()),
         is_blacklisted: crate::artist_blacklist::is_blacklisted(page.id),
         library_count,
+        library_items,
         top_tracks,
         appears_on,
         last_release,
@@ -1097,6 +1107,93 @@ pub(crate) fn stash_is_for(artist_id: &str) -> bool {
     }
 }
 
+/// `(generation, artist id)` of the page on screen, or `None` when no artist
+/// document is stashed.
+fn stashed_page() -> Option<(u64, String)> {
+    let guard = ARTIST_DOC.lock().ok()?;
+    let (generation, doc) = guard.as_ref()?;
+    let id = doc.get("id").and_then(|v| v.as_str())?.to_string();
+    Some((*generation, id))
+}
+
+// ==================== "In library" tab: live membership ====================
+//
+// The tab's rows travel inside the artist document (`ArtistViewData::
+// library_items`). Two things move them after the page is built, and both
+// come through `publish_patch` so the generation guard applies:
+//
+//   * the Library feed landing AFTER the page opened (`main::open_artist`
+//     warms it; `main::reload_library` calls `refresh_library_items` when it
+//     is published), and
+//   * a heart settling on an album / track (`main::emit_library_favorite` ->
+//     `apply_favorite_change`), after `library_qt::reconcile_qobuz_favorite`
+//     has inserted or removed the feed row.
+//
+// Both recompute the WHOLE list off the feed rather than patching one row:
+// the rule (contract §3 — purchases ∪ favourites, one row per entity, the
+// purchase row representative) is easier to keep in one place than to
+// replay incrementally, and the scan is a single pass over the feed.
+
+/// Recompute the open page's library rows from the cached feed and republish
+/// `libraryItems` + `libraryCount`. No-op without an artist on screen or
+/// before the Library has ever loaded (the count then stays at what the page
+/// was built with — 0 on a cold session — until the feed lands and this runs
+/// again).
+pub(crate) fn refresh_library_items() {
+    let Some((generation, artist_id)) = stashed_page() else {
+        return;
+    };
+    if crate::library_qt::with_library(|_| ()).is_none() {
+        return;
+    }
+    let items = crate::library_qt::artist_library_items(&artist_id);
+    log_library_membership(&artist_id, &items);
+    let count = items.len() as i64;
+    let items_json = match serde_json::to_value(&items) {
+        Ok(v) => v,
+        Err(e) => {
+            log::warn!("[qbz-qt] artist library rows serialize failed: {e}");
+            return;
+        }
+    };
+    publish_patch(generation, move |doc| {
+        if let Some(obj) = doc.as_object_mut() {
+            obj.insert("libraryItems".into(), items_json);
+            obj.insert("libraryCount".into(), json!(count));
+        }
+    });
+}
+
+/// A heart settled on an album or track: the tab's membership may have
+/// changed (a new favourite joins, a cleared one leaves unless it is also a
+/// purchase). `main::emit_library_favorite` is the one door, the same fan-out
+/// `home_qt` / `search_qt` / `recommendations_qt` hang off; the artist page was
+/// listed there as "NOT yet covered".
+pub(crate) fn apply_favorite_change(kind: &str, _id: &str, _value: bool) {
+    if kind == "track" || kind == "album" {
+        refresh_library_items();
+    }
+}
+
+/// Contract §5 discriminator, kept as `debug` once the round closed: how the
+/// open artist's owned rows split by kind and by which id matched. Read it
+/// with `RUST_LOG=qbz_qt=debug` when an artist's tab looks short.
+fn log_library_membership(artist_id: &str, items: &[FeedItem]) {
+    if !log::log_enabled!(log::Level::Debug) {
+        return;
+    }
+    let tracks = items.iter().filter(|i| i.kind == "track").count();
+    let albums = items.len() - tracks;
+    let by_album_artist = items
+        .iter()
+        .filter(|i| i.kind == "track" && i.artist_id != artist_id)
+        .count();
+    log::debug!(
+        "[qbz-qt] artist {artist_id} in-library: {tracks} track(s) ({by_album_artist} via album \
+         artist), {albums} album(s)"
+    );
+}
+
 /// Artist page per-section sort — the port of `crates/qbz/src/artist.rs:1178-1210`
 /// `resort_section` ("Re-sort one release bucket in place […] and persist the
 /// choice"), reached from `QbzArtist.setSectionSort` (artist_bridge.rs).
@@ -1830,3 +1927,20 @@ async fn load_mb_discovery(
         .collect();
     Ok((response.primary_tag, rows))
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    /// THE #737 CONTRACT: `top_queue` answers for the POPULAR list only. An
+    /// id it does not hold does not fail — it starts that list at row 0. So
+    /// no caller may hand it an id from any other list (the "In library" tab
+    /// routes through `library_qt::play_from_visible` instead).
+    #[test]
+    fn top_queue_starts_at_zero_for_a_foreign_id() {
+        TOP_QUEUE.lock().unwrap().clear();
+        let (queue, start) = top_queue(Some(424242));
+        assert!(queue.is_empty());
+        assert_eq!(start, 0);
+    }
+}
diff --git a/crates/qbz-qt/src/library_qt.rs b/crates/qbz-qt/src/library_qt.rs
index 87fa722c0..1d6eec35d 100644
--- a/crates/qbz-qt/src/library_qt.rs
+++ b/crates/qbz-qt/src/library_qt.rs
@@ -64,6 +64,14 @@ pub struct FeedItem {
     pub album: String,
     #[serde(rename = "albumId")]
     pub album_id: String,
+    /// Track rows only: the id of the ALBUM's main artist, beside the
+    /// performer id in `artist_id`. A favourited track is a member of an
+    /// artist's "In library" tab through EITHER — `artist_id` alone is the
+    /// track's performer, which on features, interpreters and re-credited
+    /// remasters is not the artist whose page is open (issue #737 round,
+    /// contract §5). Skipped when empty so album/artist rows pay nothing.
+    #[serde(default, rename = "albumArtistId", skip_serializing_if = "String::is_empty")]
+    pub album_artist_id: String,
     #[serde(rename = "imageUrl")]
     pub image_url: String,
     /// Stable artwork key (`{kind}:{id}`) — library_all.rs `feed_key`.
@@ -459,6 +467,12 @@ fn map_track(track: Track) -> FeedItem {
         .and_then(|a| a.genre.as_ref())
         .map(|g| g.name.clone())
         .unwrap_or_default();
+    let album_artist_id = track
+        .album
+        .as_ref()
+        .and_then(|a| a.artist.as_ref())
+        .map(|x| x.id.to_string())
+        .unwrap_or_default();
     let (artist, artist_id) = track
         .performer
         .map(|p| (p.name, p.id.to_string()))
@@ -474,6 +488,7 @@ fn map_track(track: Track) -> FeedItem {
         artist_id,
         album,
         album_id,
+        album_artist_id,
         genre,
         duration: mmss(track.duration),
         quality_tier: home_qt::quality_tier_from_depth(track.maximum_bit_depth).to_string(),
@@ -1330,7 +1345,7 @@ async fn fetch_purchases(
         .into_iter()
         .map(|t| {
             // Track row art: full variant (best()) — the thumbnail down-tier was reverted after the 2026-08-15 owner smoke (contract 04 §3).
-            let (img, alb, aid) = t
+            let (img, alb, aid, album_artist_id) = t
                 .album
                 .as_ref()
                 .map(|a| {
@@ -1338,6 +1353,7 @@ async fn fetch_purchases(
                         a.image.best().cloned().unwrap_or_default(),
                         a.title.clone(),
                         a.id.clone(),
+                        a.artist.as_ref().map(|x| x.id.to_string()).unwrap_or_default(),
                     )
                 })
                 .unwrap_or_default();
@@ -1354,6 +1370,7 @@ async fn fetch_purchases(
                 artist_id: t.performer.id.to_string(),
                 album: alb,
                 album_id: aid,
+                album_artist_id,
                 image_url: img,
                 quality_tier: tier.into(),
                 // See `FeedItem::bit_depth` — a purchased TRACK row is a queue
@@ -1698,6 +1715,186 @@ pub(crate) fn set_feed_favorite(kind: &str, id: &str, value: bool) {
     });
 }
 
+// ---------------------------------------------------------------------------
+// Artist page "In library" membership (#737 round, contract §3)
+// ---------------------------------------------------------------------------
+//
+// The artist page lists what the user OWNS of one artist: favourites ∪
+// purchases, with `Library > Albums` / `Library > Tracks` semantics — NOT the
+// `All` feed's. Local / Plex rows never enter (owner ruling 2026-09-04).
+//
+// One representative row per `{kind}:{id}` — the purchase row wins so its
+// quality badge survives — and `is_favorite` on that row answers "is it ALSO
+// hearted", which is what the tab's purchases/favourites switches evaluate
+// (LibraryView.qml:566-590: neither = union, one = that source, both =
+// intersection). `group` on the representative row therefore means
+// "is purchased" and `is_favorite` means "is hearted"; a row can carry both.
+//
+// A track belongs to an artist through its performer OR its album's main
+// artist (`FeedItem::album_artist_id`): the feed's `artist_id` is the
+// performer, and the owner's own screenshot (Megadeth, two hearted Popular
+// Tracks, badge 3) showed hearted tracks dropping out under the
+// performer-only rule.
+
+fn feed_row_is_artist(item: &FeedItem, artist_id: &str) -> bool {
+    item.artist_id == artist_id || item.album_artist_id == artist_id
+}
+
+/// Every album / track of `artist_id` the user owns, deduplicated per entity,
+/// in feed order (newest first — `load_library` merges that way).
+pub(crate) fn artist_library_items(artist_id: &str) -> Vec<FeedItem> {
+    if artist_id.is_empty() {
+        return Vec::new();
+    }
+    with_library(|d| artist_library_items_from(&d.feed, artist_id)).unwrap_or_default()
+}
+
+/// The pure rule behind [`artist_library_items`], over any feed slice.
+fn artist_library_items_from(feed: &[FeedItem], artist_id: &str) -> Vec<FeedItem> {
+    let mut order: Vec<String> = Vec::new();
+    let mut by_key: HashMap<String, FeedItem> = HashMap::new();
+    for item in feed.iter().filter(|i| {
+        (i.kind == "track" || i.kind == "album")
+            && (i.group == "favorites" || i.group == "purchases")
+            && feed_row_is_artist(i, artist_id)
+    }) {
+        let key = feed_key(&item.kind, &item.id);
+        let hearted = item.group == "favorites" || item.is_favorite;
+        match by_key.get_mut(&key) {
+            None => {
+                let mut row = item.clone();
+                row.is_favorite = hearted;
+                by_key.insert(key.clone(), row);
+                order.push(key);
+            }
+            Some(row) => {
+                row.is_favorite |= hearted;
+                // The purchase row is the representative (quality badge,
+                // entitlement); keep the heart it just collected.
+                if item.group == "purchases" && row.group != "purchases" {
+                    let keep_heart = row.is_favorite;
+                    *row = item.clone();
+                    row.is_favorite = keep_heart;
+                }
+            }
+        }
+    }
+    order
+        .into_iter()
+        .filter_map(|k| by_key.remove(&k))
+        .collect()
+}
+
+/// Reconcile the cached feed with a Qobuz heart that just SETTLED, so a
+/// favourite created after `load_library` ran appears in the document and a
+/// cleared one leaves it. Returns whether membership changed (the caller then
+/// republishes the Library document — the same rule `remove_local_favorite_row`
+/// / `insert_local_favorite_row` follow for local hearts).
+///
+/// Why this exists: `set_feed_favorite` only flips `is_favorite` on rows that
+/// are ALREADY in the feed. A track hearted from the artist page had no row,
+/// so the artist page's "In library" count never moved until the next
+/// session — the reference had the same hole and called it "acceptable v1"
+/// (`library_by_artist.rs`); this round closes it.
+///
+/// - `value == true` and no row: ONE `/track/get` or `/album/get`, mapped by
+///   the same producer the full load uses, inserted at the top (newest first).
+///   A failed fetch is logged and skipped — the heart itself already landed.
+/// - `value == false`: the `favorites` rows leave. A `purchases` row for the
+///   same entity STAYS (it is still library) with its heart cleared, which
+///   `set_feed_favorite` already did for every row.
+///
+/// Only Qobuz kinds ride this path; local hearts have their own pair.
+pub(crate) async fn reconcile_qobuz_favorite(
+    runtime: &Arc<AppRuntime<LoggingAdapter>>,
+    kind: &str,
+    id: &str,
+    value: bool,
+) -> bool {
+    if kind != "track" && kind != "album" {
+        return false;
+    }
+    if is_local_feed_id(kind, id) {
+        return false;
+    }
+    // No library snapshot yet: nothing to reconcile, the next load sees the
+    // server state.
+    if with_library(|_| ()).is_none() {
+        return false;
+    }
+    if !value {
+        return with_library_mut(|d| {
+            let before = d.feed.len();
+            d.feed
+                .retain(|i| !(i.group == "favorites" && i.kind == kind && i.id == id));
+            let removed = before - d.feed.len();
+            if removed > 0 {
+                d.counts.all = (d.counts.all - removed as i64).max(0);
+                match kind {
+                    "track" => d.counts.tracks = (d.counts.tracks - 1).max(0),
+                    "album" => d.counts.albums = (d.counts.albums - 1).max(0),
+                    _ => {}
+                }
+            }
+            removed > 0
+        })
+        .unwrap_or(false);
+    }
+    let already = with_library(|d| {
+        d.feed
+            .iter()
+            .any(|i| i.group == "favorites" && i.kind == kind && i.id == id)
+    })
+    .unwrap_or(false);
+    if already {
+        return false;
+    }
+    let row = match fetch_favorite_row(runtime, kind, id).await {
+        Some(row) => row,
+        None => {
+            log::warn!("[qbz-qt] library feed: could not fetch {kind}:{id} after favourite");
+            return false;
+        }
+    };
+    with_library_mut(|d| {
+        d.feed.insert(0, row);
+        d.counts.all += 1;
+        match kind {
+            "track" => d.counts.tracks += 1,
+            "album" => d.counts.albums += 1,
+            _ => {}
+        }
+    });
+    true
+}
+
+/// The catalog row for a freshly hearted entity, mapped by the SAME producer
+/// the full load uses (`map_track` / `map_album`), so a row inserted live and
+/// one fetched at load are indistinguishable downstream.
+async fn fetch_favorite_row(
+    runtime: &Arc<AppRuntime<LoggingAdapter>>,
+    kind: &str,
+    id: &str,
+) -> Option<FeedItem> {
+    match kind {
+        "track" => {
+            let tid = id.parse::<u64>().ok()?;
+            let track = runtime.core().get_track(tid).await.ok()?;
+            let mut row = map_track(track);
+            row.is_favorite = true;
+            Some(row)
+        }
+        "album" => {
+            let album = runtime.core().get_album(id).await.ok()?;
+            let ready = ready_offline_album_track_counts().await;
+            let mut row = map_album(album, ready.get(id).copied().unwrap_or(0));
+            row.is_favorite = true;
+            Some(row)
+        }
+        _ => None,
+    }
+}
+
 /// Reconcile a local-favorite membership change with the cached mixed feed.
 /// In the `all` local scope the live row stays and only its heart changes; in
 /// the `favorites` scope the row itself joins/leaves the document.
@@ -2431,4 +2628,67 @@ mod tests {
         let _ = std::fs::remove_dir_all(&guest);
         let _ = std::fs::remove_dir_all(&account);
     }
+
+    // --- Artist page "In library" membership (#737 round, contract §3) ------
+
+    fn owned(kind: &str, id: &str, group: &str, artist_id: &str, album_artist_id: &str) -> FeedItem {
+        FeedItem {
+            kind: kind.into(),
+            group: group.into(),
+            source: "qobuz".into(),
+            id: id.into(),
+            title: id.into(),
+            artist_id: artist_id.into(),
+            album_artist_id: album_artist_id.into(),
+            is_favorite: group == "favorites",
+            ..Default::default()
+        }
+    }
+
+    /// A hearted track joins through EITHER id: the performer (feed
+    /// `artist_id`) or the album's main artist — the owner's Megadeth rows
+    /// whose performer was not the page's artist.
+    #[test]
+    fn artist_library_matches_performer_or_album_artist() {
+        let feed = vec![
+            owned("track", "1", "favorites", "42", ""),
+            owned("track", "2", "favorites", "7", "42"),
+            owned("track", "3", "favorites", "7", "7"),
+            owned("album", "a", "favorites", "42", ""),
+        ];
+        let ids: Vec<String> = artist_library_items_from(&feed, "42")
+            .into_iter()
+            .map(|i| i.id)
+            .collect();
+        assert_eq!(ids, vec!["1", "2", "a"]);
+    }
+
+    /// Local / Plex rows and the `following` group never enter — the tab is
+    /// `Library > Albums / Tracks`, not `Library > All`.
+    #[test]
+    fn artist_library_excludes_local_and_following() {
+        let mut local = owned("track", "9", "local", "42", "");
+        local.source = "local".into();
+        let feed = vec![local, owned("artist", "42", "following", "42", "")];
+        assert!(artist_library_items_from(&feed, "42").is_empty());
+    }
+
+    /// A purchased album that is also hearted collapses to ONE row — the
+    /// purchase row (its quality badge survives) — carrying the heart; a
+    /// purchase that is not hearted carries none.
+    #[test]
+    fn artist_library_dedups_on_the_purchase_row() {
+        let feed = vec![
+            owned("album", "a", "favorites", "42", ""),
+            owned("album", "a", "purchases", "42", ""),
+            owned("album", "b", "purchases", "42", ""),
+        ];
+        let rows = artist_library_items_from(&feed, "42");
+        assert_eq!(rows.len(), 2);
+        assert_eq!(rows[0].id, "a");
+        assert_eq!(rows[0].group, "purchases");
+        assert!(rows[0].is_favorite);
+        assert_eq!(rows[1].id, "b");
+        assert!(!rows[1].is_favorite);
+    }
 }
diff --git a/crates/qbz-qt/src/main.rs b/crates/qbz-qt/src/main.rs
index 671761e0b..be2e97e96 100644
--- a/crates/qbz-qt/src/main.rs
+++ b/crates/qbz-qt/src/main.rs
@@ -1427,6 +1427,13 @@ pub(crate) fn open_artist(artist_id: String) {
     }
     nav_qt::record("artist");
     *LAST_DETAIL.lock().unwrap() = ("artist".to_string(), artist_id.clone());
+    // Warm the Library feed in the background: the page's "In library" tab is
+    // built off it, and on a cold session (or right after an account switch —
+    // `reset_session_latches`) it was empty until the user happened to visit
+    // Library, so the toggle never mounted. Idempotent through
+    // `LIBRARY_LOADED`; with the feed warm this is a no-op, and when it lands
+    // `reload_library` repaints the open page's rows.
+    load_library_once();
     let runtime = app();
     artist_bridge::ui(move |mut b| {
         // Same as open_album: stale artist until the fetch lands otherwise.
@@ -2956,6 +2963,16 @@ pub(crate) fn toggle_ambient_background() {
     shell_bridge::ui(move |mut b| b.as_mut().set_ambient_mode(mode));
 }
 
+/// ArtistView's "In library" toggle: ask for the feed (a fetch only if it has
+/// never loaded this session — `load_library_once`), and repaint the open
+/// page's rows from the cache when it is already warm. The owner's rule for
+/// the toggle: re-arm the warm, but SERVE FROM CACHE — clicking the tab must
+/// never refetch a 10k-row feed.
+pub(crate) fn warm_library() {
+    load_library_once();
+    artist_qt::refresh_library_items();
+}
+
 fn load_library_once() {
     if *LIBRARY_LOADED.lock().unwrap() {
         return;
@@ -3009,6 +3026,9 @@ pub(crate) fn reload_library() {
                     b.as_mut().set_library_loading(false);
                 });
                 log_rss("library published");
+                // The artist page open right now (if any) was built while the
+                // feed was cold — hand it its "In library" rows.
+                artist_qt::refresh_library_items();
             }
             Err(e) => {
                 log::warn!("[qbz-qt] library load failed: {e}");
@@ -3140,15 +3160,36 @@ pub(crate) fn library_toggle_favorite(kind: String, id: String) {
     let runtime = app();
     spawn(async move {
         if let Some(value) = library_qt::toggle_favorite(&runtime, &kind, &id).await {
-            let membership_changed = !value && library_qt::remove_local_favorite_row(&kind, &id);
-            emit_library_favorite(&kind, &id, value);
-            if membership_changed {
-                publish_library_document();
-            }
+            settle_favorite(&runtime, &kind, &id, value).await;
         }
     });
 }
 
+/// A heart's write LANDED with `value`: reconcile the cached feed (a fresh
+/// Qobuz favourite joins it, a cleared one leaves; local hearts have their
+/// own row pair), fan the settled value out through `emit_library_favorite`,
+/// and republish the Library document only when a row came or went.
+///
+/// Reconcile BEFORE emit, deliberately: the fan-out reaches
+/// `artist_qt::apply_favorite_change`, which recomputes the open artist's
+/// "In library" rows off the feed — it has to see the inserted / removed row
+/// or the tab keeps its stale count (the #737 round's "the badge never
+/// moves"). Every settle point that owns a Qobuz heart goes through here
+/// (`library_toggle_favorite`, the queue panel heart in `queue_qt`).
+pub(crate) async fn settle_favorite(
+    runtime: &Arc<AppRuntime<LoggingAdapter>>,
+    kind: &str,
+    id: &str,
+    value: bool,
+) {
+    let mut membership_changed = !value && library_qt::remove_local_favorite_row(kind, id);
+    membership_changed |= library_qt::reconcile_qobuz_favorite(runtime, kind, id, value).await;
+    emit_library_favorite(kind, id, value);
+    if membership_changed {
+        publish_library_document();
+    }
+}
+
 /// THE settle point for a heart, wherever the click came from: emit the
 /// in-place signal, then fan the settled value into the document caches.
 ///
@@ -3183,6 +3224,7 @@ pub(crate) fn emit_library_favorite(kind: &str, id: &str, value: bool) {
     home_qt::apply_favorite_change(kind, id, value);
     recommendations_qt::apply_favorite_change(kind, id, value);
     search_qt::apply_favorite_change(kind, id, value);
+    artist_qt::apply_favorite_change(kind, id, value);
 }
 
 /// Dev navigation driver — `QBZ_QT_NAV_BENCH=home,library,home,settings`.
diff --git a/crates/qbz-qt/src/queue_qt.rs b/crates/qbz-qt/src/queue_qt.rs
index 3e8ebb48b..085bbbee8 100644
--- a/crates/qbz-qt/src/queue_qt.rs
+++ b/crates/qbz-qt/src/queue_qt.rs
@@ -1562,7 +1562,7 @@ pub async fn toggle_favorite(runtime: &Arc<AppRuntime<LoggingAdapter>>, kind: &s
     // (Home / Search / Recommendations re-published the pre-toggle heart on
     // their next republish). The panel itself still repaints from `publish`.
     if let Some(value) = crate::library_qt::toggle_favorite(runtime, kind, id).await {
-        crate::emit_library_favorite(kind, id, value);
+        crate::settle_favorite(runtime, kind, id, value).await;
     }
     publish(runtime).await;
 }
diff --git a/crates/qbzd/src/api/queue.rs b/crates/qbzd/src/api/queue.rs
index 998178937..3cc9c5729 100644
--- a/crates/qbzd/src/api/queue.rs
+++ b/crates/qbzd/src/api/queue.rs
@@ -773,6 +773,7 @@ mod tests {
             },
             label: None,
             genre: None,
+            artist: None,
         });
 
         let qt = track_to_queue_track(&track);