diff --git a/ARCHITECTURE.md b/ARCHITECTURE.md
index 395a199..6d8d1ce 100644
--- a/ARCHITECTURE.md
+++ b/ARCHITECTURE.md
@@ -1,4 +1,4 @@
-# Resonance — Architecture (Phase 3: library ingestion pipeline)
+# Crate — Architecture (Phase 3: library ingestion pipeline)
 
 Local-first, offline-first music player. No INTERNET permission by design
 (verified in the merged manifest).
diff --git a/app/build.gradle.kts b/app/build.gradle.kts
index 3887841..d74d0de 100644
--- a/app/build.gradle.kts
+++ b/app/build.gradle.kts
@@ -47,6 +47,7 @@ dependencies {
     implementation(libs.androidx.lifecycle.runtime.ktx)
     implementation(libs.androidx.lifecycle.viewmodel)
     implementation(libs.androidx.lifecycle.viewmodel.compose)
+    implementation(libs.androidx.lifecycle.runtime.compose)
     implementation(libs.androidx.activity.compose)
     implementation(platform(libs.androidx.compose.bom))
     implementation(libs.androidx.ui)
diff --git a/app/src/main/AndroidManifest.xml b/app/src/main/AndroidManifest.xml
index 78b2f49..d5af32b 100644
--- a/app/src/main/AndroidManifest.xml
+++ b/app/src/main/AndroidManifest.xml
@@ -1,6 +1,6 @@
 <?xml version="1.0" encoding="utf-8"?>
 <!--
-  Resonance manifest — Phase 1 foundation.
+  Crate manifest — Phase 1 foundation.
   Privacy: NO INTERNET permission by design. Local-first, offline-first.
   Playback service + notification channels land in Phase 2; permissions below
   are declared now so the manifest does not need restructuring later.
@@ -22,7 +22,7 @@
     <application
         android:name=".app.ResonanceApp"
         android:label="@string/app_name"
-        android:theme="@style/Theme.Resonance"
+        android:theme="@style/Theme.Crate"
         android:allowBackup="true"
         android:supportsRtl="true"
         android:icon="@mipmap/ic_launcher"
diff --git a/app/src/main/java/com/resonance/player/MainActivity.kt b/app/src/main/java/com/resonance/player/MainActivity.kt
index a8d5191..c64c615 100644
--- a/app/src/main/java/com/resonance/player/MainActivity.kt
+++ b/app/src/main/java/com/resonance/player/MainActivity.kt
@@ -9,9 +9,10 @@ import androidx.core.app.ActivityCompat
 import androidx.lifecycle.lifecycleScope
 import com.resonance.player.core.permissions.MusicPermissions
 import kotlinx.coroutines.launch
-import androidx.compose.runtime.collectAsState
 import androidx.compose.runtime.getValue
+import androidx.lifecycle.compose.collectAsStateWithLifecycle
 import com.resonance.player.app.ResonanceApp
+import com.resonance.player.core.ui.theme.DEFAULT_ACCENT_HUE
 import com.resonance.player.core.ui.theme.ResonanceTheme
 import com.resonance.player.domain.settings.ThemeMode
 import com.resonance.player.navigation.ResonanceAppShell
@@ -40,10 +41,13 @@ class MainActivity : ComponentActivity() {
         enableEdgeToEdge()
         val container = (application as ResonanceApp).container
         setContent {
-            val themeMode by container.settingsRepository.themeMode.collectAsState(
-                initial = ThemeMode.SYSTEM
+            val themeMode by container.settingsRepository.themeMode.collectAsStateWithLifecycle(
+                initialValue = ThemeMode.SYSTEM
             )
-            ResonanceTheme(themeMode = themeMode) {
+            val accentHue by container.settingsRepository.accentHue.collectAsStateWithLifecycle(
+                initialValue = DEFAULT_ACCENT_HUE
+            )
+            ResonanceTheme(themeMode = themeMode, accentHue = accentHue) {
                 ResonanceAppShell(container)
             }
         }
diff --git a/app/src/main/java/com/resonance/player/app/AppContainer.kt b/app/src/main/java/com/resonance/player/app/AppContainer.kt
index e0def49..d274d93 100644
--- a/app/src/main/java/com/resonance/player/app/AppContainer.kt
+++ b/app/src/main/java/com/resonance/player/app/AppContainer.kt
@@ -19,6 +19,7 @@ import com.resonance.player.data.media.MediaStoreAudioDataSource
 import com.resonance.player.data.media.MediaStoreLibraryScanner
 import com.resonance.player.data.media.RetrieverArtworkExtractor
 import com.resonance.player.domain.library.GetAlbumSongsUseCase
+import com.resonance.player.domain.library.GetFolderSongsUseCase
 import com.resonance.player.domain.library.GetArtistSongsUseCase
 import com.resonance.player.domain.library.GetGenreSongsUseCase
 import com.resonance.player.domain.library.GetLibraryStatsUseCase
@@ -194,6 +195,7 @@ class AppContainer(context: Context) {
     val observeGenres = ObserveGenresUseCase(musicRepository)
     val observeFolders = ObserveFoldersUseCase(musicRepository)
     val getAlbumSongs = GetAlbumSongsUseCase(musicRepository)
+    val getFolderSongs = GetFolderSongsUseCase(musicRepository)
     val observeScanState = ObserveScanStateUseCase(musicRepository)
     val rescanLibrary = RescanLibraryUseCase(musicRepository)
     val getLibraryStats = GetLibraryStatsUseCase(musicRepository)
diff --git a/app/src/main/java/com/resonance/player/core/database/dao/SongDao.kt b/app/src/main/java/com/resonance/player/core/database/dao/SongDao.kt
index 0d62e0b..4be18a3 100644
--- a/app/src/main/java/com/resonance/player/core/database/dao/SongDao.kt
+++ b/app/src/main/java/com/resonance/player/core/database/dao/SongDao.kt
@@ -196,6 +196,13 @@ interface SongDao {
     )
     suspend fun getSongsOfAlbum(albumName: String, albumArtist: String?): List<SongEntity>
 
+    @Query(
+        "SELECT * FROM songs WHERE " +
+            "((relativePath IS NULL AND :relativePath IS NULL) OR relativePath = :relativePath) " +
+            "ORDER BY title COLLATE NOCASE ASC"
+    )
+    suspend fun getSongsOfFolder(relativePath: String?): List<SongEntity>
+
     @Query("SELECT DISTINCT artworkKey FROM songs WHERE artworkKey IS NOT NULL")
     suspend fun getReferencedArtworkKeys(): List<String>
 
diff --git a/app/src/main/java/com/resonance/player/core/ui/components/ArtworkImage.kt b/app/src/main/java/com/resonance/player/core/ui/components/ArtworkImage.kt
index dde3da9..9a0607c 100644
--- a/app/src/main/java/com/resonance/player/core/ui/components/ArtworkImage.kt
+++ b/app/src/main/java/com/resonance/player/core/ui/components/ArtworkImage.kt
@@ -14,23 +14,19 @@ import coil3.compose.AsyncImage
 /**
  * Cached-artwork image with a deterministic local fallback. Coil loads the
  * file:// URI lazily with downsampling + memory cache (never full-res, never
- * a Room BLOB); missing/corrupt art shows the Stitch etched fallback — never
- * an error state. No network is involved — only app-cache files.
+ * a Room BLOB); missing/corrupt art shows a plain note glyph — never an
+ * error state. No network is involved — only app-cache files.
  */
 @Composable
 fun ArtworkImage(
     artworkUri: String?,
     contentDescription: String?,
     modifier: Modifier = Modifier,
-    fallbackSize: Dp = 24.dp,
-    fallbackStyle: ArtworkFallbackStyle = ArtworkFallbackStyle.Etched
+    fallbackSize: Dp = 24.dp
 ) {
     var failed by remember(artworkUri) { mutableStateOf(false) }
     if (artworkUri.isNullOrBlank() || failed) {
-        when (fallbackStyle) {
-            ArtworkFallbackStyle.Etched -> WaveformFallback(modifier, fallbackSize)
-            ArtworkFallbackStyle.Note -> NoteFallback(modifier, fallbackSize)
-        }
+        NoteFallback(modifier, fallbackSize)
     } else {
         AsyncImage(
             model = artworkUri,
@@ -41,13 +37,3 @@ fun ArtworkImage(
         )
     }
 }
-
-/**
- * Legacy fallback entry (MusicNote box). Kept for source compatibility;
- * new code should use [ArtworkImage], which defaults to the Stitch etched
- * fallback.
- */
-@Composable
-fun ArtworkFallback(modifier: Modifier = Modifier, iconSize: Dp = 24.dp) {
-    NoteFallback(modifier, iconSize)
-}
diff --git a/app/src/main/java/com/resonance/player/core/ui/components/PermissionGate.kt b/app/src/main/java/com/resonance/player/core/ui/components/PermissionGate.kt
index cb259b0..a645c6d 100644
--- a/app/src/main/java/com/resonance/player/core/ui/components/PermissionGate.kt
+++ b/app/src/main/java/com/resonance/player/core/ui/components/PermissionGate.kt
@@ -18,9 +18,9 @@ import androidx.compose.material3.Text
 import androidx.compose.material3.TextButton
 import androidx.compose.runtime.Composable
 import androidx.compose.runtime.LaunchedEffect
-import androidx.compose.runtime.collectAsState
 import androidx.compose.runtime.getValue
 import androidx.compose.runtime.rememberCoroutineScope
+import androidx.lifecycle.compose.collectAsStateWithLifecycle
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.platform.LocalContext
 import androidx.compose.ui.res.stringResource
@@ -60,7 +60,7 @@ fun AudioPermissionGate(
     onPermissionGranted: () -> Unit,
     content: @Composable () -> Unit
 ) {
-    val status by manager.status.collectAsState()
+    val status by manager.status.collectAsStateWithLifecycle()
     val scope = rememberCoroutineScope()
     val context = LocalContext.current
     val activity = context as? Activity
diff --git a/app/src/main/java/com/resonance/player/core/ui/components/ReorderableList.kt b/app/src/main/java/com/resonance/player/core/ui/components/ReorderableList.kt
index 80d9bc0..75756b7 100644
--- a/app/src/main/java/com/resonance/player/core/ui/components/ReorderableList.kt
+++ b/app/src/main/java/com/resonance/player/core/ui/components/ReorderableList.kt
@@ -2,6 +2,7 @@
 
 import androidx.compose.foundation.gestures.detectDragGesturesAfterLongPress
 import androidx.compose.foundation.gestures.scrollBy
+import androidx.compose.foundation.layout.Box
 import androidx.compose.foundation.lazy.LazyColumn
 import androidx.compose.foundation.lazy.LazyListState
 import androidx.compose.foundation.lazy.itemsIndexed
@@ -79,13 +80,11 @@ class ReorderScope internal constructor(
             )
         }
 
-    /** Lifts the dragged row above siblings while it follows the finger. */
+    /** Follows the finger while dragging; z-raising happens on the item wrapper. */
     fun Modifier.dragged(index: Int): Modifier =
-        this
-            .zIndex(if (draggingIndex == index) 1f else 0f)
-            .graphicsLayer {
-                translationY = if (draggingIndex == index) dragOffsetY else 0f
-            }
+        this.graphicsLayer {
+            translationY = if (draggingIndex == index) dragOffsetY else 0f
+        }
 
     private fun rowTop(index: Int): Float =
         (listState.layoutInfo.visibleItemsInfo.firstOrNull { it.index == index }?.offset
@@ -108,7 +107,16 @@ fun <T> ReorderableLazyColumn(
     val reorder = remember(listState, scope) { ReorderScope(listState, scope) }
     LazyColumn(state = listState, modifier = modifier) {
         itemsIndexed(items, key = { _, item -> key(item) }) { index, item ->
-            reorder.itemContent(item, index)
+            // animateItem() springs siblings into place after a drop commits a
+            // reorder (or after an insert/remove); zIndex here (not on the row)
+            // raises the whole item above siblings while it's being dragged.
+            Box(
+                modifier = Modifier
+                    .animateItem()
+                    .zIndex(if (reorder.draggingIndex == index) 1f else 0f)
+            ) {
+                reorder.itemContent(item, index)
+            }
         }
     }
 }
diff --git a/app/src/main/java/com/resonance/player/core/ui/components/ResonanceButtons.kt b/app/src/main/java/com/resonance/player/core/ui/components/ResonanceButtons.kt
index 97c93f1..5ec2d4b 100644
--- a/app/src/main/java/com/resonance/player/core/ui/components/ResonanceButtons.kt
+++ b/app/src/main/java/com/resonance/player/core/ui/components/ResonanceButtons.kt
@@ -1,5 +1,6 @@
 package com.resonance.player.core.ui.components
 
+import androidx.compose.animation.Crossfade
 import androidx.compose.foundation.BorderStroke
 import androidx.compose.foundation.background
 import androidx.compose.foundation.clickable
@@ -62,11 +63,13 @@ fun ResonancePlaybackButton(
             )
     ) {
         Box(contentAlignment = Alignment.Center) {
-            Icon(
-                if (playing) pauseIcon else playIcon,
-                contentDescription = if (playing) pauseDescription else playDescription,
-                modifier = Modifier.size(size * 0.45f)
-            )
+            Crossfade(targetState = playing, label = "playback-icon") { isPlaying ->
+                Icon(
+                    if (isPlaying) pauseIcon else playIcon,
+                    contentDescription = if (isPlaying) pauseDescription else playDescription,
+                    modifier = Modifier.size(size * 0.45f)
+                )
+            }
         }
     }
 }
diff --git a/app/src/main/java/com/resonance/player/core/ui/components/ResonanceChrome.kt b/app/src/main/java/com/resonance/player/core/ui/components/ResonanceChrome.kt
index 4d4b04d..500a9e8 100644
--- a/app/src/main/java/com/resonance/player/core/ui/components/ResonanceChrome.kt
+++ b/app/src/main/java/com/resonance/player/core/ui/components/ResonanceChrome.kt
@@ -1,8 +1,11 @@
 package com.resonance.player.core.ui.components
 
+import androidx.compose.animation.Crossfade
+import androidx.compose.animation.animateColorAsState
 import androidx.compose.foundation.background
 import androidx.compose.foundation.clickable
 import androidx.compose.foundation.layout.Arrangement
+import androidx.compose.foundation.layout.Box
 import androidx.compose.foundation.layout.Column
 import androidx.compose.foundation.layout.Row
 import androidx.compose.foundation.layout.Spacer
@@ -21,6 +24,7 @@ import androidx.compose.material3.OutlinedTextField
 import androidx.compose.material3.OutlinedTextFieldDefaults
 import androidx.compose.material3.Text
 import androidx.compose.runtime.Composable
+import androidx.compose.runtime.getValue
 import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.graphics.vector.ImageVector
@@ -198,25 +202,31 @@ fun ResonanceNavDock(
                         .size(spacing.touchMin)
                         .clickable(onClick = { onSelect(destination.route) })
                 ) {
+                    val iconTint by animateColorAsState(
+                        if (selected) colors.accent else colors.textSecondary,
+                        label = "nav-icon-tint"
+                    )
                     Icon(
                         destination.icon,
                         contentDescription = destination.label,
-                        tint = if (selected) colors.accent else colors.textSecondary,
+                        tint = iconTint,
                         modifier = Modifier.size(ResonanceTheme.dimensions.navIcon)
                     )
                     Spacer(Modifier.height(2.dp))
-                    if (selected) {
-                        androidx.compose.foundation.layout.Box(
-                            modifier = Modifier
-                                .size(4.dp)
-                                .background(colors.accent, ResonanceTheme.radii.full)
-                        )
-                    } else {
-                        Text(
-                            destination.label,
-                            style = typography.labelSm,
-                            color = colors.textSecondary
-                        )
+                    Crossfade(targetState = selected, label = "nav-indicator") { isSelected ->
+                        if (isSelected) {
+                            Box(
+                                modifier = Modifier
+                                    .size(4.dp)
+                                    .background(colors.accent, ResonanceTheme.radii.full)
+                            )
+                        } else {
+                            Text(
+                                destination.label,
+                                style = typography.labelSm,
+                                color = colors.textSecondary
+                            )
+                        }
                     }
                 }
             }
diff --git a/app/src/main/java/com/resonance/player/core/ui/components/ResonancePlayer.kt b/app/src/main/java/com/resonance/player/core/ui/components/ResonancePlayer.kt
index e9b2efb..95c788e 100644
--- a/app/src/main/java/com/resonance/player/core/ui/components/ResonancePlayer.kt
+++ b/app/src/main/java/com/resonance/player/core/ui/components/ResonancePlayer.kt
@@ -1,5 +1,6 @@
 package com.resonance.player.core.ui.components
 
+import androidx.compose.animation.Crossfade
 import androidx.compose.foundation.background
 import androidx.compose.foundation.clickable
 import androidx.compose.foundation.layout.Box
@@ -103,11 +104,13 @@ fun ResonanceMiniPlayer(
                 onClick = onToggle,
                 modifier = Modifier.size(spacing.touchMin)
             ) {
-                Icon(
-                    if (isPlaying) Icons.Filled.Pause else Icons.Filled.PlayArrow,
-                    contentDescription = if (isPlaying) pauseDescription else playDescription,
-                    tint = colors.textPrimary
-                )
+                Crossfade(targetState = isPlaying, label = "mini-playback-icon") { playing ->
+                    Icon(
+                        if (playing) Icons.Filled.Pause else Icons.Filled.PlayArrow,
+                        contentDescription = if (playing) pauseDescription else playDescription,
+                        tint = colors.textPrimary
+                    )
+                }
             }
             if (onNext != null) {
                 IconButton(
diff --git a/app/src/main/java/com/resonance/player/core/ui/components/ResonanceVectors.kt b/app/src/main/java/com/resonance/player/core/ui/components/ResonanceVectors.kt
index 3fe082a..fa44afd 100644
--- a/app/src/main/java/com/resonance/player/core/ui/components/ResonanceVectors.kt
+++ b/app/src/main/java/com/resonance/player/core/ui/components/ResonanceVectors.kt
@@ -6,7 +6,6 @@ import androidx.compose.animation.core.animateFloat
 import androidx.compose.animation.core.infiniteRepeatable
 import androidx.compose.animation.core.rememberInfiniteTransition
 import androidx.compose.animation.core.tween
-import androidx.compose.foundation.Canvas
 import androidx.compose.foundation.background
 import androidx.compose.foundation.layout.Arrangement
 import androidx.compose.foundation.layout.Box
@@ -21,59 +20,11 @@ import androidx.compose.runtime.getValue
 import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.draw.clip
-import androidx.compose.ui.geometry.Offset
-import androidx.compose.ui.graphics.PathEffect
-import androidx.compose.ui.graphics.drawscope.Stroke
 import androidx.compose.ui.unit.Dp
 import androidx.compose.ui.unit.dp
 import com.resonance.player.core.ui.theme.ResonanceTheme
 
-/** Missing-artwork fallback styles (DESIGN.md prescribes etched geometry). */
-enum class ArtworkFallbackStyle { Etched, Note }
-
-/**
- * Stitch artwork fallback: dark slate box with an etched vinyl-groove motif
- * (concentric dashed circles + register ticks). Decorative only — playback
- * and list state are always conveyed by text + controls as well.
- */
-@Composable
-fun WaveformFallback(
-    modifier: Modifier = Modifier,
-    iconSize: Dp = 24.dp
-) {
-    val colors = ResonanceTheme.colors
-    val groove = colors.outlineStrong
-    Box(
-        modifier = modifier
-            .clip(ResonanceTheme.radii.control)
-            .background(colors.surfaceContainer),
-        contentAlignment = Alignment.Center
-    ) {
-        Canvas(modifier = Modifier.size(iconSize * 2)) {
-            val cx = size.width / 2f
-            val cy = size.height / 2f
-            val maxR = size.minDimension / 2f * 0.94f
-            val thin = size.minDimension * 0.02f
-            drawCircle(
-                color = groove,
-                radius = maxR,
-                style = Stroke(
-                    width = thin,
-                    pathEffect = PathEffect.dashPathEffect(floatArrayOf(6f, 6f))
-                )
-            )
-            drawCircle(color = groove, radius = maxR * 0.64f, style = Stroke(thin * 0.8f))
-            drawCircle(color = groove, radius = maxR * 0.28f, style = Stroke(thin))
-            val tick = maxR * 0.12f
-            drawLine(groove, Offset(cx, cy - maxR), Offset(cx, cy - maxR + tick), thin)
-            drawLine(groove, Offset(cx, cy + maxR), Offset(cx, cy + maxR - tick), thin)
-            drawLine(groove, Offset(cx - maxR, cy), Offset(cx - maxR + tick, cy), thin)
-            drawLine(groove, Offset(cx + maxR, cy), Offset(cx + maxR - tick, cy), thin)
-        }
-    }
-}
-
-/** Compact note-glyph fallback for dense rows (matches Stitch list rows). */
+/** Compact note-glyph fallback for missing artwork (dense rows and grids alike). */
 @Composable
 fun NoteFallback(
     modifier: Modifier = Modifier,
diff --git a/app/src/main/java/com/resonance/player/core/ui/components/SongPickerSheet.kt b/app/src/main/java/com/resonance/player/core/ui/components/SongPickerSheet.kt
new file mode 100644
index 0000000..6c65679
--- /dev/null
+++ b/app/src/main/java/com/resonance/player/core/ui/components/SongPickerSheet.kt
@@ -0,0 +1,131 @@
+package com.resonance.player.core.ui.components
+
+import androidx.compose.foundation.clickable
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.Row
+import androidx.compose.foundation.layout.Spacer
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.height
+import androidx.compose.foundation.layout.heightIn
+import androidx.compose.foundation.layout.size
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.layout.width
+import androidx.compose.foundation.lazy.LazyColumn
+import androidx.compose.foundation.lazy.items
+import androidx.compose.material.icons.Icons
+import androidx.compose.material.icons.filled.CheckCircle
+import androidx.compose.material.icons.outlined.Circle
+import androidx.compose.material3.Icon
+import androidx.compose.material3.Text
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.remember
+import androidx.compose.runtime.setValue
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.res.stringResource
+import androidx.compose.ui.text.style.TextOverflow
+import androidx.compose.ui.unit.dp
+import com.resonance.player.R
+import com.resonance.player.core.model.Song
+import com.resonance.player.core.ui.theme.ResonanceTheme
+
+/**
+ * Shared multi-select song browser (add-songs-to-playlist flow). Filters the
+ * full library by title/artist locally; selection is local until confirmed.
+ */
+@Composable
+fun SongPickerSheet(
+    title: String,
+    songs: List<Song>,
+    onConfirm: (List<Long>) -> Unit,
+    onDismiss: () -> Unit,
+    modifier: Modifier = Modifier
+) {
+    val colors = ResonanceTheme.colors
+    val typography = ResonanceTheme.typography
+    val spacing = ResonanceTheme.spacing
+    var query by remember { mutableStateOf("") }
+    var selected by remember { mutableStateOf(setOf<Long>()) }
+    val filtered = remember(songs, query) {
+        if (query.isBlank()) {
+            songs
+        } else {
+            songs.filter {
+                it.title.contains(query, ignoreCase = true) ||
+                    it.artistName.contains(query, ignoreCase = true)
+            }
+        }
+    }
+    ResonanceBottomSheet(onDismiss = onDismiss, modifier = modifier) {
+        Text(
+            title,
+            style = typography.titleMd,
+            color = colors.textPrimary,
+            maxLines = 2,
+            overflow = TextOverflow.Ellipsis
+        )
+        Spacer(Modifier.height(spacing.sm))
+        ResonanceSearchField(
+            value = query,
+            onValueChange = { query = it },
+            label = stringResource(R.string.search_hint)
+        )
+        Spacer(Modifier.height(spacing.sm))
+        LazyColumn(modifier = Modifier.heightIn(max = 360.dp)) {
+            items(filtered, key = { it.id }) { song ->
+                val isSelected = song.id in selected
+                Row(
+                    verticalAlignment = Alignment.CenterVertically,
+                    modifier = Modifier
+                        .fillMaxWidth()
+                        .clickable {
+                            selected = if (isSelected) selected - song.id else selected + song.id
+                        }
+                        .padding(vertical = spacing.sm)
+                ) {
+                    ArtworkImage(
+                        artworkUri = song.artworkUri,
+                        contentDescription = song.albumName,
+                        modifier = Modifier.size(ResonanceTheme.dimensions.songArtwork)
+                    )
+                    Spacer(Modifier.width(spacing.md))
+                    Column(Modifier.weight(1f)) {
+                        Text(
+                            song.title,
+                            style = typography.bodyLg,
+                            color = colors.textPrimary,
+                            maxLines = 1,
+                            overflow = TextOverflow.Ellipsis
+                        )
+                        Text(
+                            song.artistName,
+                            style = typography.bodySm,
+                            color = colors.textSecondary,
+                            maxLines = 1,
+                            overflow = TextOverflow.Ellipsis
+                        )
+                    }
+                    Icon(
+                        if (isSelected) Icons.Filled.CheckCircle else Icons.Outlined.Circle,
+                        contentDescription = null,
+                        tint = if (isSelected) colors.accent else colors.textMuted
+                    )
+                }
+            }
+        }
+        Spacer(Modifier.height(spacing.sm))
+        val label = if (selected.isEmpty()) {
+            stringResource(R.string.action_add)
+        } else {
+            stringResource(R.string.action_add) + " (${selected.size})"
+        }
+        ResonancePrimaryButton(
+            label = label,
+            onClick = { onConfirm(selected.toList()) },
+            enabled = selected.isNotEmpty(),
+            modifier = Modifier.fillMaxWidth()
+        )
+    }
+}
diff --git a/app/src/main/java/com/resonance/player/core/ui/theme/Color.kt b/app/src/main/java/com/resonance/player/core/ui/theme/Color.kt
index 61e36f2..9436fa0 100644
--- a/app/src/main/java/com/resonance/player/core/ui/theme/Color.kt
+++ b/app/src/main/java/com/resonance/player/core/ui/theme/Color.kt
@@ -25,12 +25,11 @@ internal val StitchTextPrimary = Color(0xFFF2F3F5)
 internal val StitchTextSecondary = Color(0xFF9CA3AF)
 internal val StitchTextMuted = Color(0xFF606775)
 internal val StitchTextOnSurface = Color(0xFFE3E2E6)
-internal val StitchCopper = Color(0xFFFF7A30)
-internal val StitchCopperGlow = Color(0xFFFF8A3D)
-internal val StitchCopperDim = Color(0xFF4A2209)
+// Accent (was fixed copper #FF7A30) is now user-selectable — see
+// accentColors(hue) in ResonanceColors.kt. StitchOnCopper is the fixed dark
+// "text on accent" color; it stays constant because every accent hue is
+// generated at the same high saturation/value, so dark text always contrasts.
 internal val StitchOnCopper = Color(0xFF121316)
-internal val StitchCopperSoft = Color(0xFFFFB693)
-internal val StitchCopperDeep = Color(0xFF622400)
 internal val StitchCyan = Color(0xFF2EE5C8)
 internal val StitchCyanDim = Color(0xFF063B34)
 internal val StitchOnCyan = Color(0xFF00382F)
diff --git a/app/src/main/java/com/resonance/player/core/ui/theme/ResonanceColors.kt b/app/src/main/java/com/resonance/player/core/ui/theme/ResonanceColors.kt
index 163ae8d..800caec 100644
--- a/app/src/main/java/com/resonance/player/core/ui/theme/ResonanceColors.kt
+++ b/app/src/main/java/com/resonance/player/core/ui/theme/ResonanceColors.kt
@@ -39,13 +39,39 @@ data class ResonanceColors(
     val outlineStrong: Color
 )
 
-/** Authoritative Stitch dark scheme (dark-first per DESIGN.md). */
-fun stitchDarkColors(): ResonanceColors {
+/** Default accent hue (0-360), reproducing the original Stitch copper. */
+const val DEFAULT_ACCENT_HUE = 22f
+
+/** HSV->RGB via the platform converter — same saturation/value as the
+ *  original copper accent, only the hue varies, so contrast stays constant. */
+private fun accentTone(hue: Float, saturation: Float, value: Float): Color =
+    Color(android.graphics.Color.HSVToColor(floatArrayOf(hue, saturation, value)))
+
+/** The [accent] tone for a hue, for swatch previews in the picker UI. */
+fun accentPreviewColor(hue: Float): Color = accentTone(hue, 0.81f, 1f)
+
+/** Curated accent hues (name to degrees) for the palette picker. */
+val ACCENT_PRESETS = listOf(
+    "Copper" to DEFAULT_ACCENT_HUE,
+    "Green" to 142f,
+    "Blue" to 211f,
+    "Purple" to 262f,
+    "Pink" to 330f,
+    "Teal" to 174f
+)
+
+/** Authoritative Stitch dark scheme (dark-first per DESIGN.md). [accentHue]
+ *  drives the user-selectable primary accent; everything else is fixed. */
+fun stitchDarkColors(accentHue: Float = DEFAULT_ACCENT_HUE): ResonanceColors {
+    val accent = accentTone(accentHue, 0.81f, 1f)
+    val accentGlow = accentTone(accentHue, 0.75f, 1f)
+    val accentDim = accentTone(accentHue, 0.85f, 0.29f)
+    val onAccentContainer = accentTone(accentHue, 0.42f, 1f)
     val scheme = darkColorScheme(
-        primary = StitchCopper,
+        primary = accent,
         onPrimary = StitchOnCopper,
-        primaryContainer = StitchCopperDim,
-        onPrimaryContainer = StitchCopperSoft,
+        primaryContainer = accentDim,
+        onPrimaryContainer = onAccentContainer,
         secondary = StitchCyan,
         onSecondary = StitchOnCyan,
         secondaryContainer = StitchCyanDim,
@@ -63,7 +89,7 @@ fun stitchDarkColors(): ResonanceColors {
         surfaceContainer = StitchSurfaceContainer,
         surfaceContainerHigh = StitchSurfaceHigh,
         surfaceContainerHighest = StitchSurfaceHighest,
-        surfaceTint = StitchCopperSoft,
+        surfaceTint = onAccentContainer,
         outline = StitchOutlineStrong,
         outlineVariant = StitchOutlineSubtle,
         error = StitchError,
@@ -82,9 +108,9 @@ fun stitchDarkColors(): ResonanceColors {
         textPrimary = StitchTextPrimary,
         textSecondary = StitchTextSecondary,
         textMuted = StitchTextMuted,
-        accent = StitchCopper,
-        accentGlow = StitchCopperGlow,
-        accentDim = StitchCopperDim,
+        accent = accent,
+        accentGlow = accentGlow,
+        accentDim = accentDim,
         onAccent = StitchOnCopper,
         accentSecondary = StitchCyan,
         accentSecondaryDim = StitchCyanDim,
diff --git a/app/src/main/java/com/resonance/player/core/ui/theme/Theme.kt b/app/src/main/java/com/resonance/player/core/ui/theme/Theme.kt
index ee0b433..2d36995 100644
--- a/app/src/main/java/com/resonance/player/core/ui/theme/Theme.kt
+++ b/app/src/main/java/com/resonance/player/core/ui/theme/Theme.kt
@@ -37,13 +37,14 @@ object ResonanceTheme {
 @Composable
 fun ResonanceTheme(
     themeMode: ThemeMode = ThemeMode.SYSTEM,
+    accentHue: Float = DEFAULT_ACCENT_HUE,
     content: @Composable () -> Unit
 ) {
     val systemDark = isSystemInDarkTheme()
     val colors = when (themeMode) {
         ThemeMode.LIGHT -> interimLightColors()
-        ThemeMode.DARK -> stitchDarkColors()
-        ThemeMode.SYSTEM -> if (systemDark) stitchDarkColors() else interimLightColors()
+        ThemeMode.DARK -> stitchDarkColors(accentHue)
+        ThemeMode.SYSTEM -> if (systemDark) stitchDarkColors(accentHue) else interimLightColors()
     }
     val typography = stitchTypography()
     CompositionLocalProvider(
diff --git a/app/src/main/java/com/resonance/player/data/local/DataStoreSettingsRepository.kt b/app/src/main/java/com/resonance/player/data/local/DataStoreSettingsRepository.kt
index 3750d03..e32d021 100644
--- a/app/src/main/java/com/resonance/player/data/local/DataStoreSettingsRepository.kt
+++ b/app/src/main/java/com/resonance/player/data/local/DataStoreSettingsRepository.kt
@@ -4,8 +4,10 @@ import android.content.Context
 import androidx.datastore.core.DataStore
 import androidx.datastore.preferences.core.Preferences
 import androidx.datastore.preferences.core.edit
+import androidx.datastore.preferences.core.floatPreferencesKey
 import androidx.datastore.preferences.core.stringPreferencesKey
 import androidx.datastore.preferences.preferencesDataStore
+import com.resonance.player.core.ui.theme.DEFAULT_ACCENT_HUE
 import com.resonance.player.domain.settings.ThemeMode
 import com.resonance.player.domain.settings.UserPreferencesRepository
 import kotlinx.coroutines.flow.Flow
@@ -28,7 +30,16 @@ class DataStoreSettingsRepository(private val context: Context) : UserPreference
         context.settingsStore.edit { prefs -> prefs[Keys.THEME] = mode.name }
     }
 
+    override val accentHue: Flow<Float> = context.settingsStore.data.map { prefs ->
+        prefs[Keys.ACCENT_HUE] ?: DEFAULT_ACCENT_HUE
+    }
+
+    override suspend fun setAccentHue(hue: Float) {
+        context.settingsStore.edit { prefs -> prefs[Keys.ACCENT_HUE] = hue }
+    }
+
     private object Keys {
         val THEME = stringPreferencesKey("theme_mode")
+        val ACCENT_HUE = floatPreferencesKey("accent_hue")
     }
 }
diff --git a/app/src/main/java/com/resonance/player/data/local/RoomMusicRepository.kt b/app/src/main/java/com/resonance/player/data/local/RoomMusicRepository.kt
index 262f723..6eaddbc 100644
--- a/app/src/main/java/com/resonance/player/data/local/RoomMusicRepository.kt
+++ b/app/src/main/java/com/resonance/player/data/local/RoomMusicRepository.kt
@@ -164,6 +164,20 @@ class RoomMusicRepository(
             }
         }
 
+    override suspend fun getFolderSongs(relativePath: String?): Result<List<Song>> =
+        withContext(dispatchers.io) {
+            try {
+                val entities = database.songDao().getSongsOfFolder(relativePath)
+                if (entities.isEmpty()) {
+                    return@withContext Result.Failure(AppError.EmptyLibrary)
+                }
+                val favorites = database.favoriteDao().getFavoriteIds().toSet()
+                Result.Success(entities.map { it.toDomain(isFavorite = favorites.contains(it.id)) })
+            } catch (t: Exception) {
+                Result.Failure(AppError.DatabaseError(t.message))
+            }
+        }
+
     override suspend fun getLibraryStats(): LibraryStats = withContext(dispatchers.io) {
         val dao = database.songDao()
         val lastScan: Long? = try {
diff --git a/app/src/main/java/com/resonance/player/domain/library/LibraryBrowse.kt b/app/src/main/java/com/resonance/player/domain/library/LibraryBrowse.kt
index 3b28f45..8a42ed1 100644
--- a/app/src/main/java/com/resonance/player/domain/library/LibraryBrowse.kt
+++ b/app/src/main/java/com/resonance/player/domain/library/LibraryBrowse.kt
@@ -44,6 +44,12 @@ class GetGenreSongsUseCase(private val repository: MusicRepository) {
         repository.getGenreSongs(genreName)
 }
 
+/** Songs directly inside one folder (relative path), for tap-to-play-folder. */
+class GetFolderSongsUseCase(private val repository: MusicRepository) {
+    suspend operator fun invoke(relativePath: String?): Result<List<Song>> =
+        repository.getFolderSongs(relativePath)
+}
+
 /** Scanner state for progress banners and Settings. */
 class ObserveScanStateUseCase(private val repository: MusicRepository) {
     operator fun invoke(): Flow<ScanState> = repository.observeScanState()
diff --git a/app/src/main/java/com/resonance/player/domain/library/MusicRepository.kt b/app/src/main/java/com/resonance/player/domain/library/MusicRepository.kt
index 7b65f0e..df8e3b3 100644
--- a/app/src/main/java/com/resonance/player/domain/library/MusicRepository.kt
+++ b/app/src/main/java/com/resonance/player/domain/library/MusicRepository.kt
@@ -34,6 +34,7 @@ interface MusicRepository {
     fun observeGenres(): Flow<List<Genre>>
     fun observeFolders(): Flow<List<MusicFolder>>
     suspend fun getAlbumSongs(albumName: String, albumArtist: String?): Result<List<Song>>
+    suspend fun getFolderSongs(relativePath: String?): Result<List<Song>>
     fun observeRecentlyPlayed(limit: Int): Flow<List<Song>>
     fun observeMostPlayed(limit: Int): Flow<List<Song>>
     fun observeRecentlyAdded(limit: Int): Flow<List<Song>>
diff --git a/app/src/main/java/com/resonance/player/domain/settings/UserPreferences.kt b/app/src/main/java/com/resonance/player/domain/settings/UserPreferences.kt
index 04d6bbb..10b25b4 100644
--- a/app/src/main/java/com/resonance/player/domain/settings/UserPreferences.kt
+++ b/app/src/main/java/com/resonance/player/domain/settings/UserPreferences.kt
@@ -8,4 +8,8 @@ enum class ThemeMode { SYSTEM, LIGHT, DARK }
 interface UserPreferencesRepository {
     val themeMode: Flow<ThemeMode>
     suspend fun setThemeMode(mode: ThemeMode)
+
+    /** Accent hue (0-360); see [com.resonance.player.core.ui.theme.DEFAULT_ACCENT_HUE]. */
+    val accentHue: Flow<Float>
+    suspend fun setAccentHue(hue: Float)
 }
diff --git a/app/src/main/java/com/resonance/player/feature/favorites/FavoritesScreen.kt b/app/src/main/java/com/resonance/player/feature/favorites/FavoritesScreen.kt
index d5be338..bb383ec 100644
--- a/app/src/main/java/com/resonance/player/feature/favorites/FavoritesScreen.kt
+++ b/app/src/main/java/com/resonance/player/feature/favorites/FavoritesScreen.kt
@@ -5,17 +5,23 @@ import androidx.compose.foundation.layout.fillMaxSize
 import androidx.compose.foundation.lazy.LazyColumn
 import androidx.compose.foundation.lazy.items
 import androidx.compose.runtime.Composable
-import androidx.compose.runtime.collectAsState
 import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.remember
+import androidx.compose.runtime.setValue
+import androidx.lifecycle.compose.collectAsStateWithLifecycle
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.res.stringResource
 import com.resonance.player.R
 import com.resonance.player.core.common.formatDurationMs
+import com.resonance.player.core.model.Song
 import com.resonance.player.core.ui.components.ArtworkImage
+import com.resonance.player.core.ui.components.PlaylistPickerSheet
 import com.resonance.player.core.ui.components.ResonanceEmptyState
 import com.resonance.player.core.ui.components.ResonanceSongRow
 import com.resonance.player.core.ui.components.ResonanceTopBar
 import com.resonance.player.core.ui.components.SongFormatBadge
+import com.resonance.player.core.ui.components.SongOverflowSheet
 import com.resonance.player.core.ui.components.songRowState
 
 @Composable
@@ -25,7 +31,8 @@ fun FavoritesScreen(
     onBack: () -> Unit,
     onSongClick: (Long) -> Unit
 ) {
-    val songs by viewModel.songs.collectAsState()
+    val songs by viewModel.songs.collectAsStateWithLifecycle()
+    var overflowSong by remember { mutableStateOf<Song?>(null) }
     Column(Modifier.fillMaxSize()) {
         ResonanceTopBar(
             title = stringResource(R.string.favorites_title),
@@ -61,10 +68,54 @@ fun FavoritesScreen(
                             isLoading = false
                         ),
                         isPlayingAnimation = song.id == currentSongId,
-                        badge = { SongFormatBadge(song) }
+                        badge = { SongFormatBadge(song) },
+                        onOverflowClick = { overflowSong = song },
+                        modifier = Modifier.animateItem()
                     )
                 }
             }
         }
     }
+    overflowSong?.let { song ->
+        var showPicker by remember { mutableStateOf(false) }
+        val playlists by viewModel.playlists.collectAsStateWithLifecycle()
+        val playlistError by viewModel.playlistError.collectAsStateWithLifecycle()
+        if (showPicker) {
+            PlaylistPickerSheet(
+                songTitle = song.title,
+                playlists = playlists,
+                error = playlistError,
+                onPick = { playlistId ->
+                    viewModel.addToPlaylist(playlistId, song.id) {
+                        showPicker = false
+                        overflowSong = null
+                    }
+                },
+                onNewPlaylist = { name ->
+                    viewModel.createPlaylistAndAdd(name, song.id) {
+                        showPicker = false
+                        overflowSong = null
+                    }
+                },
+                onDismiss = {
+                    showPicker = false
+                    viewModel.clearPlaylistError()
+                }
+            )
+        } else {
+            SongOverflowSheet(
+                song = song,
+                onDismiss = { overflowSong = null },
+                onPlayNext = {
+                    viewModel.playNext(song)
+                    overflowSong = null
+                },
+                onAddToQueue = {
+                    viewModel.addToQueue(song)
+                    overflowSong = null
+                },
+                onAddToPlaylist = { showPicker = true }
+            )
+        }
+    }
 }
diff --git a/app/src/main/java/com/resonance/player/feature/favorites/FavoritesViewModel.kt b/app/src/main/java/com/resonance/player/feature/favorites/FavoritesViewModel.kt
index 62bf208..82e10c5 100644
--- a/app/src/main/java/com/resonance/player/feature/favorites/FavoritesViewModel.kt
+++ b/app/src/main/java/com/resonance/player/feature/favorites/FavoritesViewModel.kt
@@ -2,23 +2,83 @@
 
 import androidx.lifecycle.ViewModel
 import androidx.lifecycle.viewModelScope
+import com.resonance.player.core.common.Result
+import com.resonance.player.core.common.userMessage
+import com.resonance.player.core.model.Playlist
 import com.resonance.player.core.model.Song
 import com.resonance.player.domain.favorites.ObserveFavoriteSongsUseCase
+import com.resonance.player.domain.playback.AppendToQueueUseCase
+import com.resonance.player.domain.playback.PlayNextUseCase
 import com.resonance.player.domain.playback.PlaySongsUseCase
+import com.resonance.player.domain.playlists.AddSongToPlaylistUseCase
+import com.resonance.player.domain.playlists.CreatePlaylistUseCase
+import com.resonance.player.domain.playlists.ObservePlaylistsUseCase
+import kotlinx.coroutines.flow.MutableStateFlow
 import kotlinx.coroutines.flow.SharingStarted
 import kotlinx.coroutines.flow.StateFlow
+import kotlinx.coroutines.flow.asStateFlow
 import kotlinx.coroutines.flow.stateIn
 import kotlinx.coroutines.launch
 
 /** Favorites list: real favorite songs, tap to play from the list. */
 class FavoritesViewModel(
     observeFavorites: ObserveFavoriteSongsUseCase,
-    private val playSongs: PlaySongsUseCase
+    private val playSongs: PlaySongsUseCase,
+    private val playNextUseCase: PlayNextUseCase,
+    private val appendToQueueUseCase: AppendToQueueUseCase,
+    observePlaylists: ObservePlaylistsUseCase,
+    private val addSongToPlaylist: AddSongToPlaylistUseCase,
+    private val createPlaylist: CreatePlaylistUseCase
 ) : ViewModel() {
     val songs: StateFlow<List<Song>> = observeFavorites()
         .stateIn(viewModelScope, SharingStarted.WhileSubscribed(5_000), emptyList())
 
+    val playlists: StateFlow<List<Playlist>> = observePlaylists()
+        .stateIn(viewModelScope, SharingStarted.WhileSubscribed(5_000), emptyList())
+
+    private val playlistErrorMutable = MutableStateFlow<String?>(null)
+    val playlistError: StateFlow<String?> = playlistErrorMutable.asStateFlow()
+
     fun playFrom(songs: List<Song>, index: Int) {
         viewModelScope.launch { playSongs(songs, index) }
     }
+
+    fun playNext(song: Song) {
+        viewModelScope.launch { playNextUseCase(song) }
+    }
+
+    fun addToQueue(song: Song) {
+        viewModelScope.launch { appendToQueueUseCase(listOf(song)) }
+    }
+
+    fun addToPlaylist(playlistId: Long, songId: Long, onDone: () -> Unit = {}) {
+        viewModelScope.launch {
+            when (val result = addSongToPlaylist(playlistId, songId)) {
+                is Result.Success -> {
+                    playlistErrorMutable.value = null
+                    onDone()
+                }
+                is Result.Failure -> playlistErrorMutable.value = result.error.userMessage()
+                is Result.Loading -> Unit
+            }
+        }
+    }
+
+    fun createPlaylistAndAdd(name: String, songId: Long, onDone: () -> Unit = {}) {
+        viewModelScope.launch {
+            when (val result = createPlaylist(name)) {
+                is Result.Success -> {
+                    playlistErrorMutable.value = null
+                    addSongToPlaylist(result.value.id, songId)
+                    onDone()
+                }
+                is Result.Failure -> playlistErrorMutable.value = result.error.userMessage()
+                is Result.Loading -> Unit
+            }
+        }
+    }
+
+    fun clearPlaylistError() {
+        playlistErrorMutable.value = null
+    }
 }
diff --git a/app/src/main/java/com/resonance/player/feature/home/HomeScreen.kt b/app/src/main/java/com/resonance/player/feature/home/HomeScreen.kt
index 914552a..710bdad 100644
--- a/app/src/main/java/com/resonance/player/feature/home/HomeScreen.kt
+++ b/app/src/main/java/com/resonance/player/feature/home/HomeScreen.kt
@@ -30,14 +30,17 @@ import androidx.compose.material3.LinearProgressIndicator
 import androidx.compose.material3.Surface
 import androidx.compose.material3.Text
 import androidx.compose.runtime.Composable
-import androidx.compose.runtime.collectAsState
 import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.remember
+import androidx.compose.runtime.setValue
 import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.draw.clip
 import androidx.compose.ui.graphics.vector.ImageVector
 import androidx.compose.ui.res.stringResource
 import androidx.compose.ui.unit.dp
+import androidx.lifecycle.compose.collectAsStateWithLifecycle
 import com.resonance.player.R
 import com.resonance.player.core.common.formatBytes
 import com.resonance.player.core.common.formatDurationMs
@@ -47,11 +50,13 @@ import com.resonance.player.core.permissions.AudioPermissionManager
 import com.resonance.player.core.ui.components.ArtworkImage
 import com.resonance.player.core.ui.components.AudioPermissionGate
 import com.resonance.player.core.ui.components.EmptyLibraryView
+import com.resonance.player.core.ui.components.PlaylistPickerSheet
 import com.resonance.player.core.ui.components.ResonanceAlbumCard
 import com.resonance.player.core.ui.components.ResonanceCardPlayButton
 import com.resonance.player.core.ui.components.ResonanceMetric
 import com.resonance.player.core.ui.components.ResonanceSectionHeader
 import com.resonance.player.core.ui.components.SongFormatBadge
+import com.resonance.player.core.ui.components.SongOverflowSheet
 import com.resonance.player.core.ui.components.ResonanceSongRow
 import com.resonance.player.core.ui.components.ResonanceTopBar
 import com.resonance.player.core.ui.components.ScanProgressBanner
@@ -95,8 +100,8 @@ private fun HomeContent(
     val colors = ResonanceTheme.colors
     val typography = ResonanceTheme.typography
     val spacing = ResonanceTheme.spacing
-    val scanState by viewModel.scanState.collectAsState()
-    val storage by viewModel.storage.collectAsState()
+    val scanState by viewModel.scanState.collectAsStateWithLifecycle()
+    val storage by viewModel.storage.collectAsStateWithLifecycle()
     val trackCount = storage?.trackCount ?: 0
     val isEmpty = trackCount == 0 && scanState !is ScanState.Scanning
 
@@ -142,7 +147,7 @@ private fun StorageCard(
     val colors = ResonanceTheme.colors
     val typography = ResonanceTheme.typography
     val spacing = ResonanceTheme.spacing
-    val overview by viewModel.storage.collectAsState()
+    val overview by viewModel.storage.collectAsStateWithLifecycle()
     Surface(
         shape = ResonanceTheme.radii.card,
         color = colors.surfaceContainer,
@@ -222,7 +227,7 @@ private fun RecentlyPlayedSection(
     onOpenLibrary: (Int) -> Unit,
     onOpenQueue: () -> Unit
 ) {
-    val albums by viewModel.recentAlbums.collectAsState()
+    val albums by viewModel.recentAlbums.collectAsStateWithLifecycle()
     if (albums.isEmpty()) return
     val spacing = ResonanceTheme.spacing
     ResonanceSectionHeader(
@@ -250,6 +255,7 @@ private fun RecentlyPlayedSection(
                     viewModel.playAlbum(album.name, album.albumArtist)
                     onOpenQueue()
                 },
+                modifier = Modifier.animateItem(),
                 playButton = {
                     ResonanceCardPlayButton(
                         onClick = {
@@ -276,9 +282,9 @@ private fun JumpBackInSection(
     val colors = ResonanceTheme.colors
     val typography = ResonanceTheme.typography
     val spacing = ResonanceTheme.spacing
-    val favCount by viewModel.favoriteCount.collectAsState()
-    val mostPlayed by viewModel.mostPlayed.collectAsState()
-    val recentSongs by viewModel.recentSongs.collectAsState()
+    val favCount by viewModel.favoriteCount.collectAsStateWithLifecycle()
+    val mostPlayed by viewModel.mostPlayed.collectAsStateWithLifecycle()
+    val recentSongs by viewModel.recentSongs.collectAsStateWithLifecycle()
     ResonanceSectionHeader(title = stringResource(R.string.home_jump_back_in))
     Spacer(Modifier.height(spacing.md))
     Column(
@@ -389,14 +395,64 @@ private fun RecentlyAddedSection(
     currentSongId: Long?,
     onSongClick: (Long) -> Unit
 ) {
-    val songs by viewModel.recentSongs.collectAsState()
+    val songs by viewModel.recentSongs.collectAsStateWithLifecycle()
     if (songs.isEmpty()) return
     val spacing = ResonanceTheme.spacing
+    var overflowSong by remember { mutableStateOf<Song?>(null) }
     ResonanceSectionHeader(title = stringResource(R.string.home_recently_added))
     Spacer(Modifier.height(spacing.sm))
     Column {
         songs.forEach { song ->
-            SongHomeRow(song, song.id == currentSongId, viewModel, songs, onSongClick)
+            SongHomeRow(
+                song,
+                song.id == currentSongId,
+                viewModel,
+                songs,
+                onSongClick,
+                onOverflowClick = { overflowSong = song }
+            )
+        }
+    }
+    overflowSong?.let { song ->
+        var showPicker by remember { mutableStateOf(false) }
+        val playlists by viewModel.playlists.collectAsStateWithLifecycle()
+        val playlistError by viewModel.playlistError.collectAsStateWithLifecycle()
+        if (showPicker) {
+            PlaylistPickerSheet(
+                songTitle = song.title,
+                playlists = playlists,
+                error = playlistError,
+                onPick = { playlistId ->
+                    viewModel.addToPlaylist(playlistId, song.id) {
+                        showPicker = false
+                        overflowSong = null
+                    }
+                },
+                onNewPlaylist = { name ->
+                    viewModel.createPlaylistAndAdd(name, song.id) {
+                        showPicker = false
+                        overflowSong = null
+                    }
+                },
+                onDismiss = {
+                    showPicker = false
+                    viewModel.clearPlaylistError()
+                }
+            )
+        } else {
+            SongOverflowSheet(
+                song = song,
+                onDismiss = { overflowSong = null },
+                onPlayNext = {
+                    viewModel.playNext(song)
+                    overflowSong = null
+                },
+                onAddToQueue = {
+                    viewModel.addToQueue(song)
+                    overflowSong = null
+                },
+                onAddToPlaylist = { showPicker = true }
+            )
         }
     }
 }
@@ -407,7 +463,8 @@ private fun SongHomeRow(
     isCurrent: Boolean,
     viewModel: HomeViewModel,
     songs: List<Song>,
-    onSongClick: (Long) -> Unit
+    onSongClick: (Long) -> Unit,
+    onOverflowClick: () -> Unit
 ) {
     ResonanceSongRow(
         title = song.title,
@@ -433,7 +490,8 @@ private fun SongHomeRow(
         isPlayingAnimation = isCurrent,
         badge = {
             SongFormatBadge(song)
-        }
+        },
+        onOverflowClick = onOverflowClick
     )
 }
 
diff --git a/app/src/main/java/com/resonance/player/feature/home/HomeViewModel.kt b/app/src/main/java/com/resonance/player/feature/home/HomeViewModel.kt
index 910ac6e..930b479 100644
--- a/app/src/main/java/com/resonance/player/feature/home/HomeViewModel.kt
+++ b/app/src/main/java/com/resonance/player/feature/home/HomeViewModel.kt
@@ -3,6 +3,7 @@
 import androidx.lifecycle.ViewModel
 import androidx.lifecycle.viewModelScope
 import com.resonance.player.core.model.Album
+import com.resonance.player.core.model.Playlist
 import com.resonance.player.core.model.ShuffleMode
 import com.resonance.player.core.model.Song
 import com.resonance.player.core.model.StorageOverview
@@ -16,11 +17,19 @@ import com.resonance.player.domain.library.ObserveScanStateUseCase
 import com.resonance.player.domain.library.GetAlbumSongsUseCase
 import com.resonance.player.domain.library.RescanLibraryUseCase
 import com.resonance.player.domain.library.recentAlbumsFromSongs
+import com.resonance.player.domain.playback.AppendToQueueUseCase
+import com.resonance.player.domain.playback.PlayNextUseCase
 import com.resonance.player.domain.playback.PlaySongsUseCase
 import com.resonance.player.domain.playback.SetShuffleModeUseCase
+import com.resonance.player.domain.playlists.AddSongToPlaylistUseCase
+import com.resonance.player.domain.playlists.CreatePlaylistUseCase
+import com.resonance.player.domain.playlists.ObservePlaylistsUseCase
 import com.resonance.player.core.common.Result
+import com.resonance.player.core.common.userMessage
+import kotlinx.coroutines.flow.MutableStateFlow
 import kotlinx.coroutines.flow.SharingStarted
 import kotlinx.coroutines.flow.StateFlow
+import kotlinx.coroutines.flow.asStateFlow
 import kotlinx.coroutines.flow.map
 import kotlinx.coroutines.flow.stateIn
 import kotlinx.coroutines.launch
@@ -40,9 +49,20 @@ class HomeViewModel(
     private val playSongs: PlaySongsUseCase,
     private val getAlbumSongs: GetAlbumSongsUseCase,
     private val setShuffleMode: SetShuffleModeUseCase,
-    private val rescanLibrary: RescanLibraryUseCase
+    private val rescanLibrary: RescanLibraryUseCase,
+    private val playNextUseCase: PlayNextUseCase,
+    private val appendToQueueUseCase: AppendToQueueUseCase,
+    observePlaylists: ObservePlaylistsUseCase,
+    private val addSongToPlaylist: AddSongToPlaylistUseCase,
+    private val createPlaylist: CreatePlaylistUseCase
 ) : ViewModel() {
 
+    val playlists: StateFlow<List<Playlist>> = observePlaylists()
+        .stateIn(viewModelScope, SharingStarted.WhileSubscribed(5_000), emptyList())
+
+    private val playlistErrorMutable = MutableStateFlow<String?>(null)
+    val playlistError: StateFlow<String?> = playlistErrorMutable.asStateFlow()
+
     val recentAlbums: StateFlow<List<Album>> = observeRecentlyPlayed(25)
         .map { recentAlbumsFromSongs(it, 10) }
         .stateIn(viewModelScope, SharingStarted.WhileSubscribed(5_000), emptyList())
@@ -86,4 +106,43 @@ class HomeViewModel(
     fun rescan() {
         viewModelScope.launch { rescanLibrary() }
     }
+
+    fun playNext(song: Song) {
+        viewModelScope.launch { playNextUseCase(song) }
+    }
+
+    fun addToQueue(song: Song) {
+        viewModelScope.launch { appendToQueueUseCase(listOf(song)) }
+    }
+
+    fun addToPlaylist(playlistId: Long, songId: Long, onDone: () -> Unit = {}) {
+        viewModelScope.launch {
+            when (val result = addSongToPlaylist(playlistId, songId)) {
+                is Result.Success -> {
+                    playlistErrorMutable.value = null
+                    onDone()
+                }
+                is Result.Failure -> playlistErrorMutable.value = result.error.userMessage()
+                is Result.Loading -> Unit
+            }
+        }
+    }
+
+    fun createPlaylistAndAdd(name: String, songId: Long, onDone: () -> Unit = {}) {
+        viewModelScope.launch {
+            when (val result = createPlaylist(name)) {
+                is Result.Success -> {
+                    playlistErrorMutable.value = null
+                    addSongToPlaylist(result.value.id, songId)
+                    onDone()
+                }
+                is Result.Failure -> playlistErrorMutable.value = result.error.userMessage()
+                is Result.Loading -> Unit
+            }
+        }
+    }
+
+    fun clearPlaylistError() {
+        playlistErrorMutable.value = null
+    }
 }
diff --git a/app/src/main/java/com/resonance/player/feature/library/LibraryScreen.kt b/app/src/main/java/com/resonance/player/feature/library/LibraryScreen.kt
index c2b456b..ead7aad 100644
--- a/app/src/main/java/com/resonance/player/feature/library/LibraryScreen.kt
+++ b/app/src/main/java/com/resonance/player/feature/library/LibraryScreen.kt
@@ -30,7 +30,6 @@ import androidx.compose.material3.IconButton
 import androidx.compose.material3.Surface
 import androidx.compose.material3.Text
 import androidx.compose.runtime.Composable
-import androidx.compose.runtime.collectAsState
 import androidx.compose.runtime.getValue
 import androidx.compose.runtime.mutableIntStateOf
 import androidx.compose.runtime.mutableStateOf
@@ -43,6 +42,7 @@ import androidx.compose.ui.input.pointer.pointerInput
 import androidx.compose.ui.res.stringResource
 import androidx.compose.ui.text.style.TextAlign
 import androidx.compose.ui.unit.dp
+import androidx.lifecycle.compose.collectAsStateWithLifecycle
 import com.resonance.player.R
 import com.resonance.player.core.common.formatDurationMs
 import com.resonance.player.core.model.Song
@@ -99,7 +99,7 @@ private fun LibraryTabs(
     onOpenSearch: () -> Unit
 ) {
     var tab by remember(initialTab) { mutableIntStateOf(initialTab.coerceIn(0, 4)) }
-    val scanState by viewModel.scanState.collectAsState()
+    val scanState by viewModel.scanState.collectAsStateWithLifecycle()
     Column(Modifier.fillMaxSize()) {
         ResonanceTopBar(
             title = stringResource(R.string.nav_library),
@@ -112,9 +112,9 @@ private fun LibraryTabs(
         when (tab) {
             0 -> SongsTab(viewModel, currentSongId, onSongClick)
             1 -> AlbumsTab(viewModel, onOpenQueue)
-            2 -> ArtistsTab(viewModel)
-            3 -> GenresTab(viewModel)
-            4 -> FoldersTab(viewModel)
+            2 -> ArtistsTab(viewModel, onOpenQueue)
+            3 -> GenresTab(viewModel, onOpenQueue)
+            4 -> FoldersTab(viewModel, onOpenQueue)
         }
     }
 }
@@ -126,12 +126,12 @@ private fun CategoryChips(
     onSelect: (Int) -> Unit
 ) {
     val spacing = ResonanceTheme.spacing
-    val songs by viewModel.uiState.collectAsState()
+    val songs by viewModel.uiState.collectAsStateWithLifecycle()
     val songCount = (songs as? LibraryUiState.Content)?.songs?.size ?: 0
-    val albums by viewModel.albums.collectAsState()
-    val artists by viewModel.artists.collectAsState()
-    val genres by viewModel.genres.collectAsState()
-    val folders by viewModel.folders.collectAsState()
+    val albums by viewModel.albums.collectAsStateWithLifecycle()
+    val artists by viewModel.artists.collectAsStateWithLifecycle()
+    val genres by viewModel.genres.collectAsStateWithLifecycle()
+    val folders by viewModel.folders.collectAsStateWithLifecycle()
     LazyRow(
         modifier = Modifier
             .fillMaxWidth()
@@ -198,7 +198,7 @@ private fun SortToolbar(viewModel: LibraryViewModel) {
     val colors = ResonanceTheme.colors
     val typography = ResonanceTheme.typography
     val spacing = ResonanceTheme.spacing
-    val sort by viewModel.sort.collectAsState()
+    val sort by viewModel.sort.collectAsStateWithLifecycle()
     var expanded by remember { mutableStateOf(false) }
     Row(
         verticalAlignment = Alignment.CenterVertically,
@@ -268,7 +268,7 @@ private fun SongsTab(
     currentSongId: Long?,
     onSongClick: (Long) -> Unit
 ) {
-    val state by viewModel.uiState.collectAsState()
+    val state by viewModel.uiState.collectAsStateWithLifecycle()
     when (val s = state) {
         LibraryUiState.Loading -> LoadingView()
         LibraryUiState.Empty -> EmptyLibraryView()
@@ -299,6 +299,7 @@ private fun SongsTab(
                                 if (at >= 0) viewModel.playFrom(s.songs, at)
                                 onSongClick(song.id)
                             },
+                            modifier = Modifier.animateItem(),
                             state = songRowState(
                                 isCurrent = isCurrent,
                                 isSelected = false,
@@ -327,8 +328,8 @@ private fun SongsTab(
             }
             overflowSong?.let { song ->
                 var showPicker by remember { mutableStateOf(false) }
-                val playlists by viewModel.playlists.collectAsState()
-                val playlistError by viewModel.playlistError.collectAsState()
+                val playlists by viewModel.playlists.collectAsStateWithLifecycle()
+                val playlistError by viewModel.playlistError.collectAsStateWithLifecycle()
                 if (showPicker) {
                     PlaylistPickerSheet(
                         songTitle = song.title,
@@ -451,7 +452,7 @@ private fun pickLetter(
 
 @Composable
 private fun AlbumsTab(viewModel: LibraryViewModel, onOpenQueue: () -> Unit) {
-    val albums by viewModel.albums.collectAsState()
+    val albums by viewModel.albums.collectAsStateWithLifecycle()
     val colors = ResonanceTheme.colors
     val typography = ResonanceTheme.typography
     val spacing = ResonanceTheme.spacing
@@ -464,6 +465,7 @@ private fun AlbumsTab(viewModel: LibraryViewModel, onOpenQueue: () -> Unit) {
             Row(
                 verticalAlignment = Alignment.CenterVertically,
                 modifier = Modifier
+                    .animateItem()
                     .fillMaxWidth()
                     .height(ResonanceTheme.dimensions.songRowHeight)
                     .padding(horizontal = spacing.lg)
@@ -502,8 +504,8 @@ private fun AlbumsTab(viewModel: LibraryViewModel, onOpenQueue: () -> Unit) {
 }
 
 @Composable
-private fun ArtistsTab(viewModel: LibraryViewModel) {
-    val artists by viewModel.artists.collectAsState()
+private fun ArtistsTab(viewModel: LibraryViewModel, onOpenQueue: () -> Unit) {
+    val artists by viewModel.artists.collectAsStateWithLifecycle()
     val colors = ResonanceTheme.colors
     val typography = ResonanceTheme.typography
     val spacing = ResonanceTheme.spacing
@@ -515,7 +517,12 @@ private fun ArtistsTab(viewModel: LibraryViewModel) {
         items(artists, key = { it.id }) { artist ->
             Column(
                 modifier = Modifier
+                    .animateItem()
                     .fillMaxWidth()
+                    .clickable {
+                        viewModel.playArtist(artist.name)
+                        onOpenQueue()
+                    }
                     .padding(horizontal = spacing.lg, vertical = spacing.md)
             ) {
                 Text(
@@ -539,8 +546,8 @@ private fun ArtistsTab(viewModel: LibraryViewModel) {
 }
 
 @Composable
-private fun GenresTab(viewModel: LibraryViewModel) {
-    val genres by viewModel.genres.collectAsState()
+private fun GenresTab(viewModel: LibraryViewModel, onOpenQueue: () -> Unit) {
+    val genres by viewModel.genres.collectAsStateWithLifecycle()
     val colors = ResonanceTheme.colors
     val typography = ResonanceTheme.typography
     val spacing = ResonanceTheme.spacing
@@ -553,7 +560,12 @@ private fun GenresTab(viewModel: LibraryViewModel) {
             Row(
                 verticalAlignment = Alignment.CenterVertically,
                 modifier = Modifier
+                    .animateItem()
                     .fillMaxWidth()
+                    .clickable {
+                        viewModel.playGenre(genre.name)
+                        onOpenQueue()
+                    }
                     .padding(horizontal = spacing.lg, vertical = spacing.md)
             ) {
                 Text(
@@ -576,8 +588,8 @@ private fun GenresTab(viewModel: LibraryViewModel) {
 }
 
 @Composable
-private fun FoldersTab(viewModel: LibraryViewModel) {
-    val folders by viewModel.folders.collectAsState()
+private fun FoldersTab(viewModel: LibraryViewModel, onOpenQueue: () -> Unit) {
+    val folders by viewModel.folders.collectAsStateWithLifecycle()
     val colors = ResonanceTheme.colors
     val typography = ResonanceTheme.typography
     val spacing = ResonanceTheme.spacing
@@ -590,7 +602,12 @@ private fun FoldersTab(viewModel: LibraryViewModel) {
             Row(
                 verticalAlignment = Alignment.CenterVertically,
                 modifier = Modifier
+                    .animateItem()
                     .fillMaxWidth()
+                    .clickable {
+                        viewModel.playFolder(folder.path)
+                        onOpenQueue()
+                    }
                     .padding(horizontal = spacing.lg, vertical = spacing.md)
             ) {
                 Column(Modifier.weight(1f)) {
diff --git a/app/src/main/java/com/resonance/player/feature/library/LibraryViewModel.kt b/app/src/main/java/com/resonance/player/feature/library/LibraryViewModel.kt
index 87df012..4e3cda0 100644
--- a/app/src/main/java/com/resonance/player/feature/library/LibraryViewModel.kt
+++ b/app/src/main/java/com/resonance/player/feature/library/LibraryViewModel.kt
@@ -13,6 +13,9 @@ import com.resonance.player.core.model.Playlist
 import com.resonance.player.core.model.ShuffleMode
 import com.resonance.player.core.model.Song
 import com.resonance.player.domain.library.GetAlbumSongsUseCase
+import com.resonance.player.domain.library.GetArtistSongsUseCase
+import com.resonance.player.domain.library.GetFolderSongsUseCase
+import com.resonance.player.domain.library.GetGenreSongsUseCase
 import com.resonance.player.domain.library.ObserveAlbumsUseCase
 import com.resonance.player.domain.library.ObserveArtistsUseCase
 import com.resonance.player.domain.library.ObserveFoldersUseCase
@@ -60,6 +63,9 @@ class LibraryViewModel(
     observeGenres: ObserveGenresUseCase,
     observeFolders: ObserveFoldersUseCase,
     private val getAlbumSongs: GetAlbumSongsUseCase,
+    private val getArtistSongs: GetArtistSongsUseCase,
+    private val getGenreSongs: GetGenreSongsUseCase,
+    private val getFolderSongs: GetFolderSongsUseCase,
     private val setShuffleMode: SetShuffleModeUseCase,
     private val playNextUseCase: PlayNextUseCase,
     private val appendToQueueUseCase: AppendToQueueUseCase,
@@ -116,6 +122,28 @@ class LibraryViewModel(
         }
     }
 
+    fun playArtist(artistName: String) {
+        viewModelScope.launch {
+            val songs = (getArtistSongs(artistName) as? Result.Success)?.value
+            if (!songs.isNullOrEmpty()) playSongs(songs, 0)
+        }
+    }
+
+    fun playGenre(genreName: String) {
+        viewModelScope.launch {
+            val songs = (getGenreSongs(genreName) as? Result.Success)?.value
+            if (!songs.isNullOrEmpty()) playSongs(songs, 0)
+        }
+    }
+
+    /** [relativePath] mirrors [com.resonance.player.core.model.MusicFolder.path]: "" means the root folder. */
+    fun playFolder(relativePath: String) {
+        viewModelScope.launch {
+            val songs = (getFolderSongs(relativePath.ifBlank { null }) as? Result.Success)?.value
+            if (!songs.isNullOrEmpty()) playSongs(songs, 0)
+        }
+    }
+
     /** Shuffle-all: play the visible list from the head, engine shuffles. */
     fun shuffleAll() {
         val songs = (uiState.value as? LibraryUiState.Content)?.songs ?: return
diff --git a/app/src/main/java/com/resonance/player/feature/player/PlayerScreen.kt b/app/src/main/java/com/resonance/player/feature/player/PlayerScreen.kt
index 7ec2ae1..e829d26 100644
--- a/app/src/main/java/com/resonance/player/feature/player/PlayerScreen.kt
+++ b/app/src/main/java/com/resonance/player/feature/player/PlayerScreen.kt
@@ -29,7 +29,6 @@ import androidx.compose.material3.ExperimentalMaterial3Api
 import androidx.compose.material3.Text
 import androidx.compose.material3.TextButton
 import androidx.compose.runtime.Composable
-import androidx.compose.runtime.collectAsState
 import androidx.compose.runtime.getValue
 import androidx.compose.runtime.mutableFloatStateOf
 import androidx.compose.runtime.mutableStateOf
@@ -42,6 +41,7 @@ import androidx.compose.ui.res.stringResource
 import androidx.compose.ui.text.style.TextOverflow
 import androidx.compose.ui.unit.DpSize
 import androidx.compose.ui.unit.dp
+import androidx.lifecycle.compose.collectAsStateWithLifecycle
 import com.resonance.player.R
 import com.resonance.player.core.common.formatBytes
 import com.resonance.player.core.common.formatDurationMs
@@ -74,10 +74,10 @@ fun PlayerScreen(
     val colors = ResonanceTheme.colors
     val typography = ResonanceTheme.typography
     val spacing = ResonanceTheme.spacing
-    val snapshot by viewModel.snapshot.collectAsState()
-    val details by viewModel.details.collectAsState()
-    val commandError by viewModel.commandError.collectAsState()
-    val isFavorite by viewModel.isFavorite.collectAsState()
+    val snapshot by viewModel.snapshot.collectAsStateWithLifecycle()
+    val details by viewModel.details.collectAsStateWithLifecycle()
+    val commandError by viewModel.commandError.collectAsStateWithLifecycle()
+    val isFavorite by viewModel.isFavorite.collectAsStateWithLifecycle()
 
     val song = snapshot.song ?: details
     val duration = snapshot.durationMs
diff --git a/app/src/main/java/com/resonance/player/feature/playlists/PlaylistDetailScreen.kt b/app/src/main/java/com/resonance/player/feature/playlists/PlaylistDetailScreen.kt
index cafee03..6707f4a 100644
--- a/app/src/main/java/com/resonance/player/feature/playlists/PlaylistDetailScreen.kt
+++ b/app/src/main/java/com/resonance/player/feature/playlists/PlaylistDetailScreen.kt
@@ -10,6 +10,7 @@ import androidx.compose.foundation.layout.padding
 import androidx.compose.foundation.layout.size
 import androidx.compose.foundation.layout.width
 import androidx.compose.material.icons.Icons
+import androidx.compose.material.icons.filled.Add
 import androidx.compose.material.icons.filled.Close
 import androidx.compose.material.icons.filled.Delete
 import androidx.compose.material.icons.filled.DragHandle
@@ -21,11 +22,11 @@ import androidx.compose.material3.IconButton
 import androidx.compose.material3.Text
 import androidx.compose.material3.TextButton
 import androidx.compose.runtime.Composable
-import androidx.compose.runtime.collectAsState
 import androidx.compose.runtime.getValue
 import androidx.compose.runtime.mutableStateOf
 import androidx.compose.runtime.remember
 import androidx.compose.runtime.setValue
+import androidx.lifecycle.compose.collectAsStateWithLifecycle
 import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.res.stringResource
@@ -39,6 +40,7 @@ import com.resonance.player.core.ui.components.ResonanceDialog
 import com.resonance.player.core.ui.components.ResonanceEmptyState
 import com.resonance.player.core.ui.components.ResonanceIconButton
 import com.resonance.player.core.ui.components.ResonanceTopBar
+import com.resonance.player.core.ui.components.SongPickerSheet
 import com.resonance.player.core.ui.theme.ResonanceTheme
 
 /**
@@ -57,10 +59,11 @@ fun PlaylistDetailScreen(
     val colors = ResonanceTheme.colors
     val typography = ResonanceTheme.typography
     val spacing = ResonanceTheme.spacing
-    val songs by viewModel.songs.collectAsState()
-    val error by viewModel.error.collectAsState()
+    val songs by viewModel.songs.collectAsStateWithLifecycle()
+    val error by viewModel.error.collectAsStateWithLifecycle()
     var showRename by remember { mutableStateOf(false) }
     var showDelete by remember { mutableStateOf(false) }
+    var showAddSongs by remember { mutableStateOf(false) }
 
     Column(Modifier.fillMaxSize()) {
         ResonanceTopBar(
@@ -92,6 +95,12 @@ fun PlaylistDetailScreen(
                 contentDescription = stringResource(R.string.cd_shuffle),
                 enabled = songs.isNotEmpty()
             )
+            ResonanceIconButton(
+                onClick = { showAddSongs = true },
+                icon = Icons.Filled.Add,
+                contentDescription = stringResource(R.string.playlist_add_songs),
+                enabled = playlist != null
+            )
             ResonanceIconButton(
                 onClick = { showRename = true },
                 icon = Icons.Filled.Edit,
@@ -189,4 +198,15 @@ fun PlaylistDetailScreen(
             dismissLabel = stringResource(R.string.action_dismiss)
         )
     }
+    if (showAddSongs && playlist != null) {
+        val allSongs by viewModel.allSongs.collectAsStateWithLifecycle()
+        SongPickerSheet(
+            title = stringResource(R.string.playlist_add_songs_title, playlist.name),
+            songs = allSongs,
+            onConfirm = { ids ->
+                viewModel.addSongs(ids) { showAddSongs = false }
+            },
+            onDismiss = { showAddSongs = false }
+        )
+    }
 }
diff --git a/app/src/main/java/com/resonance/player/feature/playlists/PlaylistsScreen.kt b/app/src/main/java/com/resonance/player/feature/playlists/PlaylistsScreen.kt
index 5d18ee6..8fbdd71 100644
--- a/app/src/main/java/com/resonance/player/feature/playlists/PlaylistsScreen.kt
+++ b/app/src/main/java/com/resonance/player/feature/playlists/PlaylistsScreen.kt
@@ -29,7 +29,6 @@ import androidx.compose.material3.OutlinedTextField
 import androidx.compose.material3.Text
 import androidx.compose.material3.TextButton
 import androidx.compose.runtime.Composable
-import androidx.compose.runtime.collectAsState
 import androidx.compose.runtime.getValue
 import androidx.compose.runtime.mutableStateOf
 import androidx.compose.runtime.remember
@@ -40,9 +39,11 @@ import androidx.compose.ui.draw.clip
 import androidx.compose.ui.res.stringResource
 import androidx.compose.ui.text.style.TextOverflow
 import androidx.compose.ui.unit.dp
+import androidx.lifecycle.compose.collectAsStateWithLifecycle
 import com.resonance.player.R
 import com.resonance.player.core.model.Playlist
 import com.resonance.player.core.ui.components.ResonanceBottomSheet
+import com.resonance.player.core.ui.components.ResonanceDialog
 import com.resonance.player.core.ui.components.ResonanceEmptyState
 import com.resonance.player.core.ui.components.ResonanceTopBar
 import com.resonance.player.core.ui.theme.ResonanceTheme
@@ -55,16 +56,18 @@ import com.resonance.player.core.ui.theme.ResonanceTheme
 fun PlaylistsScreen(
     viewModel: PlaylistsViewModel,
     onOpenDetail: (Long) -> Unit,
-    onOpenQueue: () -> Unit
+    onOpenQueue: () -> Unit,
+    onShowMessage: (String) -> Unit = {}
 ) {
     val colors = ResonanceTheme.colors
     val typography = ResonanceTheme.typography
     val spacing = ResonanceTheme.spacing
-    val playlists by viewModel.playlists.collectAsState()
-    val error by viewModel.error.collectAsState()
+    val playlists by viewModel.playlists.collectAsStateWithLifecycle()
+    val error by viewModel.error.collectAsStateWithLifecycle()
     var showCreate by remember { mutableStateOf(false) }
     var overflowPlaylist by remember { mutableStateOf<Playlist?>(null) }
     var renameTarget by remember { mutableStateOf<Playlist?>(null) }
+    var deleteTarget by remember { mutableStateOf<Playlist?>(null) }
 
     Box(Modifier.fillMaxSize()) {
         Column(Modifier.fillMaxSize()) {
@@ -82,7 +85,8 @@ fun PlaylistsScreen(
                         PlaylistRow(
                             playlist = playlist,
                             onClick = { onOpenDetail(playlist.id) },
-                            onOverflow = { overflowPlaylist = playlist }
+                            onOverflow = { overflowPlaylist = playlist },
+                            modifier = Modifier.animateItem()
                         )
                     }
                 }
@@ -118,12 +122,17 @@ fun PlaylistsScreen(
             onDismiss = { showCreate = false }
         )
     }
+    val emptyPlaylistMessage = stringResource(R.string.playlist_empty_action)
     overflowPlaylist?.let { playlist ->
         PlaylistOverflowSheet(
             playlist = playlist,
             onDismiss = { overflowPlaylist = null },
             onPlay = {
-                viewModel.play(playlist.id) { onOpenQueue() }
+                viewModel.play(
+                    playlist.id,
+                    onPlaying = { onOpenQueue() },
+                    onEmpty = { onShowMessage(emptyPlaylistMessage) }
+                )
                 overflowPlaylist = null
             },
             onRename = {
@@ -131,7 +140,7 @@ fun PlaylistsScreen(
                 overflowPlaylist = null
             },
             onDelete = {
-                viewModel.delete(playlist.id)
+                deleteTarget = playlist
                 overflowPlaylist = null
             }
         )
@@ -148,20 +157,34 @@ fun PlaylistsScreen(
             onDismiss = { renameTarget = null }
         )
     }
+    deleteTarget?.let { playlist ->
+        ResonanceDialog(
+            title = stringResource(R.string.playlist_delete_title),
+            text = stringResource(R.string.playlist_delete_body),
+            confirmLabel = stringResource(R.string.playlist_delete),
+            onConfirm = {
+                viewModel.delete(playlist.id)
+                deleteTarget = null
+            },
+            onDismiss = { deleteTarget = null },
+            dismissLabel = stringResource(R.string.action_dismiss)
+        )
+    }
 }
 
 @Composable
 private fun PlaylistRow(
     playlist: Playlist,
     onClick: () -> Unit,
-    onOverflow: () -> Unit
+    onOverflow: () -> Unit,
+    modifier: Modifier = Modifier
 ) {
     val colors = ResonanceTheme.colors
     val typography = ResonanceTheme.typography
     val spacing = ResonanceTheme.spacing
     Row(
         verticalAlignment = Alignment.CenterVertically,
-        modifier = Modifier
+        modifier = modifier
             .fillMaxWidth()
             .height(ResonanceTheme.dimensions.songRowHeight)
             .padding(horizontal = spacing.lg)
diff --git a/app/src/main/java/com/resonance/player/feature/playlists/PlaylistsViewModels.kt b/app/src/main/java/com/resonance/player/feature/playlists/PlaylistsViewModels.kt
index 3f2dcc1..1316834 100644
--- a/app/src/main/java/com/resonance/player/feature/playlists/PlaylistsViewModels.kt
+++ b/app/src/main/java/com/resonance/player/feature/playlists/PlaylistsViewModels.kt
@@ -17,6 +17,7 @@ import com.resonance.player.domain.playlists.ObservePlaylistSongsUseCase
 import com.resonance.player.domain.playlists.ObservePlaylistsUseCase
 import com.resonance.player.domain.playlists.RemoveSongFromPlaylistUseCase
 import com.resonance.player.domain.playlists.RenamePlaylistUseCase
+import com.resonance.player.domain.library.ObserveSongsUseCase
 import kotlinx.coroutines.flow.MutableStateFlow
 import kotlinx.coroutines.flow.SharingStarted
 import kotlinx.coroutines.flow.StateFlow
@@ -66,12 +67,14 @@ class PlaylistsViewModel(
         }
     }
 
-    fun play(playlistId: Long, onPlaying: () -> Unit = {}) {
+    fun play(playlistId: Long, onPlaying: () -> Unit = {}, onEmpty: () -> Unit = {}) {
         viewModelScope.launch {
             val songs = (songsOf(playlistId) as? Result.Success)?.value
             if (!songs.isNullOrEmpty()) {
                 playSongs(songs, 0)
                 onPlaying()
+            } else {
+                onEmpty()
             }
         }
     }
@@ -90,11 +93,17 @@ class PlaylistDetailViewModel(
     private val renameOp: RenamePlaylistUseCase,
     private val deleteOp: DeletePlaylistUseCase,
     private val removeSongOp: RemoveSongFromPlaylistUseCase,
-    private val moveItemOp: MovePlaylistItemUseCase
+    private val moveItemOp: MovePlaylistItemUseCase,
+    observeAllSongs: ObserveSongsUseCase,
+    private val addSongOp: AddSongToPlaylistUseCase
 ) : ViewModel() {
     private val songsMutable = MutableStateFlow<List<Song>>(emptyList())
     val songs: StateFlow<List<Song>> = songsMutable.asStateFlow()
 
+    /** Full library, for the "add songs" picker. */
+    val allSongs: StateFlow<List<Song>> = observeAllSongs()
+        .stateIn(viewModelScope, SharingStarted.WhileSubscribed(5_000), emptyList())
+
     private val errorMutable = MutableStateFlow<String?>(null)
     val error: StateFlow<String?> = errorMutable.asStateFlow()
 
@@ -137,6 +146,15 @@ class PlaylistDetailViewModel(
         }
     }
 
+    fun addSongs(songIds: List<Long>, onDone: () -> Unit = {}) {
+        if (songIds.isEmpty()) return
+        viewModelScope.launch {
+            songIds.forEach { addSongOp(playlistId, it) }
+            refresh()
+            onDone()
+        }
+    }
+
     fun move(fromPosition: Int, toPosition: Int) {
         viewModelScope.launch {
             moveItemOp(playlistId, fromPosition, toPosition)
diff --git a/app/src/main/java/com/resonance/player/feature/queue/QueueScreen.kt b/app/src/main/java/com/resonance/player/feature/queue/QueueScreen.kt
index b2e47b5..99cbb5b 100644
--- a/app/src/main/java/com/resonance/player/feature/queue/QueueScreen.kt
+++ b/app/src/main/java/com/resonance/player/feature/queue/QueueScreen.kt
@@ -17,11 +17,11 @@ import androidx.compose.material3.IconButton
 import androidx.compose.material3.Text
 import androidx.compose.material3.TextButton
 import androidx.compose.runtime.Composable
-import androidx.compose.runtime.collectAsState
 import androidx.compose.runtime.getValue
 import androidx.compose.runtime.mutableStateOf
 import androidx.compose.runtime.remember
 import androidx.compose.runtime.setValue
+import androidx.lifecycle.compose.collectAsStateWithLifecycle
 import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.res.stringResource
@@ -49,7 +49,7 @@ fun QueueScreen(viewModel: QueueViewModel, onBack: () -> Unit) {
     val colors = ResonanceTheme.colors
     val typography = ResonanceTheme.typography
     val spacing = ResonanceTheme.spacing
-    val snapshot by viewModel.snapshot.collectAsState()
+    val snapshot by viewModel.snapshot.collectAsStateWithLifecycle()
     var confirmClear by remember { mutableStateOf(false) }
 
     Column(Modifier.fillMaxSize()) {
diff --git a/app/src/main/java/com/resonance/player/feature/search/SearchScreen.kt b/app/src/main/java/com/resonance/player/feature/search/SearchScreen.kt
index c38a3df..20e179c 100644
--- a/app/src/main/java/com/resonance/player/feature/search/SearchScreen.kt
+++ b/app/src/main/java/com/resonance/player/feature/search/SearchScreen.kt
@@ -14,8 +14,11 @@ import androidx.compose.foundation.lazy.LazyColumn
 import androidx.compose.foundation.lazy.items
 import androidx.compose.material3.Text
 import androidx.compose.runtime.Composable
-import androidx.compose.runtime.collectAsState
 import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.remember
+import androidx.compose.runtime.setValue
+import androidx.lifecycle.compose.collectAsStateWithLifecycle
 import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.res.stringResource
@@ -24,12 +27,14 @@ import com.resonance.player.R
 import com.resonance.player.core.common.formatDurationMs
 import com.resonance.player.core.model.Song
 import com.resonance.player.core.ui.components.ArtworkImage
+import com.resonance.player.core.ui.components.PlaylistPickerSheet
 import com.resonance.player.core.ui.components.ResonanceEmptyState
 import com.resonance.player.core.ui.components.ResonanceSearchField
 import com.resonance.player.core.ui.components.ResonanceSectionHeader
 import com.resonance.player.core.ui.components.ResonanceSongRow
 import com.resonance.player.core.ui.components.ResonanceTopBar
 import com.resonance.player.core.ui.components.SongFormatBadge
+import com.resonance.player.core.ui.components.SongOverflowSheet
 import com.resonance.player.core.ui.components.songRowState
 import com.resonance.player.core.ui.theme.ResonanceTheme
 import androidx.compose.material.icons.Icons
@@ -49,9 +54,10 @@ fun SearchScreen(
     onOpenQueue: () -> Unit,
     onOpenPlaylist: (Long) -> Unit
 ) {
-    val query by viewModel.currentQuery.collectAsState()
-    val results by viewModel.grouped.collectAsState()
+    val query by viewModel.currentQuery.collectAsStateWithLifecycle()
+    val results by viewModel.grouped.collectAsStateWithLifecycle()
     val spacing = ResonanceTheme.spacing
+    var overflowSong by remember { mutableStateOf<Song?>(null) }
     Column(Modifier.fillMaxSize()) {
         ResonanceTopBar(
             title = stringResource(R.string.nav_search),
@@ -110,7 +116,9 @@ fun SearchScreen(
                             isLoading = false
                         ),
                         isPlayingAnimation = isCurrent,
-                        badge = { SongFormatBadge(song) }
+                        badge = { SongFormatBadge(song) },
+                        onOverflowClick = { overflowSong = song },
+                        modifier = Modifier.animateItem()
                     )
                 }
             }
@@ -126,7 +134,8 @@ fun SearchScreen(
                         onClick = {
                             viewModel.playAlbum(album.name, album.albumArtist)
                             onOpenQueue()
-                        }
+                        },
+                        modifier = Modifier.animateItem()
                     )
                 }
             }
@@ -142,7 +151,8 @@ fun SearchScreen(
                         onClick = {
                             viewModel.playArtist(artist.name)
                             onOpenQueue()
-                        }
+                        },
+                        modifier = Modifier.animateItem()
                     )
                 }
             }
@@ -155,7 +165,8 @@ fun SearchScreen(
                         title = playlist.name,
                         subtitle = playlist.itemCount.toString(),
                         artUri = null,
-                        onClick = { onOpenPlaylist(playlist.id) }
+                        onClick = { onOpenPlaylist(playlist.id) },
+                        modifier = Modifier.animateItem()
                     )
                 }
             }
@@ -171,12 +182,55 @@ fun SearchScreen(
                         onClick = {
                             viewModel.playGenre(genre.name)
                             onOpenQueue()
-                        }
+                        },
+                        modifier = Modifier.animateItem()
                     )
                 }
             }
         }
     }
+    overflowSong?.let { song ->
+        var showPicker by remember { mutableStateOf(false) }
+        val playlists by viewModel.playlists.collectAsStateWithLifecycle()
+        val playlistError by viewModel.playlistError.collectAsStateWithLifecycle()
+        if (showPicker) {
+            PlaylistPickerSheet(
+                songTitle = song.title,
+                playlists = playlists,
+                error = playlistError,
+                onPick = { playlistId ->
+                    viewModel.addToPlaylist(playlistId, song.id) {
+                        showPicker = false
+                        overflowSong = null
+                    }
+                },
+                onNewPlaylist = { name ->
+                    viewModel.createPlaylistAndAdd(name, song.id) {
+                        showPicker = false
+                        overflowSong = null
+                    }
+                },
+                onDismiss = {
+                    showPicker = false
+                    viewModel.clearPlaylistError()
+                }
+            )
+        } else {
+            SongOverflowSheet(
+                song = song,
+                onDismiss = { overflowSong = null },
+                onPlayNext = {
+                    viewModel.playNext(song)
+                    overflowSong = null
+                },
+                onAddToQueue = {
+                    viewModel.addToQueue(song)
+                    overflowSong = null
+                },
+                onAddToPlaylist = { showPicker = true }
+            )
+        }
+    }
 }
 
 @Composable
@@ -184,14 +238,15 @@ private fun CategoryRow(
     title: String,
     subtitle: String,
     artUri: String?,
-    onClick: () -> Unit
+    onClick: () -> Unit,
+    modifier: Modifier = Modifier
 ) {
     val colors = ResonanceTheme.colors
     val typography = ResonanceTheme.typography
     val spacing = ResonanceTheme.spacing
     Row(
         verticalAlignment = Alignment.CenterVertically,
-        modifier = Modifier
+        modifier = modifier
             .fillMaxWidth()
             .height(ResonanceTheme.dimensions.songRowHeight)
             .padding(horizontal = spacing.lg)
diff --git a/app/src/main/java/com/resonance/player/feature/search/SearchViewModel.kt b/app/src/main/java/com/resonance/player/feature/search/SearchViewModel.kt
index 7136a58..fc96436 100644
--- a/app/src/main/java/com/resonance/player/feature/search/SearchViewModel.kt
+++ b/app/src/main/java/com/resonance/player/feature/search/SearchViewModel.kt
@@ -3,11 +3,18 @@
 import androidx.lifecycle.ViewModel
 import androidx.lifecycle.viewModelScope
 import com.resonance.player.core.common.Result
+import com.resonance.player.core.common.userMessage
+import com.resonance.player.core.model.Playlist
 import com.resonance.player.core.model.Song
 import com.resonance.player.domain.library.GetAlbumSongsUseCase
 import com.resonance.player.domain.library.GetArtistSongsUseCase
 import com.resonance.player.domain.library.GetGenreSongsUseCase
+import com.resonance.player.domain.playback.AppendToQueueUseCase
+import com.resonance.player.domain.playback.PlayNextUseCase
 import com.resonance.player.domain.playback.PlaySongsUseCase
+import com.resonance.player.domain.playlists.AddSongToPlaylistUseCase
+import com.resonance.player.domain.playlists.CreatePlaylistUseCase
+import com.resonance.player.domain.playlists.ObservePlaylistsUseCase
 import com.resonance.player.domain.search.SearchAllUseCase
 import com.resonance.player.domain.search.SearchLibraryUseCase
 import com.resonance.player.domain.search.SearchResults
@@ -16,6 +23,7 @@ import kotlinx.coroutines.FlowPreview
 import kotlinx.coroutines.flow.MutableStateFlow
 import kotlinx.coroutines.flow.SharingStarted
 import kotlinx.coroutines.flow.StateFlow
+import kotlinx.coroutines.flow.asStateFlow
 import kotlinx.coroutines.flow.debounce
 import kotlinx.coroutines.flow.flatMapLatest
 import kotlinx.coroutines.flow.stateIn
@@ -32,10 +40,21 @@ class SearchViewModel(
     private val playSongs: PlaySongsUseCase,
     private val getAlbumSongs: GetAlbumSongsUseCase,
     private val getArtistSongs: GetArtistSongsUseCase,
-    private val getGenreSongs: GetGenreSongsUseCase
+    private val getGenreSongs: GetGenreSongsUseCase,
+    private val playNextUseCase: PlayNextUseCase,
+    private val appendToQueueUseCase: AppendToQueueUseCase,
+    observePlaylists: ObservePlaylistsUseCase,
+    private val addSongToPlaylist: AddSongToPlaylistUseCase,
+    private val createPlaylist: CreatePlaylistUseCase
 ) : ViewModel() {
     private val query = MutableStateFlow("")
 
+    val playlists: StateFlow<List<Playlist>> = observePlaylists()
+        .stateIn(viewModelScope, SharingStarted.WhileSubscribed(5_000), emptyList())
+
+    private val playlistErrorMutable = MutableStateFlow<String?>(null)
+    val playlistError: StateFlow<String?> = playlistErrorMutable.asStateFlow()
+
     @OptIn(ExperimentalCoroutinesApi::class)
     val results: StateFlow<List<Song>> = query
         .flatMapLatest { searchLibrary(it) }
@@ -77,4 +96,43 @@ class SearchViewModel(
             if (!songs.isNullOrEmpty()) playSongs(songs, 0)
         }
     }
+
+    fun playNext(song: Song) {
+        viewModelScope.launch { playNextUseCase(song) }
+    }
+
+    fun addToQueue(song: Song) {
+        viewModelScope.launch { appendToQueueUseCase(listOf(song)) }
+    }
+
+    fun addToPlaylist(playlistId: Long, songId: Long, onDone: () -> Unit = {}) {
+        viewModelScope.launch {
+            when (val result = addSongToPlaylist(playlistId, songId)) {
+                is Result.Success -> {
+                    playlistErrorMutable.value = null
+                    onDone()
+                }
+                is Result.Failure -> playlistErrorMutable.value = result.error.userMessage()
+                is Result.Loading -> Unit
+            }
+        }
+    }
+
+    fun createPlaylistAndAdd(name: String, songId: Long, onDone: () -> Unit = {}) {
+        viewModelScope.launch {
+            when (val result = createPlaylist(name)) {
+                is Result.Success -> {
+                    playlistErrorMutable.value = null
+                    addSongToPlaylist(result.value.id, songId)
+                    onDone()
+                }
+                is Result.Failure -> playlistErrorMutable.value = result.error.userMessage()
+                is Result.Loading -> Unit
+            }
+        }
+    }
+
+    fun clearPlaylistError() {
+        playlistErrorMutable.value = null
+    }
 }
diff --git a/app/src/main/java/com/resonance/player/feature/settings/SettingsScreen.kt b/app/src/main/java/com/resonance/player/feature/settings/SettingsScreen.kt
index 3f8891e..b00dd47 100644
--- a/app/src/main/java/com/resonance/player/feature/settings/SettingsScreen.kt
+++ b/app/src/main/java/com/resonance/player/feature/settings/SettingsScreen.kt
@@ -1,6 +1,12 @@
 package com.resonance.player.feature.settings
 
+import androidx.compose.foundation.background
+import androidx.compose.foundation.border
+import androidx.compose.foundation.clickable
+import androidx.compose.foundation.layout.Arrangement
+import androidx.compose.foundation.layout.Box
 import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.Row
 import androidx.compose.foundation.layout.Spacer
 import androidx.compose.foundation.layout.fillMaxSize
 import androidx.compose.foundation.layout.fillMaxWidth
@@ -8,6 +14,7 @@ import androidx.compose.foundation.layout.height
 import androidx.compose.foundation.layout.padding
 import androidx.compose.foundation.layout.size
 import androidx.compose.foundation.rememberScrollState
+import androidx.compose.foundation.shape.CircleShape
 import androidx.compose.foundation.verticalScroll
 import androidx.compose.material.icons.Icons
 import androidx.compose.material.icons.filled.FolderSpecial
@@ -17,14 +24,18 @@ import androidx.compose.material.icons.filled.Shield
 import androidx.compose.material.icons.filled.TimerOff
 import androidx.compose.material3.Icon
 import androidx.compose.material3.LinearProgressIndicator
+import androidx.compose.material3.Slider
+import androidx.compose.material3.SliderDefaults
 import androidx.compose.material3.Surface
 import androidx.compose.material3.Text
 import androidx.compose.runtime.Composable
-import androidx.compose.runtime.collectAsState
 import androidx.compose.runtime.getValue
+import androidx.lifecycle.compose.collectAsStateWithLifecycle
 import androidx.compose.ui.Modifier
+import androidx.compose.ui.draw.clip
 import androidx.compose.ui.platform.LocalContext
 import androidx.compose.ui.res.stringResource
+import androidx.compose.ui.unit.dp
 import android.app.Activity
 import com.resonance.player.BuildConfig
 import com.resonance.player.R
@@ -40,7 +51,9 @@ import com.resonance.player.core.ui.components.ResonanceSwitch
 import com.resonance.player.core.ui.components.ResonanceTopBar
 import com.resonance.player.core.ui.components.openAppSettings
 import com.resonance.player.core.ui.components.rememberPermissionGrant
+import com.resonance.player.core.ui.theme.ACCENT_PRESETS
 import com.resonance.player.core.ui.theme.ResonanceTheme
+import com.resonance.player.core.ui.theme.accentPreviewColor
 import com.resonance.player.domain.settings.ThemeMode
 import java.time.Instant
 import java.time.ZoneId
@@ -49,12 +62,13 @@ import java.time.format.FormatStyle
 
 @Composable
 fun SettingsScreen(viewModel: SettingsViewModel) {
-    val theme by viewModel.themeMode.collectAsState()
-    val scanState by viewModel.scanState.collectAsState()
-    val lastScan by viewModel.lastScan.collectAsState()
-    val stats by viewModel.stats.collectAsState()
-    val permission by viewModel.permissionStatus.collectAsState()
-    val ignoreShort by viewModel.ignoreShortFiles.collectAsState()
+    val theme by viewModel.themeMode.collectAsStateWithLifecycle()
+    val accentHue by viewModel.accentHue.collectAsStateWithLifecycle()
+    val scanState by viewModel.scanState.collectAsStateWithLifecycle()
+    val lastScan by viewModel.lastScan.collectAsStateWithLifecycle()
+    val stats by viewModel.stats.collectAsStateWithLifecycle()
+    val permission by viewModel.permissionStatus.collectAsStateWithLifecycle()
+    val ignoreShort by viewModel.ignoreShortFiles.collectAsStateWithLifecycle()
     val context = LocalContext.current
     val activity = context as? Activity
     val requestGrant = rememberPermissionGrant(viewModel.permissionManager) {
@@ -203,6 +217,8 @@ fun SettingsScreen(viewModel: SettingsViewModel) {
                     selectedIndex = ThemeMode.entries.indexOf(theme),
                     onSelect = { viewModel.setThemeMode(ThemeMode.entries[it]) }
                 )
+                Spacer(Modifier.height(spacing.md))
+                AccentPicker(hue = accentHue, onSelect = viewModel::setAccentHue)
             }
             Spacer(Modifier.height(spacing.sectionSpacing))
             SettingsGroupLabel(stringResource(R.string.settings_group_about))
@@ -244,6 +260,40 @@ fun SettingsScreen(viewModel: SettingsViewModel) {
     }
 }
 
+/** Accent hue picker: curated swatches (tap) + a full hue slider (drag). */
+@Composable
+private fun AccentPicker(hue: Float, onSelect: (Float) -> Unit) {
+    val colors = ResonanceTheme.colors
+    val spacing = ResonanceTheme.spacing
+    Row(horizontalArrangement = Arrangement.spacedBy(spacing.sm)) {
+        ACCENT_PRESETS.forEach { (_, presetHue) ->
+            val selected = kotlin.math.abs(presetHue - hue) < 1f
+            Box(
+                modifier = Modifier
+                    .size(32.dp)
+                    .clip(CircleShape)
+                    .background(accentPreviewColor(presetHue))
+                    .border(
+                        width = if (selected) 2.dp else 0.dp,
+                        color = colors.textPrimary,
+                        shape = CircleShape
+                    )
+                    .clickable { onSelect(presetHue) }
+            )
+        }
+    }
+    Spacer(Modifier.height(spacing.sm))
+    Slider(
+        value = hue,
+        onValueChange = onSelect,
+        valueRange = 0f..360f,
+        colors = SliderDefaults.colors(
+            thumbColor = colors.accent,
+            activeTrackColor = colors.accent
+        )
+    )
+}
+
 @Composable
 private fun SettingsGroupLabel(text: String) {
     val colors = ResonanceTheme.colors
diff --git a/app/src/main/java/com/resonance/player/feature/settings/SettingsViewModel.kt b/app/src/main/java/com/resonance/player/feature/settings/SettingsViewModel.kt
index b218cf4..5162ff1 100644
--- a/app/src/main/java/com/resonance/player/feature/settings/SettingsViewModel.kt
+++ b/app/src/main/java/com/resonance/player/feature/settings/SettingsViewModel.kt
@@ -11,6 +11,7 @@ import com.resonance.player.domain.library.GetLibraryStatsUseCase
 import com.resonance.player.domain.library.ObserveLastScanUseCase
 import com.resonance.player.domain.library.ObserveScanStateUseCase
 import com.resonance.player.domain.library.RescanLibraryUseCase
+import com.resonance.player.core.ui.theme.DEFAULT_ACCENT_HUE
 import com.resonance.player.domain.settings.ThemeMode
 import com.resonance.player.domain.settings.UserPreferencesRepository
 import kotlinx.coroutines.flow.SharingStarted
@@ -33,6 +34,9 @@ class SettingsViewModel(
     val themeMode: StateFlow<ThemeMode> = repository.themeMode
         .stateIn(viewModelScope, SharingStarted.WhileSubscribed(5_000), ThemeMode.SYSTEM)
 
+    val accentHue: StateFlow<Float> = repository.accentHue
+        .stateIn(viewModelScope, SharingStarted.WhileSubscribed(5_000), DEFAULT_ACCENT_HUE)
+
     val scanState: StateFlow<ScanState> = observeScanState()
         .stateIn(viewModelScope, SharingStarted.WhileSubscribed(5_000), ScanState.Idle)
 
@@ -55,6 +59,10 @@ class SettingsViewModel(
         viewModelScope.launch { repository.setThemeMode(mode) }
     }
 
+    fun setAccentHue(hue: Float) {
+        viewModelScope.launch { repository.setAccentHue(hue) }
+    }
+
     fun setIgnoreShortFiles(ignore: Boolean) {
         viewModelScope.launch {
             try {
diff --git a/app/src/main/java/com/resonance/player/navigation/AppNavGraph.kt b/app/src/main/java/com/resonance/player/navigation/AppNavGraph.kt
index 089f05c..f4aa6be 100644
--- a/app/src/main/java/com/resonance/player/navigation/AppNavGraph.kt
+++ b/app/src/main/java/com/resonance/player/navigation/AppNavGraph.kt
@@ -1,5 +1,11 @@
 package com.resonance.player.navigation
 
+import androidx.compose.animation.AnimatedVisibility
+import androidx.compose.animation.core.tween
+import androidx.compose.animation.fadeIn
+import androidx.compose.animation.fadeOut
+import androidx.compose.animation.slideInVertically
+import androidx.compose.animation.slideOutVertically
 import androidx.compose.foundation.layout.Box
 import androidx.compose.foundation.layout.Column
 import androidx.compose.foundation.layout.Row
@@ -15,8 +21,8 @@ import androidx.compose.material.icons.filled.Home
 import androidx.compose.material.icons.automirrored.filled.QueueMusic
 import androidx.compose.material.icons.filled.Settings
 import androidx.compose.runtime.Composable
-import androidx.compose.runtime.collectAsState
 import androidx.compose.runtime.getValue
+import androidx.lifecycle.compose.collectAsStateWithLifecycle
 import androidx.compose.runtime.remember
 import androidx.compose.runtime.rememberCoroutineScope
 import androidx.compose.ui.Modifier
@@ -35,7 +41,10 @@ import androidx.compose.material3.Icon
 import androidx.compose.material3.NavigationRail
 import androidx.compose.material3.NavigationRailItem
 import androidx.compose.material3.NavigationRailItemDefaults
+import androidx.compose.material3.SnackbarHost
+import androidx.compose.material3.SnackbarHostState
 import androidx.compose.material3.Text
+import androidx.compose.ui.Alignment
 import com.resonance.player.R
 import com.resonance.player.core.ui.theme.ResonanceTheme
 import com.resonance.player.app.AppContainer
@@ -45,6 +54,8 @@ import com.resonance.player.core.ui.components.ArtworkImage
 import com.resonance.player.core.ui.components.NavDockDestination
 import com.resonance.player.core.ui.components.ResonanceMiniPlayer
 import com.resonance.player.core.ui.components.ResonanceNavDock
+import com.resonance.player.core.ui.components.ResonanceSnackbar
+import com.resonance.player.core.ui.components.ResonanceSnackbarVisuals
 import com.resonance.player.core.ui.components.shouldShowMiniPlayer
 import com.resonance.player.feature.favorites.FavoritesScreen
 import com.resonance.player.feature.favorites.FavoritesViewModel
@@ -104,11 +115,20 @@ fun ResonanceAppShell(container: AppContainer) {
     val currentRoute = backStack?.destination?.route
     val selectedTab = AppDestination.tabForRoute(currentRoute)?.route
     val scope = rememberCoroutineScope()
-    val snapshot by container.playbackController.snapshot.collectAsState()
-    val showMiniPlayer = shouldShowMiniPlayer(snapshot)
+    val snapshot by container.playbackController.snapshot.collectAsStateWithLifecycle()
+    val onPlayerOrQueue = currentRoute == AppDestination.Player.route ||
+        currentRoute == AppDestination.Queue.route
+    val showMiniPlayer = shouldShowMiniPlayer(snapshot) && !onPlayerOrQueue
     val dockDestinations = dockDestinations()
+    val snackbarHostState = remember { SnackbarHostState() }
 
-    fun navigate(route: String) {
+    /** Shared feedback channel for actions that otherwise silently no-op (e.g. playing an empty playlist). */
+    fun showMessage(message: String) {
+        scope.launch { snackbarHostState.showSnackbar(ResonanceSnackbarVisuals(message)) }
+    }
+
+    /** Bottom-nav/rail tab switches only: single-top with saved/restored tab state. */
+    fun navigateToTab(route: String) {
         navController.navigate(route) {
             popUpTo(AppDestination.Home.route) { saveState = true }
             launchSingleTop = true
@@ -116,6 +136,15 @@ fun ResonanceAppShell(container: AppContainer) {
         }
     }
 
+    /**
+     * Drill-down pushes (Player/Queue/Search/PlaylistDetail/Favorites). Plain
+     * push so back returns to the screen the user actually came from, not to
+     * Home — popUpTo(Home) is only correct for the 4 tab destinations above.
+     */
+    fun navigate(route: String) {
+        navController.navigate(route) { launchSingleTop = true }
+    }
+
     fun openPlayerForCurrentTrack() {
         val song = snapshot.song ?: return
         navigate(AppDestination.Player.routeFor(song.id))
@@ -123,7 +152,9 @@ fun ResonanceAppShell(container: AppContainer) {
 
     @Composable
     fun MiniPlayerSlot(modifier: Modifier = Modifier) {
-        if (!showMiniPlayer) return
+        // Visibility/route gating lives in the AnimatedVisibility wrapper below
+        // (so it can still render the last-known song while animating out);
+        // this guard only protects against a genuinely absent song.
         val song = snapshot.song ?: return
         val progress = if (snapshot.durationMs > 0L) {
             snapshot.positionMs.toFloat() / snapshot.durationMs.toFloat()
@@ -156,7 +187,11 @@ fun ResonanceAppShell(container: AppContainer) {
         NavHost(
             navController = navController,
             startDestination = AppDestination.Home.route,
-            modifier = modifier
+            modifier = modifier,
+            enterTransition = { fadeIn(tween(180)) },
+            exitTransition = { fadeOut(tween(120)) },
+            popEnterTransition = { fadeIn(tween(180)) },
+            popExitTransition = { fadeOut(tween(120)) }
         ) {
             composable(AppDestination.Home.route) {
                 val vm: HomeViewModel = viewModel(
@@ -171,7 +206,12 @@ fun ResonanceAppShell(container: AppContainer) {
                             container.playSongs,
                             container.getAlbumSongs,
                             container.setShuffleMode,
-                            container.rescanLibrary
+                            container.rescanLibrary,
+                            container.playNext,
+                            container.appendToQueue,
+                            container.observePlaylists,
+                            container.addSongToPlaylist,
+                            container.createPlaylist
                         )
                     }
                 )
@@ -205,6 +245,9 @@ fun ResonanceAppShell(container: AppContainer) {
                             container.observeGenres,
                             container.observeFolders,
                             container.getAlbumSongs,
+                            container.getArtistSongs,
+                            container.getGenreSongs,
+                            container.getFolderSongs,
                             container.setShuffleMode,
                             container.playNext,
                             container.appendToQueue,
@@ -234,7 +277,12 @@ fun ResonanceAppShell(container: AppContainer) {
                             container.playSongs,
                             container.getAlbumSongs,
                             container.getArtistSongs,
-                            container.getGenreSongs
+                            container.getGenreSongs,
+                            container.playNext,
+                            container.appendToQueue,
+                            container.observePlaylists,
+                            container.addSongToPlaylist,
+                            container.createPlaylist
                         )
                     }
                 )
@@ -324,7 +372,8 @@ fun ResonanceAppShell(container: AppContainer) {
                 PlaylistsScreen(
                     vm,
                     onOpenDetail = { navigate(AppDestination.PlaylistDetail.routeFor(it)) },
-                    onOpenQueue = { navigate(AppDestination.Queue.route) }
+                    onOpenQueue = { navigate(AppDestination.Queue.route) },
+                    onShowMessage = ::showMessage
                 )
             }
             composable(
@@ -346,12 +395,14 @@ fun ResonanceAppShell(container: AppContainer) {
                             container.renamePlaylist,
                             container.deletePlaylist,
                             container.removeSongFromPlaylist,
-                            container.movePlaylistItem
+                            container.movePlaylistItem,
+                            container.observeSongs,
+                            container.addSongToPlaylist
                         )
                     }
                 )
                 val playlistsFlow = remember { container.observePlaylists() }
-                val playlists by playlistsFlow.collectAsState(initial = emptyList())
+                val playlists by playlistsFlow.collectAsStateWithLifecycle(initialValue = emptyList())
                 PlaylistDetailScreen(
                     vm,
                     playlists.firstOrNull { it.id == playlistId },
@@ -363,7 +414,15 @@ fun ResonanceAppShell(container: AppContainer) {
             composable(AppDestination.Favorites.route) {
                 val vm: FavoritesViewModel = viewModel(
                     factory = factory {
-                        FavoritesViewModel(container.observeFavoriteSongs, container.playSongs)
+                        FavoritesViewModel(
+                            container.observeFavoriteSongs,
+                            container.playSongs,
+                            container.playNext,
+                            container.appendToQueue,
+                            container.observePlaylists,
+                            container.addSongToPlaylist,
+                            container.createPlaylist
+                        )
                     }
                 )
                 FavoritesScreen(
@@ -376,34 +435,56 @@ fun ResonanceAppShell(container: AppContainer) {
         }
     }
 
-    Row(
-        modifier = Modifier
-            .fillMaxSize()
-            .windowInsetsPadding(WindowInsets.statusBars)
-    ) {
-        if (widthSize == WindowWidthSize.EXPANDED) {
-            ResonanceRail(
-                destinations = dockDestinations,
-                selectedRoute = selectedTab,
-                onSelect = ::navigate
-            )
-        }
-        Column(modifier = Modifier.weight(1f)) {
-            AppGraph(modifier = Modifier.weight(1f))
-            if (showMiniPlayer) {
-                Box(modifier = Modifier.padding(horizontal = 8.dp)) {
-                    MiniPlayerSlot()
-                }
-            }
-            if (widthSize != WindowWidthSize.EXPANDED) {
-                ResonanceNavDock(
+    Box(modifier = Modifier.fillMaxSize()) {
+        Row(
+            modifier = Modifier
+                .fillMaxSize()
+                .windowInsetsPadding(WindowInsets.statusBars)
+        ) {
+            if (widthSize == WindowWidthSize.EXPANDED) {
+                ResonanceRail(
                     destinations = dockDestinations,
                     selectedRoute = selectedTab,
-                    onSelect = ::navigate,
-                    modifier = Modifier.windowInsetsPadding(WindowInsets.navigationBars)
+                    onSelect = ::navigateToTab
                 )
             }
+            Column(modifier = Modifier.weight(1f)) {
+                AppGraph(modifier = Modifier.weight(1f))
+                AnimatedVisibility(
+                    visible = showMiniPlayer,
+                    enter = fadeIn() + slideInVertically { it },
+                    exit = fadeOut() + slideOutVertically { it }
+                ) {
+                    Box(modifier = Modifier.padding(horizontal = 8.dp)) {
+                        MiniPlayerSlot()
+                    }
+                }
+                if (widthSize != WindowWidthSize.EXPANDED) {
+                    ResonanceNavDock(
+                        destinations = dockDestinations,
+                        selectedRoute = selectedTab,
+                        onSelect = ::navigateToTab,
+                        modifier = Modifier.windowInsetsPadding(WindowInsets.navigationBars)
+                    )
+                }
+            }
         }
+        val snackbarBottomInset = if (widthSize != WindowWidthSize.EXPANDED) {
+            ResonanceTheme.dimensions.navigationDockHeight + if (showMiniPlayer) {
+                ResonanceTheme.dimensions.miniPlayerHeight
+            } else {
+                0.dp
+            }
+        } else {
+            0.dp
+        }
+        SnackbarHost(
+            hostState = snackbarHostState,
+            snackbar = { data -> ResonanceSnackbar(data) },
+            modifier = Modifier
+                .align(Alignment.BottomCenter)
+                .padding(bottom = snackbarBottomInset)
+        )
     }
 }
 
diff --git a/app/src/main/res/drawable/ic_launcher_foreground.xml b/app/src/main/res/drawable/ic_launcher_foreground.xml
index c3e94ad..ffb14de 100644
--- a/app/src/main/res/drawable/ic_launcher_foreground.xml
+++ b/app/src/main/res/drawable/ic_launcher_foreground.xml
@@ -5,9 +5,10 @@
     android:viewportWidth="108"
     android:viewportHeight="108">
     <path
-        android:fillColor="#FF6750A4"
-        android:pathData="M54,28a26,26 0 1,0 0.1,0z" />
+        android:strokeColor="#FFFF7A30"
+        android:strokeWidth="5"
+        android:pathData="M37,34 H71 A8,8 0 0,1 79,42 V66 A8,8 0 0,1 71,74 H37 A8,8 0 0,1 29,66 V42 A8,8 0 0,1 37,34 Z" />
     <path
-        android:fillColor="#FFFFFFFF"
-        android:pathData="M48,42h6v22h-6zM54,42h14v6H54zM62,36h6v22h-6zM48,58a8,8 0 1,0 0.1,0zM62,52a8,8 0 1,0 0.1,0z" />
+        android:fillColor="#FFFF7A30"
+        android:pathData="M46,44 L68,54 L46,64 Z" />
 </vector>
diff --git a/app/src/main/res/values/strings.xml b/app/src/main/res/values/strings.xml
index 43342ab..4b15b3b 100644
--- a/app/src/main/res/values/strings.xml
+++ b/app/src/main/res/values/strings.xml
@@ -1,6 +1,6 @@
 <?xml version="1.0" encoding="utf-8"?>
 <resources>
-    <string name="app_name">Resonance</string>
+    <string name="app_name">Crate</string>
     <string name="tagline">My music. My device. My player.</string>
     <string name="nav_home">Home</string>
     <string name="nav_library">Library</string>
@@ -31,7 +31,7 @@
     <string name="queue_drag">Reorder</string>
     <string name="queue_empty">The queue is empty. Play something from your library.</string>
     <string name="now_playing_from_queue">Playing from queue</string>
-    <string name="perm_rationale">Resonance needs access to audio files on this device to build your local music library. Your files never leave this device.</string>
+    <string name="perm_rationale">Crate needs access to audio files on this device to build your local music library. Your files never leave this device.</string>
     <string name="perm_grant">Grant access</string>
     <string name="perm_permanently_denied">Audio access was denied. You can enable it anytime in the app settings.</string>
     <string name="perm_open_settings">Open settings</string>
@@ -91,6 +91,10 @@
     <string name="playlist_detail_empty_title">Empty playlist</string>
     <string name="playlist_detail_empty_body">Add songs from any song menu to fill it up.</string>
     <string name="playlist_picker_title">Add to playlist: %1$s</string>
+    <string name="playlist_add_songs">Add songs</string>
+    <string name="playlist_add_songs_title">Add songs to %1$s</string>
+    <string name="playlist_empty_action">Playlist is empty</string>
+    <string name="action_add">Add</string>
     <string name="cd_favorite">Favorite</string>
     <string name="tech_specs">Tech specs</string>
     <string name="queue_counter">%1$d / %2$d</string>
diff --git a/app/src/main/res/values/themes.xml b/app/src/main/res/values/themes.xml
index 10c49e0..05df8df 100644
--- a/app/src/main/res/values/themes.xml
+++ b/app/src/main/res/values/themes.xml
@@ -1,7 +1,7 @@
 <?xml version="1.0" encoding="utf-8"?>
 <resources>
-    <!-- Window theme only; all UI is Jetpack Compose (Theme.Resonance composable). -->
-    <style name="Theme.Resonance" parent="android:Theme.Material.Light.NoActionBar">
+    <!-- Window theme only; all UI is Jetpack Compose (ResonanceTheme composable). -->
+    <style name="Theme.Crate" parent="android:Theme.Material.Light.NoActionBar">
         <item name="android:windowBackground">@color/window_background</item>
         <item name="android:statusBarColor">@android:color/transparent</item>
         <item name="android:navigationBarColor">@android:color/transparent</item>
diff --git a/app/src/test/java/com/resonance/player/fakes/Fakes.kt b/app/src/test/java/com/resonance/player/fakes/Fakes.kt
index 78589c4..84175a0 100644
--- a/app/src/test/java/com/resonance/player/fakes/Fakes.kt
+++ b/app/src/test/java/com/resonance/player/fakes/Fakes.kt
@@ -97,6 +97,9 @@ class FakeMusicRepository(songs: List<Song> = listOf(testSong(1L), testSong(2L))
         albumArtist: String?
     ): Result<List<Song>> = Result.Success(backing)
 
+    override suspend fun getFolderSongs(relativePath: String?): Result<List<Song>> =
+        Result.Success(backing)
+
     override suspend fun getLibraryStats(): com.resonance.player.core.model.LibraryStats =
         com.resonance.player.core.model.LibraryStats(
             songCount = backing.size, albumCount = 1, artistCount = 1,
diff --git a/gradle/libs.versions.toml b/gradle/libs.versions.toml
index 43782f9..fcb6532 100644
--- a/gradle/libs.versions.toml
+++ b/gradle/libs.versions.toml
@@ -21,6 +21,7 @@ androidx-core-ktx = { group = "androidx.core", name = "core-ktx", version.ref =
 androidx-lifecycle-runtime-ktx = { group = "androidx.lifecycle", name = "lifecycle-runtime-ktx", version.ref = "lifecycle" }
 androidx-lifecycle-viewmodel = { group = "androidx.lifecycle", name = "lifecycle-viewmodel", version.ref = "lifecycle" }
 androidx-lifecycle-viewmodel-compose = { group = "androidx.lifecycle", name = "lifecycle-viewmodel-compose", version.ref = "lifecycle" }
+androidx-lifecycle-runtime-compose = { group = "androidx.lifecycle", name = "lifecycle-runtime-compose", version.ref = "lifecycle" }
 androidx-activity-compose = { group = "androidx.activity", name = "activity-compose", version.ref = "activityCompose" }
 androidx-compose-bom = { group = "androidx.compose", name = "compose-bom", version.ref = "composeBom" }
 androidx-ui = { group = "androidx.compose.ui", name = "ui" }
diff --git a/settings.gradle.kts b/settings.gradle.kts
index 6bba194..7cae5ee 100644
--- a/settings.gradle.kts
+++ b/settings.gradle.kts
@@ -13,5 +13,5 @@ dependencyResolutionManagement {
     }
 }
 
-rootProject.name = "resonance"
+rootProject.name = "crate"
 include(":app")