diff --git a/cmd/opensave-app/frontend/src/lib/gamestatus.js b/cmd/opensave-app/frontend/src/lib/gamestatus.js
index 4d920c01..2be2f839 100644
--- a/cmd/opensave-app/frontend/src/lib/gamestatus.js
+++ b/cmd/opensave-app/frontend/src/lib/gamestatus.js
@@ -21,6 +21,9 @@ import { playLength } from './format.js';
 export function gameStatus(game, { peers = {}, activity, conflicted = false, now = Date.now() } = {}) {
   // Before anything else: with its folder gone nothing else about it can
   // move — no snapshot, no sync, no decision taken.
+  // …unless the whole drive is absent here: the game's saves live on another
+  // device's D:\ or E:\, and there is nothing on this one to worry about.
+  if (game.savePathMissing && game.saveDriveMissing) return { state: 'elsewhere', label: 'Not on this device', tone: 'muted' };
   if (game.savePathMissing) return { state: 'missing', label: 'Save folder missing', tone: 'warn' };
   // Every save file deleted here at once, held back from the other devices
   // until someone says whether that was meant (lib/emptied.js).
@@ -177,7 +180,7 @@ const stamp = (s) => (s ? Date.parse(s) : null);
 const snapshotsOf = (game) => Object.values(game.branches ?? {}).flatMap((b) => b.snapshots ?? []);
 
 // What needs looking at, in the order the summary above the library reads it.
-const URGENCY = { missing: 0, emptied: 1, conflict: 2, error: 3, syncing: 4, restoring: 4, unsynced: 5, empty: 6, paused: 7 };
+const URGENCY = { missing: 0, emptied: 1, conflict: 2, error: 3, syncing: 4, restoring: 4, unsynced: 5, empty: 6, paused: 7, elsewhere: 10 }; // unlisted states (synced, local…) rank 9
 
 /**
  * The orders the library can be put in. Each compares two rows, {game,
diff --git a/cmd/opensave-app/frontend/src/lib/gamestatus.test.js b/cmd/opensave-app/frontend/src/lib/gamestatus.test.js
index d144943c..810b197b 100644
--- a/cmd/opensave-app/frontend/src/lib/gamestatus.test.js
+++ b/cmd/opensave-app/frontend/src/lib/gamestatus.test.js
@@ -119,6 +119,18 @@ describe('a missing save folder', () => {
     expect(librarySummary(rows)).toEqual({ tone: 'warn', headline: "Hades's save folder is missing" });
     expect(sortRows(rows, 'attention').map((r) => r.game.name)).toEqual(['Hades', 'Celeste']);
   });
+
+  it('on a drive this device does not have is not a warning, and stays out of the headline', () => {
+    const g = game({ id: 'a', name: 'ARK', savePathMissing: true, saveDriveMissing: true });
+    const s = gameStatus(g);
+    expect(s).toMatchObject({ state: 'elsewhere', tone: 'muted', label: 'Not on this device' });
+    const rows = [
+      { game: g, status: s },
+      { game: game({ id: 'c', name: 'Celeste', branches: snaps(minsAgo(5)) }), status: { state: 'synced' } }
+    ];
+    expect(librarySummary(rows).tone).not.toBe('warn');
+    expect(sortRows(rows, 'attention').map((r) => r.game.name)).toEqual(['Celeste', 'ARK']);
+  });
 });
 
 describe('SORTS', () => {
diff --git a/cmd/opensave-app/frontend/src/lib/notifications.js b/cmd/opensave-app/frontend/src/lib/notifications.js
index e8633fd5..8bb495a1 100644
--- a/cmd/opensave-app/frontend/src/lib/notifications.js
+++ b/cmd/opensave-app/frontend/src/lib/notifications.js
@@ -46,7 +46,14 @@ export function waitingOnYou({ games = {}, conflicts = {}, locationConflicts = [
     out.push({ id: `offer:${o.gameId}:${o.snapshotId}`, tone: 'info', gameId: o.gameId, title: `A newer save for ${o.gameName ?? name(o.gameId)}`, detail: `From ${o.deviceName ?? 'another device'}, through the cloud`, go: { view: 'home' } });
   }
   for (const g of Object.values(games)) {
-    if (g.savePathMissing) {
+    // The same folder found on another drive here: offered, waiting for a yes.
+    if (g.savePathMissing && g.relocateSuggestion) {
+      out.push({ id: `relocate:${g.id}:${g.relocateSuggestion}`, tone: 'warn', gameId: g.id, title: `${g.name}'s save folder may be at ${g.relocateSuggestion}`, detail: 'Confirm it before it is used', go: { view: 'game', params: { gameId: g.id } } });
+    }
+  }
+  for (const g of Object.values(games)) {
+    // A drive this device doesn't have is not waiting on anyone.
+    if (g.savePathMissing && !g.saveDriveMissing) {
       out.push({ id: `missing:${g.id}`, tone: 'warn', gameId: g.id, title: `${g.name}'s save folder is missing`, detail: 'Nothing is synced for it until it is back', go: { view: 'game', params: { gameId: g.id } } });
     }
   }
diff --git a/cmd/opensave-app/frontend/src/lib/notifications.test.js b/cmd/opensave-app/frontend/src/lib/notifications.test.js
index a5828324..27487862 100644
--- a/cmd/opensave-app/frontend/src/lib/notifications.test.js
+++ b/cmd/opensave-app/frontend/src/lib/notifications.test.js
@@ -21,6 +21,11 @@ describe('notifications', () => {
     expect(w.find((x) => x.id.startsWith('damaged')).title).toBe("1 snapshot of Hades can't be restored");
   });
 
+  it('does not ask about a game whose drive this device does not have', () => {
+    const w = waitingOnYou({ games: { ark: { id: 'ark', name: 'ARK', savePathMissing: true, saveDriveMissing: true, branches: {} } } });
+    expect(w).toEqual([]);
+  });
+
   it('turns activity into events, unread since the bell was last opened', () => {
     const now = Date.UTC(2026, 8, 25, 12);
     const items = [
@@ -57,3 +62,12 @@ describe('a save arriving', () => {
     expect(arrivalMessage({ ...ev, kind: 'sent' }, games, {}, t0)).toBeNull();
   });
 });
+
+describe('a missing save folder found on another drive', () => {
+  it('waits for a yes, whether or not the drive it was on exists', () => {
+    const w = waitingOnYou({ games: { ark: { id: 'ark', name: 'ARK', savePathMissing: true, saveDriveMissing: true, relocateSuggestion: 'E:\SteamLibrary\ARK', branches: {} } } });
+    const r = w.find((x) => x.id.startsWith('relocate:'));
+    expect(r?.title).toContain('E:\SteamLibrary\ARK');
+    expect(r?.go).toEqual({ view: 'game', params: { gameId: 'ark' } });
+  });
+});
diff --git a/cmd/opensave-app/frontend/src/views/game/GameHeader.svelte b/cmd/opensave-app/frontend/src/views/game/GameHeader.svelte
index 19750020..3db66f67 100644
--- a/cmd/opensave-app/frontend/src/views/game/GameHeader.svelte
+++ b/cmd/opensave-app/frontend/src/views/game/GameHeader.svelte
@@ -17,6 +17,7 @@
   import Pencil from 'lucide-svelte/icons/pencil';
   import Star from 'lucide-svelte/icons/star';
   import TriangleAlert from 'lucide-svelte/icons/triangle-alert';
+  import Info from 'lucide-svelte/icons/info';
   import { collections, isFavourite, toggleFavourite } from '../../lib/collections.js';
 
   export let game;
@@ -69,6 +70,26 @@
       answering = false;
     }
   }
+  // The save folder is missing here, and the same folder exists on another drive.
+  // It is offered, never switched to on its own: it could be an old copy.
+  let relocating = false;
+  async function answerRelocation(use) {
+    const found = game.relocateSuggestion;
+    relocating = true;
+    try {
+      if (use) {
+        await api.post(`/api/games/${game.id}/relocate`, { path: found });
+        toast(`${game.name} now uses ${found}`, 'success');
+      } else {
+        await api.post(`/api/games/${game.id}/relocate/dismiss`);
+        toast(`Not using ${found} for ${game.name}`, 'success');
+      }
+    } catch (e) {
+      toast(e.message, 'error');
+    } finally {
+      relocating = false;
+    }
+  }
   // Reveal the save location in Explorer / Finder / the Linux file manager.
   // The bridge returns a message when it can't (e.g. the folder was deleted).
   async function openSaveFolder() {
@@ -188,7 +209,18 @@
   </div>
 {/if}
 
-{#if game.savePathMissing && !editPath}
+{#if game.savePathMissing && game.saveDriveMissing && !editPath}
+  <!-- The drive itself isn't on this device: the game lives on another PC's
+       D:\ or E:\. Nothing was lost here, so this informs rather than warns. -->
+  <div class="missing elsewhere" role="status">
+    <Info size={16} />
+    <div>
+      <strong>This game isn't on this device.</strong>
+      Its saves are on {game.savePath.slice(0, 2)}, which this PC doesn't have, so it's skipped here and keeps syncing
+      between your other devices. If it is installed here, point the game at its save folder with Edit.
+    </div>
+  </div>
+{:else if game.savePathMissing && !editPath}
   <!-- The folder is not there. It is not created again: an empty folder in
        its place would read as every file deleted, and syncing that would
        delete them on your other devices too. -->
@@ -203,6 +235,22 @@
   </div>
 {/if}
 
+{#if game.savePathMissing && game.relocateSuggestion && !editPath}
+  <!-- Offered, not taken: the same path on another drive can be an old
+       backup, and syncing from it would spread stale saves. -->
+  <div class="missing relocate" role="status">
+    <Info size={16} />
+    <div>
+      <strong>The same folder is at {game.relocateSuggestion}.</strong>
+      Is that where this game saves on this device? Only use it if it holds your current saves, not an old copy.
+      <div class="relocate-actions">
+        <button class="btn small primary" disabled={relocating} on:click={() => answerRelocation(true)}>Use this folder</button>
+        <button class="btn small ghost" disabled={relocating} on:click={() => answerRelocation(false)}>Not this one</button>
+      </div>
+    </div>
+  </div>
+{/if}
+
 <style>
   .title-row {
     display: flex;
@@ -280,6 +328,11 @@
     font-size: 0.84rem;
     color: var(--text-dim);
   }
+  .relocate-actions {
+    display: flex;
+    gap: 8px;
+    margin-top: 8px;
+  }
   .missing :global(svg) {
     flex-shrink: 0;
     margin-top: 2px;
@@ -288,6 +341,13 @@
   .missing strong {
     color: var(--text);
   }
+  .missing.elsewhere {
+    border-color: var(--border);
+    background: transparent;
+  }
+  .missing.elsewhere :global(svg) {
+    color: var(--text-faint);
+  }
   .emptied-actions {
     display: flex;
     flex-wrap: wrap;
diff --git a/internal/api/routes.go b/internal/api/routes.go
index 65a28d0c..920b1a33 100644
--- a/internal/api/routes.go
+++ b/internal/api/routes.go
@@ -65,6 +65,8 @@ func (s *Server) routes(r chi.Router) {
 	r.Post("/api/games/{gameId}/branch/switch", s.handleSwitchBranch)
 	r.Delete("/api/games/{gameId}/branch/{branch}", s.handleDeleteBranch)
 	r.Post("/api/games/{gameId}/launch", s.handleLaunchGame)
+	r.Post("/api/games/{gameId}/relocate", s.handleAcceptRelocation)
+	r.Post("/api/games/{gameId}/relocate/dismiss", s.handleDismissRelocation)
 
 	r.Post("/api/backup/export", s.handleBackupExport)
 	r.Post("/api/backup/restore", s.handleBackupRestore)
@@ -1036,3 +1038,35 @@ func (s *Server) handleSuggestName(w http.ResponseWriter, r *http.Request) {
 	}
 	writeJSON(w, http.StatusOK, map[string]string{"name": name})
 }
+
+// handleAcceptRelocation switches a game whose save folder is missing to the
+// same folder on another drive, offered to the user (relocateSuggestion).
+// body.path must be the folder offered, so an answer to an older question
+// cannot switch to a folder nobody was shown.
+func (s *Server) handleAcceptRelocation(w http.ResponseWriter, r *http.Request) {
+	gameID := chi.URLParam(r, "gameId")
+	var body struct {
+		Path string `json:"path"`
+	}
+	if err := readJSON(r, &body); err != nil || body.Path == "" {
+		writeError(w, http.StatusBadRequest, "path is required")
+		return
+	}
+	if err := s.Daemon.AcceptRelocation(gameID, body.Path); err != nil {
+		writeError(w, http.StatusConflict, err.Error())
+		return
+	}
+	s.BroadcastGamesUpdate()
+	writeJSON(w, http.StatusOK, map[string]bool{"success": true})
+}
+
+// handleDismissRelocation answers the offer with "not this one".
+func (s *Server) handleDismissRelocation(w http.ResponseWriter, r *http.Request) {
+	gameID := chi.URLParam(r, "gameId")
+	if err := s.Daemon.DismissRelocation(gameID); err != nil {
+		writeError(w, http.StatusConflict, err.Error())
+		return
+	}
+	s.BroadcastGamesUpdate()
+	writeJSON(w, http.StatusOK, map[string]bool{"success": true})
+}
diff --git a/internal/api/server.go b/internal/api/server.go
index 66a32562..0663ae75 100644
--- a/internal/api/server.go
+++ b/internal/api/server.go
@@ -567,10 +567,17 @@ func (s *Server) gamePayload(g store.Game) map[string]any {
 		// The save folder is not there — gone, moved, or on a drive not
 		// plugged in. Nothing is watched or synced for it until it is back.
 		"savePathMissing": daemon.SaveFolderMissing(g.SavePath),
-		"lastPlayedAt":    lastPlayed,
-		"playingSince":    playingSince,
-		"playtimeMs":      play.PlaytimeMs,
-		"playSessions":    play.Sessions,
+		// …and of those, the ones whose whole drive is absent here: the game
+		// lives on another device's D:\ or E:\, which is not a problem to
+		// warn about (daemon.SaveDriveMissing).
+		"saveDriveMissing": daemon.SaveFolderMissing(g.SavePath) && daemon.SaveDriveMissing(g.SavePath),
+		// The same folder found on another drive here, offered and not yet
+		// answered (daemon.RelocateSuggestion); "" when there is none.
+		"relocateSuggestion": s.Daemon.RelocateSuggestion(g.ID),
+		"lastPlayedAt":       lastPlayed,
+		"playingSince":       playingSince,
+		"playtimeMs":         play.PlaytimeMs,
+		"playSessions":       play.Sessions,
 		// Whether the game is installed on this device: "found", "not-found",
 		// or "" when there is no telling (daemon.InstallState). A game that is
 		// not here is one nobody plays here, which is why it shows no play.
diff --git a/internal/cliapp/cliapp.go b/internal/cliapp/cliapp.go
index dacaa2ac..6bdd7183 100644
--- a/internal/cliapp/cliapp.go
+++ b/internal/cliapp/cliapp.go
@@ -65,6 +65,8 @@ func Run(args []string) int {
 		return cmdConflicts(rest)
 	case "resolve":
 		return cmdResolve(rest)
+	case "relocate":
+		return cmdRelocate(rest)
 	case "offers":
 		return cmdOffers(rest)
 	case "backup":
@@ -760,12 +762,16 @@ func cmdStatus(d *daemon.Daemon, args []string) int {
 	}
 
 	playing := runningDaemonPlaying()
+	relocations := runningDaemonRelocations()
 	section(fmt.Sprintf("Tracked games %s %d", symDot(), len(games)))
 	for _, g := range games {
 		fmt.Printf("  %s %s  %s\n", symBullet(), bold(g.Name), faint(g.ID))
 		fmt.Printf("      %s\n", faint(g.SavePath))
 		if daemon.SaveFolderMissing(g.SavePath) {
 			fmt.Printf("      %s\n", warnText("save folder missing — nothing is watched or synced for it until it is back"))
+			if found := relocations[g.ID]; found != "" {
+				fmt.Printf("      %s\n", warnText(fmt.Sprintf("the same folder is at %s — use it? (opensave relocate %s use|dismiss)", found, g.ID)))
+			}
 		}
 		if e, held := d.EmptiedSaveOf(g.ID); held && e.State == "held" {
 			fmt.Printf("      %s\n", warnText(fmt.Sprintf("every save file was deleted here — not synced until you answer (opensave emptied %s delete|restore)", g.ID)))
@@ -1053,3 +1059,26 @@ func emptiedOrNil(d *daemon.Daemon, gameID string) *daemon.EmptiedSave {
 	}
 	return nil
 }
+
+// runningDaemonRelocations is, per game, the folder the running daemon offers
+// for a save folder that is missing (the same path on another drive). Empty
+// when no daemon is running: the offer lives there.
+func runningDaemonRelocations() map[string]string {
+	out := map[string]string{}
+	raw, err := daemonRequest("GET", "/api/games", nil)
+	if err != nil {
+		return out
+	}
+	var games map[string]struct {
+		RelocateSuggestion string `json:"relocateSuggestion"`
+	}
+	if json.Unmarshal(raw, &games) != nil {
+		return out
+	}
+	for id, g := range games {
+		if g.RelocateSuggestion != "" {
+			out[id] = g.RelocateSuggestion
+		}
+	}
+	return out
+}
diff --git a/internal/cliapp/commands_relocate.go b/internal/cliapp/commands_relocate.go
new file mode 100644
index 00000000..8ad029ea
--- /dev/null
+++ b/internal/cliapp/commands_relocate.go
@@ -0,0 +1,44 @@
+package cliapp
+
+import (
+	"fmt"
+	"net/url"
+	"os"
+)
+
+const relocateUsage = `usage: opensave relocate <gameId> use        use the folder offered for a missing save folder
+       opensave relocate <gameId> dismiss    not that one — it is not offered again while OpenSave runs`
+
+// cmdRelocate answers the offer the daemon makes when a game's save folder is
+// missing and the same path exists on another drive here: use that folder, or
+// not. Never switched without this answer — it could be an old copy.
+func cmdRelocate(args []string) int {
+	asJSON, args := jsonFlag(args)
+	if len(args) != 2 || (args[1] != "use" && args[1] != "dismiss") {
+		fmt.Fprintln(os.Stderr, relocateUsage)
+		return 1
+	}
+	gameID := args[0]
+	found := runningDaemonRelocations()[gameID]
+	if found == "" {
+		return fail(asJSON, fmt.Errorf("no folder is offered for %s (OpenSave must be running, and the save folder missing)", gameID))
+	}
+	path := "/api/games/" + url.PathEscape(gameID) + "/relocate"
+	var body any = map[string]string{"path": found}
+	if args[1] == "dismiss" {
+		path, body = path+"/dismiss", nil
+	}
+	raw, err := daemonRequest("POST", path, body)
+	if err != nil {
+		return fail(asJSON, err)
+	}
+	if asJSON {
+		return emitRawJSON(raw)
+	}
+	if args[1] == "use" {
+		success("%s now uses %s on this device.", bold(gameID), found)
+	} else {
+		success("Not using %s for %s.", found, bold(gameID))
+	}
+	return 0
+}
diff --git a/internal/cliapp/usage.go b/internal/cliapp/usage.go
index 33523571..8b3f032a 100644
--- a/internal/cliapp/usage.go
+++ b/internal/cliapp/usage.go
@@ -72,6 +72,7 @@ var commandGroups = []commandGroup{
 		{"storage", "Space per game, the biggest snapshots, what prune frees; --compact shares unchanged files now"},
 		{"verify [<gameId>] [--repair|--remove-damaged]", "Check every snapshot can still be restored; repair from the cloud, or remove what cannot be"},
 		{"emptied [<gameId> delete|restore]", "Saves emptied here, held back from your other devices; answer for one"},
+		{"relocate <gameId> use|dismiss", "A missing save folder found on another drive here: use it, or not"},
 		{"files <gameId> <snapId> [path]", "List a snapshot's contents, or restore one file"},
 		{"export <gameId> <dir>", "Copy the current save out to a folder"},
 		{"backup export <file.sscb>", "Write a portable backup archive"},
diff --git a/internal/daemon/daemon.go b/internal/daemon/daemon.go
index 306ce6ff..c34a83dc 100644
--- a/internal/daemon/daemon.go
+++ b/internal/daemon/daemon.go
@@ -62,6 +62,13 @@ type Daemon struct {
 	// Games whose save folder is not there; see missing.go.
 	missingMu sync.Mutex
 	missing   map[string]bool
+	// relocateChecked is when each missing save folder was last looked for on
+	// another drive (missing.go).
+	relocateChecked map[string]time.Time
+	// relocateSuggested: the folder offered for a missing one, per game;
+	// relocateDismissed: the one answered "not this one" (missing.go).
+	relocateSuggested map[string]string
+	relocateDismissed map[string]string
 
 	// Play sessions; see sessions.go.
 	sessions sessionState
diff --git a/internal/daemon/missing.go b/internal/daemon/missing.go
index aa083447..bdd44ecb 100644
--- a/internal/daemon/missing.go
+++ b/internal/daemon/missing.go
@@ -6,6 +6,8 @@ import (
 	"io/fs"
 	"os"
 	"path/filepath"
+	"strings"
+	"time"
 
 	"github.com/opensave/opensave/internal/delta"
 	"github.com/opensave/opensave/internal/logging"
@@ -34,10 +36,191 @@ func SaveFolderMissing(savePath string) bool {
 	return errors.Is(err, fs.ErrNotExist)
 }
 
+// SaveDriveMissing reports whether a save path lives on a drive this device
+// does not have at all — a D:\ or E:\ Steam library that exists on another
+// PC. That is where a game auto-tracked from a peer lands when the peer's
+// library is on a drive letter this machine lacks, and it is not something
+// to warn about: nothing was lost here, the game just isn't on this device.
+// Only a volume that is plainly absent counts; an unreachable network share
+// reports some other error and stays a warning.
+func SaveDriveMissing(savePath string) bool {
+	vol := filepath.VolumeName(savePath)
+	if vol == "" {
+		return false
+	}
+	_, err := os.Stat(vol + string(filepath.Separator))
+	return errors.Is(err, fs.ErrNotExist)
+}
+
+// The same save folder under another drive letter.
+//
+// A save inside a game's install folder — a Steam library, most often — sits
+// on whichever drive that library is on, and that differs between devices: D:
+// on one, E: on another. A game tracked on one device and auto-tracked on
+// another arrives with the first device's drive letter, and on the second the
+// folder is simply "missing" though it is right there on another drive.
+//
+// So a missing folder is looked for at the identical path on every other drive
+// letter. Exactly one match is offered, not adopted: the same path on another
+// drive can also be an old backup copy, and syncing from that would hand stale
+// saves to every device. The game shows the folder found and asks; the log says
+// so once, with the command that answers it (Daemon.AcceptRelocation,
+// DismissRelocation). None, or more than one (which would be a guess), is said
+// once too, and the search is not repeated more often than relocateRecheck: it
+// touches every drive, and the minute-long watch reconcile asks about missing
+// folders constantly.
+const relocateRecheck = time.Hour
+
+// relocateCandidates lists the folders at savePath's exact path under the other
+// drive letters that exist here. Windows drive letters only.
+func relocateCandidates(savePath string) []string {
+	vol := filepath.VolumeName(savePath)
+	if len(vol) != 2 || vol[1] != ':' {
+		return nil
+	}
+	rest := savePath[2:]
+	own := strings.ToUpper(vol[:1])
+	var found []string
+	for c := 'C'; c <= 'Z'; c++ {
+		letter := string(c)
+		if letter == own {
+			continue
+		}
+		candidate := letter + ":" + rest
+		if !SaveFolderMissing(candidate) {
+			found = append(found, candidate)
+		}
+	}
+	return found
+}
+
+// suggestOtherDrive looks for a missing save folder at the same path on the
+// other drive letters, and offers exactly one match (RelocateSuggestion) rather
+// than switching to it. Reports whether there is a suggestion now.
+func (d *Daemon) suggestOtherDrive(gameID, name, savePath string) bool {
+	d.missingMu.Lock()
+	last, checked := d.relocateChecked[gameID]
+	if checked && time.Since(last) < relocateRecheck {
+		_, suggested := d.relocateSuggested[gameID]
+		d.missingMu.Unlock()
+		return suggested
+	}
+	if d.relocateChecked == nil {
+		d.relocateChecked = map[string]time.Time{}
+	}
+	d.relocateChecked[gameID] = time.Now()
+	d.missingMu.Unlock()
+
+	if name == "" {
+		name = gameID
+	}
+	found := relocateCandidates(savePath)
+	switch {
+	case len(found) == 0:
+		if !checked {
+			d.Log.Log("info", fmt.Sprintf("the save folder of %q is not on another drive here either (looked for %s on every drive letter)",
+				name, logging.Quote(savePath[min(2, len(savePath)):])))
+		}
+		return false
+	case len(found) > 1:
+		if !checked {
+			d.Log.Log("warn", fmt.Sprintf("the save folder of %q is missing at %s, and the same path exists on %d other drives (%s) — not guessing which; set it with Edit",
+				name, logging.Quote(savePath), len(found), strings.Join(found, ", ")))
+		}
+		return false
+	}
+
+	d.missingMu.Lock()
+	defer d.missingMu.Unlock()
+	if strings.EqualFold(d.relocateDismissed[gameID], found[0]) {
+		return false // the user said this one is not it
+	}
+	if strings.EqualFold(d.relocateSuggested[gameID], found[0]) {
+		return true // offered already
+	}
+	if d.relocateSuggested == nil {
+		d.relocateSuggested = map[string]string{}
+	}
+	d.relocateSuggested[gameID] = found[0]
+	d.Log.Log("warn", fmt.Sprintf("the save folder of %q is not at %s, but the same folder exists at %s on this device. "+
+		"It is not used until you confirm it is the right one (it could be an old copy): open the game in OpenSave, "+
+		"or run `opensave relocate %s use` (or `dismiss`)",
+		name, logging.Quote(savePath), logging.Quote(found[0]), gameID))
+	return true
+}
+
+// RelocateSuggestion is the folder offered for a game whose save folder is
+// missing — the same path on another drive — or "" when there is none.
+func (d *Daemon) RelocateSuggestion(gameID string) string {
+	d.missingMu.Lock()
+	defer d.missingMu.Unlock()
+	return d.relocateSuggested[gameID]
+}
+
+// AcceptRelocation switches a game to the folder offered for it. path must be
+// the one offered, so an answer to an older question does not switch to a
+// folder nobody was shown.
+func (d *Daemon) AcceptRelocation(gameID, path string) error {
+	d.missingMu.Lock()
+	offered := d.relocateSuggested[gameID]
+	d.missingMu.Unlock()
+	if offered == "" || !strings.EqualFold(offered, path) {
+		return fmt.Errorf("no folder is offered for this game at %s", path)
+	}
+	newPath, err := d.ValidateSavePath(offered)
+	if err != nil {
+		return fmt.Errorf("the folder at %s cannot be used: %w", offered, err)
+	}
+	game, err := d.Store.GetGame(gameID)
+	if err != nil {
+		return err
+	}
+	old := game.SavePath
+	game.SavePath = newPath
+	if err := d.Store.UpdateGame(game); err != nil {
+		return fmt.Errorf("could not switch %q to %s: %w", game.Name, newPath, err)
+	}
+	d.missingMu.Lock()
+	delete(d.relocateSuggested, gameID)
+	delete(d.missing, gameID)
+	d.missingMu.Unlock()
+	d.Log.Log("success", fmt.Sprintf("the save folder of %q is now %s on this device, as confirmed (it was %s)",
+		game.Name, logging.Quote(newPath), logging.Quote(old)))
+	if d.OnGameChanged != nil {
+		d.OnGameChanged(gameID)
+	}
+	return nil
+}
+
+// DismissRelocation answers the offer for a game with "not this one": that
+// folder is not offered again for it while OpenSave runs.
+func (d *Daemon) DismissRelocation(gameID string) error {
+	d.missingMu.Lock()
+	offered := d.relocateSuggested[gameID]
+	if offered == "" {
+		d.missingMu.Unlock()
+		return fmt.Errorf("no folder is offered for this game")
+	}
+	delete(d.relocateSuggested, gameID)
+	if d.relocateDismissed == nil {
+		d.relocateDismissed = map[string]string{}
+	}
+	d.relocateDismissed[gameID] = offered
+	d.missingMu.Unlock()
+	d.Log.Log("info", fmt.Sprintf("not using %s for %s, as answered; set the save folder with Edit if it is elsewhere",
+		logging.Quote(offered), gameID))
+	return nil
+}
+
 // noteMissing records whether a game's save folder is missing, and says so
 // once when that changes — not on every minute's check — so the log and the
 // screen follow the folder going and coming back.
 func (d *Daemon) noteMissing(gameID, name, savePath string, missing bool) {
+	if missing {
+		// Offered, not switched to: the game stays missing until someone says
+		// the folder found is the right one (suggestOtherDrive).
+		d.suggestOtherDrive(gameID, name, savePath)
+	}
 	d.missingMu.Lock()
 	was := d.missing[gameID]
 	if missing {
@@ -47,6 +230,7 @@ func (d *Daemon) noteMissing(gameID, name, savePath string, missing bool) {
 		d.missing[gameID] = true
 	} else {
 		delete(d.missing, gameID)
+		delete(d.relocateSuggested, gameID) // back where it was: nothing to offer
 	}
 	d.missingMu.Unlock()
 	if was == missing {
@@ -55,7 +239,10 @@ func (d *Daemon) noteMissing(gameID, name, savePath string, missing bool) {
 	if name == "" {
 		name = gameID
 	}
-	if missing {
+	if missing && SaveDriveMissing(savePath) {
+		d.Log.Log("info", fmt.Sprintf("the save folder of %q is on %s, which this device doesn't have (%s) — the game is skipped here "+
+			"and keeps syncing between the devices that have it", name, filepath.VolumeName(savePath), logging.Quote(savePath)))
+	} else if missing {
 		d.Log.Log("warn", fmt.Sprintf("the save folder of %q is not there (%s) — it is not watched or synced until it is back; "+
 			"OpenSave will not create it, since an empty folder in its place would read as every file deleted", name, logging.Quote(savePath)))
 	} else {
diff --git a/internal/daemon/missing_test.go b/internal/daemon/missing_test.go
new file mode 100644
index 00000000..0b5fdf6c
--- /dev/null
+++ b/internal/daemon/missing_test.go
@@ -0,0 +1,40 @@
+package daemon
+
+import (
+	"os"
+	"path/filepath"
+	"runtime"
+	"testing"
+)
+
+// A save path on a drive letter this machine does not have is "not on this
+// device", not "folder gone": the UI informs rather than warns about it.
+func TestSaveDriveMissing(t *testing.T) {
+	existing := t.TempDir()
+	if SaveDriveMissing(filepath.Join(existing, "saves")) {
+		t.Error("a folder on an existing drive was reported as on a missing drive")
+	}
+	if SaveDriveMissing("relative/path") {
+		t.Error("a path without a volume was reported as on a missing drive")
+	}
+
+	if runtime.GOOS != "windows" {
+		return
+	}
+	// Find a drive letter that is not mounted.
+	for c := 'Z'; c >= 'D'; c-- {
+		root := string(c) + `:\`
+		if _, err := os.Stat(root); err == nil {
+			continue
+		}
+		p := string(c) + `:\SteamLibrary\steamapps\common\Game\save`
+		if !SaveDriveMissing(p) {
+			t.Errorf("%s: drive %c: is absent but was not reported missing", p, c)
+		}
+		if !SaveFolderMissing(p) {
+			t.Errorf("%s: SaveFolderMissing should still report the folder missing", p)
+		}
+		return
+	}
+	t.Skip("every drive letter D-Z is mounted")
+}
diff --git a/internal/daemon/relocate_test.go b/internal/daemon/relocate_test.go
new file mode 100644
index 00000000..f9941f9c
--- /dev/null
+++ b/internal/daemon/relocate_test.go
@@ -0,0 +1,136 @@
+package daemon
+
+import (
+	"os"
+	"path/filepath"
+	"runtime"
+	"strings"
+	"testing"
+
+	"github.com/opensave/opensave/internal/store"
+)
+
+// freeDriveLetter returns a drive letter not mounted here, or "".
+func freeDriveLetter() string {
+	for c := 'Z'; c >= 'D'; c-- {
+		if _, err := os.Stat(string(c) + `:\`); err != nil {
+			return string(c)
+		}
+	}
+	return ""
+}
+
+// A game tracked elsewhere with its save on a drive this device lacks, while
+// the identical path exists on another drive here: the folder is offered, not
+// switched to — it could be an old copy — and the game is switched only when
+// the user accepts that folder.
+func TestRelocateToOtherDrive_IsOfferedThenAccepted(t *testing.T) {
+	if runtime.GOOS != "windows" {
+		t.Skip("drive letters are a Windows thing")
+	}
+	free := freeDriveLetter()
+	if free == "" {
+		t.Skip("no free drive letter")
+	}
+	d := newTestDaemon(t)
+	real := filepath.Join(t.TempDir(), "SteamLibrary", "steamapps", "common", "Game", "save")
+	if err := os.MkdirAll(real, 0o777); err != nil {
+		t.Fatal(err)
+	}
+	elsewhere := free + ":" + real[2:] // same path, absent drive
+	if err := d.Store.CreateGame(store.Game{ID: "g", Name: "Game", SavePath: elsewhere, ActiveBranch: "main", AutoSync: true}); err != nil {
+		t.Fatal(err)
+	}
+
+	d.noteMissing("g", "Game", elsewhere, true)
+
+	g, _ := d.Store.GetGame("g")
+	if g.SavePath != elsewhere {
+		t.Fatalf("save path switched to %s without asking", g.SavePath)
+	}
+	if got := d.RelocateSuggestion("g"); !strings.EqualFold(got, real) {
+		t.Fatalf("offered %q, want %s", got, real)
+	}
+	d.missingMu.Lock()
+	missing := d.missing["g"]
+	d.missingMu.Unlock()
+	if !missing {
+		t.Error("the game is not marked missing while the offer is open")
+	}
+
+	if err := d.AcceptRelocation("g", `C:\somewhere\else`); err == nil {
+		t.Error("accepted a folder that was not the one offered")
+	}
+	if err := d.AcceptRelocation("g", real); err != nil {
+		t.Fatal(err)
+	}
+	g, _ = d.Store.GetGame("g")
+	if !strings.EqualFold(g.SavePath, real) {
+		t.Fatalf("save path = %s after accepting, want %s", g.SavePath, real)
+	}
+	if d.RelocateSuggestion("g") != "" {
+		t.Error("still offered after being accepted")
+	}
+}
+
+// "Not this one": the folder is not offered again.
+func TestRelocateToOtherDrive_Dismissed(t *testing.T) {
+	if runtime.GOOS != "windows" {
+		t.Skip("drive letters are a Windows thing")
+	}
+	free := freeDriveLetter()
+	if free == "" {
+		t.Skip("no free drive letter")
+	}
+	d := newTestDaemon(t)
+	real := filepath.Join(t.TempDir(), "Backup", "Game", "save")
+	if err := os.MkdirAll(real, 0o777); err != nil {
+		t.Fatal(err)
+	}
+	elsewhere := free + ":" + real[2:]
+	if err := d.Store.CreateGame(store.Game{ID: "b", Name: "Backup Game", SavePath: elsewhere, ActiveBranch: "main", AutoSync: true}); err != nil {
+		t.Fatal(err)
+	}
+	d.noteMissing("b", "Backup Game", elsewhere, true)
+	if d.RelocateSuggestion("b") == "" {
+		t.Fatal("setup: nothing offered")
+	}
+	if err := d.DismissRelocation("b"); err != nil {
+		t.Fatal(err)
+	}
+	d.missingMu.Lock()
+	delete(d.relocateChecked, "b") // as if relocateRecheck had passed
+	d.missingMu.Unlock()
+	d.noteMissing("b", "Backup Game", elsewhere, true)
+	if got := d.RelocateSuggestion("b"); got != "" {
+		t.Errorf("offered %s again after it was dismissed", got)
+	}
+	g, _ := d.Store.GetGame("b")
+	if g.SavePath != elsewhere {
+		t.Errorf("save path changed to %s", g.SavePath)
+	}
+}
+
+// Not found: said once, and not searched again on every reconcile.
+func TestRelocateNotFound_IsNotRepeated(t *testing.T) {
+	if runtime.GOOS != "windows" {
+		t.Skip("drive letters are a Windows thing")
+	}
+	free := freeDriveLetter()
+	if free == "" {
+		t.Skip("no free drive letter")
+	}
+	d := newTestDaemon(t)
+	path := free + `:\NoSuchLibrary\steamapps\common\Nothing\save`
+	if err := d.Store.CreateGame(store.Game{ID: "n", Name: "Nothing", SavePath: path, ActiveBranch: "main", AutoSync: true}); err != nil {
+		t.Fatal(err)
+	}
+	if d.suggestOtherDrive("n", "Nothing", path) {
+		t.Fatal("relocated to a folder that does not exist")
+	}
+	first := d.relocateChecked["n"]
+	d.suggestOtherDrive("n", "Nothing", path)
+	if !d.relocateChecked["n"].Equal(first) {
+		t.Error("searched again straight away; it should wait relocateRecheck")
+	}
+}