diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml
index 1e8960396..389705314 100644
--- a/.github/workflows/build.yml
+++ b/.github/workflows/build.yml
@@ -411,6 +411,7 @@ jobs:
         id: build
         env:
           DROIDDECK_BUILD_LABEL: ${{ steps.build-label.outputs.label }}
+          SGDB_API_KEY: ${{ secrets.SGDB_API_KEY }}
         run: |
           set -o pipefail
           python3 tools/release/runtime_inputs.py record
diff --git a/app/build.gradle b/app/build.gradle
index a69f39097..7734b1098 100644
--- a/app/build.gradle
+++ b/app/build.gradle
@@ -94,6 +94,7 @@ android {
         buildConfigField "String", "RELEASE_SIGNER", "\"${releaseSigner}\""
         buildConfigField "long", "COMMIT_TIME", "${commitTime}L * 1000L"
         buildConfigField "String", "VARIANT_SUFFIXES", "\"${variantSuffixes}\""
+        buildConfigField "String", "SGDB_API_KEY", "\"${System.getenv("SGDB_API_KEY") ?: project.findProperty("sgdbApiKey") ?: ""}\""
         buildConfigField "String", "DESKTOP_KDE_TAG", "\"${desktopKde.DESKTOP_KDE_TAG}\""
         buildConfigField "String", "DESKTOP_KDE_URL", "\"https://github.com/${desktopKde.DESKTOP_KDE_REPO}/releases/download/${desktopKde.DESKTOP_KDE_TAG}/desktop-kde.tar.zst\""
         buildConfigField "String", "DESKTOP_KDE_SHA256", "\"${desktopKde.DESKTOP_KDE_SHA256}\""
diff --git a/app/src/main/java/com/droiddeck/launcher/MainActivity.kt b/app/src/main/java/com/droiddeck/launcher/MainActivity.kt
index 8a4e27113..435f535a3 100644
--- a/app/src/main/java/com/droiddeck/launcher/MainActivity.kt
+++ b/app/src/main/java/com/droiddeck/launcher/MainActivity.kt
@@ -301,29 +301,34 @@ class MainActivity : ComponentActivity() {
         GameSaves.savesDir().mkdirs()
         pickSaveDir.launch(InAppFilePicker.buildDirIntent(this, getString(R.string.main_saves_pick_folder, name, layout.label(this)), GameSaves.savesDir().path))
     }
-    private val pickAddedGamesDir = registerForActivityResult(ActivityResultContracts.StartActivityForResult()) { r ->
-        if (r.resultCode == RESULT_OK) InAppFilePicker.pickedPath(r.data)?.let { path ->
-            SessionPrefs.setAddedGamesDirs(this, addedGamesDirs + path)
-            addedGamesDirs = SessionPrefs.addedGamesDirs(this)
-        addedGamesArt = SessionPrefs.addedGamesArt(this)
-            refreshAddedGames()
-            refresh()
-        }
+    /** The Games tab's +: the picked .exe becomes a game (or selects / switches the one it belongs to). */
+    private fun addGameExe(path: String) {
+        val exe = java.io.File(path)
+        Thread({
+            val result = try { com.droiddeck.launcher.frontend.AddedGames.addExe(this, exe) } catch (e: Exception) {
+                Log.w(TAG, "add game: ${e.message}"); com.droiddeck.launcher.frontend.AddedGames.AddResult.NotFound
+            }
+            val game = when (result) {
+                is com.droiddeck.launcher.frontend.AddedGames.AddResult.Added -> result.game
+                is com.droiddeck.launcher.frontend.AddedGames.AddResult.Existing -> result.game
+                is com.droiddeck.launcher.frontend.AddedGames.AddResult.Switched -> result.game
+                else -> null
+            }
+            ui.post {
+                if (game == null) {
+                    if (result is com.droiddeck.launcher.frontend.AddedGames.AddResult.Unreachable)
+                        android.widget.Toast.makeText(this, R.string.games_add_unreachable, android.widget.Toast.LENGTH_LONG).show()
+                    return@post
+                }
+                updateAddedGames(listOf(game.folder.path), then = { fetchAddedGameArt() })
+                navRequest = "app:${game.steamAppId ?: game.appId.toInt()}"
+            }
+        }, "add-game-exe").start()
     }
-    private var pendingAddedGame: String? = null
-    private val pickAddedGameExe = registerForActivityResult(ActivityResultContracts.StartActivityForResult()) { r ->
-        val folder = pendingAddedGame ?: return@registerForActivityResult
-        pendingAddedGame = null
-        if (r.resultCode == RESULT_OK) InAppFilePicker.pickedPath(r.data)?.let { path ->
-            SessionPrefs.setAddedGameExe(this, folder, path)
-            refreshAddedGames()
-            refresh()
-        }
-    }
-    private var addedGamesDirs by mutableStateOf<List<String>>(emptyList())
     private var addedGamesArt by mutableStateOf(true)
     @Volatile private var artFetchRunning = false
-    private var addedGames by mutableStateOf<List<com.droiddeck.launcher.ui.AddedGameRow>>(emptyList())
+    /** The user entered a SteamGridDB API key of their own. */
+    private var sgdbUserKey by mutableStateOf(false)
     private val pickRomsDir = registerForActivityResult(ActivityResultContracts.StartActivityForResult()) { r ->
         if (r.resultCode == RESULT_OK) InAppFilePicker.pickedPath(r.data)?.let { path ->
             SessionPrefs.setRomsDir(this, path)
@@ -590,6 +595,8 @@ class MainActivity : ComponentActivity() {
                         gameStoresSpeedTier = gameStoresSpeedTier,
                         storesOpenTab = storesOpenTab,
                         navigate = navRequest,
+                        addedGamesArt = addedGamesArt,
+                        sgdbUserKey = sgdbUserKey,
                         storesShowMature = storesShowMature,
                         storeDownloadsActive = com.droiddeck.launcher.stores.StoresState.activeDownloads,
                     ),
@@ -606,6 +613,20 @@ class MainActivity : ComponentActivity() {
                         onGameShortcut = { g -> com.droiddeck.launcher.frontend.GameShortcuts.pin(this, g) },
                         onExportGameFile = { g -> pickGameExport(g) },
                         onSyncGameFiles = { pickGameExport(null) },
+                        onAddGameExe = { path -> addGameExe(path) },
+                        onAddedGamesChanged = { folders ->
+                            // New games want art; an edit does not.
+                            val known = steamGames.mapNotNull { it.gameFiles?.path }.toSet()
+                            updateAddedGames(folders, then = { if (folders.any { it !in known }) fetchAddedGameArt() })
+                        },
+                        onAddedGameRemoved = { folder, appId, name -> removeAddedGame(folder, appId, name) },
+                        onAddedGamesArt = { on -> SessionPrefs.setAddedGamesArt(this, on); addedGamesArt = on; if (on) refreshAddedGames() },
+                        onSgdbKey = { key ->
+                            Thread({
+                                com.droiddeck.launcher.frontend.SteamGridDb.setUserKey(this, key)
+                                ui.post { sgdbUserKey = key.isNotBlank(); refreshAddedGames() }
+                            }, "sgdb-key").start()
+                        },
                         onStopGameFileSync = {
                             Thread({
                                 GameFileSync.disable(this)
@@ -1252,9 +1273,6 @@ class MainActivity : ComponentActivity() {
                 wifiDiscoveryLocation = wifiDiscoveryLocation,
                 wifiDiscoveryAsked = wifiDiscoveryAsked,
                 wifiDiscoveryBlocked = wifiDiscoveryBlocked,
-                addedGamesDirs = if (mode == SessionService.MODE_STEAM) addedGamesDirs else null,
-                addedGames = if (mode == SessionService.MODE_STEAM) addedGames else emptyList(),
-                addedGamesArt = addedGamesArt,
                 deckyInstalled = if (mode == SessionService.MODE_STEAM) decky.deckyInstalled else null,
                 deckyLatestRelease = if (mode == SessionService.MODE_STEAM) decky.deckyReleases.firstOrNull() else null,
                 deckyChecking = decky.deckyChecking, deckyStage = decky.deckyStage, deckyPercent = decky.deckyPercent,
@@ -1335,14 +1353,6 @@ class MainActivity : ComponentActivity() {
                     SessionPrefs.setRunSteamAtStartup(this, on)
                     runSteamAtStartup = on
                 },
-                onPickAddedGamesDir = { pickAddedGamesDir.launch(InAppFilePicker.buildDirIntent(this, getString(R.string.main_pick_added_games), addedGamesDirs.lastOrNull())) },
-                onAddedGamesArt = { on -> SessionPrefs.setAddedGamesArt(this, on); addedGamesArt = on; if (on) refreshAddedGames() },
-                onForgetAddedGamesDir = { dir -> SessionPrefs.setAddedGamesDirs(this, addedGamesDirs - dir); addedGamesDirs = SessionPrefs.addedGamesDirs(this); refreshAddedGames(); refresh() },
-                onAddedGameExe = { folder, path -> SessionPrefs.setAddedGameExe(this, folder, path); refreshAddedGames(); refresh() },
-                onPickAddedGameExe = { folder ->
-                    pendingAddedGame = folder
-                    pickAddedGameExe.launch(InAppFilePicker.buildIntent(this, listOf("exe"), getString(R.string.main_pick_game_exe), folder))
-                },
                 onDeckyInstall = { release -> decky.installDecky(release) },
                 onDeckyCheck = { decky.refreshDecky() },
                 onDeckyEnabled = { enabled -> DeckyManager.setSupervisorEnabled(this, enabled); decky.deckySupervisor = enabled },
@@ -1397,18 +1407,42 @@ class MainActivity : ComponentActivity() {
         )
     }
 
-    /** The added games as the settings page lists them; a scan of the folder, on this thread (one level, small). */
-    /** The added games for the session settings: a folder walk, so off the main thread. */
-    private fun refreshAddedGames() {
+    /**
+     * The Games tab after these added games were added or edited: each read alone and put in
+     * place of its old entry (or added), no library-wide scan. [then] runs after, on the main thread.
+     */
+    private fun updateAddedGames(folders: List<String>, then: () -> Unit = {}) {
+        if (folders.isEmpty()) return
         Thread({
-            val games = scanAddedGames()
-            ui.post { addedGames = games; fetchAddedGameArt() }
-        }, "added-games").start()
+            val fresh = folders.mapNotNull { f ->
+                com.droiddeck.launcher.frontend.AddedGames.single(this, f)?.let { com.droiddeck.launcher.frontend.Library.addedGame(this, it) }
+            }
+            ui.post {
+                val paths = folders.toSet()
+                steamGames = (steamGames.filterNot { it.library == Library.ADDED && it.gameFiles?.path in paths } + fresh).distinctBy { it.gameId }
+                then()
+            }
+        }, "added-games-update").start()
     }
 
-    /** Walks the added-games folders, which can sit on slow shared storage or an SD card. */
-    private fun scanAddedGames() = com.droiddeck.launcher.frontend.AddedGames.scan(this).map { g ->
-        com.droiddeck.launcher.ui.AddedGameRow(g.folder.path, g.folderName(), g.exe.path, g.exe.name, (g.candidates + g.exe).map { c -> c.path to c.name }.distinctBy { it.first })
+    /** An added game removed: off the Games tab now; the rest (cache, Steam, listing) off the main thread. */
+    private fun removeAddedGame(folder: String, appId: Long?, name: String) {
+        steamGames = steamGames.filterNot { it.library == Library.ADDED && it.gameFiles?.path == folder }
+        Thread({ com.droiddeck.launcher.frontend.AddedGames.remove(this, java.io.File(folder), appId, name) }, "added-game-remove").start()
+    }
+
+    /** After the added games changed: art that is missing is fetched (off the main thread). */
+    private fun refreshAddedGames() {
+        sgdbKeyKnown()
+        fetchAddedGameArt()
+    }
+
+    /** Whether the user has a SteamGridDB key of their own, for Setup; read off the main thread. */
+    private fun sgdbKeyKnown() {
+        Thread({
+            val set = com.droiddeck.launcher.frontend.SteamGridDb.userKey(this).isNotEmpty()
+            ui.post { sgdbUserKey = set }
+        }, "sgdb-key-state").start()
     }
 
     private fun fetchAddedGameArt() {
@@ -1447,7 +1481,6 @@ class MainActivity : ComponentActivity() {
         mangoapp = SessionPrefs.mangoapp(this)
         steamController = SessionPrefs.steamController(this)
         runSteamAtStartup = SessionPrefs.runSteamAtStartup(this)
-        addedGamesDirs = SessionPrefs.addedGamesDirs(this)
         hdrOn = SessionPrefs.hdr(this, mode)
         fpsLimit = SessionPrefs.fpsLimit(this, mode)
         upscaler = SessionPrefs.upscaler(this)
@@ -1469,12 +1502,10 @@ class MainActivity : ComponentActivity() {
         // added-games folders, the storage volumes) lands while it animates in.
         Thread({
             drivers.refreshDrivers()
-            val games = scanAddedGames()
             val storage = GameStorage.options(this)
             val deckyInstalled = if (mode == SessionService.MODE_STEAM) DeckyManager.installed(this) else null
             val deckySupervisor = mode == SessionService.MODE_STEAM && DeckyManager.supervisorEnabled(this)
             ui.post {
-                addedGames = games
                 storageOptions = storage
                 if (mode == SessionService.MODE_STEAM) {
                     decky.deckyInstalled = deckyInstalled
@@ -1523,6 +1554,7 @@ class MainActivity : ComponentActivity() {
 
     private fun refresh() {
         if (!busy && LinuxRuntimeInstaller.isBusy()) followRuntimeOperation { LinuxRuntimeInstaller.attach(it) }
+        addedGamesArt = SessionPrefs.addedGamesArt(this)
         desktopInstalled = DesktopCatalog.desktopInstalled(this)
         offlineAccount = OfflineMode.account(this)
         offline = OfflineMode.enabled(this)
diff --git a/app/src/main/java/com/droiddeck/launcher/frontend/AddedExes.kt b/app/src/main/java/com/droiddeck/launcher/frontend/AddedExes.kt
new file mode 100644
index 000000000..62afb0b8a
--- /dev/null
+++ b/app/src/main/java/com/droiddeck/launcher/frontend/AddedExes.kt
@@ -0,0 +1,48 @@
+package com.droiddeck.launcher.frontend
+
+import android.content.Context
+import org.json.JSONArray
+import org.json.JSONObject
+import java.io.File
+
+/**
+ * Games added from the Games tab's + rather than a Games folder: one picked .exe, or each game
+ * "Add all games in this folder" found. Kept by the game's folder in `files/added-exes.json`,
+ * which [AddedGames.scan] merges in. The exe chosen later, the shortcut appid, the edits and the
+ * removal live where every added game keeps them ([com.droiddeck.launcher.session.SessionPrefs]);
+ * this holds which folders are games and the exe they came with.
+ */
+object AddedExes {
+    /** [picked]: the user chose [exe]; false = [GameExePicker]'s best guess, which a scan ranks again. */
+    class Entry(val folder: String, val exe: String, val picked: Boolean = true)
+
+    private fun file(context: Context) = File(context.filesDir, "added-exes.json")
+
+    @Synchronized
+    fun list(context: Context): List<Entry> = try {
+        val array = JSONArray(file(context).takeIf { it.isFile }?.readText() ?: "[]")
+        (0 until array.length()).mapNotNull { i ->
+            val o = array.optJSONObject(i) ?: return@mapNotNull null
+            val folder = o.optString("folder"); val exe = o.optString("exe")
+            if (folder.isEmpty() || exe.isEmpty()) null else Entry(folder, exe, o.optBoolean("picked", true))
+        }
+    } catch (e: Exception) {
+        emptyList()
+    }
+
+    /** Adds [entry], replacing one for the same folder. */
+    @Synchronized
+    fun put(context: Context, entry: Entry) = write(context, list(context).filter { it.folder != entry.folder } + entry)
+
+    @Synchronized
+    fun drop(context: Context, folder: String) = write(context, list(context).filter { it.folder != folder })
+
+    private fun write(context: Context, entries: List<Entry>) {
+        val array = JSONArray()
+        entries.forEach { array.put(JSONObject().put("folder", it.folder).put("exe", it.exe).put("picked", it.picked)) }
+        val f = file(context)
+        val tmp = File(f.path + ".tmp")
+        tmp.writeText(array.toString())
+        if (!tmp.renameTo(f)) { f.delete(); tmp.renameTo(f) }
+    }
+}
diff --git a/app/src/main/java/com/droiddeck/launcher/frontend/AddedGameArt.kt b/app/src/main/java/com/droiddeck/launcher/frontend/AddedGameArt.kt
index ecc92a1db..a29e43679 100644
--- a/app/src/main/java/com/droiddeck/launcher/frontend/AddedGameArt.kt
+++ b/app/src/main/java/com/droiddeck/launcher/frontend/AddedGameArt.kt
@@ -12,8 +12,9 @@ import java.net.URL
 import java.net.URLEncoder
 
 /**
- * Artwork for an added game: what the user put in the game's folder first, else what Steam's
- * store has for the same title, fetched once into the app's cache. Four pieces, named the way
+ * Artwork for an added game: what the user put in the game's folder first, else what Steam has
+ * for it - by the Steam appid its files name, else by a store search on its title - else what
+ * SteamGridDB has ([SteamGridDb]), fetched once into the app's cache. Four pieces, named the way
  * the client names them in its grid folder: the portrait capsule, the wide header, the hero
  * background and the logo; plus an icon pulled out of the game's own .exe. The session hands
  * the paths to the runtime's shortcuts writer, which copies them into the client's grid.
@@ -28,13 +29,40 @@ object AddedGameArt {
         val any get() = portrait != null || header != null || hero != null || logo != null
     }
 
+    /**
+     * The pieces a user can choose, as the client takes them: [assetType] is its custom-artwork
+     * number (null: the icon, set by path); [cacheName] the automatic file in the game's cache.
+     */
+    enum class Slot(val key: String, val cacheName: String, val assetType: Int?) {
+        COVER("p", "p.jpg", 0), BACKGROUND("hero", "hero.jpg", 1), LOGO("logo", "logo.png", 2), ICON("icon", "icon.png", null),
+    }
+
+    /** Where a piece came from; [AUTO] = nothing found yet. */
+    const val FOLDER = "folder"
+    const val STEAM = "steam"
+    const val SGDB = "sgdb"
+    const val FILE = "file"
+    const val EXE = "exe"
+    const val AUTO = ""
+
+    /** A slot as it stands: the file shown and where it came from (one of [FOLDER].. [AUTO]); [chosen] = the user picked it. */
+    class SlotState(val slot: Slot, val file: File?, val source: String, val chosen: Boolean)
+
+    /** One image the chooser offers: its group ([FOLDER], [STEAM], [SGDB]), a thumbnail and the full image (URL or path). */
+    class Option(val group: String, val thumb: String, val full: String)
+
+    private val CHOSEN = Regex("""chosen-(\w+)\.(\w+)""")
+
+    private fun chosen(cache: File, slot: Slot): File? =
+        cache.listFiles { f -> CHOSEN.matchEntire(f.name)?.groupValues?.get(1) == slot.key }?.firstOrNull()
+
     private val IMAGE = listOf("png", "jpg", "jpeg")
     private val PORTRAIT = listOf("cover", "poster", "grid", "boxart", "capsule", "folder", "library_600x900", "portrait")
     private val HEADER = listOf("header", "banner", "library_header", "wide")
     private val HERO = listOf("hero", "background", "library_hero")
     private val LOGO = listOf("logo")
 
-    private fun cacheDir(context: Context, game: AddedGames.Game) = File(context.filesDir, "added-art/${game.appId}")
+    internal fun cacheDir(context: Context, game: AddedGames.Game) = File(context.filesDir, "added-art/${game.appId}")
 
     /** An image in the folder (or its `art` subfolder) under one of the given names, any image extension. */
     private fun find(folder: File, names: List<String>): File? {
@@ -58,20 +86,112 @@ object AddedGameArt {
         )
     }
 
-    /** The folder's art, else the cached Steam art, without touching the network. */
+    /** The user's choice for each piece, else the folder's art, else the cached art; no network. */
     fun resolve(context: Context, game: AddedGames.Game): Art {
         val own = local(game)
         val cache = cacheDir(context, game)
         fun cached(name: String) = File(cache, name).takeIf { it.isFile }
         return Art(
-            portrait = own.portrait ?: cached("p.jpg"),
-            header = own.header ?: cached("header.jpg"),
-            hero = own.hero ?: cached("hero.jpg"),
-            logo = own.logo ?: cached("logo.png"),
-            icon = own.icon ?: exeIcon(context, game),
+            portrait = chosen(cache, Slot.COVER) ?: own.portrait ?: cached("p.jpg") ?: exeArt(context, game, cover = true),
+            header = own.header ?: cached("header.jpg") ?: exeArt(context, game, cover = false),
+            hero = chosen(cache, Slot.BACKGROUND) ?: own.hero ?: cached("hero.jpg"),
+            logo = chosen(cache, Slot.LOGO) ?: own.logo ?: cached("logo.png"),
+            icon = chosen(cache, Slot.ICON) ?: own.icon ?: cached("icon-sgdb.png") ?: exeIcon(context, game),
         )
     }
 
+    /** Each choosable piece with its file and where it came from, for the game's editor; no network. */
+    fun describe(context: Context, game: AddedGames.Game): List<SlotState> {
+        val own = local(game)
+        val cache = cacheDir(context, game)
+        fun cached(name: String): Pair<File, String>? = File(cache, name).takeIf { it.isFile }?.let { f ->
+            f to (File(cache, "$name.src").takeIf { it.isFile }?.readText()?.trim()?.takeIf { it.isNotEmpty() } ?: STEAM)
+        }
+        return Slot.values().map { slot ->
+            chosen(cache, slot)?.let { return@map SlotState(slot, it, chosenSource(context, game, slot).first.ifEmpty { FILE }, true) }
+            val auto: Pair<File, String>? = when (slot) {
+                Slot.COVER -> own.portrait?.let { it to FOLDER } ?: cached("p.jpg") ?: exeArt(context, game, cover = true)?.let { it to EXE }
+                Slot.BACKGROUND -> own.hero?.let { it to FOLDER } ?: cached("hero.jpg")
+                Slot.LOGO -> own.logo?.let { it to FOLDER } ?: cached("logo.png")
+                Slot.ICON -> own.icon?.let { it to FOLDER } ?: File(cache, "icon-sgdb.png").takeIf { it.isFile }?.let { it to SGDB }
+                    ?: exeIcon(context, game)?.let { it to EXE }
+            }
+            SlotState(slot, auto?.first, auto?.second ?: AUTO, false)
+        }
+    }
+
+    private val CHOOSABLE = setOf("png", "jpg", "jpeg", "webp")
+
+    /** Images in the game's folder (and its art folders) that could stand for a piece. */
+    internal fun folderImages(folder: File): List<File> =
+        listOf(folder, File(folder, "art"), File(folder, ".art")).flatMap { dir ->
+            dir.listFiles { f -> f.isFile && f.extension.lowercase() in CHOOSABLE }?.sortedBy { it.name.lowercase() }.orEmpty()
+        }.take(12)
+
+    /**
+     * What the chooser offers for [slot]: the game folder's images, Steam's official piece (when the
+     * game has a Steam appid and Steam has the piece), and SteamGridDB's best few (with a key).
+     * Blocking: it asks the network.
+     */
+    fun options(context: Context, game: AddedGames.Game, slot: Slot): List<Option> {
+        val out = ArrayList<Option>()
+        folderImages(game.folder).forEach { out.add(Option(FOLDER, it.path, it.path)) }
+        val cache = cacheDir(context, game)
+        val steamId = runCatching { GameIdentifier.identify(game.exe).appId?.toString() }.getOrNull()
+            ?: File(cache, "steam-appid").takeIf { it.isFile }?.readText()?.trim()?.takeIf { it.isNotEmpty() && it != "none" }
+        val remote = when (slot) { Slot.COVER -> "library_600x900.jpg"; Slot.BACKGROUND -> "library_hero.jpg"; Slot.LOGO -> "logo.png"; Slot.ICON -> null }
+        if (steamId != null && remote != null) {
+            val url = "$CDN$steamId/$remote".takeIf { exists(it) } ?: steamAssetUrl(steamId, remote)
+            if (url != null) out.add(Option(STEAM, url, url))
+        }
+        val key = SteamGridDb.key(context)
+        if (key.isNotEmpty()) {
+            cache.mkdirs()
+            val gridId = remembered(File(cache, "sgdb-id")) {
+                runCatching { SteamGridDb.gameId(key, steamId?.toIntOrNull(), game.name) }.getOrNull()?.toString()
+            }?.toIntOrNull()
+            if (gridId != null) runCatching { SteamGridDb.images(key, gridId, slot, if (slot == Slot.ICON) 3 else 5) }.getOrNull()
+                ?.forEach { (thumb, full) -> out.add(Option(SGDB, thumb, full)) }
+        }
+        return out
+    }
+
+    /** Sets [slot] to [option] (a file is copied, a URL fetched) and records where it came from. False when it could not be had. Blocking. */
+    fun choose(context: Context, game: AddedGames.Game, slot: Slot, option: Option): Boolean {
+        val bytes = if (option.full.startsWith("https://")) get(option.full) else runCatching { File(option.full).readBytes() }.getOrNull()
+        bytes ?: return false
+        val ext = option.full.substringAfterLast('.', "png").substringBefore('?').lowercase().takeIf { it in CHOOSABLE + "ico" } ?: "png"
+        val cache = cacheDir(context, game).apply { mkdirs() }
+        chosen(cache, slot)?.delete()
+        val dst = File(cache, "chosen-${slot.key}.${if (ext == "jpeg") "jpg" else ext}")
+        val tmp = File(cache, dst.name + ".tmp")
+        tmp.writeBytes(bytes)
+        if (!tmp.renameTo(dst)) return false
+        SessionPrefs.setAddedGameArtSource(context, game.folder.path, slot.key, option.group + "|" + option.full)
+        return true
+    }
+
+    /** Where the user's choice for [slot] came from and which image it was ("" both when automatic). */
+    fun chosenSource(context: Context, game: AddedGames.Game, slot: Slot): Pair<String, String> {
+        val value = SessionPrefs.addedGameArtSource(context, game.folder.path, slot.key)
+        return value.substringBefore('|') to value.substringAfter('|', "")
+    }
+
+    /** [slot] back to what is found by itself. */
+    fun reset(context: Context, game: AddedGames.Game, slot: Slot) {
+        chosen(cacheDir(context, game), slot)?.delete()
+        SessionPrefs.setAddedGameArtSource(context, game.folder.path, slot.key, "")
+    }
+
+    private fun exists(url: String): Boolean = runCatching {
+        val c = URL(url).openConnection() as HttpURLConnection
+        c.requestMethod = "HEAD"
+        c.connectTimeout = 8_000
+        c.readTimeout = 8_000
+        c.setRequestProperty("User-Agent", "DroidDeck-launcher")
+        try { c.responseCode == 200 } finally { c.disconnect() }
+    }.getOrDefault(false)
+
     /** The first icon inside the game's .exe, kept as a PNG beside the cached art. */
     private fun exeIcon(context: Context, game: AddedGames.Game): File? {
         val cache = cacheDir(context, game)
@@ -88,58 +208,93 @@ object AddedGameArt {
     }
 
     /**
-     * Looks the games up on Steam's store and fetches the art that is missing, once per game
-     * (a miss is retried after a week). Blocking: run it off the main thread. Returns true when
-     * anything new arrived.
+     * Fetches the art that is missing: Steam first (the appid the game's files name, else a store
+     * search on its title whose result carries the same name), then SteamGridDB when a key is
+     * set. Each lookup runs once per game; a miss is retried after a week. Blocking: run it off
+     * the main thread. Returns true when anything new arrived.
      */
     fun fetchMissing(context: Context, games: List<AddedGames.Game>): Boolean {
         if (!SessionPrefs.addedGamesArt(context)) return false
+        val sgdbKey = SteamGridDb.key(context)
         var changed = false
         for (game in games) {
             if (local(game).portrait != null) continue
             val cache = cacheDir(context, game)
-            val lookup = File(cache, "steam-appid")
             if (File(cache, "p.jpg").isFile) continue
-            if (lookup.isFile && (lookup.readText().trim() != "none" || System.currentTimeMillis() - lookup.lastModified() < RETRY_AFTER_MS)) {
-                val id = lookup.readText().trim()
-                if (id == "none") continue
-                if (download(id, cache)) changed = true
-                continue
-            }
             cache.mkdirs()
-            val id = runCatching { search(game.name) }.onFailure { Log.w(TAG, "${game.name}: store search failed (${it.message})") }.getOrNull()
-            if (id == null) { lookup.writeText("none"); continue }
-            lookup.writeText(id)
-            Log.i(TAG, "${game.name}: Steam app $id")
-            if (download(id, cache)) changed = true
+            val appId = runCatching { GameIdentifier.identify(game.exe).appId }.getOrNull()
+            val id = steamAppId(game.name, appId, File(cache, "steam-appid")) { name ->
+                runCatching { search(name) }.onFailure { Log.w(TAG, "${game.name}: store search failed (${it.message})") }.getOrNull()
+            }
+            if (id != null && download(id, cache)) changed = true
+            if (File(cache, "p.jpg").isFile || sgdbKey.isEmpty()) continue
+            val gridId = remembered(File(cache, "sgdb-id")) {
+                runCatching { SteamGridDb.gameId(sgdbKey, appId ?: id?.toIntOrNull(), game.name) }.getOrNull()?.toString()
+            }?.toIntOrNull() ?: continue
+            if (runCatching { SteamGridDb.download(sgdbKey, gridId, cache) }.getOrDefault(false)) changed = true
         }
         return changed
     }
 
+    /**
+     * The game's Steam appid for its art: the one its files name ([appId]) as it is, else the
+     * remembered or freshly searched one ([search] on [name]); null for none.
+     */
+    internal fun steamAppId(name: String, appId: Int?, lookup: File, search: (String) -> String?): String? {
+        if (appId != null) {
+            lookup.writeText(appId.toString())
+            Log.i(TAG, "$name: Steam app $appId (from its files)")
+            return appId.toString()
+        }
+        return remembered(lookup) { search(name)?.also { Log.i(TAG, "$name: Steam app $it") } }
+    }
+
+    /** What [marker] remembers (an id, or "none" for a week), else [find]'s answer written to it. */
+    private fun remembered(marker: File, find: () -> String?): String? {
+        if (marker.isFile) {
+            val value = marker.readText().trim()
+            if (value != "none") return value
+            if (System.currentTimeMillis() - marker.lastModified() < RETRY_AFTER_MS) return null
+        }
+        val found = find()
+        marker.writeText(found ?: "none")
+        return found
+    }
+
     private fun normalize(s: String) = s.lowercase().replace(Regex("[^a-z0-9]"), "")
 
-    /** The Steam appid whose store name matches the folder name best, or null for no match. */
+    private val EDITION = Regex("(?i)\\b(complete|definitive|legendary|goty|game of the year|deluxe|ultimate|remastered)( edition)?\\b")
+
+    /**
+     * How well a result's name [got] matches the game's [name]: 3 the same, 2 the same once
+     * edition words are dropped, 1 one starts with the other; 0 no match. Nothing is taken for
+     * being the first result.
+     */
+    internal fun nameMatch(name: String, got: String): Int {
+        val want = normalize(name)
+        val wantShort = normalize(name.replace(EDITION, " ").trim().ifEmpty { name })
+        val have = normalize(got)
+        if (have.isEmpty() || wantShort.isEmpty()) return 0
+        return when {
+            have == want -> 3
+            have == wantShort -> 2
+            have.startsWith(wantShort) || wantShort.startsWith(have) -> 1
+            else -> 0
+        }
+    }
+
+    /** The id of the store result whose name matches [name] best, or null when none does. */
+    internal fun pickStoreResult(name: String, items: List<Pair<String, String>>): String? =
+        items.map { (id, got) -> id to nameMatch(name, got) }
+            .filter { it.second > 0 && it.first.isNotEmpty() }
+            .maxByOrNull { it.second }?.first
+
+    /** The Steam appid whose store name matches [name], or null for no match. */
     private fun search(name: String): String? {
-        val term = name.replace(Regex("(?i)\\b(complete|definitive|legendary|goty|game of the year|deluxe|ultimate|remastered)( edition)?\\b"), " ").trim().ifEmpty { name }
+        val term = name.replace(EDITION, " ").trim().ifEmpty { name }
         val json = get(STORE_SEARCH + URLEncoder.encode(term, "UTF-8"))?.toString(Charsets.UTF_8) ?: return null
         val items = JSONObject(json).optJSONArray("items") ?: return null
-        val want = normalize(name)
-        val wantShort = normalize(term)
-        var best: String? = null
-        var bestScore = 0
-        for (i in 0 until items.length()) {
-            val item = items.getJSONObject(i)
-            val got = normalize(item.optString("name"))
-            val score = when {
-                got == want -> 4
-                got == wantShort -> 3
-                got.startsWith(wantShort) || wantShort.startsWith(got) -> 2
-                i == 0 -> 1
-                else -> 0
-            }
-            if (score > bestScore) { bestScore = score; best = item.optString("id") }
-        }
-        return best?.takeIf { it.isNotEmpty() && bestScore >= 1 }
+        return pickStoreResult(name, (0 until items.length()).map { items.getJSONObject(it) }.map { it.optString("id") to it.optString("name") })
     }
 
     private fun download(id: String, cache: File): Boolean {
@@ -149,15 +304,73 @@ object AddedGameArt {
         )) {
             val dst = File(cache, localName)
             if (dst.isFile) continue
-            val bytes = get("$CDN$id/$remote") ?: continue
+            val bytes = get("$CDN$id/$remote") ?: steamAssetUrl(id, remote)?.let { get(it) } ?: continue
             val tmp = File(cache, "$localName.tmp")
             tmp.writeBytes(bytes)
-            if (tmp.renameTo(dst)) got = true
+            if (tmp.renameTo(dst)) { got = true; File(cache, "$localName.src").writeText(STEAM) }
         }
         return got
     }
 
-    private fun get(url: String): ByteArray? {
+    /**
+     * Newer Steam games keep their art under hashed paths (store_item_assets/steam/apps/<id>/<hash>/…),
+     * where the fixed CDN names above 404. The store's item API names those paths; once per appid.
+     */
+    private fun steamAssetUrl(id: String, remote: String): String? {
+        val assets = steamAssets.getOrPut(id) {
+            runCatching {
+                val input = """{"ids":[{"appid":$id}],"context":{"language":"english","country_code":"US"},"data_request":{"include_assets":true}}"""
+                val json = get("https://api.steampowered.com/IStoreBrowseService/GetItems/v1/?input_json=" + URLEncoder.encode(input, "UTF-8"))
+                    ?.toString(Charsets.UTF_8) ?: return@runCatching emptyMap()
+                val a = JSONObject(json).optJSONObject("response")?.optJSONArray("store_items")?.optJSONObject(0)?.optJSONObject("assets")
+                    ?: return@runCatching emptyMap()
+                val format = a.optString("asset_url_format").takeIf { it.contains("\${FILENAME}") } ?: return@runCatching emptyMap()
+                fun url(vararg keys: String) = keys.firstNotNullOfOrNull { k -> a.optString(k).takeIf { it.isNotEmpty() } }
+                    ?.let { "https://shared.akamai.steamstatic.com/store_item_assets/" + format.replace("\${FILENAME}", it) }
+                mapOf(
+                    "library_600x900.jpg" to url("library_capsule_2x", "library_capsule"),
+                    "header.jpg" to url("header"),
+                    "library_hero.jpg" to url("library_hero_2x", "library_hero"),
+                ).filterValues { it != null }.mapValues { it.value!! }
+            }.getOrDefault(emptyMap())
+        }
+        return assets[remote]
+    }
+
+    private val steamAssets = java.util.concurrent.ConcurrentHashMap<String, Map<String, String>>()
+
+    /**
+     * When nothing else gave a cover (or header), one made from the exe's icon: the icon centred on
+     * its own colour, darkened toward the bottom, so the game still has a face in the list and in
+     * Steam. Made once per game; real art found later takes over because it is looked at first.
+     */
+    private fun exeArt(context: Context, game: AddedGames.Game, cover: Boolean): File? {
+        val cache = cacheDir(context, game)
+        val out = File(cache, if (cover) "p-exe.png" else "header-exe.png")
+        if (out.isFile) return out
+        val icon = exeIcon(context, game) ?: return null
+        val src = android.graphics.BitmapFactory.decodeFile(icon.path) ?: return null
+        val (w, h) = if (cover) 600 to 900 else 920 to 430
+        val tint = android.graphics.Bitmap.createScaledBitmap(src, 1, 1, true).getPixel(0, 0)
+        val bmp = Bitmap.createBitmap(w, h, Bitmap.Config.ARGB_8888)
+        val canvas = android.graphics.Canvas(bmp)
+        fun shade(c: Int, f: Float) = android.graphics.Color.rgb(
+            (android.graphics.Color.red(c) * f).toInt(), (android.graphics.Color.green(c) * f).toInt(), (android.graphics.Color.blue(c) * f).toInt(),
+        )
+        canvas.drawPaint(android.graphics.Paint().apply {
+            shader = android.graphics.LinearGradient(0f, 0f, 0f, h.toFloat(), shade(tint, 0.7f), shade(tint, 0.15f), android.graphics.Shader.TileMode.CLAMP)
+        })
+        val side = (minOf(w, h) * 0.5f).toInt()
+        val left = (w - side) / 2f
+        val top = (h - side) / 2f
+        canvas.drawBitmap(src, null, android.graphics.RectF(left, top, left + side, top + side), android.graphics.Paint(android.graphics.Paint.FILTER_BITMAP_FLAG))
+        cache.mkdirs()
+        val tmp = File(cache, "${out.name}.tmp")
+        tmp.outputStream().use { bmp.compress(Bitmap.CompressFormat.PNG, 100, it) }
+        return if (tmp.renameTo(out)) out else null
+    }
+
+    internal fun get(url: String): ByteArray? {
         val c = URL(url).openConnection() as HttpURLConnection
         c.connectTimeout = 10_000
         c.readTimeout = 15_000
diff --git a/app/src/main/java/com/droiddeck/launcher/frontend/AddedGameEdits.kt b/app/src/main/java/com/droiddeck/launcher/frontend/AddedGameEdits.kt
new file mode 100644
index 000000000..df3a22f9b
--- /dev/null
+++ b/app/src/main/java/com/droiddeck/launcher/frontend/AddedGameEdits.kt
@@ -0,0 +1,77 @@
+package com.droiddeck.launcher.frontend
+
+import android.content.Context
+import com.droiddeck.launcher.session.SessionPrefs
+import com.droiddeck.launcher.stores.SteamLiveShortcuts
+import java.io.File
+
+/**
+ * The game editor's writes for an added game, Steam's non-Steam Properties in the app: name,
+ * target, Start in, launch options and art. Each goes through the same shortcut - the listing the
+ * shortcuts writer reads, and the running client - on the appid the game already has, so an edit
+ * never makes a second shortcut. Each call is quick (the game alone, [AddedGames.single]); the
+ * client and the listing follow on [AddedGamesPublisher], in order. Call off the main thread.
+ */
+object AddedGameEdits {
+    /** The added game in [folder] as it stands now, or null when it is not listed. */
+    fun game(context: Context, folder: String): AddedGames.Game? = AddedGames.single(context, folder)
+
+    /** The client told ([live]), then the listing rewritten, on [AddedGamesPublisher]. */
+    private fun publish(context: Context, live: () -> Unit) = AddedGamesPublisher.later(context, live)
+
+    /** [name] as the game's name; "" goes back to the name found by itself. */
+    fun setName(context: Context, folder: String, name: String): AddedGames.Game? {
+        SessionPrefs.setAddedGameName(context, folder, name)
+        return apply(context, folder)
+    }
+
+    /** [exe] as the game's target; false when the session cannot see it. */
+    fun setExe(context: Context, folder: String, exe: File): Boolean {
+        if (!exe.isFile || AddedGames.guestPath(context, exe) == null) return false
+        SessionPrefs.setAddedGameExe(context, folder, exe.path)
+        apply(context, folder)
+        return true
+    }
+
+    /** [dir] (a host folder) as the game's Start in; "" = the exe's own folder. False when the session cannot see it. */
+    fun setStartIn(context: Context, folder: String, dir: String): Boolean {
+        val guest = if (dir.isBlank()) "" else AddedGames.guestPath(context, File(dir.trim())) ?: return false
+        SessionPrefs.setAddedGameStartIn(context, folder, guest)
+        apply(context, folder)
+        return true
+    }
+
+    fun setLaunchOptions(context: Context, folder: String, options: String): AddedGames.Game? {
+        SessionPrefs.setAddedGameLaunch(context, folder, options)
+        return apply(context, folder)
+    }
+
+    /** [slot] set to [option], then handed to the shortcut. False when the image could not be had. */
+    fun setArt(context: Context, folder: String, slot: AddedGameArt.Slot, option: AddedGameArt.Option): Boolean {
+        val game = game(context, folder) ?: return false
+        if (!AddedGameArt.choose(context, game, slot, option)) return false
+        applyArt(context, game, slot)
+        return true
+    }
+
+    /** [slot] back to automatic, then handed to the shortcut. */
+    fun resetArt(context: Context, folder: String, slot: AddedGameArt.Slot) {
+        val game = game(context, folder) ?: return
+        AddedGameArt.reset(context, game, slot)
+        applyArt(context, game, slot)
+    }
+
+    private fun applyArt(context: Context, game: AddedGames.Game, slot: AddedGameArt.Slot) {
+        val file = AddedGameArt.describe(context, game).first { it.slot == slot }.file
+        publish(context) {
+            if (slot == AddedGameArt.Slot.ICON) SteamLiveShortcuts.setArt(context, game.appId, null, null, iconPath = file?.absolutePath.orEmpty())
+            else SteamLiveShortcuts.setArt(context, game.appId, slot.assetType, file)
+        }
+    }
+
+    private fun apply(context: Context, folder: String): AddedGames.Game? {
+        val game = game(context, folder)
+        if (game != null) publish(context) { SteamLiveShortcuts.update(context, game) }
+        return game
+    }
+}
diff --git a/app/src/main/java/com/droiddeck/launcher/frontend/AddedGames.kt b/app/src/main/java/com/droiddeck/launcher/frontend/AddedGames.kt
index bc4386a47..4f080f4c3 100644
--- a/app/src/main/java/com/droiddeck/launcher/frontend/AddedGames.kt
+++ b/app/src/main/java/com/droiddeck/launcher/frontend/AddedGames.kt
@@ -33,6 +33,12 @@ object AddedGames {
         val source: String = Library.ADDED,
         /** The store's own id for the game, from its sidecar; null for a plain added folder. */
         val storeId: String? = null,
+        /** The exe is the picker's guess and nothing clearly won ([GameExePicker.Ranking.uncertain]). */
+        val exeUncertain: Boolean = false,
+        /** Steam's launch options for the shortcut; "" for none. */
+        val launchOptions: String = "",
+        /** Added from the Games tab (an entry of its own), not found in a Games folder. */
+        val single: Boolean = false,
     ) {
         fun folderName(): String = folder.name
     }
@@ -86,23 +92,73 @@ object AddedGames {
         // root/Games/Stores): the tree is the session's / and needs no bind.
         val runtime = LinuxRuntime.rootDir(context).absolutePath
         if (path.startsWith("$runtime/")) return "/" + path.removePrefix("$runtime/")
+        // Internal storage, bound at /root/Storage in every session: an exe picked anywhere on it.
+        val storage = android.os.Environment.getExternalStorageDirectory().absolutePath
+        if (path.startsWith("$storage/")) return "/root/Storage/" + path.removePrefix("$storage/")
         return null
     }
 
-    /** The .exe files a game folder offers, best first. */
-    fun candidates(folder: File): List<File> {
-        val exes = ArrayList<File>()
-        val roots = listOf(folder) + (folder.listFiles { f -> f.isDirectory }?.sortedBy { it.name.lowercase() } ?: emptyList())
-        for (dir in roots) {
-            dir.listFiles { f -> f.isFile && f.name.endsWith(".exe", ignoreCase = true) && !SKIP.matches(f.name) }
-                ?.let { exes.addAll(it) }
+    /** The .exe files a game folder offers, best first ([GameExePicker]); also what its exe box lists, in that order. */
+    fun candidates(folder: File): List<File> = rank(folder).exes
+
+    /** [GameExePicker]'s ranking of [folder], without the names this list never offers. */
+    fun rank(folder: File): GameExePicker.Ranking {
+        val key = "${folder.path}|${folder.lastModified()}"
+        val now = System.currentTimeMillis()
+        ranked[key]?.takeIf { now - it.first < RANK_FRESH_MS }?.let { return it.second }
+        return GameExePicker.rank(folder) { !SKIP.matches(it.name) }.also {
+            if (ranked.size > 256) ranked.clear()
+            ranked[key] = now to it
+        }
+    }
+
+    /** A folder's ranking for a minute, so one add (rank, then the game built from it) walks it once. */
+    private val ranked = java.util.concurrent.ConcurrentHashMap<String, Pair<Long, GameExePicker.Ranking>>()
+    private const val RANK_FRESH_MS = 60_000L
+
+    /**
+     * Names identified from an exe (Steam manifest, GOG info, version resource), by the exe's path,
+     * size and time and its game folder's time (a GOG info file dropped in changes the latter).
+     */
+    private val identified = java.util.concurrent.ConcurrentHashMap<String, String>()
+
+    /**
+     * The game's own title for [exe] when the disk names one ([GameIdentifier]: a Steam manifest,
+     * a GOG info file, the exe's version resource), else null (the folder name stands).
+     */
+    internal fun identifiedName(folder: File, exe: File): String? {
+        val key = "${exe.path}|${exe.length()}|${exe.lastModified()}|${folder.lastModified()}"
+        identified[key]?.let { return it.ifEmpty { null } }
+        val id = runCatching { GameIdentifier.identify(exe) }.getOrNull()
+        val found = id?.name?.takeIf {
+            id.nameSource in setOf(GameIdentifier.Source.STEAM_MANIFEST_ACF, GameIdentifier.Source.GOG_INFO, GameIdentifier.Source.PE_VERSION)
+        }
+        val name = found?.let { if (id?.nameSource == GameIdentifier.Source.PE_VERSION) betterSpelling(underscoresToSpaces(it), folder.name) else it }
+        identified[key] = name.orEmpty()
+        return name
+    }
+
+    /**
+     * The exe's version resource often spells the title the way a programmer typed it ("Insane2")
+     * while the folder has the real spacing ("Insane 2"). When both spell the same letters and
+     * digits, the one with more word breaks wins; a tie keeps mixed case over all one case
+     * ("DiRT 3" over "dirt 3"), else the exe's spelling. Different titles keep the exe's.
+     */
+    /** "Watch_Dogs" → "Watch Dogs": an underscore in a version-resource title is a programmer's space. */
+    internal fun underscoresToSpaces(name: String): String =
+        name.replace('_', ' ').replace(Regex("\\s+"), " ").trim().ifEmpty { name }
+
+    internal fun betterSpelling(peName: String, folderName: String): String {
+        fun key(s: String) = s.lowercase().filter { it.isLetterOrDigit() }
+        if (key(peName) != key(folderName) || folderName.isBlank()) return peName
+        fun breaks(s: String) = s.count { !it.isLetterOrDigit() }
+        fun mixed(s: String) = s.any { it.isUpperCase() } && s.any { it.isLowerCase() }
+        return when {
+            breaks(folderName) > breaks(peName) -> folderName.trim()
+            breaks(folderName) < breaks(peName) -> peName
+            mixed(folderName) && !mixed(peName) -> folderName.trim()
+            else -> peName
         }
-        val key = folder.name.lowercase().replace(Regex("[^a-z0-9]"), "")
-        return exes.sortedWith(
-            compareByDescending<File> { it.parentFile == folder }
-                .thenByDescending { it.nameWithoutExtension.lowercase().replace(Regex("[^a-z0-9]"), "").let { n -> n == key || key.startsWith(n) || n.startsWith(key) } }
-                .thenByDescending { it.length() },
-        )
     }
 
     fun scan(context: Context): List<Game> {
@@ -111,22 +167,181 @@ object AddedGames {
             GameStorage.effective(context)?.let { File(it.path) },
             GameStorage.effective(context)?.let { File(it.path, "steamapps/common") },
         )
+        val removed = SessionPrefs.removedAddedGames(context).toSet()
         for (dir in folders.distinctBy { it.absolutePath }) {
             if (!dir.isDirectory) { Log.w(TAG, "$dir is not a folder; skipped"); continue }
             val steamInstalls = steamInstallDirs(dir)
             for (folder in dir.listFiles { f -> f.isDirectory }?.sortedBy { it.name.lowercase() } ?: emptyList()) {
                 if (folder.name.lowercase() in steamInstalls || folder.name.equals("steamapps", ignoreCase = true)) continue
+                // Removed from the list by the user (the folder stays on disk); restored from the settings page.
+                if (folder.path in removed) continue
                 // The store install root sits inside the Games storage; its games are scanned below, per store.
                 if (folder.name == "Games" && StoreInstallRoot.roots(context).any { it.absolutePath == folder.absolutePath }) continue
                 scanGame(context, folder, out)
             }
         }
+        // Games added as one picked exe (the Games tab's +), by that exe's folder.
+        for (entry in AddedExes.list(context)) {
+            val folder = File(entry.folder)
+            if (folder.path in removed || !folder.isDirectory) continue
+            scanGame(context, folder, out, single = entry)
+        }
         // Games the Stores section installed: one folder each under <root>/<Store>/, with a sidecar.
         // An unfinished one (sidecar still `installing`, or none at all) is neither a game nor Custom.
         for (folder in StoreInstallRoot.gameFolders(context)) if (StoreInstallRoot.isFinished(folder)) scanGame(context, folder, out)
         return out.distinctBy { it.folder.canonicalPath }
     }
 
+    /**
+     * The game in [folderPath] alone, built by the same rules as [scan] (store sidecar, an entry
+     * from the Games tab, the chosen exe, the edits) without walking every other game: what the
+     * editor needs for one game. Null when that folder is not a game, or was removed.
+     */
+    fun single(context: Context, folderPath: String): Game? {
+        val folder = File(folderPath)
+        if (!folder.isDirectory || folderPath in SessionPrefs.removedAddedGames(context)) return null
+        val out = ArrayList<Game>(1)
+        scanGame(context, folder, out, single = AddedExes.list(context).firstOrNull { it.folder == folderPath })
+        return out.firstOrNull()
+    }
+
+    /**
+     * Stops listing the added game in [folder] at once: marked removed and dropped from the
+     * library cache; the running client loses its shortcut ([appId], else the one stored for the
+     * folder) and the listing is rewritten afterwards ([AddedGamesPublisher]). Nothing on disk is
+     * deleted. Quick; call off the main thread (preferences and a small file).
+     */
+    fun remove(context: Context, folder: File, appId: Long? = null, name: String = folder.name) {
+        val app = context.applicationContext
+        val started = android.os.SystemClock.elapsedRealtime()
+        val id = appId ?: SessionPrefs.addedGameStoredAppId(app, folder.path)
+        SessionPrefs.setAddedGameRemoved(app, folder.path, true)
+        LibraryCache.save(app, LibraryCache.load(app).filterNot { it.library == Library.ADDED && it.gameFiles?.path == folder.path })
+        Log.i(TAG, "games: remove $name took ${android.os.SystemClock.elapsedRealtime() - started}ms")
+        AddedGamesPublisher.later(app) { if (id != null) com.droiddeck.launcher.stores.SteamLiveShortcuts.remove(app, id) }
+    }
+
+    /** What [addExe] did with a picked exe. */
+    sealed class AddResult {
+        /** A new game, or the existing one the exe already is, or the listed game whose exe it now is. */
+        class Added(val game: Game) : AddResult()
+        class Existing(val game: Game) : AddResult()
+        class Switched(val game: Game) : AddResult()
+        /** The session cannot see the exe's path. */
+        object Unreachable : AddResult()
+        object NotFound : AddResult()
+    }
+
+    private fun canonical(f: File): String = runCatching { f.canonicalPath }.getOrDefault(f.absolutePath)
+
+    private fun inside(path: String, folder: String) = path.startsWith(folder.trimEnd('/') + "/")
+
+    /**
+     * The game folder [exe] belongs to, without a scan: an entry from the Games tab, a removed
+     * game, a store install, or the first-level folder under a Games folder (or the Steam library)
+     * that holds it. Null when it is in none.
+     */
+    private fun ownerFolder(context: Context, exe: File): File? {
+        val path = canonical(exe)
+        fun holds(f: File) = inside(path, canonical(f))
+        AddedExes.list(context).map { File(it.folder) }.firstOrNull(::holds)?.let { return it }
+        SessionPrefs.removedAddedGames(context).map { File(it) }.firstOrNull(::holds)?.let { return it }
+        StoreInstallRoot.gameFolders(context).firstOrNull(::holds)?.let { return it }
+        val dirs = roots(context).map { it.host } + listOfNotNull(
+            GameStorage.effective(context)?.let { File(it.path, "steamapps/common") },
+            GameStorage.effective(context)?.let { File(it.path) },
+        )
+        for (dir in dirs) {
+            val base = canonical(dir)
+            if (!inside(path, base)) continue
+            val first = path.removePrefix("$base/").substringBefore('/')
+            File(dir, first).takeIf { it.isDirectory && first != "steamapps" }?.let { return it }
+        }
+        return null
+    }
+
+    /**
+     * Adds the game [exe] is: the game itself when it is listed already, that game's exe switched
+     * when [exe] sits in a listed (or removed) game's folder, else a new game for [exe]'s folder.
+     * Only that one game is read; Steam (the running client, then the listing) follows on
+     * [AddedGamesPublisher]. Nothing is added when the session cannot see the path.
+     */
+    fun addExe(context: Context, exe: File): AddResult {
+        val app = context.applicationContext
+        if (!exe.isFile) return AddResult.NotFound
+        val path = canonical(exe)
+        val owner = ownerFolder(app, exe)
+        if (owner != null && owner.path !in SessionPrefs.removedAddedGames(app)) {
+            single(app, owner.path)?.takeIf { canonical(it.exe) == path }?.let { return AddResult.Existing(it) }
+        }
+        if (owner == null && guestPath(app, exe) == null) return AddResult.Unreachable
+        val folder = owner ?: exe.parentFile ?: return AddResult.NotFound
+        SessionPrefs.setAddedGameRemoved(app, folder.path, false)
+        SessionPrefs.setAddedGameExe(app, folder.path, exe.path)
+        if (owner == null) AddedExes.put(app, AddedExes.Entry(folder.path, exe.path))
+        val game = single(app, folder.path) ?: return AddResult.NotFound
+        AddedGamesPublisher.later(app) { com.droiddeck.launcher.stores.SteamLiveShortcuts.sync(app, listOf(game)) { true } }
+        Log.i(TAG, "added ${game.name} from its exe")
+        return if (owner == null) AddResult.Added(game) else AddResult.Switched(game)
+    }
+
+    /** What [addFolder] did: the games it added, and how many of the folder's games were listed already. */
+    class FolderResult(val added: List<Game>, val already: Int)
+
+    /**
+     * "Add all games in this folder": every subfolder of [dir] with an .exe becomes a game with
+     * [GameExePicker]'s best one (marked uncertain where nothing clearly won), as an entry of its
+     * own, not a Games folder. A subfolder that is, holds or sits in a listed game counts as
+     * already there; a removed one comes back. Steam follows once, on [AddedGamesPublisher]. Blocking.
+     */
+    fun addFolder(context: Context, dir: File, onGame: (Game) -> Unit = {}, onChecking: (String?) -> Unit = {}): FolderResult {
+        val app = context.applicationContext
+        val removed = SessionPrefs.removedAddedGames(app).toSet()
+        val listed = listedFolders(app, removed)
+        var already = 0
+        val fresh = ArrayList<String>()
+        val added = ArrayList<Game>()
+        for (sub in dir.listFiles { f -> f.isDirectory && !f.name.startsWith(".") }?.sortedBy { it.name.lowercase() }.orEmpty()) {
+            val path = canonical(sub)
+            if (listed.any { it == path || inside(path, it) || inside(it, path) }) { already++; continue }
+            onChecking(sub.name)
+            val best = rank(sub).exes.firstOrNull() ?: continue
+            if (guestPath(app, best) == null) continue
+            if (sub.path in removed) SessionPrefs.setAddedGameRemoved(app, sub.path, false)
+            AddedExes.put(app, AddedExes.Entry(sub.path, best.path, picked = false))
+            fresh.add(sub.path)
+            single(app, sub.path)?.let { added.add(it); onGame(it) }
+        }
+        onChecking(null)
+        if (fresh.isEmpty()) return FolderResult(emptyList(), already)
+        AddedGamesPublisher.later(app) { com.droiddeck.launcher.stores.SteamLiveShortcuts.sync(app, added) { true } }
+        Log.i(TAG, "added ${added.size} game(s) from ${dir.name}, $already already listed")
+        return FolderResult(added, already)
+    }
+
+    /**
+     * The game folders already listed, without building any game: the first-level folders of the
+     * Games folders and the Steam library (as [scan] walks them), the Games tab's entries and the
+     * store installs. Canonical paths; removed games are left out.
+     */
+    private fun listedFolders(context: Context, removed: Set<String>): List<String> {
+        val out = ArrayList<String>()
+        val dirs = roots(context).map { it.host } + listOfNotNull(
+            GameStorage.effective(context)?.let { File(it.path) },
+            GameStorage.effective(context)?.let { File(it.path, "steamapps/common") },
+        )
+        for (dir in dirs.distinctBy { it.absolutePath }) {
+            for (folder in dir.listFiles { f -> f.isDirectory }.orEmpty()) {
+                if (folder.path in removed || folder.name.equals("steamapps", ignoreCase = true)) continue
+                if (folder.name == "Games" && StoreInstallRoot.roots(context).any { it.absolutePath == folder.absolutePath }) continue
+                out.add(canonical(folder))
+            }
+        }
+        AddedExes.list(context).filter { it.folder !in removed }.forEach { out.add(canonical(File(it.folder))) }
+        StoreInstallRoot.gameFolders(context).forEach { out.add(canonical(it)) }
+        return out
+    }
+
     /**
      * The folders under a library's steamapps/common that a manifest beside it already claims.
      * Steam lists those itself, so a shortcut would only add a non-Steam copy of the game. Steam
@@ -145,13 +360,16 @@ object AddedGames {
 
     private val INSTALL_DIR = Regex("\"installdir\"\\s*\"([^\"]*)\"", RegexOption.IGNORE_CASE)
 
-    private fun scanGame(context: Context, folder: File, out: MutableList<Game>) {
+    /** [single]: the entry a game added from the Games tab has; its exe stands in when no other is chosen and the user picked it. */
+    private fun scanGame(context: Context, folder: File, out: MutableList<Game>, single: AddedExes.Entry? = null) {
         run {
             // A store install carries a sidecar; every one of them is a shortcut.
             val sidecar = StoreGameSidecar.read(folder)
-            val candidates = candidates(folder)
+            val ranking = rank(folder)
+            val candidates = ranking.exes
             val picked = SessionPrefs.addedGameExe(context, folder.path)
             val chosen = picked.takeIf { it.isNotEmpty() }?.let { File(it) }?.takeIf { it.isFile }
+                ?: single?.takeIf { it.picked }?.let { File(it.exe) }?.takeIf { it.isFile }
             // A store install says which exe it is; the folder's guess only when that file is gone.
             val found = chosen ?: sidecar?.exeFile(folder)?.takeIf { it.isFile } ?: candidates.firstOrNull() ?: return
             // The store's launcher .bat stands in front of the exe when the game needs arguments or
@@ -159,23 +377,32 @@ object AddedGames {
             val launch = if (chosen == null) sidecar?.launcherFile(folder)?.takeIf { it.isFile } ?: found else found
             val foundGuest = guestPath(context, launch)
             if (foundGuest == null) { Log.w(TAG, "${folder.name}: the session cannot see ${launch.path}"); return }
-            val name = sidecar?.title ?: folder.name
+            // A store install's title; else the title the disk gives (the shortcut's appid is kept
+            // per folder from its first scan, so a name found later does not move it); else the folder.
+            val autoName = sidecar?.title ?: identifiedName(folder, found) ?: folder.name
             // Keyed by the pre-rename path so shortcut ids, and the prefixes and saves under them, stay put.
-            val crc = CRC32().apply { update(("\"${foundGuest.replaceFirst(Regex("^$LIBRARY/"), "$LEGACY_LIBRARY/")}\"" + name).toByteArray()) }.value
+            val crc = CRC32().apply { update(("\"${foundGuest.replaceFirst(Regex("^$LIBRARY/"), "$LEGACY_LIBRARY/")}\"" + autoName).toByteArray()) }.value
             val appId = SessionPrefs.addedGameAppId(context, folder.path, crc or 0x80000000L)
             val config = accountConfig(File(LinuxRuntime.rootDir(context), "root/.local/share/Steam"))
             val record = config?.let { shortcutRecord(it, appId) }
             val rev = record?.optInt("rev", 0) ?: 0
+            // Name, Start in and launch options edited in Steam's own Properties become the app's.
+            if (sidecar == null && record != null) adoptSteamEdits(context, folder, record)
+            val name = SessionPrefs.addedGameName(context, folder.path).takeIf { sidecar == null && it.isNotEmpty() } ?: autoName
             val adopted = guestPath(context, folder)
                 ?.let { steamTarget(folder, it, record, foundGuest, SessionPrefs.addedGameExeSeen(context, folder.path)) }
                 ?.takeIf { SessionPrefs.adoptAddedGameExe(context, folder.path, picked, it.path, rev) }
             val exe = adopted ?: found
             val guestExe = if (adopted != null) guestPath(context, adopted) ?: return else foundGuest
-            val guestDir = guestPath(context, (if (adopted != null) adopted else launch).parentFile ?: folder) ?: return
+            val guestDir = SessionPrefs.addedGameStartIn(context, folder.path).takeIf { sidecar == null && it.isNotEmpty() }
+                ?: guestPath(context, (if (adopted != null) adopted else launch).parentFile ?: folder) ?: return
             val steamId = config?.let { steamRoute(it, appId) }
             out.add(Game(folder, name, exe, guestExe, guestDir, appId,
                 steamId?.toLong() ?: ((appId shl 32) or 0x02000000L), candidates, steamId,
-                source = sidecar?.store?.id ?: Library.ADDED, storeId = sidecar?.id))
+                source = sidecar?.store?.id ?: Library.ADDED, storeId = sidecar?.id,
+                exeUncertain = sidecar == null && chosen == null && adopted == null && ranking.uncertain,
+                launchOptions = if (sidecar == null) SessionPrefs.addedGameLaunch(context, folder.path) else "",
+                single = single != null))
         }
     }
 
@@ -208,6 +435,35 @@ object AddedGames {
 
     private fun unquote(value: String?): String = value.orEmpty().trim().trim('"')
 
+    /**
+     * What the user changed in Steam's Properties since the app last wrote the shortcut ([record]:
+     * what the app asked for, and what Steam had): a new name, launch options, or a Start in other
+     * than the exe's folder, taken over as the app's own. Each Steam value is taken once, so an app
+     * edit made after it is not undone before the shortcut is written again.
+     */
+    internal fun adoptSteamEdits(context: Context, folder: File, record: JSONObject) {
+        val app = record.optJSONObject("app") ?: return
+        val steam = record.optJSONObject("steam") ?: return
+        fun adopt(field: String, value: String, apply: (String) -> Unit) {
+            if (SessionPrefs.addedGameAdopted(context, folder.path, field) == value) return
+            SessionPrefs.setAddedGameAdopted(context, folder.path, field, value)
+            apply(value)
+        }
+        if (steam.has("AppName") && app.has("AppName")) {
+            val s = steam.optString("AppName"); val a = app.optString("AppName")
+            if (s.isNotEmpty() && s != a) adopt("AppName", s) { SessionPrefs.setAddedGameName(context, folder.path, it) }
+        }
+        if (steam.has("LaunchOptions") && app.has("LaunchOptions")) {
+            val s = steam.optString("LaunchOptions"); val a = app.optString("LaunchOptions")
+            if (s != a) adopt("LaunchOptions", s) { SessionPrefs.setAddedGameLaunch(context, folder.path, it) }
+        }
+        if (steam.has("StartDir") && app.has("StartDir")) {
+            val s = unquote(steam.optString("StartDir")); val a = unquote(app.optString("StartDir"))
+            val exeDir = unquote(steam.optString("Exe")).substringBeforeLast('/', "")
+            if (s.isNotEmpty() && s != a) adopt("StartDir", s) { SessionPrefs.setAddedGameStartIn(context, folder.path, if (it == exeDir) "" else it) }
+        }
+    }
+
     /** The list the session hands the runtime's shortcuts writer; one file per session start. */
     fun writeListing(context: Context, games: List<Game>): File {
         val file = File(context.filesDir, "session/added-games.json").apply { parentFile?.mkdirs() }
@@ -218,6 +474,7 @@ object AddedGames {
                 .append(",\"folder\":").append(quote(guestPath(context, g.folder) ?: g.guestDir))
                 .append(",\"dir\":").append(quote(g.guestDir)).append(",\"appid\":").append(g.appId)
                 .append(",\"seen\":").append(SessionPrefs.addedGameExeSeen(context, g.folder.path))
+            if (g.launchOptions.isNotEmpty()) json.append(",\"launch\":").append(quote(g.launchOptions))
             // The art, as the session sees it: the app's cache is bound at its own path, a file in
             // the game's folder at the folder's guest path.
             val art = AddedGameArt.resolve(context, g)
diff --git a/app/src/main/java/com/droiddeck/launcher/frontend/AddedGamesPublisher.kt b/app/src/main/java/com/droiddeck/launcher/frontend/AddedGamesPublisher.kt
new file mode 100644
index 000000000..19243b8e8
--- /dev/null
+++ b/app/src/main/java/com/droiddeck/launcher/frontend/AddedGamesPublisher.kt
@@ -0,0 +1,40 @@
+package com.droiddeck.launcher.frontend
+
+import android.content.Context
+import android.util.Log
+import androidx.annotation.VisibleForTesting
+import java.util.concurrent.Executors
+
+/**
+ * The slow part of an added-game change, off the caller's path and in order: the running client
+ * told ([later]'s work), then the listing the shortcuts writer reads at the next session start and
+ * the library cache, both from one scan ([republish]). An add, an edit or a removal shows at once;
+ * this follows.
+ */
+object AddedGamesPublisher {
+    private const val TAG = "AddedGamesPublisher"
+
+    /** Tests publish at once, to read the listing right after a change. */
+    @VisibleForTesting
+    @Volatile
+    internal var now = false
+
+    private val worker = Executors.newSingleThreadExecutor { r -> Thread(r, "added-games-publish") }
+
+    /** [live] (a DevTools call or nothing), then [republish], on the worker. */
+    fun later(context: Context, live: () -> Unit = {}) {
+        val app = context.applicationContext
+        val work = Runnable {
+            try { live() } catch (e: Exception) { Log.w(TAG, "live: ${e.message}") }
+            try { republish(app) } catch (e: Exception) { Log.w(TAG, "listing: ${e.message}") }
+        }
+        if (now) work.run() else worker.execute(work)
+    }
+
+    /** The listing and the library cache from one scan of the added games. Blocking. */
+    fun republish(context: Context) {
+        val games = AddedGames.scan(context)
+        AddedGames.writeListing(context, games)
+        LibraryCache.save(context, Library.launchableGames(context, added = games))
+    }
+}
diff --git a/app/src/main/java/com/droiddeck/launcher/frontend/GameExePicker.kt b/app/src/main/java/com/droiddeck/launcher/frontend/GameExePicker.kt
new file mode 100644
index 000000000..1ceadbfa4
--- /dev/null
+++ b/app/src/main/java/com/droiddeck/launcher/frontend/GameExePicker.kt
@@ -0,0 +1,130 @@
+package com.droiddeck.launcher.frontend
+
+import java.io.File
+
+/**
+ * Which `.exe` in a game folder is the game. A real install holds installers, crash handlers,
+ * anti-cheat stubs and launchers beside the game, and the game itself may sit several levels down
+ * (`Game/Binaries/Win64/Game-Win64-Shipping.exe`), so candidates are collected with a bounded walk
+ * and ranked rather than guessed by position.
+ */
+object GameExePicker {
+    /** How far below a game folder to look: Unreal puts the game three down, repacks deeper. */
+    const val MAX_DEPTH = 5
+
+    /** Folders and .exe files looked at per game before the walk stops, so a huge game stays quick. */
+    const val WALK_BUDGET = 400
+
+    /** Below this the pick is marked uncertain rather than trusted silently. */
+    const val CONFIDENT_SCORE = 60
+
+    /** The best and the runner-up this close together: nothing clearly won. */
+    const val AMBIGUOUS_MARGIN = 15
+
+    /** Folders that never hold the game itself. */
+    private val SKIP_DIRS = setOf(
+        "_commonredist", "commonredist", "redist", "redistributable", "redistributables",
+        "directx", "dotnet", "dotnetfx", "vcredist", "vc_redist", "prerequisites", "prereq",
+        "installer", "installers", "__installer", "support", "extras", "docs", "documentation", "manual",
+        "soundtrack", "ost", "artbook", "bonus", "dlc", "mods", "saves", "savegames",
+        "crashreportclient", "easyanticheat", "battleye", "punkbuster", "steamworks shared", ".git",
+    )
+    private val SKIP_DIR_PREFIX = listOf("dotnet", "vcredist", "$")
+    private val SKIP_PATHS = listOf("engine/extras", "engine/binaries/thirdparty")
+
+    /** Exe names that are never the game. */
+    private val JUNK_EXE_RE = Regex(
+        """(?i)^(unins\w*|setup|install\w*|vc_?redist.*|vcredist.*|dxsetup|dxwebsetup|directx.*|""" +
+            """oalinst|openal.*|dotnetfx.*|ndp\d.*|unitycrashhandler\d*|crashreport\w*|crashpad\w*|""" +
+            """crashsender\w*|easyanticheat\w*|eac\w*|battleye\w*|beservice\w*|punkbuster\w*|""" +
+            """steamerrorreporter\d*|gameoverlayui|touchup|cleanup|config|settings|benchmark|""" +
+            """activation\w*|register\w*|readme|report\w*|.*_debug|.*-debug)$""",
+    )
+
+    /** A folder's exes best first, with their scores, and whether the first clearly won. */
+    class Ranking(val exes: List<File>, val scores: List<Int>, val uncertain: Boolean)
+
+    /** Ranks the .exe files under [folder]; [keep] drops names the caller never offers. */
+    fun rank(folder: File, keep: (File) -> Boolean = { true }): Ranking {
+        val scored = collect(folder).filter { keep(it.first) }.map { (exe, depth) -> exe to score(exe, folder, depth) }
+            .sortedWith(compareByDescending<Pair<File, Int>> { it.second }.thenBy { it.first.path.lowercase() })
+        val best = scored.firstOrNull()?.second
+        val runnerUp = scored.getOrNull(1)?.second
+        val uncertain = best != null && (best < CONFIDENT_SCORE || (runnerUp != null && best - runnerUp < AMBIGUOUS_MARGIN))
+        return Ranking(scored.map { it.first }, scored.map { it.second }, uncertain)
+    }
+
+    /**
+     * Every plausible exe under [folder] with its depth (0 = in the folder itself): up to
+     * [MAX_DEPTH] folders down, nearest levels first, at most [WALK_BUDGET] entries, never through a
+     * symlink, past folders that never hold the game.
+     */
+    private fun collect(folder: File): List<Pair<File, Int>> {
+        val found = ArrayList<Pair<File, Int>>()
+        var visited = 0
+        var level = listOf(folder)
+        var depth = 0
+        walk@ while (level.isNotEmpty()) {
+            val next = ArrayList<File>()
+            for (dir in level) {
+                val entries = dir.listFiles()?.sortedBy { it.name.lowercase() } ?: continue
+                for (f in entries) {
+                    if (visited >= WALK_BUDGET) break@walk
+                    if (isLink(f)) continue
+                    if (f.isDirectory) {
+                        visited++
+                        if (depth < MAX_DEPTH && !skipDir(f, f.relativeTo(folder).invariantSeparatorsPath)) next.add(f)
+                    } else if (f.isFile && f.name.endsWith(".exe", ignoreCase = true)) {
+                        visited++
+                        if (!JUNK_EXE_RE.matches(f.nameWithoutExtension)) found.add(f to depth)
+                    }
+                }
+            }
+            level = next
+            depth++
+        }
+        return found
+    }
+
+    /**
+     * How likely [exe] is to be the game in [folder]. Relative only: the numbers rank candidates
+     * against each other and decide whether anything won clearly enough to trust.
+     */
+    internal fun score(exe: File, folder: File, depth: Int): Int {
+        var score = 0
+        val base = exe.nameWithoutExtension
+        val exeKey = key(base)
+        val folderKey = key(folder.name)
+        // The exe named after its folder is the single strongest signal.
+        if (exeKey.isNotEmpty() && folderKey.isNotEmpty()) {
+            when {
+                exeKey == folderKey -> score += 100
+                folderKey.contains(exeKey) || exeKey.contains(folderKey) -> score += 60
+            }
+        }
+        // Unreal ships as <Game>-Win64-Shipping.exe under Binaries/Win64.
+        if (base.endsWith("-Win64-Shipping", true) || base.endsWith("-Win32-Shipping", true)) score += 70
+        val path = exe.absolutePath.lowercase()
+        if (path.contains("/binaries/win64") || path.contains("/binaries/win32")) score += 30
+        if (path.contains("/bin/") || path.contains("/bin64/")) score += 10
+        // A launcher is a real entry point, so it stays a candidate, just not the preferred one.
+        if (GameIdentifier.isLauncherExeName(base)) score -= 40
+        if (GameIdentifier.isJunkPeName(base)) score -= 30
+        // Shallower is more likely the entry point; big binaries beat small helpers.
+        score -= depth * 8
+        score += (exe.length() / (8L * 1024 * 1024)).toInt().coerceAtMost(30)
+        return score
+    }
+
+    private fun skipDir(dir: File, relative: String): Boolean {
+        val name = dir.name.lowercase().trim()
+        if (name in SKIP_DIRS || SKIP_DIR_PREFIX.any { name.startsWith(it) }) return true
+        val rel = relative.lowercase()
+        return SKIP_PATHS.any { rel == it || rel.endsWith("/$it") }
+    }
+
+    private fun isLink(f: File): Boolean = runCatching { java.nio.file.Files.isSymbolicLink(f.toPath()) }.getOrDefault(false)
+
+    /** Comparison key: letters and digits only, so "GTA IV" and "gta-iv" match. */
+    private fun key(s: String) = s.lowercase().filter { it.isLetterOrDigit() }
+}
diff --git a/app/src/main/java/com/droiddeck/launcher/frontend/GameIdentifier.kt b/app/src/main/java/com/droiddeck/launcher/frontend/GameIdentifier.kt
new file mode 100644
index 000000000..d3b88b2a9
--- /dev/null
+++ b/app/src/main/java/com/droiddeck/launcher/frontend/GameIdentifier.kt
@@ -0,0 +1,328 @@
+package com.droiddeck.launcher.frontend
+
+import java.io.File
+
+/**
+ * Best-effort identification of a game from its on-disk footprint, given its .exe: a Steam appId
+ * and/or a display name, so an added game is not just named after its folder or exe. Pure
+ * filesystem and PE parsing, no network, never throws; it reports only what the disk tells.
+ *
+ * Signal chain (appId preferred; best name chosen across all hits):
+ *  1. steam_appid.txt            → appId            (Goldberg-style installs)
+ *  2. ColdClientLoader / emu ini → appId            (AppId= key)
+ *  3. appmanifest_<id>.acf       → appId + name     (real Steam install under steamapps/)
+ *  4. goggame-<id>.info          → name (+ gogId)   (GOG installs)
+ *  5. PE VS_VERSIONINFO          → name             (ProductName / FileDescription)
+ *  6. cleaned folder / exe name  → name             (weak fallback)
+ */
+object GameIdentifier {
+
+    /** How far up the directory tree to look for marker files (games nest deep, e.g. Game/Binaries/Win64/x.exe). */
+    private const val MAX_PARENT_DEPTH = 6
+
+    enum class Source { STEAM_APPID_TXT, STEAM_MANIFEST_ACF, STEAM_EMU_INI, GOG_INFO, PE_VERSION, FILENAME, NONE }
+    enum class Confidence { HIGH, MEDIUM, LOW }
+
+    /**
+     * @param appId  Steam appId if one was found on disk, else null.
+     * @param gogId  GOG product id if a goggame info file was found, else null.
+     * @param name   Best display name found locally; may be null when only an appId was
+     *               found (caller resolves the name from the appId over the network).
+     * @param source Which signal produced the primary identity.
+     */
+    data class GameIdentity(
+        val appId: Int? = null,
+        val gogId: String? = null,
+        val name: String? = null,
+        val source: Source = Source.NONE,
+        val confidence: Confidence = Confidence.LOW,
+        /** Which signal gave [name]: [Source.FILENAME] means only a cleaned folder or exe name. */
+        val nameSource: Source = Source.NONE,
+    ) {
+        val hasStrongId: Boolean get() = appId != null
+    }
+
+    /** Identify the game owning [exeFile]. Never throws; returns an empty identity if nothing matched. */
+    fun identify(exeFile: File): GameIdentity {
+        val dirs = ancestorDirs(exeFile)
+
+        // Steam appId from a bare steam_appid.txt (in the exe dir, a steam_settings/ subdir, or an ancestor).
+        val steamAppId = dirs.firstNotNullOfOrNull { readSteamAppIdTxt(it) }
+        // AppId= out of a ColdClientLoader.ini / steam_emu.ini next to the game.
+        val emuAppId = dirs.firstNotNullOfOrNull { readEmuIniAppId(it) }
+        // Real Steam install: appmanifest_<id>.acf up under steamapps/ — carries both appId and name.
+        val acf = resolveSteamManifest(exeFile, dirs)
+        // GOG: goggame-<id>.info JSON with the real title.
+        val gog = dirs.firstNotNullOfOrNull { readGogInfo(it) }
+        // PE ProductName / FileDescription — but not when it merely names a launcher/loader
+        // ("Rockstar Games Launcher Redirector", "GSE", …), which must not become the game name.
+        val peName = PeVersionInfo.bestName(PeVersionInfo.read(exeFile))?.takeUnless { isJunkPeName(it) }
+
+        val appId = acf?.appId ?: steamAppId ?: emuAppId
+
+        // Best name, most-trustworthy first.
+        val nameHit: Pair<String, Source>? = when {
+            acf?.name != null -> acf.name to Source.STEAM_MANIFEST_ACF
+            gog?.name != null -> gog.name to Source.GOG_INFO
+            peName != null -> peName to Source.PE_VERSION
+            else -> cleanedFallbackName(exeFile)?.let { it to Source.FILENAME }
+        }
+
+        // Primary source = whatever gave us the appId (strongest), else the name source.
+        val primary: Source = when {
+            acf?.appId != null -> Source.STEAM_MANIFEST_ACF
+            steamAppId != null -> Source.STEAM_APPID_TXT
+            emuAppId != null -> Source.STEAM_EMU_INI
+            else -> nameHit?.second ?: Source.NONE
+        }
+
+        val confidence = when {
+            appId != null -> Confidence.HIGH
+            nameHit?.second == Source.GOG_INFO -> Confidence.HIGH
+            nameHit?.second == Source.PE_VERSION -> Confidence.MEDIUM
+            else -> Confidence.LOW
+        }
+
+        return GameIdentity(
+            appId = appId,
+            gogId = gog?.id,
+            name = nameHit?.first?.let(::normalizeName)?.takeIf { it.isNotBlank() },
+            source = primary,
+            confidence = confidence,
+            nameSource = nameHit?.second ?: Source.NONE,
+        )
+    }
+
+    /**
+     * Make an identified title readable and filesystem-safe (a Steam shortcut's name also names
+     * files): "DARK SOULS: REMASTERED" becomes "DARK SOULS - REMASTERED". Strips trademark marks,
+     * turns title punctuation into safe equivalents, and collapses whitespace.
+     */
+    fun normalizeName(raw: String): String {
+        var s = raw
+        s = s.replace("™", "").replace("®", "").replace("©", "")
+        s = s.replace(Regex("""(?i)\(\s*(tm|r|c)\s*\)"""), "") // "(TM)" / "(R)" / "(C)"
+        s = s.replace(":", " - ")                              // colon → dash separator (safe + readable)
+        s = s.replace(Regex("""[\\/]"""), " ")                 // path separators → space
+        s = s.replace(Regex("""["*?<>|]"""), "")               // other illegal chars → drop
+        // Drop trailing generic descriptors a PE FileDescription tacks on ("DiRT 3 Executable" → "DiRT 3").
+        s = s.replace(Regex("""(?i)[ \-]+(executable|application|launcher|redistributable|installer|setup)$"""), "")
+        s = s.replace(Regex("""\s+"""), " ").trim()            // collapse whitespace
+        return s.trim(' ', '-').trim()                          // tidy stray leading/trailing dashes
+    }
+
+    // ── directory walk ──
+
+    /** The exe's directory plus its ancestors, nearest-first, bounded by [MAX_PARENT_DEPTH]. */
+    private fun ancestorDirs(exeFile: File): List<File> {
+        val out = ArrayList<File>(MAX_PARENT_DEPTH + 1)
+        var d: File? = exeFile.absoluteFile.parentFile
+        var depth = 0
+        while (d != null && depth <= MAX_PARENT_DEPTH) {
+            out.add(d)
+            d = d.parentFile
+            depth++
+        }
+        return out
+    }
+
+    // ── signal readers (all best-effort; return null on anything unexpected) ──
+
+    /** steam_appid.txt directly in [dir] or in a steam_settings/ subdir. */
+    private fun readSteamAppIdTxt(dir: File): Int? {
+        for (candidate in arrayOf(File(dir, "steam_appid.txt"), File(dir, "steam_settings/steam_appid.txt"))) {
+            // Strip a leading UTF-8 BOM (trim() doesn't) before reading the digits.
+            val id = readSmallTextFile(candidate)?.removePrefix("\uFEFF")?.trim()
+                ?.takeWhile { it.isDigit() }?.toIntOrNull()
+            if (id != null && id > 0) return id
+        }
+        return null
+    }
+
+    /**
+     * First `AppId=<n>` in a crack/emu config .ini next to the game (ColdClientLoader, steam_emu,
+     * flt, hlm, …). Known names are tried first, then any other `.ini` in the dir — only crack
+     * configs carry an `AppId=` key, game settings .ini files (settings.ini, graphics.ini) don't,
+     * so the broad scan is safe.
+     */
+    private fun readEmuIniAppId(dir: File): Int? {
+        val re = Regex("""(?im)^\s*appid\s*=\s*(\d+)""")
+        val named = arrayOf(
+            "ColdClientLoader.ini", "steam_emu.ini", "flt.ini", "hlm.ini",
+            "valve.ini", "cream_api.ini", "SmartSteamEmu.ini", "GreenLuma.ini",
+        )
+        val seen = HashSet<String>()
+        val candidates = ArrayList<File>()
+        for (n in named) File(dir, n).let { if (it.isFile) { candidates.add(it); seen.add(n.lowercase()) } }
+        (dir.listFiles { f -> f.isFile && f.name.endsWith(".ini", ignoreCase = true) && f.name.lowercase() !in seen }
+            ?: emptyArray()).sortedBy { it.name }.forEach { candidates.add(it) }
+        for (f in candidates) {
+            val text = readSmallTextFile(f) ?: continue
+            val id = re.find(text)?.groupValues?.getOrNull(1)?.toIntOrNull()
+            if (id != null && id > 0) return id
+        }
+        return null
+    }
+
+    private data class Acf(val appId: Int?, val name: String?)
+
+    /**
+     * Resolve the Steam appmanifest for this game: find the `common` ancestor on the exe's
+     * path, read the sibling `steamapps/appmanifest_*.acf`, and match by installdir == the
+     * game folder under common. No match, no manifest: a folder in steamapps/common that no
+     * manifest claims is exactly the kind added games list, and the library's one other game is
+     * not its name.
+     */
+    private fun resolveSteamManifest(exeFile: File, dirs: List<File>): Acf? {
+        val commonIdx = dirs.indexOfFirst { it.name.equals("common", ignoreCase = true) }
+        if (commonIdx < 0) return null
+        val commonDir = dirs[commonIdx]
+        val steamapps = commonDir.parentFile ?: return null
+        val manifests = steamapps.listFiles { f ->
+            f.isFile && f.name.startsWith("appmanifest_") && f.name.endsWith(".acf")
+        } ?: return null
+        if (manifests.isEmpty()) return null
+
+        // The game's install folder is the child of `common` on our descent path.
+        val gameFolder = if (commonIdx > 0) dirs[commonIdx - 1].name else null
+
+        val match = manifests.firstOrNull { m ->
+            val text = readSmallTextFile(m) ?: return@firstOrNull false
+            val installdir = vdfValue(text, "installdir")
+            gameFolder != null && installdir != null && installdir.equals(gameFolder, ignoreCase = true)
+        } ?: return null
+
+        val text = readSmallTextFile(match) ?: return null
+        val appId = vdfValue(text, "appid")?.toIntOrNull()?.takeIf { it > 0 }
+        val name = vdfValue(text, "name")?.takeIf { it.isNotBlank() }
+        return if (appId == null && name == null) null else Acf(appId, name)
+    }
+
+    private data class Gog(val id: String?, val name: String?)
+
+    /** goggame-<id>.info JSON: pull `name` (and the id from the filename). */
+    private fun readGogInfo(dir: File): Gog? {
+        val files = dir.listFiles { f ->
+            f.isFile && f.name.startsWith("goggame-") && f.name.endsWith(".info")
+        } ?: return null
+        for (f in files) {
+            val text = readSmallTextFile(f) ?: continue
+            val name = jsonStringValue(text, "name")?.takeIf { it.isNotBlank() } ?: continue
+            val id = f.name.removePrefix("goggame-").removeSuffix(".info").takeIf { it.isNotBlank() }
+            return Gog(id, name)
+        }
+        return null
+    }
+
+    // ── filename fallback ──
+
+    private val REPACK_TOKENS = setOf(
+        "fitgirl", "dodi", "codex", "plaza", "skidrow", "rune", "empress", "flt", "tenoke",
+        "reloaded", "elamigos", "razor1911", "hoodlum", "gog", "repack", "multi", "goldberg",
+        // repack/site tags that show up in folder names
+        "ankergames", "steamrip", "onlinefix", "online-fix", "gload", "fitgirlrepacks",
+    )
+    private const val EXE_NOISE_WORDS =
+        """win64|win32|shipping|wingdk|client|launcher|game|x64|x86|64bit|32bit"""
+
+    /**
+     * Does this exe basename look like engine/arch boilerplate rather than a title? Deliberately
+     * UNANCHORED — "GameConTest" is boilerplate-ish wherever the giveaway sits, and the answer
+     * decides whether we trust the folder name instead of the exe name.
+     */
+    private val EXE_NOISE_RE = Regex("""(?i)[-_. ]*(?:$EXE_NOISE_WORDS)""")
+
+    /**
+     * Trailing noise to strip off a title. ANCHORED to the end and allowed to repeat, because these
+     * words are only junk as a suffix: "Witcher3-Win64-Shipping" -> "Witcher3", while
+     * "Game of Thrones" and "Client Simulator" must survive intact.
+     *
+     * Kept separate from [EXE_NOISE_RE] on purpose. One regex used to serve both jobs, so
+     * anchoring it to fix stripping ALSO narrowed the boilerplate test — and a game in
+     * "Game Controller Test/GameConTest.exe" stopped preferring its folder and became "GameConTest".
+     */
+    private val EXE_SUFFIX_RE = Regex("""(?i)(?:[-_. ]*(?:$EXE_NOISE_WORDS))+$""")
+    private val VERSION_TOKEN_RE = Regex("""(?i)\b(v?\d+([._]\d+)+|build[-_ ]?\d+|update[-_ ]?\d+)\b""")
+
+    /**
+     * True when an exe basename is a launcher/loader rather than the game — its parent folder is the
+     * better title. Catches "PlayGTAV"/"Play - GTA IV"/"LaunchGame"/"MyLauncher"/"GSE" but NOT a real
+     * title that merely starts with those letters ("PlayerUnknown"). A "play|launch|start|run" prefix
+     * counts only when it's a whole token — followed by a separator or a camelCase uppercase boundary,
+     * not another lowercase letter (checked case-sensitively, so it survives the case-insensitive JUNK
+     * matching used elsewhere).
+     */
+    /** True when an exe basename looks like a launcher/loader rather than the game itself. */
+    fun isLauncherExeName(base: String): Boolean {
+        val lower = base.lowercase()
+        if (lower == "gse" || lower.endsWith("launcher") || lower.endsWith("redirector")) return true
+        for (p in arrayOf("play", "launch", "start", "run")) {
+            if (!lower.startsWith(p)) continue
+            val rest = base.substring(p.length)
+            if (rest.isEmpty()) return true                         // exactly "Play"
+            val c = rest[0]
+            if (!c.isLetterOrDigit() || c.isUpperCase()) return true // "Play - GTA IV" / camelCase "PlayGTAV"
+            // lowercase continuation ("Player…") → part of a longer word, not a launcher
+        }
+        return false
+    }
+
+    /** A PE ProductName/FileDescription that describes a launcher/loader, not the game — reject it so it
+     *  doesn't become the shortcut name (e.g. "Rockstar Games Launcher Redirector", "GSE", "Steam"). */
+    private val JUNK_NAME_RE = Regex(
+        """(?i)^(gse|steam|steam client|goldberg.*|launcher|game|play|start|setup|.* launcher.*|.*launcher redirector|.* redirector|rockstar games launcher.*|epic games launcher|smartsteamemu|coldclient.*|steamemu.*)$"""
+    )
+
+    /** True when a PE name is a launcher/loader label rather than a real game title. */
+    fun isJunkPeName(name: String): Boolean {
+        val n = name.trim()
+        return n.isEmpty() || JUNK_NAME_RE.matches(n)
+    }
+
+    /**
+     * Prefer the game's install-folder name (usually the real title) over the exe basename when the
+     * exe is a UE-style shipping binary OR a launcher/loader; then strip repack/suffix noise.
+     */
+    private fun cleanedFallbackName(exeFile: File): String? {
+        val exeBase = exeFile.nameWithoutExtension
+        val preferFolder = EXE_NOISE_RE.containsMatchIn(exeBase) ||
+            isLauncherExeName(exeBase) ||
+            exeBase.equals("game", true) || exeBase.equals("start", true)
+        val folder = exeFile.absoluteFile.parentFile?.name
+        val raw = if (preferFolder && !folder.isNullOrBlank()) folder else exeBase
+        return cleanName(raw)
+    }
+
+    /** Strip bracketed tags, repack-group names, engine/arch suffixes and version tokens; tidy separators. */
+    private fun cleanName(raw: String): String? {
+        var s = raw
+        s = s.replace(Regex("""[\[(][^\])]*[\])]"""), " ") // (…) […]
+        s = VERSION_TOKEN_RE.replace(s, " ")
+        s = EXE_SUFFIX_RE.replace(s, " ")
+        s = s.replace(Regex("""[._]+"""), " ")
+        // Drop standalone repack-group words.
+        s = s.split(Regex("""[\s-]+"""))
+            .filter { it.isNotBlank() && it.lowercase() !in REPACK_TOKENS }
+            .joinToString(" ")
+        s = s.trim()
+        return s.ifBlank { null }
+    }
+
+    // ── tiny text/format helpers (regex-based → no Android/org.json dependency, unit-testable) ──
+
+    /** Read a small text file (guards against accidentally slurping a huge file). */
+    private fun readSmallTextFile(f: File, maxBytes: Long = 1L * 1024 * 1024): String? = try {
+        if (f.isFile && f.length() in 1..maxBytes) f.readText(Charsets.UTF_8) else null
+    } catch (_: Throwable) {
+        null
+    }
+
+    /** Value of a Valve KeyValues (.acf/.vdf) `"key"  "value"` pair, first match, case-insensitive key. */
+    private fun vdfValue(text: String, key: String): String? =
+        Regex(""""${Regex.escape(key)}"\s*"([^"]*)"""", RegexOption.IGNORE_CASE).find(text)?.groupValues?.getOrNull(1)?.trim()
+
+    /** Value of a JSON `"key": "value"` pair, first match. Sufficient for the flat goggame .info files. */
+    private fun jsonStringValue(text: String, key: String): String? =
+        Regex(""""${Regex.escape(key)}"\s*:\s*"([^"\\]*(?:\\.[^"\\]*)*)"""").find(text)
+            ?.groupValues?.getOrNull(1)?.replace("\\\"", "\"")?.replace("\\\\", "\\")?.trim()
+}
diff --git a/app/src/main/java/com/droiddeck/launcher/frontend/Library.kt b/app/src/main/java/com/droiddeck/launcher/frontend/Library.kt
index 56e115914..932460779 100644
--- a/app/src/main/java/com/droiddeck/launcher/frontend/Library.kt
+++ b/app/src/main/java/com/droiddeck/launcher/frontend/Library.kt
@@ -152,21 +152,24 @@ object Library {
     }
 
     /** The same installed-game inventory used for links, shortcuts and file exports. */
-    fun launchableGames(context: Context, strictRead: Boolean = false): List<SteamGame> {
+    /** [added]: the added games when the caller has just scanned them, so they are not scanned again. */
+    fun launchableGames(context: Context, strictRead: Boolean = false, added: List<AddedGames.Game>? = null): List<SteamGame> {
         val roots = steamLibraries(context).map { it.first }
-        return (steamGames(context, strictRead) + AddedGames.scan(context).map { g ->
-            AddedGameArt.resolve(context, g).let { art ->
-                SteamGame(
-                    g.steamAppId ?: g.appId.toInt(), g.name, art.portrait ?: art.header, ADDED, g.gameId,
-                    hero = art.hero ?: art.header, gameFiles = g.folder,
-                    protonPrefix = protonPrefix(context, g.steamAppId?.toLong() ?: g.appId, libraries = roots),
-                    icon = art.icon?.takeIf { it.extension.lowercase() != "ico" },
-                    source = g.source, storeId = g.storeId,
-                )
-            }
-        }).distinctBy { it.gameId }
+        return (steamGames(context, strictRead) + (added ?: AddedGames.scan(context)).map { g -> addedGame(context, g, roots) }).distinctBy { it.gameId }
     }
 
+    /** One added game as the Games tab lists it; [roots] the Steam libraries, for its Proton prefix. */
+    fun addedGame(context: Context, g: AddedGames.Game, roots: List<File> = steamLibraries(context).map { it.first }): SteamGame =
+        AddedGameArt.resolve(context, g).let { art ->
+            SteamGame(
+                g.steamAppId ?: g.appId.toInt(), g.name, art.portrait ?: art.header, ADDED, g.gameId,
+                hero = art.hero ?: art.header, gameFiles = g.folder,
+                protonPrefix = protonPrefix(context, g.steamAppId?.toLong() ?: g.appId, libraries = roots),
+                icon = art.icon?.takeIf { it.extension.lowercase() != "ico" },
+                source = g.source, storeId = g.storeId,
+            )
+        }
+
     /** Steam stores current library art inside hash-named folders under the app's cache dir. */
     private fun steamCacheImage(cache: File, appId: Int, names: List<String>): File? {
         val appDir = File(cache, appId.toString())
diff --git a/app/src/main/java/com/droiddeck/launcher/frontend/PeVersionInfo.kt b/app/src/main/java/com/droiddeck/launcher/frontend/PeVersionInfo.kt
new file mode 100644
index 000000000..77b61deca
--- /dev/null
+++ b/app/src/main/java/com/droiddeck/launcher/frontend/PeVersionInfo.kt
@@ -0,0 +1,250 @@
+package com.droiddeck.launcher.frontend
+
+import java.io.File
+import java.io.RandomAccessFile
+
+/**
+ * Reads the StringFileInfo strings (ProductName, FileDescription, …) out of the
+ * VS_VERSION_INFO resource embedded in a Windows PE executable (.exe).
+ *
+ * Walks the PE resource directory to the first RT_VERSION resource — the same
+ * navigation [com.droiddeck.launcher.files.PeIconExtractor] uses for icons — then parses the alignment-heavy
+ * VS_VERSIONINFO → StringFileInfo → StringTable → String tree by hand.
+ *
+ * Everything is best-effort: any malformed / oversized / unsupported input returns
+ * null (or an empty map). No allocation beyond the single resource blob.
+ */
+object PeVersionInfo {
+
+    private const val RT_VERSION = 16
+    private const val MAX_RES_SECTION = 64 * 1024 * 1024 // don't slurp absurd resource sections
+
+    /**
+     * Returns the StringFileInfo key→value map (e.g. `"ProductName" -> "Palworld"`),
+     * or null if the file has no readable version resource. Keys are the raw
+     * VS_VERSIONINFO names; look up [productName]/[fileDescription] for the common ones.
+     */
+    fun read(file: File): Map<String, String>? = try {
+        RandomAccessFile(file, "r").use { raf ->
+            val blob = versionResourceBytes(raf) ?: return@use null
+            parseStringFileInfo(blob).takeIf { it.isNotEmpty() }
+        }
+    } catch (_: Throwable) {
+        null
+    }
+
+    /**
+     * Best display name from a version map. ProductName is usually the cleanest title, but is
+     * sometimes an internal abbreviation (e.g. God of War ships ProductName "GoW" while
+     * FileDescription is "God of War"). When ProductName is a single spaceless token and
+     * FileDescription is a normal multi-word title, prefer FileDescription. Trimmed; null if
+     * neither is meaningful.
+     */
+    fun bestName(map: Map<String, String>?): String? {
+        if (map == null) return null
+        val product = map["ProductName"]?.trim()?.takeIf { it.isNotEmpty() }
+        val desc = map["FileDescription"]?.trim()?.takeIf { it.isNotEmpty() }
+        if (product != null && desc != null &&
+            !product.contains(' ') && desc.contains(' ') && desc.length <= 60
+        ) {
+            return desc
+        }
+        return product ?: desc
+    }
+
+    // ── locate the RT_VERSION resource blob (mirrors PeIconExtractor's navigation) ──
+
+    private fun versionResourceBytes(raf: RandomAccessFile): ByteArray? {
+        val dos = read(raf, 0, 0x40) ?: return null
+        if (u8(dos, 0) != 0x4D || u8(dos, 1) != 0x5A) return null // "MZ"
+        val peOff = u32(dos, 0x3C).toInt()
+
+        val coff = read(raf, peOff.toLong(), 24) ?: return null
+        if (u8(coff, 0) != 0x50 || u8(coff, 1) != 0x45 || u8(coff, 2) != 0 || u8(coff, 3) != 0) return null // "PE\0\0"
+        val numSections = u16(coff, 6)
+        val sizeOpt = u16(coff, 20)
+        if (numSections <= 0 || numSections > 96 || sizeOpt <= 0) return null
+
+        val optOff = peOff + 24L
+        val opt = read(raf, optOff, sizeOpt) ?: return null
+        val magic = u16(opt, 0)
+        val ddOff = if (magic == 0x20B) 112 else 96 // PE32+ vs PE32 data-directory offset
+        val resDirEntry = ddOff + 2 * 8 // data directory index 2 = resource table
+        if (resDirEntry + 8 > opt.size) return null
+        val resRVA = u32(opt, resDirEntry).toInt()
+        val resSize = u32(opt, resDirEntry + 4).toInt()
+        if (resRVA == 0 || resSize == 0) return null
+
+        val secTabOff = optOff + sizeOpt
+        val secTab = read(raf, secTabOff, numSections * 40) ?: return null
+
+        var secVA = 0
+        var secPtr = 0L
+        var secRaw = 0
+        var found = false
+        for (i in 0 until numSections) {
+            val o = i * 40
+            if (o + 40 > secTab.size) break
+            val va = u32(secTab, o + 12).toInt()
+            val vSize = u32(secTab, o + 8).toInt()
+            val raw = u32(secTab, o + 16).toInt()
+            val pRaw = u32(secTab, o + 20)
+            val span = maxOf(vSize, raw)
+            if (resRVA >= va && resRVA < va + span) {
+                secVA = va; secPtr = pRaw; secRaw = raw; found = true; break
+            }
+        }
+        if (!found || secRaw <= 0 || secRaw > MAX_RES_SECTION) return null
+
+        val res = read(raf, secPtr, secRaw) ?: return null
+        val resDirStart = resRVA - secVA
+        if (resDirStart < 0 || resDirStart + 16 > res.size) return null
+
+        val verTypeDir = findIdSubdir(res, resDirStart, RT_VERSION, resDirStart) ?: return null
+        val verData = firstDataEntry(res, verTypeDir, resDirStart) ?: return null
+        return dataEntryBytes(res, verData, secVA)
+    }
+
+    /** Resolve the sub-directory under [dirIdx] whose id matches [wantId]; null if absent or not a directory. */
+    private fun findIdSubdir(res: ByteArray, dirIdx: Int, wantId: Int, resDirStart: Int): Int? {
+        if (dirIdx + 16 > res.size) return null
+        val total = u16(res, dirIdx + 12) + u16(res, dirIdx + 14)
+        val start = dirIdx + 16
+        for (i in 0 until total) {
+            val e = start + i * 8
+            if (e + 8 > res.size) break
+            val id = u32(res, e)
+            val off = u32(res, e + 4)
+            if (id and 0x80000000L == 0L && id.toInt() == wantId) {
+                if (off and 0x80000000L != 0L) return resDirStart + (off and 0x7FFFFFFFL).toInt()
+                return null
+            }
+        }
+        return null
+    }
+
+    /** Descend the first entry of each level until an IMAGE_RESOURCE_DATA_ENTRY; returns its index. */
+    private fun firstDataEntry(res: ByteArray, dirIdx: Int, resDirStart: Int): Int? {
+        if (dirIdx + 16 > res.size) return null
+        if (u16(res, dirIdx + 12) + u16(res, dirIdx + 14) == 0) return null
+        val e = dirIdx + 16
+        if (e + 8 > res.size) return null
+        val off = u32(res, e + 4)
+        return if (off and 0x80000000L != 0L) {
+            firstDataEntry(res, resDirStart + (off and 0x7FFFFFFFL).toInt(), resDirStart)
+        } else {
+            resDirStart + off.toInt()
+        }
+    }
+
+    /** Read the bytes an IMAGE_RESOURCE_DATA_ENTRY points at (its OffsetToData is an RVA). */
+    private fun dataEntryBytes(res: ByteArray, entryIdx: Int, secVA: Int): ByteArray? {
+        if (entryIdx < 0 || entryIdx + 8 > res.size) return null
+        val rva = u32(res, entryIdx).toInt()
+        val size = u32(res, entryIdx + 4).toInt()
+        val start = rva - secVA
+        if (size <= 0 || start < 0 || start + size > res.size) return null
+        return res.copyOfRange(start, start + size)
+    }
+
+    // ── VS_VERSIONINFO tree parse ──
+    //
+    // Every node is: WORD wLength, WORD wValueLength, WORD wType, WCHAR szKey[],
+    // then (32-bit aligned) an optional Value, then (32-bit aligned) child nodes.
+    // We only care about: VS_VERSIONINFO → StringFileInfo → StringTable → String.
+
+    private fun parseStringFileInfo(b: ByteArray): Map<String, String> {
+        val out = LinkedHashMap<String, String>()
+        if (b.size < 6) return out
+        val rootLen = minOf(u16(b, 0), b.size)
+        // VS_VERSION_INFO header: skip szKey "VS_VERSION_INFO" then the FIXEDFILEINFO value.
+        val rootValLen = u16(b, 2)
+        var pos = align4(6 + (utf16zLen(b, 6) + 1) * 2)
+        pos = align4(pos + rootValLen)
+
+        while (pos + 6 <= rootLen) {
+            val childLen = u16(b, pos)
+            if (childLen < 6 || pos + childLen > b.size) break
+            val key = utf16z(b, pos + 6)
+            if (key == "StringFileInfo") parseTables(b, pos, pos + childLen, out)
+            pos = align4(pos + childLen)
+            if (childLen == 0) break
+        }
+        return out
+    }
+
+    /** Iterate the StringTable children inside a StringFileInfo block [start, end). */
+    private fun parseTables(b: ByteArray, start: Int, end: Int, out: MutableMap<String, String>) {
+        var p = align4(start + 6 + (utf16zLen(b, start + 6) + 1) * 2)
+        while (p + 6 <= end) {
+            val tableLen = u16(b, p)
+            if (tableLen < 6 || p + tableLen > end) break
+            parseStrings(b, p, minOf(p + tableLen, end), out)
+            p = align4(p + tableLen)
+            if (tableLen == 0) break
+        }
+    }
+
+    /** Iterate the String children inside a StringTable block [start, end). */
+    private fun parseStrings(b: ByteArray, start: Int, end: Int, out: MutableMap<String, String>) {
+        var q = align4(start + 6 + (utf16zLen(b, start + 6) + 1) * 2)
+        while (q + 6 <= end) {
+            val strLen = u16(b, q)
+            if (strLen < 6 || q + strLen > end) break
+            val key = utf16z(b, q + 6)
+            val valOff = align4(q + 6 + (key.length + 1) * 2)
+            if (key.isNotEmpty() && valOff < q + strLen) {
+                val value = utf16z(b, valOff, q + strLen).trim()
+                if (value.isNotEmpty()) out[key] = value
+            }
+            q = align4(q + strLen)
+            if (strLen == 0) break
+        }
+    }
+
+    // ── little-endian / UTF-16 readers ──
+
+    private fun align4(x: Int): Int = (x + 3) and 3.inv()
+
+    /** Number of UTF-16 code units before the null terminator starting at [off]. */
+    private fun utf16zLen(b: ByteArray, off: Int): Int {
+        var i = off
+        while (i + 1 < b.size) {
+            if (b[i].toInt() == 0 && b[i + 1].toInt() == 0) break
+            i += 2
+        }
+        return (i - off) / 2
+    }
+
+    /** Read a null-terminated UTF-16LE string starting at [off], not reading past [limit]. */
+    private fun utf16z(b: ByteArray, off: Int, limit: Int = b.size): String {
+        val sb = StringBuilder()
+        var i = off
+        val end = minOf(limit, b.size)
+        while (i + 1 < end) {
+            val c = u8(b, i) or (u8(b, i + 1) shl 8)
+            if (c == 0) break
+            sb.append(c.toChar())
+            i += 2
+        }
+        return sb.toString()
+    }
+
+    private fun u8(b: ByteArray, off: Int): Int = if (off < 0 || off >= b.size) 0 else b[off].toInt() and 0xFF
+    private fun u16(b: ByteArray, off: Int): Int = u8(b, off) or (u8(b, off + 1) shl 8)
+    private fun u32(b: ByteArray, off: Int): Long =
+        u8(b, off).toLong() or (u8(b, off + 1).toLong() shl 8) or
+            (u8(b, off + 2).toLong() shl 16) or (u8(b, off + 3).toLong() shl 24)
+
+    private fun read(raf: RandomAccessFile, pos: Long, len: Int): ByteArray? {
+        if (len <= 0 || pos < 0) return null
+        val fileLen = raf.length()
+        if (pos >= fileLen) return null
+        val n = minOf(len.toLong(), fileLen - pos).toInt()
+        if (n <= 0) return null
+        val buf = ByteArray(n)
+        raf.seek(pos)
+        raf.readFully(buf)
+        return buf
+    }
+}
diff --git a/app/src/main/java/com/droiddeck/launcher/frontend/SteamGridDb.kt b/app/src/main/java/com/droiddeck/launcher/frontend/SteamGridDb.kt
new file mode 100644
index 000000000..630fb64cd
--- /dev/null
+++ b/app/src/main/java/com/droiddeck/launcher/frontend/SteamGridDb.kt
@@ -0,0 +1,160 @@
+package com.droiddeck.launcher.frontend
+
+import android.content.Context
+import android.util.Log
+import androidx.annotation.VisibleForTesting
+import com.droiddeck.launcher.stores.CredentialCipher
+import org.json.JSONArray
+import org.json.JSONObject
+import java.io.File
+import java.net.HttpURLConnection
+import java.net.URL
+import java.net.URLEncoder
+
+/**
+ * SteamGridDB, the art source after Steam's store: a game by its Steam appid, else by a search
+ * whose result must carry the same name, then its best-rated grids, heroes, logos and icons.
+ *
+ * The API key: the user's own (Steam settings › Games), sealed with [CredentialCipher] in the
+ * app's files, else the one the build carries (`BuildConfig.SGDB_API_KEY`, from a CI secret), else
+ * none, and then this step is skipped. The key travels only in the Authorization header and is
+ * never logged.
+ */
+object SteamGridDb {
+    private const val TAG = "SteamGridDb"
+    private const val API = "https://www.steamgriddb.com/api/v2"
+    private const val QUERY = "nsfw=false&humor=false"
+
+    @VisibleForTesting
+    @Volatile
+    internal var keys: CredentialCipher.KeyProvider = CredentialCipher.Keystore
+
+    private fun keyFile(context: Context) = File(context.filesDir, "sgdb/key.json")
+
+    /** The key the build carries, or "" (a build without the secret, a fork's PR build). */
+    fun builtInKey(): String = runCatching {
+        Class.forName("com.droiddeck.launcher.BuildConfig").getField("SGDB_API_KEY").get(null) as? String
+    }.getOrNull().orEmpty()
+
+    /** The user's key wins, then the build's; "" when there is neither. */
+    fun pick(user: String, builtIn: String): String = user.trim().ifEmpty { builtIn.trim() }
+
+    fun key(context: Context): String = pick(userKey(context), builtInKey())
+
+    /** The key the user entered, or "". */
+    @Synchronized
+    fun userKey(context: Context): String {
+        val f = keyFile(context)
+        if (!f.isFile) return ""
+        return try {
+            val json = JSONObject(f.readText())
+            if (CredentialCipher.isEnvelope(json)) CredentialCipher.open(json, keys) else json.optString("key")
+        } catch (e: Exception) {
+            if (CredentialCipher.isPermanent(e)) f.delete()
+            Log.w(TAG, "the saved key cannot be read (${e.javaClass.simpleName})")
+            ""
+        }
+    }
+
+    /** Saves the user's key sealed (plain only where the Keystore does not work); "" clears it. */
+    @Synchronized
+    fun setUserKey(context: Context, key: String) {
+        val f = keyFile(context)
+        val value = key.trim()
+        if (value.isEmpty()) { f.delete(); return }
+        f.parentFile?.mkdirs()
+        val text = try {
+            CredentialCipher.seal(value, keys).toString()
+        } catch (e: Exception) {
+            Log.w(TAG, "keystore unavailable, the key stays plain (${e.javaClass.simpleName})")
+            JSONObject().put("key", value).toString()
+        }
+        val tmp = File(f.path + ".tmp")
+        tmp.writeText(text)
+        tmp.setReadable(false, false); tmp.setReadable(true, true)
+        if (!tmp.renameTo(f)) { f.delete(); tmp.renameTo(f) }
+    }
+
+    /** The SteamGridDB game id for [steamAppId], else for a search on [name] that returns the same name; null when neither. */
+    fun gameId(key: String, steamAppId: Int?, name: String): Int? {
+        if (steamAppId != null) {
+            json(key, "$API/games/steam/$steamAppId")?.optJSONObject("data")?.optInt("id")?.takeIf { it > 0 }?.let { return it }
+        }
+        val term = URLEncoder.encode(name, "UTF-8").replace("+", "%20")
+        val results = json(key, "$API/search/autocomplete/$term")?.optJSONArray("data") ?: return null
+        return match(name, (0 until results.length()).map { results.getJSONObject(it) }.map { it.optInt("id") to it.optString("name") })
+    }
+
+    /** The id of the first result whose name matches [name] ([AddedGameArt.nameMatch]); no blind first pick. */
+    internal fun match(name: String, results: List<Pair<Int, String>>): Int? =
+        results.map { (id, got) -> id to AddedGameArt.nameMatch(name, got) }
+            .filter { it.second > 0 && it.first > 0 }
+            .maxByOrNull { it.second }?.first
+
+    /**
+     * Fetches what is missing into [cache] under the names Steam's art uses there (p.jpg,
+     * header.jpg, hero.jpg, logo.png) and the icon as icon-sgdb.png. True when anything arrived.
+     */
+    fun download(key: String, id: Int, cache: File): Boolean {
+        var got = false
+        for ((path, local) in listOf(
+            "grids/game/$id?dimensions=600x900&$QUERY" to "p.jpg",
+            "grids/game/$id?dimensions=460x215,920x430&$QUERY" to "header.jpg",
+            "heroes/game/$id?$QUERY" to "hero.jpg",
+            "logos/game/$id?$QUERY" to "logo.png",
+            "icons/game/$id?$QUERY" to "icon-sgdb.png",
+        )) {
+            val dst = File(cache, local)
+            if (dst.isFile) continue
+            val items = json(key, "$API/$path")?.optJSONArray("data") ?: continue
+            val url = best(items, local.endsWith(".png")) ?: continue
+            val bytes = AddedGameArt.get(url) ?: continue
+            val tmp = File(cache, "$local.tmp")
+            tmp.writeBytes(bytes)
+            if (tmp.renameTo(dst)) { got = true; File(cache, "$local.src").writeText(AddedGameArt.SGDB) }
+        }
+        return got
+    }
+
+    /** The best-scored [limit] images for [slot] of game [id], as (thumbnail, full image) URLs. */
+    fun images(key: String, id: Int, slot: AddedGameArt.Slot, limit: Int): List<Pair<String, String>> {
+        val path = when (slot) {
+            AddedGameArt.Slot.COVER -> "grids/game/$id?dimensions=600x900&$QUERY"
+            AddedGameArt.Slot.BACKGROUND -> "heroes/game/$id?$QUERY"
+            AddedGameArt.Slot.LOGO -> "logos/game/$id?$QUERY"
+            AddedGameArt.Slot.ICON -> "icons/game/$id?$QUERY"
+        }
+        val items = json(key, "$API/$path")?.optJSONArray("data") ?: return emptyList()
+        return ranked(items, pngOnly = slot == AddedGameArt.Slot.LOGO || slot == AddedGameArt.Slot.ICON).take(limit)
+    }
+
+    /** [items] best-scored first, as (thumbnail, full image) URLs; for a .png slot only PNGs. */
+    internal fun ranked(items: JSONArray, pngOnly: Boolean): List<Pair<String, String>> =
+        (0 until items.length()).map { items.getJSONObject(it) }
+            .filter { it.optString("url").startsWith("https://") && (!pngOnly || it.optString("mime") == "image/png" || it.optString("url").endsWith(".png", true)) }
+            .sortedByDescending { it.optInt("score", 0) }
+            .map { (it.optString("thumb").takeIf { t -> t.startsWith("https://") } ?: it.optString("url")) to it.optString("url") }
+
+    /** The highest-scored image's URL; for a .png slot only a PNG. */
+    internal fun best(items: JSONArray, pngOnly: Boolean): String? =
+        (0 until items.length()).map { items.getJSONObject(it) }
+            .filter { it.optString("url").startsWith("https://") && (!pngOnly || it.optString("mime") == "image/png" || it.optString("url").endsWith(".png", true)) }
+            .maxByOrNull { it.optInt("score", 0) }?.optString("url")
+
+    /** A GET with the key in its Authorization header; the body as JSON, or null. Logs the path only. */
+    private fun json(key: String, url: String): JSONObject? {
+        val c = URL(url).openConnection() as HttpURLConnection
+        c.connectTimeout = 10_000
+        c.readTimeout = 15_000
+        c.setRequestProperty("User-Agent", "DroidDeck-launcher")
+        c.setRequestProperty("Authorization", "Bearer $key")
+        return try {
+            if (c.responseCode != 200) { Log.w(TAG, "${URL(url).path}: HTTP ${c.responseCode}"); null }
+            else JSONObject(c.inputStream.use { it.readBytes() }.toString(Charsets.UTF_8)).takeIf { it.optBoolean("success", true) }
+        } catch (e: Exception) {
+            Log.w(TAG, "${URL(url).path}: ${e.javaClass.simpleName}"); null
+        } finally {
+            c.disconnect()
+        }
+    }
+}
diff --git a/app/src/main/java/com/droiddeck/launcher/session/SessionPrefs.kt b/app/src/main/java/com/droiddeck/launcher/session/SessionPrefs.kt
index af23de85c..735e2103f 100644
--- a/app/src/main/java/com/droiddeck/launcher/session/SessionPrefs.kt
+++ b/app/src/main/java/com/droiddeck/launcher/session/SessionPrefs.kt
@@ -625,6 +625,60 @@ object SessionPrefs {
         prefs(context).edit().putString("addedGamesDirs", dirs.distinct().joinToString("\n")).remove("addedGamesDir").apply()
     }
 
+    /**
+     * Game folders (by path) the user removed from the added games: a scan skips them, so they
+     * stay off the Games tab and out of Steam until restored. Nothing on disk is touched.
+     */
+    fun removedAddedGames(context: Context): List<String> =
+        (prefs(context).getString("removedAddedGames", "") ?: "").split('\n').filter { it.isNotEmpty() }
+
+    fun setAddedGameRemoved(context: Context, folderPath: String, removed: Boolean) {
+        synchronized(addedGameLock) {
+            val now = removedAddedGames(context).filter { it != folderPath } + listOfNotNull(folderPath.takeIf { removed })
+            prefs(context).edit().putString("removedAddedGames", now.joinToString("\n")).apply()
+        }
+    }
+
+    /** An added game's name as the user set it (in the app, or in Steam's Properties); "" = automatic. */
+    fun addedGameName(context: Context, folderPath: String): String = prefs(context).getString("addedName:$folderPath", "") ?: ""
+
+    fun setAddedGameName(context: Context, folderPath: String, name: String) {
+        prefs(context).edit().putString("addedName:$folderPath", name.trim()).apply()
+    }
+
+    /** An added game's Start in, as the session sees it; "" = the exe's own folder. */
+    fun addedGameStartIn(context: Context, folderPath: String): String = prefs(context).getString("addedStartIn:$folderPath", "") ?: ""
+
+    fun setAddedGameStartIn(context: Context, folderPath: String, guestDir: String) {
+        prefs(context).edit().putString("addedStartIn:$folderPath", guestDir.trim()).apply()
+    }
+
+    /** An added game's launch options, as Steam takes them ("-dx11", "VAR=1 %command%"). */
+    fun addedGameLaunch(context: Context, folderPath: String): String = prefs(context).getString("addedLaunch:$folderPath", "") ?: ""
+
+    fun setAddedGameLaunch(context: Context, folderPath: String, options: String) {
+        prefs(context).edit().putString("addedLaunch:$folderPath", options.trim()).apply()
+    }
+
+    /**
+     * The last value of [field] (AppName, StartDir, LaunchOptions) taken over from Steam's own
+     * Properties for this game, so the same Steam edit is not taken again over a later app edit.
+     */
+    fun addedGameAdopted(context: Context, folderPath: String, field: String): String? =
+        prefs(context).getString("addedAdopted:$field:$folderPath", null)
+
+    fun setAddedGameAdopted(context: Context, folderPath: String, field: String, value: String) {
+        prefs(context).edit().putString("addedAdopted:$field:$folderPath", value).apply()
+    }
+
+    /** Where an added game's art for [slot] comes from when the user chose it ("folder", "steam", "sgdb", "file"); "" = automatic. */
+    fun addedGameArtSource(context: Context, folderPath: String, slot: String): String =
+        prefs(context).getString("addedArt:$slot:$folderPath", "") ?: ""
+
+    fun setAddedGameArtSource(context: Context, folderPath: String, slot: String, source: String) {
+        prefs(context).edit().putString("addedArt:$slot:$folderPath", source).apply()
+    }
+
     /** Whether added games without art of their own get Steam's store art fetched for them. */
     fun addedGamesArt(context: Context): Boolean = prefs(context).getBoolean("addedGamesArt", true)
 
@@ -650,6 +704,10 @@ object SessionPrefs {
             unchanged
         }
 
+    /** The shortcut appid stored for the folder, or null before its first scan. */
+    fun addedGameStoredAppId(context: Context, folderPath: String): Long? =
+        prefs(context).getLong("addedAppId:$folderPath", 0L).takeIf { it != 0L }
+
     fun addedGameAppId(context: Context, folderPath: String, first: Long): Long = synchronized(addedGameLock) {
         val p = prefs(context)
         p.getLong("addedAppId:$folderPath", 0L).takeIf { it != 0L }
diff --git a/app/src/main/java/com/droiddeck/launcher/stores/SteamLiveShortcuts.kt b/app/src/main/java/com/droiddeck/launcher/stores/SteamLiveShortcuts.kt
index 475af804e..250a37346 100644
--- a/app/src/main/java/com/droiddeck/launcher/stores/SteamLiveShortcuts.kt
+++ b/app/src/main/java/com/droiddeck/launcher/stores/SteamLiveShortcuts.kt
@@ -36,9 +36,9 @@ object SteamLiveShortcuts {
     private const val TAG_NAME = "droiddeck-app"
     private const val COMPAT_TOOL = "droiddeck-proton-arm64"
 
-    /** Adds every store game in [games] the client does not list yet. Blocking; worker thread. */
-    fun sync(context: Context, games: List<AddedGames.Game>) {
-        val wanted = games.filter { it.source != Library.ADDED }
+    /** Adds every game in [games] that [include] takes (store games by default) and the client does not list yet. Blocking; worker thread. */
+    fun sync(context: Context, games: List<AddedGames.Game>, include: (AddedGames.Game) -> Boolean = { it.source != Library.ADDED }) {
+        val wanted = games.filter(include)
         if (wanted.isEmpty() || !clientRunning()) return
         val list = JSONArray()
         for (g in wanted) list.put(JSONObject().put("name", g.name).put("exe", g.guestExe).put("dir", g.guestDir))
@@ -71,6 +71,47 @@ object SteamLiveShortcuts {
         if (result != null) Log.i(TAG, "live shortcuts: removed $appId")
     }
 
+    /**
+     * The running client's shortcut for [game] made to match it: name, target, Start in and
+     * launch options, on the same appid (an edit never adds a second shortcut). Blocking.
+     */
+    fun update(context: Context, game: AddedGames.Game) {
+        if (!clientRunning()) return
+        val id = game.appId and 0xFFFFFFFFL
+        val js = """
+            (async () => {
+              const id = $id;
+              try { SteamClient.Apps.SetShortcutName(id, ${JSONObject.quote(game.name)}); } catch (e) {}
+              try { SteamClient.Apps.SetShortcutExe(id, ${JSONObject.quote("\"" + game.guestExe + "\"")}); } catch (e) {}
+              try { SteamClient.Apps.SetShortcutStartDir(id, ${JSONObject.quote("\"" + game.guestDir + "\"")}); } catch (e) {}
+              try { SteamClient.Apps.SetShortcutLaunchOptions(id, ${JSONObject.quote(game.launchOptions)}); } catch (e) {}
+              return 1;
+            })()
+        """.trimIndent()
+        if (evaluate(context, js) != null) Log.i(TAG, "live shortcuts: updated $id")
+    }
+
+    /**
+     * One piece of art for the running client's shortcut [appId]: [assetType] as the client numbers
+     * them (0 portrait capsule, 1 hero, 2 logo, 3 wide capsule), from [file]; null clears it. The
+     * icon goes by path ([iconPath]). Blocking.
+     */
+    fun setArt(context: Context, appId: Long, assetType: Int?, file: java.io.File?, iconPath: String? = null) {
+        if (!clientRunning()) return
+        val id = appId and 0xFFFFFFFFL
+        val js = when {
+            iconPath != null -> "(async () => { try { SteamClient.Apps.SetShortcutIcon($id, ${JSONObject.quote(iconPath)}); } catch (e) {} return 1; })()"
+            assetType == null -> return
+            file == null -> "(async () => { try { await SteamClient.Apps.ClearCustomArtworkForApp($id, $assetType); } catch (e) {} return 1; })()"
+            else -> {
+                val data = runCatching { Base64.encodeToString(file.readBytes(), Base64.NO_WRAP) }.getOrNull() ?: return
+                val type = if (file.extension.equals("png", true)) "png" else "jpg"
+                "(async () => { try { await SteamClient.Apps.SetCustomArtworkForApp($id, ${JSONObject.quote(data)}, ${JSONObject.quote(type)}, $assetType); } catch (e) {} return 1; })()"
+            }
+        }
+        if (evaluate(context, js) != null) Log.i(TAG, "live shortcuts: art $assetType for $id")
+    }
+
     private fun clientRunning(): Boolean = SessionState.running && SessionState.mode == SessionService.MODE_STEAM && !SessionState.stopRequested
 
     /** `Runtime.evaluate` of [expression] in the client's SharedJSContext; the value as text, or null. */
diff --git a/app/src/main/java/com/droiddeck/launcher/stores/StoreInstalls.kt b/app/src/main/java/com/droiddeck/launcher/stores/StoreInstalls.kt
index 91c034574..acda6dd92 100644
--- a/app/src/main/java/com/droiddeck/launcher/stores/StoreInstalls.kt
+++ b/app/src/main/java/com/droiddeck/launcher/stores/StoreInstalls.kt
@@ -64,7 +64,7 @@ object StoreInstalls {
         try {
             val games = AddedGames.scan(app)
             AddedGames.writeListing(app, games)
-            LibraryCache.save(app, Library.launchableGames(app))
+            LibraryCache.save(app, Library.launchableGames(app, added = games))
             SteamLiveShortcuts.sync(app, games)
         } catch (e: Exception) {
             Log.w(TAG, "registration: ${e.message}")
diff --git a/app/src/main/java/com/droiddeck/launcher/ui/AddAppDialog.kt b/app/src/main/java/com/droiddeck/launcher/ui/AddAppDialog.kt
index 07237e0de..31b8f46d6 100644
--- a/app/src/main/java/com/droiddeck/launcher/ui/AddAppDialog.kt
+++ b/app/src/main/java/com/droiddeck/launcher/ui/AddAppDialog.kt
@@ -41,6 +41,7 @@ import androidx.compose.foundation.layout.heightIn
 import androidx.compose.foundation.layout.imePadding
 import androidx.compose.foundation.layout.padding
 import androidx.compose.foundation.layout.size
+import androidx.compose.foundation.layout.width
 import androidx.compose.foundation.layout.widthIn
 import androidx.compose.foundation.rememberScrollState
 import androidx.compose.foundation.shape.RoundedCornerShape
@@ -313,12 +314,17 @@ internal fun rememberShown(onDismiss: () -> Unit): MutableTransitionState<Boolea
 @Composable
 internal fun AppDialog(
     shown: MutableTransitionState<Boolean>, close: () -> Unit, label: String, wide: Boolean,
-    modifier: Modifier = Modifier, maxWidth: Dp? = null, content: @Composable ColumnScope.() -> Unit,
+    modifier: Modifier = Modifier, maxWidth: Dp? = null,
+    /** [width] fixed, else as wide as its content when [fitContent], else as wide as it may be. */
+    width: Dp? = null, fitContent: Boolean = false,
+    /** What B / Back does, when not [close] (a picker goes up a folder first). */
+    back: (() -> Unit)? = null,
+    content: @Composable ColumnScope.() -> Unit,
 ) {
     val pal = LocalPalette.current
     // The page's ring stays out of sight behind it.
     VeilRing()
-    Dialog(onDismissRequest = close, properties = DialogProperties(usePlatformDefaultWidth = false, decorFitsSystemWindows = false)) {
+    Dialog(onDismissRequest = back ?: close, properties = DialogProperties(usePlatformDefaultWidth = false, decorFitsSystemWindows = false)) {
       // The page's focus memory stays the page's: nothing in here is a place to come back to.
       CompositionLocalProvider(LocalFrontFocus provides null) {
         Box(
@@ -337,14 +343,20 @@ internal fun AppDialog(
                     modifier = Modifier
                         .padding(12.dp)
                         .widthIn(max = maxWidth ?: if (wide) 860.dp else 560.dp)
-                        .fillMaxWidth()
+                        .then(
+                            when {
+                                width != null -> Modifier.width(width)
+                                fitContent -> Modifier.width(androidx.compose.foundation.layout.IntrinsicSize.Max)
+                                else -> Modifier.fillMaxWidth()
+                            },
+                        )
                         .heightIn(max = (LocalConfiguration.current.screenHeightDp - 24).dp)
                         .shadow(24.dp, Shape16, ambientColor = Color.Black, spotColor = Color.Black)
                         .clip(Shape16)
                         .background(pal.surfaceVariant.copy(alpha = 0.97f))
                         .border(1.dp, pal.signal.copy(alpha = 0.22f), Shape16)
                         .clickable(interactionSource = remember { MutableInteractionSource() }, indication = null) {}
-                        .controllerBack(close)
+                        .controllerBack(back ?: close)
                         .then(modifier)
                         .verticalScroll(rememberScrollState())
                         .padding(horizontal = 18.dp, vertical = 16.dp),
diff --git a/app/src/main/java/com/droiddeck/launcher/ui/AddedGameEditor.kt b/app/src/main/java/com/droiddeck/launcher/ui/AddedGameEditor.kt
new file mode 100644
index 000000000..1822ee527
--- /dev/null
+++ b/app/src/main/java/com/droiddeck/launcher/ui/AddedGameEditor.kt
@@ -0,0 +1,555 @@
+package com.droiddeck.launcher.ui
+
+import androidx.compose.foundation.background
+import androidx.compose.foundation.border
+import androidx.compose.foundation.clickable
+import androidx.compose.foundation.hoverable
+import androidx.compose.foundation.layout.Arrangement
+import androidx.compose.foundation.layout.Box
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.ExperimentalLayoutApi
+import androidx.compose.foundation.layout.FlowRow
+import androidx.compose.foundation.layout.Row
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.heightIn
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.layout.size
+import androidx.compose.foundation.layout.width
+import androidx.compose.foundation.rememberScrollState
+import androidx.compose.foundation.shape.RoundedCornerShape
+import androidx.compose.foundation.verticalScroll
+import androidx.compose.material.icons.Icons
+import androidx.compose.material.icons.filled.Close
+import androidx.compose.material.icons.automirrored.filled.ArrowBack
+import androidx.compose.material.icons.outlined.Image
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.Text
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.LaunchedEffect
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.key
+import androidx.compose.runtime.mutableIntStateOf
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.remember
+import androidx.compose.runtime.rememberCoroutineScope
+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.focus.FocusRequester
+import androidx.compose.ui.focus.focusRequester
+import androidx.compose.ui.layout.ContentScale
+import androidx.compose.ui.platform.LocalConfiguration
+import androidx.compose.ui.platform.LocalContext
+import androidx.compose.ui.res.pluralStringResource
+import androidx.compose.ui.res.stringResource
+import androidx.compose.ui.semantics.Role
+import androidx.compose.ui.semantics.contentDescription
+import androidx.compose.ui.semantics.semantics
+import androidx.compose.ui.text.font.FontWeight
+import androidx.compose.ui.text.style.TextOverflow
+import androidx.compose.ui.unit.Dp
+import androidx.compose.ui.unit.dp
+import androidx.compose.ui.unit.sp
+import coil.compose.AsyncImage
+import com.droiddeck.launcher.R
+import com.droiddeck.launcher.frontend.AddedGameArt
+import com.droiddeck.launcher.frontend.AddedGameEdits
+import com.droiddeck.launcher.frontend.AddedGames
+import com.droiddeck.launcher.session.SessionPrefs
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.launch
+import kotlinx.coroutines.withContext
+import java.io.File
+
+/** Each art slot's thumbnail, in its true shape: width, height, corner. */
+private fun AddedGameArt.Slot.shape(): Triple<Dp, Dp, Dp> = when (this) {
+    AddedGameArt.Slot.COVER -> Triple(28.dp, 41.dp, 5.dp)
+    AddedGameArt.Slot.BACKGROUND -> Triple(60.dp, 34.dp, 5.dp)
+    AddedGameArt.Slot.LOGO -> Triple(60.dp, 26.dp, 5.dp)
+    AddedGameArt.Slot.ICON -> Triple(30.dp, 30.dp, 7.dp)
+}
+
+@Composable
+private fun AddedGameArt.Slot.label(): String = stringResource(
+    when (this) {
+        AddedGameArt.Slot.COVER -> R.string.art_cover
+        AddedGameArt.Slot.BACKGROUND -> R.string.art_background
+        AddedGameArt.Slot.LOGO -> R.string.art_logo
+        AddedGameArt.Slot.ICON -> R.string.art_icon
+    },
+)
+
+@Composable
+private fun artSourceLabel(source: String): String = stringResource(
+    when (source) {
+        AddedGameArt.FOLDER -> R.string.art_src_folder
+        AddedGameArt.STEAM -> R.string.art_src_steam
+        AddedGameArt.SGDB -> R.string.art_src_sgdb
+        AddedGameArt.FILE -> R.string.art_src_file
+        AddedGameArt.EXE -> R.string.art_src_exe
+        else -> R.string.art_src_auto
+    },
+)
+
+/** A thumbnail of [model] (a file or URL) in [slot]'s shape, scaled by [scale]. */
+@Composable
+private fun SlotThumb(slot: AddedGameArt.Slot, model: Any?, scale: Float = 1f, selected: Boolean = false) {
+    val pal = LocalPalette.current
+    val (w, h, r) = slot.shape()
+    val shape = RoundedCornerShape(r)
+    Box(
+        Modifier.size(w * scale, h * scale).clip(shape).background(MaterialTheme.colorScheme.surfaceVariant)
+            .border(if (selected) 2.dp else 1.dp, if (selected) pal.signal else pal.line, shape),
+    ) {
+        if (model != null) AsyncImage(
+            model = model, contentDescription = null,
+            contentScale = if (slot == AddedGameArt.Slot.LOGO || slot == AddedGameArt.Slot.ICON) ContentScale.Fit else ContentScale.Crop,
+            modifier = Modifier.matchParentSize(),
+        )
+    }
+}
+
+/** A row of the editor: a label column, then the value. */
+@Composable
+private fun FieldRow(label: String, focus: FocusRequester? = null, onClick: () -> Unit, value: @Composable () -> Unit) {
+    ListRow(focus = focus, onClick = onClick) {
+        Text(label, fontSize = 14.sp, color = MaterialTheme.colorScheme.onSurfaceVariant, maxLines = 1, overflow = TextOverflow.Ellipsis, modifier = Modifier.width(110.dp))
+        Box(Modifier.weight(1f)) { value() }
+    }
+}
+
+/** Where the editor opens: its game's folder, straight on Target, and whether it came from the added-games summary. */
+internal class EditRequest(val folder: String, val openTarget: Boolean, val fromSummary: Boolean, val preview: EditPreview)
+
+/**
+ * What the editor shows on its first frame, from what the page already has (the game's row, or
+ * the summary's); the rest (the ranked exes, where each piece of art came from) follows.
+ * [exeName] / [startIn] null = not known yet.
+ */
+internal class EditPreview(
+    val name: String, val exeName: String?, val startIn: String?, val launchOptions: String,
+    val art: Map<AddedGameArt.Slot, File?>,
+) {
+    companion object {
+        /** From the Games tab's row for [game] and the few preferences the edits keep. */
+        fun of(context: android.content.Context, game: com.droiddeck.launcher.frontend.Library.SteamGame, folder: String): EditPreview {
+            val exe = SessionPrefs.addedGameExe(context, folder).ifEmpty {
+                com.droiddeck.launcher.frontend.AddedExes.list(context).firstOrNull { it.folder == folder && it.picked }?.exe.orEmpty()
+            }.takeIf { it.isNotEmpty() }?.let { File(it) }
+            val startIn = SessionPrefs.addedGameStartIn(context, folder).takeIf { it.isNotEmpty() }?.substringAfterLast('/') ?: exe?.parentFile?.name
+            return EditPreview(
+                game.name, exe?.name, startIn, SessionPrefs.addedGameLaunch(context, folder),
+                mapOf(AddedGameArt.Slot.COVER to game.art, AddedGameArt.Slot.BACKGROUND to game.hero, AddedGameArt.Slot.ICON to game.icon),
+            )
+        }
+
+        /** From a summary row's game and its cover. */
+        fun of(game: AddedGames.Game, cover: File?) = EditPreview(
+            game.name, game.exe.name, game.guestDir.substringAfterLast('/'), game.launchOptions, mapOf(AddedGameArt.Slot.COVER to cover),
+        )
+    }
+}
+
+/** A small spinner where a value is still being read. */
+@Composable
+private fun Loading() {
+    androidx.compose.material3.CircularProgressIndicator(Modifier.size(14.dp), strokeWidth = 2.dp)
+}
+
+/**
+ * An added game's editor, Steam's non-Steam Properties in the app: Name, Target (the ranked exes,
+ * "?" where nothing clearly won, Other exe…), Start in, Launch options, the four pieces of art, and
+ * Remove (two presses; the files stay). Every change goes through the game's own Steam shortcut.
+ */
+@Composable
+internal fun AddedGameEditor(
+    request: EditRequest, onBack: () -> Unit, onClose: () -> Unit, onChanged: () -> Unit,
+    /** Remove pressed twice: the game's folder, its shortcut appid when known, its name. */
+    onRemove: (folder: String, appId: Long?, name: String) -> Unit,
+) {
+    val ctx = LocalContext.current
+    val app = ctx.applicationContext
+    val colors = MaterialTheme.colorScheme
+    val scope = rememberCoroutineScope()
+    val shown = rememberShown(onClose)
+    val close = { shown.targetState = false }
+    val folder = request.folder
+    var version by remember { mutableIntStateOf(0) }
+    var game by remember { mutableStateOf<AddedGames.Game?>(null) }
+    var arts by remember { mutableStateOf<List<AddedGameArt.SlotState>>(emptyList()) }
+    var ranked by remember { mutableStateOf<List<File>?>(null) }
+    var targetOpen by remember { mutableStateOf(request.openTarget) }
+    var armed by remember { mutableStateOf(false) }
+    var editing by remember { mutableStateOf<String?>(null) }
+    var otherExe by remember { mutableStateOf(false) }
+    var artSlot by remember { mutableStateOf<AddedGameArt.Slot?>(null) }
+    var unreachable by remember { mutableStateOf(false) }
+    LaunchedEffect(version) {
+        withContext(Dispatchers.IO) {
+            val g = AddedGameEdits.game(app, folder)
+            game = g
+            if (g != null) {
+                ranked = g.candidates.let { list -> if (list.any { it.path == g.exe.path }) list else listOf(g.exe) + list }
+                arts = AddedGameArt.describe(app, g)
+            }
+        }
+    }
+    LaunchedEffect(armed) { if (armed) { kotlinx.coroutines.delay(4_000); armed = false } }
+    val change: (() -> Unit) -> Unit = { work ->
+        scope.launch {
+            withContext(Dispatchers.IO) { work() }
+            version++
+            onChanged()
+        }
+    }
+    val first = remember { FocusRequester() }
+    LaunchedEffect(Unit) { focusWithinFrames({ false }) { first } }
+    val preview = request.preview
+    AppDialog(shown, close, "gameEditor", wide = false, maxWidth = 460.dp) {
+        val g = game
+        val name = g?.name ?: preview.name
+        DialogTitleRow(
+            name, onClose = close,
+            leading = if (request.fromSummary) ({ SmallIconButton(Icons.AutoMirrored.Filled.ArrowBack, stringResource(R.string.common_back), colors.onBackground) { onBack(); close() } }) else null,
+        )
+        val maxHeight = (LocalConfiguration.current.screenHeightDp * 0.72f).dp
+        Column(
+            verticalArrangement = Arrangement.spacedBy(6.dp),
+            modifier = Modifier.fillMaxWidth().heightIn(max = maxHeight).verticalScroll(rememberScrollState()),
+        ) {
+            FieldRow(stringResource(R.string.edit_name), focus = first, onClick = { editing = "name" }) { ValueText(name) }
+            FieldRow(stringResource(R.string.edit_target), onClick = { targetOpen = !targetOpen }) {
+                Row(verticalAlignment = Alignment.CenterVertically, horizontalArrangement = Arrangement.spacedBy(8.dp)) {
+                    val exeName = g?.exe?.name ?: preview.exeName
+                    Box(Modifier.weight(1f)) { if (exeName != null) ValueText(exeName) else Loading() }
+                    if (g == null && exeName != null) Loading()
+                    if (g?.exeUncertain == true) UncertainMark(stringResource(R.string.mode_added_exe_check))
+                }
+            }
+            if (targetOpen) {
+                Column(verticalArrangement = Arrangement.spacedBy(4.dp), modifier = Modifier.padding(start = 16.dp)) {
+                    val list = ranked
+                    if (g == null || list == null) Box(Modifier.padding(8.dp)) { Loading() }
+                    else for (exe in list) key(exe.path) {
+                        val rel = exe.relativeToOrSelf(g.folder).invariantSeparatorsPath
+                        PickerRow(null, exe.name, rel.substringBeforeLast('/', "").ifEmpty { null }, accent = exe.path == g.exe.path) {
+                            targetOpen = false
+                            change { AddedGameEdits.setExe(app, folder, exe) }
+                        }
+                    }
+                    PickerRow(null, stringResource(R.string.edit_other_exe), null, enabled = g != null) { otherExe = true }
+                }
+            }
+            FieldRow(stringResource(R.string.edit_start_in), onClick = { if (g != null) editing = "start" }) {
+                val startIn = g?.guestDir?.substringAfterLast('/') ?: preview.startIn
+                if (startIn != null) ValueText(startIn) else Loading()
+            }
+            val launch = g?.launchOptions ?: preview.launchOptions
+            FieldRow(stringResource(R.string.edit_launch_options), onClick = { editing = "launch" }) { ValueText(launch.ifEmpty { "—" }, muted = launch.isEmpty()) }
+            Text(stringResource(R.string.edit_artwork), fontSize = 12.sp, color = colors.onSurfaceVariant, modifier = Modifier.padding(start = 4.dp, top = 8.dp))
+            for (slot in AddedGameArt.Slot.values()) key(slot) {
+                val state = arts.firstOrNull { it.slot == slot }
+                FieldRow(slot.label(), onClick = { if (g != null) artSlot = slot }) {
+                    Row(verticalAlignment = Alignment.CenterVertically, horizontalArrangement = Arrangement.spacedBy(10.dp)) {
+                        SlotThumb(slot, if (state != null) state.file else preview.art[slot])
+                        if (state != null) ValueText(artSourceLabel(state.source), muted = true) else Loading()
+                    }
+                }
+            }
+            RemoveRow(armed) {
+                if (!armed) armed = true else {
+                    armed = false
+                    // At once: the page drops the game and the rest runs off this dialog's life.
+                    onRemove(folder, game?.appId, game?.name ?: preview.name)
+                    if (request.fromSummary) onBack()
+                    close()
+                }
+            }
+        }
+        if (unreachable) Text(stringResource(R.string.games_add_unreachable), fontSize = 12.sp, color = colors.error)
+    }
+    val shownName = game?.name ?: preview.name
+    when (editing) {
+        "name" -> TextEntryDialog(stringResource(R.string.edit_name), SessionPrefs.addedGameName(ctx, folder).ifEmpty { shownName }, onDismiss = { editing = null }) { value ->
+            change { AddedGameEdits.setName(app, folder, if (value == shownName && SessionPrefs.addedGameName(app, folder).isEmpty()) "" else value) }
+        }
+        "launch" -> TextEntryDialog(stringResource(R.string.edit_launch_options), game?.launchOptions ?: preview.launchOptions, onDismiss = { editing = null }) { value ->
+            change { AddedGameEdits.setLaunchOptions(app, folder, value) }
+        }
+    }
+    val g = game ?: return
+    when (editing) {
+        "start" -> TextEntryDialog(stringResource(R.string.edit_start_in), hostPath(ctx, g), onDismiss = { editing = null }) { value ->
+            scope.launch {
+                val ok = withContext(Dispatchers.IO) { AddedGameEdits.setStartIn(app, folder, if (value == g.exe.parentFile?.path) "" else value) }
+                unreachable = !ok
+                version++
+                onChanged()
+            }
+        }
+    }
+    if (otherExe) ExePickerDialog(stringResource(R.string.games_pick_exe_title), start = g.folder, onDismiss = { otherExe = false }, onPick = { exe ->
+        targetOpen = false
+        scope.launch {
+            val ok = withContext(Dispatchers.IO) { AddedGameEdits.setExe(app, folder, exe) }
+            unreachable = !ok
+            version++
+            onChanged()
+        }
+    })
+    artSlot?.let { slot ->
+        val current = arts.firstOrNull { it.slot == slot }
+        ArtChooserDialog(g, slot, current, onBack = { artSlot = null }, onCloseAll = { artSlot = null; close() }) { version++; onChanged() }
+    }
+}
+
+/** Start in as a path on the device: the override mapped back under the game's folder, else the exe's folder. */
+private fun hostPath(context: android.content.Context, game: AddedGames.Game): String {
+    val folderGuest = AddedGames.guestPath(context, game.folder) ?: return game.exe.parentFile?.path.orEmpty()
+    return when {
+        game.guestDir == folderGuest -> game.folder.path
+        game.guestDir.startsWith("$folderGuest/") -> game.folder.path + game.guestDir.removePrefix(folderGuest)
+        else -> game.exe.parentFile?.path.orEmpty()
+    }
+}
+
+@Composable
+private fun ValueText(text: String, muted: Boolean = false) {
+    Text(
+        text, fontSize = 14.sp, color = if (muted) MaterialTheme.colorScheme.onSurfaceVariant else MaterialTheme.colorScheme.onBackground,
+        maxLines = 1, overflow = TextOverflow.Ellipsis,
+    )
+}
+
+/** "Remove" in red; pressed once it asks, a second press within four seconds removes. */
+@Composable
+private fun RemoveRow(armed: Boolean, onClick: () -> Unit) {
+    val colors = MaterialTheme.colorScheme
+    val src = remember { androidx.compose.foundation.interaction.MutableInteractionSource() }
+    val hot = rememberHot(src)
+    Box(
+        Modifier.fillMaxWidth().padding(top = 8.dp).clip(Shape12)
+            .background(if (armed) colors.error.copy(alpha = 0.18f) else if (hot) colors.error.copy(alpha = 0.10f) else androidx.compose.ui.graphics.Color.Transparent)
+            .glideBorder(hot, Shape12, colors.error, colors.error.copy(alpha = 0.4f))
+            .hoverable(src)
+            .clickable(interactionSource = src, indication = androidx.compose.foundation.LocalIndication.current, role = Role.Button, onClick = onClick)
+            .controllerConfirm(onClick = onClick)
+            .padding(horizontal = 12.dp, vertical = 10.dp),
+    ) {
+        Text(
+            stringResource(if (armed) R.string.mode_added_remove_confirm else R.string.edit_remove),
+            fontSize = 14.sp, fontWeight = FontWeight.SemiBold, color = colors.error,
+        )
+    }
+}
+
+/** One line of text in a compact dialog: [title] and a red X, the field, OK. */
+@Composable
+internal fun TextEntryDialog(title: String, initial: String, onDismiss: () -> Unit, onSave: (String) -> Unit) {
+    val shown = rememberShown(onDismiss)
+    val close = { shown.targetState = false }
+    var value by remember { mutableStateOf(initial) }
+    val focus = remember { FocusRequester() }
+    LaunchedEffect(Unit) { focusWithinFrames({ false }) { focus } }
+    AppDialog(shown, close, "textEntry", wide = false, maxWidth = 460.dp) {
+        DialogTitleRow(title, onClose = close)
+        androidx.compose.material3.OutlinedTextField(
+            value, { value = it }, singleLine = true, modifier = Modifier.fillMaxWidth().focusRequester(focus),
+            keyboardActions = androidx.compose.foundation.text.KeyboardActions(onDone = { onSave(value.trim()); close() }),
+            keyboardOptions = androidx.compose.foundation.text.KeyboardOptions(imeAction = androidx.compose.ui.text.input.ImeAction.Done),
+        )
+        Row(Modifier.fillMaxWidth(), horizontalArrangement = Arrangement.End) {
+            SecondaryButton(stringResource(R.string.common_ok), compact = true) { onSave(value.trim()); close() }
+        }
+    }
+}
+
+/**
+ * The art chooser for one [slot]: back, the slot's name and a red X; the images grouped by where
+ * they come from (the game's folder, Steam, SteamGridDB, fetched as it opens), the current one
+ * outlined, a tap applies it; "Pick image…" and "Reset to automatic".
+ */
+@OptIn(ExperimentalLayoutApi::class)
+@Composable
+private fun ArtChooserDialog(
+    game: AddedGames.Game, slot: AddedGameArt.Slot, current: AddedGameArt.SlotState?,
+    onBack: () -> Unit, onCloseAll: () -> Unit, onChanged: () -> Unit,
+) {
+    val ctx = LocalContext.current
+    val app = ctx.applicationContext
+    val colors = MaterialTheme.colorScheme
+    val scope = rememberCoroutineScope()
+    val shown = rememberShown(onBack)
+    val back = { shown.targetState = false }
+    var options by remember { mutableStateOf<List<AddedGameArt.Option>?>(null) }
+    var picking by remember { mutableStateOf(false) }
+    val chosenRef = remember(current) { AddedGameArt.chosenSource(app, game, slot).second }
+    LaunchedEffect(slot) { options = withContext(Dispatchers.IO) { runCatching { AddedGameArt.options(app, game, slot) }.getOrDefault(emptyList()) } }
+    val first = remember { FocusRequester() }
+    LaunchedEffect(Unit) { focusWithinFrames({ false }) { first } }
+    val apply: (AddedGameArt.Option) -> Unit = { option ->
+        scope.launch {
+            withContext(Dispatchers.IO) { AddedGameEdits.setArt(app, game.folder.path, slot, option) }
+            onChanged()
+            back()
+        }
+    }
+    val slotName = slot.label()
+    AppDialog(shown, back, "artChooser", wide = false, maxWidth = 460.dp) {
+        DialogTitleRow(slotName, onClose = { onCloseAll() }, leading = {
+            SmallIconButton(Icons.AutoMirrored.Filled.ArrowBack, stringResource(R.string.common_back), colors.onBackground, onClick = back)
+        })
+        val maxHeight = (LocalConfiguration.current.screenHeightDp * 0.72f).dp
+        Column(
+            verticalArrangement = Arrangement.spacedBy(8.dp),
+            modifier = Modifier.fillMaxWidth().heightIn(max = maxHeight).verticalScroll(rememberScrollState()),
+        ) {
+            val opts = options
+            if (opts == null) {
+                androidx.compose.material3.LinearProgressIndicator(Modifier.fillMaxWidth().padding(vertical = 8.dp))
+            } else {
+                var firstGiven = false
+                for (group in listOf(AddedGameArt.FOLDER, AddedGameArt.STEAM, AddedGameArt.SGDB)) {
+                    val inGroup = opts.filter { it.group == group }
+                    if (inGroup.isEmpty()) continue
+                    Text(artSourceLabel(group), fontSize = 12.sp, color = colors.onSurfaceVariant, modifier = Modifier.padding(start = 2.dp, top = 4.dp))
+                    FlowRow(horizontalArrangement = Arrangement.spacedBy(8.dp), verticalArrangement = Arrangement.spacedBy(8.dp)) {
+                        for (option in inGroup) key(option.full) {
+                            val focus = if (!firstGiven) first.also { firstGiven = true } else null
+                            ArtOption(slot, option, selected = current?.chosen == true && option.full == chosenRef, focus = focus, description = "${artSourceLabel(group)} $slotName") { apply(option) }
+                        }
+                    }
+                }
+            }
+            PickerRow(Icons.Outlined.Image, stringResource(R.string.art_pick_image), null, focus = if (opts?.isEmpty() != false) first else null) { picking = true }
+            PickerRow(null, stringResource(R.string.art_reset), null) {
+                scope.launch {
+                    withContext(Dispatchers.IO) { AddedGameEdits.resetArt(app, game.folder.path, slot) }
+                    onChanged()
+                    back()
+                }
+            }
+        }
+    }
+    if (picking) ExePickerDialog(stringResource(R.string.art_pick_title, slotName), kind = PickKind.IMAGE, onDismiss = { picking = false }, onPick = { file ->
+        apply(AddedGameArt.Option(AddedGameArt.FILE, file.path, file.path))
+    })
+}
+
+@Composable
+private fun ArtOption(slot: AddedGameArt.Slot, option: AddedGameArt.Option, selected: Boolean, focus: FocusRequester?, description: String, onClick: () -> Unit) {
+    val pal = LocalPalette.current
+    val src = remember { androidx.compose.foundation.interaction.MutableInteractionSource() }
+    val hot = rememberHot(src)
+    val scale = when (slot) { AddedGameArt.Slot.COVER -> 1.9f; AddedGameArt.Slot.ICON -> 1.6f; else -> 1.5f }
+    Box(
+        Modifier.then(if (focus != null) Modifier.focusRequester(focus) else Modifier).clip(RoundedCornerShape(8.dp))
+            .glideBorder(hot, RoundedCornerShape(8.dp), pal.signal)
+            .hoverable(src)
+            .clickable(interactionSource = src, indication = androidx.compose.foundation.LocalIndication.current, role = Role.Button, onClick = onClick)
+            .controllerConfirm(onClick = onClick)
+            .semantics { contentDescription = description }
+            .padding(2.dp),
+    ) {
+        SlotThumb(slot, if (option.thumb.startsWith("https://")) option.thumb else File(option.thumb), scale, selected)
+    }
+}
+
+/**
+ * After "Add all games in this folder": how many were added and how many were there already, then
+ * one row per added game (cover, name, exe, "?" where unsure); a row opens that game's editor.
+ * [games] are the added games as the add left them, shown at once; the rows then follow edits and
+ * removals, and the covers arrive.
+ */
+@Composable
+internal fun AddedGamesSummaryDialog(
+    games: List<AddedGames.Game>, already: Int, checking: String? = null,
+    onOpen: (folder: String, uncertain: Boolean, preview: EditPreview) -> Unit,
+    onRemove: (folder: String, appId: Long?, name: String) -> Unit,
+    onDismiss: () -> Unit,
+) {
+    val ctx = LocalContext.current
+    val app = ctx.applicationContext
+    val colors = MaterialTheme.colorScheme
+    val shown = rememberShown(onDismiss)
+    val close = { shown.targetState = false }
+    var rows by remember { mutableStateOf(games.map { it to (null as File?) }) }
+    var gone by remember { mutableStateOf(emptySet<String>()) }
+    var armed by remember { mutableStateOf<String?>(null) }
+    LaunchedEffect(armed) { if (armed != null) { kotlinx.coroutines.delay(4_000); armed = null } }
+    // Rows show as the games arrive; each is refreshed once (current name and exe, a removed one
+    // dropped) and gets its cover, without redoing the ones already done when more arrive.
+    var resolved by remember { mutableStateOf(emptyMap<String, Pair<AddedGames.Game, File?>?>()) }
+    LaunchedEffect(games) {
+        for (old in games) {
+            val path = old.folder.path
+            if (path in resolved) continue
+            val fresh = withContext(Dispatchers.IO) { AddedGames.single(app, path)?.let { g -> g to AddedGameArt.resolve(app, g).portrait } }
+            resolved = resolved + (path to fresh)
+        }
+    }
+    LaunchedEffect(games, resolved) {
+        rows = games.mapNotNull { g -> if (g.folder.path in resolved) resolved[g.folder.path] else g to null }
+    }
+    val first = remember { FocusRequester() }
+    val list = rows.filter { it.first.folder.path !in gone }
+    LaunchedEffect(list.isNotEmpty()) { if (list.isNotEmpty()) focusWithinFrames({ false }) { first } }
+    AppDialog(shown, close, "addedSummary", wide = false, maxWidth = 440.dp) {
+        DialogTitleRow(
+            if (list.isEmpty() && checking == null) stringResource(R.string.games_added_none) else pluralStringResource(R.plurals.games_added_n, list.size, list.size),
+            onClose = close,
+        )
+        if (already > 0) Text(pluralStringResource(R.plurals.games_already_n, already, already), fontSize = 12.sp, color = colors.onSurfaceVariant)
+        if (checking != null) Row(verticalAlignment = Alignment.CenterVertically, horizontalArrangement = Arrangement.spacedBy(8.dp)) {
+            androidx.compose.material3.CircularProgressIndicator(Modifier.size(14.dp), strokeWidth = 2.dp, color = colors.primary)
+            Text(checking, fontSize = 12.sp, color = colors.onSurfaceVariant, maxLines = 1, overflow = TextOverflow.Ellipsis)
+        }
+        val maxHeight = (LocalConfiguration.current.screenHeightDp * 0.7f).dp
+        Column(
+            verticalArrangement = Arrangement.spacedBy(6.dp),
+            modifier = Modifier.fillMaxWidth().heightIn(max = maxHeight).verticalScroll(rememberScrollState()),
+        ) {
+            list.forEachIndexed { i, (g, cover) ->
+                key(g.folder.path) {
+                    ListRow(focus = if (i == 0) first else null, onClick = { onOpen(g.folder.path, g.exeUncertain, EditPreview.of(g, cover)); close() }) {
+                        SlotThumb(AddedGameArt.Slot.COVER, cover, 0.9f)
+                        Column(Modifier.weight(1f)) {
+                            Text(g.name, fontSize = 14.sp, fontWeight = FontWeight.SemiBold, color = colors.onBackground, maxLines = 1, overflow = TextOverflow.Ellipsis)
+                            Text(g.exe.name, fontSize = 12.sp, color = colors.onSurfaceVariant, maxLines = 1, overflow = TextOverflow.Ellipsis)
+                        }
+                        if (g.exeUncertain) UncertainMark(stringResource(R.string.mode_added_exe_check))
+                        val path = g.folder.path
+                        RemoveX(armed == path, stringResource(R.string.summary_remove_game, g.name)) {
+                            if (armed != path) armed = path else {
+                                armed = null
+                                gone = gone + path
+                                onRemove(path, g.appId, g.name)
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+}
+
+/** A summary row's red X: the first press arms it (filled), a second within 4 s removes the game. */
+@Composable
+private fun RemoveX(armed: Boolean, description: String, onClick: () -> Unit) {
+    val colors = MaterialTheme.colorScheme
+    val src = remember { androidx.compose.foundation.interaction.MutableInteractionSource() }
+    val hot = rememberHot(src)
+    Box(
+        contentAlignment = Alignment.Center,
+        modifier = Modifier.size(32.dp).clip(Shape12)
+            .background(if (armed) colors.error else if (hot) colors.error.copy(alpha = 0.15f) else androidx.compose.ui.graphics.Color.Transparent)
+            .glideBorder(hot, Shape12, colors.error)
+            .hoverable(src)
+            .clickable(interactionSource = src, indication = androidx.compose.foundation.LocalIndication.current, role = Role.Button, onClick = onClick)
+            .controllerConfirm(onClick = onClick)
+            .semantics { contentDescription = description },
+    ) {
+        androidx.compose.material3.Icon(Icons.Filled.Close, null, tint = if (armed) colors.onError else colors.error, modifier = Modifier.size(18.dp))
+    }
+}
diff --git a/app/src/main/java/com/droiddeck/launcher/ui/ExePickerDialog.kt b/app/src/main/java/com/droiddeck/launcher/ui/ExePickerDialog.kt
new file mode 100644
index 000000000..cda22fc69
--- /dev/null
+++ b/app/src/main/java/com/droiddeck/launcher/ui/ExePickerDialog.kt
@@ -0,0 +1,234 @@
+package com.droiddeck.launcher.ui
+
+import android.content.Context
+import android.os.Environment
+import android.os.StatFs
+import androidx.compose.foundation.LocalIndication
+import androidx.compose.foundation.background
+import androidx.compose.foundation.clickable
+import androidx.compose.foundation.hoverable
+import androidx.compose.foundation.interaction.MutableInteractionSource
+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.fillMaxWidth
+import androidx.compose.foundation.layout.heightIn
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.layout.size
+import androidx.compose.foundation.rememberScrollState
+import androidx.compose.foundation.verticalScroll
+import androidx.compose.material.icons.Icons
+import androidx.compose.material.icons.automirrored.outlined.ArrowBack
+import androidx.compose.material.icons.filled.Add
+import androidx.compose.material.icons.filled.Close
+import androidx.compose.material.icons.outlined.Folder
+import androidx.compose.material.icons.outlined.Image
+import androidx.compose.material.icons.outlined.InsertDriveFile
+import androidx.compose.material.icons.outlined.SdCard
+import androidx.compose.material.icons.outlined.Smartphone
+import androidx.compose.material3.Icon
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.Text
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.LaunchedEffect
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.key
+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.alpha
+import androidx.compose.ui.draw.clip
+import androidx.compose.ui.focus.FocusRequester
+import androidx.compose.ui.focus.focusRequester
+import androidx.compose.ui.graphics.vector.ImageVector
+import androidx.compose.ui.layout.onSizeChanged
+import androidx.compose.ui.platform.LocalConfiguration
+import androidx.compose.ui.platform.LocalContext
+import androidx.compose.ui.platform.LocalDensity
+import androidx.compose.ui.res.stringResource
+import androidx.compose.ui.semantics.Role
+import androidx.compose.ui.semantics.contentDescription
+import androidx.compose.ui.semantics.semantics
+import androidx.compose.ui.text.font.FontWeight
+import androidx.compose.ui.text.style.TextOverflow
+import androidx.compose.ui.unit.Dp
+import androidx.compose.ui.unit.dp
+import androidx.compose.ui.unit.sp
+import com.droiddeck.launcher.R
+import com.droiddeck.launcher.session.GameStorage
+import com.droiddeck.launcher.stores.formatBytes
+import java.io.File
+
+/** What a picker lists besides folders. */
+internal enum class PickKind(val extensions: Set<String>) {
+    EXE(setOf("exe")),
+    IMAGE(setOf("png", "jpg", "jpeg", "webp", "ico")),
+}
+
+/** A place a file can be picked from: internal storage or a card, at its root. */
+internal class PickVolume(val root: File, val label: String, val removable: Boolean) {
+    val free: Long get() = runCatching { StatFs(root.path).availableBytes }.getOrDefault(0L)
+}
+
+internal fun pickVolumes(context: Context): List<PickVolume> =
+    listOf(PickVolume(Environment.getExternalStorageDirectory(), context.getString(R.string.games_internal), removable = false)) +
+        GameStorage.options(context).mapNotNull { o ->
+            File(o.path.substringBefore("/Android/")).takeIf { it.isDirectory }?.let { PickVolume(it, o.name, removable = true) }
+        }.distinctBy { it.root.absolutePath }
+
+/** A folder in a listing; [readable] false = shown greyed, not opened. */
+internal class PickFolder(val dir: File, val readable: Boolean)
+
+internal class PickListing(val folders: List<PickFolder>, val files: List<File>)
+
+/**
+ * Every folder of [dir] (dot-folders left out, the unreadable ones marked), then the files [kind]
+ * takes; each A-Z.
+ */
+internal fun pickListing(dir: File, kind: PickKind): PickListing {
+    val all = dir.listFiles()?.filter { !it.name.startsWith(".") }.orEmpty().sortedBy { it.name.lowercase() }
+    return PickListing(
+        all.filter { it.isDirectory }.map { PickFolder(it, it.canRead() && it.list() != null) },
+        all.filter { it.isFile && it.extension.lowercase() in kind.extensions },
+    )
+}
+
+/**
+ * The compact in-app file picker: [title] and a red X on one line; the storage rows (internal
+ * storage, each card, free space); inside one, its root first, a breadcrumb, "..", every folder
+ * and the [kind] files, scrolling in the dialog. Its width is what the first step needed and stays;
+ * long names are cut short. B / Back goes up a folder, and closes from the storage rows. [start]
+ * opens in a folder. [onAddAll] adds a row on top of a folder with subfolders.
+ */
+@Composable
+internal fun ExePickerDialog(
+    title: String, kind: PickKind = PickKind.EXE, start: File? = null,
+    onAddAll: ((File) -> Unit)? = null, onPick: (File) -> Unit, onDismiss: () -> Unit,
+) {
+    val ctx = LocalContext.current
+    val colors = MaterialTheme.colorScheme
+    val density = LocalDensity.current
+    val shown = rememberShown(onDismiss)
+    val close = { shown.targetState = false }
+    val volumes = remember { pickVolumes(ctx) }
+    fun volumeOf(d: File) = volumes.filter { d.path == it.root.path || d.path.startsWith(it.root.path + "/") }.maxByOrNull { it.root.path.length }
+    var dir by remember { mutableStateOf(start?.takeIf { it.isDirectory && volumeOf(it) != null }) }
+    val volume = dir?.let { volumeOf(it) }
+    val up = { dir = dir?.let { d -> if (volume == null || d.path == volume.root.path) null else d.parentFile } }
+    val back = { if (dir == null) close() else up() }
+    val first = remember(dir) { FocusRequester() }
+    LaunchedEffect(dir) { focusWithinFrames({ false }) { first } }
+    val listing = remember(dir) { dir?.let { pickListing(it, kind) } }
+    var locked by remember { mutableStateOf<Dp?>(null) }
+    AppDialog(
+        shown, close, "filePicker", wide = false, maxWidth = 520.dp, width = locked, fitContent = locked == null, back = back,
+        modifier = Modifier.onSizeChanged { if (locked == null && it.width > 0) locked = with(density) { it.width.toDp() } },
+    ) {
+        Column(verticalArrangement = Arrangement.spacedBy(6.dp), modifier = Modifier.fillMaxWidth()) {
+            DialogTitleRow(title, onClose = close)
+            if (dir != null && volume != null) {
+                val crumbs = listOf(volume.label) + dir!!.path.removePrefix(volume.root.path).split('/').filter { it.isNotEmpty() }
+                Text(crumbs.joinToString(" › "), fontSize = 12.sp, color = colors.onSurfaceVariant, maxLines = 1, overflow = TextOverflow.Ellipsis)
+            }
+            val maxHeight = (LocalConfiguration.current.screenHeightDp * 0.7f).dp
+            Column(
+                verticalArrangement = Arrangement.spacedBy(6.dp),
+                modifier = Modifier.fillMaxWidth().heightIn(max = maxHeight).verticalScroll(rememberScrollState()).padding(top = 4.dp),
+            ) {
+                if (dir == null) {
+                    volumes.forEachIndexed { i, v ->
+                        key(v.root.path) {
+                            PickerRow(if (v.removable) Icons.Outlined.SdCard else Icons.Outlined.Smartphone, v.label,
+                                stringResource(R.string.stores_target_free, formatBytes(v.free)), tall = true, focus = if (i == 0) first else null) { dir = v.root }
+                        }
+                    }
+                } else {
+                    val shownListing = listing ?: PickListing(emptyList(), emptyList())
+                    PickerRow(Icons.AutoMirrored.Outlined.ArrowBack, "..", null, focus = first, onClick = up)
+                    if (onAddAll != null && shownListing.folders.any { it.readable }) {
+                        PickerRow(Icons.Filled.Add, stringResource(R.string.games_add_all), null, accent = true) { onAddAll(dir!!); close() }
+                    }
+                    for (f in shownListing.folders) key(f.dir.path) {
+                        PickerRow(Icons.Outlined.Folder, f.dir.name, null, enabled = f.readable) { dir = f.dir }
+                    }
+                    for (f in shownListing.files) key(f.path) {
+                        PickerRow(if (kind == PickKind.IMAGE) Icons.Outlined.Image else Icons.Outlined.InsertDriveFile, f.name, formatBytes(f.length()), file = true) {
+                            onPick(f); close()
+                        }
+                    }
+                }
+            }
+        }
+    }
+}
+
+/** A compact dialog's title line: [leading] (a back arrow), the title, a small red X. */
+@Composable
+internal fun DialogTitleRow(title: String, onClose: () -> Unit, leading: (@Composable () -> Unit)? = null) {
+    Row(verticalAlignment = Alignment.CenterVertically, horizontalArrangement = Arrangement.spacedBy(6.dp), modifier = Modifier.fillMaxWidth()) {
+        leading?.invoke()
+        Text(title, fontSize = 15.sp, color = MaterialTheme.colorScheme.onBackground, maxLines = 1, overflow = TextOverflow.Ellipsis, modifier = Modifier.weight(1f))
+        SmallIconButton(Icons.Filled.Close, stringResource(R.string.common_close), tint = MaterialTheme.colorScheme.error, onClick = onClose)
+    }
+}
+
+/** A 32 dp icon button for a dialog's title line. */
+@Composable
+internal fun SmallIconButton(icon: ImageVector, description: String, tint: androidx.compose.ui.graphics.Color, onClick: () -> Unit) {
+    val src = remember { MutableInteractionSource() }
+    val hot = rememberHot(src)
+    Box(
+        contentAlignment = Alignment.Center,
+        modifier = Modifier.size(32.dp).clip(Shape12)
+            .background(if (hot) tint.copy(alpha = 0.15f) else androidx.compose.ui.graphics.Color.Transparent)
+            .glideBorder(hot, Shape12, tint)
+            .hoverable(src).clickable(interactionSource = src, indication = LocalIndication.current, role = Role.Button, onClick = onClick)
+            .controllerConfirm(onClick = onClick)
+            .semantics { contentDescription = description },
+    ) {
+        Icon(icon, null, tint = tint, modifier = Modifier.size(18.dp))
+    }
+}
+
+/** One row of a compact dialog's list, the Install dialog's style: [content] laid out in a row. */
+@Composable
+internal fun ListRow(
+    enabled: Boolean = true, accent: Boolean = false, tall: Boolean = false, focus: FocusRequester? = null,
+    onClick: () -> Unit, content: @Composable androidx.compose.foundation.layout.RowScope.(hot: Boolean) -> Unit,
+) {
+    val colors = MaterialTheme.colorScheme
+    val pal = LocalPalette.current
+    val src = remember { MutableInteractionSource() }
+    val hot = rememberHot(src) && enabled
+    Row(
+        verticalAlignment = Alignment.CenterVertically, horizontalArrangement = Arrangement.spacedBy(10.dp),
+        modifier = Modifier.fillMaxWidth().then(if (focus != null) Modifier.focusRequester(focus) else Modifier).clip(Shape12)
+            .alpha(if (enabled) 1f else 0.4f)
+            .background(if (hot) pal.signal.copy(alpha = 0.14f) else colors.surface.copy(alpha = 0.6f))
+            .glideBorder(hot, Shape12, pal.signal, if (accent) pal.signal else pal.line)
+            .then(
+                if (enabled) Modifier.hoverable(src).clickable(interactionSource = src, indication = LocalIndication.current, role = Role.Button, onClick = onClick)
+                    .controllerConfirm(onClick = onClick) else Modifier,
+            )
+            .padding(horizontal = 12.dp, vertical = if (tall) 11.dp else 9.dp),
+    ) { content(hot) }
+}
+
+/** A list row with an icon, a name (cut short when long) and a detail on the right. */
+@Composable
+internal fun PickerRow(
+    icon: ImageVector?, name: String, detail: String?, tall: Boolean = false, file: Boolean = false, accent: Boolean = false,
+    enabled: Boolean = true, focus: FocusRequester? = null, onClick: () -> Unit,
+) {
+    val colors = MaterialTheme.colorScheme
+    val pal = LocalPalette.current
+    ListRow(enabled, accent, tall, focus, onClick) { hot ->
+        if (icon != null) Icon(icon, null, tint = if (hot || file || accent) pal.signal else colors.onSurfaceVariant, modifier = Modifier.size(20.dp))
+        Text(name, fontSize = 14.sp, fontWeight = if (tall) FontWeight.SemiBold else FontWeight.Normal, color = colors.onBackground,
+            maxLines = 1, overflow = TextOverflow.Ellipsis, modifier = Modifier.weight(1f))
+        if (detail != null) Text(detail, fontSize = 12.sp, color = colors.onSurfaceVariant, maxLines = 1, modifier = Modifier.padding(start = 8.dp))
+    }
+}
diff --git a/app/src/main/java/com/droiddeck/launcher/ui/FrontEndGames.kt b/app/src/main/java/com/droiddeck/launcher/ui/FrontEndGames.kt
index e62315151..1c97f986f 100644
--- a/app/src/main/java/com/droiddeck/launcher/ui/FrontEndGames.kt
+++ b/app/src/main/java/com/droiddeck/launcher/ui/FrontEndGames.kt
@@ -30,6 +30,10 @@ import androidx.compose.foundation.rememberScrollState
 import androidx.compose.foundation.shape.RoundedCornerShape
 import androidx.compose.foundation.verticalScroll
 import androidx.compose.material.icons.Icons
+import androidx.compose.material.icons.outlined.Edit
+import androidx.compose.ui.semantics.semantics
+import androidx.compose.foundation.shape.CircleShape
+import androidx.compose.material.icons.filled.Add
 import androidx.compose.material.icons.filled.PlayArrow
 import androidx.compose.material3.MaterialTheme
 import androidx.compose.material3.Text
@@ -55,6 +59,7 @@ import androidx.compose.ui.unit.dp
 import androidx.compose.ui.unit.sp
 import coil.compose.AsyncImage
 import com.droiddeck.launcher.frontend.Library
+import kotlinx.coroutines.launch
 
 // The Games page: the list, the hero for the selected game and its labels.
 
@@ -67,9 +72,15 @@ internal fun GamesPage(s: FrontEndState, a: FrontEndActions, selected: String, o
     val games = remember(s.steamGames) { s.steamGames.sortedByDescending { it.lastPlayed } }
     val narrow = LocalNarrowPane.current
     val current = games.firstOrNull { "app:${it.appId}" == selected } ?: games.firstOrNull()
+    GamesDialogs(a)
+    val onAdd: (() -> Unit)? = if (s.shortcutPicker) null else ({ GamesDialogState.adding = true })
+    val pageContext = androidx.compose.ui.platform.LocalContext.current
+    val onEdit: (Library.SteamGame) -> Unit = { g ->
+        g.gameFiles?.let { GamesDialogState.editing = EditRequest(it.path, openTarget = false, fromSummary = false, preview = EditPreview.of(pageContext, g, it.path)) }
+    }
     if (current == null) {
         Column(modifier = modifier.padding(horizontal = if (narrow) 16.dp else 22.dp, vertical = if (narrow) 12.dp else 18.dp)) {
-            Rise(0) { PageHeader(stringResource(R.string.content_games)) }
+            Rise(0) { PageHeader(stringResource(R.string.content_games)) { onAdd?.let { AddGameButton(it) } } }
             Rise(1) { Note(stringResource(if (s.shortcutPicker && s.shortcutLibraryScanning) R.string.game_shortcut_scanning else R.string.games_empty)) }
             if (!s.shortcutPicker) Rise(2) {
                 Actions { PrimaryButton(stringResource(R.string.games_play_steam), enabled = !s.busy, main = true, icon = Icons.Filled.PlayArrow, modifier = Modifier.padding(top = 12.dp).testTag("play-steam"), onClick = a.onPlay) }
@@ -81,11 +92,12 @@ internal fun GamesPage(s: FrontEndState, a: FrontEndActions, selected: String, o
     val host = rememberMenuHost()
     if (games.size == 1) {
         Column(modifier = modifier.verticalScroll(rememberScrollState()).padding(horizontal = if (narrow) 16.dp else 22.dp, vertical = if (narrow) 12.dp else 18.dp)) {
+            if (onAdd != null) Rise(0) { GamesHeader(1, onAdd, Modifier.padding(bottom = 10.dp)) }
             Rise(0) {
                 Row(verticalAlignment = Alignment.Bottom) {
                     GameHero(current, Modifier.weight(1f).heightIn(min = if (narrow) 190.dp else 250.dp)) {
                         GameHeroCopy(current, if (narrow) 28.sp else 38.sp)
-                        GameActions(current, s, a)
+                        GameActions(current, s, a, onEdit)
                     }
                     if (!narrow) Poster(current.art, current.name, Modifier.width(168.dp))
                 }
@@ -98,7 +110,7 @@ internal fun GamesPage(s: FrontEndState, a: FrontEndActions, selected: String, o
     }
     val pal = LocalPalette.current
     Row(modifier = modifier) {
-        GameList(games, current, onSelect = { onSelect("app:${it.appId}") }, onLaunch = { a.onSteamGame(it) },
+        GameList(games, current, onSelect = { onSelect("app:${it.appId}") }, onLaunch = { a.onSteamGame(it) }, onAdd = onAdd,
             modifier = Modifier.width(if (narrow) 168.dp else 250.dp).fillMaxHeight())
         Box(Modifier.width(1.dp).fillMaxHeight().background(pal.line))
         Column(
@@ -107,7 +119,7 @@ internal fun GamesPage(s: FrontEndState, a: FrontEndActions, selected: String, o
         ) {
             GameHero(current, Modifier.fillMaxWidth().heightIn(min = if (narrow) 170.dp else 200.dp)) {
                 GameHeroCopy(current, if (narrow) 24.sp else 32.sp)
-                GameActions(current, s, a)
+                GameActions(current, s, a, onEdit)
             }
             SectionTitle(stringResource(R.string.games_launch_settings), null)
             LaunchSettings(s, a, host, current)
@@ -135,7 +147,7 @@ private fun GameFileFolderActions(s: FrontEndState, a: FrontEndActions) {
 
 
 @Composable
-private fun GameActions(g: Library.SteamGame, s: FrontEndState, a: FrontEndActions) {
+private fun GameActions(g: Library.SteamGame, s: FrontEndState, a: FrontEndActions, onEdit: (Library.SteamGame) -> Unit) {
     Actions {
         PrimaryButton(stringResource(if (s.shortcutPicker) R.string.game_shortcut_choose else R.string.games_launch), enabled = !s.busy, main = true, icon = Icons.Filled.PlayArrow) { a.onSteamGame(g) }
         g.gameFiles?.takeIf { it.isDirectory }?.let { dir ->
@@ -147,6 +159,8 @@ private fun GameActions(g: Library.SteamGame, s: FrontEndState, a: FrontEndActio
             if (g.library == Library.ADDED) ManageSaves(g, dir, a)
         }
         if (!s.shortcutPicker) GameShortcutMenu(g, a)
+        // A game added in DroidDeck (Custom): its editor, Steam's Properties for a non-Steam game.
+        if (!s.shortcutPicker && g.library == Library.ADDED && g.source == Library.ADDED && g.gameFiles != null) EditGameButton { onEdit(g) }
         BusyChip(s)
     }
 }
@@ -299,7 +313,7 @@ private fun ColumnScope.GameHeroCopy(g: Library.SteamGame, titleSize: androidx.c
 @Composable
 private fun GameList(
     games: List<Library.SteamGame>, current: Library.SteamGame,
-    onSelect: (Library.SteamGame) -> Unit, onLaunch: (Library.SteamGame) -> Unit, modifier: Modifier,
+    onSelect: (Library.SteamGame) -> Unit, onLaunch: (Library.SteamGame) -> Unit, onAdd: (() -> Unit)?, modifier: Modifier,
 ) {
     val colors = MaterialTheme.colorScheme
     // Laid out whole, as the art grid is: the pad's focus search only finds rows that exist.
@@ -307,16 +321,127 @@ private fun GameList(
         verticalArrangement = Arrangement.spacedBy(2.dp),
         modifier = modifier.verticalScroll(rememberScrollState()).padding(start = 12.dp, end = 10.dp, top = 16.dp, bottom = 16.dp),
     ) {
-        Row(verticalAlignment = Alignment.Bottom, horizontalArrangement = Arrangement.spacedBy(8.dp), modifier = Modifier.padding(start = 6.dp, bottom = 10.dp)) {
-            Text(stringResource(R.string.content_games), fontSize = 22.sp, fontWeight = FontWeight.Bold, color = colors.onBackground, maxLines = 1)
-            Text(games.size.toString(), fontSize = 13.sp, color = colors.onSurfaceVariant, modifier = Modifier.padding(bottom = 3.dp))
-        }
+        GamesHeader(games.size, onAdd, Modifier.padding(start = 6.dp, bottom = 10.dp))
         for (g in games) key(g.appId) {
             GameRow(g, g.appId == current.appId, onSelect = { onSelect(g) }, onLaunch = { onLaunch(g) })
         }
     }
 }
 
+/** "Games N", and the + that adds a game from its .exe beside it ([onAdd] null: no +). */
+@Composable
+private fun GamesHeader(count: Int, onAdd: (() -> Unit)?, modifier: Modifier) {
+    val colors = MaterialTheme.colorScheme
+    Row(verticalAlignment = Alignment.CenterVertically, horizontalArrangement = Arrangement.spacedBy(8.dp), modifier = modifier) {
+        Text(stringResource(R.string.content_games), fontSize = 22.sp, fontWeight = FontWeight.Bold, color = colors.onBackground, maxLines = 1)
+        Text(count.toString(), fontSize = 13.sp, color = colors.onSurfaceVariant)
+        if (onAdd != null) AddGameButton(onAdd)
+    }
+}
+
+/**
+ * The Games tab's dialogs, one at a time: the + picker, the summary after "Add all games in this
+ * folder", and a game's editor (from the page's ✎ or a summary row, with back to the summary).
+ */
+internal object GamesDialogState {
+    var adding by androidx.compose.runtime.mutableStateOf(false)
+    var summary by androidx.compose.runtime.mutableStateOf<Pair<List<com.droiddeck.launcher.frontend.AddedGames.Game>, Int>?>(null)
+    var editing by androidx.compose.runtime.mutableStateOf<EditRequest?>(null)
+    /** The subfolder "Add all games in this folder" is looking at; null when it is done. */
+    var checking by androidx.compose.runtime.mutableStateOf<String?>(null)
+    /** The summary an editor opened from it goes back to. */
+    var behindEditor: Pair<List<com.droiddeck.launcher.frontend.AddedGames.Game>, Int>? = null
+}
+
+@Composable
+private fun GamesDialogs(a: FrontEndActions) {
+    val ctx = androidx.compose.ui.platform.LocalContext.current
+    val scope = androidx.compose.runtime.rememberCoroutineScope()
+    val st = GamesDialogState
+    if (st.adding) ExePickerDialog(
+        stringResource(R.string.games_add_title),
+        onAddAll = { dir ->
+            st.summary = emptyList<com.droiddeck.launcher.frontend.AddedGames.Game>() to 0
+            st.checking = dir.name
+            scope.launch {
+                val result = kotlinx.coroutines.withContext(kotlinx.coroutines.Dispatchers.IO) {
+                    com.droiddeck.launcher.frontend.AddedGames.addFolder(
+                        ctx.applicationContext, dir,
+                        onGame = { g -> scope.launch { st.summary?.let { (list, n) -> st.summary = (list + g) to n } } },
+                        onChecking = { name -> scope.launch { st.checking = name } },
+                    )
+                }
+                st.checking = null
+                a.onAddedGamesChanged(result.added.map { it.folder.path })
+                st.summary?.let { (list, _) -> st.summary = list to result.already }
+            }
+        },
+        onPick = { a.onAddGameExe(it.path) },
+        onDismiss = { st.adding = false },
+    )
+    st.summary?.let { (added, already) ->
+        AddedGamesSummaryDialog(added, already, checking = st.checking, onOpen = { folder, uncertain, preview ->
+            st.behindEditor = added to already
+            st.editing = EditRequest(folder, openTarget = uncertain, fromSummary = true, preview = preview)
+        }, onRemove = { folder, appId, name ->
+            st.summary = st.summary?.let { (list, n) -> list.filterNot { it.folder.path == folder } to n }
+            a.onAddedGameRemoved(folder, appId, name)
+        }, onDismiss = { st.summary = null; st.checking = null })
+    }
+    st.editing?.let { request ->
+        AddedGameEditor(
+            request,
+            onBack = { st.behindEditor?.let { st.summary = it }; st.behindEditor = null },
+            onClose = { st.editing = null },
+            onChanged = { a.onAddedGamesChanged(listOf(request.folder)) },
+            onRemove = { folder, appId, name -> a.onAddedGameRemoved(folder, appId, name) },
+        )
+    }
+}
+
+/** The ✎ on a Custom game's page: icon only. */
+@Composable
+private fun EditGameButton(onClick: () -> Unit) {
+    val colors = MaterialTheme.colorScheme
+    val pal = LocalPalette.current
+    val src = remember { MutableInteractionSource() }
+    val hot = rememberHot(src)
+    val label = stringResource(R.string.common_edit)
+    Box(
+        contentAlignment = Alignment.Center,
+        modifier = Modifier.paneItem("game:edit").size(40.dp).clip(Shape12)
+            .background(if (hot) pal.signal.copy(alpha = 0.18f) else colors.surface.copy(alpha = 0.55f))
+            .glideBorder(hot, Shape12, pal.signal, pal.line2)
+            .hoverable(src).clickable(interactionSource = src, indication = LocalIndication.current, role = androidx.compose.ui.semantics.Role.Button, onClick = onClick)
+            .controllerConfirm(onClick = onClick)
+            .semantics { contentDescription = label },
+    ) {
+        androidx.compose.material3.Icon(Icons.Outlined.Edit, contentDescription = null, tint = colors.onBackground, modifier = Modifier.size(18.dp))
+    }
+}
+
+/** A round + that opens the .exe picker. */
+@Composable
+private fun AddGameButton(onClick: () -> Unit) {
+    val colors = MaterialTheme.colorScheme
+    val pal = LocalPalette.current
+    val src = remember { MutableInteractionSource() }
+    val focused by src.collectIsFocusedAsState()
+    val hovered by src.collectIsHoveredAsState()
+    val label = stringResource(R.string.games_add)
+    Box(
+        contentAlignment = Alignment.Center,
+        modifier = Modifier.paneItem("games:add").size(32.dp).clip(CircleShape)
+            .background(if (focused || hovered) pal.signal.copy(alpha = 0.18f) else colors.surfaceVariant)
+            .glideBorder(focused, CircleShape, pal.signal)
+            .hoverable(src).clickable(interactionSource = src, indication = LocalIndication.current, role = androidx.compose.ui.semantics.Role.Button, onClick = onClick)
+            .controllerConfirm(onClick = onClick)
+            .semantics { contentDescription = label },
+    ) {
+        androidx.compose.material3.Icon(Icons.Filled.Add, contentDescription = null, tint = colors.onBackground, modifier = Modifier.size(20.dp))
+    }
+}
+
 /** One game in the list. Moving onto it with the pad shows it; A launches it, a tap only shows it. */
 @Composable
 private fun GameRow(g: Library.SteamGame, selected: Boolean, onSelect: () -> Unit, onLaunch: () -> Unit) {
diff --git a/app/src/main/java/com/droiddeck/launcher/ui/FrontEndScreen.kt b/app/src/main/java/com/droiddeck/launcher/ui/FrontEndScreen.kt
index e9717dc65..cf3558568 100644
--- a/app/src/main/java/com/droiddeck/launcher/ui/FrontEndScreen.kt
+++ b/app/src/main/java/com/droiddeck/launcher/ui/FrontEndScreen.kt
@@ -137,6 +137,9 @@ class FrontEndState(
     val storesOpenTab: String = SessionPrefs.STORES_OPEN_LIBRARY,
     /** A page to open once: "stores:downloads", or a selection such as "app:<id>" (a notification's tap). */
     val navigate: String? = null,
+    /** Setup: art for added games is fetched; the user has a SteamGridDB key of their own. */
+    val addedGamesArt: Boolean = true,
+    val sgdbUserKey: Boolean = false,
     val storesShowMature: Boolean = false,
     /** Downloads queued, running or paused across the three stores; the rail item's badge. */
     val storeDownloadsActive: Int = 0,
@@ -151,6 +154,15 @@ class FrontEndActions(
     val onGameShortcut: (Library.SteamGame) -> Unit = {},
     val onExportGameFile: (Library.SteamGame) -> Unit = {},
     val onSyncGameFiles: () -> Unit = {},
+    /** The Games tab's +: the .exe picked in its dialog, to add as a game. */
+    val onAddGameExe: (path: String) -> Unit = {},
+    /** These added games (by folder) were added or edited: the Games tab updates just them. */
+    val onAddedGamesChanged: (folders: List<String>) -> Unit = {},
+    /** An added game removed in its editor: off the Games tab at once, out of Steam after. */
+    val onAddedGameRemoved: (folder: String, appId: Long?, name: String) -> Unit = { _, _, _ -> },
+    /** Setup's Artwork switch and the user's SteamGridDB API key ("" removes it). */
+    val onAddedGamesArt: (Boolean) -> Unit = {},
+    val onSgdbKey: (String) -> Unit = {},
     val onStopGameFileSync: () -> Unit = {},
     val onCopyGameLink: (Library.SteamGame) -> Unit = {},
     val onDesktop: () -> Unit,
diff --git a/app/src/main/java/com/droiddeck/launcher/ui/FrontEndSetup.kt b/app/src/main/java/com/droiddeck/launcher/ui/FrontEndSetup.kt
index 171caf818..1b9f086f8 100644
--- a/app/src/main/java/com/droiddeck/launcher/ui/FrontEndSetup.kt
+++ b/app/src/main/java/com/droiddeck/launcher/ui/FrontEndSetup.kt
@@ -164,6 +164,8 @@ internal fun SetupPanel(
     val limitBlocks = PhantomProcessLimit.blocksSteam(s.phantomProcessStatus)
     val signedIn = s.offlineAccount != null
     var showLimitDetails by rememberSaveable { mutableStateOf(false) }
+    var editSgdbKey by remember { mutableStateOf(false) }
+    if (editSgdbKey) SgdbKeyDialog(s.sgdbUserKey, onSave = { a.onSgdbKey(it); editSgdbKey = false }, onDismiss = { editSgdbKey = false })
     // Four tabs instead of one long scroll; LB and RB turn them from anywhere on the page. Build
     // and credits are on the Updates page.
     val tabs = listOf(stringResource(R.string.setup_tab_overview), stringResource(R.string.setup_tab_controller), stringResource(R.string.setup_tab_session), stringResource(R.string.setup_tab_launcher))
@@ -368,6 +370,13 @@ internal fun SetupPanel(
                                 s.storeEnabled,
                             ) { a.onStoreEnabled(it) }
                         }
+                        SettingsGroup(stringResource(R.string.content_games)) {
+                            ToggleRow(host, "added-art", stringResource(R.string.mode_added_art), stringResource(R.string.mode_added_art_hint), s.addedGamesArt) { a.onAddedGamesArt(it) }
+                            ActionRow(
+                                stringResource(R.string.mode_sgdb_key), if (s.sgdbUserKey) stringResource(R.string.mode_sgdb_key_yours) else null,
+                                stringResource(R.string.mode_sgdb_edit), onClick = { editSgdbKey = true },
+                            )
+                        }
                         SettingsGroup(stringResource(R.string.setup_stores)) {
                             ToggleRow(
                                 host, "stores-enabled", stringResource(R.string.setup_stores_show),
diff --git a/app/src/main/java/com/droiddeck/launcher/ui/ModeSettingsDialog.kt b/app/src/main/java/com/droiddeck/launcher/ui/ModeSettingsDialog.kt
index 8f3f29ec0..67cde5939 100644
--- a/app/src/main/java/com/droiddeck/launcher/ui/ModeSettingsDialog.kt
+++ b/app/src/main/java/com/droiddeck/launcher/ui/ModeSettingsDialog.kt
@@ -103,10 +103,6 @@ class ModeSettings(
     val wifiDiscoveryLocation: Boolean = false,
     val wifiDiscoveryAsked: Boolean = false,
     val wifiDiscoveryBlocked: Boolean = false,
-    /** Steam only: the user's chosen Games folders; null outside Steam. */
-    val addedGamesDirs: List<String>? = null,
-    val addedGames: List<AddedGameRow> = emptyList(),
-    val addedGamesArt: Boolean = true,
     /** Latest Banners-Turnip release: what each driver menu offers to download, and the refresh line. */
     /** Steam only: Decky Loader is managed from the Steam session settings. */
     val deckyInstalled: String? = null,
@@ -120,9 +116,6 @@ class ModeSettings(
     val deckySessionRunning: Boolean = false,
 )
 
-/** One added game as the settings page shows it: its folder, the chosen .exe, the other .exe files it could be. */
-class AddedGameRow(val folderPath: String, val folderName: String, val exePath: String, val exeName: String, val candidates: List<Pair<String, String>>)
-
 class ModeSettingsActions(
     val onResolution: (String) -> Unit,
     val onHdr: (Boolean) -> Unit,
@@ -154,11 +147,6 @@ class ModeSettingsActions(
     val onRunSteamAtStartup: (Boolean) -> Unit = {},
     val onWifiDiscovery: (Boolean) -> Unit = {},
     val onWifiDiscoverySettings: () -> Unit = {},
-    val onPickAddedGamesDir: () -> Unit = {},
-    val onForgetAddedGamesDir: (path: String) -> Unit = {},
-    val onAddedGamesArt: (Boolean) -> Unit = {},
-    val onAddedGameExe: (folderPath: String, path: String) -> Unit = { _, _ -> },
-    val onPickAddedGameExe: (folderPath: String) -> Unit = {},
     val onDeckyInstall: (DeckyManager.Release) -> Unit = {},
     val onDeckyCheck: () -> Unit = {},
     val onDeckyEnabled: (Boolean) -> Unit = {},
@@ -429,33 +417,6 @@ fun ModeSettingsPage(s: ModeSettings, a: ModeSettingsActions) {
                 }
             }
         }
-        if (steam && tab == ModeSettingsTab.GAMES && s.addedGamesDirs != null) SettingsGroup(stringResource(R.string.mode_added_games)) {
-            for (dir in s.addedGamesDirs) {
-                val n = s.addedGames.count { it.folderPath.startsWith("$dir/") }
-                ActionRow(
-                    dir.substringAfterLast('/').ifEmpty { dir }, dir + " · " + (if (n == 0) stringResource(R.string.mode_added_none) else pluralStringResource(R.plurals.mode_added_count, n, n)) + ". " + stringResource(R.string.added_games_forget_hint),
-                    stringResource(R.string.common_forget), onClick = { a.onForgetAddedGamesDir(dir) },
-                )
-            }
-            ActionRow(
-                if (s.addedGamesDirs.isEmpty()) stringResource(R.string.mode_games_folder) else stringResource(R.string.mode_games_folder_another),
-                stringResource(R.string.added_games_import_hint),
-                stringResource(R.string.common_add_ellipsis), onClick = a.onPickAddedGamesDir,
-            )
-            ToggleRow(
-                host, "addedArt", stringResource(R.string.mode_added_art),
-                stringResource(R.string.mode_added_art_hint),
-                s.addedGamesArt, onChange = a.onAddedGamesArt,
-            )
-            for (g in s.addedGames) {
-                ChoiceRow(
-                    host, "added:" + g.folderPath, g.folderName, if (s.addedGamesDirs.size > 1) stringResource(R.string.mode_added_launches_in, g.exeName, g.folderPath.substringBeforeLast('/').substringAfterLast('/')) else stringResource(R.string.mode_added_launches, g.exeName),
-                    g.candidates + ("__pick__" to stringResource(R.string.mode_added_choose)), g.exePath,
-                    note = stringResource(R.string.mode_added_exe_note),
-                    onPick = { path -> if (path == "__pick__") a.onPickAddedGameExe(g.folderPath) else a.onAddedGameExe(g.folderPath, path) },
-                )
-            }
-        }
         if (steam && tab == ModeSettingsTab.GAMES && s.fexPreset != null) SettingsGroup(stringResource(R.string.game_settings_title)) {
             if (s.syncBackend != null) SettingsRow(
                 stringResource(R.string.sync_backend_title),
@@ -552,6 +513,31 @@ fun ModeSettingsPage(s: ModeSettings, a: ModeSettingsActions) {
 }
 
 /** Width × height for the session, with the common handheld shapes one tap away. */
+/** Entry for the user's SteamGridDB API key; the saved key is never shown back. */
+@Composable
+internal fun SgdbKeyDialog(hasKey: Boolean, onSave: (String) -> Unit, onDismiss: () -> Unit) {
+    var key by remember { mutableStateOf("") }
+    androidx.compose.material3.AlertDialog(
+        onDismissRequest = onDismiss,
+        title = { Text(stringResource(R.string.mode_sgdb_key)) },
+        text = {
+            androidx.compose.material3.OutlinedTextField(
+                key, { v -> key = v.trim() }, label = { Text(stringResource(R.string.mode_sgdb_key)) },
+                singleLine = true, visualTransformation = androidx.compose.ui.text.input.PasswordVisualTransformation(),
+                keyboardOptions = androidx.compose.foundation.text.KeyboardOptions(keyboardType = androidx.compose.ui.text.input.KeyboardType.Password),
+                modifier = Modifier.fillMaxWidth(),
+            )
+        },
+        confirmButton = { androidx.compose.material3.TextButton(onClick = { onSave(key) }, enabled = key.isNotEmpty()) { Text(stringResource(R.string.common_ok)) } },
+        dismissButton = {
+            androidx.compose.foundation.layout.Row {
+                if (hasKey) androidx.compose.material3.TextButton(onClick = { onSave("") }) { Text(stringResource(R.string.common_delete)) }
+                androidx.compose.material3.TextButton(onClick = onDismiss) { Text(stringResource(R.string.common_cancel)) }
+            }
+        },
+    )
+}
+
 @OptIn(androidx.compose.foundation.layout.ExperimentalLayoutApi::class)
 @Composable
 internal fun CustomResolutionDialog(initial: Pair<Int, Int>?, onSave: (Pair<Int, Int>) -> Unit, onDismiss: () -> Unit) {
diff --git a/app/src/main/java/com/droiddeck/launcher/ui/SettingsWidgets.kt b/app/src/main/java/com/droiddeck/launcher/ui/SettingsWidgets.kt
index d091bc1bb..3aeb4e2fb 100644
--- a/app/src/main/java/com/droiddeck/launcher/ui/SettingsWidgets.kt
+++ b/app/src/main/java/com/droiddeck/launcher/ui/SettingsWidgets.kt
@@ -494,6 +494,19 @@ fun <T> ChoiceRow(
     }
 }
 
+/** A small "?" beside a value the app guessed and is not sure of; [description] says what to check. */
+@Composable
+fun UncertainMark(description: String) {
+    val colors = MaterialTheme.colorScheme
+    Box(
+        contentAlignment = Alignment.Center,
+        modifier = Modifier.size(22.dp).clip(CircleShape).background(colors.surfaceVariant)
+            .semantics { contentDescription = description },
+    ) {
+        Text("?", fontSize = 13.sp, fontWeight = FontWeight.Bold, color = colors.onSurfaceVariant)
+    }
+}
+
 @Composable
 fun ToggleRow(host: MenuHost, key: String, label: String, hint: String?, checked: Boolean, enabled: Boolean = true, chipModifier: Modifier = Modifier, onChange: (Boolean) -> Unit) =
     SettingsRow(label, hint) {
diff --git a/app/src/main/res/values-es/strings.xml b/app/src/main/res/values-es/strings.xml
index f346d1137..ce3f28abc 100644
--- a/app/src/main/res/values-es/strings.xml
+++ b/app/src/main/res/values-es/strings.xml
@@ -41,9 +41,7 @@
     <string name="hud_fg_failed">%1$s: falló el motor</string>
     <string name="hud_fg_needs_lossless">%1$s: requiere Lossless Scaling</string>
     <string name="hud_fg_starting">%1$s  %2$s · iniciando</string>
-    <string name="added_games_import_hint">Una carpeta con una subcarpeta por cada juego de Windows. Los juegos que tienes en Steam usan sus entradas de Steam tras reiniciar Steam; el resto se convierten en accesos directos ajenos a Steam. Con Segunda biblioteca en Automático, Steam también puede instalar juegos en esta carpeta.</string>
     <string name="second_library_import_hint">Añade una biblioteca de Steam y busca juegos de Windows en ella. Los juegos que tienes usan sus entradas de Steam; el resto se convierten en accesos directos ajenos a Steam.</string>
-    <string name="added_games_forget_hint">Olvidar quita los accesos directos en la próxima sesión. Los archivos se conservan.</string>
     <string name="game_env_title">Entorno del juego</string>
     <string name="game_env_hint">Variables de entorno para juegos de Proton.</string>
     <string name="game_env_edit">Editar</string>
@@ -299,16 +297,18 @@
     <string name="mode_steam_repair_hint">Vuelve a descargar el cliente de Steam la próxima vez que se inicie Steam. Úsalo si Steam se queda en la pantalla de carga. Se conservan los juegos, la sesión iniciada y los ajustes.</string>
     <string name="mode_steam_repair_queued">El cliente de Steam se volverá a descargar la próxima vez que se inicie Steam.</string>
     <string name="mode_steam_repair_button">Reparar</string>
-    <string name="mode_added_games">Juegos añadidos</string>
-    <string name="mode_added_none">no hay carpetas de juegos con un .exe</string>
-    <string name="mode_games_folder">Carpeta de juegos</string>
-    <string name="mode_games_folder_another">Otra carpeta de juegos</string>
-    <string name="mode_added_art">Imágenes de Steam</string>
+    <string name="mode_added_art">Ilustraciones</string>
+    <string name="mode_sgdb_key">Clave API de SteamGridDB</string>
+    <string name="mode_sgdb_key_yours">Tu clave</string>
+    <string name="mode_sgdb_edit">Editar…</string>
     <string name="mode_added_art_hint">Completa las imágenes que faltan según el nombre de la carpeta. Tus propios cover.jpg, hero.jpg, logo.png o icon.png en la carpeta del juego tienen prioridad.</string>
-    <string name="mode_added_launches">Inicia %1$s</string>
-    <string name="mode_added_launches_in">Inicia %1$s · en %2$s</string>
-    <string name="mode_added_choose">Elegir otro archivo…</string>
-    <string name="mode_added_exe_note">Por defecto, el .exe con el nombre de la carpeta o, si no, el más grande.</string>
+    <string name="summary_remove_game">Remove %1$s</string>
+    <string name="mode_added_remove_confirm">¿Quitar?</string>
+    <string name="games_add">Añadir juego</string>
+    <string name="games_add_title">Añadir un juego:</string>
+    <string name="games_pick_exe_title">Elige el exe:</string>
+    <string name="games_add_unreachable">Esta ubicación no está disponible en la sesión</string>
+    <string name="mode_added_exe_check">Revisa este .exe</string>
     <string name="wincomp_title">Componentes de Windows</string>
     <string name="wincomp_pad_hint">LB / RB saltan entre las secciones.</string>
     <string name="wincomp_card_none">Ninguno</string>
@@ -1139,8 +1139,6 @@
     <string name="main_removing_named">Quitando %1$s…</string>
     <string name="main_forgetting_named">Olvidando %1$s…</string>
     <string name="main_pick_game_storage">Elige la carpeta de almacenamiento de juegos</string>
-    <string name="main_pick_added_games">Elige una carpeta con tus propios juegos</string>
-    <string name="main_pick_game_exe">Elige el .exe del juego</string>
     <string name="main_pick_decky_zip">Elige un ZIP de plugin de Decky</string>
     <string name="main_storage_not_usable">No se puede usar: %1$s</string>
 
@@ -2086,4 +2084,39 @@
     <string name="device_info_copied">Copiado.</string>
     <string name="force_ssbs_title">Forzar SSBS</string>
     <string name="force_ssbs_hint">Mantiene activado un ajuste de velocidad de la CPU que Wine sigue desactivando. Puede hacer más rápidos los juegos de Windows en Snapdragon 8 Elite; poco cambio en chips anteriores. Se aplica en el próximo inicio de un juego.</string>
+    <string name="common_close">Cerrar</string>
+    <string name="common_back">Atrás</string>
+    <string name="common_edit">Editar</string>
+    <string name="games_add_all">Añadir todos los juegos de esta carpeta</string>
+    <string name="games_added_none">Nada nuevo en esta carpeta</string>
+    <string name="edit_name">Nombre</string>
+    <string name="edit_target">Destino</string>
+    <string name="edit_start_in">Iniciar en</string>
+    <string name="edit_launch_options">Opciones de lanzamiento</string>
+    <string name="edit_artwork">Ilustraciones</string>
+    <string name="edit_other_exe">Otro exe…</string>
+    <string name="edit_remove">Quitar</string>
+    <string name="art_cover">Portada</string>
+    <string name="art_background">Fondo</string>
+    <string name="art_logo">Logotipo</string>
+    <string name="art_icon">Icono</string>
+    <string name="art_src_folder">Carpeta del juego</string>
+    <string name="art_src_steam">Steam</string>
+    <string name="art_src_sgdb">SteamGridDB</string>
+    <string name="art_src_file">Tu archivo</string>
+    <string name="art_src_exe">Del exe</string>
+    <string name="art_src_auto">Automático</string>
+    <string name="art_pick_image">Elegir imagen…</string>
+    <string name="art_pick_title">Elige una imagen: %1$s</string>
+    <string name="art_reset">Restablecer a automático</string>
+    <plurals name="games_added_n">
+        <item quantity="one">%1$d juego añadido</item>
+        <item quantity="many">%1$d juegos añadidos</item>
+        <item quantity="other">%1$d juegos añadidos</item>
+    </plurals>
+    <plurals name="games_already_n">
+        <item quantity="one">%1$d ya en Juegos</item>
+        <item quantity="many">%1$d ya en Juegos</item>
+        <item quantity="other">%1$d ya en Juegos</item>
+    </plurals>
 </resources>
diff --git a/app/src/main/res/values-fr/strings.xml b/app/src/main/res/values-fr/strings.xml
index 07a3c7f41..ed5442eca 100644
--- a/app/src/main/res/values-fr/strings.xml
+++ b/app/src/main/res/values-fr/strings.xml
@@ -41,9 +41,7 @@
     <string name="hud_fg_failed">%1$s : échec du moteur</string>
     <string name="hud_fg_needs_lossless">%1$s : nécessite Lossless Scaling</string>
     <string name="hud_fg_starting">%1$s  %2$s · Démarrage en cours</string>
-    <string name="added_games_import_hint">Un dossier contenant plusieurs sous-dossiers, chaque sous-dossier correspondant à un jeu Windows. Les jeux que vous possédez sur Steam utiliseront les entrées Steam correspondantes après le redémarrage de Steam ; les autres jeux deviendront des raccourcis non-Steam. Si Bibliothèque secondaire est sur Auto, Steam peut aussi installer des jeux dans ce dossier.</string>
     <string name="second_library_import_hint">Ajoutez une bibliothèque Steam et analysez-y les jeux Windows. Les jeux déjà possédés utiliseront les entrées Steam correspondantes, les autres deviendront des raccourcis non-Steam.</string>
-    <string name="added_games_forget_hint">« Oublier » supprimera ces raccourcis lors de la prochaine session. Mais les fichiers resteront sur le disque.</string>
     <string name="game_env_title">Environnement de jeu</string>
     <string name="game_env_hint">Variables d\'environnement pour les jeux Proton.</string>
     <string name="game_env_edit">Modifier</string>
@@ -269,16 +267,18 @@
     <string name="mode_branch_public">Bêta</string>
     <string name="mode_branch_deck_beta">Bêta Steam Deck</string>
     <string name="mode_branch_note">Le mode Deck utilise toujours la version bêta de Steam Deck.</string>
-    <string name="mode_added_games">Jeux ajoutés</string>
-    <string name="mode_added_none">Aucun dossier de jeu contenant un .exe trouvé</string>
-    <string name="mode_games_folder">Dossier de jeux</string>
-    <string name="mode_games_folder_another">Autre dossier de jeux</string>
-    <string name="mode_added_art">Images depuis Steam</string>
+    <string name="mode_added_art">Illustrations</string>
+    <string name="mode_sgdb_key">Clé API SteamGridDB</string>
+    <string name="mode_sgdb_key_yours">Votre clé</string>
+    <string name="mode_sgdb_edit">Modifier…</string>
     <string name="mode_added_art_hint">Complète les images manquantes selon le nom du dossier. Les fichiers cover.jpg, hero.jpg, logo.png ou icon.png dans le dossier du jeu sont prioritaires.</string>
-    <string name="mode_added_launches">Lancer %1$s</string>
-    <string name="mode_added_launches_in">Lancer %1$s · dans %2$s</string>
-    <string name="mode_added_choose">Choisir un autre fichier…</string>
-    <string name="mode_added_exe_note">Utilise par défaut le .exe portant le même nom que le dossier, sinon le .exe le plus volumineux.</string>
+    <string name="summary_remove_game">Remove %1$s</string>
+    <string name="mode_added_remove_confirm">Retirer ?</string>
+    <string name="games_add">Ajouter un jeu</string>
+    <string name="games_add_title">Ajouter un jeu :</string>
+    <string name="games_pick_exe_title">Choisir l’exe :</string>
+    <string name="games_add_unreachable">Cet emplacement n’est pas disponible dans la session</string>
+    <string name="mode_added_exe_check">Vérifier cet exécutable</string>
     <string name="mode_stretch169">Étirer les jeux 16:9</string>
     <string name="mode_stretch169_hint">Sur les écrans dont le rapport d\'aspect est inférieur à 16:9, étire le jeu pour remplir l\'écran au lieu d\'afficher des bandes noires. Prendra effet à la prochaine session.</string>
     <string name="mode_audio">Audio</string>
@@ -935,4 +935,37 @@
     <string name="game_frontend_files">Fichiers frontaux</string>
     <string name="fm_up_one_level">Remonter d\'un niveau</string>
     <string name="fm_drive_linux">Système Linux</string>
+    <string name="common_close">Fermer</string>
+    <string name="common_back">Retour</string>
+    <string name="common_edit">Modifier</string>
+    <string name="games_add_all">Ajouter tous les jeux de ce dossier</string>
+    <string name="games_added_none">Rien de nouveau dans ce dossier</string>
+    <string name="edit_name">Nom</string>
+    <string name="edit_target">Cible</string>
+    <string name="edit_start_in">Démarrer dans</string>
+    <string name="edit_launch_options">Options de lancement</string>
+    <string name="edit_artwork">Illustrations</string>
+    <string name="edit_other_exe">Autre exe…</string>
+    <string name="edit_remove">Retirer</string>
+    <string name="art_cover">Jaquette</string>
+    <string name="art_background">Arrière-plan</string>
+    <string name="art_logo">Logo</string>
+    <string name="art_icon">Icône</string>
+    <string name="art_src_folder">Dossier du jeu</string>
+    <string name="art_src_steam">Steam</string>
+    <string name="art_src_sgdb">SteamGridDB</string>
+    <string name="art_src_file">Votre fichier</string>
+    <string name="art_src_exe">Depuis l’exe</string>
+    <string name="art_src_auto">Automatique</string>
+    <string name="art_pick_image">Choisir une image…</string>
+    <string name="art_pick_title">Choisir une image : %1$s</string>
+    <string name="art_reset">Revenir à automatique</string>
+    <plurals name="games_added_n">
+        <item quantity="one">%1$d jeu ajouté</item>
+        <item quantity="other">%1$d jeux ajoutés</item>
+    </plurals>
+    <plurals name="games_already_n">
+        <item quantity="one">%1$d déjà dans Jeux</item>
+        <item quantity="other">%1$d déjà dans Jeux</item>
+    </plurals>
 </resources>
\ No newline at end of file
diff --git a/app/src/main/res/values-ja/strings.xml b/app/src/main/res/values-ja/strings.xml
index e2f18b9f6..f77b79aa9 100644
--- a/app/src/main/res/values-ja/strings.xml
+++ b/app/src/main/res/values-ja/strings.xml
@@ -41,9 +41,7 @@
     <string name="hud_fg_failed">%1$s：エンジンエラー</string>
     <string name="hud_fg_needs_lossless">%1$s：Lossless Scalingが必要です</string>
     <string name="hud_fg_starting">%1$s  %2$s · 起動中</string>
-    <string name="added_games_import_hint">複数のサブフォルダを含むフォルダ。各サブフォルダはWindowsゲームに対応します。Steamで所有しているゲームはSteamの再起動後にSteamの項目を使用し、それ以外のゲームは非Steamショートカットになります。第2ライブラリが自動の場合、Steamはこのフォルダにもゲームをインストールできます。</string>
     <string name="second_library_import_hint">Steamライブラリを追加し、その中のWindowsゲームをスキャンします。所有しているゲームはSteamの項目を使用し、それ以外のゲームは非Steamショートカットになります。</string>
-    <string name="added_games_forget_hint">「忘れる」を選択すると、次回のセッションでこれらのショートカットが削除されます。ただし、ファイルはディスク上に残ります。</string>
     <string name="game_env_title">ゲーム環境</string>
     <string name="game_env_hint">Protonゲームの環境変数です。</string>
     <string name="game_env_edit">編集</string>
@@ -299,16 +297,18 @@
     <string name="mode_steam_repair_hint">次回Steamの起動時にSteamクライアントを再ダウンロードします。Steamが読み込み画面のまま進まない場合に使用してください。ゲーム、ログイン情報、設定は保持されます。</string>
     <string name="mode_steam_repair_queued">次回Steamの起動時にSteamクライアントを再ダウンロードします。</string>
     <string name="mode_steam_repair_button">修復</string>
-    <string name="mode_added_games">追加されたゲーム</string>
-    <string name="mode_added_none">.exeを含むゲームフォルダが見つかりません</string>
-    <string name="mode_games_folder">ゲームフォルダ</string>
-    <string name="mode_games_folder_another">別のゲームフォルダ</string>
-    <string name="mode_added_art">Steamからの画像</string>
+    <string name="mode_added_art">アートワーク</string>
+    <string name="mode_sgdb_key">SteamGridDB API キー</string>
+    <string name="mode_sgdb_key_yours">自分のキー</string>
+    <string name="mode_sgdb_edit">編集…</string>
     <string name="mode_added_art_hint">フォルダ名に基づいて不足している画像を補完します。ゲームフォルダ内のcover.jpg、hero.jpg、logo.png、またはicon.pngが優先的に使用されます。</string>
-    <string name="mode_added_launches">%1$sを起動</string>
-    <string name="mode_added_launches_in">%1$sを起動 · %2$s内</string>
-    <string name="mode_added_choose">別のファイルを選択…</string>
-    <string name="mode_added_exe_note">デフォルトではフォルダと同じ名前の.exeを使用し、ない場合は最大の.exeを使用します。</string>
+    <string name="summary_remove_game">Remove %1$s</string>
+    <string name="mode_added_remove_confirm">削除？</string>
+    <string name="games_add">ゲームを追加</string>
+    <string name="games_add_title">ゲームを追加:</string>
+    <string name="games_pick_exe_title">exe を選択:</string>
+    <string name="games_add_unreachable">この場所はセッションから使えません</string>
+    <string name="mode_added_exe_check">この exe を確認</string>
     <string name="wincomp_title">Windowsコンポーネント</string>
     <string name="wincomp_pad_hint">LB / RBでセクション間を移動します。</string>
     <string name="wincomp_card_none">なし</string>
@@ -1123,8 +1123,6 @@
     <string name="main_removing_named">%1$sを削除中…</string>
     <string name="main_forgetting_named">%1$sを登録解除中…</string>
     <string name="main_pick_game_storage">ゲームの保存先フォルダを選択</string>
-    <string name="main_pick_added_games">自分のゲームがあるフォルダを選択</string>
-    <string name="main_pick_game_exe">ゲームの.exeを選択</string>
     <string name="main_pick_decky_zip">Deckyプラグインのzipを選択</string>
     <string name="main_storage_not_usable">使用できません：%1$s</string>
 
@@ -2048,4 +2046,35 @@
     <string name="device_info_copied">コピーしました。</string>
     <string name="force_ssbs_title">SSBSを強制</string>
     <string name="force_ssbs_hint">Wineがオフにし続けるCPUの速度設定をオンに保ちます。Snapdragon 8 EliteではWindowsゲームが速くなることがあります。古いチップではほとんど変化がありません。次のゲーム起動時に反映されます。</string>
+    <string name="common_close">閉じる</string>
+    <string name="common_back">戻る</string>
+    <string name="common_edit">編集</string>
+    <string name="games_add_all">このフォルダーのゲームをすべて追加</string>
+    <string name="games_added_none">このフォルダーに新しいゲームはありません</string>
+    <string name="edit_name">名前</string>
+    <string name="edit_target">ターゲット</string>
+    <string name="edit_start_in">開始フォルダー</string>
+    <string name="edit_launch_options">起動オプション</string>
+    <string name="edit_artwork">アートワーク</string>
+    <string name="edit_other_exe">別の exe…</string>
+    <string name="edit_remove">削除</string>
+    <string name="art_cover">カバー</string>
+    <string name="art_background">背景</string>
+    <string name="art_logo">ロゴ</string>
+    <string name="art_icon">アイコン</string>
+    <string name="art_src_folder">ゲームフォルダー</string>
+    <string name="art_src_steam">Steam</string>
+    <string name="art_src_sgdb">SteamGridDB</string>
+    <string name="art_src_file">自分のファイル</string>
+    <string name="art_src_exe">exe から</string>
+    <string name="art_src_auto">自動</string>
+    <string name="art_pick_image">画像を選択…</string>
+    <string name="art_pick_title">画像を選択: %1$s</string>
+    <string name="art_reset">自動に戻す</string>
+    <plurals name="games_added_n">
+        <item quantity="other">%1$d 本のゲームを追加しました</item>
+    </plurals>
+    <plurals name="games_already_n">
+        <item quantity="other">%1$d 本はすでにゲームにあります</item>
+    </plurals>
 </resources>
diff --git a/app/src/main/res/values-ko/strings.xml b/app/src/main/res/values-ko/strings.xml
index a4fca8255..44a88c5f9 100644
--- a/app/src/main/res/values-ko/strings.xml
+++ b/app/src/main/res/values-ko/strings.xml
@@ -41,9 +41,7 @@
     <string name="hud_fg_failed">%1$s: 엔진 실패</string>
     <string name="hud_fg_needs_lossless">%1$s: Lossless Scaling 필요</string>
     <string name="hud_fg_starting">%1$s  %2$s · 시작 중</string>
-    <string name="added_games_import_hint">여러 하위 폴더가 포함된 폴더이며, 각 하위 폴더는 Windows 게임에 해당합니다. Steam에서 소유한 게임은 Steam 재시작 후 해당 Steam 항목을 사용하고, 나머지 게임은 비 Steam 바로 가기가 됩니다. 보조 라이브러리가 자동이면 Steam이 이 폴더에도 게임을 설치할 수 있습니다.</string>
     <string name="second_library_import_hint">Steam 라이브러리를 추가하고 그 안의 Windows 게임을 검사합니다. 소유한 게임은 해당 Steam 항목을 사용하고, 나머지 게임은 비 Steam 바로 가기가 됩니다.</string>
-    <string name="added_games_forget_hint">\"잊기\"를 누르면 다음 세션에서 이 바로 가기가 제거됩니다. 하지만 파일은 디스크에 그대로 남습니다.</string>
     <string name="game_env_title">게임 환경</string>
     <string name="game_env_hint">Proton 게임의 환경 변수입니다.</string>
     <string name="game_env_edit">편집</string>
@@ -299,16 +297,18 @@
     <string name="mode_steam_repair_hint">다음에 Steam을 시작할 때 Steam 클라이언트를 다시 다운로드합니다. Steam이 로딩 화면에서 넘어가지 않을 때 사용하세요. 게임, 로그인 정보 및 설정은 유지됩니다.</string>
     <string name="mode_steam_repair_queued">다음에 Steam을 시작할 때 Steam 클라이언트를 다시 다운로드합니다.</string>
     <string name="mode_steam_repair_button">복구</string>
-    <string name="mode_added_games">추가된 게임</string>
-    <string name="mode_added_none">.exe가 포함된 게임 폴더를 찾을 수 없습니다</string>
-    <string name="mode_games_folder">게임 폴더</string>
-    <string name="mode_games_folder_another">다른 게임 폴더</string>
-    <string name="mode_added_art">Steam에서 가져온 이미지</string>
+    <string name="mode_added_art">아트워크</string>
+    <string name="mode_sgdb_key">SteamGridDB API 키</string>
+    <string name="mode_sgdb_key_yours">내 키</string>
+    <string name="mode_sgdb_edit">편집…</string>
     <string name="mode_added_art_hint">폴더 이름을 기준으로 누락된 이미지를 채웁니다. 게임 폴더의 cover.jpg, hero.jpg, logo.png 또는 icon.png가 우선적으로 사용됩니다.</string>
-    <string name="mode_added_launches">%1$s 실행</string>
-    <string name="mode_added_launches_in">%1$s 실행 · %2$s에 위치</string>
-    <string name="mode_added_choose">다른 파일 선택…</string>
-    <string name="mode_added_exe_note">기본적으로 폴더와 이름이 같은 .exe를 사용하고, 없으면 가장 큰 .exe를 사용합니다.</string>
+    <string name="summary_remove_game">Remove %1$s</string>
+    <string name="mode_added_remove_confirm">제거?</string>
+    <string name="games_add">게임 추가</string>
+    <string name="games_add_title">게임 추가:</string>
+    <string name="games_pick_exe_title">exe 선택:</string>
+    <string name="games_add_unreachable">이 위치는 세션에서 사용할 수 없습니다</string>
+    <string name="mode_added_exe_check">이 exe 확인</string>
     <string name="wincomp_title">Windows 구성 요소</string>
     <string name="wincomp_pad_hint">LB / RB로 섹션 사이를 이동합니다.</string>
     <string name="wincomp_card_none">없음</string>
@@ -1123,8 +1123,6 @@
     <string name="main_removing_named">%1$s 제거 중…</string>
     <string name="main_forgetting_named">%1$s 잊는 중…</string>
     <string name="main_pick_game_storage">게임 저장 폴더 선택</string>
-    <string name="main_pick_added_games">내 게임이 있는 폴더 선택</string>
-    <string name="main_pick_game_exe">게임의 .exe 선택</string>
     <string name="main_pick_decky_zip">Decky 플러그인 ZIP 선택</string>
     <string name="main_storage_not_usable">사용할 수 없음: %1$s</string>
 
@@ -2048,4 +2046,35 @@
     <string name="device_info_copied">복사했습니다.</string>
     <string name="force_ssbs_title">SSBS 강제</string>
     <string name="force_ssbs_hint">Wine이 계속 끄는 CPU 속도 설정을 켜 둡니다. Snapdragon 8 Elite에서 Windows 게임이 빨라질 수 있으며, 이전 칩에서는 변화가 거의 없습니다. 다음 게임 실행 시 적용됩니다.</string>
+    <string name="common_close">닫기</string>
+    <string name="common_back">뒤로</string>
+    <string name="common_edit">편집</string>
+    <string name="games_add_all">이 폴더의 모든 게임 추가</string>
+    <string name="games_added_none">이 폴더에 새 게임이 없습니다</string>
+    <string name="edit_name">이름</string>
+    <string name="edit_target">대상</string>
+    <string name="edit_start_in">시작 위치</string>
+    <string name="edit_launch_options">실행 옵션</string>
+    <string name="edit_artwork">아트워크</string>
+    <string name="edit_other_exe">다른 exe…</string>
+    <string name="edit_remove">제거</string>
+    <string name="art_cover">커버</string>
+    <string name="art_background">배경</string>
+    <string name="art_logo">로고</string>
+    <string name="art_icon">아이콘</string>
+    <string name="art_src_folder">게임 폴더</string>
+    <string name="art_src_steam">Steam</string>
+    <string name="art_src_sgdb">SteamGridDB</string>
+    <string name="art_src_file">내 파일</string>
+    <string name="art_src_exe">exe에서</string>
+    <string name="art_src_auto">자동</string>
+    <string name="art_pick_image">이미지 선택…</string>
+    <string name="art_pick_title">이미지 선택: %1$s</string>
+    <string name="art_reset">자동으로 재설정</string>
+    <plurals name="games_added_n">
+        <item quantity="other">게임 %1$d개 추가됨</item>
+    </plurals>
+    <plurals name="games_already_n">
+        <item quantity="other">%1$d개는 이미 게임에 있음</item>
+    </plurals>
 </resources>
diff --git a/app/src/main/res/values-ru/strings.xml b/app/src/main/res/values-ru/strings.xml
index 0863f3265..9e39a6775 100644
--- a/app/src/main/res/values-ru/strings.xml
+++ b/app/src/main/res/values-ru/strings.xml
@@ -41,9 +41,7 @@
     <string name="hud_fg_failed">%1$s: сбой движка</string>
     <string name="hud_fg_needs_lossless">%1$s: требуется Lossless Scaling</string>
     <string name="hud_fg_starting">%1$s  %2$s · запуск</string>
-    <string name="added_games_import_hint">Папка, где каждая подпапка — отдельная игра для Windows. Игры из вашей библиотеки Steam после перезапуска Steam используют свои записи, остальные добавляются как ярлыки сторонних игр. Если для параметра «Вторая библиотека» выбрано «Авто», Steam также может устанавливать игры в эту папку.</string>
     <string name="second_library_import_hint">Добавляет библиотеку Steam и ищет в ней игры для Windows. Игры из вашей библиотеки Steam используют свои записи Steam, остальные добавляются как ярлыки сторонних игр.</string>
-    <string name="added_games_forget_hint">«Забыть» удалит ярлыки в следующей сессии. Файлы останутся на диске.</string>
     <string name="game_env_title">Игровая среда</string>
     <string name="game_env_hint">Переменные среды для игр Proton.</string>
     <string name="game_env_edit">Изменить</string>
@@ -297,16 +295,18 @@
     <string name="mode_steam_repair_hint">При следующем запуске Steam клиент будет скачан заново. Используйте, если Steam зависает на экране загрузки. Игры, вход и настройки сохраняются.</string>
     <string name="mode_steam_repair_queued">Клиент Steam будет скачан заново при следующем запуске Steam.</string>
     <string name="mode_steam_repair_button">Восстановить</string>
-    <string name="mode_added_games">Добавленные игры</string>
-    <string name="mode_added_none">папок с играми (.exe) не найдено</string>
-    <string name="mode_games_folder">Папка с играми</string>
-    <string name="mode_games_folder_another">Другая папка с играми</string>
-    <string name="mode_added_art">Обложки из Steam</string>
+    <string name="mode_added_art">Обложки</string>
+    <string name="mode_sgdb_key">API-ключ SteamGridDB</string>
+    <string name="mode_sgdb_key_yours">Ваш ключ</string>
+    <string name="mode_sgdb_edit">Изменить…</string>
     <string name="mode_added_art_hint">Дополняет отсутствующие изображения по имени папки. Файлы cover.jpg, hero.jpg, logo.png или icon.png в папке с игрой имеют приоритет.</string>
-    <string name="mode_added_launches">Запускает %1$s</string>
-    <string name="mode_added_launches_in">Запускает %1$s · в %2$s</string>
-    <string name="mode_added_choose">Выбрать другой файл…</string>
-    <string name="mode_added_exe_note">По умолчанию используется .exe с именем папки, иначе самый большой .exe.</string>
+    <string name="summary_remove_game">Remove %1$s</string>
+    <string name="mode_added_remove_confirm">Убрать?</string>
+    <string name="games_add">Добавить игру</string>
+    <string name="games_add_title">Добавить игру:</string>
+    <string name="games_pick_exe_title">Выберите exe:</string>
+    <string name="games_add_unreachable">Это расположение недоступно в сеансе</string>
+    <string name="mode_added_exe_check">Проверьте этот exe</string>
     <string name="mode_stretch169">Растянуть игры 16:9</string>
     <string name="mode_stretch169_hint">На экранах уже 16:9 растягивает игры на весь экран вместо черных полос. Вступит в силу в следующей сессии.</string>
     <string name="mode_audio">Аудио</string>
@@ -1042,4 +1042,41 @@
     <string name="device_info_copy">Копировать</string>
     <string name="device_info_copy_hint">Скопируйте эти сведения в отчет об ошибке.</string>
     <string name="device_info_copied">Скопировано.</string>
+    <string name="common_close">Закрыть</string>
+    <string name="common_back">Назад</string>
+    <string name="common_edit">Изменить</string>
+    <string name="games_add_all">Добавить все игры из этой папки</string>
+    <string name="games_added_none">В этой папке нет новых игр</string>
+    <string name="edit_name">Название</string>
+    <string name="edit_target">Объект</string>
+    <string name="edit_start_in">Рабочая папка</string>
+    <string name="edit_launch_options">Параметры запуска</string>
+    <string name="edit_artwork">Обложки</string>
+    <string name="edit_other_exe">Другой exe…</string>
+    <string name="edit_remove">Убрать</string>
+    <string name="art_cover">Обложка</string>
+    <string name="art_background">Фон</string>
+    <string name="art_logo">Логотип</string>
+    <string name="art_icon">Значок</string>
+    <string name="art_src_folder">Папка игры</string>
+    <string name="art_src_steam">Steam</string>
+    <string name="art_src_sgdb">SteamGridDB</string>
+    <string name="art_src_file">Ваш файл</string>
+    <string name="art_src_exe">Из exe</string>
+    <string name="art_src_auto">Автоматически</string>
+    <string name="art_pick_image">Выбрать изображение…</string>
+    <string name="art_pick_title">Выберите изображение: %1$s</string>
+    <string name="art_reset">Сбросить на автоматически</string>
+    <plurals name="games_added_n">
+        <item quantity="one">Добавлена %1$d игра</item>
+        <item quantity="few">Добавлено %1$d игры</item>
+        <item quantity="many">Добавлено %1$d игр</item>
+        <item quantity="other">Добавлено %1$d игр</item>
+    </plurals>
+    <plurals name="games_already_n">
+        <item quantity="one">%1$d уже в «Играх»</item>
+        <item quantity="few">%1$d уже в «Играх»</item>
+        <item quantity="many">%1$d уже в «Играх»</item>
+        <item quantity="other">%1$d уже в «Играх»</item>
+    </plurals>
 </resources>
\ No newline at end of file
diff --git a/app/src/main/res/values-zh-rCN/strings.xml b/app/src/main/res/values-zh-rCN/strings.xml
index ea26e2ddd..e8e2326ee 100644
--- a/app/src/main/res/values-zh-rCN/strings.xml
+++ b/app/src/main/res/values-zh-rCN/strings.xml
@@ -41,9 +41,7 @@
     <string name="hud_fg_failed">%1$s：引擎失败</string>
     <string name="hud_fg_needs_lossless">%1$s：需要 Lossless Scaling</string>
     <string name="hud_fg_starting">%1$s  %2$s · 启动中</string>
-    <string name="added_games_import_hint">一个文件夹，其中每个 Windows 游戏各占一个子文件夹。你在 Steam 拥有的游戏会在 Steam 重启后使用其 Steam 条目；其余会变成非 Steam 快捷方式。第二个库设为自动时，Steam 也可以把游戏安装到此文件夹。</string>
     <string name="second_library_import_hint">添加一个 Steam 库并扫描其中的 Windows 游戏。已拥有的游戏使用其 Steam 条目；其余变成非 Steam 快捷方式。</string>
-    <string name="added_games_forget_hint">“移除”会在下次会话删除这些快捷方式。文件仍保留在磁盘上。</string>
     <string name="game_env_title">游戏环境</string>
     <string name="game_env_hint">Proton 游戏的环境变量。</string>
     <string name="game_env_edit">编辑</string>
@@ -299,16 +297,18 @@
     <string name="mode_steam_repair_hint">下次启动 Steam 时重新下载 Steam 客户端。如果 Steam 一直停在加载画面，请使用此项。游戏、登录信息和设置都会保留。</string>
     <string name="mode_steam_repair_queued">下次启动 Steam 时将重新下载 Steam 客户端。</string>
     <string name="mode_steam_repair_button">修复</string>
-    <string name="mode_added_games">已添加的游戏</string>
-    <string name="mode_added_none">未找到含 .exe 的游戏文件夹</string>
-    <string name="mode_games_folder">游戏文件夹</string>
-    <string name="mode_games_folder_another">另一个游戏文件夹</string>
-    <string name="mode_added_art">来自 Steam 的美术图</string>
+    <string name="mode_added_art">美术图</string>
+    <string name="mode_sgdb_key">SteamGridDB API 密钥</string>
+    <string name="mode_sgdb_key_yours">你的密钥</string>
+    <string name="mode_sgdb_edit">编辑…</string>
     <string name="mode_added_art_hint">按文件夹名补齐缺失的美术图。游戏文件夹中你自己的 cover.jpg、hero.jpg、logo.png 或 icon.png 优先。</string>
-    <string name="mode_added_launches">启动 %1$s</string>
-    <string name="mode_added_launches_in">启动 %1$s · 位于 %2$s</string>
-    <string name="mode_added_choose">选择其他文件…</string>
-    <string name="mode_added_exe_note">默认为与文件夹同名的 .exe，否则为最大的那个。</string>
+    <string name="summary_remove_game">Remove %1$s</string>
+    <string name="mode_added_remove_confirm">移除？</string>
+    <string name="games_add">添加游戏</string>
+    <string name="games_add_title">添加游戏：</string>
+    <string name="games_pick_exe_title">选择 exe：</string>
+    <string name="games_add_unreachable">会话中无法访问此位置</string>
+    <string name="mode_added_exe_check">请检查此 exe</string>
     <string name="wincomp_title">Windows 组件</string>
     <string name="wincomp_pad_hint">按 LB / RB 在各部分之间跳转。</string>
     <string name="wincomp_card_none">无</string>
@@ -1123,8 +1123,6 @@
     <string name="main_removing_named">正在移除 %1$s…</string>
     <string name="main_forgetting_named">正在移除 %1$s…</string>
     <string name="main_pick_game_storage">选择游戏存储文件夹</string>
-    <string name="main_pick_added_games">选择存放你自己游戏的文件夹</string>
-    <string name="main_pick_game_exe">选择游戏的 .exe</string>
     <string name="main_pick_decky_zip">选择 Decky 插件 ZIP 包</string>
     <string name="main_storage_not_usable">无法使用：%1$s</string>
 
@@ -2048,4 +2046,35 @@
     <string name="device_info_copied">已复制。</string>
     <string name="force_ssbs_title">强制 SSBS</string>
     <string name="force_ssbs_hint">保持开启一项 Wine 会不断关闭的 CPU 速度设置。在骁龙 8 至尊版上可能让 Windows 游戏更快；在较旧芯片上变化不大。下次启动游戏时生效。</string>
+    <string name="common_close">关闭</string>
+    <string name="common_back">返回</string>
+    <string name="common_edit">编辑</string>
+    <string name="games_add_all">添加此文件夹中的所有游戏</string>
+    <string name="games_added_none">此文件夹中没有新游戏</string>
+    <string name="edit_name">名称</string>
+    <string name="edit_target">目标</string>
+    <string name="edit_start_in">起始位置</string>
+    <string name="edit_launch_options">启动选项</string>
+    <string name="edit_artwork">美术图</string>
+    <string name="edit_other_exe">其他 exe…</string>
+    <string name="edit_remove">移除</string>
+    <string name="art_cover">封面</string>
+    <string name="art_background">背景</string>
+    <string name="art_logo">标志</string>
+    <string name="art_icon">图标</string>
+    <string name="art_src_folder">游戏文件夹</string>
+    <string name="art_src_steam">Steam</string>
+    <string name="art_src_sgdb">SteamGridDB</string>
+    <string name="art_src_file">你的文件</string>
+    <string name="art_src_exe">来自 exe</string>
+    <string name="art_src_auto">自动</string>
+    <string name="art_pick_image">选择图片…</string>
+    <string name="art_pick_title">选择图片：%1$s</string>
+    <string name="art_reset">重置为自动</string>
+    <plurals name="games_added_n">
+        <item quantity="other">已添加 %1$d 个游戏</item>
+    </plurals>
+    <plurals name="games_already_n">
+        <item quantity="other">%1$d 个已在游戏中</item>
+    </plurals>
 </resources>
diff --git a/app/src/main/res/values-zh-rHK/strings.xml b/app/src/main/res/values-zh-rHK/strings.xml
index c236140ce..2ff75d749 100644
--- a/app/src/main/res/values-zh-rHK/strings.xml
+++ b/app/src/main/res/values-zh-rHK/strings.xml
@@ -41,9 +41,7 @@
     <string name="hud_fg_failed">%1$s：引擎故障</string>
     <string name="hud_fg_needs_lossless">%1$s：需要 Lossless Scaling</string>
     <string name="hud_fg_starting">%1$s  %2$s · 正在啟動</string>
-    <string name="added_games_import_hint">一個資料夾，每個 Windows 遊戲各佔一個子資料夾。你在 Steam 上擁有的遊戲會在 Steam 重新啟動後使用其 Steam 項目，其餘遊戲則成為非 Steam 捷徑。第二個收藏庫設為自動時，Steam 亦可以將遊戲安裝到此資料夾。</string>
     <string name="second_library_import_hint">新增一個 Steam 收藏庫並掃描其中的 Windows 遊戲。已擁有的遊戲會使用其 Steam 項目，其餘遊戲則成為非 Steam 捷徑。</string>
-    <string name="added_games_forget_hint">「忘記」會在下次會話移除這些捷徑，檔案仍會保留在磁碟上。</string>
     <string name="game_env_title">遊戲環境</string>
     <string name="game_env_hint">Proton 遊戲的環境變數。</string>
     <string name="game_env_edit">編輯</string>
@@ -299,16 +297,18 @@
     <string name="mode_steam_repair_hint">下次啟動 Steam 時重新下載 Steam 用戶端。如果 Steam 一直停留在載入畫面，請使用此功能。遊戲、登入資料和設定都會保留。</string>
     <string name="mode_steam_repair_queued">下次啟動 Steam 時會重新下載 Steam 用戶端。</string>
     <string name="mode_steam_repair_button">修復</string>
-    <string name="mode_added_games">已新增的遊戲</string>
-    <string name="mode_added_none">找不到含有 .exe 的遊戲資料夾</string>
-    <string name="mode_games_folder">遊戲資料夾</string>
-    <string name="mode_games_folder_another">另一個遊戲資料夾</string>
-    <string name="mode_added_art">取自 Steam 的圖片</string>
+    <string name="mode_added_art">圖片</string>
+    <string name="mode_sgdb_key">SteamGridDB API 密鑰</string>
+    <string name="mode_sgdb_key_yours">你的密鑰</string>
+    <string name="mode_sgdb_edit">編輯…</string>
     <string name="mode_added_art_hint">按資料夾名稱補上缺少的圖片。遊戲資料夾中你自己的 cover.jpg、hero.jpg、logo.png 或 icon.png 會優先使用。</string>
-    <string name="mode_added_launches">啟動 %1$s</string>
-    <string name="mode_added_launches_in">啟動 %1$s · 位於 %2$s</string>
-    <string name="mode_added_choose">選擇其他檔案…</string>
-    <string name="mode_added_exe_note">預設使用與資料夾同名的 .exe，否則使用最大的 .exe。</string>
+    <string name="summary_remove_game">Remove %1$s</string>
+    <string name="mode_added_remove_confirm">移除？</string>
+    <string name="games_add">加入遊戲</string>
+    <string name="games_add_title">加入遊戲：</string>
+    <string name="games_pick_exe_title">選擇 exe：</string>
+    <string name="games_add_unreachable">工作階段無法存取此位置</string>
+    <string name="mode_added_exe_check">請檢查此 exe</string>
     <string name="wincomp_title">Windows 組件</string>
     <string name="wincomp_pad_hint">按 LB / RB 在各部分之間切換。</string>
     <string name="wincomp_card_none">無</string>
@@ -1123,8 +1123,6 @@
     <string name="main_removing_named">正在移除 %1$s…</string>
     <string name="main_forgetting_named">正在忘記 %1$s…</string>
     <string name="main_pick_game_storage">選擇遊戲儲存資料夾</string>
-    <string name="main_pick_added_games">選擇存放你自己遊戲的資料夾</string>
-    <string name="main_pick_game_exe">選擇遊戲的 .exe</string>
     <string name="main_pick_decky_zip">選擇 Decky 插件 ZIP</string>
     <string name="main_storage_not_usable">無法使用：%1$s</string>
 
@@ -2048,4 +2046,35 @@
     <string name="device_info_copied">已複製。</string>
     <string name="force_ssbs_title">強制 SSBS</string>
     <string name="force_ssbs_hint">讓一項 Wine 會不斷關閉的 CPU 速度設定保持開啟。在 Snapdragon 8 Elite 上可能令 Windows 遊戲更快；在較舊的晶片上變化不大。下次啟動遊戲時生效。</string>
+    <string name="common_close">關閉</string>
+    <string name="common_back">返回</string>
+    <string name="common_edit">編輯</string>
+    <string name="games_add_all">加入此資料夾中的所有遊戲</string>
+    <string name="games_added_none">此資料夾中沒有新遊戲</string>
+    <string name="edit_name">名稱</string>
+    <string name="edit_target">目標</string>
+    <string name="edit_start_in">開始位置</string>
+    <string name="edit_launch_options">啟動選項</string>
+    <string name="edit_artwork">圖片</string>
+    <string name="edit_other_exe">其他 exe…</string>
+    <string name="edit_remove">移除</string>
+    <string name="art_cover">封面</string>
+    <string name="art_background">背景</string>
+    <string name="art_logo">標誌</string>
+    <string name="art_icon">圖示</string>
+    <string name="art_src_folder">遊戲資料夾</string>
+    <string name="art_src_steam">Steam</string>
+    <string name="art_src_sgdb">SteamGridDB</string>
+    <string name="art_src_file">你的檔案</string>
+    <string name="art_src_exe">來自 exe</string>
+    <string name="art_src_auto">自動</string>
+    <string name="art_pick_image">選擇圖片…</string>
+    <string name="art_pick_title">選擇圖片：%1$s</string>
+    <string name="art_reset">重設為自動</string>
+    <plurals name="games_added_n">
+        <item quantity="other">已加入 %1$d 個遊戲</item>
+    </plurals>
+    <plurals name="games_already_n">
+        <item quantity="other">%1$d 個已在遊戲中</item>
+    </plurals>
 </resources>
diff --git a/app/src/main/res/values-zh-rTW/strings.xml b/app/src/main/res/values-zh-rTW/strings.xml
index f7372765c..7ba84e88e 100644
--- a/app/src/main/res/values-zh-rTW/strings.xml
+++ b/app/src/main/res/values-zh-rTW/strings.xml
@@ -41,9 +41,7 @@
     <string name="hud_fg_failed">%1$s：引擎失敗</string>
     <string name="hud_fg_needs_lossless">%1$s：需要 Lossless Scaling</string>
     <string name="hud_fg_starting">%1$s  %2$s · 正在啟動</string>
-    <string name="added_games_import_hint">一個包含多個子資料夾的資料夾，每個子資料夾對應一個 Windows 遊戲。你在 Steam 上擁有的遊戲會在 Steam 重啟後使用對應的 Steam 項目，其餘遊戲會成為非 Steam 捷徑。第二收藏庫設為自動時，Steam 也可以將遊戲安裝到此資料夾。</string>
     <string name="second_library_import_hint">新增一個 Steam 收藏庫，並掃描其中的 Windows 遊戲。已擁有的遊戲會使用對應的 Steam 項目，其餘遊戲會成為非 Steam 捷徑。</string>
-    <string name="added_games_forget_hint">「忘記」會在下次工作階段中移除這些捷徑。但檔案仍保留在磁碟上。</string>
     <string name="game_env_title">遊戲環境</string>
     <string name="game_env_hint">Proton 遊戲的環境變數。</string>
     <string name="game_env_edit">編輯</string>
@@ -299,16 +297,18 @@
     <string name="mode_steam_repair_hint">下次啟動 Steam 時重新下載 Steam 用戶端。如果 Steam 一直停在載入畫面，請使用此功能。遊戲、登入狀態和設定都會保留。</string>
     <string name="mode_steam_repair_queued">下次啟動 Steam 時會重新下載 Steam 用戶端。</string>
     <string name="mode_steam_repair_button">修復</string>
-    <string name="mode_added_games">已新增的遊戲</string>
-    <string name="mode_added_none">未找到包含 .exe 的遊戲資料夾</string>
-    <string name="mode_games_folder">遊戲資料夾</string>
-    <string name="mode_games_folder_another">另一個遊戲資料夾</string>
-    <string name="mode_added_art">來自 Steam 的圖片</string>
+    <string name="mode_added_art">圖片</string>
+    <string name="mode_sgdb_key">SteamGridDB API 金鑰</string>
+    <string name="mode_sgdb_key_yours">你的金鑰</string>
+    <string name="mode_sgdb_edit">編輯…</string>
     <string name="mode_added_art_hint">按資料夾名稱補全缺少的圖片。遊戲資料夾中的 cover.jpg、hero.jpg、logo.png 或 icon.png 優先使用。</string>
-    <string name="mode_added_launches">啟動 %1$s</string>
-    <string name="mode_added_launches_in">啟動 %1$s · 位於 %2$s</string>
-    <string name="mode_added_choose">選擇其他檔案…</string>
-    <string name="mode_added_exe_note">預設使用與資料夾同名的 .exe，否則使用最大的 .exe。</string>
+    <string name="summary_remove_game">Remove %1$s</string>
+    <string name="mode_added_remove_confirm">移除？</string>
+    <string name="games_add">新增遊戲</string>
+    <string name="games_add_title">新增遊戲：</string>
+    <string name="games_pick_exe_title">選擇 exe：</string>
+    <string name="games_add_unreachable">工作階段無法存取此位置</string>
+    <string name="mode_added_exe_check">請檢查此 exe</string>
     <string name="wincomp_title">Windows 元件</string>
     <string name="wincomp_pad_hint">按 LB / RB 在各區段之間切換。</string>
     <string name="wincomp_card_none">無</string>
@@ -1123,8 +1123,6 @@
     <string name="main_removing_named">正在移除 %1$s…</string>
     <string name="main_forgetting_named">正在忘記 %1$s…</string>
     <string name="main_pick_game_storage">選擇遊戲儲存資料夾</string>
-    <string name="main_pick_added_games">選擇存放你自己遊戲的資料夾</string>
-    <string name="main_pick_game_exe">選擇遊戲的 .exe</string>
     <string name="main_pick_decky_zip">選擇 Decky 外掛程式 ZIP</string>
     <string name="main_storage_not_usable">無法使用：%1$s</string>
 
@@ -2048,4 +2046,35 @@
     <string name="device_info_copied">已複製。</string>
     <string name="force_ssbs_title">強制 SSBS</string>
     <string name="force_ssbs_hint">讓一項 Wine 會不斷關閉的 CPU 速度設定保持開啟。在 Snapdragon 8 Elite 上可能讓 Windows 遊戲更快；在較舊的晶片上變化不大。下次啟動遊戲時生效。</string>
+    <string name="common_close">關閉</string>
+    <string name="common_back">返回</string>
+    <string name="common_edit">編輯</string>
+    <string name="games_add_all">新增此資料夾中的所有遊戲</string>
+    <string name="games_added_none">此資料夾中沒有新遊戲</string>
+    <string name="edit_name">名稱</string>
+    <string name="edit_target">目標</string>
+    <string name="edit_start_in">開始位置</string>
+    <string name="edit_launch_options">啟動選項</string>
+    <string name="edit_artwork">圖片</string>
+    <string name="edit_other_exe">其他 exe…</string>
+    <string name="edit_remove">移除</string>
+    <string name="art_cover">封面</string>
+    <string name="art_background">背景</string>
+    <string name="art_logo">標誌</string>
+    <string name="art_icon">圖示</string>
+    <string name="art_src_folder">遊戲資料夾</string>
+    <string name="art_src_steam">Steam</string>
+    <string name="art_src_sgdb">SteamGridDB</string>
+    <string name="art_src_file">你的檔案</string>
+    <string name="art_src_exe">來自 exe</string>
+    <string name="art_src_auto">自動</string>
+    <string name="art_pick_image">選擇圖片…</string>
+    <string name="art_pick_title">選擇圖片：%1$s</string>
+    <string name="art_reset">重設為自動</string>
+    <plurals name="games_added_n">
+        <item quantity="other">已新增 %1$d 個遊戲</item>
+    </plurals>
+    <plurals name="games_already_n">
+        <item quantity="other">%1$d 個已在遊戲中</item>
+    </plurals>
 </resources>
diff --git a/app/src/main/res/values/strings.xml b/app/src/main/res/values/strings.xml
index fccdf24a1..eeb8d94eb 100644
--- a/app/src/main/res/values/strings.xml
+++ b/app/src/main/res/values/strings.xml
@@ -43,9 +43,7 @@
     <string name="hud_fg_failed">%1$s: engine failed</string>
     <string name="hud_fg_needs_lossless">%1$s: needs Lossless Scaling</string>
     <string name="hud_fg_starting">%1$s  %2$s · starting</string>
-    <string name="added_games_import_hint">A folder with one subfolder per Windows game. Games you own on Steam use their Steam entries after Steam restarts; the rest become non-Steam shortcuts. With Second library on Automatic, Steam can install games into this folder too.</string>
     <string name="second_library_import_hint">Adds a Steam library and scans it for Windows games. Owned games use their Steam entries; the rest become non-Steam shortcuts.</string>
-    <string name="added_games_forget_hint">Forget removes the shortcuts next session. Files stay on disk.</string>
     <string name="game_env_title">Game environment</string>
     <string name="game_env_hint">Environment variables for Proton games.</string>
     <string name="game_env_edit">Edit</string>
@@ -305,16 +303,18 @@
     <string name="mode_steam_repair_hint">Downloads the Steam client again the next time Steam starts. Use it if Steam stays on its loading screen. Games, sign-in and settings are kept.</string>
     <string name="mode_steam_repair_queued">The Steam client will be downloaded again the next time Steam starts.</string>
     <string name="mode_steam_repair_button">Repair</string>
-    <string name="mode_added_games">Added games</string>
-    <string name="mode_added_none">no game folders with a .exe found</string>
-    <string name="mode_games_folder">Games folder</string>
-    <string name="mode_games_folder_another">Another games folder</string>
-    <string name="mode_added_art">Artwork from Steam</string>
-    <string name="mode_added_art_hint">Fills in missing art by folder name. Your own cover.jpg, hero.jpg, logo.png or icon.png in the game folder takes priority.</string>
-    <string name="mode_added_launches">Launches %1$s</string>
-    <string name="mode_added_launches_in">Launches %1$s · in %2$s</string>
-    <string name="mode_added_choose">Choose another file…</string>
-    <string name="mode_added_exe_note">Defaults to the .exe named after the folder, or else the largest.</string>
+    <string name="mode_added_art">Artwork</string>
+    <string name="mode_sgdb_key">SteamGridDB API key</string>
+    <string name="mode_sgdb_key_yours">Your key</string>
+    <string name="mode_sgdb_edit">Edit…</string>
+    <string name="mode_added_art_hint">Fills in missing art from Steam, then SteamGridDB. Your own cover.jpg, hero.jpg, logo.png or icon.png in the game folder takes priority.</string>
+    <string name="summary_remove_game">Remove %1$s</string>
+    <string name="mode_added_remove_confirm">Remove?</string>
+    <string name="games_add">Add game</string>
+    <string name="games_add_title">Add a game:</string>
+    <string name="games_pick_exe_title">Pick the exe:</string>
+    <string name="games_add_unreachable">This location is not available in the session</string>
+    <string name="mode_added_exe_check">Check this exe</string>
     <string name="wincomp_title">Windows components</string>
     <string name="wincomp_pad_hint">LB / RB jump between the sections.</string>
     <string name="wincomp_card_none">None</string>
@@ -1128,8 +1128,6 @@
     <string name="main_removing_named">Removing %1$s…</string>
     <string name="main_forgetting_named">Forgetting %1$s…</string>
     <string name="main_pick_game_storage">Choose the game storage folder</string>
-    <string name="main_pick_added_games">Choose a folder of your own games</string>
-    <string name="main_pick_game_exe">Choose the game\'s .exe</string>
     <string name="main_pick_decky_zip">Choose a Decky plugin ZIP</string>
     <string name="main_storage_not_usable">Not usable: %1$s</string>
     <!-- What is running, when it is a program without a known name -->
@@ -2115,4 +2113,37 @@
     <string name="stores_login_error_ssl">The connection to the sign-in page is not secure.</string>
     <string name="stores_login_error_verification">The sign-in could not be verified. Try again.</string>
     <string name="stores_login_error_generic">Sign-in failed. Try again.</string>
+    <string name="common_close">Close</string>
+    <string name="common_back">Back</string>
+    <string name="common_edit">Edit</string>
+    <string name="games_add_all">Add all games in this folder</string>
+    <string name="games_added_none">Nothing new in this folder</string>
+    <string name="edit_name">Name</string>
+    <string name="edit_target">Target</string>
+    <string name="edit_start_in">Start in</string>
+    <string name="edit_launch_options">Launch options</string>
+    <string name="edit_artwork">Artwork</string>
+    <string name="edit_other_exe">Other exe…</string>
+    <string name="edit_remove">Remove</string>
+    <string name="art_cover">Cover</string>
+    <string name="art_background">Background</string>
+    <string name="art_logo">Logo</string>
+    <string name="art_icon">Icon</string>
+    <string name="art_src_folder">Game folder</string>
+    <string name="art_src_steam">Steam</string>
+    <string name="art_src_sgdb">SteamGridDB</string>
+    <string name="art_src_file">Your file</string>
+    <string name="art_src_exe">From the exe</string>
+    <string name="art_src_auto">Automatic</string>
+    <string name="art_pick_image">Pick image…</string>
+    <string name="art_pick_title">Pick an image: %1$s</string>
+    <string name="art_reset">Reset to automatic</string>
+    <plurals name="games_added_n">
+        <item quantity="one">%1$d game added</item>
+        <item quantity="other">%1$d games added</item>
+    </plurals>
+    <plurals name="games_already_n">
+        <item quantity="one">%1$d already in Games</item>
+        <item quantity="other">%1$d already in Games</item>
+    </plurals>
 </resources>
diff --git a/app/src/test/java/com/droiddeck/launcher/frontend/AddedExesTest.kt b/app/src/test/java/com/droiddeck/launcher/frontend/AddedExesTest.kt
new file mode 100644
index 000000000..d4deabba4
--- /dev/null
+++ b/app/src/test/java/com/droiddeck/launcher/frontend/AddedExesTest.kt
@@ -0,0 +1,106 @@
+package com.droiddeck.launcher.frontend
+
+import android.os.Environment
+import com.droiddeck.launcher.session.SessionPrefs
+import java.io.File
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertTrue
+import org.junit.Rule
+import org.junit.Test
+import org.junit.rules.TemporaryFolder
+import org.junit.runner.RunWith
+import org.robolectric.RobolectricTestRunner
+import org.robolectric.RuntimeEnvironment
+import org.robolectric.annotation.Config
+
+/** The Games tab's +: one picked .exe becomes a game, once, wherever the session can see it. */
+@RunWith(RobolectricTestRunner::class)
+@Config(sdk = [33])
+class AddedExesTest {
+    private val app get() = RuntimeEnvironment.getApplication()
+    @get:Rule val tmp = TemporaryFolder()
+
+    @org.junit.Before fun publishAtOnce() { AddedGamesPublisher.now = true }
+
+    private fun exe(path: File): File = path.apply { parentFile!!.mkdirs(); writeBytes(ByteArray(16)) }
+
+    private fun onStorage(rel: String) = exe(File(Environment.getExternalStorageDirectory(), rel))
+
+    private fun noGamesFolders() {
+        SessionPrefs.setGameStorage(app, SessionPrefs.GAME_STORAGE_OFF, "")
+        SessionPrefs.setAddedGamesDirs(app, emptyList())
+    }
+
+    @Test fun theEntryStoreKeepsOneEntryPerFolder() {
+        assertEquals(0, AddedExes.list(app).size)
+        AddedExes.put(app, AddedExes.Entry("/a/One", "/a/One/one.exe"))
+        AddedExes.put(app, AddedExes.Entry("/a/Two", "/a/Two/two.exe"))
+        AddedExes.put(app, AddedExes.Entry("/a/One", "/a/One/bin/one64.exe"))
+        assertEquals(listOf("/a/Two" to "/a/Two/two.exe", "/a/One" to "/a/One/bin/one64.exe"), AddedExes.list(app).map { it.folder to it.exe })
+        AddedExes.drop(app, "/a/Two")
+        assertEquals(listOf("/a/One"), AddedExes.list(app).map { it.folder })
+    }
+
+    @Test fun aPickedExeOnInternalStorageBecomesAGameOnce() {
+        noGamesFolders()
+        val pick = onStorage("Download/Celeste/Celeste.exe")
+        val added = AddedGames.addExe(app, pick)
+        assertTrue(added is AddedGames.AddResult.Added)
+        val game = (added as AddedGames.AddResult.Added).game
+        assertEquals("Celeste", game.name)
+        assertEquals(pick.path, game.exe.path)
+        assertEquals("/root/Storage/Download/Celeste/Celeste.exe", game.guestExe)
+        assertEquals("/root/Storage/Download/Celeste", game.guestDir)
+        assertEquals(Library.ADDED, game.source)
+        assertTrue(File(app.filesDir, "session/added-games.json").readText().contains("Celeste.exe"))
+
+        // The same exe again: the game it already is, no second entry.
+        val again = AddedGames.addExe(app, pick)
+        assertTrue(again is AddedGames.AddResult.Existing)
+        assertEquals(game.appId, (again as AddedGames.AddResult.Existing).game.appId)
+        assertEquals(1, AddedExes.list(app).size)
+        assertEquals(1, AddedGames.scan(app).size)
+    }
+
+    @Test fun anotherExeInTheSameGameSwitchesItsExe() {
+        noGamesFolders()
+        val first = onStorage("Games2/Hades/Hades.exe")
+        val other = onStorage("Games2/Hades/x64/Hades.exe")
+        val game = (AddedGames.addExe(app, first) as AddedGames.AddResult.Added).game
+        val switched = AddedGames.addExe(app, other)
+        assertTrue(switched is AddedGames.AddResult.Switched)
+        assertEquals(other.path, (switched as AddedGames.AddResult.Switched).game.exe.path)
+        assertEquals(game.appId, switched.game.appId)
+        assertEquals(1, AddedGames.scan(app).size)
+    }
+
+    @Test fun anExeInsideAListedGamesFolderGameSwitchesThatGame() {
+        val games = tmp.newFolder("PC")
+        exe(File(games, "Example/Example.exe"))
+        val deep = exe(File(games, "Example/bin/Example64.exe"))
+        SessionPrefs.setGameStorage(app, SessionPrefs.GAME_STORAGE_OFF, "")
+        SessionPrefs.setAddedGamesDirs(app, listOf(games.path))
+        val result = AddedGames.addExe(app, deep)
+        assertTrue(result is AddedGames.AddResult.Switched)
+        assertEquals(deep.path, AddedGames.scan(app).single().exe.path)
+        assertEquals(0, AddedExes.list(app).size)
+    }
+
+    @Test fun anExeTheSessionCannotSeeIsNotAdded() {
+        noGamesFolders()
+        val outside = exe(File(tmp.newFolder("elsewhere"), "Game/Game.exe"))
+        assertEquals(AddedGames.AddResult.Unreachable, AddedGames.addExe(app, outside))
+        assertEquals(0, AddedExes.list(app).size)
+        assertEquals(0, AddedGames.scan(app).size)
+    }
+
+    @Test fun aRemovedSingleExeGameStaysOffUntilPickedAgain() {
+        noGamesFolders()
+        val pick = onStorage("Download/Celeste/Celeste.exe")
+        val game = (AddedGames.addExe(app, pick) as AddedGames.AddResult.Added).game
+        AddedGames.remove(app, game.folder)
+        assertEquals(0, AddedGames.scan(app).size)
+        assertTrue(AddedGames.addExe(app, pick) is AddedGames.AddResult.Switched)
+        assertEquals(1, AddedGames.scan(app).size)
+    }
+}
diff --git a/app/src/test/java/com/droiddeck/launcher/frontend/AddedGameArtLookupTest.kt b/app/src/test/java/com/droiddeck/launcher/frontend/AddedGameArtLookupTest.kt
new file mode 100644
index 000000000..417c93c68
--- /dev/null
+++ b/app/src/test/java/com/droiddeck/launcher/frontend/AddedGameArtLookupTest.kt
@@ -0,0 +1,102 @@
+package com.droiddeck.launcher.frontend
+
+import com.droiddeck.launcher.stores.CredentialCipher
+import org.json.JSONArray
+import org.json.JSONObject
+import org.junit.After
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertFalse
+import org.junit.Assert.assertNull
+import org.junit.Assert.assertTrue
+import org.junit.Assert.fail
+import org.junit.Rule
+import org.junit.Test
+import org.junit.rules.TemporaryFolder
+import org.junit.runner.RunWith
+import org.robolectric.RobolectricTestRunner
+import org.robolectric.RuntimeEnvironment
+import org.robolectric.annotation.Config
+import java.io.File
+import java.security.SecureRandom
+import javax.crypto.spec.SecretKeySpec
+
+/** Where an added game's art comes from: its own Steam appid, a matching name, SteamGridDB's key. */
+@RunWith(RobolectricTestRunner::class)
+@Config(sdk = [33])
+class AddedGameArtLookupTest {
+    private val app get() = RuntimeEnvironment.getApplication()
+    @get:Rule val tmp = TemporaryFolder()
+
+    @After fun tearDown() {
+        SteamGridDb.setUserKey(app, "")
+        SteamGridDb.keys = CredentialCipher.Keystore
+    }
+
+    @Test fun anAppidFromTheGamesFilesIsUsedWithoutASearch() {
+        val lookup = File(tmp.newFolder(), "steam-appid")
+        val id = AddedGameArt.steamAppId("Palworld", 1623730, lookup) { fail("searched"); null }
+        assertEquals("1623730", id)
+        assertEquals("1623730", lookup.readText())
+        // An earlier "none" from a search does not stand in its way.
+        lookup.writeText("none")
+        assertEquals("1623730", AddedGameArt.steamAppId("Palworld", 1623730, lookup) { fail("searched"); null })
+    }
+
+    @Test fun withoutAnAppidTheTitleIsSearchedOnceAWeek() {
+        val lookup = File(tmp.newFolder(), "steam-appid")
+        var searches = 0
+        assertNull(AddedGameArt.steamAppId("Nothing Like It", null, lookup) { searches++; null })
+        assertEquals("none", lookup.readText())
+        assertNull(AddedGameArt.steamAppId("Nothing Like It", null, lookup) { searches++; "1" })
+        assertEquals(1, searches)
+        lookup.setLastModified(System.currentTimeMillis() - 8L * 24 * 3600 * 1000)
+        assertEquals("42", AddedGameArt.steamAppId("Nothing Like It", null, lookup) { searches++; "42" })
+        assertEquals(2, searches)
+    }
+
+    @Test fun aStoreResultIsTakenOnlyWhenItsNameMatches() {
+        // The first result is no longer taken for being first.
+        assertNull(AddedGameArt.pickStoreResult("My Obscure Game", listOf("10" to "Totally Different", "11" to "Another One")))
+        assertEquals("20", AddedGameArt.pickStoreResult("Hades", listOf("19" to "Hades II Soundtrack Bundle Extra", "20" to "Hades")))
+        assertEquals("30", AddedGameArt.pickStoreResult("Skyrim Special Edition Complete Edition", listOf("1" to "Unrelated", "30" to "Skyrim Special Edition")))
+        assertEquals("40", AddedGameArt.pickStoreResult("Portal 2", listOf("40" to "Portal 2 - Perpetual Testing")))
+        assertNull(AddedGameArt.pickStoreResult("", listOf("1" to "Anything")))
+    }
+
+    @Test fun aSteamGridDbSearchResultIsTakenOnlyWhenItsNameMatches() {
+        assertNull(SteamGridDb.match("My Obscure Game", listOf(5 to "Something Else")))
+        assertEquals(6, SteamGridDb.match("The Witcher 3 - Wild Hunt", listOf(5 to "Witcher", 6 to "The Witcher 3: Wild Hunt")))
+    }
+
+    @Test fun theBestScoredImageWinsAndAPngSlotTakesOnlyPng() {
+        val items = JSONArray()
+            .put(JSONObject().put("url", "https://cdn2.steamgriddb.com/a.png").put("mime", "image/png").put("score", 2))
+            .put(JSONObject().put("url", "https://cdn2.steamgriddb.com/b.jpg").put("mime", "image/jpeg").put("score", 9))
+        assertEquals("https://cdn2.steamgriddb.com/b.jpg", SteamGridDb.best(items, pngOnly = false))
+        assertEquals("https://cdn2.steamgriddb.com/a.png", SteamGridDb.best(items, pngOnly = true))
+        assertNull(SteamGridDb.best(JSONArray(), pngOnly = false))
+    }
+
+    @Test fun theUsersKeyWinsOverTheBuildsAndNoneMeansNone() {
+        assertEquals("user", SteamGridDb.pick("user", "build"))
+        assertEquals("build", SteamGridDb.pick("", "build"))
+        assertEquals("build", SteamGridDb.pick("  ", "build"))
+        assertEquals("", SteamGridDb.pick("", ""))
+        // This test build carries no key.
+        assertEquals("", SteamGridDb.builtInKey())
+        assertEquals("", SteamGridDb.key(app))
+    }
+
+    @Test fun theUsersKeyIsSealedOnDiskAndClears() {
+        val key = SecretKeySpec(ByteArray(32).also { SecureRandom().nextBytes(it) }, "AES")
+        SteamGridDb.keys = CredentialCipher.KeyProvider { key }
+        SteamGridDb.setUserKey(app, "abcdef0123456789secretkey")
+        val file = File(app.filesDir, "sgdb/key.json")
+        assertFalse(file.readText().contains("secretkey"))
+        assertTrue(CredentialCipher.isEnvelope(JSONObject(file.readText())))
+        assertEquals("abcdef0123456789secretkey", SteamGridDb.key(app))
+        SteamGridDb.setUserKey(app, "")
+        assertFalse(file.exists())
+        assertEquals("", SteamGridDb.key(app))
+    }
+}
diff --git a/app/src/test/java/com/droiddeck/launcher/frontend/AddedGameEditsTest.kt b/app/src/test/java/com/droiddeck/launcher/frontend/AddedGameEditsTest.kt
new file mode 100644
index 000000000..f83a082d1
--- /dev/null
+++ b/app/src/test/java/com/droiddeck/launcher/frontend/AddedGameEditsTest.kt
@@ -0,0 +1,148 @@
+package com.droiddeck.launcher.frontend
+
+import android.os.Environment
+import com.droiddeck.launcher.session.SessionPrefs
+import org.json.JSONArray
+import org.json.JSONObject
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertFalse
+import org.junit.Assert.assertNull
+import org.junit.Assert.assertTrue
+import org.junit.Before
+import org.junit.Rule
+import org.junit.Test
+import org.junit.rules.TemporaryFolder
+import org.junit.runner.RunWith
+import org.robolectric.RobolectricTestRunner
+import org.robolectric.RuntimeEnvironment
+import org.robolectric.annotation.Config
+import java.io.File
+
+/** "Add all games in this folder", the editor's writes to the shortcut listing, art choices. */
+@RunWith(RobolectricTestRunner::class)
+@Config(sdk = [33])
+class AddedGameEditsTest {
+    private val app get() = RuntimeEnvironment.getApplication()
+    @get:Rule val tmp = TemporaryFolder()
+
+    private fun exe(rel: String, size: Int = 16): File =
+        File(Environment.getExternalStorageDirectory(), rel).apply { parentFile!!.mkdirs(); writeBytes(ByteArray(size)) }
+
+    private fun listing(): List<JSONObject> = JSONArray(File(app.filesDir, "session/added-games.json").readText()).let { a -> (0 until a.length()).map { a.getJSONObject(it) } }
+
+    @Before fun noGamesFolders() {
+        AddedGamesPublisher.now = true
+        SessionPrefs.setGameStorage(app, SessionPrefs.GAME_STORAGE_OFF, "")
+        SessionPrefs.setAddedGamesDirs(app, emptyList())
+    }
+
+    @Test fun addingAFolderAddsEachGameWithItsBestExeAndSkipsThoseListed() {
+        exe("Games/Alpha/Alpha.exe")
+        exe("Games/Alpha/UnityCrashHandler64.exe")
+        exe("Games/Beta/x86/Run.exe")
+        exe("Games/Beta/x64/Thing.exe")
+        File(Environment.getExternalStorageDirectory(), "Games/Manual").mkdirs()
+        val listed = exe("Games/Celeste/Celeste.exe")
+        assertTrue(AddedGames.addExe(app, listed) is AddedGames.AddResult.Added)
+
+        val dir = File(Environment.getExternalStorageDirectory(), "Games")
+        val result = AddedGames.addFolder(app, dir)
+        assertEquals(listOf("Alpha", "Beta"), result.added.map { it.name })
+        assertEquals(1, result.already)
+        val alpha = result.added.first { it.name == "Alpha" }
+        assertEquals("Alpha.exe", alpha.exe.name)
+        assertFalse(alpha.exeUncertain)
+        // Two lookalikes: the best guess, marked.
+        assertTrue(result.added.first { it.name == "Beta" }.exeUncertain)
+        // Entries, not a Games folder.
+        assertEquals(emptyList<String>(), SessionPrefs.addedGamesDirs(app))
+        assertEquals(3, AddedExes.list(app).size)
+        assertTrue(listing().map { it.getString("name") }.containsAll(listOf("Alpha", "Beta", "Celeste")))
+
+        // Again: nothing new, all three there already.
+        val again = AddedGames.addFolder(app, dir)
+        assertEquals(emptyList<String>(), again.added.map { it.name })
+        assertEquals(3, again.already)
+    }
+
+    @Test fun editsReachTheShortcutListingOnTheSameAppid() {
+        val pick = exe("Games/Hades/Hades.exe")
+        val other = exe("Games/Hades/x64/Hades.exe")
+        val game = (AddedGames.addExe(app, pick) as AddedGames.AddResult.Added).game
+        val folder = game.folder.path
+
+        AddedGameEdits.setName(app, folder, "Hades: Deluxe")
+        AddedGameEdits.setLaunchOptions(app, folder, "-dx11")
+        assertTrue(AddedGameEdits.setStartIn(app, folder, File(game.folder, "x64").path))
+        assertTrue(AddedGameEdits.setExe(app, folder, other))
+
+        val entry = listing().single()
+        assertEquals("Hades: Deluxe", entry.getString("name"))
+        assertEquals("-dx11", entry.getString("launch"))
+        assertEquals("/root/Storage/Games/Hades/x64/Hades.exe", entry.getString("exe"))
+        assertEquals("/root/Storage/Games/Hades/x64", entry.getString("dir"))
+        assertEquals(game.appId, entry.getLong("appid"))
+        assertEquals(game.appId, AddedGameEdits.game(app, folder)!!.appId)
+
+        // Back to automatic.
+        AddedGameEdits.setName(app, folder, "")
+        assertTrue(AddedGameEdits.setStartIn(app, folder, ""))
+        val auto = listing().single()
+        assertEquals("Hades", auto.getString("name"))
+        assertEquals("/root/Storage/Games/Hades/x64", auto.getString("dir"))
+        assertEquals(game.appId, auto.getLong("appid"))
+    }
+
+    @Test fun aStartInTheSessionCannotSeeIsRefused() {
+        val game = (AddedGames.addExe(app, exe("Games/Tunic/Tunic.exe")) as AddedGames.AddResult.Added).game
+        assertFalse(AddedGameEdits.setStartIn(app, game.folder.path, tmp.newFolder("elsewhere").path))
+        assertEquals("", SessionPrefs.addedGameStartIn(app, game.folder.path))
+    }
+
+    @Test fun editsMadeInSteamAreTakenOnceAndAnAppEditAfterThemStays() {
+        val folder = File("/x/Game")
+        val record = JSONObject()
+            .put("app", JSONObject().put("AppName", "Game").put("StartDir", "\"/g/Game\"").put("LaunchOptions", "").put("Exe", "\"/g/Game/Game.exe\""))
+            .put("steam", JSONObject().put("AppName", "Game GOTY").put("StartDir", "\"/g/Game/data\"").put("LaunchOptions", "-safe").put("Exe", "\"/g/Game/Game.exe\""))
+        AddedGames.adoptSteamEdits(app, folder, record)
+        assertEquals("Game GOTY", SessionPrefs.addedGameName(app, folder.path))
+        assertEquals("/g/Game/data", SessionPrefs.addedGameStartIn(app, folder.path))
+        assertEquals("-safe", SessionPrefs.addedGameLaunch(app, folder.path))
+
+        // The user renames it in the app before Steam's shortcut is written again: the same Steam
+        // value is not taken a second time.
+        SessionPrefs.setAddedGameName(app, folder.path, "Mine")
+        AddedGames.adoptSteamEdits(app, folder, record)
+        assertEquals("Mine", SessionPrefs.addedGameName(app, folder.path))
+    }
+
+    @Test fun aStartInSteamMovedWithTheExeIsAutomatic() {
+        val folder = File("/x/Other")
+        val record = JSONObject()
+            .put("app", JSONObject().put("StartDir", "\"/g/Other\"").put("Exe", "\"/g/Other/Other.exe\""))
+            .put("steam", JSONObject().put("StartDir", "\"/g/Other/bin\"").put("Exe", "\"/g/Other/bin/Other.exe\""))
+        AddedGames.adoptSteamEdits(app, folder, record)
+        assertEquals("", SessionPrefs.addedGameStartIn(app, folder.path))
+    }
+
+    @Test fun anArtChoiceIsKeptAndResetGoesBackToAutomatic() {
+        val game = (AddedGames.addExe(app, exe("Games/Celeste/Celeste.exe")) as AddedGames.AddResult.Added).game
+        val image = File(game.folder, "cover-alt.png").apply { writeBytes(byteArrayOf(1, 2, 3)) }
+        val option = AddedGameArt.folderImages(game.folder).map { AddedGameArt.Option(AddedGameArt.FOLDER, it.path, it.path) }.single()
+        assertEquals(image.path, option.full)
+
+        assertTrue(AddedGameEdits.setArt(app, game.folder.path, AddedGameArt.Slot.COVER, option))
+        val cover = AddedGameArt.describe(app, game).first { it.slot == AddedGameArt.Slot.COVER }
+        assertTrue(cover.chosen)
+        assertEquals(AddedGameArt.FOLDER, cover.source)
+        assertEquals(AddedGameArt.FOLDER to image.path, AddedGameArt.chosenSource(app, game, AddedGameArt.Slot.COVER))
+        assertEquals(cover.file, AddedGameArt.resolve(app, game).portrait)
+        assertEquals(cover.file!!.absolutePath, listing().single().getJSONObject("art").getString("p"))
+
+        AddedGameEdits.resetArt(app, game.folder.path, AddedGameArt.Slot.COVER)
+        val auto = AddedGameArt.describe(app, game).first { it.slot == AddedGameArt.Slot.COVER }
+        assertFalse(auto.chosen)
+        assertNull(AddedGameArt.resolve(app, game).portrait)
+        assertEquals(AddedGameArt.AUTO, auto.source)
+    }
+}
diff --git a/app/src/test/java/com/droiddeck/launcher/frontend/AddedGamesCandidatesTest.kt b/app/src/test/java/com/droiddeck/launcher/frontend/AddedGamesCandidatesTest.kt
new file mode 100644
index 000000000..6771a4a18
--- /dev/null
+++ b/app/src/test/java/com/droiddeck/launcher/frontend/AddedGamesCandidatesTest.kt
@@ -0,0 +1,151 @@
+package com.droiddeck.launcher.frontend
+
+import com.droiddeck.launcher.session.SessionPrefs
+import java.io.File
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertFalse
+import org.junit.Assert.assertTrue
+import org.junit.Rule
+import org.junit.Test
+import org.junit.rules.TemporaryFolder
+import org.junit.runner.RunWith
+import org.robolectric.RobolectricTestRunner
+import org.robolectric.RuntimeEnvironment
+import org.robolectric.annotation.Config
+
+/** The .exe picker below a game folder (five levels, past installer folders, ranked) and the names it finds. */
+@RunWith(RobolectricTestRunner::class)
+@Config(sdk = [33])
+class AddedGamesCandidatesTest {
+    private val app get() = RuntimeEnvironment.getApplication()
+    @get:Rule val tmp = TemporaryFolder()
+
+    private fun exe(root: File, path: String, size: Int = 10): File =
+        File(root, path).apply { parentFile!!.mkdirs(); writeBytes(ByteArray(size)) }
+
+    private fun names(folder: File) = AddedGames.candidates(folder).map { it.relativeTo(folder).invariantSeparatorsPath }
+
+    @Test fun anUnrealShippingBuildThreeDownWinsOverTheTopLevelHelpers() {
+        val game = tmp.newFolder("Some Game")
+        exe(game, "CrashReportClient.exe", 5000)
+        exe(game, "Engine/Binaries/Win64/UnrealCEFSubProcess.exe", 9000)
+        val shipping = exe(game, "SomeGame/Binaries/Win64/SomeGame-Win64-Shipping.exe", 100)
+        exe(game, "SomeGame/Binaries/Win64/Tool.exe", 8000)
+        assertEquals("SomeGame/Binaries/Win64/SomeGame-Win64-Shipping.exe", names(game).first())
+        assertFalse(names(game).any { it.contains("CrashReport") })
+        assertEquals(shipping, AddedGames.candidates(game).first())
+    }
+
+    @Test fun aShippingExeNotNamedAfterTheFolderStillRanksAboveOtherDeepExes() {
+        val game = tmp.newFolder("Folder")
+        exe(game, "Proj/Binaries/Win64/Proj-Win64-Shipping.exe", 10)
+        exe(game, "Proj/Tools/Big.exe", 9000)
+        assertEquals("Proj/Binaries/Win64/Proj-Win64-Shipping.exe", names(game).first())
+    }
+
+    @Test fun fiveLevelsDownIsFoundSixIsNot() {
+        val game = tmp.newFolder("Deep")
+        exe(game, "a/b/c/d/e/Five.exe")
+        exe(game, "a/b/c/d/e/f/Six.exe")
+        assertEquals(listOf("a/b/c/d/e/Five.exe"), names(game))
+    }
+
+    @Test fun installerAndRedistFoldersAreSkipped() {
+        val game = tmp.newFolder("Skips")
+        for (dir in listOf("_CommonRedist", "CommonRedist", "Redist", "DirectX", "DotNetFx", "vcredist_x64", "Prerequisites",
+            "Support", "Engine/Extras", "Engine/Binaries/ThirdParty", "__Installer", "Installers", ".git", "\$PLUGINSDIR")) {
+            exe(game, "$dir/Thing.exe")
+        }
+        val game2 = exe(game, "Bin/Game.exe")
+        assertEquals(listOf("Bin/Game.exe"), names(game))
+        assertTrue(game2.isFile)
+    }
+
+    @Test fun theWalkStopsAtItsBudget() {
+        val game = tmp.newFolder("Huge")
+        for (i in 0 until GameExePicker.WALK_BUDGET + 50) File(game, "data/d%04d".format(i)).mkdirs()
+        exe(game, "zzz/Late.exe")
+        // data/ alone fills the budget before zzz/ is listed.
+        assertEquals(emptyList<String>(), names(game))
+        val small = tmp.newFolder("Small")
+        exe(small, "x/y/Found.exe")
+        assertEquals(listOf("x/y/Found.exe"), names(small))
+    }
+
+    @Test fun theUsersPickIsKeptOverTheDeepScan() {
+        val games = tmp.newFolder("PC")
+        val game = File(games, "Some Game")
+        val top = exe(game, "Launcher.exe", 10)
+        exe(game, "SomeGame/Binaries/Win64/SomeGame-Win64-Shipping.exe", 100)
+        SessionPrefs.setGameStorage(app, SessionPrefs.GAME_STORAGE_OFF, "")
+        SessionPrefs.setAddedGamesDirs(app, listOf(games.path))
+        SessionPrefs.setAddedGameExe(app, game.path, top.path)
+        val g = AddedGames.scan(app).single()
+        assertEquals(top.path, g.exe.path)
+    }
+
+    @Test fun aDeepExeStartsInItsOwnFolder() {
+        val games = tmp.newFolder("PC")
+        val game = File(games, "Some Game")
+        exe(game, "SomeGame/Binaries/Win64/SomeGame-Win64-Shipping.exe", 100)
+        SessionPrefs.setGameStorage(app, SessionPrefs.GAME_STORAGE_OFF, "")
+        SessionPrefs.setAddedGamesDirs(app, listOf(games.path))
+        val g = AddedGames.scan(app).single()
+        assertEquals("/root/Games/PC/Some Game/SomeGame/Binaries/Win64/SomeGame-Win64-Shipping.exe", g.guestExe)
+        assertEquals("/root/Games/PC/Some Game/SomeGame/Binaries/Win64", g.guestDir)
+    }
+
+    @Test fun twoLookalikeExesAreUncertainANamedOneIsNot() {
+        val unsure = tmp.newFolder("Folder A")
+        exe(unsure, "x86/Run.exe"); exe(unsure, "x64/Thing.exe")
+        assertTrue(GameExePicker.rank(unsure).uncertain)
+        val sure = tmp.newFolder("Example")
+        exe(sure, "Example.exe"); exe(sure, "bin/Tool.exe")
+        val r = GameExePicker.rank(sure)
+        assertFalse(r.uncertain)
+        assertEquals("Example.exe", r.exes.first().name)
+    }
+
+    @Test fun aLauncherRanksBelowTheGame() {
+        val game = tmp.newFolder("Grand Theft Auto V")
+        exe(game, "PlayGTAV.exe"); exe(game, "GTA5.exe")
+        assertEquals("GTA5.exe", names(game).first())
+    }
+
+    @Test fun anUncertainGuessIsMarkedAndAPickIsNot() {
+        val games = tmp.newFolder("PC")
+        val game = File(games, "Folder A")
+        exe(game, "x86/Run.exe"); val pick = exe(game, "x64/Thing.exe")
+        SessionPrefs.setGameStorage(app, SessionPrefs.GAME_STORAGE_OFF, "")
+        SessionPrefs.setAddedGamesDirs(app, listOf(games.path))
+        assertTrue(AddedGames.scan(app).single().exeUncertain)
+        SessionPrefs.setAddedGameExe(app, game.path, pick.path)
+        assertFalse(AddedGames.scan(app).single().exeUncertain)
+    }
+
+    @Test fun theGamesOwnTitleNamesItAndItsShortcutIdStays() {
+        val games = tmp.newFolder("PC")
+        val game = File(games, "ws-v1.2")
+        exe(game, "ws-v1.2.exe")
+        SessionPrefs.setGameStorage(app, SessionPrefs.GAME_STORAGE_OFF, "")
+        SessionPrefs.setAddedGamesDirs(app, listOf(games.path))
+        val before = AddedGames.scan(app).single()
+        assertEquals("ws-v1.2", before.name)
+
+        File(game, "goggame-1207658691.info").writeText("""{"gameId":"1207658691","name":"The Witcher 3: Wild Hunt"}""")
+        game.setLastModified(game.lastModified() + 10_000)
+        val after = AddedGames.scan(app).single()
+        assertEquals("The Witcher 3 - Wild Hunt", after.name)
+        // Already added under the folder name: the shortcut keeps its id.
+        assertEquals(before.appId, after.appId)
+    }
+
+    @Test fun onlyACleanedFileNameKeepsTheFolderName() {
+        val games = tmp.newFolder("PC")
+        val game = File(games, "My Game [Repack]")
+        exe(game, "MyGame-Win64-Shipping.exe")
+        SessionPrefs.setGameStorage(app, SessionPrefs.GAME_STORAGE_OFF, "")
+        SessionPrefs.setAddedGamesDirs(app, listOf(games.path))
+        assertEquals("My Game [Repack]", AddedGames.scan(app).single().name)
+    }
+}
diff --git a/app/src/test/java/com/droiddeck/launcher/frontend/AddedGamesRemoveTest.kt b/app/src/test/java/com/droiddeck/launcher/frontend/AddedGamesRemoveTest.kt
new file mode 100644
index 000000000..e98d08031
--- /dev/null
+++ b/app/src/test/java/com/droiddeck/launcher/frontend/AddedGamesRemoveTest.kt
@@ -0,0 +1,74 @@
+package com.droiddeck.launcher.frontend
+
+import com.droiddeck.launcher.session.SessionPrefs
+import java.io.File
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertTrue
+import org.junit.Rule
+import org.junit.Test
+import org.junit.rules.TemporaryFolder
+import org.junit.runner.RunWith
+import org.robolectric.RobolectricTestRunner
+import org.robolectric.RuntimeEnvironment
+import org.robolectric.annotation.Config
+
+/** Removing an added game stops listing it and keeps it off after a rescan, until it is added again; nothing on disk goes. */
+@RunWith(RobolectricTestRunner::class)
+@Config(sdk = [33])
+class AddedGamesRemoveTest {
+    private val app get() = RuntimeEnvironment.getApplication()
+    @get:Rule val tmp = TemporaryFolder()
+
+    @org.junit.Before fun publishAtOnce() { AddedGamesPublisher.now = true }
+
+    private fun gamesFolder(vararg names: String): File {
+        val games = tmp.newFolder("PC")
+        for (n in names) File(games, "$n/$n.exe").apply { parentFile!!.mkdirs() }.writeText("game")
+        SessionPrefs.setGameStorage(app, SessionPrefs.GAME_STORAGE_OFF, "")
+        SessionPrefs.setAddedGamesDirs(app, listOf(games.path))
+        return games
+    }
+
+    @Test fun theExclusionListAddsRemovesAndKeepsOrder() {
+        assertEquals(emptyList<String>(), SessionPrefs.removedAddedGames(app))
+        SessionPrefs.setAddedGameRemoved(app, "/a/One", true)
+        SessionPrefs.setAddedGameRemoved(app, "/a/Two", true)
+        SessionPrefs.setAddedGameRemoved(app, "/a/One", true)
+        assertEquals(listOf("/a/Two", "/a/One"), SessionPrefs.removedAddedGames(app))
+        SessionPrefs.setAddedGameRemoved(app, "/a/Two", false)
+        assertEquals(listOf("/a/One"), SessionPrefs.removedAddedGames(app))
+        SessionPrefs.setAddedGameRemoved(app, "/a/Missing", false)
+        assertEquals(listOf("/a/One"), SessionPrefs.removedAddedGames(app))
+    }
+
+    @Test fun aScanSkipsRemovedFoldersUntilRestored() {
+        val games = gamesFolder("Alpha", "Beta", "Gamma")
+        assertEquals(listOf("Alpha", "Beta", "Gamma"), AddedGames.scan(app).map { it.name })
+
+        SessionPrefs.setAddedGameRemoved(app, File(games, "Beta").path, true)
+        assertEquals(listOf("Alpha", "Gamma"), AddedGames.scan(app).map { it.name })
+        // A rescan does not bring it back.
+        assertEquals(listOf("Alpha", "Gamma"), AddedGames.scan(app).map { it.name })
+
+        SessionPrefs.setAddedGameRemoved(app, File(games, "Beta").path, false)
+        assertEquals(listOf("Alpha", "Beta", "Gamma"), AddedGames.scan(app).map { it.name })
+    }
+
+    @Test fun removeDropsItFromTheListingAndLeavesTheFolder() {
+        val games = gamesFolder("Alpha", "Beta")
+        val beta = File(games, "Beta")
+        AddedGames.remove(app, beta)
+
+        assertEquals(listOf(beta.path), SessionPrefs.removedAddedGames(app))
+        assertEquals(listOf("Alpha"), AddedGames.scan(app).map { it.name })
+        val listing = File(app.filesDir, "session/added-games.json").readText()
+        assertTrue(listing.contains("\"Alpha\""))
+        assertTrue(!listing.contains("\"Beta\""))
+        assertTrue(File(beta, "Beta.exe").isFile)
+
+        // Added again with the +: it comes back.
+        assertTrue(AddedGames.addExe(app, File(beta, "Beta.exe")) is AddedGames.AddResult.Switched)
+        assertEquals(emptyList<String>(), SessionPrefs.removedAddedGames(app))
+        assertTrue(File(app.filesDir, "session/added-games.json").readText().contains("\"Beta\""))
+    }
+}
diff --git a/app/src/test/java/com/droiddeck/launcher/frontend/AddedGamesSpellingTest.kt b/app/src/test/java/com/droiddeck/launcher/frontend/AddedGamesSpellingTest.kt
new file mode 100644
index 000000000..e31d35a74
--- /dev/null
+++ b/app/src/test/java/com/droiddeck/launcher/frontend/AddedGamesSpellingTest.kt
@@ -0,0 +1,14 @@
+package com.droiddeck.launcher.frontend
+
+import org.junit.Assert.assertEquals
+import org.junit.Test
+
+class AddedGamesSpellingTest {
+    @Test fun folderSpacingWinsOverAJoinedExeName() = assertEquals("Insane 2", AddedGames.betterSpelling("Insane2", "Insane 2"))
+    @Test fun exeSpacingWinsOverAJoinedFolderName() = assertEquals("DiRT 3", AddedGames.betterSpelling("DiRT 3", "dirt3"))
+    @Test fun mixedCaseWinsATie() = assertEquals("Hollow Knight", AddedGames.betterSpelling("HOLLOW KNIGHT", "Hollow Knight"))
+    @Test fun differentTitlesKeepTheExeName() = assertEquals("The Witcher 3", AddedGames.betterSpelling("The Witcher 3", "witcher3-goty"))
+    @Test fun sameSpellingKeepsTheExeName() = assertEquals("Celeste", AddedGames.betterSpelling("Celeste", "Celeste"))
+    @Test fun underscoresBecomeSpaces() = assertEquals("Watch Dogs", AddedGames.betterSpelling(AddedGames.underscoresToSpaces("Watch_Dogs"), "Watch Dogs"))
+    @Test fun underscoresBecomeSpacesWithoutAFolderMatch() = assertEquals("Watch Dogs 2", AddedGames.underscoresToSpaces("Watch_Dogs_2"))
+}
diff --git a/app/src/test/java/com/droiddeck/launcher/frontend/GameIdentifierTest.kt b/app/src/test/java/com/droiddeck/launcher/frontend/GameIdentifierTest.kt
new file mode 100644
index 000000000..9f6a6820b
--- /dev/null
+++ b/app/src/test/java/com/droiddeck/launcher/frontend/GameIdentifierTest.kt
@@ -0,0 +1,219 @@
+package com.droiddeck.launcher.frontend
+
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertFalse
+import org.junit.Assert.assertNull
+import org.junit.Assert.assertTrue
+import org.junit.Rule
+import org.junit.Test
+import org.junit.rules.TemporaryFolder
+import java.io.File
+
+/**
+ * Signal-chain coverage for [GameIdentifier]. Pure JVM: builds
+ * fake game layouts in a temp dir and asserts the right appId/name/source/confidence come back.
+ * The PE version-resource path is exercised on-device (real .exe), not here.
+ */
+class GameIdentifierTest {
+
+    @get:Rule
+    val tmp = TemporaryFolder()
+
+    private fun exeIn(dir: File, name: String = "game.exe"): File =
+        File(dir, name).apply { parentFile?.mkdirs(); writeBytes(byteArrayOf(0x4D, 0x5A)) } // "MZ" — not a real PE
+
+    @Test
+    fun steamAppIdTxt_besideExe_givesHighConfidenceAppId() {
+        val dir = tmp.newFolder("Palworld")
+        File(dir, "steam_appid.txt").writeText("1623730\n")
+        val id = GameIdentifier.identify(exeIn(dir))
+        assertEquals(1623730, id.appId)
+        assertEquals(GameIdentifier.Source.STEAM_APPID_TXT, id.source)
+        assertEquals(GameIdentifier.Confidence.HIGH, id.confidence)
+    }
+
+    @Test
+    fun steamAppIdTxt_inSteamSettingsSubdir_isFound() {
+        val dir = tmp.newFolder("Game")
+        File(dir, "steam_settings").mkdirs()
+        File(dir, "steam_settings/steam_appid.txt").writeText("480")
+        assertEquals(480, GameIdentifier.identify(exeIn(dir)).appId)
+    }
+
+    @Test
+    fun coldClientLoaderIni_appIdKey_isParsed() {
+        val dir = tmp.newFolder("Cracked")
+        File(dir, "ColdClientLoader.ini").writeText("[SteamClient]\nExe=game.exe\nAppId=427520\n")
+        val id = GameIdentifier.identify(exeIn(dir))
+        assertEquals(427520, id.appId)
+        assertEquals(GameIdentifier.Source.STEAM_EMU_INI, id.source)
+    }
+
+    @Test
+    fun steamManifestAcf_matchedByInstalldir_givesAppIdAndName() {
+        // steamapps/common/Palworld/Pal/Binaries/Win64/Palworld-Win64-Shipping.exe
+        val steamapps = tmp.newFolder("steamapps")
+        File(steamapps, "appmanifest_1623730.acf").writeText(
+            """
+            "AppState"
+            {
+                "appid"        "1623730"
+                "name"         "Palworld"
+                "installdir"   "Palworld"
+            }
+            """.trimIndent()
+        )
+        // a decoy manifest that must NOT win
+        File(steamapps, "appmanifest_570.acf").writeText(
+            """"AppState" { "appid" "570" "name" "Dota 2" "installdir" "dota 2 beta" }"""
+        )
+        val win64 = File(steamapps, "common/Palworld/Pal/Binaries/Win64").apply { mkdirs() }
+        val id = GameIdentifier.identify(exeIn(win64, "Palworld-Win64-Shipping.exe"))
+        assertEquals(1623730, id.appId)
+        assertEquals("Palworld", id.name)
+        assertEquals(GameIdentifier.Source.STEAM_MANIFEST_ACF, id.source)
+    }
+
+    @Test
+    fun gogInfo_givesNameAndId_highConfidence() {
+        val dir = tmp.newFolder("Witcher3")
+        File(dir, "goggame-1207658691.info").writeText(
+            """{"gameId":"1207658691","name":"The Witcher 3: Wild Hunt","version":1}"""
+        )
+        val id = GameIdentifier.identify(exeIn(dir))
+        // normalizeName() deliberately converts ":" to " - " (a colon is illegal in a Windows
+        // filename), so the identified name never carries one. The test asserted the raw GOG
+        // string and had never passed.
+        assertEquals("The Witcher 3 - Wild Hunt", id.name)
+        assertEquals("1207658691", id.gogId)
+        assertNull(id.appId)
+        assertEquals(GameIdentifier.Confidence.HIGH, id.confidence)
+    }
+
+    @Test
+    fun acfNamePreferredOverGogName_whenBothPresent() {
+        val steamapps = tmp.newFolder("steamapps")
+        File(steamapps, "appmanifest_100.acf").writeText(""""AppState"{"appid" "100" "name" "SteamName" "installdir" "MyGame"}""")
+        val gameDir = File(steamapps, "common/MyGame").apply { mkdirs() }
+        File(gameDir, "goggame-9.info").writeText("""{"name":"GogName"}""")
+        val id = GameIdentifier.identify(exeIn(gameDir))
+        assertEquals("SteamName", id.name)
+        assertEquals(100, id.appId)
+    }
+
+    @Test
+    fun noMarkers_fallsBackToCleanedFolderName_forEngineBinary() {
+        // UE shipping binary → the folder name is the real title, exe basename is noise.
+        val dir = tmp.newFolder("Hades")
+        val id = GameIdentifier.identify(exeIn(dir, "Hades-Win64-Shipping.exe"))
+        assertEquals("Hades", id.name)
+        assertEquals(GameIdentifier.Source.FILENAME, id.source)
+        assertEquals(GameIdentifier.Confidence.LOW, id.confidence)
+    }
+
+    @Test
+    fun fallbackName_stripsRepackTagsAndVersionTokens() {
+        val dir = tmp.newFolder("Stardew Valley [FitGirl Repack] v1.5.4")
+        val id = GameIdentifier.identify(exeIn(dir, "Stardew.exe"))
+        assertEquals("Stardew", id.name) // exe basename wins (not an engine binary); folder tags irrelevant here
+        // and a repack-style exe basename is cleaned too:
+        val id2 = GameIdentifier.identify(exeIn(tmp.newFolder("g2"), "Game.CODEX.exe"))
+        assertEquals(GameIdentifier.Source.FILENAME, id2.source)
+    }
+
+    @Test
+    fun fltIni_gameSettingsAppId_isParsed() {
+        // Real God of War (FLT release) layout: flt.ini holds the appid under [GameSettings].
+        val dir = tmp.newFolder("GodOfWar")
+        File(dir, "flt.ini").writeText("[GameSettings]\nAppId=1593500\nUserName=X\nBuildId=7969425\n")
+        File(dir, "settings.ini").writeText("[Settings]\nVideoDevice=Wrapper\nMonitor=0\n") // no AppId -> ignored
+        val id = GameIdentifier.identify(exeIn(dir, "GoW.exe"))
+        assertEquals(1593500, id.appId)
+        assertEquals(GameIdentifier.Confidence.HIGH, id.confidence)
+    }
+
+    @Test
+    fun genericIni_withAppId_isFoundByBroadScan() {
+        val dir = tmp.newFolder("g")
+        File(dir, "whatever_crack.ini").writeText("[cfg]\nappid = 220\n")
+        assertEquals(220, GameIdentifier.identify(exeIn(dir)).appId)
+    }
+
+    @Test
+    fun bestName_prefersFileDescriptionWhenProductNameIsAbbreviation() {
+        // God of War ships ProductName "GoW" but FileDescription "God of War".
+        assertEquals(
+            "God of War",
+            PeVersionInfo.bestName(mapOf("ProductName" to "GoW", "FileDescription" to "God of War")),
+        )
+        // Normal case: ProductName is the full title -> keep it.
+        assertEquals(
+            "Cyberpunk 2077",
+            PeVersionInfo.bestName(mapOf("ProductName" to "Cyberpunk 2077", "FileDescription" to "Cyberpunk 2077")),
+        )
+        assertNull(PeVersionInfo.bestName(null))
+    }
+
+    @Test
+    fun name_isNormalizedToBeFilesystemSafeAndTidy() {
+        // Colon → " - " (would otherwise be sanitized to '_' by the shortcut writer).
+        val d1 = tmp.newFolder("ds")
+        File(d1, "goggame-1.info").writeText("""{"name":"Dark Souls: Remastered"}""")
+        assertEquals("Dark Souls - Remastered", GameIdentifier.identify(exeIn(d1)).name)
+        // Trademark marks (symbol and text forms) stripped.
+        val d2 = tmp.newFolder("gow2")
+        File(d2, "goggame-2.info").writeText("""{"name":"God of War™"}""")
+        assertEquals("God of War", GameIdentifier.identify(exeIn(d2)).name)
+        val d3 = tmp.newFolder("ds3")
+        File(d3, "goggame-3.info").writeText("""{"name":"DARK SOULS(TM): REMASTERED"}""")
+        assertEquals("DARK SOULS - REMASTERED", GameIdentifier.identify(exeIn(d3)).name)
+        // Trailing PE descriptors dropped (DiRT 3's FileDescription is "DiRT 3 Executable").
+        val d4 = tmp.newFolder("dirt")
+        File(d4, "goggame-4.info").writeText("""{"name":"DiRT 3 Executable"}""")
+        assertEquals("DiRT 3", GameIdentifier.identify(exeIn(d4)).name)
+    }
+
+    @Test
+    fun launcherExe_prefersFolderName_overLauncher() {
+        // GTA V Enhanced: user picks the Rockstar launcher PlayGTAV.exe (no Steam id, PE = junk on
+        // a real exe). Fallback must use the folder title, not "PlayGTAV".
+        val dir = tmp.newFolder("Grand Theft Auto V Enhanced")
+        val id = GameIdentifier.identify(exeIn(dir, "PlayGTAV.exe"))
+        assertEquals("Grand Theft Auto V Enhanced", id.name)
+        assertEquals(GameIdentifier.Source.FILENAME, id.source)
+    }
+
+    @Test
+    fun launcherExe_withSeparator_prefersFolder_andStripsSiteTag() {
+        val dir = tmp.newFolder("Grand-Theft-Auto-IV-AnkerGames")
+        val id = GameIdentifier.identify(exeIn(dir, "Play - GTA IV.exe"))
+        assertEquals("Grand Theft Auto IV", id.name) // "AnkerGames" site tag stripped
+    }
+
+    @Test
+    fun nonLauncherExe_startingWithPlay_keepsItsOwnName() {
+        // "PlayerUnknown" must NOT be treated as a launcher (would wrongly use the folder name).
+        val dir = tmp.newFolder("SomeInstallFolder")
+        val id = GameIdentifier.identify(exeIn(dir, "PlayerUnknown.exe"))
+        assertEquals("PlayerUnknown", id.name)
+    }
+
+    @Test
+    fun isJunkPeName_flagsLaunchersNotGames() {
+        for (junk in listOf("Rockstar Games Launcher Redirector", "GSE", "Steam", "Launcher", "Epic Games Launcher")) {
+            assertTrue("expected junk: $junk", GameIdentifier.isJunkPeName(junk))
+        }
+        for (real in listOf("God of War", "Grand Theft Auto V", "DARK SOULS: REMASTERED", "Hades")) {
+            assertFalse("expected real: $real", GameIdentifier.isJunkPeName(real))
+        }
+    }
+
+    @Test
+    fun emptyWhenNothingIdentifiable() {
+        val dir = tmp.newFolder("x")
+        val id = GameIdentifier.identify(exeIn(dir, "Game.exe")) // engine-ish base → folder "x"
+        // "x" is a valid (if useless) fallback name; the point is it must not crash and appId is null.
+        assertNull(id.appId)
+        assertTrue(id.confidence == GameIdentifier.Confidence.LOW)
+    }
+}
diff --git a/app/src/test/java/com/droiddeck/launcher/ui/PickListingTest.kt b/app/src/test/java/com/droiddeck/launcher/ui/PickListingTest.kt
new file mode 100644
index 000000000..af7b6f50d
--- /dev/null
+++ b/app/src/test/java/com/droiddeck/launcher/ui/PickListingTest.kt
@@ -0,0 +1,52 @@
+package com.droiddeck.launcher.ui
+
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertFalse
+import org.junit.Assert.assertTrue
+import org.junit.Assume.assumeFalse
+import org.junit.Rule
+import org.junit.Test
+import org.junit.rules.TemporaryFolder
+import org.junit.runner.RunWith
+import org.robolectric.RobolectricTestRunner
+import org.robolectric.annotation.Config
+import java.io.File
+
+/** What the in-app picker lists in a folder: every folder A-Z, then only the files asked for. */
+@RunWith(RobolectricTestRunner::class)
+@Config(sdk = [33])
+class PickListingTest {
+    @get:Rule val tmp = TemporaryFolder()
+
+    private fun storage(): File {
+        val root = tmp.newFolder("emulated0")
+        for (d in listOf("Download", "Android", "DCIM", "Games", "Documents", "Winlator", ".thumbnails", "alarms")) File(root, d).mkdirs()
+        for (f in listOf("Setup.exe", "game.EXE", "cover.jpg", "notes.txt", "logo.PNG", "icon.ico", "hero.webp", ".hidden.exe")) File(root, f).writeText("x")
+        return root
+    }
+
+    @Test fun everyFolderIsListedAToZAndDotFoldersAreNot() {
+        val listing = pickListing(storage(), PickKind.EXE)
+        assertEquals(listOf("alarms", "Android", "DCIM", "Documents", "Download", "Games", "Winlator"), listing.folders.map { it.dir.name })
+    }
+
+    @Test fun onlyExesForAGameOnlyImagesForArt() {
+        val root = storage()
+        assertEquals(listOf("game.EXE", "Setup.exe"), pickListing(root, PickKind.EXE).files.map { it.name })
+        assertEquals(listOf("cover.jpg", "hero.webp", "icon.ico", "logo.PNG"), pickListing(root, PickKind.IMAGE).files.map { it.name })
+    }
+
+    @Test fun aFolderTheAppCannotReadIsListedButMarked() {
+        val root = storage()
+        val locked = File(root, "Android")
+        locked.setReadable(false, false)
+        try {
+            assumeFalse("running as root reads everything", locked.list() != null)
+            val folders = pickListing(root, PickKind.EXE).folders.associate { it.dir.name to it.readable }
+            assertFalse(folders.getValue("Android"))
+            assertTrue(folders.getValue("Download"))
+        } finally {
+            locked.setReadable(true, false)
+        }
+    }
+}
diff --git a/docs/development/added-games.md b/docs/development/added-games.md
new file mode 100644
index 000000000..9f335adbb
--- /dev/null
+++ b/docs/development/added-games.md
@@ -0,0 +1,77 @@
+# Added games
+
+Windows games the user adds to DroidDeck's Games tab, each a non-Steam shortcut in the
+Steam client that runs under `droiddeck-proton-arm64`. They show with the Custom chip.
+
+## Adding
+
+- **+ beside "Games N"** opens the in-app picker (`ExePickerDialog`, never Android's
+  system picker): the storage rows (Internal storage, each card, free space), then the
+  chosen storage from its root: every folder A-Z (dot-folders hidden, unreadable ones
+  greyed), `.exe` files only. The dialog keeps the width it opened with; long names are cut
+  short; it grows to 70% of the screen and scrolls. Red X closes; B / Back goes up a
+  folder, then closes.
+- **Picking an exe** (`AddedGames.addExe`): the game it already is gets selected; an exe in
+  a listed game's folder becomes that game's target; otherwise the exe's folder becomes a
+  game (`files/added-exes.json`), registered at once (the listing the shortcuts writer
+  reads, and a running client over DevTools) and selected. A path the session cannot see
+  (internal storage maps to `/root/Storage`; cards only through Games folders, the Steam
+  library and store roots) is refused with one line.
+- **"Add all games in this folder"** (top row of a folder with subfolders,
+  `AddedGames.addFolder`): each subfolder with an exe becomes a game with
+  `GameExePicker`'s best exe, kept as an entry of its own (not a Games folder); subfolders
+  already listed are counted, not added. A summary follows: games added, how many were
+  there already, one row per game (cover, name, exe, "?" when unsure); a row opens that
+  game's editor, straight on Target when unsure, with back to the summary.
+- Games folders added before this (Steam settings had a Games section) keep listing their
+  games; there is no place to add a new one.
+
+## Exe and name
+
+`GameExePicker` walks up to five folders down (nearest first, 400 entries, no symlinks,
+past installer / redistributable / extras folders), drops junk exe names and scores the
+rest (named after the folder, Unreal `-Shipping` and `Binaries/Win64`, `bin/`, launchers
+and junk lower, deeper lower, bigger higher). Best under 60, or a runner-up within 15:
+uncertain, shown as "?". `GameIdentifier` / `PeVersionInfo` give the title (Steam
+manifest by installdir, GOG info, the exe's version resource), else the folder name. The
+shortcut appid is stored per folder at the first scan and never changes after.
+
+## Editor
+
+The ✎ on a Custom game's page (`AddedGameEditor`) mirrors Steam's Properties for a
+non-Steam game: Name, Target (ranked exes, "?", Other exe… opening the picker in the
+game's folder), Start in (automatic = the exe's folder), Launch options, Artwork (Cover,
+Background, Logo, Icon, each with its thumbnail and source), and Remove (two presses; the
+files stay; adding it again brings it back). `AddedGameEdits` writes each change through
+the same shortcut: the listing (`name`, `exe`, `dir`, `launch`, `art`, the stored `appid`)
+and, with a client running, `SetShortcutName` / `Exe` / `StartDir` / `LaunchOptions` and
+`SetCustomArtworkForApp` / `SetShortcutIcon` on that appid. A new target updates the
+existing shortcut; there is never a second one.
+
+The shortcuts writer (`droiddeck-steam-shortcuts`) keeps what the user set in Steam: a
+field follows the app only while Steam still has what the app last asked for. It records
+Steam's AppName, Exe, StartDir and LaunchOptions in `.droiddeck-shortcuts.json`; a scan
+takes a Steam-side edit over as the app's own once (`AddedGames.adoptSteamEdits`), so one
+value holds on both sides.
+
+## Art
+
+Automatic: the game folder's own images, then Steam (the appid the files name, else a
+store search whose result has the same name), then SteamGridDB, then the exe's icon. The
+art chooser (an Artwork row) shows the game folder's images, Steam's official piece and
+SteamGridDB's best few (fetched when it opens); a tap applies one, "Pick image…" takes a
+file through the same picker (png, jpg, jpeg, webp, ico), "Reset to automatic" drops the
+choice. A choice is a copy in `files/added-art/<appid>/chosen-<slot>.<ext>`, its source in
+the preferences.
+
+Setup › Launcher › Games holds the Artwork switch (automatic fetching) and the
+SteamGridDB API key: the user's own, sealed with `CredentialCipher`, wins over the build's
+(`BuildConfig.SGDB_API_KEY` from the `SGDB_API_KEY` secret); with neither, SteamGridDB is
+skipped.
+
+## Tests
+
+`AddedExesTest`, `AddedGameEditsTest` (bulk add and skip, edits to the listing on a stable
+appid, Steam-side read-back, art choice and reset), `AddedGamesCandidatesTest`,
+`AddedGameArtLookupTest` (key precedence), `GameIdentifierTest`, `PickListingTest`, and
+`tools/tests/test_steam_shortcuts.py` for the writer.
diff --git a/docs/progress-log.md b/docs/progress-log.md
index 7d15e1d2c..7d97b14ad 100644
--- a/docs/progress-log.md
+++ b/docs/progress-log.md
@@ -7,6 +7,32 @@ the timeline, then lessons and backlog. Companion to the README (what the app *d
 
 ---
 
+## 2026-10-09 - `feat/games-add-edit`: add games from the Games tab, edit them like Steam's Properties
+
+- **Steam ⚙ settings:** the Games section is gone (it was a feature, not a setting). Games
+  folders added before keep listing their games.
+- **+ beside "Games N":** a compact in-app picker (storage step, then the storage root; every
+  folder A-Z, unreadable ones greyed; `.exe` only; width fixed at opening; red X; B goes up).
+  Picking an exe adds the game (name from `GameIdentifier`, art, Custom chip, Steam shortcut via
+  the listing and the running client, Start in = exe folder) and selects it; an exe in a listed
+  game switches its target; the same exe again selects it; a path the session cannot see is
+  refused. Internal storage anywhere now maps to `/root/Storage`.
+- **"Add all games in this folder":** each subfolder with its best exe (`GameExePicker`, depth
+  5, "?" when unsure), listed ones skipped, then a summary (added, already there, rows that open
+  the editor with back to the summary).
+- **✎ editor** on a Custom game: Name, Target (ranked, "?", Other exe…), Start in, Launch
+  options, Artwork (Cover, Background, Logo, Icon with thumbnails and sources; chooser with the
+  game folder, Steam and SteamGridDB; Pick image…; Reset to automatic), Remove (two presses, files
+  kept). Every edit goes through the same shortcut on its stored appid (listing + live DevTools);
+  the writer keeps Steam-side edits and records them, and the app takes them over once.
+- **Setup:** Artwork switch and SteamGridDB API key (user key sealed with the Keystore, wins over
+  `BuildConfig.SGDB_API_KEY` from the `SGDB_API_KEY` secret).
+- Brought over from `feat/added-games-remove` (not merged): `GameExePicker`, `GameIdentifier` +
+  `PeVersionInfo`, the art and SteamGridDB work, the build secret, the + and the picker.
+- Docs: `docs/development/added-games.md`. Tests: `AddedExesTest`, `AddedGameEditsTest`,
+  `AddedGamesCandidatesTest`, `AddedGameArtLookupTest`, `GameIdentifierTest`, `PickListingTest`,
+  `AddedGamesRemoveTest`, `test_steam_shortcuts.py`. Not yet on a device.
+
 ## 2026-10-09 - `feat/store-credentials-keystore`: store sign-ins sealed with the Android Keystore
 
 - **What:** `filesDir/stores/<store>/credentials.json` (GOG, Epic, Amazon: tokens, ids, names,
diff --git a/tools/linuxfs/overlay/usr/local/bin/droiddeck-steam-shortcuts b/tools/linuxfs/overlay/usr/local/bin/droiddeck-steam-shortcuts
index 5b3d8dda9..3fa78c900 100755
--- a/tools/linuxfs/overlay/usr/local/bin/droiddeck-steam-shortcuts
+++ b/tools/linuxfs/overlay/usr/local/bin/droiddeck-steam-shortcuts
@@ -97,7 +97,7 @@ def write(obj):
     return bytes(out)
 
 
-def shortcut(game, launch_options=""):
+def shortcut(game, launch_options=None):
     appid = int(game["appid"]) & 0xFFFFFFFF
     return {
         "appid": struct.unpack("<i", struct.pack("<I", appid))[0],
@@ -106,7 +106,7 @@ def shortcut(game, launch_options=""):
         "StartDir": '"%s"' % game["dir"],
         "icon": (game.get("art") or {}).get("icon", "") or "",
         "ShortcutPath": "",
-        "LaunchOptions": launch_options,
+        "LaunchOptions": launch_options if launch_options is not None else (game.get("launch") or ""),
         "IsHidden": 0,
         "AllowDesktopConfig": 1,
         "AllowOverlay": 1,
@@ -122,7 +122,10 @@ def shortcut(game, launch_options=""):
 
 RECORD = ".droiddeck-shortcuts.json"
 AWAY_LIMIT = 256
-FIELDS = ("AppName", "Exe", "StartDir", "icon")
+FIELDS = ("AppName", "Exe", "StartDir", "icon", "LaunchOptions")
+# What the app may change after the shortcut exists. Each follows the app only while Steam still
+# has what the app last asked for; a value the user set in Steam's Properties stays.
+FOLLOWED = ("StartDir", "LaunchOptions")
 
 
 def unquoted(value):
@@ -161,6 +164,14 @@ def merge(fresh, current, state, seen):
     for field in ("AppName", "icon"):
         if current.get(field) == base.get(field):
             entry[field] = fresh[field]
+    # Start in and launch options the app sets: only once there is a record of what it asked for
+    # before (a first run keeps whatever the shortcut already had), and an older record that did
+    # not keep launch options means the app asked for none.
+    if isinstance(state.get("app"), dict):
+        for field in FOLLOWED:
+            was = base.get(field, "" if field == "LaunchOptions" else current.get(field))
+            if fresh[field] != was and current.get(field) == was:
+                entry[field] = fresh[field]
     tags = dict(current["tags"]) if isinstance(current.get("tags"), dict) else {}
     if TAG not in tags.values():
         slot = 0
@@ -215,7 +226,7 @@ def reconcile(existing, wanted, seen, record):
         entry = ours[index]
         state[str(appid & 0xFFFFFFFF)] = {
             "app": {field: wanted[appid][field] for field in FIELDS},
-            "steam": {"Exe": entry.get("Exe", ""), "StartDir": entry.get("StartDir", "")},
+            "steam": {field: entry.get(field, "") for field in ("AppName", "Exe", "StartDir", "LaunchOptions")},
             "rev": rev,
         }
     return kept, ours, {"games": state, "away": away}
diff --git a/tools/tests/test_steam_shortcuts.py b/tools/tests/test_steam_shortcuts.py
index c9e658cf2..1213888f1 100644
--- a/tools/tests/test_steam_shortcuts.py
+++ b/tools/tests/test_steam_shortcuts.py
@@ -165,5 +165,41 @@ class ShortcutsTest(unittest.TestCase):
         self.assertIn(str(0x80000000 + shortcuts.AWAY_LIMIT + 3), away)
 
 
+    def test_name_start_in_and_launch_options_set_in_the_app_reach_the_shortcut(self):
+        self.run_writer(self.game())
+        game = dict(self.game(name='Example: Renamed'), dir=GUEST + '/data', launch='-dx11')
+        entry = self.run_writer(game)[APPID]
+        self.assertEqual('Example: Renamed', entry['AppName'])
+        self.assertEqual('"%s/data"' % GUEST, entry['StartDir'])
+        self.assertEqual('-dx11', entry['LaunchOptions'])
+        # One shortcut, the same appid.
+        self.assertEqual([APPID], list(self.run_writer(game)))
+
+    def test_a_target_chosen_in_the_app_updates_the_same_shortcut(self):
+        self.run_writer(self.game())
+        entries = self.run_writer(self.game('bin/Example64.exe'))
+        self.assertEqual([APPID], list(entries))
+        self.assertEqual('"%s/bin/Example64.exe"' % GUEST, entries[APPID]['Exe'])
+        self.assertEqual('"%s/bin"' % GUEST, entries[APPID]['StartDir'])
+
+    def test_launch_options_set_in_steam_stay_over_the_apps_old_value(self):
+        self.run_writer(dict(self.game(), launch='-dx11'))
+        self.steam_edits(LaunchOptions='-vulkan', AppName='Mine')
+        entry = self.run_writer(dict(self.game(), launch='-dx11'))[APPID]
+        self.assertEqual('-vulkan', entry['LaunchOptions'])
+        self.assertEqual('Mine', entry['AppName'])
+        steam = self.record()['games'][str(APPID)]['steam']
+        self.assertEqual('-vulkan', steam['LaunchOptions'])
+        self.assertEqual('Mine', steam['AppName'])
+
+    def test_an_older_record_without_launch_options_still_takes_the_apps(self):
+        self.run_writer(self.game())
+        record = self.record()
+        del record['games'][str(APPID)]['app']['LaunchOptions']
+        (self.config / shortcuts.RECORD).write_text(json.dumps(record))
+        entry = self.run_writer(dict(self.game(), launch='-safe'))[APPID]
+        self.assertEqual('-safe', entry['LaunchOptions'])
+
+
 if __name__ == '__main__':
     unittest.main()