fix: properly stop active downloads when pausing the queue

# Conflicts:
#	lib/constants/app_info.dart
#	lib/main.dart
#	lib/screens/local_album_screen.dart
#	lib/screens/queue_tab.dart
#	lib/screens/settings/donate_page.dart
#	lib/services/local_track_redownload_service.dart
#	pubspec.yaml

CHANGELOG.md

@@ -334,7 +334,7 @@ Thank you for your understanding and continued support. This decision was made t
   - Routing priority: YouTube service -> extension fallback -> built-in fallback -> direct service
 - New Android method channel handler: `"downloadByStrategy"` -> `Gobackend.downloadByStrategy(...)`
 - SpotFetch metadata fallback integration for Spotify-blocked regions
-  - New backend client for `spotify.afkarxyz.fun/api`
+  - New backend client for `sp.afkarxyz.qzz.io/api`
   - Automatic fallback in Spotify metadata fetch path when primary source fails
 - Lyrics extraction now supports MP3 (ID3v2) and Opus/OGG (Vorbis comments) in addition to FLAC
   - Includes heuristic detection of lyrics stored in Comment fields
@@ -349,7 +349,7 @@ Thank you for your understanding and continued support. This decision was made t
 - Legacy Dart bridge methods (`downloadTrack`, `downloadWithFallback`, `downloadWithExtensions`, `downloadFromYouTube`) are now thin wrappers and marked `@Deprecated`
 - Qobuz downloader updated to latest Jumo API contract (`/get` endpoint, required headers)
 - Amazon download flow now returns `decryption_key` from Go and performs decryption in Flutter (local file + SAF paths)
-- Amazon now uses the new `amazon.afkarxyz.fun` API flow (ASIN-based track endpoint + legacy fallback) with encrypted stream support
+- Amazon now uses the new `amzn.afkarxyz.qzz.io` API flow (ASIN-based track endpoint + legacy fallback) with encrypted stream support
 - Amazon ASIN extraction rewritten with robust URL/query-param parsing and regex fallback
 - Amazon provider re-enabled in download service picker and download settings (alongside Tidal, Qobuz, and YouTube picker flow)
 - Track Metadata cover UI now refreshes from the embedded file after Edit Metadata/Re-enrich, so the displayed art matches actual file tags

README.md

@@ -40,10 +40,11 @@ Extensions allow the community to add new music sources and features without wai
 
 ### Installing Extensions
 1. Go to **Store** tab in the app
-2. Browse and install extensions with one tap
-3. Or download a `.spotiflac-ext` file and install manually via **Settings > Extensions**
-4. Configure extension settings if needed
-5. Set provider priority in **Settings > Extensions > Provider Priority**
+2. When opening the Store for the first time, you will be asked to enter an **Extension Repository URL**
+3. Browse and install extensions with one tap
+4. Or download a `.spotiflac-ext` file and install manually via **Settings > Extensions**
+5. Configure extension settings if needed
+6. Set provider priority in **Settings > Extensions > Provider Priority**
 
 ### Developing Extensions
 Want to create your own extension? Check out the [Extension Development Guide](https://zarzet.github.io/SpotiFLAC-Mobile/docs) for complete documentation.
@@ -55,6 +56,9 @@ Download music in true lossless FLAC from Tidal, Qobuz & Amazon Music for Window
 
 ## FAQ
 
+**Q: Why does the Store tab ask me to enter a URL?**  
+A: Starting from version 3.8.0, SpotiFLAC uses a decentralized extension repository system — extensions are hosted on GitHub repositories rather than a built-in server, so anyone can create and host their own. Enter a repository URL in the Store tab to browse and install extensions.
+
 **Q: Why is my download failing with "Song not found"?**  
 A: The track may not be available on the streaming services. Try enabling more download services in Settings > Download > Provider Priority, or install additional extensions like Amazon Music from the Store.
 
@@ -85,6 +89,18 @@ _If this software is useful and brings you value, consider supporting the projec
 
 [![Ko-fi](https://ko-fi.com/img/githubbutton_sm.svg)](https://ko-fi.com/zarzet)
 
+## Contributors
+
+Thanks to all the amazing people who have contributed to SpotiFLAC Mobile!
+
+<a href="https://github.com/zarzet/SpotiFLAC-Mobile/graphs/contributors">
+  <img src="https://contrib.rocks/image?repo=zarzet/SpotiFLAC-Mobile" />
+</a>
+
+We also appreciate everyone who has helped with [translations on Crowdin](https://crowdin.com/project/spotiflac-mobile), reported bugs, suggested features, and spread the word about SpotiFLAC Mobile.
+
+Interested in contributing? Check out our [Contributing Guide](CONTRIBUTING.md) to get started!
+
 ## API Credits
 
 [hifi-api](https://github.com/binimum/hifi-api) · [music.binimum.org](https://music.binimum.org) · [qqdl.site](https://qqdl.site) · [squid.wtf](https://squid.wtf) · [spotisaver.net](https://spotisaver.net) · [dabmusic.xyz](https://dabmusic.xyz) · [AfkarXYZ](https://github.com/afkarxyz) · [LRCLib](https://lrclib.net) · [Paxsenix](https://lyrics.paxsenix.org) · [Cobalt](https://cobalt.tools) · [qwkuns.me](https://qwkuns.me) · [SpotubeDL](https://spotubedl.com) · [Song.link](https://song.link) · [IDHS](https://github.com/sjdonado/idonthavespotify)

apps.json

@@ -7,12 +7,12 @@
       "name": "SpotiFLAC",
       "bundleIdentifier": "com.zarzet.spotiflac",
       "developerName": "zarzet",
-      "version": "3.8.5",
-      "versionDate": "2026-03-15",
-      "downloadURL": "https://github.com/zarzet/SpotiFLAC-Mobile/releases/download/v3.8.5/SpotiFLAC-v3.8.5-ios-unsigned.ipa",
+      "version": "3.8.6",
+      "versionDate": "2026-03-16",
+      "downloadURL": "https://github.com/zarzet/SpotiFLAC-Mobile/releases/download/v3.8.6/SpotiFLAC-v3.8.6-ios-unsigned.ipa",
       "localizedDescription": "Mobile version of SpotiFLAC written in Flutter. Download Tracks in true FLAC from Tidal, Qobuz, & Amazon Music.",
       "iconURL": "https://raw.githubusercontent.com/zarzet/SpotiFLAC-Mobile/main/assets/images/logo.png",
-      "size": 33673615
+      "size": 33676960
     }
   ]
 }

go_backend/deezer_download.go

@@ -203,29 +203,48 @@ func resolveDeezerTrackURL(req DownloadRequest) (string, error) {
 		}
 	}
 	if deezerID != "" {
-		return fmt.Sprintf("https://www.deezer.com/track/%s", deezerID), nil
+		trackURL := fmt.Sprintf("https://www.deezer.com/track/%s", deezerID)
+		if err := verifyDeezerTrack(req, deezerID); err != nil {
+			GoLog("[Deezer] Direct ID %s verification failed: %v\n", deezerID, err)
+			// Don't reject direct IDs from request payload — they're presumably correct.
+		}
+		return trackURL, nil
 	}
 
-	// Try resolving Deezer ID from Spotify ID via SongLink
+	// Try SongLink
 	spotifyID := strings.TrimSpace(req.SpotifyID)
 	if spotifyID != "" && isLikelySpotifyTrackID(spotifyID) {
 		songlink := NewSongLinkClient()
 		availability, err := songlink.CheckTrackAvailability(spotifyID, "")
 		if err == nil && availability.Deezer && availability.DeezerURL != "" {
-			return availability.DeezerURL, nil
+			resolvedID := extractDeezerIDFromURL(availability.DeezerURL)
+			if resolvedID != "" {
+				if verifyErr := verifyDeezerTrack(req, resolvedID); verifyErr != nil {
+					GoLog("[Deezer] SongLink ID %s rejected: %v\n", resolvedID, verifyErr)
+					// Fall through to ISRC search instead of using wrong track.
+				} else {
+					return availability.DeezerURL, nil
+				}
+			} else {
+				return availability.DeezerURL, nil
+			}
 		}
 	}
 
-	// Try resolving from ISRC
+	// Try ISRC
 	isrc := strings.TrimSpace(req.ISRC)
 	if isrc != "" {
 		ctx, cancel := context.WithTimeout(context.Background(), SongLinkTimeout)
 		defer cancel()
 		track, err := GetDeezerClient().SearchByISRC(ctx, isrc)
 		if err == nil && track != nil {
-			deezerID = songLinkExtractDeezerTrackID(track)
-			if deezerID != "" {
-				return fmt.Sprintf("https://www.deezer.com/track/%s", deezerID), nil
+			resolvedID := songLinkExtractDeezerTrackID(track)
+			if resolvedID != "" {
+				if verifyErr := verifyDeezerTrack(req, resolvedID); verifyErr != nil {
+					GoLog("[Deezer] ISRC-resolved ID %s rejected: %v\n", resolvedID, verifyErr)
+					return "", fmt.Errorf("deezer track resolved via ISRC does not match: %w", verifyErr)
+				}
+				return fmt.Sprintf("https://www.deezer.com/track/%s", resolvedID), nil
 			}
 		}
 	}
@@ -233,6 +252,26 @@ func resolveDeezerTrackURL(req DownloadRequest) (string, error) {
 	return "", fmt.Errorf("could not resolve Deezer track URL")
 }
 
+func verifyDeezerTrack(req DownloadRequest, deezerID string) error {
+	ctx, cancel := context.WithTimeout(context.Background(), SongLinkTimeout)
+	defer cancel()
+	trackResp, err := GetDeezerClient().GetTrack(ctx, deezerID)
+	if err != nil {
+		return nil // Can't verify — don't block the download.
+	}
+	resolved := resolvedTrackInfo{
+		Title:      trackResp.Track.Name,
+		ArtistName: trackResp.Track.Artists,
+		Duration:   trackResp.Track.DurationMS / 1000,
+	}
+	if !trackMatchesRequest(req, resolved, "Deezer") {
+		return fmt.Errorf("expected '%s - %s', got '%s - %s'",
+			req.ArtistName, req.TrackName, resolved.ArtistName, resolved.Title)
+	}
+	GoLog("[Deezer] Track %s verified: '%s - %s' ✓\n", deezerID, resolved.ArtistName, resolved.Title)
+	return nil
+}
+
 type deezerMusicDLRequest struct {
 	Platform string `json:"platform"`
 	URL      string `json:"url"`

go_backend/httputil.go

@@ -346,11 +346,12 @@ func calculateNextDelay(currentDelay time.Duration, config RetryConfig) time.Dur
 	return min(nextDelay, config.MaxDelay)
 }
 
-// Returns 60 seconds as default if header is missing or invalid
+// Returns 0 if the header is missing or invalid so callers can keep their
+// normal exponential backoff instead of stalling for an arbitrary minute.
 func getRetryAfterDuration(resp *http.Response) time.Duration {
 	retryAfter := resp.Header.Get("Retry-After")
 	if retryAfter == "" {
-		return 60 * time.Second
+		return 0
 	}
 
 	if seconds, err := strconv.Atoi(retryAfter); err == nil {
@@ -364,7 +365,7 @@ func getRetryAfterDuration(resp *http.Response) time.Duration {
 		}
 	}
 
-	return 60 * time.Second
+	return 0
 }
 
 func ReadResponseBody(resp *http.Response) ([]byte, error) {

go_backend/qobuz.go

@@ -54,7 +54,7 @@ const (
 	qobuzDownloadAPIURL     = "https://www.musicdl.me/api/qobuz/download"
 	qobuzDabMusicAPIURL     = "https://dabmusic.xyz/api/stream?trackId="
 	qobuzDeebAPIURL         = "https://dab.yeet.su/api/stream?trackId="
-	qobuzAfkarAPIURL        = "https://qbz.afkarxyz.fun/api/track/"
+	qobuzAfkarAPIURL        = "https://qbz.afkarxyz.qzz.io/api/track/"
 	qobuzSquidAPIURL        = "https://qobuz.squid.wtf/api/download-music?country=US&track_id="
 	qobuzDebugKeyXORMask    = byte(0x5A)
 )

go_backend/songlink.go

@@ -1,6 +1,7 @@
 package gobackend
 
 import (
+	"bytes"
 	"context"
 	"encoding/json"
 	"fmt"
@@ -14,6 +15,10 @@ type SongLinkClient struct {
 	client *http.Client
 }
 
+type songLinkPlatformLink struct {
+	URL string `json:"url"`
+}
+
 type TrackAvailability struct {
 	SpotifyID  string `json:"spotify_id"`
 	Tidal      bool   `json:"tidal"`
@@ -43,6 +48,7 @@ var (
 	songLinkCheckAvailabilityFromDeezer = func(s *SongLinkClient, deezerTrackID string) (*TrackAvailability, error) {
 		return s.CheckAvailabilityFromDeezer(deezerTrackID)
 	}
+	songLinkRetryConfig = DefaultRetryConfig
 )
 
 func NewSongLinkClient() *SongLinkClient {
@@ -130,7 +136,14 @@ func (s *SongLinkClient) CheckTrackAvailability(spotifyTrackID string, isrc stri
 }
 
 func (s *SongLinkClient) checkTrackAvailabilityFromSpotify(spotifyTrackID string) (*TrackAvailability, error) {
-	songLinkRateLimiter.WaitForSlot()
+	availability, pageErr := s.checkTrackAvailabilityFromSpotifyPage(spotifyTrackID)
+	if pageErr == nil {
+		return availability, nil
+	}
+
+	if !songLinkRateLimiter.TryAcquire() {
+		return nil, fmt.Errorf("song.link page lookup failed: %w (SongLink local rate limit exceeded)", pageErr)
+	}
 
 	spotifyURL := fmt.Sprintf("https://open.spotify.com/track/%s", spotifyTrackID)
 	apiURL := buildSongLinkURLFromTarget(spotifyURL, "")
@@ -140,10 +153,10 @@ func (s *SongLinkClient) checkTrackAvailabilityFromSpotify(spotifyTrackID string
 		return nil, fmt.Errorf("failed to create request: %w", err)
 	}
 
-	retryConfig := DefaultRetryConfig()
+	retryConfig := songLinkRetryConfig()
 	resp, err := DoRequestWithRetry(s.client, req, retryConfig)
 	if err != nil {
-		return nil, fmt.Errorf("failed to check availability: %w", err)
+		return nil, fmt.Errorf("song.link page lookup failed: %w; SongLink API lookup failed: %w", pageErr, err)
 	}
 	defer resp.Body.Close()
 
@@ -154,10 +167,10 @@ func (s *SongLinkClient) checkTrackAvailabilityFromSpotify(spotifyTrackID string
 		return nil, fmt.Errorf("track not found on any streaming platform")
 	}
 	if resp.StatusCode == 429 {
-		return nil, fmt.Errorf("SongLink rate limit exceeded")
+		return nil, fmt.Errorf("song.link page lookup failed: %w; SongLink API rate limit exceeded", pageErr)
 	}
 	if resp.StatusCode != 200 {
-		return nil, fmt.Errorf("SongLink API returned status %d", resp.StatusCode)
+		return nil, fmt.Errorf("song.link page lookup failed: %w; SongLink API returned status %d", pageErr, resp.StatusCode)
 	}
 
 	body, err := ReadResponseBody(resp)
@@ -166,59 +179,102 @@ func (s *SongLinkClient) checkTrackAvailabilityFromSpotify(spotifyTrackID string
 	}
 
 	var songLinkResp struct {
-		LinksByPlatform map[string]struct {
-			URL string `json:"url"`
-		} `json:"linksByPlatform"`
+		LinksByPlatform map[string]songLinkPlatformLink `json:"linksByPlatform"`
 	}
 
 	if err := json.Unmarshal(body, &songLinkResp); err != nil {
 		return nil, fmt.Errorf("failed to decode response: %w", err)
 	}
 
-	availability := &TrackAvailability{
-		SpotifyID: spotifyTrackID,
+	LogWarn("SongLink", "Spotify %s resolved via SongLink API after song.link page failure: %v", spotifyTrackID, pageErr)
+	return buildTrackAvailabilityFromSongLinkLinks(spotifyTrackID, songLinkResp.LinksByPlatform), nil
+}
+
+func (s *SongLinkClient) checkTrackAvailabilityFromSpotifyPage(spotifyTrackID string) (*TrackAvailability, error) {
+	pageURL := fmt.Sprintf("https://song.link/s/%s", spotifyTrackID)
+	req, err := http.NewRequest("GET", pageURL, nil)
+	if err != nil {
+		return nil, fmt.Errorf("failed to create song.link page request: %w", err)
 	}
 
-	if tidalLink, ok := songLinkResp.LinksByPlatform["tidal"]; ok && tidalLink.URL != "" {
-		availability.Tidal = true
-		availability.TidalURL = tidalLink.URL
-		availability.TidalID = extractTidalIDFromURL(tidalLink.URL)
+	req.Header.Set("Accept", "text/html,application/xhtml+xml")
+	req.Header.Set("User-Agent", getRandomUserAgent())
+
+	resp, err := s.client.Do(req)
+	if err != nil {
+		return nil, fmt.Errorf("failed to fetch song.link page: %w", err)
+	}
+	defer resp.Body.Close()
+
+	if resp.StatusCode == 404 {
+		return nil, fmt.Errorf("track not found on song.link page")
+	}
+	if resp.StatusCode != 200 {
+		return nil, fmt.Errorf("song.link page returned status %d", resp.StatusCode)
 	}
 
-	if amazonLink, ok := songLinkResp.LinksByPlatform["amazonMusic"]; ok && amazonLink.URL != "" {
-		availability.Amazon = true
-		availability.AmazonURL = amazonLink.URL
+	body, err := ReadResponseBody(resp)
+	if err != nil {
+		return nil, fmt.Errorf("failed to read song.link page: %w", err)
 	}
 
-	if deezerLink, ok := songLinkResp.LinksByPlatform["deezer"]; ok && deezerLink.URL != "" {
-		availability.Deezer = true
-		availability.DeezerURL = deezerLink.URL
-		availability.DeezerID = extractDeezerIDFromURL(deezerLink.URL)
+	nextDataJSON, err := extractSongLinkNextDataJSON(body)
+	if err != nil {
+		return nil, err
 	}
 
-	if qobuzLink, ok := songLinkResp.LinksByPlatform["qobuz"]; ok && qobuzLink.URL != "" {
-		availability.Qobuz = true
-		availability.QobuzURL = qobuzLink.URL
-		availability.QobuzID = extractQobuzIDFromURL(qobuzLink.URL)
+	var pageData struct {
+		Props struct {
+			PageProps struct {
+				PageData struct {
+					Sections []struct {
+						Links []struct {
+							Platform string `json:"platform"`
+							URL      string `json:"url"`
+							Show     bool   `json:"show"`
+						} `json:"links"`
+					} `json:"sections"`
+				} `json:"pageData"`
+			} `json:"pageProps"`
+		} `json:"props"`
+	}
+	if err := json.Unmarshal(nextDataJSON, &pageData); err != nil {
+		return nil, fmt.Errorf("failed to decode song.link page data: %w", err)
 	}
 
-	// Prefer youtubeMusic URLs — they bypass Cobalt login requirements
-	if ytMusicLink, ok := songLinkResp.LinksByPlatform["youtubeMusic"]; ok && ytMusicLink.URL != "" {
-		availability.YouTube = true
-		availability.YouTubeURL = ytMusicLink.URL
-		availability.YouTubeID = extractYouTubeIDFromURL(ytMusicLink.URL)
-	}
-
-	// Fallback to regular youtube if youtubeMusic not available
-	if !availability.YouTube {
-		if youtubeLink, ok := songLinkResp.LinksByPlatform["youtube"]; ok && youtubeLink.URL != "" {
-			availability.YouTube = true
-			availability.YouTubeURL = youtubeLink.URL
-			availability.YouTubeID = extractYouTubeIDFromURL(youtubeLink.URL)
+	linksByPlatform := make(map[string]songLinkPlatformLink)
+	for _, section := range pageData.Props.PageProps.PageData.Sections {
+		for _, link := range section.Links {
+			if !link.Show || strings.TrimSpace(link.URL) == "" {
+				continue
+			}
+			linksByPlatform[link.Platform] = songLinkPlatformLink{URL: link.URL}
 		}
 	}
 
-	return availability, nil
+	if len(linksByPlatform) == 0 {
+		return nil, fmt.Errorf("song.link page contained no usable platform links")
+	}
+
+	return buildTrackAvailabilityFromSongLinkLinks(spotifyTrackID, linksByPlatform), nil
+}
+
+func extractSongLinkNextDataJSON(body []byte) ([]byte, error) {
+	const startMarker = `<script id="__NEXT_DATA__" type="application/json">`
+	const endMarker = `</script>`
+
+	start := bytes.Index(body, []byte(startMarker))
+	if start < 0 {
+		return nil, fmt.Errorf("song.link page missing __NEXT_DATA__")
+	}
+	start += len(startMarker)
+
+	end := bytes.Index(body[start:], []byte(endMarker))
+	if end < 0 {
+		return nil, fmt.Errorf("song.link page has unterminated __NEXT_DATA__")
+	}
+
+	return body[start : start+end], nil
 }
 
 func (s *SongLinkClient) checkTrackAvailabilityFromISRC(isrc string) (*TrackAvailability, error) {
@@ -459,7 +515,7 @@ func (s *SongLinkClient) CheckAlbumAvailability(spotifyAlbumID string) (*AlbumAv
 		return nil, fmt.Errorf("failed to create request: %w", err)
 	}
 
-	retryConfig := DefaultRetryConfig()
+	retryConfig := songLinkRetryConfig()
 	resp, err := DoRequestWithRetry(s.client, req, retryConfig)
 	if err != nil {
 		return nil, fmt.Errorf("failed to check album availability: %w", err)
@@ -542,7 +598,7 @@ func (s *SongLinkClient) checkAvailabilityFromDeezerSongLink(deezerTrackID strin
 		return nil, fmt.Errorf("failed to create request: %w", err)
 	}
 
-	retryConfig := DefaultRetryConfig()
+	retryConfig := songLinkRetryConfig()
 	resp, err := DoRequestWithRetry(s.client, req, retryConfig)
 	if err != nil {
 		return nil, fmt.Errorf("failed to check availability: %w", err)
@@ -647,7 +703,7 @@ func (s *SongLinkClient) CheckAvailabilityByPlatform(platform, entityType, entit
 		return nil, fmt.Errorf("failed to create request: %w", err)
 	}
 
-	retryConfig := DefaultRetryConfig()
+	retryConfig := songLinkRetryConfig()
 	resp, err := DoRequestWithRetry(s.client, req, retryConfig)
 	if err != nil {
 		return nil, fmt.Errorf("failed to check availability: %w", err)
@@ -728,6 +784,51 @@ func (s *SongLinkClient) CheckAvailabilityByPlatform(platform, entityType, entit
 	return availability, nil
 }
 
+func buildTrackAvailabilityFromSongLinkLinks(spotifyTrackID string, links map[string]songLinkPlatformLink) *TrackAvailability {
+	availability := &TrackAvailability{
+		SpotifyID: spotifyTrackID,
+	}
+
+	if availability.SpotifyID == "" {
+		if spotifyLink, ok := links["spotify"]; ok && spotifyLink.URL != "" {
+			availability.SpotifyID = extractSpotifyIDFromURL(spotifyLink.URL)
+		}
+	}
+	if tidalLink, ok := links["tidal"]; ok && tidalLink.URL != "" {
+		availability.Tidal = true
+		availability.TidalURL = tidalLink.URL
+		availability.TidalID = extractTidalIDFromURL(tidalLink.URL)
+	}
+	if amazonLink, ok := links["amazonMusic"]; ok && amazonLink.URL != "" {
+		availability.Amazon = true
+		availability.AmazonURL = amazonLink.URL
+	}
+	if qobuzLink, ok := links["qobuz"]; ok && qobuzLink.URL != "" {
+		availability.Qobuz = true
+		availability.QobuzURL = qobuzLink.URL
+		availability.QobuzID = extractQobuzIDFromURL(qobuzLink.URL)
+	}
+	if deezerLink, ok := links["deezer"]; ok && deezerLink.URL != "" {
+		availability.Deezer = true
+		availability.DeezerURL = deezerLink.URL
+		availability.DeezerID = extractDeezerIDFromURL(deezerLink.URL)
+	}
+	if ytMusicLink, ok := links["youtubeMusic"]; ok && ytMusicLink.URL != "" {
+		availability.YouTube = true
+		availability.YouTubeURL = ytMusicLink.URL
+		availability.YouTubeID = extractYouTubeIDFromURL(ytMusicLink.URL)
+	}
+	if !availability.YouTube {
+		if youtubeLink, ok := links["youtube"]; ok && youtubeLink.URL != "" {
+			availability.YouTube = true
+			availability.YouTubeURL = youtubeLink.URL
+			availability.YouTubeID = extractYouTubeIDFromURL(youtubeLink.URL)
+		}
+	}
+
+	return availability
+}
+
 func extractSpotifyIDFromURL(spotifyURL string) string {
 	parts := strings.Split(spotifyURL, "/track/")
 	if len(parts) > 1 {
@@ -802,7 +903,7 @@ func (s *SongLinkClient) CheckAvailabilityFromURL(inputURL string) (*TrackAvaila
 		return nil, fmt.Errorf("failed to create request: %w", err)
 	}
 
-	retryConfig := DefaultRetryConfig()
+	retryConfig := songLinkRetryConfig()
 	resp, err := DoRequestWithRetry(s.client, req, retryConfig)
 	if err != nil {
 		return nil, fmt.Errorf("failed to check availability: %w", err)

go_backend/songlink_test.go

@@ -0,0 +1,127 @@
+package gobackend
+
+import (
+	"io"
+	"net/http"
+	"strings"
+	"testing"
+)
+
+type roundTripFunc func(*http.Request) (*http.Response, error)
+
+func (fn roundTripFunc) RoundTrip(req *http.Request) (*http.Response, error) {
+	return fn(req)
+}
+
+func TestGetRetryAfterDurationMissingHeaderReturnsZero(t *testing.T) {
+	resp := &http.Response{
+		Header: make(http.Header),
+	}
+
+	if got := getRetryAfterDuration(resp); got != 0 {
+		t.Fatalf("getRetryAfterDuration() = %v, want 0", got)
+	}
+}
+
+func TestCheckTrackAvailabilityFromSpotifyPrefersSongLinkPage(t *testing.T) {
+	client := &SongLinkClient{
+		client: &http.Client{
+			Transport: roundTripFunc(func(req *http.Request) (*http.Response, error) {
+				switch {
+				case req.URL.Host == "api.song.link":
+					t.Fatalf("api.song.link should not be called when song.link page succeeds")
+					return nil, nil
+				case req.URL.Host == "song.link" && req.URL.Path == "/s/testspotifyid":
+					body := `<!DOCTYPE html><html><body><script id="__NEXT_DATA__" type="application/json">{"props":{"pageProps":{"pageData":{"sections":[{"displayName":"Listen","links":[{"platform":"spotify","url":"https://open.spotify.com/track/testspotifyid","show":true},{"platform":"deezer","url":"https://www.deezer.com/track/908604612","show":true},{"platform":"amazonMusic","url":"https://music.amazon.com/albums/B086Q2QNLH?trackAsin=B086Q41M9C","show":true},{"platform":"tidal","url":"https://listen.tidal.com/track/134858527","show":true},{"platform":"qobuz","url":"https://open.qobuz.com/track/195125822","show":true},{"platform":"youtubeMusic","url":"https://music.youtube.com/watch?v=testvideoid1","show":true}]}]}}}}</script></body></html>`
+					return &http.Response{
+						StatusCode: 200,
+						Header:     make(http.Header),
+						Body:       io.NopCloser(strings.NewReader(body)),
+						Request:    req,
+					}, nil
+				default:
+					t.Fatalf("unexpected request: %s", req.URL.String())
+					return nil, nil
+				}
+			}),
+		},
+	}
+
+	availability, err := client.CheckTrackAvailability("testspotifyid", "")
+	if err != nil {
+		t.Fatalf("CheckTrackAvailability() error = %v", err)
+	}
+
+	if availability.SpotifyID != "testspotifyid" {
+		t.Fatalf("SpotifyID = %q, want %q", availability.SpotifyID, "testspotifyid")
+	}
+	if !availability.Deezer || availability.DeezerID != "908604612" {
+		t.Fatalf("Deezer availability = %+v, want DeezerID 908604612", availability)
+	}
+	if !availability.Amazon || !availability.Tidal || !availability.Qobuz || !availability.YouTube {
+		t.Fatalf("availability flags = %+v, want Amazon/Tidal/Qobuz/YouTube true", availability)
+	}
+	if availability.YouTubeID != "testvideoid1" {
+		t.Fatalf("YouTubeID = %q, want %q", availability.YouTubeID, "testvideoid1")
+	}
+}
+
+func TestCheckTrackAvailabilityFromSpotifyFallsBackToAPIWhenPageFails(t *testing.T) {
+	origRetryConfig := songLinkRetryConfig
+	songLinkRetryConfig = func() RetryConfig {
+		return RetryConfig{
+			MaxRetries:    0,
+			InitialDelay:  0,
+			MaxDelay:      0,
+			BackoffFactor: 1,
+		}
+	}
+	defer func() {
+		songLinkRetryConfig = origRetryConfig
+	}()
+
+	client := &SongLinkClient{
+		client: &http.Client{
+			Transport: roundTripFunc(func(req *http.Request) (*http.Response, error) {
+				switch {
+				case req.URL.Host == "song.link" && req.URL.Path == "/s/testspotifyid":
+					return &http.Response{
+						StatusCode: 500,
+						Header:     make(http.Header),
+						Body:       io.NopCloser(strings.NewReader("page failure")),
+						Request:    req,
+					}, nil
+				case req.URL.Host == "api.song.link":
+					body := `{"linksByPlatform":{"spotify":{"url":"https://open.spotify.com/track/testspotifyid"},"deezer":{"url":"https://www.deezer.com/track/908604612"},"amazonMusic":{"url":"https://music.amazon.com/albums/B086Q2QNLH?trackAsin=B086Q41M9C"},"tidal":{"url":"https://listen.tidal.com/track/134858527"},"qobuz":{"url":"https://open.qobuz.com/track/195125822"},"youtubeMusic":{"url":"https://music.youtube.com/watch?v=testvideoid1"}}}`
+					return &http.Response{
+						StatusCode: 200,
+						Header:     make(http.Header),
+						Body:       io.NopCloser(strings.NewReader(body)),
+						Request:    req,
+					}, nil
+				default:
+					t.Fatalf("unexpected request: %s", req.URL.String())
+					return nil, nil
+				}
+			}),
+		},
+	}
+
+	availability, err := client.CheckTrackAvailability("testspotifyid", "")
+	if err != nil {
+		t.Fatalf("CheckTrackAvailability() error = %v", err)
+	}
+
+	if availability.SpotifyID != "testspotifyid" {
+		t.Fatalf("SpotifyID = %q, want %q", availability.SpotifyID, "testspotifyid")
+	}
+	if !availability.Deezer || availability.DeezerID != "908604612" {
+		t.Fatalf("Deezer availability = %+v, want DeezerID 908604612", availability)
+	}
+	if !availability.Amazon || !availability.Tidal || !availability.Qobuz || !availability.YouTube {
+		t.Fatalf("availability flags = %+v, want Amazon/Tidal/Qobuz/YouTube true", availability)
+	}
+	if availability.YouTubeID != "testvideoid1" {
+		t.Fatalf("YouTubeID = %q, want %q", availability.YouTubeID, "testvideoid1")
+	}
+}

go_backend/spotfetch_api.go

@@ -10,7 +10,7 @@ import (
 	"time"
 )
 
-const DefaultSpotFetchAPIBaseURL = "https://spotify.afkarxyz.fun/api"
+const DefaultSpotFetchAPIBaseURL = "https://sp.afkarxyz.qzz.io/api"
 
 // GetSpotifyDataWithAPI fetches Spotify metadata through SpotFetch-compatible API.
 // This is used as a fallback when direct Spotify API access is blocked/limited.

go_backend/tidal.go

@@ -1911,6 +1911,32 @@ func resolveTidalTrackForRequest(req DownloadRequest, downloader *TidalDownloade
 		return nil, fmt.Errorf("failed to find tidal track id from request/cache/songlink")
 	}
 
+	// Verify the resolved track matches the request.
+	actualTrack, fetchErr := downloader.getPublicTrack(strconv.FormatInt(trackID, 10))
+	if fetchErr != nil {
+		GoLog("[%s] Warning: could not fetch Tidal track %d for verification: %v\n", logPrefix, trackID, fetchErr)
+		// Continue without verification — better than failing entirely.
+	} else {
+		providerArtist := actualTrack.Artist.Name
+		if providerArtist == "" && len(actualTrack.Artists) > 0 {
+			providerArtist = actualTrack.Artists[0].Name
+		}
+		resolved := resolvedTrackInfo{
+			Title:      actualTrack.Title,
+			ArtistName: providerArtist,
+			Duration:   actualTrack.Duration,
+		}
+		if !trackMatchesRequest(req, resolved, logPrefix) {
+			// Invalidate the cached ID so future requests don't reuse it.
+			if req.ISRC != "" {
+				GetTrackIDCache().SetTidal(req.ISRC, 0)
+			}
+			return nil, fmt.Errorf("tidal track %d does not match request: expected '%s - %s', got '%s - %s'",
+				trackID, req.ArtistName, req.TrackName, resolved.ArtistName, resolved.Title)
+		}
+		GoLog("[%s] Track %d verified: '%s - %s' ✓\n", logPrefix, trackID, resolved.ArtistName, resolved.Title)
+	}
+
 	track := &TidalTrack{
 		ID:           trackID,
 		Title:        strings.TrimSpace(req.TrackName),

go_backend/title_match_utils.go

@@ -68,3 +68,45 @@ func normalizeSymbolOnlyTitle(title string) string {
 
 	return b.String()
 }
+
+// ==================== Shared Track Verification ====================
+
+// resolvedTrackInfo holds the metadata fetched from a provider for verification.
+type resolvedTrackInfo struct {
+	Title      string
+	ArtistName string
+	Duration   int // seconds
+}
+
+// trackMatchesRequest checks whether a resolved track from a provider matches
+// the original download request. Returns true if the track is a plausible match.
+func trackMatchesRequest(req DownloadRequest, resolved resolvedTrackInfo, logPrefix string) bool {
+	if req.ArtistName != "" && resolved.ArtistName != "" &&
+		!artistsMatch(req.ArtistName, resolved.ArtistName) {
+		GoLog("[%s] Verification failed: artist mismatch — expected '%s', got '%s'\n",
+			logPrefix, req.ArtistName, resolved.ArtistName)
+		return false
+	}
+
+	if req.TrackName != "" && resolved.Title != "" &&
+		!titlesMatch(req.TrackName, resolved.Title) {
+		GoLog("[%s] Verification failed: title mismatch — expected '%s', got '%s'\n",
+			logPrefix, req.TrackName, resolved.Title)
+		return false
+	}
+
+	expectedDurationSec := req.DurationMS / 1000
+	if expectedDurationSec > 0 && resolved.Duration > 0 {
+		diff := expectedDurationSec - resolved.Duration
+		if diff < 0 {
+			diff = -diff
+		}
+		if diff > 10 {
+			GoLog("[%s] Verification failed: duration mismatch — expected %ds, got %ds\n",
+				logPrefix, expectedDurationSec, resolved.Duration)
+			return false
+		}
+	}
+
+	return true
+}

lib/constants/app_info.dart

@@ -3,8 +3,8 @@ import 'package:flutter/foundation.dart';
 /// App version and info constants
 /// Update version here only - all other files will reference this
 class AppInfo {
-  static const String version = '3.8.5';
-  static const String buildNumber = '111';
+  static const String version = '3.8.7';
+  static const String buildNumber = '113';
   static const String fullVersion = '$version+$buildNumber';
 
   /// Shows "Internal" in debug builds, actual version in release.

lib/l10n/app_localizations.dart

@@ -3106,6 +3106,42 @@ abstract class AppLocalizations {
   /// **'Show when searching for existing tracks'**
   String get libraryShowDuplicateIndicatorSubtitle;
 
+  /// Setting for automatic library scanning
+  ///
+  /// In en, this message translates to:
+  /// **'Auto Scan'**
+  String get libraryAutoScan;
+
+  /// Subtitle for auto scan setting
+  ///
+  /// In en, this message translates to:
+  /// **'Automatically scan your library for new files'**
+  String get libraryAutoScanSubtitle;
+
+  /// Auto scan disabled
+  ///
+  /// In en, this message translates to:
+  /// **'Off'**
+  String get libraryAutoScanOff;
+
+  /// Auto scan when app opens
+  ///
+  /// In en, this message translates to:
+  /// **'Every app open'**
+  String get libraryAutoScanOnOpen;
+
+  /// Auto scan once per day
+  ///
+  /// In en, this message translates to:
+  /// **'Daily'**
+  String get libraryAutoScanDaily;
+
+  /// Auto scan once per week
+  ///
+  /// In en, this message translates to:
+  /// **'Weekly'**
+  String get libraryAutoScanWeekly;
+
   /// Section header for library actions
   ///
   /// In en, this message translates to:

lib/l10n/app_localizations_de.dart

@@ -1719,6 +1719,25 @@ class AppLocalizationsDe extends AppLocalizations {
   String get libraryShowDuplicateIndicatorSubtitle =>
       'Bei der Suche nach vorhandenen Titeln anzeigen';
 
+  @override
+  String get libraryAutoScan => 'Auto Scan';
+
+  @override
+  String get libraryAutoScanSubtitle =>
+      'Automatically scan your library for new files';
+
+  @override
+  String get libraryAutoScanOff => 'Off';
+
+  @override
+  String get libraryAutoScanOnOpen => 'Every app open';
+
+  @override
+  String get libraryAutoScanDaily => 'Daily';
+
+  @override
+  String get libraryAutoScanWeekly => 'Weekly';
+
   @override
   String get libraryActions => 'Aktionen';
 

lib/l10n/app_localizations_en.dart

@@ -1695,6 +1695,25 @@ class AppLocalizationsEn extends AppLocalizations {
   String get libraryShowDuplicateIndicatorSubtitle =>
       'Show when searching for existing tracks';
 
+  @override
+  String get libraryAutoScan => 'Auto Scan';
+
+  @override
+  String get libraryAutoScanSubtitle =>
+      'Automatically scan your library for new files';
+
+  @override
+  String get libraryAutoScanOff => 'Off';
+
+  @override
+  String get libraryAutoScanOnOpen => 'Every app open';
+
+  @override
+  String get libraryAutoScanDaily => 'Daily';
+
+  @override
+  String get libraryAutoScanWeekly => 'Weekly';
+
   @override
   String get libraryActions => 'Actions';
 

lib/l10n/app_localizations_es.dart

@@ -1695,6 +1695,25 @@ class AppLocalizationsEs extends AppLocalizations {
   String get libraryShowDuplicateIndicatorSubtitle =>
       'Show when searching for existing tracks';
 
+  @override
+  String get libraryAutoScan => 'Auto Scan';
+
+  @override
+  String get libraryAutoScanSubtitle =>
+      'Automatically scan your library for new files';
+
+  @override
+  String get libraryAutoScanOff => 'Off';
+
+  @override
+  String get libraryAutoScanOnOpen => 'Every app open';
+
+  @override
+  String get libraryAutoScanDaily => 'Daily';
+
+  @override
+  String get libraryAutoScanWeekly => 'Weekly';
+
   @override
   String get libraryActions => 'Actions';
 

lib/l10n/app_localizations_fr.dart

@@ -1697,6 +1697,25 @@ class AppLocalizationsFr extends AppLocalizations {
   String get libraryShowDuplicateIndicatorSubtitle =>
       'Show when searching for existing tracks';
 
+  @override
+  String get libraryAutoScan => 'Auto Scan';
+
+  @override
+  String get libraryAutoScanSubtitle =>
+      'Automatically scan your library for new files';
+
+  @override
+  String get libraryAutoScanOff => 'Off';
+
+  @override
+  String get libraryAutoScanOnOpen => 'Every app open';
+
+  @override
+  String get libraryAutoScanDaily => 'Daily';
+
+  @override
+  String get libraryAutoScanWeekly => 'Weekly';
+
   @override
   String get libraryActions => 'Actions';
 

lib/l10n/app_localizations_hi.dart

@@ -1695,6 +1695,25 @@ class AppLocalizationsHi extends AppLocalizations {
   String get libraryShowDuplicateIndicatorSubtitle =>
       'Show when searching for existing tracks';
 
+  @override
+  String get libraryAutoScan => 'Auto Scan';
+
+  @override
+  String get libraryAutoScanSubtitle =>
+      'Automatically scan your library for new files';
+
+  @override
+  String get libraryAutoScanOff => 'Off';
+
+  @override
+  String get libraryAutoScanOnOpen => 'Every app open';
+
+  @override
+  String get libraryAutoScanDaily => 'Daily';
+
+  @override
+  String get libraryAutoScanWeekly => 'Weekly';
+
   @override
   String get libraryActions => 'Actions';
 

lib/l10n/app_localizations_id.dart

@@ -1702,6 +1702,25 @@ class AppLocalizationsId extends AppLocalizations {
   String get libraryShowDuplicateIndicatorSubtitle =>
       'Show when searching for existing tracks';
 
+  @override
+  String get libraryAutoScan => 'Auto Scan';
+
+  @override
+  String get libraryAutoScanSubtitle =>
+      'Automatically scan your library for new files';
+
+  @override
+  String get libraryAutoScanOff => 'Off';
+
+  @override
+  String get libraryAutoScanOnOpen => 'Every app open';
+
+  @override
+  String get libraryAutoScanDaily => 'Daily';
+
+  @override
+  String get libraryAutoScanWeekly => 'Weekly';
+
   @override
   String get libraryActions => 'Actions';
 

lib/l10n/app_localizations_ja.dart

@@ -1682,6 +1682,25 @@ class AppLocalizationsJa extends AppLocalizations {
   String get libraryShowDuplicateIndicatorSubtitle =>
       'Show when searching for existing tracks';
 
+  @override
+  String get libraryAutoScan => 'Auto Scan';
+
+  @override
+  String get libraryAutoScanSubtitle =>
+      'Automatically scan your library for new files';
+
+  @override
+  String get libraryAutoScanOff => 'Off';
+
+  @override
+  String get libraryAutoScanOnOpen => 'Every app open';
+
+  @override
+  String get libraryAutoScanDaily => 'Daily';
+
+  @override
+  String get libraryAutoScanWeekly => 'Weekly';
+
   @override
   String get libraryActions => 'アクション';
 

lib/l10n/app_localizations_ko.dart

@@ -1675,6 +1675,25 @@ class AppLocalizationsKo extends AppLocalizations {
   String get libraryShowDuplicateIndicatorSubtitle =>
       'Show when searching for existing tracks';
 
+  @override
+  String get libraryAutoScan => 'Auto Scan';
+
+  @override
+  String get libraryAutoScanSubtitle =>
+      'Automatically scan your library for new files';
+
+  @override
+  String get libraryAutoScanOff => 'Off';
+
+  @override
+  String get libraryAutoScanOnOpen => 'Every app open';
+
+  @override
+  String get libraryAutoScanDaily => 'Daily';
+
+  @override
+  String get libraryAutoScanWeekly => 'Weekly';
+
   @override
   String get libraryActions => 'Actions';
 

lib/l10n/app_localizations_nl.dart

@@ -1695,6 +1695,25 @@ class AppLocalizationsNl extends AppLocalizations {
   String get libraryShowDuplicateIndicatorSubtitle =>
       'Show when searching for existing tracks';
 
+  @override
+  String get libraryAutoScan => 'Auto Scan';
+
+  @override
+  String get libraryAutoScanSubtitle =>
+      'Automatically scan your library for new files';
+
+  @override
+  String get libraryAutoScanOff => 'Off';
+
+  @override
+  String get libraryAutoScanOnOpen => 'Every app open';
+
+  @override
+  String get libraryAutoScanDaily => 'Daily';
+
+  @override
+  String get libraryAutoScanWeekly => 'Weekly';
+
   @override
   String get libraryActions => 'Actions';
 

lib/l10n/app_localizations_pt.dart

@@ -1695,6 +1695,25 @@ class AppLocalizationsPt extends AppLocalizations {
   String get libraryShowDuplicateIndicatorSubtitle =>
       'Show when searching for existing tracks';
 
+  @override
+  String get libraryAutoScan => 'Auto Scan';
+
+  @override
+  String get libraryAutoScanSubtitle =>
+      'Automatically scan your library for new files';
+
+  @override
+  String get libraryAutoScanOff => 'Off';
+
+  @override
+  String get libraryAutoScanOnOpen => 'Every app open';
+
+  @override
+  String get libraryAutoScanDaily => 'Daily';
+
+  @override
+  String get libraryAutoScanWeekly => 'Weekly';
+
   @override
   String get libraryActions => 'Actions';
 

lib/l10n/app_localizations_ru.dart

@@ -1731,6 +1731,25 @@ class AppLocalizationsRu extends AppLocalizations {
   String get libraryShowDuplicateIndicatorSubtitle =>
       'Показать при поиске существующих треков';
 
+  @override
+  String get libraryAutoScan => 'Auto Scan';
+
+  @override
+  String get libraryAutoScanSubtitle =>
+      'Automatically scan your library for new files';
+
+  @override
+  String get libraryAutoScanOff => 'Off';
+
+  @override
+  String get libraryAutoScanOnOpen => 'Every app open';
+
+  @override
+  String get libraryAutoScanDaily => 'Daily';
+
+  @override
+  String get libraryAutoScanWeekly => 'Weekly';
+
   @override
   String get libraryActions => 'Действия';
 

lib/l10n/app_localizations_tr.dart

@@ -1707,6 +1707,25 @@ class AppLocalizationsTr extends AppLocalizations {
   String get libraryShowDuplicateIndicatorSubtitle =>
       'Show when searching for existing tracks';
 
+  @override
+  String get libraryAutoScan => 'Auto Scan';
+
+  @override
+  String get libraryAutoScanSubtitle =>
+      'Automatically scan your library for new files';
+
+  @override
+  String get libraryAutoScanOff => 'Off';
+
+  @override
+  String get libraryAutoScanOnOpen => 'Every app open';
+
+  @override
+  String get libraryAutoScanDaily => 'Daily';
+
+  @override
+  String get libraryAutoScanWeekly => 'Weekly';
+
   @override
   String get libraryActions => 'Actions';
 

lib/l10n/app_localizations_zh.dart

@@ -1695,6 +1695,25 @@ class AppLocalizationsZh extends AppLocalizations {
   String get libraryShowDuplicateIndicatorSubtitle =>
       'Show when searching for existing tracks';
 
+  @override
+  String get libraryAutoScan => 'Auto Scan';
+
+  @override
+  String get libraryAutoScanSubtitle =>
+      'Automatically scan your library for new files';
+
+  @override
+  String get libraryAutoScanOff => 'Off';
+
+  @override
+  String get libraryAutoScanOnOpen => 'Every app open';
+
+  @override
+  String get libraryAutoScanDaily => 'Daily';
+
+  @override
+  String get libraryAutoScanWeekly => 'Weekly';
+
   @override
   String get libraryActions => 'Actions';
 

lib/l10n/arb/app_en.arb

@@ -2242,6 +2242,30 @@
   "@libraryShowDuplicateIndicatorSubtitle": {
     "description": "Subtitle for duplicate indicator toggle"
   },
+  "libraryAutoScan": "Auto Scan",
+  "@libraryAutoScan": {
+    "description": "Setting for automatic library scanning"
+  },
+  "libraryAutoScanSubtitle": "Automatically scan your library for new files",
+  "@libraryAutoScanSubtitle": {
+    "description": "Subtitle for auto scan setting"
+  },
+  "libraryAutoScanOff": "Off",
+  "@libraryAutoScanOff": {
+    "description": "Auto scan disabled"
+  },
+  "libraryAutoScanOnOpen": "Every app open",
+  "@libraryAutoScanOnOpen": {
+    "description": "Auto scan when app opens"
+  },
+  "libraryAutoScanDaily": "Daily",
+  "@libraryAutoScanDaily": {
+    "description": "Auto scan once per day"
+  },
+  "libraryAutoScanWeekly": "Weekly",
+  "@libraryAutoScanWeekly": {
+    "description": "Auto scan once per week"
+  },
   "libraryActions": "Actions",
   "@libraryActions": {
     "description": "Section header for library actions"

lib/main.dart

@@ -4,6 +4,7 @@ import 'package:device_info_plus/device_info_plus.dart';
 import 'package:flutter/material.dart';
 import 'package:flutter_riverpod/flutter_riverpod.dart';
 import 'package:path_provider/path_provider.dart';
+import 'package:shared_preferences/shared_preferences.dart';
 import 'package:spotiflac_android/app.dart';
 import 'package:spotiflac_android/providers/download_queue_provider.dart';
 import 'package:spotiflac_android/providers/extension_provider.dart';
@@ -13,6 +14,7 @@ import 'package:spotiflac_android/providers/settings_provider.dart';
 import 'package:spotiflac_android/services/notification_service.dart';
 import 'package:spotiflac_android/services/share_intent_service.dart';
 import 'package:spotiflac_android/services/cover_cache_manager.dart';
+import 'package:spotiflac_android/utils/local_library_scan_prefs.dart';
 
 void main() async {
   WidgetsFlutterBinding.ensureInitialized();
@@ -90,16 +92,19 @@ class _EagerInitialization extends ConsumerStatefulWidget {
       _EagerInitializationState();
 }
 
-class _EagerInitializationState extends ConsumerState<_EagerInitialization> {
+class _EagerInitializationState extends ConsumerState<_EagerInitialization>
+    with WidgetsBindingObserver {
   ProviderSubscription<bool>? _localLibraryEnabledSub;
   Timer? _downloadHistoryWarmupTimer;
   Timer? _libraryCollectionsWarmupTimer;
   Timer? _localLibraryWarmupTimer;
   bool _localLibraryWarmupScheduled = false;
+  bool _autoScanTriggeredOnLaunch = false;
 
   @override
   void initState() {
     super.initState();
+    WidgetsBinding.instance.addObserver(this);
     WidgetsBinding.instance.addPostFrameCallback((_) {
       if (!mounted) return;
       _initializeAppServices();
@@ -110,6 +115,7 @@ class _EagerInitializationState extends ConsumerState<_EagerInitialization> {
 
   @override
   void dispose() {
+    WidgetsBinding.instance.removeObserver(this);
     _localLibraryEnabledSub?.close();
     _downloadHistoryWarmupTimer?.cancel();
     _libraryCollectionsWarmupTimer?.cancel();
@@ -117,6 +123,13 @@ class _EagerInitializationState extends ConsumerState<_EagerInitialization> {
     super.dispose();
   }
 
+  @override
+  void didChangeAppLifecycleState(AppLifecycleState state) {
+    if (state == AppLifecycleState.resumed) {
+      _maybeAutoScanLocalLibrary();
+    }
+  }
+
   void _initializeDeferredProviders() {
     _downloadHistoryWarmupTimer = _scheduleProviderWarmup(
       const Duration(milliseconds: 400),
@@ -155,7 +168,63 @@ class _EagerInitializationState extends ConsumerState<_EagerInitialization> {
     _localLibraryWarmupScheduled = true;
     _localLibraryWarmupTimer = _scheduleProviderWarmup(
       const Duration(milliseconds: 1600),
-      () => ref.read(localLibraryProvider),
+      () {
+        ref.read(localLibraryProvider);
+        // Trigger auto-scan after initial warmup on first app launch.
+        if (!_autoScanTriggeredOnLaunch) {
+          _autoScanTriggeredOnLaunch = true;
+          // Give the provider a moment to load existing data before scanning.
+          Future.delayed(const Duration(milliseconds: 500), () {
+            if (mounted) _maybeAutoScanLocalLibrary();
+          });
+        }
+      },
+    );
+  }
+
+  /// Checks whether an automatic incremental scan should be triggered based on
+  /// the user's auto-scan preference and the time since the last scan.
+  Future<void> _maybeAutoScanLocalLibrary() async {
+    if (!mounted) return;
+
+    final settings = ref.read(settingsProvider);
+    if (!settings.localLibraryEnabled) return;
+    if (settings.localLibraryPath.isEmpty) return;
+    if (settings.localLibraryAutoScan == 'off') return;
+
+    // Don't start a scan if one is already running.
+    final libraryState = ref.read(localLibraryProvider);
+    if (libraryState.isScanning) return;
+
+    // Determine cooldown based on auto-scan mode.
+    final now = DateTime.now();
+    final prefs = await SharedPreferences.getInstance();
+    final lastScanned = readLocalLibraryLastScannedAt(prefs);
+
+    if (lastScanned != null) {
+      final elapsed = now.difference(lastScanned);
+
+      switch (settings.localLibraryAutoScan) {
+        case 'on_open':
+          // Cooldown of 10 minutes to prevent rapid re-scans.
+          if (elapsed.inMinutes < 10) return;
+          break;
+        case 'daily':
+          if (elapsed.inHours < 24) return;
+          break;
+        case 'weekly':
+          if (elapsed.inDays < 7) return;
+          break;
+        default:
+          return;
+      }
+    }
+
+    // All checks passed -- start an incremental scan.
+    final iosBookmark = settings.localLibraryBookmark;
+    ref.read(localLibraryProvider.notifier).startScan(
+      settings.localLibraryPath,
+      iosBookmark: iosBookmark.isNotEmpty ? iosBookmark : null,
     );
   }
 

lib/models/settings.dart

@@ -59,6 +59,8 @@ class AppSettings {
   localLibraryBookmark; // Base64-encoded iOS security-scoped bookmark
   final bool
   localLibraryShowDuplicates; // Show indicator when searching for existing tracks
+  final String
+  localLibraryAutoScan; // Auto-scan mode: 'off', 'on_open', 'daily', 'weekly'
 
   final bool
   hasCompletedTutorial; // Track if user has completed the app tutorial
@@ -123,6 +125,7 @@ class AppSettings {
     this.localLibraryPath = '',
     this.localLibraryBookmark = '',
     this.localLibraryShowDuplicates = true,
+    this.localLibraryAutoScan = 'off',
     this.hasCompletedTutorial = false,
     this.lyricsProviders = const [
       'lrclib',
@@ -186,6 +189,7 @@ class AppSettings {
     String? localLibraryPath,
     String? localLibraryBookmark,
     bool? localLibraryShowDuplicates,
+    String? localLibraryAutoScan,
     bool? hasCompletedTutorial,
     List<String>? lyricsProviders,
     bool? lyricsIncludeTranslationNetease,
@@ -251,6 +255,8 @@ class AppSettings {
       localLibraryBookmark: localLibraryBookmark ?? this.localLibraryBookmark,
       localLibraryShowDuplicates:
           localLibraryShowDuplicates ?? this.localLibraryShowDuplicates,
+      localLibraryAutoScan:
+          localLibraryAutoScan ?? this.localLibraryAutoScan,
       hasCompletedTutorial: hasCompletedTutorial ?? this.hasCompletedTutorial,
       lyricsProviders: lyricsProviders ?? this.lyricsProviders,
       lyricsIncludeTranslationNetease:

lib/models/settings.g.dart

@@ -57,6 +57,7 @@ AppSettings _$AppSettingsFromJson(Map<String, dynamic> json) => AppSettings(
   localLibraryBookmark: json['localLibraryBookmark'] as String? ?? '',
   localLibraryShowDuplicates:
       json['localLibraryShowDuplicates'] as bool? ?? true,
+  localLibraryAutoScan: json['localLibraryAutoScan'] as String? ?? 'off',
   hasCompletedTutorial: json['hasCompletedTutorial'] as bool? ?? false,
   lyricsProviders:
       (json['lyricsProviders'] as List<dynamic>?)
@@ -129,6 +130,7 @@ Map<String, dynamic> _$AppSettingsToJson(
   'localLibraryPath': instance.localLibraryPath,
   'localLibraryBookmark': instance.localLibraryBookmark,
   'localLibraryShowDuplicates': instance.localLibraryShowDuplicates,
+  'localLibraryAutoScan': instance.localLibraryAutoScan,
   'hasCompletedTutorial': instance.hasCompletedTutorial,
   'lyricsProviders': instance.lyricsProviders,
   'lyricsIncludeTranslationNetease': instance.lyricsIncludeTranslationNetease,

lib/providers/download_queue_provider.dart

@@ -770,6 +770,37 @@ class DownloadHistoryNotifier extends Notifier<DownloadHistoryState> {
 
   /// Remove history entries where the file no longer exists on disk
   /// Returns the number of orphaned entries removed
+  /// Audio file extensions that the app commonly produces or converts between.
+  static const _audioExtensions = [
+    '.flac',
+    '.m4a',
+    '.mp3',
+    '.opus',
+    '.ogg',
+    '.wav',
+    '.aac',
+  ];
+
+  /// When the original file is missing, check whether a sibling with a
+  /// different audio extension exists (e.g. the user converted .flac → .opus).
+  /// Returns the path of the first match found, or `null` if none exist.
+  Future<String?> _findConvertedSibling(String originalPath) async {
+    // Strip the current extension to get the base path.
+    final dotIndex = originalPath.lastIndexOf('.');
+    if (dotIndex < 0) return null;
+    final basePath = originalPath.substring(0, dotIndex);
+    final originalExt = originalPath.substring(dotIndex).toLowerCase();
+
+    for (final ext in _audioExtensions) {
+      if (ext == originalExt) continue;
+      final candidatePath = '$basePath$ext';
+      try {
+        if (await fileExists(candidatePath)) return candidatePath;
+      } catch (_) {}
+    }
+    return null;
+  }
+
   Future<int> cleanupOrphanedDownloads() async {
     _historyLog.i('Starting orphaned downloads cleanup...');
 
@@ -791,7 +822,21 @@ class DownloadHistoryNotifier extends Notifier<DownloadHistoryState> {
           if (filePath == null || filePath.isEmpty) return null;
           pathById[id] = filePath;
           try {
-            return MapEntry(id, await fileExists(filePath));
+            if (await fileExists(filePath)) return MapEntry(id, true);
+
+            // Original file missing -- check for a converted sibling.
+            final sibling = await _findConvertedSibling(filePath);
+            if (sibling != null) {
+              _historyLog.i(
+                'Found converted sibling for $id: $filePath → $sibling',
+              );
+              // Update the stored path so future checks succeed immediately.
+              await _db.updateFilePath(id, sibling);
+              pathById[id] = sibling;
+              return MapEntry(id, true);
+            }
+
+            return MapEntry(id, false);
           } catch (e) {
             _historyLog.w('Error checking file existence for $id: $e');
             return MapEntry(id, false);
@@ -960,6 +1005,7 @@ class DownloadQueueNotifier extends Notifier<DownloadQueueState> {
   int _lastNotifPercent = -1;
   int _lastNotifQueueCount = -1;
   final Set<String> _locallyCancelledItemIds = {};
+  final Set<String> _pausePendingItemIds = {};
 
   double _normalizeProgressForUi(double value) {
     final clamped = value.clamp(0.0, 1.0).toDouble();
@@ -1279,6 +1325,10 @@ class DownloadQueueNotifier extends Notifier<DownloadQueueState> {
       if (localItem == null) {
         continue;
       }
+      if (_isPausePending(itemId)) {
+        PlatformBridge.clearItemProgress(itemId).catchError((_) {});
+        continue;
+      }
       if (localItem.status == DownloadStatus.skipped) {
         PlatformBridge.clearItemProgress(itemId).catchError((_) {});
         continue;
@@ -2078,12 +2128,42 @@ class DownloadQueueNotifier extends Notifier<DownloadQueueState> {
     return resolved?.status == DownloadStatus.skipped;
   }
 
+  bool _isPausePending(String id) => _pausePendingItemIds.contains(id);
+
+  void _requeueItemForPause(String id) {
+    final updatedItems = state.items
+        .map((item) {
+          if (item.id != id) return item;
+          if (item.status == DownloadStatus.completed ||
+              item.status == DownloadStatus.failed ||
+              item.status == DownloadStatus.skipped) {
+            return item;
+          }
+          return item.copyWith(
+            status: DownloadStatus.queued,
+            progress: 0,
+            speedMBps: 0,
+            bytesReceived: 0,
+          );
+        })
+        .toList(growable: false);
+
+    final currentDownload = state.currentDownload?.id == id
+        ? null
+        : state.currentDownload;
+    state = state.copyWith(
+      items: updatedItems,
+      currentDownload: currentDownload,
+    );
+  }
+
   void _requestNativeCancel(String id) {
     PlatformBridge.cancelDownload(id).catchError((_) {});
     PlatformBridge.clearItemProgress(id).catchError((_) {});
   }
 
   void cancelItem(String id) {
+    _pausePendingItemIds.remove(id);
     _locallyCancelledItemIds.add(id);
     updateItemStatus(id, DownloadStatus.skipped);
     _requestNativeCancel(id);
@@ -2116,6 +2196,7 @@ class DownloadQueueNotifier extends Notifier<DownloadQueueState> {
         .toList(growable: false);
 
     if (activeIds.isNotEmpty) {
+      _pausePendingItemIds.addAll(activeIds);
       _locallyCancelledItemIds.addAll(activeIds);
       for (final id in activeIds) {
         _requestNativeCancel(id);
@@ -2128,11 +2209,29 @@ class DownloadQueueNotifier extends Notifier<DownloadQueueState> {
     if (!wasProcessing) {
       _locallyCancelledItemIds.clear();
     }
+    _pausePendingItemIds.clear();
   }
 
   void pauseQueue() {
     if (state.isProcessing && !state.isPaused) {
-      state = state.copyWith(isPaused: true);
+      final activeIds = state.items
+          .where(
+            (item) =>
+                item.status == DownloadStatus.downloading ||
+                item.status == DownloadStatus.finalizing,
+          )
+          .map((item) => item.id)
+          .toSet();
+
+      if (activeIds.isNotEmpty) {
+        _pausePendingItemIds.addAll(activeIds);
+        for (final id in activeIds) {
+          _requestNativeCancel(id);
+          _requeueItemForPause(id);
+        }
+      }
+
+      state = state.copyWith(isPaused: true, currentDownload: null);
       _notificationService.cancelDownloadNotification();
       _log.i('Queue paused');
     }
@@ -2334,7 +2433,11 @@ class DownloadQueueNotifier extends Notifier<DownloadQueueState> {
     }
   }
 
+  /// Deezer CDN cover size pattern: /WxH-0-0-0-0.jpg
+  static final _deezerSizeRegex = RegExp(r'/(\d+)x(\d+)-\d+-\d+-\d+-\d+\.jpg$');
+
   String _upgradeToMaxQualityCover(String coverUrl) {
+    // Spotify CDN upgrade (hash-based size identifiers)
     const spotifySize300 = 'ab67616d00001e02';
     const spotifySize640 = 'ab67616d0000b273';
     const spotifySizeMax = 'ab67616d000082c1';
@@ -2343,11 +2446,29 @@ class DownloadQueueNotifier extends Notifier<DownloadQueueState> {
     if (result.contains(spotifySize300)) {
       result = result.replaceFirst(spotifySize300, spotifySize640);
     }
-
     if (result.contains(spotifySize640)) {
       result = result.replaceFirst(spotifySize640, spotifySizeMax);
     }
 
+    // Deezer CDN upgrade (1000x1000 → 1800x1800)
+    if (result.contains('cdn-images.dzcdn.net')) {
+      final upgraded = result.replaceFirst(
+        _deezerSizeRegex,
+        '/1800x1800-000000-80-0-0.jpg',
+      );
+      if (upgraded != result) {
+        _log.d('Cover URL upgraded (Deezer): 1800x1800');
+        result = upgraded;
+      }
+    }
+
+    // Tidal CDN upgrade (1280x1280 → origin)
+    if (result.contains('resources.tidal.com') &&
+        result.contains('/1280x1280.jpg')) {
+      result = result.replaceFirst('/1280x1280.jpg', '/origin.jpg');
+      _log.d('Cover URL upgraded (Tidal): origin');
+    }
+
     return result;
   }
 
@@ -3201,7 +3322,11 @@ class DownloadQueueNotifier extends Notifier<DownloadQueueState> {
       }
 
       final queuedItems = state.items
-          .where((item) => item.status == DownloadStatus.queued)
+          .where(
+            (item) =>
+                item.status == DownloadStatus.queued &&
+                !_pausePendingItemIds.contains(item.id),
+          )
           .toList();
 
       if (queuedItems.isEmpty && activeDownloads.isEmpty) {
@@ -3246,11 +3371,13 @@ class DownloadQueueNotifier extends Notifier<DownloadQueueState> {
     _stopProgressPolling();
     final remainingIds = state.items.map((item) => item.id).toSet();
     _locallyCancelledItemIds.removeWhere((id) => !remainingIds.contains(id));
+    _pausePendingItemIds.removeWhere((id) => !remainingIds.contains(id));
   }
 
   Future<void> _downloadSingleItem(DownloadItem item) async {
     _log.d('Processing: ${item.track.name} by ${item.track.artistName}');
     _log.d('Cover URL: ${item.track.coverUrl}');
+    var pausedDuringThisRun = false;
 
     final currentItem = _findItemById(item.id) ?? item;
     if (_isLocallyCancelled(item.id, item: currentItem)) {
@@ -3258,11 +3385,33 @@ class DownloadQueueNotifier extends Notifier<DownloadQueueState> {
       return;
     }
 
+    if (_isPausePending(item.id)) {
+      pausedDuringThisRun = true;
+      _requeueItemForPause(item.id);
+      _log.i('Download is pause-pending before start, skipping');
+      return;
+    }
+
     state = state.copyWith(currentDownload: item);
 
     updateItemStatus(item.id, DownloadStatus.downloading);
 
     try {
+      bool shouldAbortWork(String stage) {
+        final current = _findItemById(item.id);
+        if (_isLocallyCancelled(item.id, item: current)) {
+          _log.i('Download was cancelled $stage, skipping');
+          return true;
+        }
+        if (_isPausePending(item.id)) {
+          pausedDuringThisRun = true;
+          _requeueItemForPause(item.id);
+          _log.i('Download pause requested $stage, re-queueing');
+          return true;
+        }
+        return false;
+      }
+
       final settings = ref.read(settingsProvider);
       final metadataEmbeddingEnabled = settings.embedMetadata;
 
@@ -3343,6 +3492,10 @@ class DownloadQueueNotifier extends Notifier<DownloadQueueState> {
           _log.w('Failed to enrich metadata: $e');
           _log.w('Stack trace: $stack');
         }
+
+        if (shouldAbortWork('during metadata enrichment')) {
+          return;
+        }
       }
 
       _log.d('Track coverUrl after enrichment: ${trackToDownload.coverUrl}');
@@ -3456,6 +3609,10 @@ class DownloadQueueNotifier extends Notifier<DownloadQueueState> {
         } catch (e) {
           _log.w('Failed to search Deezer by ISRC: $e');
         }
+
+        if (shouldAbortWork('during Deezer ISRC lookup')) {
+          return;
+        }
       }
 
       // Fallback: Use SongLink to convert Spotify ID to Deezer ID
@@ -3556,6 +3713,10 @@ class DownloadQueueNotifier extends Notifier<DownloadQueueState> {
         } catch (e) {
           _log.w('Failed to convert Spotify to Deezer via SongLink: $e');
         }
+
+        if (shouldAbortWork('during SongLink availability lookup')) {
+          return;
+        }
       }
 
       if (deezerTrackId != null && deezerTrackId.isNotEmpty) {
@@ -3575,6 +3736,10 @@ class DownloadQueueNotifier extends Notifier<DownloadQueueState> {
         } catch (e) {
           _log.w('Failed to fetch extended metadata from Deezer: $e');
         }
+
+        if (shouldAbortWork('during extended metadata lookup')) {
+          return;
+        }
       }
 
       Map<String, dynamic> result;
@@ -3693,8 +3858,7 @@ class DownloadQueueNotifier extends Notifier<DownloadQueueState> {
         );
       }
 
-      if (_isLocallyCancelled(item.id)) {
-        _log.i('Download was cancelled before native download start, skipping');
+      if (shouldAbortWork('before native download start')) {
         return;
       }
 
@@ -3736,10 +3900,8 @@ class DownloadQueueNotifier extends Notifier<DownloadQueueState> {
       _log.d('Result: $result');
 
       final itemAfterResult = _findItemById(item.id);
-      final cancelledAfterResult =
-          itemAfterResult == null ||
-          _isLocallyCancelled(item.id, item: itemAfterResult);
-      if (cancelledAfterResult) {
+      if (itemAfterResult == null ||
+          _isLocallyCancelled(item.id, item: itemAfterResult)) {
         _log.i('Download was cancelled, skipping result processing');
         final filePath = result['file_path'] as String?;
         if (filePath != null && result['success'] == true) {
@@ -3749,6 +3911,18 @@ class DownloadQueueNotifier extends Notifier<DownloadQueueState> {
         return;
       }
 
+      if (_isPausePending(item.id)) {
+        pausedDuringThisRun = true;
+        final filePath = result['file_path'] as String?;
+        if (filePath != null && result['success'] == true) {
+          await deleteFile(filePath);
+          _log.d('Deleted paused download file: $filePath');
+        }
+        _requeueItemForPause(item.id);
+        _log.i('Download pause requested after result, re-queueing');
+        return;
+      }
+
       if (result['success'] == true) {
         var filePath = result['file_path'] as String?;
         final reportedFileName = result['file_name'] as String?;
@@ -4282,6 +4456,19 @@ class DownloadQueueNotifier extends Notifier<DownloadQueueState> {
           return;
         }
 
+        if (_isPausePending(item.id)) {
+          pausedDuringThisRun = true;
+          if (filePath != null) {
+            await deleteFile(filePath);
+            _log.d(
+              'Deleted paused download file during finalization: $filePath',
+            );
+          }
+          _requeueItemForPause(item.id);
+          _log.i('Download pause requested during finalization, re-queueing');
+          return;
+        }
+
         // SAF downloads should end with content URI. If we still have a
         // transient FD path, recover URI from SAF metadata to keep history
         // dedup/exclusion stable.
@@ -4549,11 +4736,26 @@ class DownloadQueueNotifier extends Notifier<DownloadQueueState> {
           return;
         }
 
+        if (_isPausePending(item.id)) {
+          pausedDuringThisRun = true;
+          _requeueItemForPause(item.id);
+          _log.i('Download pause requested after backend failure, re-queueing');
+          return;
+        }
+
         final errorMsg = result['error'] as String? ?? 'Download failed';
         final errorTypeStr = result['error_type'] as String? ?? 'unknown';
         if (errorTypeStr == 'cancelled') {
-          _log.i('Download was cancelled by backend, skipping error handling');
-          updateItemStatus(item.id, DownloadStatus.skipped);
+          if (_isPausePending(item.id)) {
+            pausedDuringThisRun = true;
+            _requeueItemForPause(item.id);
+            _log.i('Download was paused by backend cancellation, re-queueing');
+          } else {
+            _log.i(
+              'Download was cancelled by backend, skipping error handling',
+            );
+            updateItemStatus(item.id, DownloadStatus.skipped);
+          }
           return;
         }
 
@@ -4612,6 +4814,13 @@ class DownloadQueueNotifier extends Notifier<DownloadQueueState> {
         return;
       }
 
+      if (_isPausePending(item.id)) {
+        pausedDuringThisRun = true;
+        _requeueItemForPause(item.id);
+        _log.i('Download pause requested after exception, re-queueing');
+        return;
+      }
+
       _log.e('Exception: $e', e, stackTrace);
 
       String errorMsg = e.toString();
@@ -4637,6 +4846,10 @@ class DownloadQueueNotifier extends Notifier<DownloadQueueState> {
       } catch (cleanupErr) {
         _log.e('Post-exception connection cleanup failed: $cleanupErr');
       }
+    } finally {
+      if (pausedDuringThisRun) {
+        _pausePendingItemIds.remove(item.id);
+      }
     }
   }
 }

lib/providers/local_library_provider.dart

@@ -9,11 +9,11 @@ import 'package:spotiflac_android/services/library_database.dart';
 import 'package:spotiflac_android/services/notification_service.dart';
 import 'package:spotiflac_android/services/platform_bridge.dart';
 import 'package:spotiflac_android/utils/logger.dart';
+import 'package:spotiflac_android/utils/local_library_scan_prefs.dart';
 import 'package:spotiflac_android/utils/path_match_keys.dart';
 
 final _log = AppLogger('LocalLibrary');
 
-const _lastScannedAtKey = 'local_library_last_scanned_at';
 const _excludedDownloadedCountKey = 'local_library_excluded_downloaded_count';
 final _prefs = SharedPreferences.getInstance();
 
@@ -165,10 +165,7 @@ class LocalLibraryNotifier extends Notifier<LocalLibraryState> {
       var excludedDownloadedCount = 0;
       try {
         final prefs = await prefsFuture;
-        final lastScannedAtStr = prefs.getString(_lastScannedAtKey);
-        if (lastScannedAtStr != null && lastScannedAtStr.isNotEmpty) {
-          lastScannedAt = DateTime.tryParse(lastScannedAtStr);
-        }
+        lastScannedAt = readLocalLibraryLastScannedAt(prefs);
         excludedDownloadedCount =
             prefs.getInt(_excludedDownloadedCountKey) ?? 0;
       } catch (e) {
@@ -336,7 +333,7 @@ class LocalLibraryNotifier extends Notifier<LocalLibraryState> {
         final now = DateTime.now();
         try {
           final prefs = await SharedPreferences.getInstance();
-          await prefs.setString(_lastScannedAtKey, now.toIso8601String());
+          await writeLocalLibraryLastScannedAt(prefs, now);
           await prefs.setInt(_excludedDownloadedCountKey, skippedDownloads);
           _log.d('Saved lastScannedAt: $now');
         } catch (e) {
@@ -500,7 +497,7 @@ class LocalLibraryNotifier extends Notifier<LocalLibraryState> {
         final now = DateTime.now();
         try {
           final prefs = await SharedPreferences.getInstance();
-          await prefs.setString(_lastScannedAtKey, now.toIso8601String());
+          await writeLocalLibraryLastScannedAt(prefs, now);
           await prefs.setInt(_excludedDownloadedCountKey, skippedDownloads);
           _log.d('Saved lastScannedAt: $now');
         } catch (e) {
@@ -818,7 +815,7 @@ class LocalLibraryNotifier extends Notifier<LocalLibraryState> {
 
     try {
       final prefs = await SharedPreferences.getInstance();
-      await prefs.remove(_lastScannedAtKey);
+      await clearLocalLibraryLastScannedAt(prefs);
       await prefs.remove(_excludedDownloadedCountKey);
     } catch (e) {
       _log.w('Failed to clear lastScannedAt: $e');

lib/providers/settings_provider.dart

@@ -518,6 +518,11 @@ class SettingsNotifier extends Notifier<AppSettings> {
     _saveSettings();
   }
 
+  void setLocalLibraryAutoScan(String mode) {
+    state = state.copyWith(localLibraryAutoScan: mode);
+    _saveSettings();
+  }
+
   void setTutorialComplete() {
     state = state.copyWith(hasCompletedTutorial: true);
     _saveSettings();

lib/screens/album_screen.dart

@@ -81,7 +81,6 @@ class _AlbumScreenState extends ConsumerState<AlbumScreen> {
     _scrollController.addListener(_onScroll);
 
     WidgetsBinding.instance.addPostFrameCallback((_) {
-      // Use extensionId if available, otherwise detect from albumId prefix
       final providerId =
           widget.extensionId ??
           (() {
@@ -134,9 +133,7 @@ class _AlbumScreenState extends ConsumerState<AlbumScreen> {
     return (mediaSize.height * 0.55).clamp(360.0, 520.0);
   }
 
-  /// Upgrade cover URL to a reasonable resolution for full-screen display.
-  /// Spotify CDN only has 300, 640, ~2000 — we stay at 640 (no intermediate).
-  /// Deezer CDN: upgrade to 1000x1000 (available: 56, 250, 500, 1000, 1400, 1800).
+  /// Upgrade cover URL to a higher resolution for full-screen display.
   String? _highResCoverUrl(String? url) {
     if (url == null) return null;
     // Spotify CDN: upgrade 300 → 640 only (no intermediate between 640 and 2000)
@@ -519,7 +516,6 @@ class _AlbumScreenState extends ConsumerState<AlbumScreen> {
   }
 
   Widget _buildInfoCard(BuildContext context, ColorScheme colorScheme) {
-    // Info is now displayed in the full-screen cover overlay
     return const SliverToBoxAdapter(child: SizedBox.shrink());
   }
 
@@ -574,37 +570,74 @@ class _AlbumScreenState extends ConsumerState<AlbumScreen> {
   void _downloadAll(BuildContext context) {
     final tracks = _tracks;
     if (tracks == null || tracks.isEmpty) return;
+
+    // Skip already-downloaded tracks
+    final historyState = ref.read(downloadHistoryProvider);
     final settings = ref.read(settingsProvider);
+    final localLibState = (settings.localLibraryEnabled && settings.localLibraryShowDuplicates)
+        ? ref.read(localLibraryProvider)
+        : null;
+    final tracksToQueue = <Track>[];
+    int skippedCount = 0;
+
+    for (final track in tracks) {
+      final isInHistory = historyState.isDownloaded(track.id) ||
+          (track.isrc != null && historyState.getByIsrc(track.isrc!) != null) ||
+          historyState.findByTrackAndArtist(track.name, track.artistName) != null;
+      final isInLocal = localLibState?.existsInLibrary(
+            isrc: track.isrc,
+            trackName: track.name,
+            artistName: track.artistName,
+          ) ??
+          false;
+
+      if (isInHistory || isInLocal) {
+        skippedCount++;
+      } else {
+        tracksToQueue.add(track);
+      }
+    }
+
+    if (tracksToQueue.isEmpty) {
+      ScaffoldMessenger.of(context).showSnackBar(
+        SnackBar(
+          content: Text(
+            context.l10n.discographySkippedDownloaded(0, skippedCount),
+          ),
+        ),
+      );
+      return;
+    }
+
     if (settings.askQualityBeforeDownload) {
       DownloadServicePicker.show(
         context,
-        trackName: '${tracks.length} tracks',
+        trackName: '${tracksToQueue.length} tracks',
         artistName: widget.albumName,
         onSelect: (quality, service) {
           ref
               .read(downloadQueueProvider.notifier)
-              .addMultipleToQueue(tracks, service, qualityOverride: quality);
-          ScaffoldMessenger.of(context).showSnackBar(
-            SnackBar(
-              content: Text(
-                context.l10n.snackbarAddedTracksToQueue(tracks.length),
-              ),
-            ),
-          );
+              .addMultipleToQueue(tracksToQueue, service, qualityOverride: quality);
+          _showQueuedSnackbar(context, tracksToQueue.length, skippedCount);
         },
       );
     } else {
       ref
           .read(downloadQueueProvider.notifier)
-          .addMultipleToQueue(tracks, settings.defaultService);
-      ScaffoldMessenger.of(context).showSnackBar(
-        SnackBar(
-          content: Text(context.l10n.snackbarAddedTracksToQueue(tracks.length)),
-        ),
-      );
+          .addMultipleToQueue(tracksToQueue, settings.defaultService);
+      _showQueuedSnackbar(context, tracksToQueue.length, skippedCount);
     }
   }
 
+  void _showQueuedSnackbar(BuildContext context, int added, int skipped) {
+    final message = skipped > 0
+        ? context.l10n.discographySkippedDownloaded(added, skipped)
+        : context.l10n.snackbarAddedTracksToQueue(added);
+    ScaffoldMessenger.of(context).showSnackBar(
+      SnackBar(content: Text(message)),
+    );
+  }
+
   Widget _buildLoveAllButton() {
     final collectionsState = ref.watch(libraryCollectionsProvider);
     final tracks = _tracks;

lib/screens/library_tracks_folder_screen.dart

@@ -872,12 +872,54 @@ class _LibraryTracksFolderScreenState
 
   void _downloadAll(List<Track> tracks) {
     if (tracks.isEmpty) return;
+    final historyState = ref.read(downloadHistoryProvider);
     final settings = ref.read(settingsProvider);
-    final playlistName = widget.mode == LibraryTracksFolderMode.playlist ? playlist?.name ?? context.l10n.collectionPlaylist : null;
+    final localLibState =
+        (settings.localLibraryEnabled && settings.localLibraryShowDuplicates)
+        ? ref.read(localLibraryProvider)
+        : null;
+    final playlistName = widget.mode == LibraryTracksFolderMode.playlist
+        ? playlist?.name ?? context.l10n.collectionPlaylist
+        : null;
+    final tracksToQueue = <Track>[];
+    var skippedCount = 0;
+
+    for (final track in tracks) {
+      final isInHistory =
+          historyState.isDownloaded(track.id) ||
+          (track.isrc != null && historyState.getByIsrc(track.isrc!) != null) ||
+          historyState.findByTrackAndArtist(track.name, track.artistName) !=
+              null;
+      final isInLocal =
+          localLibState?.existsInLibrary(
+            isrc: track.isrc,
+            trackName: track.name,
+            artistName: track.artistName,
+          ) ??
+          false;
+
+      if (isInHistory || isInLocal) {
+        skippedCount++;
+      } else {
+        tracksToQueue.add(track);
+      }
+    }
+
+    if (tracksToQueue.isEmpty) {
+      ScaffoldMessenger.of(context).showSnackBar(
+        SnackBar(
+          content: Text(
+            context.l10n.discographySkippedDownloaded(0, skippedCount),
+          ),
+        ),
+      );
+      return;
+    }
+
     if (settings.askQualityBeforeDownload) {
       DownloadServicePicker.show(
         context,
-        trackName: '${tracks.length} tracks',
+        trackName: '${tracksToQueue.length} tracks',
         artistName: switch (widget.mode) {
           LibraryTracksFolderMode.wishlist => context.l10n.collectionWishlist,
           LibraryTracksFolderMode.loved => context.l10n.collectionLoved,
@@ -886,12 +928,24 @@ class _LibraryTracksFolderScreenState
         onSelect: (quality, service) {
           ref
               .read(downloadQueueProvider.notifier)
-              .addMultipleToQueue(tracks, service, qualityOverride: quality, playlistName: playlistName);
+              .addMultipleToQueue(
+                tracksToQueue,
+                service,
+                qualityOverride: quality,
+                playlistName: playlistName,
+              );
           if (!mounted) return;
           ScaffoldMessenger.of(context).showSnackBar(
             SnackBar(
               content: Text(
-                context.l10n.snackbarAddedTracksToQueue(tracks.length),
+                skippedCount > 0
+                    ? context.l10n.discographySkippedDownloaded(
+                        tracksToQueue.length,
+                        skippedCount,
+                      )
+                    : context.l10n.snackbarAddedTracksToQueue(
+                        tracksToQueue.length,
+                      ),
               ),
             ),
           );
@@ -900,10 +954,21 @@ class _LibraryTracksFolderScreenState
     } else {
       ref
           .read(downloadQueueProvider.notifier)
-          .addMultipleToQueue(tracks, settings.defaultService, playlistName: playlistName);
+          .addMultipleToQueue(
+            tracksToQueue,
+            settings.defaultService,
+            playlistName: playlistName,
+          );
       ScaffoldMessenger.of(context).showSnackBar(
         SnackBar(
-          content: Text(context.l10n.snackbarAddedTracksToQueue(tracks.length)),
+          content: Text(
+            skippedCount > 0
+                ? context.l10n.discographySkippedDownloaded(
+                    tracksToQueue.length,
+                    skippedCount,
+                  )
+                : context.l10n.snackbarAddedTracksToQueue(tracksToQueue.length),
+          ),
         ),
       );
     }

lib/screens/local_album_screen.dart

@@ -626,11 +626,13 @@ class _LocalAlbumScreenState extends ConsumerState<LocalAlbumScreen> {
 
       slivers.add(
         SliverList(
-          delegate: SliverChildBuilderDelegate(
-            (context, index) =>
-                _buildTrackItem(context, colorScheme, discTracks[index]),
-            childCount: discTracks.length,
-          ),
+          delegate: SliverChildBuilderDelegate((context, index) {
+            final track = discTracks[index];
+            return KeyedSubtree(
+              key: ValueKey(track.id),
+              child: _buildTrackItem(context, colorScheme, track),
+            );
+          }, childCount: discTracks.length),
         ),
       );
     }
@@ -900,16 +902,19 @@ class _LocalAlbumScreenState extends ConsumerState<LocalAlbumScreen> {
     return false;
   }
 
-  Future<void> _queueSelectedAsFlac(List<LocalLibraryItem> allTracks) async {
+  List<LocalLibraryItem> _selectedFlacEligibleItems(
+    List<LocalLibraryItem> allTracks,
+  ) {
     final tracksById = {for (final t in allTracks) t.id: t};
-    final selected = <LocalLibraryItem>[];
+    return _selectedIds
+        .map((id) => tracksById[id])
+        .whereType<LocalLibraryItem>()
+        .where(LocalTrackRedownloadService.isFlacUpgradeEligible)
+        .toList(growable: false);
+  }
 
-    for (final id in _selectedIds) {
-      final item = tracksById[id];
-      if (item != null) {
-        selected.add(item);
-      }
-    }
+  Future<void> _queueSelectedAsFlac(List<LocalLibraryItem> allTracks) async {
+    final selected = _selectedFlacEligibleItems(allTracks);
 
     if (selected.isEmpty) {
       return;
@@ -962,9 +967,7 @@ class _LocalAlbumScreenState extends ConsumerState<LocalAlbumScreen> {
       ScaffoldMessenger.of(context).clearSnackBars();
       ScaffoldMessenger.of(context).showSnackBar(
         SnackBar(
-          content: Text(
-            context.l10n.queueFlacFindingProgress(i + 1, total),
-          ),
+          content: Text(context.l10n.queueFlacFindingProgress(i + 1, total)),
           duration: const Duration(seconds: 30),
         ),
       );
@@ -1177,8 +1180,9 @@ class _LocalAlbumScreenState extends ConsumerState<LocalAlbumScreen> {
     String selectedFormat = formats.first;
     bool isLosslessTarget =
         selectedFormat == 'ALAC' || selectedFormat == 'FLAC';
-    String selectedBitrate =
-        isLosslessTarget ? '320k' : (selectedFormat == 'Opus' ? '128k' : '320k');
+    String selectedBitrate = isLosslessTarget
+        ? '320k'
+        : (selectedFormat == 'Opus' ? '128k' : '320k');
 
     showModalBottomSheet(
       context: context,
@@ -1240,8 +1244,9 @@ class _LocalAlbumScreenState extends ConsumerState<LocalAlbumScreen> {
                                 isLosslessTarget =
                                     format == 'ALAC' || format == 'FLAC';
                                 if (!isLosslessTarget) {
-                                  selectedBitrate =
-                                      format == 'Opus' ? '128k' : '320k';
+                                  selectedBitrate = format == 'Opus'
+                                      ? '128k'
+                                      : '320k';
                                 }
                               });
                             }
@@ -1286,11 +1291,8 @@ class _LocalAlbumScreenState extends ConsumerState<LocalAlbumScreen> {
                           const SizedBox(width: 6),
                           Text(
                             context.l10n.trackConvertLosslessHint,
-                            style: Theme.of(
-                              context,
-                            ).textTheme.bodySmall?.copyWith(
-                              color: colorScheme.primary,
-                            ),
+                            style: Theme.of(context).textTheme.bodySmall
+                                ?.copyWith(color: colorScheme.primary),
                           ),
                         ],
                       ),
@@ -1371,7 +1373,8 @@ class _LocalAlbumScreenState extends ConsumerState<LocalAlbumScreen> {
       if (currentFormat == null || currentFormat == targetFormat) continue;
       // Skip lossy sources when target is lossless (pointless re-encoding)
       final isLosslessTarget = targetFormat == 'ALAC' || targetFormat == 'FLAC';
-      final isLosslessSource = currentFormat == 'FLAC' || currentFormat == 'M4A';
+      final isLosslessSource =
+          currentFormat == 'FLAC' || currentFormat == 'M4A';
       if (isLosslessTarget && !isLosslessSource) continue;
       selected.add(item);
     }
@@ -1656,6 +1659,7 @@ class _LocalAlbumScreenState extends ConsumerState<LocalAlbumScreen> {
     double bottomPadding,
   ) {
     final selectedCount = _selectedIds.length;
+    final flacEligibleCount = _selectedFlacEligibleItems(tracks).length;
     final allSelected = selectedCount == tracks.length && tracks.isNotEmpty;
 
     return Container(
@@ -1747,17 +1751,18 @@ class _LocalAlbumScreenState extends ConsumerState<LocalAlbumScreen> {
 
               Row(
                 children: [
-                  Expanded(
-                    child: _LocalAlbumSelectionActionButton(
-                      icon: Icons.download_for_offline_outlined,
-                      label: '${context.l10n.queueFlacAction} ($selectedCount)',
-                      onPressed: selectedCount > 0
-                          ? () => _queueSelectedAsFlac(tracks)
-                          : null,
-                      colorScheme: colorScheme,
+                  if (flacEligibleCount > 0) ...[
+                    Expanded(
+                      child: _LocalAlbumSelectionActionButton(
+                        icon: Icons.download_for_offline_outlined,
+                        label:
+                            '${context.l10n.queueFlacAction} ($flacEligibleCount)',
+                        onPressed: () => _queueSelectedAsFlac(tracks),
+                        colorScheme: colorScheme,
+                      ),
                     ),
-                  ),
-                  const SizedBox(width: 8),
+                    const SizedBox(width: 8),
+                  ],
                   Expanded(
                     child: _LocalAlbumSelectionActionButton(
                       icon: Icons.auto_fix_high_outlined,

lib/screens/playlist_screen.dart

@@ -350,7 +350,6 @@ class _PlaylistScreenState extends ConsumerState<PlaylistScreen> {
   }
 
   Widget _buildInfoCard(BuildContext context, ColorScheme colorScheme) {
-    // Info is now displayed in the full-screen cover overlay
     return const SliverToBoxAdapter(child: SizedBox.shrink());
   }
 
@@ -608,45 +607,82 @@ class _PlaylistScreenState extends ConsumerState<PlaylistScreen> {
 
   void _downloadTracks(BuildContext context, List<Track> tracks) {
     if (tracks.isEmpty) return;
+
+    // Skip already-downloaded tracks
+    final historyState = ref.read(downloadHistoryProvider);
     final settings = ref.read(settingsProvider);
+    final localLibState = (settings.localLibraryEnabled && settings.localLibraryShowDuplicates)
+        ? ref.read(localLibraryProvider)
+        : null;
+    final tracksToQueue = <Track>[];
+    int skippedCount = 0;
+
+    for (final track in tracks) {
+      final isInHistory = historyState.isDownloaded(track.id) ||
+          (track.isrc != null && historyState.getByIsrc(track.isrc!) != null) ||
+          historyState.findByTrackAndArtist(track.name, track.artistName) != null;
+      final isInLocal = localLibState?.existsInLibrary(
+            isrc: track.isrc,
+            trackName: track.name,
+            artistName: track.artistName,
+          ) ??
+          false;
+
+      if (isInHistory || isInLocal) {
+        skippedCount++;
+      } else {
+        tracksToQueue.add(track);
+      }
+    }
+
+    if (tracksToQueue.isEmpty) {
+      ScaffoldMessenger.of(context).showSnackBar(
+        SnackBar(
+          content: Text(
+            context.l10n.discographySkippedDownloaded(0, skippedCount),
+          ),
+        ),
+      );
+      return;
+    }
+
     if (settings.askQualityBeforeDownload) {
       DownloadServicePicker.show(
         context,
-        trackName: '${tracks.length} tracks',
+        trackName: '${tracksToQueue.length} tracks',
         artistName: _playlistName,
         onSelect: (quality, service) {
           ref
               .read(downloadQueueProvider.notifier)
               .addMultipleToQueue(
-                tracks,
+                tracksToQueue,
                 service,
                 qualityOverride: quality,
                 playlistName: _playlistName,
               );
-          ScaffoldMessenger.of(context).showSnackBar(
-            SnackBar(
-              content: Text(
-                context.l10n.snackbarAddedTracksToQueue(tracks.length),
-              ),
-            ),
-          );
+          _showQueuedSnackbar(context, tracksToQueue.length, skippedCount);
         },
       );
     } else {
       ref
           .read(downloadQueueProvider.notifier)
           .addMultipleToQueue(
-            tracks,
+            tracksToQueue,
             settings.defaultService,
             playlistName: _playlistName,
           );
-      ScaffoldMessenger.of(context).showSnackBar(
-        SnackBar(
-          content: Text(context.l10n.snackbarAddedTracksToQueue(tracks.length)),
-        ),
-      );
+      _showQueuedSnackbar(context, tracksToQueue.length, skippedCount);
     }
   }
+
+  void _showQueuedSnackbar(BuildContext context, int added, int skipped) {
+    final message = skipped > 0
+        ? context.l10n.discographySkippedDownloaded(added, skipped)
+        : context.l10n.snackbarAddedTracksToQueue(added);
+    ScaffoldMessenger.of(context).showSnackBar(
+      SnackBar(content: Text(message)),
+    );
+  }
 }
 
 /// Separate Consumer widget for each track - only rebuilds when this specific track's status changes

lib/screens/queue_tab.dart

@@ -4484,14 +4484,21 @@ class _QueueTabState extends ConsumerState<QueueTab> {
     return false;
   }
 
+  List<LocalLibraryItem> _selectedFlacEligibleLocalItems(
+    List<UnifiedLibraryItem> allItems,
+  ) {
+    final selectedItems = _selectedItemsFromAll(allItems);
+    return selectedItems
+        .map((item) => item.localItem)
+        .whereType<LocalLibraryItem>()
+        .where(LocalTrackRedownloadService.isFlacUpgradeEligible)
+        .toList(growable: false);
+  }
+
   Future<void> _queueSelectedLocalAsFlac(
     List<UnifiedLibraryItem> allItems,
   ) async {
-    final selectedItems = _selectedItemsFromAll(allItems);
-    final selectedLocalItems = selectedItems
-        .map((item) => item.localItem)
-        .whereType<LocalLibraryItem>()
-        .toList(growable: false);
+    final selectedLocalItems = _selectedFlacEligibleLocalItems(allItems);
 
     if (selectedLocalItems.isEmpty) {
       return;
@@ -4546,9 +4553,7 @@ class _QueueTabState extends ConsumerState<QueueTab> {
       ScaffoldMessenger.of(context).clearSnackBars();
       ScaffoldMessenger.of(context).showSnackBar(
         SnackBar(
-          content: Text(
-            context.l10n.queueFlacFindingProgress(i + 1, total),
-          ),
+          content: Text(context.l10n.queueFlacFindingProgress(i + 1, total)),
           duration: const Duration(seconds: 30),
         ),
       );
@@ -4797,8 +4802,9 @@ class _QueueTabState extends ConsumerState<QueueTab> {
     String selectedFormat = formats.first;
     bool isLosslessTarget =
         selectedFormat == 'ALAC' || selectedFormat == 'FLAC';
-    String selectedBitrate =
-        isLosslessTarget ? '320k' : (selectedFormat == 'Opus' ? '128k' : '320k');
+    String selectedBitrate = isLosslessTarget
+        ? '320k'
+        : (selectedFormat == 'Opus' ? '128k' : '320k');
     var didStartConversion = false;
 
     _hideSelectionOverlay();
@@ -4864,8 +4870,9 @@ class _QueueTabState extends ConsumerState<QueueTab> {
                                 isLosslessTarget =
                                     format == 'ALAC' || format == 'FLAC';
                                 if (!isLosslessTarget) {
-                                  selectedBitrate =
-                                      format == 'Opus' ? '128k' : '320k';
+                                  selectedBitrate = format == 'Opus'
+                                      ? '128k'
+                                      : '320k';
                                 }
                               });
                             }
@@ -4910,11 +4917,8 @@ class _QueueTabState extends ConsumerState<QueueTab> {
                           const SizedBox(width: 6),
                           Text(
                             context.l10n.trackConvertLosslessHint,
-                            style: Theme.of(
-                              context,
-                            ).textTheme.bodySmall?.copyWith(
-                              color: colorScheme.primary,
-                            ),
+                            style: Theme.of(context).textTheme.bodySmall
+                                ?.copyWith(color: colorScheme.primary),
                           ),
                         ],
                       ),
@@ -5054,7 +5058,8 @@ class _QueueTabState extends ConsumerState<QueueTab> {
     int successCount = 0;
     final total = selectedItems.length;
     final historyDb = HistoryDatabase.instance;
-    final newQuality = (targetFormat.toUpperCase() == 'ALAC' ||
+    final newQuality =
+        (targetFormat.toUpperCase() == 'ALAC' ||
             targetFormat.toUpperCase() == 'FLAC')
         ? '${targetFormat.toUpperCase()} Lossless'
         : '${targetFormat.toUpperCase()} ${bitrate.trim().toLowerCase()}';
@@ -5375,6 +5380,9 @@ class _QueueTabState extends ConsumerState<QueueTab> {
     final allSelected =
         selectedCount == unifiedItems.length && unifiedItems.isNotEmpty;
     final localOnlySelection = _isLocalOnlySelection(unifiedItems);
+    final flacEligibleCount = _selectedFlacEligibleLocalItems(
+      unifiedItems,
+    ).length;
 
     return Container(
       decoration: BoxDecoration(
@@ -5464,15 +5472,13 @@ class _QueueTabState extends ConsumerState<QueueTab> {
               // Action buttons row: Share/Re-enrich, Convert, Delete
               Row(
                 children: [
-                  if (localOnlySelection) ...[
+                  if (localOnlySelection && flacEligibleCount > 0) ...[
                     Expanded(
                       child: _SelectionActionButton(
                         icon: Icons.download_for_offline_outlined,
                         label:
-                            '${context.l10n.queueFlacAction} ($selectedCount)',
-                        onPressed: selectedCount > 0
-                            ? () => _queueSelectedLocalAsFlac(unifiedItems)
-                            : null,
+                            '${context.l10n.queueFlacAction} ($flacEligibleCount)',
+                        onPressed: () => _queueSelectedLocalAsFlac(unifiedItems),
                         colorScheme: colorScheme,
                       ),
                     ),

lib/screens/settings/donate_page.dart

@@ -164,7 +164,7 @@ class _RecentDonorsCard extends StatelessWidget {
   @override
   Widget build(BuildContext context) {
     final isDark = Theme.of(context).brightness == Brightness.dark;
-    const donorNames = <String>['a fan'];
+    const donorNames = <String>['micahRichie', 'a fan', 'mc nuggets jimmy', 'CJBGR'];
 
     // Match SettingsGroup color logic
     final cardColor = isDark
@@ -479,8 +479,8 @@ int _cr(String v) {
   return r;
 }
 
-// Highlighted supporters (hashes of names): none for now.
-const _cv = <int>{};
+// Highlighted supporters (hashes of names).
+const _cv = <int>{1211573191};
 
 class _SupporterChip extends StatelessWidget {
   final String name;

lib/screens/settings/download_settings_page.dart

@@ -1310,8 +1310,27 @@ class _DownloadSettingsPageState extends ConsumerState<DownloadSettingsPage> {
               subtitle: Text(context.l10n.setupChooseFromFilesSubtitle),
               onTap: () async {
                 Navigator.pop(ctx);
+                if (Platform.isIOS) {
+                  await Future<void>.delayed(const Duration(milliseconds: 250));
+                }
+
                 // Note: iOS requires folder to have at least one file to be selectable
-                final result = await FilePicker.platform.getDirectoryPath();
+                String? result;
+                try {
+                  result = await FilePicker.platform.getDirectoryPath();
+                } catch (e) {
+                  if (ctx.mounted) {
+                    ScaffoldMessenger.of(ctx).showSnackBar(
+                      SnackBar(
+                        content: Text('Failed to open folder picker: $e'),
+                        backgroundColor: Theme.of(ctx).colorScheme.error,
+                        duration: const Duration(seconds: 4),
+                      ),
+                    );
+                  }
+                  return;
+                }
+
                 if (result != null) {
                   // iOS: Validate the selected path is writable (not iCloud or container root)
                   if (Platform.isIOS) {

lib/screens/settings/library_settings_page.dart

@@ -241,6 +241,99 @@ class _LibrarySettingsPageState extends ConsumerState<LibrarySettingsPage> {
     }
   }
 
+  String _getAutoScanLabel(BuildContext context, String mode) {
+    switch (mode) {
+      case 'on_open':
+        return context.l10n.libraryAutoScanOnOpen;
+      case 'daily':
+        return context.l10n.libraryAutoScanDaily;
+      case 'weekly':
+        return context.l10n.libraryAutoScanWeekly;
+      default:
+        return context.l10n.libraryAutoScanOff;
+    }
+  }
+
+  void _showAutoScanPicker(BuildContext context, String current) {
+    final colorScheme = Theme.of(context).colorScheme;
+    showModalBottomSheet(
+      context: context,
+      useRootNavigator: true,
+      backgroundColor: colorScheme.surfaceContainerHigh,
+      shape: const RoundedRectangleBorder(
+        borderRadius: BorderRadius.vertical(top: Radius.circular(28)),
+      ),
+      builder: (context) => SafeArea(
+        child: Column(
+          mainAxisSize: MainAxisSize.min,
+          crossAxisAlignment: CrossAxisAlignment.start,
+          children: [
+            Padding(
+              padding: const EdgeInsets.fromLTRB(24, 24, 24, 8),
+              child: Text(
+                context.l10n.libraryAutoScan,
+                style: Theme.of(context)
+                    .textTheme
+                    .titleLarge
+                    ?.copyWith(fontWeight: FontWeight.bold),
+              ),
+            ),
+            Padding(
+              padding: const EdgeInsets.fromLTRB(24, 0, 24, 16),
+              child: Text(
+                context.l10n.libraryAutoScanSubtitle,
+                style: Theme.of(context).textTheme.bodyMedium?.copyWith(
+                  color: colorScheme.onSurfaceVariant,
+                ),
+              ),
+            ),
+            _AutoScanOption(
+              icon: Icons.block,
+              title: context.l10n.libraryAutoScanOff,
+              selected: current == 'off',
+              colorScheme: colorScheme,
+              onTap: () {
+                ref.read(settingsProvider.notifier).setLocalLibraryAutoScan('off');
+                Navigator.pop(context);
+              },
+            ),
+            _AutoScanOption(
+              icon: Icons.open_in_new,
+              title: context.l10n.libraryAutoScanOnOpen,
+              selected: current == 'on_open',
+              colorScheme: colorScheme,
+              onTap: () {
+                ref.read(settingsProvider.notifier).setLocalLibraryAutoScan('on_open');
+                Navigator.pop(context);
+              },
+            ),
+            _AutoScanOption(
+              icon: Icons.today,
+              title: context.l10n.libraryAutoScanDaily,
+              selected: current == 'daily',
+              colorScheme: colorScheme,
+              onTap: () {
+                ref.read(settingsProvider.notifier).setLocalLibraryAutoScan('daily');
+                Navigator.pop(context);
+              },
+            ),
+            _AutoScanOption(
+              icon: Icons.date_range,
+              title: context.l10n.libraryAutoScanWeekly,
+              selected: current == 'weekly',
+              colorScheme: colorScheme,
+              onTap: () {
+                ref.read(settingsProvider.notifier).setLocalLibraryAutoScan('weekly');
+                Navigator.pop(context);
+              },
+            ),
+            const SizedBox(height: 16),
+          ],
+        ),
+      ),
+    );
+  }
+
   @override
   Widget build(BuildContext context) {
     final settings = ref.watch(settingsProvider);
@@ -344,7 +437,18 @@ class _LibrarySettingsPageState extends ConsumerState<LibrarySettingsPage> {
                   onChanged: (value) => ref
                       .read(settingsProvider.notifier)
                       .setLocalLibraryShowDuplicates(value),
-                  showDivider: false,
+                ),
+                Opacity(
+                  opacity: settings.localLibraryEnabled ? 1.0 : 0.5,
+                  child: SettingsItem(
+                    icon: Icons.autorenew_rounded,
+                    title: context.l10n.libraryAutoScan,
+                    subtitle: _getAutoScanLabel(context, settings.localLibraryAutoScan),
+                    onTap: settings.localLibraryEnabled
+                        ? () => _showAutoScanPicker(context, settings.localLibraryAutoScan)
+                        : null,
+                    showDivider: false,
+                  ),
                 ),
               ],
             ),
@@ -825,3 +929,31 @@ class _ScanProgressTile extends StatelessWidget {
     );
   }
 }
+
+class _AutoScanOption extends StatelessWidget {
+  final IconData icon;
+  final String title;
+  final bool selected;
+  final ColorScheme colorScheme;
+  final VoidCallback onTap;
+
+  const _AutoScanOption({
+    required this.icon,
+    required this.title,
+    required this.selected,
+    required this.colorScheme,
+    required this.onTap,
+  });
+
+  @override
+  Widget build(BuildContext context) {
+    return ListTile(
+      leading: Icon(icon),
+      title: Text(title),
+      trailing: selected
+          ? Icon(Icons.check, color: colorScheme.primary)
+          : null,
+      onTap: onTap,
+    );
+  }
+}

lib/screens/setup_screen.dart

@@ -321,7 +321,26 @@ class _SetupScreenState extends ConsumerState<SetupScreen> {
               title: Text(context.l10n.setupChooseFromFiles),
               onTap: () async {
                 Navigator.pop(ctx);
-                final result = await FilePicker.platform.getDirectoryPath();
+                if (Platform.isIOS) {
+                  await Future<void>.delayed(const Duration(milliseconds: 250));
+                }
+
+                String? result;
+                try {
+                  result = await FilePicker.platform.getDirectoryPath();
+                } catch (e) {
+                  if (mounted) {
+                    ScaffoldMessenger.of(context).showSnackBar(
+                      SnackBar(
+                        content: Text('Failed to open folder picker: $e'),
+                        backgroundColor: Theme.of(context).colorScheme.error,
+                        duration: const Duration(seconds: 4),
+                      ),
+                    );
+                  }
+                  return;
+                }
+
                 if (result != null) {
                   // iOS: Validate the selected path is writable
                   if (Platform.isIOS) {

lib/screens/store_tab.dart

@@ -269,22 +269,19 @@ class _StoreTabState extends ConsumerState<StoreTab> {
                 ),
 
                 SliverToBoxAdapter(
-                  child: Padding(
-                    padding: const EdgeInsets.symmetric(horizontal: 16),
-                    child: SettingsGroup(
-                      children: filteredExtensions.asMap().entries.map((entry) {
-                        final index = entry.key;
-                        final ext = entry.value;
-                        return _ExtensionItem(
-                          extension: ext,
-                          showDivider: index < filteredExtensions.length - 1,
-                          isDownloading: downloadingId == ext.id,
-                          onInstall: () => _installExtension(ext),
-                          onUpdate: () => _updateExtension(ext),
-                          onTap: () => _showExtensionDetails(ext),
-                        );
-                      }).toList(),
-                    ),
+                  child: SettingsGroup(
+                    children: filteredExtensions.asMap().entries.map((entry) {
+                      final index = entry.key;
+                      final ext = entry.value;
+                      return _ExtensionItem(
+                        extension: ext,
+                        showDivider: index < filteredExtensions.length - 1,
+                        isDownloading: downloadingId == ext.id,
+                        onInstall: () => _installExtension(ext),
+                        onUpdate: () => _updateExtension(ext),
+                        onTap: () => _showExtensionDetails(ext),
+                      );
+                    }).toList(),
                   ),
                 ),
 

lib/services/local_track_redownload_service.dart

@@ -23,6 +23,15 @@ class LocalTrackRedownloadService {
   static const int _minimumConfidenceScore = 85;
   static const int _ambiguousScoreGap = 8;
 
+  static bool isFlacUpgradeEligible(LocalLibraryItem item) {
+    final format = item.format?.trim().toLowerCase();
+    if (format == 'flac') {
+      return false;
+    }
+
+    return !item.filePath.toLowerCase().endsWith('.flac');
+  }
+
   static Future<LocalTrackRedownloadResolution> resolveBestMatch(
     LocalLibraryItem item, {
     required bool includeExtensions,

lib/utils/local_library_scan_prefs.dart

@@ -0,0 +1,29 @@
+import 'package:shared_preferences/shared_preferences.dart';
+
+const localLibraryLastScannedAtKey = 'local_library_last_scanned_at';
+
+DateTime? readLocalLibraryLastScannedAt(SharedPreferences prefs) {
+  final lastScannedAtStr = prefs.getString(localLibraryLastScannedAtKey);
+  if (lastScannedAtStr != null && lastScannedAtStr.isNotEmpty) {
+    return DateTime.tryParse(lastScannedAtStr);
+  }
+
+  // Backward compatibility for older builds that may have stored epoch millis.
+  final lastScannedAtMs = prefs.getInt(localLibraryLastScannedAtKey);
+  if (lastScannedAtMs != null) {
+    return DateTime.fromMillisecondsSinceEpoch(lastScannedAtMs);
+  }
+
+  return null;
+}
+
+Future<void> writeLocalLibraryLastScannedAt(
+  SharedPreferences prefs,
+  DateTime value,
+) {
+  return prefs.setString(localLibraryLastScannedAtKey, value.toIso8601String());
+}
+
+Future<void> clearLocalLibraryLastScannedAt(SharedPreferences prefs) {
+  return prefs.remove(localLibraryLastScannedAtKey);
+}

lib/utils/path_match_keys.dart

@@ -8,6 +8,33 @@ const _androidStoragePathAliases = <String>[
   '/mnt/sdcard',
 ];
 
+/// Audio file extensions that the app commonly produces or converts between.
+/// Used to generate extension-stripped match keys so that a file converted from
+/// one format to another (e.g. .flac → .opus) is still recognised as the same
+/// track.
+const _audioExtensions = <String>[
+  '.flac',
+  '.m4a',
+  '.mp3',
+  '.opus',
+  '.ogg',
+  '.wav',
+  '.aac',
+];
+
+/// Strips a trailing audio extension from [path] if present.
+/// Returns the path without extension, or `null` if no known audio extension
+/// was found.
+String? _stripAudioExtension(String path) {
+  final lower = path.toLowerCase();
+  for (final ext in _audioExtensions) {
+    if (lower.endsWith(ext)) {
+      return path.substring(0, path.length - ext.length);
+    }
+  }
+  return null;
+}
+
 Set<String> buildPathMatchKeys(String? filePath) {
   final raw = filePath?.trim() ?? '';
   if (raw.isEmpty) return const {};
@@ -79,6 +106,18 @@ Set<String> buildPathMatchKeys(String? filePath) {
   }
 
   addNormalized(cleaned);
+
+  // Add extension-stripped variants so that a file converted from one audio
+  // format to another (e.g. Song.flac → Song.opus) still matches.
+  final extensionStrippedKeys = <String>{};
+  for (final key in keys) {
+    final stripped = _stripAudioExtension(key);
+    if (stripped != null && stripped.isNotEmpty) {
+      extensionStrippedKeys.add(stripped);
+    }
+  }
+  keys.addAll(extensionStrippedKeys);
+
   return keys;
 }
 

pubspec.yaml

@@ -1,7 +1,7 @@
 name: spotiflac_android
 description: Download Spotify tracks in FLAC from Tidal, Qobuz & Deezer
 publish_to: "none"
-version: 3.8.5+111
+version: 3.8.7+113
 
 environment:
   sdk: ^3.10.0