From ea0022e28c7c19bc0da01dfa07d6ccffa693a84d Mon Sep 17 00:00:00 2001
From: Paul Otto <paul@cloo-gmbh-de>
Date: Thu, 12 Nov 2026 11:10:29 +0100
Subject: [PATCH 1/7] fix(ytmusic): read a sign-in YouTube stopped taking from
 the browser again

A browser that goes on using its sign-in gets new cookies for it, and the
copy cloofy took stops working after a day or two (#26). The sign-in now
keeps which browser it came from and whose it is. When YouTube no longer
takes the cookies, cloofy reads them from that browser again, once per
run, and keeps them only if they sign in the same account. Requests for
the library wait for that check, so they go out with the new cookies.

Co-Authored-By: Claude Fable 5.2 <noreply@anthropic.com>
---
 crates/cloofy-ytmusic/src/account.rs          | 43 ++++++++
 crates/cloofy-ytmusic/src/auth.rs             | 97 +++++++++++++++++--
 crates/cloofy-ytmusic/src/innertube.rs        | 42 ++++++--
 crates/cloofy-ytmusic/src/lib.rs              | 68 ++++++++++++-
 crates/cloofy-ytmusic/src/library.rs          |  8 +-
 .../src/content/docs/docs/youtube-music.md    |  2 +-
 6 files changed, 236 insertions(+), 24 deletions(-)

diff --git a/crates/cloofy-ytmusic/src/account.rs b/crates/cloofy-ytmusic/src/account.rs
index 95f06ac..e15dddf 100644
--- a/crates/cloofy-ytmusic/src/account.rs
+++ b/crates/cloofy-ytmusic/src/account.rs
@@ -17,6 +17,8 @@ const MAX_ACCOUNTS: u32 = 10;
 /// The comments in the sign-in's `cookies.txt` that say which account it acts as.
 const INDEX_NOTE: &str = "# cloofy-authuser: ";
 const PAGE_NOTE: &str = "# cloofy-pageid: ";
+const BROWSER_NOTE: &str = "# cloofy-browser: ";
+const USER_NOTE: &str = "# cloofy-user: ";
 
 /// The account requests act as.
 #[derive(Debug, Clone, Default, PartialEq, Eq)]
@@ -52,6 +54,36 @@ impl Identity {
     }
 }
 
+/// Where a sign-in came from, kept with it so that cloofy can read it from there again when
+/// YouTube stops taking the cookies: a browser that goes on using its sign-in gets new cookies
+/// for it, and the ones cloofy copied stop working after a day or two.
+#[derive(Debug, Clone, Default, PartialEq, Eq)]
+pub(crate) struct Origin {
+    /// The browser as yt-dlp's `--cookies-from-browser` takes it; `None` for a pasted header.
+    pub browser: Option<String>,
+    /// YouTube's ID of the account signed in as. Cookies read again are only kept when they
+    /// are this account's: the browser may have signed in to another one since.
+    pub user: Option<String>,
+}
+
+impl Origin {
+    /// Reads it from the sign-in's `cookies.txt`; empty where the file says nothing, as files
+    /// from before cloofy 0.5.3 do.
+    pub(crate) fn parse(text: &str) -> Self {
+        let note = |prefix: &str| {
+            let lines = text.lines().map(|line| line.trim_end_matches('\r'));
+            lines.filter_map(|line| line.strip_prefix(prefix)).map(str::trim).rfind(|value| !value.is_empty())
+        };
+        Self { browser: note(BROWSER_NOTE).map(str::to_owned), user: note(USER_NOTE).map(str::to_owned) }
+    }
+
+    /// The lines that keep it in a `cookies.txt`, as comments other readers skip.
+    pub(crate) fn notes(&self) -> String {
+        let note = |prefix: &str, value: &Option<String>| value.as_ref().map(|value| format!("{prefix}{value}\n"));
+        [note(BROWSER_NOTE, &self.browser), note(USER_NOTE, &self.user)].into_iter().flatten().collect()
+    }
+}
+
 /// An account the cookies can act as.
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub struct Account {
@@ -166,6 +198,17 @@ fn parse(page: &Value, index: u32) -> Vec<Account> {
 mod tests {
     use super::*;
 
+    #[test]
+    fn where_a_sign_in_came_from_survives_its_file() {
+        let origin = Origin { browser: Some("brave+gnomekeyring".into()), user: Some("UCabc".into()) };
+        let text = format!("# Netscape HTTP Cookie File\n{}{}", Identity::default().notes(), origin.notes());
+        assert_eq!(Origin::parse(&text), origin);
+        assert_eq!(Identity::parse(&text), Identity::default(), "next to the account's own notes");
+        // A file from before 0.5.3, and a pasted header's.
+        assert_eq!(Origin::parse("# cloofy-authuser: 1\n"), Origin::default());
+        assert_eq!(Origin::default().notes(), "");
+    }
+
     fn fixture() -> Value {
         serde_json::from_str(include_str!("../tests/fixtures/accounts_list.json")).unwrap()
     }
diff --git a/crates/cloofy-ytmusic/src/auth.rs b/crates/cloofy-ytmusic/src/auth.rs
index 949b13d..a8f6abe 100644
--- a/crates/cloofy-ytmusic/src/auth.rs
+++ b/crates/cloofy-ytmusic/src/auth.rs
@@ -17,9 +17,10 @@ use tokio::process::Command;
 
 use crate::{
     YtMusic,
-    account::{self, Account},
+    account::{self, Account, Origin},
     cookies::Jar,
-    innertube, library,
+    innertube::{self, InnerTube},
+    library,
 };
 
 /// A browser yt-dlp can read cookies from.
@@ -192,8 +193,11 @@ pub struct SignIn {
 }
 
 impl SignIn {
-    fn new(jar: Jar) -> Result<Self> {
-        Ok(Self { client: YtMusic::unsaved(jar)? })
+    /// `browser` is where the cookies were read, as yt-dlp names it; `None` for pasted ones.
+    fn new(jar: Jar, browser: Option<String>) -> Result<Self> {
+        let client = YtMusic::unsaved(jar)?;
+        client.api().set_origin(Origin { browser, user: None });
+        Ok(Self { client })
     }
 
     /// The accounts it can act as: each Google account signed in to the browser, in Google's
@@ -207,9 +211,13 @@ impl SignIn {
         self.client.api().set_identity(account.identity.clone());
     }
 
-    /// Asks YouTube Music whose sign-in it is; fails when it turns the cookies down.
+    /// Asks YouTube Music whose sign-in it is; fails when it turns the cookies down. The
+    /// account is kept with the sign-in, for when cloofy reads the browser's cookies again.
     pub async fn check(&self) -> Result<User> {
-        library::me(self.client.api()).await
+        let api = self.client.api();
+        let user = library::me(api).await?;
+        api.set_origin(Origin { user: Some(user.id.clone()), ..api.origin().unwrap_or_default() });
+        Ok(user)
     }
 
     /// Keeps it in place of the sign-in before, with the account chosen and the cookies
@@ -241,7 +249,7 @@ pub async fn from_browser(paths: &Paths, browser: &mut Browser) -> Result<Option
         browser.spec = spec;
     }
     if signed_in(&jar) {
-        return SignIn::new(jar).map(Some);
+        return SignIn::new(jar, Some(browser.spec.clone())).map(Some);
     }
     // Cookies it couldn't decrypt may be the sign-in.
     if undecrypted(&stderr) {
@@ -253,6 +261,32 @@ pub async fn from_browser(paths: &Paths, browser: &mut Browser) -> Result<Option
     Ok(None)
 }
 
+/// Reads the cookies again from the browser the sign-in of `api` came from, for when YouTube
+/// stopped taking the ones kept: a browser that goes on using its sign-in gets new cookies for
+/// it, and the copy cloofy took goes stale within days. They replace the kept ones only when
+/// YouTube takes them and they sign in the same account as before. Fails otherwise, and for a
+/// sign-in that didn't come from a browser.
+pub(crate) async fn renew(api: &InnerTube, paths: &Paths) -> Result<User> {
+    let origin = api.origin().context("Not signed in")?;
+    let spec = origin.browser.as_deref().context("The sign-in didn't come from a browser")?;
+    let (jar, stderr) = export(paths, spec).await?;
+    innertube::check_jar(&jar).with_context(|| format!("The browser isn't signed in to YouTube{}", reason(&stderr)))?;
+    let trial = InnerTube::unsaved(jar)?;
+    trial.set_identity(api.identity().unwrap_or_default());
+    let user = library::me(&trial).await?;
+    if !same_account(&origin, &user) {
+        bail!("The browser is signed in to another account now");
+    }
+    api.renew(trial.jar().context("Not signed in")?);
+    Ok(user)
+}
+
+/// Whether `user` is the account the sign-in was made for. One from before cloofy kept the
+/// account passes: the browser's account at the same place is the best there is to go by.
+fn same_account(origin: &Origin, user: &User) -> bool {
+    origin.user.as_ref().is_none_or(|id| *id == user.id)
+}
+
 /// The cookies of youtube.com in the browser of `spec`, and what yt-dlp printed to stderr.
 async fn export(paths: &Paths, spec: &str) -> Result<(Jar, String)> {
     let dir = private_dir(paths)?;
@@ -316,7 +350,7 @@ fn reason(stderr: &str) -> String {
 pub fn from_cookie_header(header: &str) -> Result<SignIn> {
     let jar = Jar::from_header(header);
     innertube::check_jar(&jar)?;
-    SignIn::new(jar)
+    SignIn::new(jar, None)
 }
 
 /// Forgets the cookies; YouTube Music is signed out on the next start.
@@ -390,6 +424,53 @@ mod tests {
         fs::remove_dir_all(paths.data.parent().unwrap()).unwrap();
     }
 
+    /// Issue #26: a browser that goes on using its sign-in makes the cookies cloofy copied go
+    /// stale. The sign-in keeps where it came from and whose it is, to read it there again.
+    #[test]
+    fn where_the_sign_in_came_from_is_kept_with_it() {
+        let paths = paths("origin");
+        let jar = Jar::from_header("SAPISID=abc; LOGIN_INFO=def");
+        let sign_in = SignIn::new(jar, Some("firefox:/home/x/.zen".into())).unwrap();
+        // As `check` does once YouTube named the account.
+        let api = sign_in.client.api();
+        api.set_origin(Origin { user: Some("UCabc".into()), ..api.origin().unwrap() });
+        sign_in.save(&paths).unwrap();
+
+        let client = crate::YtMusic::new(&paths).unwrap();
+        let origin = Origin { browser: Some("firefox:/home/x/.zen".into()), user: Some("UCabc".into()) };
+        assert_eq!(client.api().origin(), Some(origin));
+        assert_eq!(client.api().jar().unwrap().get("SAPISID"), Some("abc"), "the notes aren't cookies");
+
+        // New cookies from the browser go on as the same account, from the same browser.
+        let brand = Identity { index: 1, page_id: None };
+        client.api().set_identity(brand.clone());
+        client.api().renew(Jar::from_header("SAPISID=new; LOGIN_INFO=def"));
+        let again = crate::YtMusic::new(&paths).unwrap();
+        assert_eq!(again.api().jar().unwrap().get("SAPISID"), Some("new"), "kept right away");
+        assert_eq!(again.api().identity(), Some(brand));
+        assert_eq!(again.api().origin(), client.api().origin());
+        fs::remove_dir_all(paths.data.parent().unwrap()).unwrap();
+    }
+
+    #[tokio::test]
+    async fn a_pasted_sign_in_has_no_browser_to_read_again() {
+        let paths = paths("pasted");
+        let sign_in = from_cookie_header("SAPISID=abc; LOGIN_INFO=def").unwrap();
+        assert_eq!(sign_in.client.api().origin(), Some(Origin::default()));
+        // Fails before yt-dlp or YouTube are asked anything.
+        let err = renew(sign_in.client.api(), &paths).await.unwrap_err();
+        assert!(format!("{err:#}").contains("didn't come from a browser"), "{err:#}");
+    }
+
+    #[test]
+    fn cookies_read_again_must_be_the_same_account_s() {
+        let user = |id: &str| User { id: id.into(), name: "Someone".into() };
+        let kept = Origin { browser: Some("firefox".into()), user: Some("UCabc".into()) };
+        assert!(same_account(&kept, &user("UCabc")));
+        assert!(!same_account(&kept, &user("UCother")), "the browser signed in to another account");
+        assert!(same_account(&Origin::default(), &user("UCother")), "nothing kept to compare with");
+    }
+
     #[test]
     fn adding_an_account_comes_back_to_youtube_music() {
         let url = url::Url::parse(ADD_ACCOUNT_URL).unwrap();
diff --git a/crates/cloofy-ytmusic/src/innertube.rs b/crates/cloofy-ytmusic/src/innertube.rs
index 98fc712..a4cc252 100644
--- a/crates/cloofy-ytmusic/src/innertube.rs
+++ b/crates/cloofy-ytmusic/src/innertube.rs
@@ -14,7 +14,7 @@ use serde_json::{Value, json};
 use sha1::{Digest, Sha1};
 
 use crate::{
-    account::Identity,
+    account::{Identity, Origin},
     cookies::{self, Jar},
 };
 
@@ -56,6 +56,7 @@ pub(crate) struct InnerTube {
 struct Auth {
     jar: Jar,
     identity: Identity,
+    origin: Origin,
     /// Where the cookies are kept; `None` for a sign-in that isn't kept, or no longer is.
     store: Option<Stored>,
     dirty: bool,
@@ -72,8 +73,8 @@ impl InnerTube {
     pub fn new(store: Secret) -> Result<Self> {
         let auth = store.read()?.and_then(|bytes| {
             let text = String::from_utf8_lossy(&bytes);
-            let (jar, identity) = (Jar::parse(&text), Identity::parse(&text));
-            signed_in(&jar).then(|| Auth::new(jar, identity, Some(Stored { secret: store, bytes })))
+            let (jar, identity, origin) = (Jar::parse(&text), Identity::parse(&text), Origin::parse(&text));
+            signed_in(&jar).then(|| Auth::new(jar, identity, origin, Some(Stored { secret: store, bytes })))
         });
         Self::with_auth(auth)
     }
@@ -81,7 +82,7 @@ impl InnerTube {
     /// Signed in with cookies that aren't kept, to try them before they are. They act as the
     /// browser's first account until `set_identity` picks another.
     pub fn unsaved(jar: Jar) -> Result<Self> {
-        Self::with_auth(signed_in(&jar).then(|| Auth::new(jar, Identity::default(), None)))
+        Self::with_auth(signed_in(&jar).then(|| Auth::new(jar, Identity::default(), Origin::default(), None)))
     }
 
     fn with_auth(auth: Option<Auth>) -> Result<Self> {
@@ -108,6 +109,29 @@ impl InnerTube {
         *self.visitor.lock().unwrap() = None;
     }
 
+    /// Where the sign-in came from; `None` signed out.
+    pub fn origin(&self) -> Option<Origin> {
+        self.auth.lock().unwrap().as_ref().map(|auth| auth.origin.clone())
+    }
+
+    /// Keeps where the sign-in came from with the cookies.
+    pub fn set_origin(&self, origin: Origin) {
+        if let Some(auth) = self.auth.lock().unwrap().as_mut() {
+            auth.dirty |= auth.origin != origin;
+            auth.origin = origin;
+        }
+    }
+
+    /// Goes on with the cookies of `jar`, read again from where the sign-in came from, and
+    /// keeps them right away. The account and where it came from stay.
+    pub fn renew(&self, jar: Jar) {
+        if let Some(auth) = self.auth.lock().unwrap().as_mut() {
+            auth.jar = jar;
+            auth.save();
+        }
+        *self.visitor.lock().unwrap() = None;
+    }
+
     /// Calls an endpoint, e.g. `browse` or `music/get_queue`, as the web client.
     pub async fn call(&self, endpoint: &str, body: Value) -> Result<Value> {
         self.call_as(ClientKind::Web, endpoint, body).await
@@ -285,7 +309,6 @@ impl InnerTube {
     }
 
     /// The cookies as they are now, with what YouTube refreshed; `None` signed out.
-    #[cfg(test)]
     pub fn jar(&self) -> Option<Jar> {
         self.auth.lock().unwrap().as_ref().map(|auth| auth.jar.clone())
     }
@@ -298,13 +321,14 @@ impl InnerTube {
 }
 
 impl Auth {
-    fn new(jar: Jar, identity: Identity, store: Option<Stored>) -> Self {
-        Self { jar, identity, store, dirty: false, saved: Instant::now() }
+    fn new(jar: Jar, identity: Identity, origin: Origin, store: Option<Stored>) -> Self {
+        Self { jar, identity, origin, store, dirty: false, saved: Instant::now() }
     }
 
-    /// The `cookies.txt` it is kept as, with the account in comments at the end.
+    /// The `cookies.txt` it is kept as, with the account and where the sign-in came from in
+    /// comments at the end.
     fn text(&self) -> String {
-        self.jar.to_text() + &self.identity.notes()
+        self.jar.to_text() + &self.identity.notes() + &self.origin.notes()
     }
 
     /// Writes the cookies back, unless the sign-in was replaced or removed since this client
diff --git a/crates/cloofy-ytmusic/src/lib.rs b/crates/cloofy-ytmusic/src/lib.rs
index 324e63f..e1d1543 100644
--- a/crates/cloofy-ytmusic/src/lib.rs
+++ b/crates/cloofy-ytmusic/src/lib.rs
@@ -59,23 +59,39 @@ struct Inner {
     api: InnerTube,
     http: reqwest::Client,
     library: Library,
+    /// Where the sign-in is kept, for reading it from the browser again; `None` for one that
+    /// isn't kept.
+    paths: Option<Paths>,
+    /// Held while YouTube is asked whether it still takes the sign-in, so that requests for
+    /// the library wait for the answer, and for new cookies if it says no.
+    session: tokio::sync::Mutex<Session>,
+}
+
+/// What this run knows about the sign-in.
+#[derive(Default)]
+struct Session {
+    /// YouTube answered whether it takes the sign-in.
+    asked: bool,
+    /// The cookies were read from the browser again, or cloofy tried to.
+    renewed: bool,
 }
 
 impl YtMusic {
     /// Signs in with the cookies saved by `cloofy login ytmusic`, if any; signed out otherwise.
     pub fn new(paths: &Paths) -> Result<Self> {
-        Self::with_api(InnerTube::new(paths.ytmusic_cookies())?)
+        Self::with_api(InnerTube::new(paths.ytmusic_cookies())?, Some(paths.clone()))
     }
 
     /// Signed in with cookies that aren't kept, to try a sign-in before it replaces the one
     /// before.
     pub(crate) fn unsaved(jar: cookies::Jar) -> Result<Self> {
-        Self::with_api(InnerTube::unsaved(jar)?)
+        Self::with_api(InnerTube::unsaved(jar)?, None)
     }
 
-    fn with_api(api: InnerTube) -> Result<Self> {
+    fn with_api(api: InnerTube, paths: Option<Paths>) -> Result<Self> {
         let http = cloofy_core::http::client(concat!("cloofy/", env!("CARGO_PKG_VERSION"))).build()?;
-        Ok(Self { inner: Arc::new(Inner { api, http, library: Library::default() }) })
+        let session = tokio::sync::Mutex::default();
+        Ok(Self { inner: Arc::new(Inner { api, http, library: Library::default(), paths, session }) })
     }
 
     pub fn signed_in(&self) -> bool {
@@ -87,7 +103,42 @@ impl YtMusic {
         if !self.signed_in() {
             return Ok(None);
         }
-        library::me(&self.inner.api).await.map(Some)
+        let mut session = self.inner.session.lock().await;
+        self.ask(&mut session).await.map(Some)
+    }
+
+    /// Asks YouTube whose sign-in it is. When it no longer takes the cookies, cloofy reads
+    /// them again from the browser they came from, once per run.
+    async fn ask(&self, session: &mut Session) -> Result<User> {
+        let api = &self.inner.api;
+        let user = library::asked(api).await?;
+        session.asked = true;
+        if let Some(user) = user {
+            return Ok(user);
+        }
+        let refused = "YouTube doesn't accept the saved sign-in any more – run `cloofy login ytmusic` again";
+        let Some(paths) = self.inner.paths.as_ref().filter(|_| !session.renewed) else { anyhow::bail!(refused) };
+        session.renewed = true;
+        match auth::renew(api, paths).await {
+            Ok(user) => {
+                tracing::info!("YouTube Music: read the sign-in from the browser again");
+                Ok(user)
+            }
+            Err(err) => {
+                tracing::info!("YouTube Music: couldn't read the sign-in from the browser again: {err:#}");
+                anyhow::bail!(refused)
+            }
+        }
+    }
+
+    /// Makes sure YouTube was asked about the sign-in before the first request for the
+    /// library, which would fail with cookies it no longer takes. What the request then says
+    /// stays its own business.
+    async fn checked(&self) {
+        let mut session = self.inner.session.lock().await;
+        if !session.asked && self.signed_in() {
+            let _ = self.ask(&mut session).await;
+        }
     }
 
     /// Which of the browser's accounts the sign-in acts as, with its address; `None` when
@@ -137,19 +188,23 @@ impl YtMusic {
 
     /// The playlists in the library, without Liked Music.
     pub async fn library_playlists(&self) -> Result<Vec<PlaylistInfo>> {
+        self.checked().await;
         library::playlists(&self.inner.api, &self.inner.library).await
     }
 
     pub async fn saved_albums(&self) -> Result<Vec<AlbumInfo>> {
+        self.checked().await;
         library::albums(&self.inner.api, &self.inner.library).await
     }
 
     /// The artists the user subscribed to.
     pub async fn followed_artists(&self) -> Result<Vec<ArtistInfo>> {
+        self.checked().await;
         library::artists(&self.inner.api, &self.inner.library).await
     }
 
     pub async fn liked_count(&self) -> Result<u32> {
+        self.checked().await;
         library::liked_count(&self.inner.api).await
     }
 
@@ -171,16 +226,19 @@ impl YtMusic {
     /// Whether each URI is in the library: liked songs, saved albums and playlists, subscribed
     /// artists. Signed out, nothing is.
     pub async fn check_saved(&self, uris: &[String]) -> Result<Vec<(String, bool)>> {
+        self.checked().await;
         library::check_saved(&self.inner.api, &self.inner.library, uris).await
     }
 
     /// Likes or unlikes a song, saves or removes an album or playlist, subscribes to or
     /// unsubscribes from an artist.
     pub async fn set_saved(&self, uri: &str, saved: bool) -> Result<()> {
+        self.checked().await;
         library::set_saved(&self.inner.api, &self.inner.library, uri, saved).await
     }
 
     pub async fn add_to_playlist(&self, playlist_uri: &str, uris: &[String]) -> Result<()> {
+        self.checked().await;
         library::add_to_playlist(&self.inner.api, playlist_uri, uris).await
     }
 
diff --git a/crates/cloofy-ytmusic/src/library.rs b/crates/cloofy-ytmusic/src/library.rs
index 29c2b1c..a18137b 100644
--- a/crates/cloofy-ytmusic/src/library.rs
+++ b/crates/cloofy-ytmusic/src/library.rs
@@ -70,8 +70,14 @@ fn require_sign_in(api: &InnerTube) -> Result<()> {
 }
 
 pub(crate) async fn me(api: &InnerTube) -> Result<User> {
+    asked(api).await?.context("YouTube doesn't accept the saved sign-in any more – run `cloofy login ytmusic` again")
+}
+
+/// Whose sign-in it is; `None` when YouTube answers but no longer takes the cookies, which is
+/// not the same as an answer that didn't arrive.
+pub(crate) async fn asked(api: &InnerTube) -> Result<Option<User>> {
     let page = api.call("account/account_menu", json!({})).await?;
-    parse_me(&page).context("YouTube doesn't accept the saved sign-in any more – run `cloofy login ytmusic` again")
+    Ok(parse_me(&page))
 }
 
 fn parse_me(page: &Value) -> Option<User> {
diff --git a/website/src/content/docs/docs/youtube-music.md b/website/src/content/docs/docs/youtube-music.md
index a75412c..a12e5ba 100644
--- a/website/src/content/docs/docs/youtube-music.md
+++ b/website/src/content/docs/docs/youtube-music.md
@@ -55,4 +55,4 @@ The DJ, devices, crossfade and podcasts are Spotify's.
 
 ## Your cookies
 
-`cloofy login ytmusic` has yt-dlp export the browser's cookies into a private folder, keeps only youtube.com's, and deletes the export right away. They stay in `~/.local/share/cloofy/ytmusic/cookies.txt`, which only you can read, or in the macOS Keychain with `credentials = "keychain"`. cloofy sends them only to music.youtube.com, with its own requests there; streams, covers and lyrics from LRCLIB load without them. They are a signed-in session like the browser's, so treat the file like a password. `cloofy logout ytmusic` deletes it.
+`cloofy login ytmusic` has yt-dlp export the browser's cookies into a private folder, keeps only youtube.com's, and deletes the export right away. They stay in `~/.local/share/cloofy/ytmusic/cookies.txt`, which only you can read, or in the macOS Keychain with `credentials = "keychain"`. cloofy sends them only to music.youtube.com, with its own requests there; streams, covers and lyrics from LRCLIB load without them. They are a signed-in session like the browser's, so treat the file like a password. `cloofy logout ytmusic` deletes it. A browser that goes on using its sign-in gets new cookies for it, so after a day or two YouTube may stop taking cloofy's copy: cloofy then reads them from the same browser again, the same way, and keeps them only when they still sign in the same account.

From 9f42c90a885e12c49d5f4782a48466a4446bae3e Mon Sep 17 00:00:00 2001
From: Paul Otto <paul@cloo-gmbh-de>
Date: Thu, 12 Nov 2026 11:10:29 +0100
Subject: [PATCH 2/7] feat: normalize volume, hidden shelves, cloofy in the app
 menu on Linux

- Normalize volume (#32): a setting under Playback. Spotify applies the
  gain it measured per track, switched while a track plays through the
  librespot fork; YouTube Music gets mpv's loudnorm at -14 LUFS.
- Hide this shelf (#31) in the menu of anything on a Home shelf, kept as
  hidden_shelves in config.toml; Settings shows them all again.
- cloofy launcher install/remove (#30) writes a desktop entry and the
  icon. The installer runs it outside Omarchy, the Linux release archives
  and the AUR packages carry both files.

Co-Authored-By: Claude Fable 5.2 <noreply@anthropic.com>
---
 .github/workflows/release.yml                 |   9 +-
 CHANGELOG.md                                  |  10 +
 README.md                                     |  10 +-
 crates/cloofy-core/src/config.rs              |   4 +
 crates/cloofy-core/src/home.rs                |  26 +++
 crates/cloofy-player/src/lib.rs               |  10 +-
 crates/cloofy-tui/src/app/menu.rs             |  13 +-
 crates/cloofy-tui/src/app/mod.rs              |   9 +-
 crates/cloofy-tui/src/app/settings.rs         |  34 ++++
 crates/cloofy-tui/src/backend/fake.rs         |   4 +
 crates/cloofy-tui/src/backend/mod.rs          |   7 +
 crates/cloofy-tui/src/backend/spotify/mod.rs  |  10 +-
 .../cloofy-tui/src/backend/spotify/player.rs  |   7 +-
 crates/cloofy-tui/src/backend/ytmusic/mod.rs  |   4 +
 crates/cloofy-tui/src/lib.rs                  |   8 +-
 crates/cloofy-tui/src/overlay.rs              |   3 +
 crates/cloofy-tui/src/preferences.rs          |  32 +++-
 crates/cloofy-tui/src/scenarios/playback.rs   |  43 ++++-
 crates/cloofy-tui/src/views.rs                |  18 ++
 crates/cloofy-ytmusic/src/player/mod.rs       |  60 +++++-
 crates/cloofy/src/launcher.rs                 | 175 ++++++++++++++++++
 crates/cloofy/src/main.rs                     |   9 +
 crates/cloofy/src/omarchy.rs                  |  15 +-
 crates/cloofy/src/spotify/playback.rs         |   4 +-
 install.sh                                    |  11 ++
 integrations/linux/cloofy.desktop             |  12 ++
 packaging/aur/cloofy-bin/PKGBUILD             |   2 +
 packaging/aur/cloofy-full-bin/PKGBUILD        |   2 +
 packaging/aur/cloofy-ytmusic-bin/PKGBUILD     |   2 +
 packaging/aur/cloofy/PKGBUILD                 |   2 +
 vendor/librespot                              |   2 +-
 website/src/content/docs/docs/install.mdx     |   2 +-
 website/src/content/docs/docs/settings.md     |   4 +-
 33 files changed, 533 insertions(+), 30 deletions(-)
 create mode 100644 crates/cloofy/src/launcher.rs
 create mode 100644 integrations/linux/cloofy.desktop

diff --git a/.github/workflows/release.yml b/.github/workflows/release.yml
index 1eb1765..a96606d 100644
--- a/.github/workflows/release.yml
+++ b/.github/workflows/release.yml
@@ -92,7 +92,14 @@ jobs:
           for variant in spotify ytmusic full; do
             archive="cloofy-$variant-$TARGET.tar.gz"
             cp LICENSE README.md "dist/$variant/"
-            tar -czf "$archive" -C "dist/$variant" cloofy LICENSE README.md
+            files="cloofy LICENSE README.md"
+            # The app menu's entry and its icon, which the Linux packages install.
+            if [ "$RUNNER_OS" = Linux ]; then
+              cp integrations/linux/cloofy.desktop integrations/omarchy/cloofy.svg "dist/$variant/"
+              files="$files cloofy.desktop cloofy.svg"
+            fi
+            # shellcheck disable=SC2086
+            tar -czf "$archive" -C "dist/$variant" $files
             shasum -a 256 "$archive" > "$archive.sha256"
           done
           # cloofy 0.4 and older update themselves from this name, and play Spotify.
diff --git a/CHANGELOG.md b/CHANGELOG.md
index 52ec47b..63fa80b 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -4,6 +4,16 @@ All notable changes to cloofy. The format follows [Keep a Changelog](https://kee
 
 ## [Unreleased]
 
+### Added
+
+- **Normalize volume.** A new setting under Playback plays every song at about the same loudness, on Spotify with the loudness Spotify measured for each track, on YouTube Music with mpv's loudness filter, at the level Spotify and YouTube aim for. It applies at once, to the song that plays ([#32](https://github.com/parda21/cloofy/issues/32)).
+- **Hide a shelf on Home.** The menu of anything on a shelf (<kbd>.</kbd> or a right-click) has **Hide this shelf**, on both services; the shelf stays away after a restart. **Hidden shelves** on the Settings page shows them all again ([#31](https://github.com/parda21/cloofy/issues/31)).
+- **cloofy in the app menu on Linux.** The installer and the Arch packages add a desktop entry and cloofy's icon, so GNOME, KDE Plasma, rofi or Walker find it; it opens in the desktop's terminal. `cloofy launcher install` and `cloofy launcher remove` do the same by hand, and `--uninstall` takes it out again. On Omarchy the launcher stays the one of `cloofy omarchy install` ([#30](https://github.com/parda21/cloofy/issues/30)).
+
+### Fixed
+
+- **Signed out of YouTube Music after a day or two.** A browser that goes on using its sign-in gets new cookies for it, and the ones cloofy copied stop working. When YouTube no longer takes them, cloofy now reads them from the same browser again, once per start, and keeps them only if they are still the same account's; otherwise it asks you to sign in as before. Sign-ins made with 0.5.2 or older, and pasted ones, don't say which browser they came from: run `cloofy login ytmusic --force` once ([#26](https://github.com/parda21/cloofy/issues/26)).
+
 ## [0.5.2] - 2026-11-10
 
 YouTube Music's Home looks and works as in its own apps, and cloofy asks once for a star.
diff --git a/README.md b/README.md
index f4d70d4..f4edfbc 100644
--- a/README.md
+++ b/README.md
@@ -87,7 +87,7 @@ The demo opens the full interface with a sample library: real albums and artists
 curl -fsSL https://cloofy.app/install.sh | bash
 ```
 
-The installer first asks what you listen to: Spotify, YouTube Music, or both. Each comes as a build of its own, so a YouTube Music install carries no Spotify code, and the other way around. Then it checks your system, puts the latest release in `~/.local/bin`, and walks you through the [setup](#setup). For Spotify that's your Spotify app, its client ID and signing in. For YouTube Music it's mpv, yt-dlp and deno, which it offers to install with your package manager, and an optional sign-in. On [Omarchy](https://omarchy.org) it also offers cloofy's [bar widget, theme, menu entries and launcher](#omarchy). Run it again to switch; cloofy offers new releases itself, see [updates](#updates).
+The installer first asks what you listen to: Spotify, YouTube Music, or both. Each comes as a build of its own, so a YouTube Music install carries no Spotify code, and the other way around. Then it checks your system, puts the latest release in `~/.local/bin`, and walks you through the [setup](#setup). For Spotify that's your Spotify app, its client ID and signing in. For YouTube Music it's mpv, yt-dlp and deno, which it offers to install with your package manager, and an optional sign-in. On [Omarchy](https://omarchy.org) it also offers cloofy's [bar widget, theme, menu entries and launcher](#omarchy). On other Linux desktops it adds cloofy with its icon to the app menu. Run it again to switch; cloofy offers new releases itself, see [updates](#updates).
 
 Package managers have the same three builds:
 
@@ -115,7 +115,7 @@ Homebrew's and Arch's YouTube Music packages bring mpv, yt-dlp and deno along; w
 
 - `bash -s -- --service ytmusic` installs YouTube Music without asking about it: `spotify`, `ytmusic` or `both`.
 - `bash -s -- --yes` installs without asking anything: the services you have, or Spotify the first time.
-- `bash -s -- --uninstall` removes cloofy, and its Omarchy setup.
+- `bash -s -- --uninstall` removes cloofy, its entry in the app menu and its Omarchy setup.
 
 On platforms without a prebuilt binary, the installer builds cloofy with cargo, with only the services you picked. To do that yourself (Rust 1.90 or newer), name them as features; without any, you get both:
 
@@ -221,12 +221,14 @@ Installed with Homebrew, mise, a system package or Nix, cloofy leaves its update
 
 ## Settings
 
-<kbd>,</kbd>, the command palette, or a click on your name in the top bar opens the Settings page: crossfade, cover art and how covers are drawn, the colors, the accent color, icons, power saving, song notifications and update checks. Changes apply at once and cloofy saves them in `~/.config/cloofy/config.toml`, so there's no need to edit the file. You still can; it's read at start:
+<kbd>,</kbd>, the command palette, or a click on your name in the top bar opens the Settings page: crossfade, volume normalization, the shelves hidden from Home, cover art and how covers are drawn, the colors, the accent color, icons, power saving, song notifications and update checks. Changes apply at once and cloofy saves them in `~/.config/cloofy/config.toml`, so there's no need to edit the file. You still can; it's read at start:
 
 ```toml
 client_id = "your client id"
 services = ["ytmusic"]     # "spotify", "ytmusic" or both, in the switch's order; every one built in when missing
 crossfade = 6              # seconds tracks overlap, 0 to 12; off when missing
+normalize_volume = true    # every song at about the same loudness; off when missing
+hidden_shelves = ["Covers and remixes"]  # shelves Home leaves out, by title
 covers = false             # no cover art, for slower computers; on when missing
 colors = "terminal"        # "cloofy" or "terminal"; Omarchy's theme there, cloofy's own elsewhere, when missing
 accent = "violet"          # "theme", "green", "violet", "pink", "blue" or "orange"; follows the cover when missing
@@ -301,7 +303,7 @@ YouTube protects its audio streams with challenges that only a JavaScript runtim
 <details>
 <summary><b>Is signing in to YouTube Music with my browser's cookies safe?</b></summary>
 
-`cloofy login ytmusic` has yt-dlp export the browser's cookies into a private folder, keeps only youtube.com's, and deletes the export right away. They stay in `~/.local/share/cloofy/ytmusic/cookies.txt`, which only you can read, or in the macOS Keychain with `credentials = "keychain"`. cloofy sends them only to music.youtube.com, with its own requests there; streams, covers and lyrics from LRCLIB load without them. They are a signed-in session like the browser's, so treat the file like a password. `cloofy logout ytmusic` deletes it.
+`cloofy login ytmusic` has yt-dlp export the browser's cookies into a private folder, keeps only youtube.com's, and deletes the export right away. They stay in `~/.local/share/cloofy/ytmusic/cookies.txt`, which only you can read, or in the macOS Keychain with `credentials = "keychain"`. cloofy sends them only to music.youtube.com, with its own requests there; streams, covers and lyrics from LRCLIB load without them. They are a signed-in session like the browser's, so treat the file like a password. `cloofy logout ytmusic` deletes it. A browser that goes on using its sign-in gets new cookies for it, so after a day or two YouTube may stop taking cloofy's copy: cloofy then reads them from the same browser again, the same way, and keeps them only when they still sign in the same account.
 </details>
 
 <details>
diff --git a/crates/cloofy-core/src/config.rs b/crates/cloofy-core/src/config.rs
index 19f0520..f58abda 100644
--- a/crates/cloofy-core/src/config.rs
+++ b/crates/cloofy-core/src/config.rs
@@ -14,6 +14,10 @@ pub struct Config {
     pub client_id: Option<String>,
     /// Seconds consecutive tracks overlap (0–12); off when missing.
     pub crossfade: Option<u64>,
+    /// Plays every song at about the same loudness; off when missing.
+    pub normalize_volume: Option<bool>,
+    /// Titles of the shelves Home leaves out, such as `["Covers and remixes"]`.
+    pub hidden_shelves: Option<Vec<String>>,
     /// `"nerd"` or `"text"`; detected from the terminal when missing.
     pub icons: Option<String>,
     /// `"keychain"` keeps sign-ins in the system's keychain; files when missing.
diff --git a/crates/cloofy-core/src/home.rs b/crates/cloofy-core/src/home.rs
index efe3744..5a6a7f0 100644
--- a/crates/cloofy-core/src/home.rs
+++ b/crates/cloofy-core/src/home.rs
@@ -13,6 +13,14 @@ pub struct Home {
 }
 
 impl Home {
+    /// This Home without the shelves titled as one of `hidden`, whatever the case. The
+    /// shortcuts at the top have no title to hide them by.
+    pub fn without_shelves(mut self, hidden: &[String]) -> Self {
+        let hidden: Vec<String> = hidden.iter().map(|title| title.trim().to_lowercase()).collect();
+        self.shelves.retain(|shelf| shelf.shortcuts || !hidden.contains(&shelf.title.trim().to_lowercase()));
+        self
+    }
+
     /// The chip Home is narrowed to, if any.
     pub fn chip(&self) -> Option<&Chip> {
         self.chips.iter().find(|chip| chip.selected)
@@ -79,3 +87,21 @@ impl HomeItem {
         self.kind == ItemKind::Playlist && self.context_uri != self.uri
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn hidden_shelves_go_by_title_and_the_shortcuts_stay() {
+        let shelf = |title: &str, shortcuts| Shelf { title: title.into(), shortcuts, ..Shelf::default() };
+        let home = Home {
+            shelves: vec![shelf("", true), shelf("Covers and remixes", false), shelf("Quick picks", false)],
+            ..Home::default()
+        };
+        let shown = home.clone().without_shelves(&["covers and Remixes ".into(), String::new()]);
+        let titles: Vec<&str> = shown.shelves.iter().map(|shelf| shelf.title.as_str()).collect();
+        assert_eq!(titles, ["", "Quick picks"]);
+        assert_eq!(home.without_shelves(&[]).shelves.len(), 3);
+    }
+}
diff --git a/crates/cloofy-player/src/lib.rs b/crates/cloofy-player/src/lib.rs
index 981d8eb..5172819 100644
--- a/crates/cloofy-player/src/lib.rs
+++ b/crates/cloofy-player/src/lib.rs
@@ -35,17 +35,23 @@ pub struct Engine {
 
 impl Engine {
     /// `crossfade` overlaps consecutive tracks by that long; zero plays them back to back.
+    /// `normalize` plays every track at about the same loudness, as Spotify's apps do.
     ///
     /// The receiver gets the name of each audio output that goes away during playback, such as
     /// headphones being unplugged; playback should pause then.
-    pub fn new(session: &Session, crossfade: Duration) -> Result<(Self, UnboundedReceiver<String>)> {
+    pub fn new(session: &Session, crossfade: Duration, normalize: bool) -> Result<(Self, UnboundedReceiver<String>)> {
         let backend = PREFERRED_BACKENDS
             .iter()
             .find_map(|name| audio_backend::find(Some((*name).to_owned())))
             .or_else(|| audio_backend::find(None))
             .context("No audio backend available")?;
         let mixer = (mixer::find(None).context("No mixer available")?)(MixerConfig::default())?;
-        let config = PlayerConfig { bitrate: Bitrate::Bitrate320, crossfade, ..PlayerConfig::default() };
+        let config = PlayerConfig {
+            bitrate: Bitrate::Bitrate320,
+            crossfade,
+            normalisation: normalize,
+            ..PlayerConfig::default()
+        };
         let (lost_tx, lost_rx) = mpsc::unbounded_channel();
         let player =
             Player::new(config, session.clone(), mixer.get_soft_volume(), move || open_output(backend, lost_tx));
diff --git a/crates/cloofy-tui/src/app/menu.rs b/crates/cloofy-tui/src/app/menu.rs
index b6bd10d..9c6008d 100644
--- a/crates/cloofy-tui/src/app/menu.rs
+++ b/crates/cloofy-tui/src/app/menu.rs
@@ -64,7 +64,9 @@ impl App {
                 SearchEntry::Artist(a) => Some(target(&a.uri, &a.name, TargetKind::Artist, a.image_url.clone())),
                 SearchEntry::Header(_) => None,
             },
-            View::Home(v) => v.selected().map(|item| self.home_target(item)),
+            View::Home(v) => v
+                .selected()
+                .map(|item| ContextTarget { shelf: v.shelf_title().map(str::to_owned), ..self.home_target(item) }),
             View::Artist(v) => match v.selected()? {
                 ArtistSelection::Track(t) => Some(track_target(&t.track, Some(v.uri.clone()))),
                 ArtistSelection::Item(item) => Some(self.home_target(item)),
@@ -197,6 +199,11 @@ impl App {
                 copy_to_clipboard(&backend::web_link(&target.uri));
                 self.notice("Link copied".into());
             }
+            MenuAction::HideShelf => {
+                if let Some(title) = target.shelf {
+                    self.hide_shelf(title);
+                }
+            }
         }
     }
 
@@ -294,6 +301,7 @@ fn target(uri: &str, name: &str, kind: TargetKind, image_url: Option<String>) ->
         owned: false,
         liked_songs: false,
         upcoming: None,
+        shelf: None,
     }
 }
 
@@ -383,6 +391,9 @@ fn menu_items(target: &ContextTarget, saved: bool) -> Vec<(MenuAction, String)>
     if !target.liked_songs {
         add(MenuAction::CopyLink, i.link, "Copy link");
     }
+    if target.shelf.is_some() {
+        add(MenuAction::HideShelf, i.remove, "Hide this shelf");
+    }
     items
 }
 
diff --git a/crates/cloofy-tui/src/app/mod.rs b/crates/cloofy-tui/src/app/mod.rs
index a36286b..23ccbe5 100644
--- a/crates/cloofy-tui/src/app/mod.rs
+++ b/crates/cloofy-tui/src/app/mod.rs
@@ -1031,6 +1031,9 @@ impl App {
         let service = player.service();
         self.player_errors.remove(&service);
         player.set_crossfade(Duration::from_secs(self.prefs.crossfade));
+        if self.prefs.normalize {
+            player.set_normalize(true);
+        }
         self.players.insert(service, player);
         // Until something plays, the player of the service shown is the one that would.
         if self.active.is_none() || (self.now.track.is_none() && self.loader.service() == Some(service)) {
@@ -1475,12 +1478,13 @@ impl App {
                     self.home_fetched_at = Some(Instant::now());
                     self.data_dirty = true;
                 }
+                let hidden = self.prefs.hidden_shelves.clone();
                 let Some(View::Home(v)) = self.view_mut(view) else { return false };
                 if !v.wants(chip.as_deref()) {
                     return false;
                 }
                 match result {
-                    Ok(home) => v.set_home(home),
+                    Ok(home) => v.set_home(home.without_shelves(&hidden)),
                     // The Home before the chip stays, so the failure is said at the bottom.
                     Err(err) => match v.chip_failed() {
                         Some(failed) => self.error(format!("Couldn't load {failed}: {err}")),
@@ -3245,7 +3249,8 @@ impl App {
 
     fn open_home(&mut self) {
         let id = self.next_id();
-        let mut view = HomeView::new(id, self.home_cache.clone());
+        let cached = self.home_cache.clone().map(|home| home.without_shelves(&self.prefs.hidden_shelves));
+        let mut view = HomeView::new(id, cached);
         if self.home_fetched_at.is_some_and(|at| at.elapsed() < HOME_FRESH) {
             view.loading = false;
         } else {
diff --git a/crates/cloofy-tui/src/app/settings.rs b/crates/cloofy-tui/src/app/settings.rs
index 0c46d62..b3e0400 100644
--- a/crates/cloofy-tui/src/app/settings.rs
+++ b/crates/cloofy-tui/src/app/settings.rs
@@ -82,6 +82,12 @@ impl App {
                     player.set_crossfade(Duration::from_secs(self.prefs.crossfade));
                 }
             }
+            Setting::Normalize => {
+                for player in self.players.values() {
+                    player.set_normalize(self.prefs.normalize);
+                }
+            }
+            Setting::HiddenShelves => self.show_hidden_shelves(),
             Setting::Covers if self.prefs.covers => {
                 if let Some(url) = self.now.track.as_ref().and_then(|t| t.cover_url.clone()) {
                     self.load_cover(url);
@@ -135,6 +141,34 @@ impl App {
         self.colors.as_ref().is_some_and(Colors::knows_terminal)
     }
 
+    /// Leaves the shelf titled `title` out of Home from now on, here and after a restart.
+    pub(super) fn hide_shelf(&mut self, title: String) {
+        if !self.prefs.hidden_shelves.iter().any(|hidden| hidden.eq_ignore_ascii_case(&title)) {
+            self.prefs.hidden_shelves.push(title.clone());
+        }
+        let hidden = self.prefs.hidden_shelves.clone();
+        for view in std::iter::once(&mut self.view).chain(self.history.iter_mut()) {
+            if let View::Home(home) = view {
+                home.hide_shelves(&hidden);
+            }
+        }
+        self.save_setting(Setting::HiddenShelves);
+        self.notice(format!("Hid “{title}” · Settings brings it back"));
+    }
+
+    /// With no shelf hidden any more: Home shows what it was loaded with. A chip's Home has
+    /// them back the next time it loads.
+    fn show_hidden_shelves(&mut self) {
+        let Some(home) = self.home_cache.clone() else { return };
+        for view in std::iter::once(&mut self.view).chain(self.history.iter_mut()) {
+            if let View::Home(shown) = view
+                && shown.is_whole()
+            {
+                shown.set_home(home.clone());
+            }
+        }
+    }
+
     /// Writes `setting` to the config file. The demo keeps changes until it closes.
     pub(super) fn save_setting(&mut self, setting: Setting) {
         if self.demo {
diff --git a/crates/cloofy-tui/src/backend/fake.rs b/crates/cloofy-tui/src/backend/fake.rs
index 0f31193..1f25f24 100644
--- a/crates/cloofy-tui/src/backend/fake.rs
+++ b/crates/cloofy-tui/src/backend/fake.rs
@@ -268,6 +268,10 @@ impl Fake {
         Ok(())
     }
 
+    pub fn set_normalize(&self, normalize: bool) {
+        self.record(format!("normalize {normalize}"));
+    }
+
     pub fn shuffle(&self, on: bool) -> Result<()> {
         self.record(format!("shuffle {on}"));
         self.send(PlayerEvent::ShuffleChanged { shuffle: on });
diff --git a/crates/cloofy-tui/src/backend/mod.rs b/crates/cloofy-tui/src/backend/mod.rs
index 59bc8ff..6ec6ff9 100644
--- a/crates/cloofy-tui/src/backend/mod.rs
+++ b/crates/cloofy-tui/src/backend/mod.rs
@@ -180,6 +180,8 @@ pub enum Account {
 pub struct Launch {
     pub paths: Paths,
     pub crossfade: Duration,
+    /// Every song at about the same loudness.
+    pub normalize: bool,
     /// Where the last session left the volume, if anywhere.
     pub volume: Option<u16>,
     /// Cuts a wait between attempts to connect short, as when the computer wakes up.
@@ -334,6 +336,11 @@ impl Player {
         }
     }
 
+    /// Plays every song at about the same loudness, or as loud as it is.
+    pub fn set_normalize(&self, normalize: bool) {
+        dispatch!(self, Player, player => player.set_normalize(normalize))
+    }
+
     /// Elsewhere songs follow each other as they are.
     pub fn set_crossfade(&self, crossfade: Duration) {
         match self {
diff --git a/crates/cloofy-tui/src/backend/spotify/mod.rs b/crates/cloofy-tui/src/backend/spotify/mod.rs
index b2fd3c4..627502f 100644
--- a/crates/cloofy-tui/src/backend/spotify/mod.rs
+++ b/crates/cloofy-tui/src/backend/spotify/mod.rs
@@ -75,7 +75,15 @@ impl Account {
         let state = Arc::new(watch::Sender::new(SessionState::Connecting));
         let volume = launch.volume.unwrap_or(cloofy_player::DEFAULT_VOLUME);
         let hashes = launch.paths.pathfinder_hashes();
-        player::spawn(launch.paths, launch.crossfade, volume, launch.retry_now, launch.tx.clone(), state.clone());
+        player::spawn(
+            launch.paths,
+            launch.crossfade,
+            launch.normalize,
+            volume,
+            launch.retry_now,
+            launch.tx.clone(),
+            state.clone(),
+        );
         Catalog::new(self.api, state, hashes, launch.tx)
     }
 }
diff --git a/crates/cloofy-tui/src/backend/spotify/player.rs b/crates/cloofy-tui/src/backend/spotify/player.rs
index a9aca3d..28936c1 100644
--- a/crates/cloofy-tui/src/backend/spotify/player.rs
+++ b/crates/cloofy-tui/src/backend/spotify/player.rs
@@ -165,6 +165,10 @@ impl Controller {
         self.engine.player.set_crossfade(crossfade);
     }
 
+    pub fn set_normalize(&self, normalize: bool) {
+        self.engine.player.set_normalisation(normalize);
+    }
+
     /// cloofy's Spotify Connect device ID.
     pub fn device_id(&self) -> String {
         self.session.device_id().to_owned()
@@ -196,6 +200,7 @@ impl Controller {
 pub fn spawn(
     paths: Paths,
     crossfade: Duration,
+    normalize: bool,
     volume: u16,
     retry_now: Arc<Notify>,
     tx: UnboundedSender<AppEvent>,
@@ -211,7 +216,7 @@ pub fn spawn(
     tokio::spawn(async move {
         let started = async {
             let pending = session::prepare(&paths)?;
-            let (engine, lost_outputs) = Engine::new(&pending.session, crossfade)?;
+            let (engine, lost_outputs) = Engine::new(&pending.session, crossfade, normalize)?;
             forward_events(&engine, lost_outputs, &tx, &state);
             anyhow::Ok((pending, Arc::new(engine)))
         };
diff --git a/crates/cloofy-tui/src/backend/ytmusic/mod.rs b/crates/cloofy-tui/src/backend/ytmusic/mod.rs
index ad68fcd..9319a84 100644
--- a/crates/cloofy-tui/src/backend/ytmusic/mod.rs
+++ b/crates/cloofy-tui/src/backend/ytmusic/mod.rs
@@ -111,6 +111,10 @@ impl Controller {
         self.0.set_volume(volume)
     }
 
+    pub fn set_normalize(&self, normalize: bool) {
+        let _ = self.0.set_normalize(normalize);
+    }
+
     pub fn shuffle(&self, on: bool) -> Result<()> {
         self.0.shuffle(on)
     }
diff --git a/crates/cloofy-tui/src/lib.rs b/crates/cloofy-tui/src/lib.rs
index ce5288a..d309ac2 100644
--- a/crates/cloofy-tui/src/lib.rs
+++ b/crates/cloofy-tui/src/lib.rs
@@ -214,12 +214,18 @@ async fn run_app(
         None => {
             let saved = state::load(&paths.state_file());
             let crossfade = Duration::from_secs(prefs.crossfade);
+            let normalize = prefs.normalize;
             let started: Vec<(Service, Result<Catalog, String>)> = accounts
                 .into_iter()
                 .zip(retries)
                 .map(|((service, account), retry_now)| {
                     let (paths, tx, volume) = (paths.clone(), tx.clone(), saved.volume);
-                    (service, account.map(|account| account.start(Launch { paths, crossfade, volume, retry_now, tx })))
+                    (
+                        service,
+                        account.map(|account| {
+                            account.start(Launch { paths, crossfade, normalize, volume, retry_now, tx })
+                        }),
+                    )
                 })
                 .collect();
             (app::Start::Restore(Box::new(saved)), started)
diff --git a/crates/cloofy-tui/src/overlay.rs b/crates/cloofy-tui/src/overlay.rs
index 5603d91..801595c 100644
--- a/crates/cloofy-tui/src/overlay.rs
+++ b/crates/cloofy-tui/src/overlay.rs
@@ -74,6 +74,7 @@ pub enum MenuAction {
     GoToAlbum,
     GoToArtist,
     CopyLink,
+    HideShelf,
 }
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
@@ -104,6 +105,8 @@ pub struct ContextTarget {
     pub liked_songs: bool,
     /// The queue entry a track of the queue page stands for: playing it skips ahead to it.
     pub upcoming: Option<crate::queue::Upcoming>,
+    /// The title of the Home shelf it is on, which the menu can hide.
+    pub shelf: Option<String>,
 }
 
 impl Overlay {
diff --git a/crates/cloofy-tui/src/preferences.rs b/crates/cloofy-tui/src/preferences.rs
index 5b91db1..8250d18 100644
--- a/crates/cloofy-tui/src/preferences.rs
+++ b/crates/cloofy-tui/src/preferences.rs
@@ -15,6 +15,10 @@ const CROSSFADE_STEPS: [u64; 5] = [0, 3, 6, 9, 12];
 pub struct Preferences {
     /// Seconds consecutive tracks overlap.
     pub crossfade: u64,
+    /// Every song at about the same loudness.
+    pub normalize: bool,
+    /// Titles of the shelves Home leaves out.
+    pub hidden_shelves: Vec<String>,
     pub covers: bool,
     pub images: ImageProtocol,
     pub colors: ColorChoice,
@@ -35,6 +39,8 @@ impl Preferences {
     pub fn from_config(config: &Config) -> Self {
         Self {
             crossfade: config.crossfade.unwrap_or(0).min(12),
+            normalize: config.normalize_volume == Some(true),
+            hidden_shelves: config.hidden_shelves.clone().unwrap_or_default(),
             covers: config.covers != Some(false),
             images: config.images.as_deref().and_then(ImageProtocol::parse).unwrap_or_default(),
             colors: match config.colors.as_deref() {
@@ -74,6 +80,9 @@ impl Preferences {
         match setting {
             Setting::Crossfade if self.crossfade == 0 => "Off".to_owned(),
             Setting::Crossfade => format!("{} s", self.crossfade),
+            Setting::Normalize => on_off(self.normalize),
+            Setting::HiddenShelves if self.hidden_shelves.is_empty() => "None".to_owned(),
+            Setting::HiddenShelves => format!("{} hidden", self.hidden_shelves.len()),
             Setting::Covers => on_off(self.covers),
             Setting::Images => self.images.label().to_owned(),
             Setting::Colors => self.colors.label().to_owned(),
@@ -88,10 +97,12 @@ impl Preferences {
     /// For settings that are switched rather than chosen: whether it's on.
     pub fn switch(&self, setting: Setting) -> Option<bool> {
         match setting {
+            Setting::Normalize => Some(self.normalize),
             Setting::Covers => Some(self.covers),
             Setting::Notifications => Some(self.notifications),
             Setting::UpdateCheck => Some(self.update_check),
             Setting::Crossfade
+            | Setting::HiddenShelves
             | Setting::Images
             | Setting::Colors
             | Setting::Accent
@@ -104,6 +115,9 @@ impl Preferences {
     pub fn step(&mut self, setting: Setting, forward: bool) {
         match setting {
             Setting::Crossfade => self.crossfade = cycle(&CROSSFADE_STEPS, &self.crossfade, forward),
+            Setting::Normalize => self.normalize = !self.normalize,
+            // Its one choice: every shelf shown again.
+            Setting::HiddenShelves => self.hidden_shelves.clear(),
             Setting::Covers => self.covers = !self.covers,
             Setting::Images => self.images = cycle(&ImageProtocol::ALL, &self.images, forward),
             Setting::Colors => self.colors = cycle(&ColorChoice::ALL, &self.colors, forward),
@@ -121,6 +135,12 @@ impl Preferences {
         let off = |on: bool| (!on).then(|| Value::from(false));
         match setting {
             Setting::Crossfade => ("crossfade", (self.crossfade > 0).then(|| Value::from(self.crossfade as i64))),
+            Setting::Normalize => ("normalize_volume", self.normalize.then(|| Value::from(true))),
+            Setting::HiddenShelves => (
+                "hidden_shelves",
+                (!self.hidden_shelves.is_empty())
+                    .then(|| self.hidden_shelves.iter().map(String::as_str).collect::<Value>()),
+            ),
             Setting::Covers => ("covers", off(self.covers)),
             Setting::Images => (
                 "images",
@@ -147,6 +167,8 @@ fn cycle<T: Clone + PartialEq>(items: &[T], current: &T, forward: bool) -> T {
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 pub enum Setting {
     Crossfade,
+    Normalize,
+    HiddenShelves,
     Covers,
     Images,
     Colors,
@@ -158,8 +180,9 @@ pub enum Setting {
 }
 
 /// The Settings page: section titles with their settings, in order.
-pub const SECTIONS: [(&str, &[Setting]); 4] = [
-    ("Playback", &[Setting::Crossfade]),
+pub const SECTIONS: [(&str, &[Setting]); 5] = [
+    ("Playback", &[Setting::Crossfade, Setting::Normalize]),
+    ("Home", &[Setting::HiddenShelves]),
     ("Display", &[Setting::Covers, Setting::Images, Setting::Colors, Setting::Accent, Setting::Icons]),
     ("Power", &[Setting::PowerSaving]),
     ("Notifications and updates", &[Setting::Notifications, Setting::UpdateCheck]),
@@ -174,6 +197,8 @@ impl Setting {
     pub fn label(self) -> &'static str {
         match self {
             Setting::Crossfade => "Crossfade",
+            Setting::Normalize => "Normalize volume",
+            Setting::HiddenShelves => "Hidden shelves",
             Setting::Covers => "Cover art",
             Setting::Images => "Cover images",
             Setting::Colors => "Colors",
@@ -188,6 +213,8 @@ impl Setting {
     pub fn description(self) -> &'static str {
         match self {
             Setting::Crossfade => "Let songs fade into each other.",
+            Setting::Normalize => "Play every song at about the same loudness.",
+            Setting::HiddenShelves => "Shelves you hid from Home with its menu. Enter shows them all again.",
             Setting::Covers => "Turn off to save memory and processor time on slower computers.",
             Setting::Images => "How covers reach the terminal. Blocks work in every terminal.",
             Setting::Colors => "Auto follows Omarchy's theme; Terminal takes the terminal's background and text.",
@@ -404,6 +431,7 @@ mod tests {
         assert!(Setting::all().all(|setting| preferences.entry(setting).1.is_none()));
         assert!(preferences.covers && preferences.notifications && preferences.update_check);
         assert_eq!(preferences.crossfade, 0);
+        assert!(!preferences.normalize);
     }
 
     #[test]
diff --git a/crates/cloofy-tui/src/scenarios/playback.rs b/crates/cloofy-tui/src/scenarios/playback.rs
index cb09d77..cd6ce77 100644
--- a/crates/cloofy-tui/src/scenarios/playback.rs
+++ b/crates/cloofy-tui/src/scenarios/playback.rs
@@ -4,7 +4,10 @@
 use std::time::Duration;
 
 use cloofy_core::{player::PlayerEvent, service::Service};
-use crossterm::event::KeyCode::{Char, Down, Enter};
+use crossterm::event::{
+    KeyCode,
+    KeyCode::{Char, Down, Enter},
+};
 
 use crate::{backend::fake::SONG, harness::Harness, views::View};
 
@@ -264,3 +267,41 @@ async fn the_bot_check_says_why_nothing_plays() {
     h.settle().await;
     assert!(!h.shows("prove it isn't a bot"), "{}", h.screen());
 }
+
+/// Normalize volume (#32) reaches every player at once, and the players that start later.
+#[tokio::test]
+async fn normalizing_the_volume_reaches_every_player() {
+    let mut h = Harness::fakes(&[SPOTIFY, YOUTUBE]).await;
+    h.press(Char(',')).await.click_on("Normalize volume").await;
+    assert!(h.shows("Play every song at about the same loudness."), "{}", h.screen());
+    h.press(Enter).await;
+    for service in [SPOTIFY, YOUTUBE] {
+        assert_eq!(h.fake(service).commands(), ["normalize true"], "{}", service.name());
+    }
+    h.press(Enter).await;
+    assert_eq!(h.fake(SPOTIFY).commands(), ["normalize true", "normalize false"]);
+}
+
+/// A shelf hidden from its menu (#31) is gone from Home until Settings shows them all again.
+#[tokio::test]
+async fn a_hidden_shelf_stays_away_until_settings_brings_it_back() {
+    let mut h = Harness::fakes(&[YOUTUBE]).await;
+    // The notice names the shelf, so its Play all tells whether the shelf itself is there.
+    assert!(h.shows("Play all") && h.shows("For you"), "{}", h.screen());
+    h.press(Char('.')).await.click_on("Hide this shelf").await;
+    assert!(!h.shows("Play all") && !h.shows("YouTube Music Song 4") && h.shows("For you"), "{}", h.screen());
+    assert!(h.shows("Hid “Quick picks” · Settings brings it back"), "{}", h.screen());
+
+    // Home loaded again leaves it out too.
+    h.press(Char('S')).await.press(Char('S')).await;
+    h.wait(Duration::from_secs(600)).await.press(Char('1')).await;
+    assert!(!h.shows("Play all"), "{}", h.screen());
+
+    h.press(Char(',')).await.click_on("Hidden shelves").await;
+    assert!(h.shows("1 hidden"), "{}", h.screen());
+    h.press(Enter).await;
+    assert!(!h.shows("1 hidden"), "{}", h.screen());
+    // Back on Home the shelf is there again, above the one that stayed selected.
+    h.press(KeyCode::Esc).await;
+    assert!(h.shows("YouTube Music Song 4") && h.shows("For you"), "{}", h.screen());
+}
diff --git a/crates/cloofy-tui/src/views.rs b/crates/cloofy-tui/src/views.rs
index e2924a9..53f2902 100644
--- a/crates/cloofy-tui/src/views.rs
+++ b/crates/cloofy-tui/src/views.rs
@@ -447,6 +447,24 @@ impl HomeView {
         }
     }
 
+    /// The title of the selected shelf, if it has one to hide it by.
+    pub fn shelf_title(&self) -> Option<&str> {
+        let shelf = self.home.as_ref()?.shelves.get(self.shelf).filter(|_| self.chip.is_none())?;
+        Some(shelf.title.trim()).filter(|title| !shelf.shortcuts && !title.is_empty())
+    }
+
+    /// Whether this view shows the whole Home rather than a chip's.
+    pub fn is_whole(&self) -> bool {
+        self.filter.is_none()
+    }
+
+    /// Takes the shelves titled as one of `hidden` out of the Home shown.
+    pub fn hide_shelves(&mut self, hidden: &[String]) {
+        if let Some(home) = self.home.clone() {
+            self.set_home(home.without_shelves(hidden));
+        }
+    }
+
     /// Shows a newer Home. Shelves and cards are found again by URI, so the selection and
     /// how far each shelf was paged survive the update.
     pub fn set_home(&mut self, home: Home) {
diff --git a/crates/cloofy-ytmusic/src/player/mod.rs b/crates/cloofy-ytmusic/src/player/mod.rs
index 2d33dfd..96e1cb5 100644
--- a/crates/cloofy-ytmusic/src/player/mod.rs
+++ b/crates/cloofy-ytmusic/src/player/mod.rs
@@ -67,6 +67,7 @@ enum Command {
     Previous,
     Seek(u32),
     Volume(u16),
+    Normalize(bool),
     Shuffle(bool),
     Repeat { context: bool, track: bool },
     ClearQueue,
@@ -97,7 +98,7 @@ impl Player {
         mpv_args: Vec<String>,
     ) -> Result<Player> {
         let (mpv_tx, mpv_rx) = mpsc::unbounded_channel();
-        let mpv = Mpv::spawn(&with_volume(&mpv_args, volume), mpv_tx.clone()).await?;
+        let mpv = Mpv::spawn(&mpv_options(&mpv_args, volume, false), mpv_tx.clone()).await?;
         let (commands, commands_rx) = mpsc::unbounded_channel();
         let (jobs, jobs_rx) = mpsc::unbounded_channel();
         let engine = Engine {
@@ -154,6 +155,11 @@ impl Player {
         self.send(Command::Volume(volume))
     }
 
+    /// Plays every song at about the same loudness, from now on.
+    pub fn set_normalize(&self, on: bool) -> Result<()> {
+        self.send(Command::Normalize(on))
+    }
+
     pub fn shuffle(&self, on: bool) -> Result<()> {
         self.send(Command::Shuffle(on))
     }
@@ -187,9 +193,20 @@ impl Player {
     }
 }
 
-fn with_volume(args: &[String], volume: u16) -> Vec<String> {
+/// mpv's filter that evens out loudness: EBU R 128 to -14 LUFS, what Spotify and YouTube aim
+/// for, with peaks kept under full scale. It measures loudness the way ears do, where a filter
+/// that goes by peaks leaves a loud master louder than a quiet one.
+const NORMALIZE_FILTER: &str = "@normalize:lavfi=[loudnorm=I=-14:TP=-1.5:LRA=11]";
+/// The filter's name, for taking it out again.
+const NORMALIZE_LABEL: &str = "@normalize";
+
+/// `args` with what mpv starts at: the volume, and the loudness filter when it's on.
+fn mpv_options(args: &[String], volume: u16, normalize: bool) -> Vec<String> {
     let mut args = args.to_vec();
     args.push(format!("--volume={}", mpv_volume(volume)));
+    if normalize {
+        args.push(format!("--af={NORMALIZE_FILTER}"));
+    }
     args
 }
 
@@ -274,6 +291,8 @@ struct Engine {
     /// A seek mpv took, to this position, and when.
     seeking: Option<(u32, Instant)>,
     volume: u16,
+    /// Whether mpv evens out loudness.
+    normalize: bool,
     active: bool,
     autoplay: Autoplay,
     /// When the song before ended, to log the gap to the next one.
@@ -321,6 +340,7 @@ impl Engine {
             duration_ms: None,
             seeking: None,
             volume,
+            normalize: false,
             active: false,
             autoplay: Autoplay::default(),
             ended_at: None,
@@ -383,6 +403,19 @@ impl Engine {
                 self.emit(PlayerEvent::VolumeChanged { volume });
                 Ok(())
             }
+            Command::Normalize(on) => {
+                let changed = std::mem::replace(&mut self.normalize, on) != on;
+                // An mpv started later gets the filter from the start.
+                if let Some(mpv) = self.mpv.as_mut().filter(|_| changed) {
+                    let filter = if on {
+                        json!(["af", "add", NORMALIZE_FILTER])
+                    } else {
+                        json!(["af", "remove", NORMALIZE_LABEL])
+                    };
+                    mpv.command(filter).await?;
+                }
+                Ok(())
+            }
             Command::Shuffle(on) => {
                 self.queue.set_shuffle(on);
                 if let Some(starting) = self.starting.as_mut() {
@@ -424,7 +457,8 @@ impl Engine {
     /// mpv, started again should it have gone away.
     async fn mpv(&mut self) -> Result<&mut Mpv> {
         if self.mpv.is_none() {
-            let mpv = Mpv::spawn(&with_volume(&self.mpv_args, self.volume), self.mpv_events.clone()).await?;
+            let options = mpv_options(&self.mpv_args, self.volume, self.normalize);
+            let mpv = Mpv::spawn(&options, self.mpv_events.clone()).await?;
             self.mpv = Some(mpv);
         }
         Ok(self.mpv.as_mut().expect("just started"))
@@ -1203,6 +1237,26 @@ mod tests {
         assert!(mpv.get("mpv-version").await.is_ok());
     }
 
+    #[tokio::test]
+    async fn normalizing_reaches_the_mpv_that_runs_and_the_one_after() {
+        let Some((mut engine, _events)) = engine("normalize").await else { return };
+        async fn filters(engine: &mut Engine) -> Vec<String> {
+            let filters = engine.mpv().await.unwrap().get("af").await.unwrap();
+            filters.as_array().unwrap().iter().map(|filter| filter["label"].as_str().unwrap_or("").to_owned()).collect()
+        }
+        assert!(filters(&mut engine).await.is_empty());
+        engine.command(Command::Normalize(true)).await.unwrap();
+        assert_eq!(filters(&mut engine).await, ["normalize"]);
+        // Asked twice, mpv still has it once.
+        engine.command(Command::Normalize(true)).await.unwrap();
+        assert_eq!(filters(&mut engine).await, ["normalize"]);
+        // mpv went away; the one started in its place evens out loudness from the start.
+        engine.mpv = None;
+        assert_eq!(filters(&mut engine).await, ["normalize"]);
+        engine.command(Command::Normalize(false)).await.unwrap();
+        assert!(filters(&mut engine).await.is_empty());
+    }
+
     #[tokio::test]
     async fn a_seek_mpv_turns_down_holds_nothing_back() {
         let Some((mut engine, (mut events, _))) = engine("seek").await else { return };
diff --git a/crates/cloofy/src/launcher.rs b/crates/cloofy/src/launcher.rs
new file mode 100644
index 0000000..7f8390d
--- /dev/null
+++ b/crates/cloofy/src/launcher.rs
@@ -0,0 +1,175 @@
+//! cloofy in the desktop's app menu on Linux: a desktop entry and an icon in the user's own
+//! folders, where GNOME, KDE Plasma, rofi, Walker and the like find them. The packages put the
+//! same two files in `/usr/share`; on Omarchy, `cloofy omarchy install` writes an entry of its
+//! own, which opens cloofy the way Omarchy opens its terminal apps.
+
+use std::{
+    env, fs,
+    path::{Path, PathBuf},
+    process::Command,
+};
+
+use anyhow::Result;
+use clap::Subcommand;
+
+use crate::{
+    omarchy::{self, remove_file, write_if_changed},
+    style,
+};
+
+/// The entry, which opens cloofy in the desktop's own terminal.
+const ENTRY: &str = include_str!("../../../integrations/linux/cloofy.desktop");
+pub const ICON: &str = include_str!("../../../integrations/omarchy/cloofy.svg");
+/// Marks the desktop entry as the one `install` wrote.
+const MARK: &str = "X-cloofy-launcher=true";
+
+#[derive(Subcommand)]
+pub enum Action {
+    /// Add cloofy and its icon to the app menu
+    Install,
+    /// Take them out again
+    Remove,
+}
+
+pub fn run(action: Action) -> Result<()> {
+    let Some(home) = env::var_os("HOME").map(PathBuf::from) else {
+        anyhow::bail!("HOME is not set, so there is no app menu to add cloofy to");
+    };
+    let launcher = Launcher { home };
+    let done = match action {
+        Action::Install => launcher.install()?,
+        Action::Remove => launcher.remove()?,
+    };
+    println!("  {}  {}", style::green("✓"), style::dim(done));
+    Ok(())
+}
+
+/// Whether the desktop entry at `path` is one cloofy wrote here.
+pub fn is_ours(path: &Path) -> bool {
+    fs::read_to_string(path).is_ok_and(|entry| entry.lines().any(|line| line.trim() == MARK))
+}
+
+struct Launcher {
+    home: PathBuf,
+}
+
+impl Launcher {
+    fn entry(&self) -> PathBuf {
+        self.home.join(".local/share/applications/cloofy.desktop")
+    }
+
+    fn icon(&self) -> PathBuf {
+        self.home.join(".local/share/icons/hicolor/scalable/apps/cloofy.svg")
+    }
+
+    fn install(&self) -> Result<&'static str> {
+        let entry = self.entry();
+        if omarchy::is_ours(&entry) {
+            return Ok("Omarchy's launcher for cloofy is there, so it stays");
+        }
+        if entry.exists() && !is_ours(&entry) {
+            return Ok("cloofy.desktop is your own, so it stays");
+        }
+        // An icon of the user's own stays, and the entry shows that one.
+        let icon = self.icon();
+        if fs::symlink_metadata(&icon).is_err() {
+            write_if_changed(&icon, ICON)?;
+        }
+        write_if_changed(&entry, ENTRY)?;
+        self.refresh();
+        Ok("cloofy is in the app menu")
+    }
+
+    fn remove(&self) -> Result<&'static str> {
+        if !is_ours(&self.entry()) {
+            return Ok("cloofy's entry in the app menu wasn't there");
+        }
+        remove_file(&self.entry())?;
+        if fs::read_to_string(self.icon()).is_ok_and(|icon| icon == ICON) {
+            remove_file(&self.icon())?;
+            // The folders `install` may have made for it, where nothing else is in them.
+            for dir in self.icon().ancestors().skip(1).take(2) {
+                let _ = fs::remove_dir(dir);
+            }
+        }
+        self.refresh();
+        Ok("cloofy is out of the app menu")
+    }
+
+    /// Tells the desktop about the change, where it has the tools for that; it finds out by
+    /// itself otherwise, at the latest when the user signs in again.
+    fn refresh(&self) {
+        let share = self.home.join(".local/share");
+        let _ = Command::new("update-desktop-database").arg(share.join("applications")).output();
+        let _ = Command::new("gtk-update-icon-cache").arg(share.join("icons/hicolor")).output();
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn scratch(name: &str) -> Launcher {
+        let home = env::temp_dir().join(format!("cloofy-launcher-{name}-{}", std::process::id()));
+        let _ = fs::remove_dir_all(&home);
+        Launcher { home }
+    }
+
+    /// What desktops read from an entry: the keys of its `[Desktop Entry]` group.
+    fn key<'a>(entry: &'a str, key: &str) -> Option<&'a str> {
+        entry.lines().find_map(|line| line.strip_prefix(key)?.strip_prefix('='))
+    }
+
+    #[test]
+    fn the_entry_opens_cloofy_in_a_terminal() {
+        assert_eq!(ENTRY.lines().next(), Some("[Desktop Entry]"));
+        assert_eq!(key(ENTRY, "Exec"), Some("cloofy"));
+        assert_eq!(key(ENTRY, "Terminal"), Some("true"));
+        assert_eq!(key(ENTRY, "Icon"), Some("cloofy"));
+        assert_eq!(key(ENTRY, "Categories"), Some("AudioVideo;Audio;Player;"));
+        assert!(ENTRY.lines().any(|line| line == MARK));
+    }
+
+    #[test]
+    fn installs_and_removes_the_entry_and_the_icon() {
+        let launcher = scratch("both");
+        launcher.install().unwrap();
+        assert!(is_ours(&launcher.entry()));
+        assert_eq!(fs::read_to_string(launcher.icon()).unwrap(), ICON);
+        launcher.remove().unwrap();
+        assert!(!launcher.entry().exists() && !launcher.icon().exists());
+        assert!(!launcher.home.join(".local/share/icons/hicolor/scalable").exists(), "the folders it made go too");
+        fs::remove_dir_all(&launcher.home).unwrap();
+    }
+
+    #[test]
+    fn leaves_an_entry_and_an_icon_of_the_user_s_own() {
+        let launcher = scratch("theirs");
+        let theirs = "[Desktop Entry]\nName=cloofy\nExec=kitty -e cloofy\n";
+        write_if_changed(&launcher.entry(), theirs).unwrap();
+        launcher.install().unwrap();
+        assert_eq!(fs::read_to_string(launcher.entry()).unwrap(), theirs);
+        assert!(!launcher.icon().exists(), "nothing to show an icon for");
+        launcher.remove().unwrap();
+        assert_eq!(fs::read_to_string(launcher.entry()).unwrap(), theirs);
+
+        fs::remove_file(launcher.entry()).unwrap();
+        let icon = "<svg><!-- mine --></svg>\n";
+        write_if_changed(&launcher.icon(), icon).unwrap();
+        launcher.install().unwrap();
+        launcher.remove().unwrap();
+        assert_eq!(fs::read_to_string(launcher.icon()).unwrap(), icon);
+        fs::remove_dir_all(&launcher.home).unwrap();
+    }
+
+    #[test]
+    fn leaves_omarchy_s_launcher() {
+        let launcher = scratch("omarchy");
+        let omarchy = "[Desktop Entry]\nName=cloofy\nExec=omarchy-launch-or-focus-tui cloofy\nX-cloofy-omarchy=true\n";
+        write_if_changed(&launcher.entry(), omarchy).unwrap();
+        launcher.install().unwrap();
+        launcher.remove().unwrap();
+        assert_eq!(fs::read_to_string(launcher.entry()).unwrap(), omarchy);
+        fs::remove_dir_all(&launcher.home).unwrap();
+    }
+}
diff --git a/crates/cloofy/src/main.rs b/crates/cloofy/src/main.rs
index ab66f91..41c3665 100644
--- a/crates/cloofy/src/main.rs
+++ b/crates/cloofy/src/main.rs
@@ -8,6 +8,8 @@
 mod doctor;
 #[cfg(any(feature = "spotify", feature = "ytmusic"))]
 mod headless;
+#[cfg(target_os = "linux")]
+mod launcher;
 #[cfg(any(feature = "spotify", feature = "ytmusic"))]
 mod media;
 #[cfg(target_os = "linux")]
@@ -95,6 +97,12 @@ enum Command {
         #[arg(long, default_value = "cloofy")]
         name: String,
     },
+    /// Add cloofy to the desktop's app menu, with its icon
+    #[cfg(target_os = "linux")]
+    Launcher {
+        #[command(subcommand)]
+        action: launcher::Action,
+    },
     /// Make cloofy part of Omarchy: a bar widget, the theme's colors, menu entries and a launcher
     #[cfg(target_os = "linux")]
     Omarchy {
@@ -182,6 +190,7 @@ async fn run() -> Result<()> {
         #[cfg(feature = "spotify")]
         Some(Command::DjSample { dir }) => spotify::dj_sample(&paths, &dir).await,
         #[cfg(target_os = "linux")]
+        Some(Command::Launcher { action }) => launcher::run(action),
         Some(Command::Omarchy { action }) => omarchy::run(action),
         None => update::restart_if_asked(cloofy_tui::run(&paths).await?),
     }
diff --git a/crates/cloofy/src/omarchy.rs b/crates/cloofy/src/omarchy.rs
index 0ea0afd..99909fb 100644
--- a/crates/cloofy/src/omarchy.rs
+++ b/crates/cloofy/src/omarchy.rs
@@ -18,7 +18,10 @@ use anyhow::{Context, Result};
 use clap::Subcommand;
 use cloofy_tui::omarchy as theme;
 
-use crate::style;
+use crate::{
+    launcher::{self, ICON},
+    style,
+};
 
 const PLUGIN_ID: &str = "cloofy.nowplaying";
 const PLUGIN: [(&str, &str); 4] = [
@@ -27,7 +30,6 @@ const PLUGIN: [(&str, &str); 4] = [
     ("Equalizer.qml", include_str!("../../../integrations/omarchy/plugin/Equalizer.qml")),
     ("Marquee.qml", include_str!("../../../integrations/omarchy/plugin/Marquee.qml")),
 ];
-const ICON: &str = include_str!("../../../integrations/omarchy/cloofy.svg");
 /// The theme templates earlier releases put in place, which `install` brings up to date and
 /// `remove` takes out as unedited. When the template changes, its old text goes here.
 const OLDER_TEMPLATES: &[&str] = &[];
@@ -344,7 +346,8 @@ impl Omarchy {
 
     fn install_launcher(&self) -> Result<Step> {
         let entry = self.desktop_entry();
-        if entry.exists() && !is_ours(&entry) {
+        // The entry `cloofy launcher install` wrote makes way for Omarchy's.
+        if entry.exists() && !is_ours(&entry) && !launcher::is_ours(&entry) {
             return Ok(Step::Nothing(format!("{} is your own, so it stays", entry.display())));
         }
         // An icon of the user's own stays, and the entry shows that one.
@@ -675,7 +678,7 @@ fn remove_block_from(path: &Path, comment: &str) -> Result<bool> {
     Ok(true)
 }
 
-fn is_ours(desktop_entry: &Path) -> bool {
+pub fn is_ours(desktop_entry: &Path) -> bool {
     fs::read_to_string(desktop_entry).is_ok_and(|entry| entry.lines().any(|line| line.trim() == DESKTOP_MARK))
 }
 
@@ -687,7 +690,7 @@ fn is_our_icon(icon: &Path) -> bool {
 /// Writes `content` unless the file has it already, through a temporary file so that a reader
 /// never sees half of it. A symlink, as stow or chezmoi put in place, stays one: the file it
 /// points to gets the content, and keeps its permissions.
-fn write_if_changed(path: &Path, content: &str) -> Result<()> {
+pub fn write_if_changed(path: &Path, content: &str) -> Result<()> {
     if fs::read_to_string(path).is_ok_and(|current| current == content) {
         return Ok(());
     }
@@ -718,7 +721,7 @@ fn link_target(path: &Path) -> PathBuf {
 }
 
 /// Removes a file; whether there was one.
-fn remove_file(path: &Path) -> Result<bool> {
+pub fn remove_file(path: &Path) -> Result<bool> {
     match fs::remove_file(path) {
         Ok(()) => Ok(true),
         Err(err) if err.kind() == io::ErrorKind::NotFound => Ok(false),
diff --git a/crates/cloofy/src/spotify/playback.rs b/crates/cloofy/src/spotify/playback.rs
index 16e2a58..d932c97 100644
--- a/crates/cloofy/src/spotify/playback.rs
+++ b/crates/cloofy/src/spotify/playback.rs
@@ -26,7 +26,7 @@ pub async fn play(paths: &Paths, input: &str, shuffle: bool) -> Result<()> {
     let uri = parse_uri(input)?;
     let pending = session::prepare(paths)?;
     let session = pending.session.clone();
-    let (engine, mut lost_outputs) = Engine::new(&session, Duration::ZERO)?;
+    let (engine, mut lost_outputs) = Engine::new(&session, Duration::ZERO, false)?;
     let mut player_events = engine.player.get_player_event_channel();
     let (spirc, task) = engine.connect_device(pending, DEVICE_NAME.into(), DEFAULT_VOLUME).await?;
     session::remember(paths, &session)?;
@@ -94,7 +94,7 @@ pub async fn play(paths: &Paths, input: &str, shuffle: bool) -> Result<()> {
 pub async fn connect(paths: &Paths, name: String) -> Result<()> {
     let pending = session::prepare(paths)?;
     let session = pending.session.clone();
-    let (engine, mut lost_outputs) = Engine::new(&pending.session, Duration::ZERO)?;
+    let (engine, mut lost_outputs) = Engine::new(&pending.session, Duration::ZERO, false)?;
     let mut player_events = engine.player.get_player_event_channel();
     let (spirc, task) = engine.connect_device(pending, name.clone(), DEFAULT_VOLUME).await?;
     session::remember(paths, &session)?;
diff --git a/install.sh b/install.sh
index b22345b..df3fd8d 100755
--- a/install.sh
+++ b/install.sh
@@ -601,6 +601,10 @@ if $uninstall; then
 			warn "Some of cloofy may be left in Omarchy's settings"
 		fi
 	fi
+	# Its entry in the app menu, which only the binary can tell from one of your own.
+	if [ "$(uname -s)" = Linux ] && "$bin" launcher --help </dev/null >/dev/null 2>&1; then
+		"$bin" launcher remove </dev/null >/dev/null 2>&1 || warn "cloofy may be left in the app menu"
+	fi
 	sudo=""
 	[ -w "$(dirname "$bin")" ] || sudo="sudo"
 	$sudo rm -f "$bin"
@@ -833,6 +837,13 @@ else
 	if [ -n "$installed_variant" ] && [ "$installed_variant" != "$variant" ]; then
 		note "In place of the build for $(variant_name "$installed_variant"). Settings and sign-ins stay."
 	fi
+	# The desktop's app menu and launchers find cloofy by its entry. Omarchy has a launcher of
+	# its own, below; releases before 0.5.3 have neither.
+	if [ "$os" = linux ] && ! $omarchy && "$bin" launcher --help </dev/null >/dev/null 2>&1; then
+		if "$bin" launcher install </dev/null >/dev/null 2>&1; then
+			ok "Added cloofy to the app menu"
+		fi
+	fi
 fi
 
 # Kept as they are with --yes: there may be fewer turned on than the build has.
diff --git a/integrations/linux/cloofy.desktop b/integrations/linux/cloofy.desktop
new file mode 100644
index 0000000..abca7db
--- /dev/null
+++ b/integrations/linux/cloofy.desktop
@@ -0,0 +1,12 @@
+[Desktop Entry]
+Version=1.0
+Type=Application
+Name=cloofy
+GenericName=Music Player
+Comment=Spotify and YouTube Music in your terminal
+Exec=cloofy
+Icon=cloofy
+Terminal=true
+Categories=AudioVideo;Audio;Player;
+Keywords=music;spotify;youtube;player;
+X-cloofy-launcher=true
diff --git a/packaging/aur/cloofy-bin/PKGBUILD b/packaging/aur/cloofy-bin/PKGBUILD
index 075e7c2..b135c12 100644
--- a/packaging/aur/cloofy-bin/PKGBUILD
+++ b/packaging/aur/cloofy-bin/PKGBUILD
@@ -21,6 +21,8 @@ sha256sums_aarch64=('@SHA256_SPOTIFY_AARCH64_UNKNOWN_LINUX_GNU@')
 
 package() {
   install -Dm755 cloofy "$pkgdir/usr/bin/cloofy"
+  install -Dm644 cloofy.desktop "$pkgdir/usr/share/applications/cloofy.desktop"
+  install -Dm644 cloofy.svg "$pkgdir/usr/share/icons/hicolor/scalable/apps/cloofy.svg"
   install -Dm644 LICENSE "$pkgdir/usr/share/licenses/$pkgname/LICENSE"
   install -Dm644 README.md "$pkgdir/usr/share/doc/$pkgname/README.md"
 }
diff --git a/packaging/aur/cloofy-full-bin/PKGBUILD b/packaging/aur/cloofy-full-bin/PKGBUILD
index 78076f6..a0df5bc 100644
--- a/packaging/aur/cloofy-full-bin/PKGBUILD
+++ b/packaging/aur/cloofy-full-bin/PKGBUILD
@@ -23,6 +23,8 @@ sha256sums_aarch64=('@SHA256_FULL_AARCH64_UNKNOWN_LINUX_GNU@')
 
 package() {
   install -Dm755 cloofy "$pkgdir/usr/bin/cloofy"
+  install -Dm644 cloofy.desktop "$pkgdir/usr/share/applications/cloofy.desktop"
+  install -Dm644 cloofy.svg "$pkgdir/usr/share/icons/hicolor/scalable/apps/cloofy.svg"
   install -Dm644 LICENSE "$pkgdir/usr/share/licenses/$pkgname/LICENSE"
   install -Dm644 README.md "$pkgdir/usr/share/doc/$pkgname/README.md"
 }
diff --git a/packaging/aur/cloofy-ytmusic-bin/PKGBUILD b/packaging/aur/cloofy-ytmusic-bin/PKGBUILD
index d7b0249..c20700d 100644
--- a/packaging/aur/cloofy-ytmusic-bin/PKGBUILD
+++ b/packaging/aur/cloofy-ytmusic-bin/PKGBUILD
@@ -23,6 +23,8 @@ sha256sums_aarch64=('@SHA256_YTMUSIC_AARCH64_UNKNOWN_LINUX_GNU@')
 
 package() {
   install -Dm755 cloofy "$pkgdir/usr/bin/cloofy"
+  install -Dm644 cloofy.desktop "$pkgdir/usr/share/applications/cloofy.desktop"
+  install -Dm644 cloofy.svg "$pkgdir/usr/share/icons/hicolor/scalable/apps/cloofy.svg"
   install -Dm644 LICENSE "$pkgdir/usr/share/licenses/$pkgname/LICENSE"
   install -Dm644 README.md "$pkgdir/usr/share/doc/$pkgname/README.md"
 }
diff --git a/packaging/aur/cloofy/PKGBUILD b/packaging/aur/cloofy/PKGBUILD
index 720cf21..d89f776 100644
--- a/packaging/aur/cloofy/PKGBUILD
+++ b/packaging/aur/cloofy/PKGBUILD
@@ -51,6 +51,8 @@ check() {
 package() {
   cd "$pkgname"
   install -Dm755 target/release/cloofy "$pkgdir/usr/bin/cloofy"
+  install -Dm644 integrations/linux/cloofy.desktop "$pkgdir/usr/share/applications/cloofy.desktop"
+  install -Dm644 integrations/omarchy/cloofy.svg "$pkgdir/usr/share/icons/hicolor/scalable/apps/cloofy.svg"
   install -Dm644 LICENSE "$pkgdir/usr/share/licenses/$pkgname/LICENSE"
   install -Dm644 README.md "$pkgdir/usr/share/doc/$pkgname/README.md"
 }
diff --git a/vendor/librespot b/vendor/librespot
index 3bfc3f2..5f30142 160000
--- a/vendor/librespot
+++ b/vendor/librespot
@@ -1 +1 @@
-Subproject commit 3bfc3f202de610f620b034010ed44763967fdc9b
+Subproject commit 5f301423104ca46471394b143ebc5dc215c176ce
diff --git a/website/src/content/docs/docs/install.mdx b/website/src/content/docs/docs/install.mdx
index b84a9cf..b13a023 100644
--- a/website/src/content/docs/docs/install.mdx
+++ b/website/src/content/docs/docs/install.mdx
@@ -29,7 +29,7 @@ curl -fsSL https://cloofy.app/install.sh | bash -s -- --service ytmusic
 | --- | --- |
 | `--service S` | Installs `spotify`, `ytmusic` or `both` without asking about it |
 | `--yes` | Asks nothing: the services you have, or Spotify the first time; sign in later |
-| `--uninstall` | Removes cloofy and its Omarchy setup, and its settings and sign-ins if you want |
+| `--uninstall` | Removes cloofy, its entry in the app menu and its Omarchy setup, and its settings and sign-ins if you want |
 
 `CLOOFY_INSTALL_DIR` puts the binary somewhere else than `~/.local/bin`, and `CLOOFY_VERSION` installs a release such as `v0.5.0` instead of the latest.
 
diff --git a/website/src/content/docs/docs/settings.md b/website/src/content/docs/docs/settings.md
index 895f0df..fd48a70 100644
--- a/website/src/content/docs/docs/settings.md
+++ b/website/src/content/docs/docs/settings.md
@@ -3,7 +3,7 @@ title: Settings
 description: cloofy's Settings page, and every option of config.toml.
 ---
 
-<kbd>,</kbd>, the command palette, or a click on your name in the top bar opens the Settings page: crossfade, cover art and how covers are drawn, the colors, the accent color, icons, power saving, song notifications and update checks. Changes apply at once and cloofy saves them in `~/.config/cloofy/config.toml`, so there's no need to edit the file.
+<kbd>,</kbd>, the command palette, or a click on your name in the top bar opens the Settings page: crossfade, volume normalization, the shelves hidden from Home, cover art and how covers are drawn, the colors, the accent color, icons, power saving, song notifications and update checks. Changes apply at once and cloofy saves them in `~/.config/cloofy/config.toml`, so there's no need to edit the file.
 
 ## config.toml
 
@@ -13,6 +13,8 @@ You still can; it's read at start:
 client_id = "your client id"
 services = ["ytmusic"]     # "spotify", "ytmusic" or both, in the switch's order; every one built in when missing
 crossfade = 6              # seconds tracks overlap, 0 to 12; off when missing
+normalize_volume = true    # every song at about the same loudness; off when missing
+hidden_shelves = ["Covers and remixes"]  # shelves Home leaves out, by title
 covers = false             # no cover art, for slower computers; on when missing
 colors = "terminal"        # "cloofy" or "terminal"; Omarchy's theme there, cloofy's own elsewhere, when missing
 accent = "violet"          # "theme", "green", "violet", "pink", "blue" or "orange"; follows the cover when missing

From bbfeb586907dddd2c6ddeafed4041715583280dd Mon Sep 17 00:00:00 2001
From: Paul Otto <paul@cloo-gmbh-de>
Date: Thu, 12 Nov 2026 11:10:51 +0100
Subject: [PATCH 3/7] chore: version 0.5.3

Co-Authored-By: Claude Fable 5.2 <noreply@anthropic.com>
---
 Cargo.lock | 14 +++++++-------
 Cargo.toml |  2 +-
 2 files changed, 8 insertions(+), 8 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index eec6678..d0b4a75 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -436,7 +436,7 @@ checksum = "1c133bc6a41be0d194c306b5506d15e6feeea7b1d6604bd3f8310dfb2ca96486"
 
 [[package]]
 name = "cloofy"
-version = "0.5.2"
+version = "0.5.3"
 dependencies = [
  "anyhow",
  "clap",
@@ -461,7 +461,7 @@ dependencies = [
 
 [[package]]
 name = "cloofy-core"
-version = "0.5.2"
+version = "0.5.3"
 dependencies = [
  "anyhow",
  "cloofy-os",
@@ -480,7 +480,7 @@ dependencies = [
 
 [[package]]
 name = "cloofy-os"
-version = "0.5.2"
+version = "0.5.3"
 dependencies = [
  "block2",
  "dispatch2",
@@ -501,7 +501,7 @@ dependencies = [
 
 [[package]]
 name = "cloofy-player"
-version = "0.5.2"
+version = "0.5.3"
 dependencies = [
  "anyhow",
  "cloofy-core",
@@ -515,7 +515,7 @@ dependencies = [
 
 [[package]]
 name = "cloofy-spotify"
-version = "0.5.2"
+version = "0.5.3"
 dependencies = [
  "anyhow",
  "base64 0.23.1",
@@ -538,7 +538,7 @@ dependencies = [
 
 [[package]]
 name = "cloofy-tui"
-version = "0.5.2"
+version = "0.5.3"
 dependencies = [
  "anyhow",
  "base64 0.23.1",
@@ -572,7 +572,7 @@ dependencies = [
 
 [[package]]
 name = "cloofy-ytmusic"
-version = "0.5.2"
+version = "0.5.3"
 dependencies = [
  "anyhow",
  "cloofy-core",
diff --git a/Cargo.toml b/Cargo.toml
index 142f8de..9901a05 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -5,7 +5,7 @@ members = ["crates/*"]
 exclude = ["vendor"]
 
 [workspace.package]
-version = "0.5.2"
+version = "0.5.3"
 edition = "2024"
 rust-version = "1.90"
 license = "MIT"

From aa90db8bb7d02c1586c8571591740504af67d711 Mon Sep 17 00:00:00 2001
From: Paul Otto <paul@cloo-gmbh-de>
Date: Thu, 12 Nov 2026 11:10:51 +0100
Subject: [PATCH 4/7] chore(release): 0.5.3

Co-Authored-By: Claude Fable 5.2 <noreply@anthropic.com>
---
 CHANGELOG.md | 7 ++++++-
 1 file changed, 6 insertions(+), 1 deletion(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 63fa80b..b52066a 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -4,6 +4,10 @@ All notable changes to cloofy. The format follows [Keep a Changelog](https://kee
 
 ## [Unreleased]
 
+## [0.5.3] - 2026-11-12
+
+What you asked for: every song at the same loudness, shelves you can hide, cloofy in the app menu on Linux, and a YouTube Music sign-in that lasts.
+
 ### Added
 
 - **Normalize volume.** A new setting under Playback plays every song at about the same loudness, on Spotify with the loudness Spotify measured for each track, on YouTube Music with mpv's loudness filter, at the level Spotify and YouTube aim for. It applies at once, to the song that plays ([#32](https://github.com/parda21/cloofy/issues/32)).
@@ -176,7 +180,8 @@ The first release.
 - **Session restore.** The page, the selection and the last track come back after a restart.
 - **Installer.** It sets everything up step by step.
 
-[Unreleased]: https://github.com/parda21/cloofy/compare/v0.5.2...HEAD
+[Unreleased]: https://github.com/parda21/cloofy/compare/v0.5.3...HEAD
+[0.5.3]: https://github.com/parda21/cloofy/compare/v0.5.2...v0.5.3
 [0.5.2]: https://github.com/parda21/cloofy/compare/v0.5.1...v0.5.2
 [0.5.1]: https://github.com/parda21/cloofy/compare/v0.5.0...v0.5.1
 [0.5.0]: https://github.com/parda21/cloofy/compare/v0.4.0...v0.5.0

From 0cc1629a29eeec12ef47acd59e595c9656ddf6f2 Mon Sep 17 00:00:00 2001
From: Paul Otto <paul@cloo-gmbh-de>
Date: Thu, 12 Nov 2026 11:18:26 +0100
Subject: [PATCH 5/7] fix(cli): the Omarchy command is for Linux only again

Adding the launcher command took the cfg off its match arm, so macOS
didn't build.

Co-Authored-By: Claude Fable 5.2 <noreply@anthropic.com>
---
 crates/cloofy/src/main.rs | 1 +
 1 file changed, 1 insertion(+)

diff --git a/crates/cloofy/src/main.rs b/crates/cloofy/src/main.rs
index 41c3665..84051ce 100644
--- a/crates/cloofy/src/main.rs
+++ b/crates/cloofy/src/main.rs
@@ -191,6 +191,7 @@ async fn run() -> Result<()> {
         Some(Command::DjSample { dir }) => spotify::dj_sample(&paths, &dir).await,
         #[cfg(target_os = "linux")]
         Some(Command::Launcher { action }) => launcher::run(action),
+        #[cfg(target_os = "linux")]
         Some(Command::Omarchy { action }) => omarchy::run(action),
         None => update::restart_if_asked(cloofy_tui::run(&paths).await?),
     }

From 389b40816ccbd0d21c0f9f3f7fe5a32cefc6f867 Mon Sep 17 00:00:00 2001
From: Paul Otto <paul@cloo-gmbh-de>
Date: Thu, 12 Nov 2026 11:32:41 +0100
Subject: [PATCH 6/7] docs(website): what's new in 0.5.3

Co-Authored-By: Claude Fable 5.2 <noreply@anthropic.com>
---
 website/src/pages/index.astro | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/website/src/pages/index.astro b/website/src/pages/index.astro
index 910234f..da10333 100644
--- a/website/src/pages/index.astro
+++ b/website/src/pages/index.astro
@@ -88,7 +88,7 @@ const initial = commands(builds.ytmusic);
 			<section class="hero">
 				<canvas id="field" aria-hidden="true"></canvas>
 				<div class="hero-inner">
-					<a class="pill" href="/changelog/">What's new in 0.5.2: YouTube Music's Home <span aria-hidden="true">→</span></a>
+					<a class="pill" href="/changelog/">What's new in 0.5.3: normalize volume, hide shelves <span aria-hidden="true">→</span></a>
 					<h1 class="wordmark"><img src="/logo.svg" alt="cloofy" width="504" height="120" /></h1>
 					<p class="tagline">Spotify and YouTube Music in your terminal.</p>
 					<p class="sub">Plays on its own, with Home, Spotify's DJ, synced lyrics, real cover art and a mouse that works everywhere.</p>

From 71568911bf5e96442755b94eb3dcb315caa7856a Mon Sep 17 00:00:00 2001
From: Paul Otto <paul@cloo-gmbh-de>
Date: Thu, 12 Nov 2026 11:38:47 +0100
Subject: [PATCH 7/7] fix: from the review on #34

- ytmusic: a 401 or 403 from account_menu counts as a sign-in YouTube
  turned down, like a page without an account, and a refusal later in a
  run makes the next library request ask again. Cookies read from the
  browser again are kept only for an account told by its channel or
  handle, never by its name. An answer to the cookies before no longer
  writes over the renewed ones, and a save that failed is tried again.
- A player hears the normalize setting as it is when it starts, and
  cloofy play and cloofy connect follow it too.
- Hiding a shelf reaches the other service's pages and leaves a mood
  that is still loading alone; showing them again uses each service's
  own Home.
- The user's desktop entry starts cloofy by its path, for desktops whose
  PATH lacks the folder it was installed to.
- Docs: which sign-ins need cloofy login ytmusic --force once.

Co-Authored-By: Claude Fable 5.2 <noreply@anthropic.com>
---
 CHANGELOG.md                                  |  6 +--
 README.md                                     |  2 +-
 crates/cloofy-tui/src/app/browsing.rs         | 13 +++++
 crates/cloofy-tui/src/app/mod.rs              |  5 +-
 crates/cloofy-tui/src/app/settings.rs         |  7 ++-
 crates/cloofy-tui/src/backend/fake.rs         |  7 ++-
 crates/cloofy-tui/src/views.rs                |  3 ++
 crates/cloofy-ytmusic/src/auth.rs             | 15 ++++--
 crates/cloofy-ytmusic/src/innertube.rs        | 49 ++++++++++++++++---
 crates/cloofy-ytmusic/src/lib.rs              | 24 ++++++---
 crates/cloofy-ytmusic/src/library.rs          | 10 ++--
 crates/cloofy/src/launcher.rs                 | 42 +++++++++++++++-
 crates/cloofy/src/spotify/playback.rs         | 11 +++--
 crates/cloofy/src/ytmusic/playback.rs         |  6 ++-
 .../src/content/docs/docs/youtube-music.md    |  2 +-
 15 files changed, 166 insertions(+), 36 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index b52066a..6dbb430 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -10,13 +10,13 @@ What you asked for: every song at the same loudness, shelves you can hide, cloof
 
 ### Added
 
-- **Normalize volume.** A new setting under Playback plays every song at about the same loudness, on Spotify with the loudness Spotify measured for each track, on YouTube Music with mpv's loudness filter, at the level Spotify and YouTube aim for. It applies at once, to the song that plays ([#32](https://github.com/parda21/cloofy/issues/32)).
+- **Normalize volume.** A new setting under Playback plays every song at about the same loudness, on Spotify with the loudness Spotify measured for each track, on YouTube Music with mpv's loudness filter, at the level Spotify and YouTube aim for. It applies at once, to the song that plays, and to `cloofy play` and `cloofy connect` ([#32](https://github.com/parda21/cloofy/issues/32)).
 - **Hide a shelf on Home.** The menu of anything on a shelf (<kbd>.</kbd> or a right-click) has **Hide this shelf**, on both services; the shelf stays away after a restart. **Hidden shelves** on the Settings page shows them all again ([#31](https://github.com/parda21/cloofy/issues/31)).
-- **cloofy in the app menu on Linux.** The installer and the Arch packages add a desktop entry and cloofy's icon, so GNOME, KDE Plasma, rofi or Walker find it; it opens in the desktop's terminal. `cloofy launcher install` and `cloofy launcher remove` do the same by hand, and `--uninstall` takes it out again. On Omarchy the launcher stays the one of `cloofy omarchy install` ([#30](https://github.com/parda21/cloofy/issues/30)).
+- **cloofy in the app menu on Linux.** The installer and the Arch packages add a desktop entry and cloofy's icon, so GNOME, KDE Plasma, rofi or Walker find it; it opens in the desktop's terminal. The installer's entry starts cloofy by its path, so it works where the desktop doesn't look in `~/.local/bin`. `cloofy launcher install` and `cloofy launcher remove` do the same by hand, and `--uninstall` takes it out again. On Omarchy the launcher stays the one of `cloofy omarchy install` ([#30](https://github.com/parda21/cloofy/issues/30)).
 
 ### Fixed
 
-- **Signed out of YouTube Music after a day or two.** A browser that goes on using its sign-in gets new cookies for it, and the ones cloofy copied stop working. When YouTube no longer takes them, cloofy now reads them from the same browser again, once per start, and keeps them only if they are still the same account's; otherwise it asks you to sign in as before. Sign-ins made with 0.5.2 or older, and pasted ones, don't say which browser they came from: run `cloofy login ytmusic --force` once ([#26](https://github.com/parda21/cloofy/issues/26)).
+- **Signed out of YouTube Music after a day or two.** A browser that goes on using its sign-in gets new cookies for it, and the ones cloofy copied stop working. When YouTube no longer takes them, cloofy now reads them from the same browser again, once per start, and keeps them only if they are still the same account's, told by its channel or handle; otherwise it asks you to sign in as before. Sign-ins made with 0.5.2 or older, and pasted ones, don't say which browser they came from: run `cloofy login ytmusic --force` once ([#26](https://github.com/parda21/cloofy/issues/26)).
 
 ## [0.5.2] - 2026-11-10
 
diff --git a/README.md b/README.md
index f4edfbc..b9d53aa 100644
--- a/README.md
+++ b/README.md
@@ -303,7 +303,7 @@ YouTube protects its audio streams with challenges that only a JavaScript runtim
 <details>
 <summary><b>Is signing in to YouTube Music with my browser's cookies safe?</b></summary>
 
-`cloofy login ytmusic` has yt-dlp export the browser's cookies into a private folder, keeps only youtube.com's, and deletes the export right away. They stay in `~/.local/share/cloofy/ytmusic/cookies.txt`, which only you can read, or in the macOS Keychain with `credentials = "keychain"`. cloofy sends them only to music.youtube.com, with its own requests there; streams, covers and lyrics from LRCLIB load without them. They are a signed-in session like the browser's, so treat the file like a password. `cloofy logout ytmusic` deletes it. A browser that goes on using its sign-in gets new cookies for it, so after a day or two YouTube may stop taking cloofy's copy: cloofy then reads them from the same browser again, the same way, and keeps them only when they still sign in the same account.
+`cloofy login ytmusic` has yt-dlp export the browser's cookies into a private folder, keeps only youtube.com's, and deletes the export right away. They stay in `~/.local/share/cloofy/ytmusic/cookies.txt`, which only you can read, or in the macOS Keychain with `credentials = "keychain"`. cloofy sends them only to music.youtube.com, with its own requests there; streams, covers and lyrics from LRCLIB load without them. They are a signed-in session like the browser's, so treat the file like a password. `cloofy logout ytmusic` deletes it. A browser that goes on using its sign-in gets new cookies for it, so after a day or two YouTube may stop taking cloofy's copy: cloofy then reads them from the same browser again, the same way, and keeps them only when they still sign in the same account. A sign-in made before cloofy 0.5.3, or from a pasted Cookie header, doesn't say which browser it came from: run `cloofy login ytmusic --force` once to sign in with a browser.
 </details>
 
 <details>
diff --git a/crates/cloofy-tui/src/app/browsing.rs b/crates/cloofy-tui/src/app/browsing.rs
index eb05271..46dd51e 100644
--- a/crates/cloofy-tui/src/app/browsing.rs
+++ b/crates/cloofy-tui/src/app/browsing.rs
@@ -80,6 +80,19 @@ impl Browsing {
         std::iter::once(&mut self.view).chain(self.history.iter_mut())
     }
 
+    /// Shows this service's Home as it was loaded, on its pages that show the whole Home: for
+    /// when no shelf is hidden any more.
+    pub(super) fn show_whole_home(&mut self) {
+        let Some(home) = self.home_cache.clone() else { return };
+        for view in std::iter::once(&mut self.view).chain(self.history.iter_mut()) {
+            if let View::Home(shown) = view
+                && shown.is_whole()
+            {
+                shown.set_home(home.clone());
+            }
+        }
+    }
+
     /// Where its pages were left, for the next start.
     fn page(&self) -> Page {
         super::persist::page(&self.view, &self.history, self.focus, &self.nav, self.library_filter)
diff --git a/crates/cloofy-tui/src/app/mod.rs b/crates/cloofy-tui/src/app/mod.rs
index 23ccbe5..69467a8 100644
--- a/crates/cloofy-tui/src/app/mod.rs
+++ b/crates/cloofy-tui/src/app/mod.rs
@@ -1031,9 +1031,8 @@ impl App {
         let service = player.service();
         self.player_errors.remove(&service);
         player.set_crossfade(Duration::from_secs(self.prefs.crossfade));
-        if self.prefs.normalize {
-            player.set_normalize(true);
-        }
+        // As the setting is now: it may have changed since the player was started with it.
+        player.set_normalize(self.prefs.normalize);
         self.players.insert(service, player);
         // Until something plays, the player of the service shown is the one that would.
         if self.active.is_none() || (self.now.track.is_none() && self.loader.service() == Some(service)) {
diff --git a/crates/cloofy-tui/src/app/settings.rs b/crates/cloofy-tui/src/app/settings.rs
index b3e0400..a1c74b1 100644
--- a/crates/cloofy-tui/src/app/settings.rs
+++ b/crates/cloofy-tui/src/app/settings.rs
@@ -147,7 +147,9 @@ impl App {
             self.prefs.hidden_shelves.push(title.clone());
         }
         let hidden = self.prefs.hidden_shelves.clone();
-        for view in std::iter::once(&mut self.view).chain(self.history.iter_mut()) {
+        // The other services' pages too: a title may be on more than one Home.
+        let parked = self.parked.values_mut().flat_map(super::browsing::Browsing::views_mut);
+        for view in std::iter::once(&mut self.view).chain(self.history.iter_mut()).chain(parked) {
             if let View::Home(home) = view {
                 home.hide_shelves(&hidden);
             }
@@ -159,6 +161,9 @@ impl App {
     /// With no shelf hidden any more: Home shows what it was loaded with. A chip's Home has
     /// them back the next time it loads.
     fn show_hidden_shelves(&mut self) {
+        for parked in self.parked.values_mut() {
+            parked.show_whole_home();
+        }
         let Some(home) = self.home_cache.clone() else { return };
         for view in std::iter::once(&mut self.view).chain(self.history.iter_mut()) {
             if let View::Home(shown) = view
diff --git a/crates/cloofy-tui/src/backend/fake.rs b/crates/cloofy-tui/src/backend/fake.rs
index 1f25f24..e6c9813 100644
--- a/crates/cloofy-tui/src/backend/fake.rs
+++ b/crates/cloofy-tui/src/backend/fake.rs
@@ -40,6 +40,8 @@ struct State {
     playing: Option<Playing>,
     /// Home fails to load from now on.
     home_down: bool,
+    /// Whether loudness is evened out.
+    normalize: bool,
 }
 
 struct Playing {
@@ -268,8 +270,11 @@ impl Fake {
         Ok(())
     }
 
+    /// Recorded when it changes something: a player hears the setting whenever it starts.
     pub fn set_normalize(&self, normalize: bool) {
-        self.record(format!("normalize {normalize}"));
+        if std::mem::replace(&mut self.state().normalize, normalize) != normalize {
+            self.record(format!("normalize {normalize}"));
+        }
     }
 
     pub fn shuffle(&self, on: bool) -> Result<()> {
diff --git a/crates/cloofy-tui/src/views.rs b/crates/cloofy-tui/src/views.rs
index 53f2902..7992666 100644
--- a/crates/cloofy-tui/src/views.rs
+++ b/crates/cloofy-tui/src/views.rs
@@ -461,7 +461,10 @@ impl HomeView {
     /// Takes the shelves titled as one of `hidden` out of the Home shown.
     pub fn hide_shelves(&mut self, hidden: &[String]) {
         if let Some(home) = self.home.clone() {
+            // A chip's Home may still be on its way: what it falls back to and the wait stay.
+            let (fallback, loading) = (self.fallback.clone(), self.loading);
             self.set_home(home.without_shelves(hidden));
+            (self.fallback, self.loading) = (fallback, loading);
         }
     }
 
diff --git a/crates/cloofy-ytmusic/src/auth.rs b/crates/cloofy-ytmusic/src/auth.rs
index a8f6abe..8d2f835 100644
--- a/crates/cloofy-ytmusic/src/auth.rs
+++ b/crates/cloofy-ytmusic/src/auth.rs
@@ -281,10 +281,12 @@ pub(crate) async fn renew(api: &InnerTube, paths: &Paths) -> Result<User> {
     Ok(user)
 }
 
-/// Whether `user` is the account the sign-in was made for. One from before cloofy kept the
-/// account passes: the browser's account at the same place is the best there is to go by.
+/// Whether `user` is the account the sign-in was made for, by an ID that is the account's
+/// alone: its channel or its handle. A name is not, as two accounts may share one, and with
+/// nothing kept to compare there is nothing to go by; the user signs in again then.
 fn same_account(origin: &Origin, user: &User) -> bool {
-    origin.user.as_ref().is_none_or(|id| *id == user.id)
+    let unique = |id: &str| id.starts_with("UC") || id.starts_with('@');
+    origin.user.as_deref().is_some_and(|id| unique(id) && id == user.id)
 }
 
 /// The cookies of youtube.com in the browser of `spec`, and what yt-dlp printed to stderr.
@@ -468,7 +470,12 @@ mod tests {
         let kept = Origin { browser: Some("firefox".into()), user: Some("UCabc".into()) };
         assert!(same_account(&kept, &user("UCabc")));
         assert!(!same_account(&kept, &user("UCother")), "the browser signed in to another account");
-        assert!(same_account(&Origin::default(), &user("UCother")), "nothing kept to compare with");
+        assert!(!same_account(&Origin::default(), &user("UCabc")), "nothing kept to compare with");
+        let handle = Origin { user: Some("@someone".into()), ..kept.clone() };
+        assert!(same_account(&handle, &user("@someone")));
+        // Without a channel or a handle the ID is the name, which two accounts may share.
+        let named = Origin { user: Some("Someone".into()), ..kept };
+        assert!(!same_account(&named, &user("Someone")));
     }
 
     #[test]
diff --git a/crates/cloofy-ytmusic/src/innertube.rs b/crates/cloofy-ytmusic/src/innertube.rs
index a4cc252..5f19235 100644
--- a/crates/cloofy-ytmusic/src/innertube.rs
+++ b/crates/cloofy-ytmusic/src/innertube.rs
@@ -55,6 +55,9 @@ pub(crate) struct InnerTube {
 
 struct Auth {
     jar: Jar,
+    /// Counts the times the cookies were replaced as a whole. A response to a request sent
+    /// with the cookies before says nothing about the new ones.
+    generation: u64,
     identity: Identity,
     origin: Origin,
     /// Where the cookies are kept; `None` for a sign-in that isn't kept, or no longer is.
@@ -109,6 +112,11 @@ impl InnerTube {
         *self.visitor.lock().unwrap() = None;
     }
 
+    /// Which cookies requests go out with now, see [`Auth::generation`].
+    fn generation(&self) -> u64 {
+        self.auth.lock().unwrap().as_ref().map_or(0, |auth| auth.generation)
+    }
+
     /// Where the sign-in came from; `None` signed out.
     pub fn origin(&self) -> Option<Origin> {
         self.auth.lock().unwrap().as_ref().map(|auth| auth.origin.clone())
@@ -127,6 +135,7 @@ impl InnerTube {
     pub fn renew(&self, jar: Jar) {
         if let Some(auth) = self.auth.lock().unwrap().as_mut() {
             auth.jar = jar;
+            auth.generation += 1;
             auth.save();
         }
         *self.visitor.lock().unwrap() = None;
@@ -190,6 +199,7 @@ impl InnerTube {
         }
         let url = format!("{API}{endpoint}?prettyPrint=false");
         let mut request = self.http.post(url).json(&payload).header("Referer", format!("{ORIGIN}/"));
+        let generation = self.generation();
         for (name, value) in self.headers(kind, identity.as_ref()) {
             request = request.header(name, value);
         }
@@ -198,7 +208,7 @@ impl InnerTube {
             Failure::Retry(err)
         })?;
         let status = response.status();
-        self.keep_cookies(response.headers());
+        self.keep_cookies(response.headers(), generation);
         let bytes = response.bytes().await.map_err(|err| Failure::Retry(err.into()))?;
         let value: Value = serde_json::from_slice(&bytes).unwrap_or(Value::Null);
         if !status.is_success() {
@@ -288,9 +298,10 @@ impl InnerTube {
     }
 
     /// Keeps the cookies YouTube refreshes, as the browser would, so the sign-in stays valid.
-    fn keep_cookies(&self, headers: &HeaderMap) {
+    fn keep_cookies(&self, headers: &HeaderMap, generation: u64) {
         let mut auth = self.auth.lock().unwrap();
-        let Some(auth) = auth.as_mut() else { return };
+        // An answer to cookies that were replaced meanwhile would put old values over new ones.
+        let Some(auth) = auth.as_mut().filter(|auth| auth.generation == generation) else { return };
         for value in headers.get_all(reqwest::header::SET_COOKIE) {
             if let Ok(value) = value.to_str() {
                 auth.dirty |= auth.jar.update(HOST, value);
@@ -322,7 +333,7 @@ impl InnerTube {
 
 impl Auth {
     fn new(jar: Jar, identity: Identity, origin: Origin, store: Option<Stored>) -> Self {
-        Self { jar, identity, origin, store, dirty: false, saved: Instant::now() }
+        Self { jar, generation: 0, identity, origin, store, dirty: false, saved: Instant::now() }
     }
 
     /// The `cookies.txt` it is kept as, with the account and where the sign-in came from in
@@ -348,12 +359,17 @@ impl Auth {
             }
             Err(err) => {
                 tracing::warn!("reading YouTube Music cookies: {err:#}");
+                // Still to be written, the next time cookies are kept.
+                self.dirty = true;
                 return;
             }
         }
         match store.secret.write(&text) {
             Ok(()) => store.bytes = text,
-            Err(err) => tracing::warn!("saving YouTube Music cookies: {err:#}"),
+            Err(err) => {
+                tracing::warn!("saving YouTube Music cookies: {err:#}");
+                self.dirty = true;
+            }
         }
     }
 }
@@ -380,6 +396,11 @@ impl std::fmt::Display for ApiError {
 
 impl std::error::Error for ApiError {}
 
+/// Whether YouTube turned the sign-in down with this error, rather than the request.
+pub(crate) fn refused(err: &anyhow::Error) -> bool {
+    matches!(status(err), Some(StatusCode::UNAUTHORIZED | StatusCode::FORBIDDEN))
+}
+
 /// The status YouTube answered with, if the error is YouTube's.
 pub(crate) fn status(err: &anyhow::Error) -> Option<StatusCode> {
     err.chain().find_map(|cause| cause.downcast_ref::<ApiError>()).map(|err| err.status)
@@ -513,6 +534,22 @@ mod tests {
         assert_eq!(Jar::parse(&kept).get("SAPISID"), Some("a"));
     }
 
+    /// A request sent before the cookies were read from the browser again may be answered
+    /// after: what it refreshes belongs to the old cookies.
+    #[test]
+    fn an_answer_to_the_cookies_before_leaves_the_renewed_ones_alone() {
+        let api = InnerTube::unsaved(Jar::from_header("SAPISID=old; LOGIN_INFO=x")).unwrap();
+        let sent_with = api.generation();
+        api.renew(Jar::from_header("SAPISID=new; LOGIN_INFO=x"));
+        let mut headers = HeaderMap::new();
+        let cookie = "SAPISID=stale; Domain=.youtube.com; Path=/; Secure";
+        headers.insert(reqwest::header::SET_COOKIE, cookie.parse().unwrap());
+        api.keep_cookies(&headers, sent_with);
+        assert_eq!(api.jar().unwrap().get("SAPISID"), Some("new"));
+        api.keep_cookies(&headers, api.generation());
+        assert_eq!(api.jar().unwrap().get("SAPISID"), Some("stale"), "one to the new cookies counts");
+    }
+
     #[test]
     fn refreshed_cookies_never_undo_a_sign_out_or_another_sign_in() {
         let dir = std::env::temp_dir().join(format!("cloofy-ytm-keep-{}", std::process::id()));
@@ -526,7 +563,7 @@ mod tests {
             let mut headers = HeaderMap::new();
             let cookie = format!("SIDCC={value}; Domain=.youtube.com; Path=/; Secure");
             headers.insert(reqwest::header::SET_COOKIE, cookie.parse().unwrap());
-            api.keep_cookies(&headers);
+            api.keep_cookies(&headers, api.generation());
             api.flush();
             api
         };
diff --git a/crates/cloofy-ytmusic/src/lib.rs b/crates/cloofy-ytmusic/src/lib.rs
index e1d1543..1a94e33 100644
--- a/crates/cloofy-ytmusic/src/lib.rs
+++ b/crates/cloofy-ytmusic/src/lib.rs
@@ -141,6 +141,16 @@ impl YtMusic {
         }
     }
 
+    /// Hands on what a request for the library answered. When YouTube turned the sign-in down,
+    /// as it may after days in one run, the next request asks about it again, and reads the
+    /// cookies from the browser again if that wasn't done in this run yet.
+    async fn noting<T>(&self, result: Result<T>) -> Result<T> {
+        if result.as_ref().is_err_and(innertube::refused) {
+            self.inner.session.lock().await.asked = false;
+        }
+        result
+    }
+
     /// Which of the browser's accounts the sign-in acts as, with its address; `None` when
     /// signed out, or when YouTube no longer lists it.
     pub async fn account(&self) -> Result<Option<Account>> {
@@ -189,23 +199,23 @@ impl YtMusic {
     /// The playlists in the library, without Liked Music.
     pub async fn library_playlists(&self) -> Result<Vec<PlaylistInfo>> {
         self.checked().await;
-        library::playlists(&self.inner.api, &self.inner.library).await
+        self.noting(library::playlists(&self.inner.api, &self.inner.library).await).await
     }
 
     pub async fn saved_albums(&self) -> Result<Vec<AlbumInfo>> {
         self.checked().await;
-        library::albums(&self.inner.api, &self.inner.library).await
+        self.noting(library::albums(&self.inner.api, &self.inner.library).await).await
     }
 
     /// The artists the user subscribed to.
     pub async fn followed_artists(&self) -> Result<Vec<ArtistInfo>> {
         self.checked().await;
-        library::artists(&self.inner.api, &self.inner.library).await
+        self.noting(library::artists(&self.inner.api, &self.inner.library).await).await
     }
 
     pub async fn liked_count(&self) -> Result<u32> {
         self.checked().await;
-        library::liked_count(&self.inner.api).await
+        self.noting(library::liked_count(&self.inner.api).await).await
     }
 
     /// Songs by URI, with their details, in the given order; unknown ones are left out.
@@ -227,19 +237,19 @@ impl YtMusic {
     /// artists. Signed out, nothing is.
     pub async fn check_saved(&self, uris: &[String]) -> Result<Vec<(String, bool)>> {
         self.checked().await;
-        library::check_saved(&self.inner.api, &self.inner.library, uris).await
+        self.noting(library::check_saved(&self.inner.api, &self.inner.library, uris).await).await
     }
 
     /// Likes or unlikes a song, saves or removes an album or playlist, subscribes to or
     /// unsubscribes from an artist.
     pub async fn set_saved(&self, uri: &str, saved: bool) -> Result<()> {
         self.checked().await;
-        library::set_saved(&self.inner.api, &self.inner.library, uri, saved).await
+        self.noting(library::set_saved(&self.inner.api, &self.inner.library, uri, saved).await).await
     }
 
     pub async fn add_to_playlist(&self, playlist_uri: &str, uris: &[String]) -> Result<()> {
         self.checked().await;
-        library::add_to_playlist(&self.inner.api, playlist_uri, uris).await
+        self.noting(library::add_to_playlist(&self.inner.api, playlist_uri, uris).await).await
     }
 
     /// A raw InnerTube call, for diagnostics and the `ytm` example.
diff --git a/crates/cloofy-ytmusic/src/library.rs b/crates/cloofy-ytmusic/src/library.rs
index a18137b..9a0eaa7 100644
--- a/crates/cloofy-ytmusic/src/library.rs
+++ b/crates/cloofy-ytmusic/src/library.rs
@@ -16,7 +16,7 @@ use futures::{StreamExt, stream};
 use serde_json::{Value, json};
 
 use crate::{
-    innertube::InnerTube,
+    innertube::{self, InnerTube},
     pages::{self, LIKED},
     parse::{self, ALBUM, ARTIST, PLAYLIST, TRACK, find, find_all, list, str_at, text},
 };
@@ -76,8 +76,12 @@ pub(crate) async fn me(api: &InnerTube) -> Result<User> {
 /// Whose sign-in it is; `None` when YouTube answers but no longer takes the cookies, which is
 /// not the same as an answer that didn't arrive.
 pub(crate) async fn asked(api: &InnerTube) -> Result<Option<User>> {
-    let page = api.call("account/account_menu", json!({})).await?;
-    Ok(parse_me(&page))
+    match api.call("account/account_menu", json!({})).await {
+        Ok(page) => Ok(parse_me(&page)),
+        // YouTube says no either way: with a page that names no account, or with a status.
+        Err(err) if innertube::refused(&err) => Ok(None),
+        Err(err) => Err(err),
+    }
 }
 
 fn parse_me(page: &Value) -> Option<User> {
diff --git a/crates/cloofy/src/launcher.rs b/crates/cloofy/src/launcher.rs
index 7f8390d..d7349cd 100644
--- a/crates/cloofy/src/launcher.rs
+++ b/crates/cloofy/src/launcher.rs
@@ -17,7 +17,8 @@ use crate::{
     style,
 };
 
-/// The entry, which opens cloofy in the desktop's own terminal.
+/// The entry, which opens cloofy in the desktop's own terminal. The packages install it as it
+/// is, next to a cloofy on everyone's `PATH`.
 const ENTRY: &str = include_str!("../../../integrations/linux/cloofy.desktop");
 pub const ICON: &str = include_str!("../../../integrations/omarchy/cloofy.svg");
 /// Marks the desktop entry as the one `install` wrote.
@@ -49,6 +50,30 @@ pub fn is_ours(path: &Path) -> bool {
     fs::read_to_string(path).is_ok_and(|entry| entry.lines().any(|line| line.trim() == MARK))
 }
 
+/// The entry for the user's own folder. It starts this cloofy by its path: the desktop looks
+/// programs up on the session's `PATH`, which `~/.local/bin` or another folder cloofy was
+/// installed to may not be on, even where the shell's has it.
+fn entry_for(binary: Option<&Path>) -> String {
+    let Some(binary) = binary.and_then(Path::to_str) else { return ENTRY.to_owned() };
+    ENTRY.replacen("Exec=cloofy\n", &format!("Exec={}\n", exec_argument(binary)), 1)
+}
+
+/// `argument` as the `Exec` key of a desktop entry takes it: in quotes where it has characters
+/// the key reserves, those that mean something inside quotes escaped, then every backslash
+/// once more, as in any string of an entry, and `%` doubled, which starts a field code.
+fn exec_argument(argument: &str) -> String {
+    const RESERVED: &str = " \t\n\"'\\><~|&;$*?#()`";
+    let mut quoted = String::new();
+    for c in argument.chars() {
+        if matches!(c, '"' | '`' | '$' | '\\') {
+            quoted.push('\\');
+        }
+        quoted.push(c);
+    }
+    let argument = if argument.contains(|c| RESERVED.contains(c)) { format!("\"{quoted}\"") } else { quoted };
+    argument.replace('\\', "\\\\").replace('%', "%%")
+}
+
 struct Launcher {
     home: PathBuf,
 }
@@ -75,7 +100,7 @@ impl Launcher {
         if fs::symlink_metadata(&icon).is_err() {
             write_if_changed(&icon, ICON)?;
         }
-        write_if_changed(&entry, ENTRY)?;
+        write_if_changed(&entry, &entry_for(env::current_exe().ok().as_deref()))?;
         self.refresh();
         Ok("cloofy is in the app menu")
     }
@@ -130,6 +155,19 @@ mod tests {
         assert!(ENTRY.lines().any(|line| line == MARK));
     }
 
+    /// The desktop's `PATH` may lack the folder cloofy is in, so the user's entry names it.
+    #[test]
+    fn the_user_s_entry_starts_this_cloofy_by_its_path() {
+        let entry = entry_for(Some(Path::new("/home/someone/.local/bin/cloofy")));
+        assert_eq!(key(&entry, "Exec"), Some("/home/someone/.local/bin/cloofy"));
+        assert!(entry.lines().any(|line| line == MARK) && key(&entry, "Terminal") == Some("true"));
+        assert_eq!(entry_for(None), ENTRY, "by its name where the path is unknown");
+
+        assert_eq!(exec_argument("/opt/my apps/cloofy"), "\"/opt/my apps/cloofy\"");
+        assert_eq!(exec_argument("/opt/100%/cloofy"), "/opt/100%%/cloofy");
+        assert_eq!(exec_argument("/opt/a$b/cloofy"), "\"/opt/a\\\\$b/cloofy\"");
+    }
+
     #[test]
     fn installs_and_removes_the_entry_and_the_icon() {
         let launcher = scratch("both");
diff --git a/crates/cloofy/src/spotify/playback.rs b/crates/cloofy/src/spotify/playback.rs
index d932c97..eb8a703 100644
--- a/crates/cloofy/src/spotify/playback.rs
+++ b/crates/cloofy/src/spotify/playback.rs
@@ -3,7 +3,7 @@
 use std::time::Duration;
 
 use anyhow::{Context, Result, bail};
-use cloofy_core::{paths::Paths, player::PlayerEvent};
+use cloofy_core::{config::Config, paths::Paths, player::PlayerEvent};
 use cloofy_os::media::Command;
 use cloofy_player::{DEFAULT_VOLUME, Engine, events};
 use cloofy_spotify::session;
@@ -21,12 +21,17 @@ use crate::{
 
 const DEVICE_NAME: &str = "cloofy";
 
+/// Whether Settings has Normalize volume on, which goes for these commands too.
+fn normalize(paths: &Paths) -> bool {
+    Config::load(paths).is_ok_and(|config| config.normalize_volume == Some(true))
+}
+
 /// Plays standalone: cloofy activates itself as the playing device and loads the context.
 pub async fn play(paths: &Paths, input: &str, shuffle: bool) -> Result<()> {
     let uri = parse_uri(input)?;
     let pending = session::prepare(paths)?;
     let session = pending.session.clone();
-    let (engine, mut lost_outputs) = Engine::new(&session, Duration::ZERO, false)?;
+    let (engine, mut lost_outputs) = Engine::new(&session, Duration::ZERO, normalize(paths))?;
     let mut player_events = engine.player.get_player_event_channel();
     let (spirc, task) = engine.connect_device(pending, DEVICE_NAME.into(), DEFAULT_VOLUME).await?;
     session::remember(paths, &session)?;
@@ -94,7 +99,7 @@ pub async fn play(paths: &Paths, input: &str, shuffle: bool) -> Result<()> {
 pub async fn connect(paths: &Paths, name: String) -> Result<()> {
     let pending = session::prepare(paths)?;
     let session = pending.session.clone();
-    let (engine, mut lost_outputs) = Engine::new(&pending.session, Duration::ZERO, false)?;
+    let (engine, mut lost_outputs) = Engine::new(&pending.session, Duration::ZERO, normalize(paths))?;
     let mut player_events = engine.player.get_player_event_channel();
     let (spirc, task) = engine.connect_device(pending, name.clone(), DEFAULT_VOLUME).await?;
     session::remember(paths, &session)?;
diff --git a/crates/cloofy/src/ytmusic/playback.rs b/crates/cloofy/src/ytmusic/playback.rs
index 616b10e..9611e04 100644
--- a/crates/cloofy/src/ytmusic/playback.rs
+++ b/crates/cloofy/src/ytmusic/playback.rs
@@ -4,7 +4,7 @@
 use std::time::Duration;
 
 use anyhow::{Result, anyhow};
-use cloofy_core::{paths::Paths, player::PlayerEvent};
+use cloofy_core::{config::Config, paths::Paths, player::PlayerEvent};
 use cloofy_os::media::Command;
 use cloofy_ytmusic::{Player, YtMusic, playable};
 use tokio::sync::mpsc;
@@ -22,6 +22,10 @@ pub async fn play(paths: &Paths, input: &str, shuffle: bool) -> Result<()> {
     let playable = playable(input)?;
     let (events_tx, mut events) = mpsc::unbounded_channel();
     let player = Player::spawn(YtMusic::new(paths)?, paths, VOLUME, events_tx).await?;
+    // As Settings has it.
+    if Config::load(paths).is_ok_and(|config| config.normalize_volume == Some(true)) {
+        player.set_normalize(true)?;
+    }
     if shuffle {
         player.play_shuffled(playable.context)?;
     } else {
diff --git a/website/src/content/docs/docs/youtube-music.md b/website/src/content/docs/docs/youtube-music.md
index a12e5ba..fdb05de 100644
--- a/website/src/content/docs/docs/youtube-music.md
+++ b/website/src/content/docs/docs/youtube-music.md
@@ -55,4 +55,4 @@ The DJ, devices, crossfade and podcasts are Spotify's.
 
 ## Your cookies
 
-`cloofy login ytmusic` has yt-dlp export the browser's cookies into a private folder, keeps only youtube.com's, and deletes the export right away. They stay in `~/.local/share/cloofy/ytmusic/cookies.txt`, which only you can read, or in the macOS Keychain with `credentials = "keychain"`. cloofy sends them only to music.youtube.com, with its own requests there; streams, covers and lyrics from LRCLIB load without them. They are a signed-in session like the browser's, so treat the file like a password. `cloofy logout ytmusic` deletes it. A browser that goes on using its sign-in gets new cookies for it, so after a day or two YouTube may stop taking cloofy's copy: cloofy then reads them from the same browser again, the same way, and keeps them only when they still sign in the same account.
+`cloofy login ytmusic` has yt-dlp export the browser's cookies into a private folder, keeps only youtube.com's, and deletes the export right away. They stay in `~/.local/share/cloofy/ytmusic/cookies.txt`, which only you can read, or in the macOS Keychain with `credentials = "keychain"`. cloofy sends them only to music.youtube.com, with its own requests there; streams, covers and lyrics from LRCLIB load without them. They are a signed-in session like the browser's, so treat the file like a password. `cloofy logout ytmusic` deletes it. A browser that goes on using its sign-in gets new cookies for it, so after a day or two YouTube may stop taking cloofy's copy: cloofy then reads them from the same browser again, the same way, and keeps them only when they still sign in the same account. A sign-in made before cloofy 0.5.3, or from a pasted Cookie header, doesn't say which browser it came from: run `cloofy login ytmusic --force` once to sign in with a browser.