feat(sync): auto-refresh device version on upgrade + first-time multi-slot picker

Device version: persist the client_version last reported per device
(Host.DeviceClientVersion); on startup, if grout was upgraded since, PUT the new
version to the server (RefreshDeviceVersion in connectAndLoadPlatforms). Registration
stamps the version so the startup check only fires on a real upgrade.

Multi-slot first-time pull: when a ROM has no local save and the server offers it in
more than one slot, mapOperationsToItems / buildDiscoveryItems now populate
AvailableSlots + AllRemoteSaves so the existing slot picker (resolveMultiSlotDownloads)
prompts the user instead of silently picking. A ROM that already has a local save is
still pinned to its managed slot (no picker).

Author: BrandonKowalski

app/setup.go

@@ -18,6 +18,7 @@ import (
 	"grout/internal/fileutil"
 	"grout/resources"
 	"grout/romm"
+	"grout/sync"
 	"grout/ui"
 	"log"
 	"log/slog"
@@ -313,6 +314,14 @@ func connectAndLoadPlatforms(config *internal.Config, logger *slog.Logger) []rom
 				}
 			}
 
+			// If grout was upgraded since this device last reported in, refresh the
+			// client_version the server has on record (diagnostic/display only).
+			if v, changed := sync.RefreshDeviceVersion(authClient, host.DeviceID, host.DeviceClientVersion); changed {
+				host.DeviceClientVersion = v
+				config.Hosts[0] = host
+				internal.SaveConfig(config)
+			}
+
 			// Load platforms
 			if err := config.LoadPlatformsBinding(config.Hosts[0], config.ApiTimeout.Duration()); err != nil {
 				logger.Debug("Failed to load platform bindings", "error", err)

romm/host.go

@@ -20,6 +20,9 @@ type Host struct {
 
 	DeviceID   string `json:"device_id,omitempty"`
 	DeviceName string `json:"device_name,omitempty"`
+	// DeviceClientVersion is the grout version last reported to the server for this
+	// device; used to refresh the server's record after an app upgrade.
+	DeviceClientVersion string `json:"device_client_version,omitempty"`
 }
 
 func (h Host) HasTokenAuth() bool {

sync/flow.go

@@ -164,17 +164,75 @@ func buildDiscoveryItems(uncovered map[int]cfw.LocalRomFile, savesByRom map[int]
 			"romID", romID, "romName", rom.RomName, "saveID", best.ID,
 			"file", best.FileName, "fetched", len(saves))
 
-		items = append(items, SyncItem{
+		item := SyncItem{
 			LocalSave:  ls,
 			RemoteSave: best,
 			TargetSlot: preferredSlot,
 			Action:     ActionDownload,
-		})
+		}
+		// First-time multi-slot pull: offer the slot choice to the UI. Discovery only
+		// runs for ROMs with no local save, so every multi-slot case is first-time.
+		if slots := distinctSaveSlots(saves); len(slots) > 1 {
+			item.AvailableSlots = slots
+			item.AllRemoteSaves = saves
+		}
+
+		items = append(items, item)
 	}
 
 	return items
 }
 
+// distinctSaveSlots returns the sorted distinct slot names across saves (nil/empty slot
+// counts as "autosave").
+func distinctSaveSlots(saves []romm.Save) []string {
+	set := make(map[string]bool)
+	for _, s := range saves {
+		slot := "autosave"
+		if s.Slot != nil && *s.Slot != "" {
+			slot = *s.Slot
+		}
+		set[slot] = true
+	}
+	out := make([]string, 0, len(set))
+	for s := range set {
+		out = append(out, s)
+	}
+	sort.Strings(out)
+	return out
+}
+
+// distinctOpSlots returns the sorted distinct slot names across download ops (nil/empty
+// slot counts as "autosave").
+func distinctOpSlots(ops []romm.SyncOperationSchema) []string {
+	set := make(map[string]bool)
+	for _, op := range ops {
+		slot := "autosave"
+		if op.Slot != nil && *op.Slot != "" {
+			slot = *op.Slot
+		}
+		set[slot] = true
+	}
+	out := make([]string, 0, len(set))
+	for s := range set {
+		out = append(out, s)
+	}
+	sort.Strings(out)
+	return out
+}
+
+// opStubsToSaves builds romm.Save stubs from download ops for slot re-selection by the
+// multi-slot picker.
+func opStubsToSaves(ops []romm.SyncOperationSchema) []romm.Save {
+	saves := make([]romm.Save, 0, len(ops))
+	for _, op := range ops {
+		if stub := buildRemoteSaveStub(op); stub != nil {
+			saves = append(saves, *stub)
+		}
+	}
+	return saves
+}
+
 // discoverRemoteOnlySaves finds locally-present ROMs that have no local save and were
 // not covered by a negotiate operation, fetches their server saves, and builds download
 // items for any save this device has never synced.
@@ -378,12 +436,25 @@ func mapOperationsToItems(
 		if !ok {
 			ls = resolveLocalSaveForDownload(op, resolvedRoms, cm)
 		}
-		items = append(items, SyncItem{
+		item := SyncItem{
 			LocalSave:  ls,
 			RemoteSave: buildRemoteSaveStub(op),
 			TargetSlot: preferred,
 			Action:     ActionDownload,
-		})
+		}
+
+		// First-time multi-slot pull: if this ROM has no local save yet and the server
+		// offers it in more than one slot, surface the choice to the UI instead of
+		// silently picking. (A ROM that already has a local save was filtered to its
+		// managed slot above, so it never reaches here multi-slot.)
+		if _, hasLocal := localByRom[romID]; !hasLocal {
+			if slots := distinctOpSlots(dops); len(slots) > 1 {
+				item.AvailableSlots = slots
+				item.AllRemoteSaves = opStubsToSaves(dops)
+			}
+		}
+
+		items = append(items, item)
 	}
 
 	return items
@@ -526,6 +597,25 @@ func RegisterDevice(client *romm.Client, name string) (romm.Device, error) {
 	return dev, nil
 }
 
+// RefreshDeviceVersion updates the server's record of this device's client_version when
+// the running grout version differs from lastReported (i.e. the app was upgraded since
+// the version was last sent). Returns the version now reported and whether an update was
+// sent. Best-effort: a failure is logged and leaves lastReported unchanged.
+func RefreshDeviceVersion(client *romm.Client, deviceID, lastReported string) (string, bool) {
+	current := version.Get().Version
+	if deviceID == "" || current == "" || current == lastReported {
+		return lastReported, false
+	}
+	if _, err := client.UpdateDevice(deviceID, romm.UpdateDeviceRequest{ClientVersion: current}); err != nil {
+		gaba.GetLogger().Warn("Failed to refresh device client_version on upgrade",
+			"deviceID", deviceID, "from", lastReported, "to", current, "error", err)
+		return lastReported, false
+	}
+	gaba.GetLogger().Debug("Refreshed device client_version after upgrade",
+		"deviceID", deviceID, "from", lastReported, "to", current)
+	return current, true
+}
+
 func ScanSaves(config *internal.Config) []LocalSave {
 	logger := gaba.GetLogger()
 	currentCFW := cfw.GetCFW()

sync/flow_test.go

@@ -282,6 +282,48 @@ func TestMapOperationsToItems_AcceptsSameSlotDownloadWhenLocalSaveExists(t *test
 	}
 }
 
+func TestMapOperationsToItems_FirstTimeMultiSlotOffersChoice(t *testing.T) {
+	// rom 303 is installed but has no local save; the server offers two slots. The item
+	// should carry AvailableSlots + AllRemoteSaves so the UI can prompt for a choice.
+	resolved := map[int]cfw.LocalRomFile{
+		303: {RomID: 303, RomName: "Pokemon", FSSlug: "gba", FileName: "Pokemon.gba"},
+	}
+	now := time.Now()
+	ops := []romm.SyncOperationSchema{
+		{Action: "download", RomID: 303, SaveID: ptrInt(235), FileName: "P [a].srm", Slot: ptrStr("autosave"), ServerUpdatedAt: ptrTime(now)},
+		{Action: "download", RomID: 303, SaveID: ptrInt(228), FileName: "P [q].srm", Slot: ptrStr("quicksave"), ServerUpdatedAt: ptrTime(now)},
+	}
+
+	items := mapOperationsToItems(ops, nil, resolved, nil, nil, nil)
+
+	if len(items) != 1 {
+		t.Fatalf("expected 1 item, got %d", len(items))
+	}
+	it := items[0]
+	if len(it.AvailableSlots) != 2 || it.AvailableSlots[0] != "autosave" || it.AvailableSlots[1] != "quicksave" {
+		t.Errorf("AvailableSlots = %v, want [autosave quicksave]", it.AvailableSlots)
+	}
+	if len(it.AllRemoteSaves) != 2 {
+		t.Errorf("AllRemoteSaves = %d, want 2", len(it.AllRemoteSaves))
+	}
+}
+
+func TestMapOperationsToItems_LocalSaveDoesNotOfferMultiSlot(t *testing.T) {
+	// ROM already has a local save in "autosave"; the "quicksave" download is skipped by
+	// the managed-slot gate, so no picker is offered.
+	local := []LocalSave{{RomID: 303, FileName: "Pokemon.srm", FilePath: "/x/Pokemon.srm", FSSlug: "gba"}}
+	recorded := map[saveKey]string{{romID: 303, fileName: "Pokemon.srm"}: "autosave"}
+	now := time.Now()
+	ops := []romm.SyncOperationSchema{
+		{Action: "download", RomID: 303, SaveID: ptrInt(228), FileName: "P [q].srm", Slot: ptrStr("quicksave"), ServerUpdatedAt: ptrTime(now)},
+	}
+
+	items := mapOperationsToItems(ops, local, nil, nil, nil, recorded)
+	if len(items) != 0 {
+		t.Fatalf("expected other-slot download skipped (no picker), got %d items", len(items))
+	}
+}
+
 // --- buildClientSaveStates tests ---
 
 func TestBuildClientSaveStates_FileSlotEmulatorHash(t *testing.T) {

ui/device_registration.go

@@ -6,6 +6,7 @@ import (
 	"grout/internal"
 	"grout/romm"
 	"grout/sync"
+	"grout/version"
 	"os"
 
 	gaba "github.com/BrandonKowalski/gabagool/v2/pkg/gabagool"
@@ -233,5 +234,8 @@ func (s *SaveSyncSettingsScreen) registerDevice(output SaveSyncSettingsOutput) (
 
 	output.Host.DeviceID = device.ID
 	output.Host.DeviceName = deviceName
+	// RegisterDevice already pushed the current client_version; record it so the startup
+	// refresh only fires on a later upgrade.
+	output.Host.DeviceClientVersion = version.Get().Version
 	return output, nil
 }