Built-in libretro saves & states: flat layout, honor explicit restores, surface silent failures (#266)

* saves: flush built-in SRAM to disk before caching on quit

The in-game quit handler cached the session save (cacheCurrentSessionForQuit reads the .srm off disk) before saveSram() flushed the live SRAM, so the cache captured the pre-session copy and a later resume could restore that stale save over the fresh one. Flush SRAM first, then cache.

* states: flatten built-in save-state layout; channels are cache-only

Built-in libretro wrote live save-states into per-channel subdirs ({statesDir}/{channel}/rom.state.X) while every cache/restore path that writes the live disk wrote flat and, for built-in, used StatePathRegistry's unexpanded '{filesDir}/libretro/states' base -- reconciled by a flat->default/ migration. SRAM and external emulators are already flat. Unify on flat, channels only in the cache:

- LibretroStateSlots: single source of truth for slot<->filename.
- LibretroStatePathResolver: flat live-state base dir with the real filesDir and the same override precedence GameLauncher uses (fixes the unexpanded {filesDir} bug for built-in).
- SaveStateManager: flat live paths; migration inverted to lift legacy channel states up to flat.
- StateCacheManager / RestoreCachedStatesUseCase / RestoreStateUseCase route through the resolver; deleteAutoStateFromDisk -> deleteAutoResumeStatesFromDisk now clears both auto and resume so an explicitly-restored save loads instead of being overridden by a stale auto-resume state.

Also: RESUME_HARDCORE falls back to the active SRAM save instead of starting fresh when no hardcore-tagged save exists (RetroAchievements allows SRAM in hardcore). No DB schema change (disk-layout migration only).

* states: resolve GameLauncher's built-in state dir via LibretroStatePathResolver

GameLauncher computed the live state dir inline (platformOverride?.statePath ?: customStatePath), mirroring the resolver instead of using it. Route it through LibretroStatePathResolver.liveStateBaseDir so the launch path and the cache/restore path share one source of truth. LibretroActivity still layers variant isolation on top of this base. No behavior change (the resolver replicates the prior precedence, with an added blank-path guard).

* settings: mark save-state toggles as casual-only in built-in settings

Save states are disabled in hardcore (checkStateSupport bails on hardcoreMode), so 'Save State on Exit', 'Restore State on Launch', and 'Hardware-Core Save States' have no effect in a hardcore session. Add an 'Applies to casual games only' subtitle to each so that's clear in the UI.

* gamedetail: offer Continue-in-Hardcore when only a casual save exists

RESUME_HARDCORE now falls back to loading the active SRAM, so a game with only casual saves can be continued in hardcore. But the Play Options modal only showed the hardcore continue row when a hardcore-tagged save existed, so hardcore could never resume such a game (only New Game offered hardcore). Show the row whenever hardcore is available (RA logged in) and there is any resumable save; the condition is centralized on PlayOptionsState.showResumeHardcore so the delegate index math and the modal rendering stay in sync.

* settings: add global "Default to Hardcore" launch preference

New built-in setting (default off), 'When launching a game, default to hardcore instead of casual'. When on and hardcore is available, the Play Options modal pre-focuses the Continue-in-Hardcore row so A launches hardcore without reaching for the secondary action. Wired through BuiltinEmulatorSettings + the prefs repo + the LibretroSettingDef built-in settings UI (accessor/section/routers), read in PlayOptionsDelegate.showPlayOptions to choose the default focus.

* saves: refresh save panel in place after restore instead of closing

Restoring a save (activateSlot / restoreSave) set isVisible=false, so the panel closed and never showed the restore taking effect -- and a server restore left activeSaveCacheId null with nothing marked active, so the panel kept showing the local save as current. Keep the panel open and call refreshEntries() on success; the active marker falls back to the recorded timestamp, so server (cloud) restores now show as the active point too.

* emulator: surface core-fallback + SRAM-load failures, register vba_next

Three related fixes so save/core problems stop being silent:
- resolveBuiltinCoreId warned to log and silently substituted mGBA when the configured core wasn't a valid built-in core. Now it shows a 'Failed to load X, using Y instead' notification.
- The built-in registry only listed mgba/vbam for GBA, so a vba_next selection was rejected and fell back to mGBA (making an incompatible 64KB save). Register vba_next so it downloads from the buildbot and matches vba_next cloud saves exactly.
- unserializeSRAM returns false on a size mismatch (e.g. a 128KB save into a 64KB core) but the result was ignored, so the game booted a fresh save silently. GLRetroView now records it and LibretroActivity shows 'Failed to load save, using new save instead' in-game.

* saves: honor an explicit save restore over the default resume pick

A save-management restore writes the chosen save to the live .srm and sets activeSaveApplied, but restoreSaveForLaunchMode ignored that and re-derived the SRAM from the cache -- RESUME_HARDCORE via getLatestHardcoreSave, RESUME via getByTimestamp. So a Continue / Continue-Hardcore launch right after a restore silently loaded a different save (e.g. the latest hardcore autosave) and clobbered the user's choice, with no error since the SRAM itself loaded fine. When activeSaveApplied is set (cleared on session end) load the on-disk .srm as-is for RESUME/RESUME_HARDCORE. Consistent with ConflictAutoResolver already treating activeSaveApplied as keep-local.

* cleanup: dedup play-options ordering, reuse resolver inputs + core name helper

Post-review simplifications (no behavior change):
- PlayOptionsDelegate: derive row count, confirm mapping and default focus from one visibleActions() list instead of three parallel index computations; drop the redundant defaultFocusIndex helper.
- PlayOptionsModal: the hardcore-continue row's (hasSaves || hasHardcoreSave) is always true inside the CONTINUE section -> gate on showHardcoreOptions only.
- LibretroStatePathResolver: add a (platformStatePath, customStatePath) overload so GameLauncher reuses the game/platform/prefs it already loaded instead of 2 extra Room reads + a DataStore collect per launch.
- SaveStateManager.restoreSaveForLaunchMode: read the game row once and thread it into restoreResumeSave instead of fetching it twice on RESUME.
- LibretroCoreRegistry.displayNameFor(): shared coreId->name fallback, reused by GameLauncher and CoreCrashController.

* saves: recognize server-only cloud saves in Start Game + delete

For a freshly synced RomM game the save lives only on the server (no local cache), and two paths only looked at the local cache: Start Game (showPlayOptions + shouldShowModeSelection) showed New Game with no Continue -- and New Game overwrites the cloud save on launch -- while deleting a save slot removed only the local cache, reporting success as the server copy re-synced back. Start Game now derives its options from GetUnifiedSavesUseCase (cache + server, offline-safe via checkSavesForGame returning empty), and confirmDeleteChannel now deletes the server copies too, matching confirmDeleteLegacyChannel.

* saves: apply autosave autocleanup when the channel is the string "autosave"

autocleanup (server-side pruning to the newest 10) was gated on channelName == null, but the autosave channel is also represented as the literal string "autosave" -- a restore sets it via targetChannel = entry.channelName ?: AUTOSAVE_SLOT_NAME. In that string form autocleanup was skipped, so the autosave slot's server-side history grew unbounded after a restore. Recognize both forms (matching SaveSyncApiClient's own autosave normalization).

* gamedetail: apply Default to Hardcore on the direct-launch + fresh paths

Default to Hardcore only set the play-options modal's focus, so the direct launch (playGame -> gameLaunchDelegate.launchGame with forResume=true) and the fresh-game mode picker ignored it and started/resumed casual -- which is what a game with a save actually hits. playGame now passes overrideLaunchMode=RESUME_HARDCORE for a built-in game when the setting is on and RetroAchievements is signed in; showFreshGameModeSelection pre-focuses New Hardcore. New shouldDefaultToHardcoreResume() centralizes the decision (setting + RA login). Verified on-device that the pref itself was persisted true, so this was purely the launch path not consulting it.

* launch: centralize Default to Hardcore in the shared launch path

The default-to-hardcore decision only lived in GameDetailViewModel.playGame, so launching from the home screen, library, dual-screen, or secondary home (which all call GameLaunchDelegate.launchGame directly) still resumed casual. Move it into GameLaunchDelegate's launch-mode when() alongside isActiveSaveHardcore: a built-in game defaults to RESUME_HARDCORE when the setting is on and RetroAchievements is signed in. Every launch entry point now honors it. Revert the per-call-site check in playGame and drop the now-unused PlayOptionsDelegate.shouldDefaultToHardcoreResume; explicit modal choices (overrideLaunchMode) still take precedence.

* cleanup: dedup channel-delete, autosave-channel check, and modal-open

Post-review /simplify pass on the server-save + default-to-hardcore changes: extract SaveChannelSavesDelegate.deleteChannelEverywhere (was copy-pasted between confirmDeleteChannel and confirmDeleteLegacyChannel); add SaveSyncApiClient.isAutosaveChannel() for the null-or-"autosave" check, used by SaveUploader's autocleanup gate and computeUploadFileName; extract PlayOptionsDelegate.openModal(state, preferred) shared by showPlayOptions and showFreshGameModeSelection; and gate shouldShowModeSelection on the cheap raRepository.isLoggedIn() before the networked getUnifiedSaves.

* review: address maintainer feedback on the save/state PR

- cores: restrict vba_next to platforms = setOf("gba"). VBA Next only loads .gba, so listing gb/gbc made it a dead-end selectable core and let a stale vba_next selection on a GB/GBC game pass resolveBuiltinCoreId validation, suppressing the fallback toast.
- launch: gate Default to Hardcore on game.achievementCount > 0. hardcoreMode disables save states, rewind, and cheats regardless of whether an RA session resolves, so forcing it on an achievement-less game only removes features, and its hardcore-tagged save would ratchet future resumes into hardcore even after the setting is turned off.
- gamedetail: skip the Start Game server fetch when offline. GetUnifiedSavesUseCase gains includeServer; showPlayOptions and shouldShowModeSelection pass NetworkUtils.isOnline so an offline launch no longer waits out checkSavesForGame's 30s connect timeout. The blocking fetch is kept when online.
- saves: correct the slot-delete dialog copy to "from the server and local storage. This cannot be undone.", matching the delete now removing the server copy.
- libretro: surface the casual-into-hardcore fallback. RestoreResult gains casualSaveInHardcore, set when RESUME_HARDCORE falls back to a non-hardcore save, and LibretroActivity shows "Continuing casual save in hardcore".
- test: cover the activeSaveApplied early-return in restoreSaveForLaunchMode (the on-disk .srm must win over the cache's hardcore pick).
- cleanup: remove inline narration comments per project standard; move the genuinely-novel rationale into docblocks.

Author: Yiannis128

app/src/main/kotlin/com/nendo/argosy/core/emulator/LibretroSettingDef.kt

@@ -144,21 +144,31 @@ sealed class LibretroSettingDef(
         key = "autoSaveState",
         section = "saving",
         title = "Save State on Exit",
+        subtitle = "Applies to casual games only",
         type = SettingType.Switch
     )
 
     data object AutoRestoreState : LibretroSettingDef(
         key = "autoRestoreState",
         section = "saving",
         title = "Restore State on Launch",
+        subtitle = "Applies to casual games only",
         type = SettingType.Switch
     )
 
     data object HwCoreSaveStates : LibretroSettingDef(
         key = "hwCoreSaveStates",
         section = "saving",
         title = "Hardware-Core Save States",
-        subtitle = "Experimental; cores like Dolphin may black-screen or fail to resume",
+        subtitle = "Experimental; cores like Dolphin may black-screen or fail to resume. Applies to casual games only",
+        type = SettingType.Switch
+    )
+
+    data object DefaultToHardcore : LibretroSettingDef(
+        key = "defaultToHardcore",
+        section = "saving",
+        title = "Default to Hardcore",
+        subtitle = "When launching a game, default to hardcore instead of casual",
         type = SettingType.Switch
     )
 
@@ -183,7 +193,8 @@ sealed class LibretroSettingDef(
             AudioVolume,
             AutoSaveState,
             AutoRestoreState,
-            HwCoreSaveStates
+            HwCoreSaveStates,
+            DefaultToHardcore
         )
 
         val SECTIONS: Map<String, String> = mapOf(

app/src/main/kotlin/com/nendo/argosy/data/emulator/GameLauncher.kt

@@ -87,7 +87,9 @@ class GameLauncher @Inject constructor(
     private val coreSystemDataManager: CoreSystemDataManager,
     private val gameFileDao: GameFileDao,
     private val emulatorSaveConfigRepository: com.nendo.argosy.data.repository.EmulatorSaveConfigRepository,
-    private val saveHandlerRegistry: com.nendo.argosy.data.sync.platform.PlatformSaveHandlerRegistry
+    private val saveHandlerRegistry: com.nendo.argosy.data.sync.platform.PlatformSaveHandlerRegistry,
+    private val libretroStatePathResolver: LibretroStatePathResolver,
+    private val notificationManager: com.nendo.argosy.core.notification.NotificationManager
 ) {
     private val shellAmAvailable: Boolean by lazy {
         try {
@@ -521,7 +523,9 @@ class GameLauncher @Inject constructor(
         val builtinBesideRom = emulatorSaveConfigRepository.getByEmulator("builtin")?.savesBesideRom == true
         val effectiveSavePath = if (builtinBesideRom) romFile.parent
             else platformLibretroOverride?.savePath ?: builtinSettings.customSavePath
-        val effectiveStatePath = platformLibretroOverride?.statePath ?: builtinSettings.customStatePath
+        val effectiveStatePath = libretroStatePathResolver
+            .liveStateBaseDir(platformLibretroOverride?.statePath, builtinSettings.customStatePath)
+            .absolutePath
         return Intent(context, LibretroActivity::class.java).apply {
             putExtra(LibretroActivity.EXTRA_ROM_PATH, romFile.absolutePath)
             putExtra(LibretroActivity.EXTRA_VARIANT_FILE_ID, variantFileId ?: -1L)
@@ -535,7 +539,7 @@ class GameLauncher @Inject constructor(
             putExtra(LibretroActivity.EXTRA_CORE_VAR_KEYS, coreVariables.map { it.key }.toTypedArray())
             putExtra(LibretroActivity.EXTRA_CORE_VAR_VALUES, coreVariables.map { it.value }.toTypedArray())
             effectiveSavePath?.let { putExtra(LibretroActivity.EXTRA_SAVES_DIR, it) }
-            effectiveStatePath?.let { putExtra(LibretroActivity.EXTRA_STATES_DIR, it) }
+            putExtra(LibretroActivity.EXTRA_STATES_DIR, effectiveStatePath)
             addFlags(Intent.FLAG_ACTIVITY_NEW_TASK)
         }
     }
@@ -1061,11 +1065,13 @@ class GameLauncher @Inject constructor(
     private suspend fun resolveBuiltinCoreId(game: GameEntity): String? {
         val validCoreIds = com.nendo.argosy.libretro.LibretroCoreRegistry
             .getCoresForPlatform(game.platformSlug).map { it.coreId }.toSet()
+        var rejectedCore: String? = null
 
         fun accept(coreId: String?, source: String): String? {
             if (coreId.isNullOrBlank()) return null
             if (coreId !in validCoreIds) {
                 Logger.warn(TAG, "[BuiltIn] ignoring unknown core '$coreId' from $source for ${game.platformSlug}")
+                if (rejectedCore == null) rejectedCore = coreId
                 return null
             }
             Logger.debug(TAG, "[BuiltIn] core selection: $source -> $coreId")
@@ -1079,6 +1085,16 @@ class GameLauncher @Inject constructor(
         val default = com.nendo.argosy.libretro.LibretroCoreRegistry
             .getDefaultCoreForPlatform(game.platformSlug)?.coreId
         Logger.debug(TAG, "[BuiltIn] core selection: registry default -> $default")
+
+        val rejected = rejectedCore
+        if (rejected != null && default != null) {
+            val registry = com.nendo.argosy.libretro.LibretroCoreRegistry
+            notificationManager.show(
+                title = "Failed to load ${registry.displayNameFor(rejected)}, " +
+                    "using ${registry.displayNameFor(default)} instead",
+                type = com.nendo.argosy.core.notification.NotificationType.WARNING
+            )
+        }
         return default
     }
 

app/src/main/kotlin/com/nendo/argosy/data/emulator/LibretroStatePathResolver.kt

@@ -0,0 +1,56 @@
+package com.nendo.argosy.data.emulator
+
+import android.content.Context
+import com.nendo.argosy.data.local.dao.GameDao
+import com.nendo.argosy.data.local.dao.PlatformLibretroSettingsDao
+import com.nendo.argosy.data.preferences.UserPreferencesRepository
+import com.nendo.argosy.libretro.LibretroStateSlots
+import com.nendo.argosy.util.AppPaths
+import dagger.hilt.android.qualifiers.ApplicationContext
+import kotlinx.coroutines.flow.first
+import java.io.File
+import javax.inject.Inject
+import javax.inject.Singleton
+
+/**
+ * Single source of truth for the built-in libretro core's FLAT live save-state directory.
+ *
+ * Live states are flat ({base}/rom.state.X), mirroring SRAM and external emulators; channels
+ * live only in the cache. The base dir mirrors the precedence [GameLauncher] uses when it builds
+ * the launch intent: per-platform override -> global custom path -> default
+ * ({filesDir}/libretro/states). Routing the cache/restore side through here keeps it in step with
+ * the live engine and fixes the old bug where the cache side used StatePathRegistry's unexpanded
+ * "{filesDir}/libretro/states" token for built-in.
+ *
+ * Keyed by gameId because the cache/restore callers have a gameId but not always the numeric
+ * platformId the per-platform override is keyed on. Variant isolation ({base}/variants/{id}) is
+ * applied by LibretroActivity at launch and is not modelled here (cache/restore is non-variant).
+ */
+@Singleton
+class LibretroStatePathResolver @Inject constructor(
+    @ApplicationContext private val context: Context,
+    private val gameDao: GameDao,
+    private val platformLibretroSettingsDao: PlatformLibretroSettingsDao,
+    private val userPreferencesRepository: UserPreferencesRepository,
+) {
+    suspend fun liveStateBaseDir(gameId: Long): File {
+        val platformId = gameDao.getById(gameId)?.platformId
+        val platformOverride = platformId?.let { platformLibretroSettingsDao.getByPlatformId(it)?.statePath }
+        val custom = userPreferencesRepository.getBuiltinEmulatorSettings().first().customStatePath
+        return liveStateBaseDir(platformOverride, custom)
+    }
+
+    /**
+     * Overload for callers ([GameLauncher]) that already hold the resolved per-platform override and
+     * custom paths -- avoids the extra game/platform/prefs lookups the gameId overload performs.
+     */
+    fun liveStateBaseDir(platformStatePath: String?, customStatePath: String?): File {
+        val base = platformStatePath?.takeIf { it.isNotBlank() }
+            ?: customStatePath?.takeIf { it.isNotBlank() }
+            ?: AppPaths.libretroStatesDir(context.filesDir).absolutePath
+        return File(base)
+    }
+
+    fun liveStateFile(baseDir: File, romBaseName: String, slotNumber: Int): File =
+        File(baseDir, LibretroStateSlots.fileName(romBaseName, slotNumber))
+}

app/src/main/kotlin/com/nendo/argosy/data/preferences/BuiltinEmulatorPreferencesRepository.kt

@@ -48,6 +48,7 @@ class BuiltinEmulatorPreferencesRepository @Inject constructor(
         val BUILTIN_AUTO_RESTORE_STATE = booleanPreferencesKey("builtin_auto_restore_state")
         val BUILTIN_AUTO_RESTORE_STATE_MODE = stringPreferencesKey("builtin_auto_restore_state_mode")
         val BUILTIN_HW_CORE_SAVE_STATES = booleanPreferencesKey("builtin_hw_core_save_states")
+        val BUILTIN_DEFAULT_TO_HARDCORE = booleanPreferencesKey("builtin_default_to_hardcore")
         val BUILTIN_CUSTOM_SAVE_PATH = stringPreferencesKey("builtin_custom_save_path")
         val BUILTIN_CUSTOM_STATE_PATH = stringPreferencesKey("builtin_custom_state_path")
         val BUILTIN_MIGRATION_V1 = booleanPreferencesKey("builtin_migration_v2")
@@ -101,6 +102,7 @@ class BuiltinEmulatorPreferencesRepository @Inject constructor(
                 ?: (prefs[Keys.BUILTIN_AUTO_RESTORE_STATE_MODE] != "off"),
             autoRestoreStateMode = prefs[Keys.BUILTIN_AUTO_RESTORE_STATE_MODE] ?: "restore",
             hwCoreSaveStatesEnabled = prefs[Keys.BUILTIN_HW_CORE_SAVE_STATES] ?: false,
+            defaultToHardcore = prefs[Keys.BUILTIN_DEFAULT_TO_HARDCORE] ?: false,
             customSavePath = prefs[Keys.BUILTIN_CUSTOM_SAVE_PATH],
             customStatePath = prefs[Keys.BUILTIN_CUSTOM_STATE_PATH],
             architectureOverride = prefs[Keys.BUILTIN_ARCHITECTURE_OVERRIDE],
@@ -277,6 +279,10 @@ class BuiltinEmulatorPreferencesRepository @Inject constructor(
         dataStore.edit { it[Keys.BUILTIN_HW_CORE_SAVE_STATES] = enabled }
     }
 
+    suspend fun setBuiltinDefaultToHardcore(enabled: Boolean) {
+        dataStore.edit { it[Keys.BUILTIN_DEFAULT_TO_HARDCORE] = enabled }
+    }
+
     suspend fun setBuiltinCustomSavePath(path: String?) {
         dataStore.edit {
             if (path != null) it[Keys.BUILTIN_CUSTOM_SAVE_PATH] = path

app/src/main/kotlin/com/nendo/argosy/data/preferences/UserPreferencesRepository.kt

@@ -421,6 +421,7 @@ data class BuiltinEmulatorSettings(
     val autoRestoreState: Boolean = true,
     val autoRestoreStateMode: String = "restore",
     val hwCoreSaveStatesEnabled: Boolean = false,
+    val defaultToHardcore: Boolean = false,
     val customSavePath: String? = null,
     val customStatePath: String? = null,
     val architectureOverride: String? = null,

app/src/main/kotlin/com/nendo/argosy/data/repository/LibretroSettingsRepository.kt

@@ -125,6 +125,9 @@ class LibretroSettingsRepository @Inject constructor(
     suspend fun setBuiltinHwCoreSaveStates(enabled: Boolean) =
         builtinPrefs.setBuiltinHwCoreSaveStates(enabled)
 
+    suspend fun setBuiltinDefaultToHardcore(enabled: Boolean) =
+        builtinPrefs.setBuiltinDefaultToHardcore(enabled)
+
     suspend fun setBuiltinCustomSavePath(path: String?) =
         builtinPrefs.setBuiltinCustomSavePath(path)
 

app/src/main/kotlin/com/nendo/argosy/data/repository/SaveSyncApiClient.kt

@@ -463,11 +463,17 @@ class SaveSyncApiClient @Inject constructor(
         internal const val MIN_VALID_SAVE_SIZE_BYTES = 100L
         internal const val AUTOCLEANUP_LIMIT = 10
 
+        /**
+         * The autosave channel is stored as either null or the literal "autosave" (a restore sets
+         * the string form); recognize both so callers do not each re-inline the check.
+         */
+        fun isAutosaveChannel(channelName: String?): Boolean =
+            channelName == null || channelName.equals(AUTOSAVE_SLOT_NAME, ignoreCase = true)
+
         fun computeUploadFileName(localSavePath: String?, channelName: String?, romBaseName: String?): String {
             val baseName = when {
-                channelName == null || channelName.equals(AUTOSAVE_SLOT_NAME, ignoreCase = true) ->
-                    romBaseName ?: DEFAULT_SAVE_NAME
-                else -> channelName
+                isAutosaveChannel(channelName) -> romBaseName ?: DEFAULT_SAVE_NAME
+                else -> channelName ?: DEFAULT_SAVE_NAME
             }
             val ext = localSavePath?.let { java.io.File(it) }?.let { file ->
                 when {

app/src/main/kotlin/com/nendo/argosy/data/repository/SaveUploader.kt

@@ -313,7 +313,7 @@ class SaveUploader @Inject constructor(
             val filePart = MultipartBody.Part.createFormData("saveFile", uploadFileName, requestBody)
 
             val slotForUpload = channelName ?: SaveSyncApiClient.AUTOSAVE_SLOT_NAME
-            val isAutosaveSlot = channelName == null
+            val isAutosaveSlot = SaveSyncApiClient.isAutosaveChannel(channelName)
             val autocleanupEnabled = isAutosaveSlot
             val autocleanupLimit = if (isAutosaveSlot) SaveSyncApiClient.AUTOCLEANUP_LIMIT else null
             val response = if (deviceId != null) {

app/src/main/kotlin/com/nendo/argosy/data/repository/StateCacheManager.kt

@@ -62,6 +62,7 @@ class StateCacheManager @Inject constructor(
     private val coreVersionExtractor: CoreVersionExtractor,
     private val retroArchConfigParser: RetroArchConfigParser,
     private val retroArchPathResolver: com.nendo.argosy.data.emulator.RetroArchPathResolver,
+    private val libretroStatePathResolver: com.nendo.argosy.data.emulator.LibretroStatePathResolver,
     private val saveSyncApiClient: SaveSyncApiClient,
     private val payloadCodec: com.nendo.argosy.data.sync.SyncPayloadCodec
 ) {
@@ -134,13 +135,7 @@ class StateCacheManager @Inject constructor(
                 retroArchPathResolver.resolveStateDirectories(req)
             }
             userStateOverride != null -> listOf(userStateOverride)
-            emulatorId == "builtin" -> {
-                val baseDir = AppPaths.libretroStatesDir(context.filesDir)
-                val channelDirs = baseDir.listFiles { f -> f.isDirectory }
-                    ?.map { it.absolutePath }
-                    ?: listOf(File(baseDir, "default").absolutePath)
-                channelDirs
-            }
+            emulatorId == "builtin" -> listOf(libretroStatePathResolver.liveStateBaseDir(gameId).absolutePath)
             else -> StatePathRegistry.resolvePath(config, platformId)
         }
         Log.d(TAG, "Searching ${statePaths.size} paths: $statePaths")
@@ -487,7 +482,12 @@ class StateCacheManager @Inject constructor(
         emulatorId: String? = null,
         coreName: String? = null,
         romPath: String? = null,
+        gameId: Long? = null,
     ): String? {
+        if (emulatorId == "builtin" && gameId != null) {
+            val baseDir = libretroStatePathResolver.liveStateBaseDir(gameId)
+            return libretroStatePathResolver.liveStateFile(baseDir, romBaseName, slotNumber).absolutePath
+        }
         val paths = if (emulatorId != null &&
             com.nendo.argosy.data.emulator.RetroArchPathResolver.isRetroArch(emulatorId)
         ) {
@@ -560,16 +560,17 @@ class StateCacheManager @Inject constructor(
     suspend fun getStatesForChannelAndCore(gameId: Long, channelName: String?, coreId: String?): List<StateCacheEntity> =
         stateCacheDao.getByChannelAndCore(gameId, channelName, coreId)
 
-    suspend fun deleteAutoStateFromDisk(
+    suspend fun deleteAutoResumeStatesFromDisk(
         emulatorId: String,
         romPath: String,
         platformSlug: String,
         emulatorPackage: String?,
-        coreId: String?
+        coreId: String?,
+        gameId: Long? = null,
     ): Boolean = withContext(Dispatchers.IO) {
         val config = StatePathRegistry.getConfig(emulatorId)
         if (config == null) {
-            Log.d(TAG, "deleteAutoStateFromDisk: No state config for emulator: $emulatorId")
+            Log.d(TAG, "deleteAutoResumeStatesFromDisk: No state config for emulator: $emulatorId")
             return@withContext false
         }
 
@@ -590,26 +591,33 @@ class StateCacheManager @Inject constructor(
                 retroArchPathResolver.resolveStateDirectories(req)
             }
             userStateOverride != null -> listOf(userStateOverride)
+            emulatorId == "builtin" && gameId != null ->
+                listOf(libretroStatePathResolver.liveStateBaseDir(gameId).absolutePath)
             else -> StatePathRegistry.resolvePath(config, platformSlug)
         }
 
-        val autoFileName = config.slotPattern.buildFileName(romBaseName, -1)
+        val fileNames = listOf(
+            config.slotPattern.buildFileName(romBaseName, -1),
+            com.nendo.argosy.libretro.LibretroStateSlots.fileName(
+                romBaseName, com.nendo.argosy.libretro.LibretroStateSlots.RESUME_SLOT
+            ),
+        )
 
+        var deletedAny = false
         for (path in statePaths) {
             val stateDir = File(path)
             if (!stateDir.exists()) continue
-
-            val autoStateFile = File(stateDir, autoFileName)
-            if (autoStateFile.exists()) {
-                autoStateFile.delete()
-                File("${autoStateFile.absolutePath}.png").takeIf { it.exists() }?.delete()
-                Log.d(TAG, "Deleted auto-state from disk: ${autoStateFile.absolutePath}")
-                return@withContext true
+            for (name in fileNames) {
+                val file = File(stateDir, name)
+                if (file.exists() && file.delete()) {
+                    File("${file.absolutePath}.png").takeIf { it.exists() }?.delete()
+                    Log.d(TAG, "Deleted live state: ${file.absolutePath}")
+                    deletedAny = true
+                }
             }
         }
-
-        Log.d(TAG, "deleteAutoStateFromDisk: No auto-state found for $romBaseName")
-        false
+        if (!deletedAny) Log.d(TAG, "deleteAutoResumeStatesFromDisk: nothing to delete for $romBaseName")
+        deletedAny
     }
 
     suspend fun clearAllCache() = withContext(Dispatchers.IO) {

app/src/main/kotlin/com/nendo/argosy/domain/usecase/save/GetUnifiedSavesUseCase.kt

@@ -23,15 +23,16 @@ class GetUnifiedSavesUseCase @Inject constructor(
 ) {
     suspend operator fun invoke(
         gameId: Long,
-        expandHistory: Boolean = false
+        expandHistory: Boolean = false,
+        includeServer: Boolean = true
     ): List<UnifiedSaveEntry> {
         saveCacheManager.dedupeIdenticalCaches(gameId)
         val localCaches = saveCacheManager.getCachesForGameOnce(gameId)
         val game = gameDao.getById(gameId)
         val rommId = game?.rommId
         val romBaseName = game?.localPath?.let { File(it).nameWithoutExtension }
 
-        val serverSaves = if (rommId != null) {
+        val serverSaves = if (rommId != null && includeServer) {
             saveSyncRepository.checkSavesForGame(gameId, rommId)
         } else {
             emptyList()