rewind.patch

diff --git a/forge-game/src/main/java/forge/game/Game.java b/forge-game/src/main/java/forge/game/Game.java
index 3456a071..124936e8 100644
--- a/forge-game/src/main/java/forge/game/Game.java
+++ b/forge-game/src/main/java/forge/game/Game.java
@@ -55,6 +55,7 @@ import org.tinylog.Logger;
 import org.tinylog.TaggedLogger;
 
 import java.util.*;
+import java.util.function.BiConsumer;
 import java.util.function.Predicate;
 
 /**
@@ -103,6 +104,60 @@ public class Game {
 
     // If this merges with LKI In the future, it will need to change forms
     private GameSnapshot previousGameState = null;
+
+    /**
+     * Rewind points, newest first. One is taken at the start of each human player's own
+     * turn — see stashTurnRewindPoint for why that particular moment.
+     */
+    private final Deque<RewindPoint> turnRewindPoints = new ArrayDeque<>();
+
+    /** How many of their own turns a player may rewind. Set by the Match from the preferences. */
+    public int REWIND_STEPS = 3;
+
+    /**
+     * Called with (turn, state text) whenever a rewind point is taken, so the position can
+     * also be put on disk. Set from the GUI side, which is what knows about folders; null
+     * in tests and on servers. A rewind point already exists in memory at that moment, so
+     * this costs nothing beyond the write itself.
+     */
+    private BiConsumer<Integer, List<String>> rewindAutosave = null;
+
+    public void setRewindAutosave(final BiConsumer<Integer, List<String>> hook) {
+        rewindAutosave = hook;
+    }
+
+    /**
+     * A rewind point is the game written out in Forge's own save format, the same one
+     * puzzles and saved games use. Stored as text rather than as a parsed GameState so it
+     * cannot hold on to live objects from the game it was taken in.
+     */
+    private static final class RewindPoint {
+        private final List<String> stateText;
+        /** Turn and priority bookkeeping that the save format itself does not carry. */
+        private final PhaseHandler.PriorityState priorityState;
+        /**
+         * Emblems and the hidden helper cards behind lasting effects ("for the rest of the
+         * game", "you have no maximum hand size"). The save format can only name printed
+         * cards, so these would be dropped; the point holds on to the objects instead.
+         */
+        private final List<Pair<Card, Player>> commandEffects;
+        /** Whose turn this point is the start of; only that player is offered it. */
+        private final Player player;
+        private final int turn;
+
+        private RewindPoint(List<String> stateText, PhaseHandler.PriorityState priorityState,
+                List<Pair<Card, Player>> commandEffects, Player player, int turn) {
+            this.stateText = stateText;
+            this.priorityState = priorityState;
+            this.commandEffects = commandEffects;
+            this.player = player;
+            this.turn = turn;
+        }
+
+        private String describe() {
+            return String.valueOf(turn);
+        }
+    }
     private CardCollection lastStateBattlefield = new CardCollection();
     private CardCollection lastStateGraveyard = new CardCollection();
 
@@ -215,6 +270,190 @@ public class Game {
         return true;
     }
 
+    /**
+     * Remember where this turn started, if this is the right moment for it.
+     *
+     * The save format carries no "until end of turn" effects and no running combat, so a
+     * point taken mid-turn would always be missing something. The start of a player's own
+     * turn is the one moment where that does not matter: the previous turn's temporary
+     * effects have already worn off in its cleanup step, no combat is running, and by the
+     * first main phase the upkeep and draw triggers have finished resolving. Hence the
+     * conditions below — own turn, first main phase, empty stack, and only once per turn.
+     */
+    public void stashTurnRewindPoint(Player p) {
+        if (REWIND_STEPS < 1 || p == null) {
+            return;
+        }
+        if (p != phaseHandler.getPlayerTurn() || phaseHandler.getPhase() != PhaseType.MAIN1) {
+            return;
+        }
+        if (!stack.isEmpty() || stack.isFrozen()) {
+            return;
+        }
+        final RewindPoint newest = turnRewindPoints.peekFirst();
+        if (newest != null && newest.player == p && newest.turn == phaseHandler.getTurn()) {
+            return; // already have this turn, including right after rewinding back into it
+        }
+
+        final GameState state = new GameState();
+        try {
+            state.initFromGame(this);
+        } catch (Exception e) {
+            Logger.warn(e, "Could not record a rewind point for turn {}", phaseHandler.getTurn());
+            return;
+        }
+        final List<String> stateText = Arrays.asList(state.toString().split("\n"));
+        turnRewindPoints.addFirst(new RewindPoint(stateText,
+                phaseHandler.capturePriorityState(), collectCommandEffects(), p, phaseHandler.getTurn()));
+
+        if (rewindAutosave != null) {
+            try {
+                rewindAutosave.accept(phaseHandler.getTurn(), stateText);
+            } catch (Exception e) {
+                // A full disk must never cost anyone their turn.
+                Logger.warn(e, "Could not autosave turn {}", phaseHandler.getTurn());
+            }
+        }
+
+        // Trim per player, so a second human at the table cannot push someone else's
+        // points out of the list before they have used up their own allowance.
+        int mine = 0;
+        for (Iterator<RewindPoint> it = turnRewindPoints.iterator(); it.hasNext();) {
+            if (it.next().player == p && ++mine > REWIND_STEPS) {
+                it.remove();
+            }
+        }
+    }
+
+    /**
+     * The cards in the command zone that the save format cannot describe, because it can
+     * only write down printed cards and tokens. Emblems and the helper cards that carry
+     * lasting effects are neither, so applying a state silently drops them — see the
+     * paper card check in GameState#addCard. Keeping the objects themselves lets a rewind
+     * put back exactly the ones that existed at that moment.
+     */
+    private List<Pair<Card, Player>> collectCommandEffects() {
+        final List<Pair<Card, Player>> out = Lists.newArrayList();
+        for (final Player p : getPlayers()) {
+            for (final Card c : p.getZone(ZoneType.Command).getCards()) {
+                if (c.getPaperCard() == null && !c.isToken()) {
+                    out.add(Pair.of(c, p));
+                }
+            }
+        }
+        return out;
+    }
+
+    /**
+     * Short description of each rewind point available to this player, newest first, so a
+     * menu can say where a step leads instead of just how far.
+     */
+    public List<String> describeRewindPoints(Player p) {
+        List<String> out = Lists.newArrayList();
+        for (RewindPoint point : turnRewindPoints) {
+            if (point.player == p) {
+                out.add(point.describe());
+            }
+        }
+        return out;
+    }
+
+    /** Drops the rewind history, e.g. after loading a save — it belongs to another game. */
+    public void clearRewindPoints() {
+        turnRewindPoints.clear();
+    }
+
+    /**
+     * How many of this player's own turns can still be rewound to. Never more than
+     * REWIND_STEPS, and less than that in the opening turns of a game.
+     */
+    public int getAvailableRewindSteps(Player p) {
+        int found = 0;
+        for (RewindPoint point : turnRewindPoints) {
+            if (point.player == p) {
+                found++;
+            }
+        }
+        return found;
+    }
+
+    /**
+     * Rewind the whole game to the start of this player's n-th most recent own turn,
+     * discarding everything that happened since — including other players' and the AI's
+     * moves, which get played out again from there.
+     *
+     * @param steps 1 = back to the start of the current or last own turn, 2 = the one before it, ...
+     * @return true if a matching rewind point was found and restored
+     */
+    public boolean rewindToActionOf(Player p, int steps) {
+        if (steps < 1 || steps > REWIND_STEPS) {
+            return false;
+        }
+
+        int found = 0;
+        for (RewindPoint point : turnRewindPoints) { // newest first
+            if (point.player != p || ++found < steps) {
+                continue;
+            }
+            final GameState state = new GameState();
+            try {
+                state.parse(point.stateText);
+                // Applying a state only adds the spells it recorded, it never clears what
+                // is there — so anything in flight when the rewind was asked for would
+                // survive it. A turn is starting over: nothing may be waiting to resolve.
+                stack.clearSimultaneousStack();
+                stack.clearFrozen();
+                stack.clearUndoStack();
+                stack.clear();
+                state.applyToGame(this);
+            } catch (Exception e) {
+                Logger.error(e, "Rewind to turn {} failed", point.turn);
+                return false;
+            }
+            phaseHandler.restorePriorityState(point.priorityState);
+            restoreCommandEffects(point);
+            // Everything newer than the target is gone for good — you can't redo a rewind.
+            while (turnRewindPoints.peekFirst() != point) {
+                turnRewindPoints.removeFirst();
+            }
+            fireEvent(new GameEventAddLog(GameLogEntryType.INFORMATION,
+                    p + " rewound the game to turn " + point.turn + "."));
+            return true;
+        }
+        return false;
+    }
+
+    /**
+     * Puts back the emblems and lasting-effect helper cards the state could not carry.
+     * Applying a state empties the command zone, so anything created after the point is
+     * already gone and only what belongs there is added back.
+     */
+    private void restoreCommandEffects(RewindPoint point) {
+        for (final Pair<Card, Player> entry : point.commandEffects) {
+            final Zone zone = entry.getRight().getZone(ZoneType.Command);
+            final Card effect = entry.getLeft();
+            // Applying the state rebuilds a few of these itself — the commander, speed and
+            // adventure effects among them — and the rebuilt one is the better copy,
+            // because it points at the cards the state just created. An Adventure reminder
+            // is named after the adventure half, so it will not match by name.
+            if (zone.contains(effect) || hasEffectNamed(zone, effect.getName())
+                    || effect.getName().endsWith("'s Adventure")) {
+                continue;
+            }
+            zone.add(effect);
+        }
+        action.checkStateEffects(true);
+    }
+
+    private static boolean hasEffectNamed(Zone zone, String name) {
+        for (final Card c : zone.getCards()) {
+            if (c.getPaperCard() == null && c.getName().equals(name)) {
+                return true;
+            }
+        }
+        return false;
+    }
+
     public void copyLastState() {
         lastStateBattlefield.clear();
         lastStateGraveyard.clear();
diff --git a/forge-game/src/main/java/forge/game/GameActionUtil.java b/forge-game/src/main/java/forge/game/GameActionUtil.java
index 432477be..a666743a 100644
--- a/forge-game/src/main/java/forge/game/GameActionUtil.java
+++ b/forge-game/src/main/java/forge/game/GameActionUtil.java
@@ -944,6 +944,20 @@ public final class GameActionUtil {
             // If we're able to restore the whole game state when rolling back an ability don't try to manually roll back
             System.out.println("Restored state from snapshot! Rolled back: " + ability.getHostCard().getName() + " - " + ability.getActivatingPlayer());
 
+            // The snapshot covers the cards, their zones and the mana pool, so the manual
+            // rollback below and its refund would double up on it. The ability is not part of
+            // the snapshot though, and neither is the frozen stack: without the cleanup an
+            // announced value or a chosen target survives into the next attempt to cast the
+            // card, and the stack stays frozen.
+            Card restored = game.getCardState(oldCard, null);
+            if (restored != null) {
+                restored.setCastSA(null);
+                restored.setCastFrom(null);
+            }
+            resetAnnouncedCosts(ability);
+            resetChosenTargets(ability);
+            game.getStack().clearFrozen();
+            game.getTriggerHandler().clearWaitingTriggers();
             return;
         }
 
@@ -964,18 +978,7 @@ public final class GameActionUtil {
             Integer newPosition = zonePosition >= 0 ? Math.min(zonePosition, fromZone.size()) : null;
             fromZone.add(oldCard, newPosition, null, true);
             ability.setHostCard(oldCard);
-            ability.setXManaCostPaid(null);
-            ability.setSpendPhyrexianMana(false);
-            ability.clearPipsToReduce();
-            ability.setPaidLife(0);
-            if (ability.hasParam("Announce")) {
-                for (final String aVar : ability.getParam("Announce").split(",")) {
-                    final String varName = aVar.trim();
-                    if (!varName.equals("X")) {
-                        ability.setSVar(varName, "0");
-                    }
-                }
-            }
+            resetAnnouncedCosts(ability);
             // better safe than sorry approach in case rolled back ability was copy (from addExtraKeywordCost)
             for (SpellAbility sa : oldCard.getSpells()) {
                 sa.setHostCard(oldCard);
@@ -996,6 +999,30 @@ public final class GameActionUtil {
             }
         }
 
+        resetChosenTargets(ability);
+        payment.refundPayment();
+        game.getStack().clearFrozen();
+        game.getTriggerHandler().clearWaitingTriggers();
+    }
+
+    /** Values the player announced or committed to while casting, which a snapshot does not hold. */
+    private static void resetAnnouncedCosts(SpellAbility ability) {
+        ability.setXManaCostPaid(null);
+        ability.setSpendPhyrexianMana(false);
+        ability.clearPipsToReduce();
+        ability.setPaidLife(0);
+        if (ability.hasParam("Announce")) {
+            for (final String aVar : ability.getParam("Announce").split(",")) {
+                final String varName = aVar.trim();
+                if (!varName.equals("X")) {
+                    ability.setSVar(varName, "0");
+                }
+            }
+        }
+    }
+
+    /** Modes and targets picked while casting, likewise not covered by a snapshot. */
+    private static void resetChosenTargets(SpellAbility ability) {
         if (ability.getApi() == ApiType.Charm) {
             // reset chain
             ability.setSubAbility(null);
@@ -1005,9 +1032,6 @@ public final class GameActionUtil {
         ability.clearTargets();
 
         ability.resetOnceResolved();
-        payment.refundPayment();
-        game.getStack().clearFrozen();
-        game.getTriggerHandler().clearWaitingTriggers();
     }
 
 }
diff --git a/forge-game/src/main/java/forge/game/GameSnapshot.java b/forge-game/src/main/java/forge/game/GameSnapshot.java
index d74b5ca1..b3193c76 100644
--- a/forge-game/src/main/java/forge/game/GameSnapshot.java
+++ b/forge-game/src/main/java/forge/game/GameSnapshot.java
@@ -14,6 +14,7 @@ import forge.game.spellability.SpellAbility;
 import forge.game.spellability.SpellAbilityStackInstance;
 import forge.game.trigger.TriggerType;
 import forge.game.zone.PlayerZoneBattlefield;
+import forge.game.zone.Zone;
 import forge.game.zone.ZoneType;
 
 import java.util.Collections;
@@ -298,7 +299,12 @@ public class GameSnapshot {
 
         for(Card fromCard : fromGame.getCardsInGame()) {
             Card newCard = toGame.findById(fromCard.getId());
-            Player toPlayer = findBy(toGame, fromCard.getController());
+            // Zones belong to a player: the controller's battlefield, but the owner's
+            // graveyard, hand and library. Going by the controller alone files a card whose
+            // control has changed under the wrong player, so a stolen creature that died
+            // reappears in the thief's graveyard when the snapshot is used.
+            Player fromZonePlayer = fromCard.getZone().getPlayer();
+            Player toPlayer = findBy(toGame, fromZonePlayer != null ? fromZonePlayer : fromCard.getController());
             ZoneType fromType = fromCard.getZone().getZoneType();
             int zonePosition = 0;
             if (ZoneType.ORDERED_ZONES.contains(fromType)) {
@@ -308,16 +314,19 @@ public class GameSnapshot {
             }
 
             if (newCard == null) {
-                // Storing a game uses this path...
-                newCard = createCardCopy(toGame, toPlayer, fromCard);
+                // Storing a game uses this path... the copy keeps the original owner, which
+                // is not the same player as the one whose zone it currently sits in.
+                newCard = createCardCopy(toGame, findBy(toGame, fromCard.getOwner()), fromCard);
             } else {
-                ZoneType type = newCard.getZone().getZoneType();
-                if (type != fromType) {
-                    if (type.equals(ZoneType.Stack)) {
-                        toGame.getStackZone().remove(newCard);
-                    } else {
-                        toPlayer.getZone(type).remove(newCard);
-                    }
+                // Take it out of wherever it currently is, unless that is already the zone
+                // it is going into. Comparing zone types alone misses a move between two
+                // players' battlefields — a creature stolen after the snapshot was taken
+                // then ends up in both of them.
+                Zone currentZone = newCard.getZone();
+                Zone targetZone = fromType.equals(ZoneType.Stack)
+                        ? toGame.getStackZone() : toPlayer.getZone(fromType);
+                if (currentZone != null && currentZone != targetZone) {
+                    currentZone.remove(newCard);
                 }
             }
 
@@ -334,6 +343,19 @@ public class GameSnapshot {
             setCardInCopiedGame(toGame, ue.toPlayer, ue.fromCard, ue.newCard, ue.fromType, ue.zonePosition);
         }
 
+        // Cards the current game has but the snapshot does not: tokens, copies and effect
+        // cards that came into being after it was taken. There is no earlier state to put
+        // them back into, so they leave the game — and the loops below would otherwise look
+        // them up in the snapshot and find nothing.
+        for (Card extraCard : toGame.getCardsInGame()) {
+            if (fromGame.findById(extraCard.getId()) == null) {
+                Zone zone = extraCard.getZone();
+                if (zone != null) {
+                    zone.remove(extraCard);
+                }
+            }
+        }
+
         // This loop happens later to make sure all cards are in the correct zone first
         for (Card newCard : toGame.getCardsIn(ZoneType.Battlefield)) {
             Card fromCard = fromGame.findById(newCard.getId());
@@ -346,6 +368,10 @@ public class GameSnapshot {
                     newAttachedTo.addAttachedCard(newCard);
                 }
             }
+            // Melded or not, the front half has to point at what the snapshot had — the two
+            // halves are one permanent, and a stale link outlives the meld otherwise.
+            newCard.setMeldedWith(fromCard.getMeldedWith() == null ? null
+                    : toGame.findById(fromCard.getMeldedWith().getId()));
             if (fromCard.getCloneOrigin() != null) {
                 newCard.setCloneOrigin(toGame.findById(fromCard.getCloneOrigin().getId()));
             }
@@ -377,7 +403,20 @@ public class GameSnapshot {
         if (fromType.equals(ZoneType.Stack)) {
             toGame.getStackZone().add(newCard);
             newCard.setZone(toGame.getStackZone());
+        } else if (isMelded(fromCard)) {
+            // The back half of a meld lives in the battlefield zone but in its own
+            // collection rather than the card list. Putting it in the list instead would
+            // leave it on the battlefield as a permanent of its own.
+            PlayerZoneBattlefield battlefield = (PlayerZoneBattlefield) toPlayer.getZone(ZoneType.Battlefield);
+            if (newCard.getZone() == null) {
+                newCard.setZone(battlefield);
+            }
+            battlefield.addToMelded(newCard);
         } else {
+            // It may have been melded in the state we are leaving behind.
+            if (toPlayer.getZone(ZoneType.Battlefield) instanceof PlayerZoneBattlefield battlefield) {
+                battlefield.removeFromMelded(newCard);
+            }
             toPlayer.getZone(fromType).add(newCard);
             newCard.setZone(toPlayer.getZone(fromType));
         }
@@ -389,11 +428,25 @@ public class GameSnapshot {
         newCard.setFaceDown(fromCard.isFaceDown());
         newCard.setManifested(fromCard.getManifestedSA());
         newCard.setSickness(fromCard.hasSickness());
-        //newCard.setForetold(fromCard.isForetold());
-        //newCard.setForetoldCostByEffect(fromCard.isForetoldCostByEffect());
+        // Who controls a card is state of its own. A creature stolen after the snapshot was
+        // taken stays with the thief otherwise: its zone is corrected, but the card still
+        // names the thief as controller, so it keeps playing for them.
+        Player fromController = findBy(toGame, fromCard.getController());
+        if (fromController != null && fromController != newCard.getController()) {
+            newCard.setController(fromController, toGame.getNextTimestamp());
+        }
+        newCard.setForetold(fromCard.isForetold());
+        newCard.setForetoldCostByEffect(fromCard.isForetoldCostByEffect());
+        newCard.setBackSide(fromCard.isBackSide());
         newCard.setState(fromCard.getCurrentStateName(), false);
     }
 
+    /** The back half of a meld: on the battlefield, but held apart from its card list. */
+    private static boolean isMelded(Card c) {
+        return c.getZone() instanceof PlayerZoneBattlefield battlefield
+                && battlefield.getMeldedCards().contains(c);
+    }
+
     private static SpellAbility findSAInCard(SpellAbility sa, Card c) {
         String saDesc = sa.getDescription();
         for (SpellAbility cardSa : c.getAllSpellAbilities()) {
diff --git a/forge-game/src/main/java/forge/game/GameState.java b/forge-game/src/main/java/forge/game/GameState.java
index 38039ad1..97915de6 100644
--- a/forge-game/src/main/java/forge/game/GameState.java
+++ b/forge-game/src/main/java/forge/game/GameState.java
@@ -70,6 +70,12 @@ public class GameState {
 
     private final Map<Integer, Card> idToCard = new HashMap<>();
     private final Map<Card, Integer> cardToAttachId = new HashMap<>();
+    /**
+     * Cards on an Adventure. Their permission effect goes into the command zone, which is
+     * set up after exile, so creating it while reading the exile zone would only see it
+     * wiped again — it has to wait until every zone is in place.
+     */
+    private final List<Card> cardsOnAdventure = new ArrayList<>();
     private final Map<Card, Player> cardToEnchantPlayerId = new HashMap<>();
     private final Map<Card, Integer> markedDamage = new HashMap<>();
     private final Map<Card, List<String>> cardToChosenClrs = new HashMap<>();
@@ -588,6 +594,7 @@ public class GameState {
         }
 
         idToCard.clear();
+        cardsOnAdventure.clear();
         cardToAttachId.clear();
         cardToEnchantPlayerId.clear();
         cardToRememberedId.clear();
@@ -617,6 +624,7 @@ public class GameState {
         for (int i = 0; i < playerStates.size(); i++) {
             setupPlayerState(game.getPlayers().get(i), playerStates.get(i));
         }
+        handleAdventures();
         handleCardAttachments();
         handleChosenEntities();
         handleRememberedEntities();
@@ -1054,6 +1062,18 @@ public class GameState {
         }
     }
 
+    /**
+     * Gives back the permission that keeps a card on an Adventure castable while it waits
+     * in exile, built from the same definition the game itself uses.
+     */
+    private void handleAdventures() {
+        for (final Card c : cardsOnAdventure) {
+            final SpellAbility sa = CardFactoryUtil.makeAdventureEffect(c.getState(CardStateName.Secondary));
+            sa.setActivatingPlayer(c.getOwner());
+            sa.resolve();
+        }
+    }
+
     private void handleCardAttachments() {
         // Unattach all permanents first
         for (Entry<Card, Integer> entry : cardToAttachId.entrySet()) {
@@ -1334,14 +1354,7 @@ public class GameState {
                     c.setBackSide(true);
                 }
                 else if (info.startsWith("OnAdventure")) {
-                    String abAdventure = "DB$ Effect | RememberObjects$ Self | StaticAbilities$ Play | ForgetOnMoved$ Exile | Duration$ Permanent | ConditionDefined$ Self | ConditionPresent$ Card.!copiedSpell";
-                    SpellAbility saAdventure = AbilityFactory.getAbility(abAdventure, c);
-                    StringBuilder sbPlay = new StringBuilder();
-                    sbPlay.append("Mode$ Continuous | MayPlay$ True | EffectZone$ Command | Affected$ Card.IsRemembered+nonAdventure");
-                    sbPlay.append(" | AffectedZone$ Exile | Description$ You may cast the card.");
-                    saAdventure.setSVar("Play", sbPlay.toString());
-                    saAdventure.setActivatingPlayer(c.getOwner());
-                    saAdventure.resolve();
+                    cardsOnAdventure.add(c);
                     c.setExiledWith(c); // This seems to be the way it's set up internally. Potentially not needed here?
                     c.setExiledBy(c.getController());
                 } else if (info.startsWith("IsCommander")) {
diff --git a/forge-game/src/main/java/forge/game/card/CardFactoryUtil.java b/forge-game/src/main/java/forge/game/card/CardFactoryUtil.java
index 545242b9..a42a922b 100644
--- a/forge-game/src/main/java/forge/game/card/CardFactoryUtil.java
+++ b/forge-game/src/main/java/forge/game/card/CardFactoryUtil.java
@@ -4062,6 +4062,22 @@ public class CardFactoryUtil {
 
         SpellAbility saExile = AbilityFactory.getAbility(abExile, card);
 
+        saExile.setSubAbility(makeAdventureEffect(card));
+
+        ReplacementEffect re = ReplacementHandler.parseReplacement(repeffstr, card.getCard(), true);
+
+        re.setOverridingAbility(saExile);
+        return re;
+    }
+
+    /**
+     * The effect that keeps a card on an Adventure castable while it sits in exile.
+     *
+     * Also needed when a game state is loaded, because the card comes back in exile with
+     * nothing to grant that permission. Shared so the two cannot drift apart — the copy in
+     * GameState had done exactly that.
+     */
+    public static AbilitySub makeAdventureEffect(CardState card) {
         String abEffect = "DB$ Effect | RememberObjects$ Self | StaticAbilities$ Play | ForgetOnMoved$ Exile | Duration$ Permanent | ConditionDefined$ Self | ConditionPresent$ Card.!copiedSpell+!token | Adventure$ True";
         AbilitySub saEffect = (AbilitySub)AbilityFactory.getAbility(abEffect, card);
 
@@ -4070,12 +4086,7 @@ public class CardFactoryUtil {
         sbPlay.append(" | AffectedZone$ Exile | Description$ You may cast EFFECTSOURCE.");
         saEffect.setSVar("Play", sbPlay.toString());
 
-        saExile.setSubAbility(saEffect);
-
-        ReplacementEffect re = ReplacementHandler.parseReplacement(repeffstr, card.getCard(), true);
-
-        re.setOverridingAbility(saExile);
-        return re;
+        return saEffect;
     }
 
     public static ReplacementEffect setupOmenAbility(CardState card) {
diff --git a/forge-game/src/main/java/forge/game/phase/PhaseHandler.java b/forge-game/src/main/java/forge/game/phase/PhaseHandler.java
index c95b9061..6c186922 100644
--- a/forge-game/src/main/java/forge/game/phase/PhaseHandler.java
+++ b/forge-game/src/main/java/forge/game/phase/PhaseHandler.java
@@ -1059,9 +1059,34 @@ public class PhaseHandler implements java.io.Serializable, IHasForgeLog {
                     return;
                 }
                 game.stashGameState();
+                // Record where this turn began, if this is that moment. Only for players
+                // who can actually ask for a rewind. Reading the game out does not change
+                // it, so the call is safe here; the timing conditions are checked inside.
+                if (!pPlayerPriority.getController().isAI()) {
+                    game.stashTurnRewindPoint(pPlayerPriority);
+                }
 
                 chosenSa = pPlayerPriority.getController().chooseSpellAbilityToPlay();
 
+                // The player asked to rewind instead of acting. Do it here, where the state
+                // is between actions, and let the main game loop restart from the restored
+                // position on its next step.
+                final int rewindSteps = pPlayerPriority.getController().consumeRewindRequest();
+                if (rewindSteps > 0 && game.rewindToActionOf(pPlayerPriority, rewindSteps)) {
+                    pPlayerPriority.getController().afterRewind();
+                    return;
+                }
+
+                // A saved game the player asked to load. Same reasoning as the rewind: the
+                // state is between actions here, so it is safe to replace it wholesale.
+                final GameState pendingState = pPlayerPriority.getController().consumePendingGameState();
+                if (pendingState != null) {
+                    pendingState.applyToGame(game);
+                    game.clearRewindPoints();
+                    pPlayerPriority.getController().afterRewind();
+                    return;
+                }
+
                 // this needs to come after chosenSa so it sees you conceding on own turn
                 if (playerTurn.hasLost() && pPlayerPriority.equals(playerTurn) && pFirstPriority.equals(playerTurn)) {
                     // If the active player has lost, and they have priority, set the next player to have priority
@@ -1211,6 +1236,74 @@ public class PhaseHandler implements java.io.Serializable, IHasForgeLog {
 
     // this is a hack for the setup game state mode, do not use outside of devSetupGameState code
     // as it avoids calling any of the phase effects that may be necessary in a less enforced context
+    /**
+     * The parts of the turn structure that GameSnapshot does not carry: who holds priority,
+     * who held it first this round, and the per-turn counters. Without these a restored
+     * snapshot would resume the main loop at the wrong player.
+     */
+    public static final class PriorityState implements java.io.Serializable {
+        private static final long serialVersionUID = 1L;
+
+        private final Player pPlayerPriority, pFirstPriority, playerPreviousTurn;
+        private final boolean givePriorityToPlayer, skipDamageSteps, bRepeatCleanup;
+        private final int nUpkeepsThisTurn, nUpkeepsThisGame, nCombatsThisTurn, nMainsThisTurn,
+                nEndOfTurnsThisTurn, planarDiceSpecialActionThisTurn;
+        private final List<ExtraTurn> extraTurns;
+        private final Map<PhaseType, List<ExtraPhase>> extraPhases;
+
+        private PriorityState(PhaseHandler ph) {
+            pPlayerPriority = ph.pPlayerPriority;
+            pFirstPriority = ph.pFirstPriority;
+            playerPreviousTurn = ph.playerPreviousTurn;
+            givePriorityToPlayer = ph.givePriorityToPlayer;
+            skipDamageSteps = ph.skipDamageSteps;
+            bRepeatCleanup = ph.bRepeatCleanup;
+            nUpkeepsThisTurn = ph.nUpkeepsThisTurn;
+            nUpkeepsThisGame = ph.nUpkeepsThisGame;
+            nCombatsThisTurn = ph.nCombatsThisTurn;
+            nMainsThisTurn = ph.nMainsThisTurn;
+            nEndOfTurnsThisTurn = ph.nEndOfTurnsThisTurn;
+            planarDiceSpecialActionThisTurn = ph.planarDiceSpecialActionThisTurn;
+            extraTurns = Lists.newArrayList(ph.extraTurns);
+            extraPhases = Maps.newEnumMap(PhaseType.class);
+            for (Map.Entry<PhaseType, Stack<ExtraPhase>> e : ph.extraPhases.entrySet()) {
+                extraPhases.put(e.getKey(), Lists.newArrayList(e.getValue()));
+            }
+        }
+    }
+
+    public PriorityState capturePriorityState() {
+        return new PriorityState(this);
+    }
+
+    public void restorePriorityState(final PriorityState s) {
+        pPlayerPriority = s.pPlayerPriority;
+        pFirstPriority = s.pFirstPriority;
+        playerPreviousTurn = s.playerPreviousTurn;
+        givePriorityToPlayer = s.givePriorityToPlayer;
+        skipDamageSteps = s.skipDamageSteps;
+        bRepeatCleanup = s.bRepeatCleanup;
+        nUpkeepsThisTurn = s.nUpkeepsThisTurn;
+        nUpkeepsThisGame = s.nUpkeepsThisGame;
+        nCombatsThisTurn = s.nCombatsThisTurn;
+        nMainsThisTurn = s.nMainsThisTurn;
+        nEndOfTurnsThisTurn = s.nEndOfTurnsThisTurn;
+        planarDiceSpecialActionThisTurn = s.planarDiceSpecialActionThisTurn;
+
+        extraTurns.clear();
+        extraTurns.addAll(s.extraTurns);
+        extraPhases.clear();
+        for (Map.Entry<PhaseType, List<ExtraPhase>> e : s.extraPhases.entrySet()) {
+            final Stack<ExtraPhase> stack = new Stack<>();
+            stack.addAll(e.getValue());
+            extraPhases.put(e.getKey(), stack);
+        }
+
+        for (final Player p : game.getPlayers()) {
+            p.setHasPriority(pPlayerPriority == p);
+        }
+    }
+
     public final void devModeSet(final PhaseType phase0, final Player player0, boolean endCombat, int cturn) {
         if (phase0 != null) {
             setPhase(phase0);
diff --git a/forge-game/src/main/java/forge/game/player/PlayerController.java b/forge-game/src/main/java/forge/game/player/PlayerController.java
index ffce4494..a4bf3ea5 100644
--- a/forge-game/src/main/java/forge/game/player/PlayerController.java
+++ b/forge-game/src/main/java/forge/game/player/PlayerController.java
@@ -86,6 +86,36 @@ public abstract class PlayerController {
         return false;
     }
 
+    /**
+     * Number of own actions this controller wants rewound, consumed by the main game loop
+     * the next time this player holds priority. Only the local human controller ever
+     * returns more than 0 — see Game#rewindToActionOf.
+     */
+    public int consumeRewindRequest() {
+        return 0;
+    }
+
+    /** Called on the game thread right after a rewind this controller asked for. */
+    public void afterRewind() {
+    }
+
+    /**
+     * A saved game state waiting to be loaded, taken by the main game loop the next time
+     * this player holds priority. Applying one mid-action would pull the ground out from
+     * under whatever the game thread is doing, so it happens between actions like a rewind.
+     */
+    private GameState pendingGameState = null;
+
+    public void setPendingGameState(GameState state) {
+        pendingGameState = state;
+    }
+
+    public GameState consumePendingGameState() {
+        GameState state = pendingGameState;
+        pendingGameState = null;
+        return state;
+    }
+
     public Game getGame() { return gameView.getGame(); }
     public Match getMatch() { return gameView.getMatch(); }
     public Player getPlayer() { return player; }
diff --git a/forge-gui-desktop/src/main/java/forge/gui/framework/DragCell.java b/forge-gui-desktop/src/main/java/forge/gui/framework/DragCell.java
index 63aedf90..5178e803 100644
--- a/forge-gui-desktop/src/main/java/forge/gui/framework/DragCell.java
+++ b/forge-gui-desktop/src/main/java/forge/gui/framework/DragCell.java
@@ -13,6 +13,8 @@ import javax.swing.JLabel;
 import javax.swing.JPanel;
 import javax.swing.SwingConstants;
 
+import org.tinylog.Logger;
+
 import com.google.common.collect.Lists;
 
 import forge.localinstance.properties.ForgePreferences;
@@ -267,9 +269,24 @@ public final class DragCell extends JPanel implements ILocalRepaint {
      * @param doc0 &emsp; {@link forge.gui.framework.IVDoc} */
     public void addDoc(final IVDoc<? extends ICDoc> doc0) {
         if (doc0 instanceof VEmptyDoc) { return; }
+        if (allDocs.contains(doc0)) {
+            // Already here. Adding it again would list it twice while Swing merely moves
+            // the one tab label it has, leaving the list longer than the head bar — and the
+            // next add then aims past the end of it. The deck editor does exactly this when
+            // it puts its tabs back on the way out.
+            setSelected(getSelected());
+            return;
+        }
         allDocs.add(doc0);
         doc0.setParentCell(this);
-        pnlHead.add(doc0.getTabLabel(), "h 100%!, gap " + tabPaddingPx + "px " + tabPaddingPx + "px 0 0", allDocs.size() - 1);
+        // Meant to append. Clamped, so a head bar that drifted out of step with the list
+        // cannot turn into an illegal position and take the whole action down with it.
+        final int position = Math.min(allDocs.size() - 1, pnlHead.getComponentCount());
+        if (position != allDocs.size() - 1) {
+            Logger.warn("Tab bar holds {} labels for {} docs; appending {} at {}",
+                    pnlHead.getComponentCount(), allDocs.size(), doc0.getDocumentID(), position);
+        }
+        pnlHead.add(doc0.getTabLabel(), "h 100%!, gap " + tabPaddingPx + "px " + tabPaddingPx + "px 0 0", position);
 
         // Ensure that a tab is selected
         setSelected(getSelected());
@@ -312,13 +329,24 @@ public final class DragCell extends JPanel implements ILocalRepaint {
         pnlBody.removeAll();
 
         // Priorities are used to "remember" tab selection history.
-        for (final IVDoc<? extends ICDoc> doc : allDocs) {
+        // Iterate a copy: populate() and update() can reach code that adds or removes
+        // docs from this very cell (zone tabs docking themselves in, dev mode coming
+        // and going, a match registering its views), which would blow up the iterator.
+        for (final IVDoc<? extends ICDoc> doc : Lists.newArrayList(allDocs)) {
             if (doc.equals(doc0)) {
                 docSelected = doc0;
                 doc.getTabLabel().priorityOne();
                 doc.getTabLabel().setSelected(true);
-                doc.populate();
-                doc.getLayoutControl().update();
+                // A panel that fails to fill itself must not take the screen down with it.
+                // This runs inside loadLayout, so an exception here used to abort the whole
+                // layout and leave an empty window over a still-running game.
+                try {
+                    doc.populate();
+                    doc.getLayoutControl().update();
+                } catch (final Exception ex) {
+                    Logger.error(ex, "Tab {} failed to populate; leaving it blank and carrying on",
+                            doc.getDocumentID());
+                }
             }
             else {
                 doc.getTabLabel().setSelected(false);
@@ -389,7 +417,7 @@ public final class DragCell extends JPanel implements ILocalRepaint {
         DragTab temp;
         int lowest = Integer.MAX_VALUE;
 
-        for (final IVDoc<? extends ICDoc> d : allDocs) {
+        for (final IVDoc<? extends ICDoc> d : Lists.newArrayList(allDocs)) {
             temp = d.getTabLabel();
 
             // This line prevents two tabs from having the same priority.
diff --git a/forge-gui-desktop/src/main/java/forge/menus/ForgeMenu.java b/forge-gui-desktop/src/main/java/forge/menus/ForgeMenu.java
index a175bb39..425abf89 100644
--- a/forge-gui-desktop/src/main/java/forge/menus/ForgeMenu.java
+++ b/forge-gui-desktop/src/main/java/forge/menus/ForgeMenu.java
@@ -78,6 +78,8 @@ public final class ForgeMenu {
         add(new AudioMenu().getMenu());
         add(HelpMenu.getMenu());
         addSeparator();
+        add(LoadSavedGame.getMenuItem());
+        addSeparator();
         add(OnlineMenu.getMenu());
         addSeparator();
         add(getMenuItem_Restart());
diff --git a/forge-gui-desktop/src/main/java/forge/menus/LoadSavedGame.java b/forge-gui-desktop/src/main/java/forge/menus/LoadSavedGame.java
new file mode 100644
index 00000000..2fff29d1
--- /dev/null
+++ b/forge-gui-desktop/src/main/java/forge/menus/LoadSavedGame.java
@@ -0,0 +1,124 @@
+package forge.menus;
+
+import java.io.File;
+import java.io.FileInputStream;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+import javax.swing.SwingUtilities;
+
+import forge.gui.GuiBase;
+import forge.deck.Deck;
+import forge.game.GameRules;
+import forge.game.GameState;
+import forge.game.GameType;
+import forge.game.player.RegisteredPlayer;
+import forge.gamemodes.match.HostedMatch;
+import forge.gui.SOverlayUtils;
+import forge.localinstance.properties.ForgeConstants;
+import forge.player.GamePlayerUtil;
+import forge.toolbox.FSkin.SkinnedMenuItem;
+import forge.util.Localizer;
+import forge.util.FileUtil;
+import forge.gui.util.SOptionPane;
+
+/**
+ * Starts a match from a game saved during play (Game menu &gt; Save game).
+ *
+ * A saved state carries everything the position needs, libraries included, so the match is
+ * started with empty decks and no opening hand — the same way puzzles are set up — and the
+ * state is applied once the game exists.
+ */
+public final class LoadSavedGame {
+    private static final Pattern PLAYER_KEY = Pattern.compile("^p(\\d+)life=", Pattern.MULTILINE);
+    /** What Forge uses when nobody says otherwise — see RegisteredPlayer.startingHand. */
+    private static final int DEFAULT_MAX_HAND_SIZE = 7;
+
+    private LoadSavedGame() { }
+
+    public static SkinnedMenuItem getMenuItem() {
+        final SkinnedMenuItem item = new SkinnedMenuItem(Localizer.getInstance().getMessage("lblLoadSavedGame"));
+        item.addActionListener(e -> load());
+        return item;
+    }
+
+    private static void load() {
+        final Localizer localizer = Localizer.getInstance();
+        final File dir = new File(ForgeConstants.USER_GAMES_DIR);
+        if (!dir.exists()) {
+            dir.mkdirs();
+        }
+        final String filename = GuiBase.getInterface().showFileDialog(
+                localizer.getMessage("lblLoadSavedGame"), ForgeConstants.USER_GAMES_DIR);
+        if (filename == null) {
+            return;
+        }
+
+        final GameState state = new GameState();
+        final int playerCount;
+        try {
+            playerCount = countPlayers(filename);
+            try (FileInputStream in = new FileInputStream(filename)) {
+                state.parse(in);
+            }
+        } catch (final Exception e) {
+            SOptionPane.showErrorDialog(localizer.getMessage("lblErrorLoadingBattleSetupFile") + "\n" + filename);
+            return;
+        }
+        if (playerCount < 2) {
+            SOptionPane.showErrorDialog(localizer.getMessage("lblSavedGameUnreadable") + "\n" + filename);
+            return;
+        }
+
+        SwingUtilities.invokeLater(() -> {
+            SOverlayUtils.startGameOverlay();
+            SOverlayUtils.showOverlay();
+        });
+
+        final HostedMatch hostedMatch = GuiBase.getInterface().hostMatch();
+        hostedMatch.setStartGameHook(() -> {
+            state.applyToGame(hostedMatch.getGame());
+            // Starting the match with no opening hand also sets the maximum hand size to
+            // zero (Game.java: setMaxHandSize(startingHand)), and a saved state does not
+            // carry that number, so cleanup would ask the player to discard their hand.
+            for (final forge.game.player.Player p : hostedMatch.getGame().getPlayers()) {
+                p.setMaxHandSize(DEFAULT_MAX_HAND_SIZE);
+                p.setStartingHandSize(DEFAULT_MAX_HAND_SIZE);
+            }
+        });
+
+        // Empty decks and no opening hand: everything comes from the saved state. The first
+        // player is the one who saved, the rest are AI, matching how the file numbers them.
+        final List<RegisteredPlayer> players = new ArrayList<>();
+        final RegisteredPlayer human = new RegisteredPlayer(new Deck()).setPlayer(GamePlayerUtil.getGuiPlayer());
+        human.setStartingHand(0);
+        players.add(human);
+        for (int i = 1; i < playerCount; i++) {
+            final RegisteredPlayer ai = new RegisteredPlayer(new Deck()).setPlayer(GamePlayerUtil.createAiPlayer());
+            ai.setStartingHand(0);
+            players.add(ai);
+        }
+
+        // Puzzle rules, because loading a position is what they are for: no mulligan over the
+        // empty opening hand, and the first player is taken rather than diced for. The saved
+        // state decides whose turn it is anyway.
+        final GameRules rules = new GameRules(GameType.Puzzle);
+        rules.setGamesPerMatch(1);
+        hostedMatch.startMatch(rules, null, players, human, GuiBase.getInterface().getNewGuiGame());
+
+        SwingUtilities.invokeLater(SOverlayUtils::hideOverlay);
+    }
+
+    /** How many players the file describes, counted from its "pNlife=" lines. */
+    private static int countPlayers(String filename) {
+        final String text = String.join("\n", FileUtil.readFile(filename));
+        final Matcher m = PLAYER_KEY.matcher(text);
+        int highest = -1;
+        while (m.find()) {
+            highest = Math.max(highest, Integer.parseInt(m.group(1)));
+        }
+        return highest + 1;
+    }
+}
diff --git a/forge-gui-desktop/src/main/java/forge/screens/deckeditor/controllers/CAllDecks.java b/forge-gui-desktop/src/main/java/forge/screens/deckeditor/controllers/CAllDecks.java
index 467db702..ab6a7c81 100644
--- a/forge-gui-desktop/src/main/java/forge/screens/deckeditor/controllers/CAllDecks.java
+++ b/forge-gui-desktop/src/main/java/forge/screens/deckeditor/controllers/CAllDecks.java
@@ -60,11 +60,16 @@ public enum CAllDecks implements ICDoc {
             // This may be default and so requiring potential update!
             ACEditorBase<? extends InventoryItem, ? extends DeckBase> editorCtrl =
                     CDeckEditorUI.SINGLETON_INSTANCE.getCurrentEditorController();
-            if (editorCtrl != null) {
+            // An editor exists well before its deck controller is wired up, and switching
+            // screens runs this in between. Asking it for a deck name then threw, which
+            // aborted the entire layout load and left the window with nothing in it.
+            if (editorCtrl != null && editorCtrl.getDeckController() != null) {
                 String currentDeckName = editorCtrl.getDeckController().getModelName();
                 if (currentDeckName != null && currentDeckName.length() > 0) {
                     DeckProxy deckProxy = dm.stringToItem(currentDeckName);
-                    if (deckProxy != null && !dm.getSelectedItem().equals(deckProxy))
+                    // deckProxy on the left: having nothing selected is a normal state,
+                    // and getSelectedItem() is null then.
+                    if (deckProxy != null && !deckProxy.equals(dm.getSelectedItem()))
                         dm.setSelectedItem(deckProxy);
                 }
             }
diff --git a/forge-gui-desktop/src/main/java/forge/screens/home/settings/CSubmenuPreferences.java b/forge-gui-desktop/src/main/java/forge/screens/home/settings/CSubmenuPreferences.java
index 9915861a..68afd7ff 100644
--- a/forge-gui-desktop/src/main/java/forge/screens/home/settings/CSubmenuPreferences.java
+++ b/forge-gui-desktop/src/main/java/forge/screens/home/settings/CSubmenuPreferences.java
@@ -211,6 +211,7 @@ public enum CSubmenuPreferences implements ICDoc {
         initializeAiProfilesComboBox();
         initializeAiSideboardingModeComboBox();
         initializeAiTimeoutComboBox();
+        initializeRewindStepsComboBox();
         initializeSoundSetsComboBox();
         initializeMusicSetsComboBox();
         initializeStackAdditionsComboBox();
@@ -496,6 +497,14 @@ public enum CSubmenuPreferences implements ICDoc {
         panel.setComboBox(comboBox, selectedItem);
     }
 
+    private void initializeRewindStepsComboBox() {
+        final FPref userSetting = FPref.MATCH_REWIND_STEPS;
+        final FComboBoxPanel<String> panel = this.view.getRewindStepsComboBox();
+        final FComboBox<String> comboBox = createComboBox(new String[] {"0", "1", "2", "3", "5", "10"}, userSetting);
+        final String selectedItem = this.prefs.getPref(userSetting);
+        panel.setComboBox(comboBox, selectedItem);
+    }
+
     private void initializeSoundSetsComboBox() {
         final FPref userSetting = FPref.UI_CURRENT_SOUND_SET;
         final FComboBoxPanel<String> panel = this.view.getSoundSetsComboBoxPanel();
diff --git a/forge-gui-desktop/src/main/java/forge/screens/home/settings/VSubmenuPreferences.java b/forge-gui-desktop/src/main/java/forge/screens/home/settings/VSubmenuPreferences.java
index c0141ae4..aedd1c85 100644
--- a/forge-gui-desktop/src/main/java/forge/screens/home/settings/VSubmenuPreferences.java
+++ b/forge-gui-desktop/src/main/java/forge/screens/home/settings/VSubmenuPreferences.java
@@ -150,6 +150,7 @@ public enum VSubmenuPreferences implements IVSubmenu<CSubmenuPreferences> {
     private final FComboBoxPanel<String> cbpAiProfiles = new FComboBoxPanel<>(localizer.getMessage("cbpAiProfiles")+":");
     private final FComboBoxPanel<String> cbpAiSideboardingMode = new FComboBoxPanel<>(localizer.getMessage("cbpAiSideboardingMode")+":");
     private final FComboBoxPanel<String> cbpAiTimeout = new FComboBoxPanel<>(localizer.getMessage("cbAITimeout")+":");
+    private final FComboBoxPanel<String> cbpRewindSteps = new FComboBoxPanel<>(localizer.getMessage("cbpRewindSteps")+":");
     private final FComboBoxPanel<String> cbpStackAdditions = new FComboBoxPanel<>(localizer.getMessage("cbpStackAdditions")+":");
     private final FComboBoxPanel<String> cbpLandPlayed = new FComboBoxPanel<>(localizer.getMessage("cbpLandPlayed")+":");
     private final FComboBoxPanel<String> cbpDisplayCurrentCardColors = new FComboBoxPanel<>(localizer.getMessage("cbpDisplayCurrentCardColors")+":");
@@ -266,6 +267,9 @@ public enum VSubmenuPreferences implements IVSubmenu<CSubmenuPreferences> {
         pnlPrefs.add(cbExperimentalRestore, titleConstraints);
         pnlPrefs.add(new NoteLabel(localizer.getMessage("nlExperimentalRestore")), descriptionConstraints);
 
+        pnlPrefs.add(cbpRewindSteps, titleConstraints);
+        pnlPrefs.add(new NoteLabel(localizer.getMessage("nlRewindSteps")), descriptionConstraints);
+
         pnlPrefs.add(cbpAiTimeout, titleConstraints);
         pnlPrefs.add(new NoteLabel(localizer.getMessage("nlAITimeout")), descriptionConstraints);
 
@@ -900,6 +904,10 @@ public enum VSubmenuPreferences implements IVSubmenu<CSubmenuPreferences> {
         return cbpAiTimeout;
     }
 
+    public FComboBoxPanel<String> getRewindStepsComboBox() {
+        return cbpRewindSteps;
+    }
+
     public FComboBoxPanel<String> getCbpStackAdditionsComboBoxPanel() {
         return cbpStackAdditions;
     }
diff --git a/forge-gui-desktop/src/main/java/forge/screens/match/menus/GameMenu.java b/forge-gui-desktop/src/main/java/forge/screens/match/menus/GameMenu.java
index 4281a454..e344fed1 100644
--- a/forge-gui-desktop/src/main/java/forge/screens/match/menus/GameMenu.java
+++ b/forge-gui-desktop/src/main/java/forge/screens/match/menus/GameMenu.java
@@ -1,6 +1,7 @@
 package forge.screens.match.menus;
 
 import java.awt.event.KeyEvent;
+import java.util.List;
 
 import javax.swing.JMenu;
 import javax.swing.JMenuItem;
@@ -15,6 +16,7 @@ import forge.gamemodes.match.YieldUpdate;
 import forge.localinstance.properties.ForgePreferences;
 import forge.localinstance.properties.ForgePreferences.FPref;
 import forge.model.FModel;
+import forge.player.PlayerControllerHuman;
 import forge.screens.match.CMatchUI;
 import forge.screens.match.VAutoYieldsAndTriggers;
 import forge.screens.match.VYieldSettings;
@@ -37,6 +39,18 @@ public final class GameMenu {
         final JMenu menu = new JMenu(localizer.getMessage("lblGame"));
         menu.setMnemonic(KeyEvent.VK_G);
         menu.add(getMenuItem_Undo());
+        final JMenu rewindMenu = getMenu_Rewind();
+        if (rewindMenu != null) {
+            menu.add(rewindMenu);
+        }
+        final SkinnedMenuItem saveItem = getMenuItem_SaveGame();
+        final SkinnedMenuItem loadItem = getMenuItem_LoadGame();
+        if (saveItem != null) {
+            menu.addSeparator();
+            menu.add(saveItem);
+            menu.add(loadItem);
+            menu.addSeparator();
+        }
         menu.add(getMenuItem_Concede());
         menu.add(getMenuItem_OfferDraw());
         menu.add(getMenuItem_EndTurn());
@@ -52,6 +66,22 @@ public final class GameMenu {
         menu.addMenuListener(new MenuListener() {
             @Override public void menuSelected(final MenuEvent e) {
                 autoPassItem.setState(prefs.getPrefBoolean(FPref.YIELD_AUTO_PASS_NO_ACTIONS));
+                if (rewindMenu != null) {
+                    // Name every entry after the turn it leads back to, and show only the
+                    // ones that have a recorded point behind them.
+                    final PlayerControllerHuman controller =
+                            (PlayerControllerHuman) matchUI.getGameController();
+                    final List<String> points = controller.describeRewindPoints();
+                    final Localizer loc = Localizer.getInstance();
+                    rewindMenu.setEnabled(!points.isEmpty());
+                    for (int i = 0; i < rewindMenu.getItemCount(); i++) {
+                        final JMenuItem item = rewindMenu.getItem(i);
+                        item.setVisible(i < points.size());
+                        if (i < points.size()) {
+                            item.setText(loc.getMessage("lblRewindToTurn", points.get(i)));
+                        }
+                    }
+                }
             }
             @Override public void menuDeselected(final MenuEvent e) {}
             @Override public void menuCanceled(final MenuEvent e) {}
@@ -66,6 +96,54 @@ public final class GameMenu {
         return menuItem;
     }
 
+    /**
+     * Restarts one of the player's own turns from its beginning, discarding everything
+     * that happened since — including the other players' and the AI's moves. Only offered
+     * to whoever runs the game (host or single player); a network client has no game state
+     * to rewind.
+     *
+     * One entry per recorded turn, so going back further is a single click rather than
+     * repeated rewinds.
+     */
+    private JMenu getMenu_Rewind() {
+        if (!(matchUI.getGameController() instanceof PlayerControllerHuman controller)) {
+            return null;
+        }
+        final int maxSteps = controller.getGame().REWIND_STEPS;
+        if (maxSteps < 1) {
+            return null;
+        }
+        final Localizer localizer = Localizer.getInstance();
+        final JMenu menu = new JMenu(localizer.getMessage("lblRewind"));
+        for (int step = 1; step <= maxSteps; step++) {
+            final int steps = step;
+            // Text is filled in when the menu opens, once the turn numbers are known.
+            final SkinnedMenuItem item = new SkinnedMenuItem(localizer.getMessage("lblRewindNoPoints"));
+            item.addActionListener(e -> controller.requestRewind(steps));
+            menu.add(item);
+        }
+        return menu;
+    }
+
+    /** Writes the current position to a file, for picking it up again after a crash. */
+    private SkinnedMenuItem getMenuItem_SaveGame() {
+        if (!(matchUI.getGameController() instanceof PlayerControllerHuman controller)) {
+            return null;
+        }
+        final SkinnedMenuItem menuItem = new SkinnedMenuItem(Localizer.getInstance().getMessage("lblSaveGame"));
+        menuItem.addActionListener(e -> controller.saveGameToFile());
+        return menuItem;
+    }
+
+    private SkinnedMenuItem getMenuItem_LoadGame() {
+        if (!(matchUI.getGameController() instanceof PlayerControllerHuman controller)) {
+            return null;
+        }
+        final SkinnedMenuItem menuItem = new SkinnedMenuItem(Localizer.getInstance().getMessage("lblLoadGame"));
+        menuItem.addActionListener(e -> controller.loadGameFromFile());
+        return menuItem;
+    }
+
     private SkinnedMenuItem getMenuItem_Undo() {
         final Localizer localizer = Localizer.getInstance();
         final SkinnedMenuItem menuItem = new SkinnedMenuItem(localizer.getMessage("lblUndo"));
diff --git a/forge-gui-desktop/src/test/java/forge/ai/AdventureGameStateTest.java b/forge-gui-desktop/src/test/java/forge/ai/AdventureGameStateTest.java
new file mode 100644
index 00000000..327d0284
--- /dev/null
+++ b/forge-gui-desktop/src/test/java/forge/ai/AdventureGameStateTest.java
@@ -0,0 +1,75 @@
+package forge.ai;
+
+import forge.game.Game;
+import forge.game.GameState;
+import forge.game.card.Card;
+import forge.game.phase.PhaseType;
+import forge.game.player.Player;
+import forge.game.spellability.SpellAbility;
+import forge.game.zone.ZoneType;
+import org.testng.AssertJUnit;
+import org.testng.annotations.Test;
+
+import java.util.Arrays;
+
+/**
+ * A card on an Adventure waits in exile and its creature half stays castable. Loading a
+ * state used to lose that: the permission effect was created while the exile zone was
+ * being read, and setting up the command zone right afterwards wiped it again.
+ */
+public class AdventureGameStateTest extends AITest {
+
+    private void applyOnGameThread(final Game game, final String text) {
+        final Thread t = new Thread(() -> {
+            final GameState in = new GameState();
+            in.parse(Arrays.asList(text.split("\n")));
+            in.applyToGame(game);
+        }, "Game-test");
+        t.start();
+        try {
+            t.join();
+        } catch (InterruptedException e) {
+            throw new RuntimeException(e);
+        }
+    }
+
+    private SpellAbility creatureHalf(Game game, Player p) {
+        for (Card c : p.getZone(ZoneType.Exile).getCards()) {
+            for (SpellAbility sa : c.getAllPossibleAbilities(p, false)) {
+                if (!sa.isAdventure()) {
+                    return sa;
+                }
+            }
+        }
+        return null;
+    }
+
+    @Test
+    public void adventureCardStaysCastableAfterLoadingAState() {
+        Game game = initAndCreateGame();
+        Player p = game.getPlayers().get(0);
+        game.getPhaseHandler().devModeSet(PhaseType.MAIN1, p, 3);
+        game.getPhaseHandler().setPriority(p);
+
+        addCardToZone("Callous Sell-Sword", p, ZoneType.Exile);
+
+        final GameState written = new GameState();
+        written.initFromGame(game);
+        final String text = written.toString();
+        AssertJUnit.assertTrue("the state records the adventure", text.contains("OnAdventure"));
+
+        applyOnGameThread(game, text);
+
+        Player after = game.getPlayers().get(0);
+        AssertJUnit.assertEquals("the card is back in exile", 1, after.getZone(ZoneType.Exile).size());
+        AssertJUnit.assertNotNull("and its creature half can be cast from there", creatureHalf(game, after));
+
+        int reminders = 0;
+        for (Card c : after.getZone(ZoneType.Command).getCards()) {
+            if (c.getName().endsWith("'s Adventure")) {
+                reminders++;
+            }
+        }
+        AssertJUnit.assertEquals("exactly one reminder in the command zone", 1, reminders);
+    }
+}
diff --git a/forge-gui-desktop/src/test/java/forge/ai/ForetellSnapshotTest.java b/forge-gui-desktop/src/test/java/forge/ai/ForetellSnapshotTest.java
new file mode 100644
index 00000000..bfdfbcc2
--- /dev/null
+++ b/forge-gui-desktop/src/test/java/forge/ai/ForetellSnapshotTest.java
@@ -0,0 +1,48 @@
+package forge.ai;
+
+import forge.game.Game;
+import forge.game.card.Card;
+import forge.game.player.Player;
+import forge.game.zone.ZoneType;
+import org.testng.AssertJUnit;
+import org.testng.annotations.Test;
+
+/**
+ * Reproduces #7844: a foretold card that is cast from exile and then cancelled comes back
+ * face up and can no longer be cast with Foretell.
+ *
+ * The steps below are what the cancel does internally: a snapshot is taken while the card
+ * sits face down in exile, casting turns it face up and moves it to the stack, and the
+ * rollback restores the snapshot.
+ */
+public class ForetellSnapshotTest extends AITest {
+
+    @Test
+    public void foretoldCardIsStillForetoldAfterRollback() {
+        Game game = initAndCreateGame();
+        game.EXPERIMENTAL_RESTORE_SNAPSHOT = true;
+        Player p = game.getPlayers().get(0);
+        game.getPhaseHandler().setPriority(p);
+
+        Card card = addCardToZone("Doomskar Oracle", p, ZoneType.Exile);
+        card.setForetold(true);
+        card.turnFaceDown(true);
+        AssertJUnit.assertTrue(card.isForetold());
+        AssertJUnit.assertTrue(card.isFaceDown());
+
+        game.stashGameState();
+
+        // Cast it: face up, onto the stack.
+        card.turnFaceUp(false, null);
+        game.getAction().moveTo(ZoneType.Stack, card, null, null);
+
+        // Cancel: roll back to the snapshot.
+        AssertJUnit.assertTrue(game.restoreGameState());
+
+        Card after = game.findById(card.getId());
+        AssertJUnit.assertNotNull("card should still be in the game", after);
+        AssertJUnit.assertEquals("card should be back in exile", ZoneType.Exile, after.getZone().getZoneType());
+        AssertJUnit.assertTrue("card should be face down again", after.isFaceDown());
+        AssertJUnit.assertTrue("card should still be foretold", after.isForetold());
+    }
+}
diff --git a/forge-gui-desktop/src/test/java/forge/ai/RewindAutosaveTest.java b/forge-gui-desktop/src/test/java/forge/ai/RewindAutosaveTest.java
new file mode 100644
index 00000000..4039561d
--- /dev/null
+++ b/forge-gui-desktop/src/test/java/forge/ai/RewindAutosaveTest.java
@@ -0,0 +1,81 @@
+package forge.ai;
+
+import forge.game.Game;
+import forge.game.phase.PhaseType;
+import forge.game.player.Player;
+import org.testng.AssertJUnit;
+import org.testng.annotations.Test;
+
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * Every rewind point is also handed to whoever wants to put it on disk. Without that, a
+ * game whose window dies is only reachable by attaching to the live process — which is
+ * exactly the hole this closes.
+ */
+public class RewindAutosaveTest extends AITest {
+
+    private void startTurn(Game game, Player p, int turn) {
+        game.getPhaseHandler().devModeSet(PhaseType.MAIN1, p, turn);
+        game.getPhaseHandler().setPriority(p);
+    }
+
+    @Test
+    public void everyRewindPointIsOfferedForAutosaving() {
+        final Game game = initAndCreateGame();
+        final Player p = game.getPlayers().get(0);
+
+        final List<Integer> turns = new ArrayList<>();
+        final List<List<String>> texts = new ArrayList<>();
+        game.setRewindAutosave((turn, text) -> {
+            turns.add(turn);
+            texts.add(text);
+        });
+
+        startTurn(game, p, 3);
+        game.stashTurnRewindPoint(p);
+        startTurn(game, p, 5);
+        game.stashTurnRewindPoint(p);
+
+        AssertJUnit.assertEquals("one autosave per rewind point", 2, turns.size());
+        AssertJUnit.assertEquals(Integer.valueOf(3), turns.get(0));
+        AssertJUnit.assertEquals(Integer.valueOf(5), turns.get(1));
+        AssertJUnit.assertTrue("the text is the saved position",
+                String.join("\n", texts.get(1)).contains("turn=5"));
+    }
+
+    @Test
+    public void aFailingAutosaveDoesNotCostThePlayerTheirRewindPoint() {
+        final Game game = initAndCreateGame();
+        final Player p = game.getPlayers().get(0);
+
+        game.setRewindAutosave((turn, text) -> {
+            throw new RuntimeException("disk full");
+        });
+
+        startTurn(game, p, 3);
+        game.stashTurnRewindPoint(p);
+
+        AssertJUnit.assertEquals("the point is still there", 1, game.getAvailableRewindSteps(p));
+    }
+
+    @Test
+    public void turnsThatTakeNoRewindPointAlsoWriteNothing() {
+        final Game game = initAndCreateGame();
+        final Player p = game.getPlayers().get(0);
+
+        final List<Integer> turns = new ArrayList<>();
+        game.setRewindAutosave((turn, text) -> turns.add(turn));
+
+        startTurn(game, p, 3);
+        game.stashTurnRewindPoint(p);
+        game.stashTurnRewindPoint(p); // same turn again: already covered
+
+        game.getPhaseHandler().devModeSet(PhaseType.COMBAT_DECLARE_ATTACKERS, p, 4);
+        game.getPhaseHandler().setPriority(p);
+        game.stashTurnRewindPoint(p); // wrong phase
+
+        AssertJUnit.assertEquals(1, turns.size());
+    }
+}
diff --git a/forge-gui-desktop/src/test/java/forge/ai/RewindHandSizeTest.java b/forge-gui-desktop/src/test/java/forge/ai/RewindHandSizeTest.java
new file mode 100644
index 00000000..c3fc5d24
--- /dev/null
+++ b/forge-gui-desktop/src/test/java/forge/ai/RewindHandSizeTest.java
@@ -0,0 +1,75 @@
+package forge.ai;
+
+import forge.game.Game;
+import forge.game.card.Card;
+import forge.game.phase.PhaseType;
+import forge.game.player.Player;
+import org.testng.AssertJUnit;
+import org.testng.annotations.Test;
+
+/**
+ * The save format does not record a player's maximum hand size, so a rewind can only get
+ * it right if it is recomputed from what is on the battlefield. These tests check that it
+ * is, in both directions.
+ */
+public class RewindHandSizeTest extends AITest {
+
+    private boolean rewind(final Game game, final Player p, final int steps) {
+        final boolean[] result = new boolean[1];
+        final Thread t = new Thread(() -> result[0] = game.rewindToActionOf(p, steps), "Game-test");
+        t.start();
+        try {
+            t.join();
+        } catch (InterruptedException e) {
+            throw new RuntimeException(e);
+        }
+        return result[0];
+    }
+
+    private void startTurn(Game game, Player p, int turn) {
+        game.getPhaseHandler().devModeSet(PhaseType.MAIN1, p, turn);
+        game.getPhaseHandler().setPriority(p);
+    }
+
+    @Test
+    public void rewindTakesBackAnUnlimitedHandSize() {
+        Game game = initAndCreateGame();
+        Player p = game.getPlayers().get(0);
+        startTurn(game, p, 3);
+
+        game.stashTurnRewindPoint(p);
+        AssertJUnit.assertFalse("no tower yet", p.isUnlimitedHandSize());
+
+        addCard("Reliquary Tower", p);
+        game.getAction().checkStateEffects(true);
+        AssertJUnit.assertTrue("tower grants it", p.isUnlimitedHandSize());
+
+        AssertJUnit.assertTrue(rewind(game, p, 1));
+
+        Player after = game.getPlayers().get(0);
+        AssertJUnit.assertFalse("gone again with the tower", after.isUnlimitedHandSize());
+        AssertJUnit.assertEquals(7, after.getMaxHandSize());
+    }
+
+    @Test
+    public void rewindGivesAnUnlimitedHandSizeBack() {
+        Game game = initAndCreateGame();
+        Player p = game.getPlayers().get(0);
+        startTurn(game, p, 3);
+
+        Card tower = addCard("Reliquary Tower", p);
+        game.getAction().checkStateEffects(true);
+        AssertJUnit.assertTrue(p.isUnlimitedHandSize());
+
+        game.stashTurnRewindPoint(p);
+
+        game.getAction().destroy(tower, null, true, null);
+        game.getAction().checkStateEffects(true);
+        AssertJUnit.assertFalse("tower destroyed", p.isUnlimitedHandSize());
+
+        AssertJUnit.assertTrue(rewind(game, p, 1));
+
+        Player after = game.getPlayers().get(0);
+        AssertJUnit.assertTrue("tower is back, and so is the effect", after.isUnlimitedHandSize());
+    }
+}
diff --git a/forge-gui-desktop/src/test/java/forge/ai/RewindLastingEffectTest.java b/forge-gui-desktop/src/test/java/forge/ai/RewindLastingEffectTest.java
new file mode 100644
index 00000000..e9ba6add
--- /dev/null
+++ b/forge-gui-desktop/src/test/java/forge/ai/RewindLastingEffectTest.java
@@ -0,0 +1,84 @@
+package forge.ai;
+
+import forge.game.Game;
+import forge.game.card.Card;
+import forge.game.phase.PhaseType;
+import forge.game.player.Player;
+import forge.game.spellability.SpellAbility;
+import forge.game.zone.ZoneType;
+import org.testng.AssertJUnit;
+import org.testng.annotations.Test;
+
+/**
+ * Praetor's Counsel grants "you have no maximum hand size" for the rest of the game, and
+ * then goes to the graveyard. Nothing on the battlefield carries the effect afterwards —
+ * it lives on as an Effect card in the command zone. Does a rewind get that right?
+ */
+public class RewindLastingEffectTest extends AITest {
+
+    private boolean rewind(final Game game, final Player p, final int steps) {
+        final boolean[] result = new boolean[1];
+        final Thread t = new Thread(() -> result[0] = game.rewindToActionOf(p, steps), "Game-test");
+        t.start();
+        try {
+            t.join();
+        } catch (InterruptedException e) {
+            throw new RuntimeException(e);
+        }
+        return result[0];
+    }
+
+    private void castPraetorsCounsel(Game game, Player p) {
+        Card counsel = addCardToZone("Praetor's Counsel", p, ZoneType.Hand);
+        SpellAbility sa = counsel.getFirstSpellAbility();
+        sa.setActivatingPlayer(p);
+        game.getStack().add(sa);
+        playUntilStackClear(game);
+        game.getAction().checkStateEffects(true);
+    }
+
+    @Test
+    public void rewindTakesBackARestOfGameEffect() {
+        Game game = initAndCreateGame();
+        Player p = game.getPlayers().get(0);
+        game.getPhaseHandler().devModeSet(PhaseType.MAIN1, p, 3);
+        game.getPhaseHandler().setPriority(p);
+
+        game.stashTurnRewindPoint(p);
+        AssertJUnit.assertFalse("not yet cast", p.isUnlimitedHandSize());
+
+        castPraetorsCounsel(game, p);
+        AssertJUnit.assertTrue("the spell granted it", p.isUnlimitedHandSize());
+        AssertJUnit.assertEquals("and nothing on the battlefield carries it", 0,
+                p.getCardsIn(ZoneType.Battlefield).size());
+
+        AssertJUnit.assertTrue(rewind(game, p, 1));
+
+        Player after = game.getPlayers().get(0);
+        AssertJUnit.assertFalse("gone again after the rewind", after.isUnlimitedHandSize());
+        AssertJUnit.assertEquals(7, after.getMaxHandSize());
+    }
+
+    @Test
+    public void rewindKeepsARestOfGameEffectItWasTakenAfter() {
+        Game game = initAndCreateGame();
+        Player p = game.getPlayers().get(0);
+        game.getPhaseHandler().devModeSet(PhaseType.MAIN1, p, 3);
+        game.getPhaseHandler().setPriority(p);
+
+        castPraetorsCounsel(game, p);
+        AssertJUnit.assertTrue(p.isUnlimitedHandSize());
+
+        game.getPhaseHandler().devModeSet(PhaseType.MAIN1, p, 5);
+        game.getPhaseHandler().setPriority(p);
+        game.stashTurnRewindPoint(p);
+
+        addCard("Mountain", p);
+        AssertJUnit.assertTrue(rewind(game, p, 1));
+
+        Player after = game.getPlayers().get(0);
+        AssertJUnit.assertEquals("the Mountain is gone", 0, after.getCardsIn(ZoneType.Battlefield).size());
+        AssertJUnit.assertTrue("but the rest-of-game effect is still there",
+                after.isUnlimitedHandSize());
+    }
+}
diff --git a/forge-gui-desktop/src/test/java/forge/ai/RewindTest.java b/forge-gui-desktop/src/test/java/forge/ai/RewindTest.java
new file mode 100644
index 00000000..99c7f15a
--- /dev/null
+++ b/forge-gui-desktop/src/test/java/forge/ai/RewindTest.java
@@ -0,0 +1,182 @@
+package forge.ai;
+
+import forge.game.Game;
+import forge.game.phase.PhaseHandler;
+import forge.game.phase.PhaseType;
+import forge.game.player.Player;
+import forge.game.zone.ZoneType;
+import org.testng.AssertJUnit;
+import org.testng.annotations.Test;
+
+/**
+ * Tests for the turn based rewind (Game#stashTurnRewindPoint, Game#rewindToActionOf),
+ * which restarts one of the player's own turns from its beginning and throws away
+ * everything that happened since.
+ *
+ * A point is recorded once per turn, in the turn player's first main phase with an empty
+ * stack, because that is the only moment the save format describes without gaps.
+ */
+public class RewindTest extends AITest {
+
+    /** Puts the game at the start of the given player's turn, ready for a rewind point. */
+    private void startTurn(Game game, Player p, int turn) {
+        game.getPhaseHandler().devModeSet(PhaseType.MAIN1, p, turn);
+        game.getPhaseHandler().setPriority(p);
+    }
+
+    /**
+     * Restoring a state runs on the game thread, which in a real match is the thread the
+     * rewind is triggered from. Tests have no such thread, so borrow one — GameAction
+     * recognises it by its name.
+     */
+    private boolean rewind(final Game game, final Player p, final int steps) {
+        final boolean[] result = new boolean[1];
+        final Thread t = new Thread(() -> result[0] = game.rewindToActionOf(p, steps), "Game-test");
+        t.start();
+        try {
+            t.join();
+        } catch (InterruptedException e) {
+            throw new RuntimeException(e);
+        }
+        return result[0];
+    }
+
+    @Test
+    public void rewindRestartsTheCurrentTurn() {
+        Game game = initAndCreateGame();
+        Player p = game.getPlayers().get(0);
+
+        startTurn(game, p, 3);
+        game.stashTurnRewindPoint(p);
+
+        addCard("Mountain", p);
+        p.setLife(15, null);
+
+        AssertJUnit.assertEquals(1, game.getAvailableRewindSteps(p));
+        AssertJUnit.assertTrue(rewind(game, p, 1));
+
+        Player after = game.getPlayers().get(0);
+        AssertJUnit.assertEquals(0, after.getCardsIn(ZoneType.Battlefield).size());
+        AssertJUnit.assertEquals(20, after.getLife());
+    }
+
+    @Test
+    public void rewindGoesBackSeveralOwnTurns() {
+        Game game = initAndCreateGame();
+        Player p = game.getPlayers().get(0);
+
+        startTurn(game, p, 1);
+        game.stashTurnRewindPoint(p);
+        addCard("Mountain", p);
+
+        startTurn(game, p, 3);
+        game.stashTurnRewindPoint(p);
+        addCard("Forest", p);
+
+        startTurn(game, p, 5);
+        game.stashTurnRewindPoint(p);
+        addCard("Island", p);
+
+        AssertJUnit.assertEquals(3, game.getAvailableRewindSteps(p));
+
+        // Three steps back is the oldest point: none of the lands had been played yet.
+        AssertJUnit.assertTrue(rewind(game, p, 3));
+        AssertJUnit.assertEquals(1, game.getPhaseHandler().getTurn());
+        AssertJUnit.assertEquals(0, game.getPlayers().get(0).getCardsIn(ZoneType.Battlefield).size());
+    }
+
+    @Test
+    public void rewindUndoesWhatHappenedInBetween() {
+        Game game = initAndCreateGame();
+        Player me = game.getPlayers().get(0);
+        Player other = game.getPlayers().get(1);
+
+        startTurn(game, me, 3);
+        game.stashTurnRewindPoint(me);
+        addCard("Mountain", me);
+
+        // The opponent's turn follows and they get something onto the battlefield too.
+        startTurn(game, other, 4);
+        addCard("Swamp", other);
+
+        startTurn(game, me, 5);
+
+        // Back to the start of my turn 3: my Mountain and their Swamp are both gone.
+        AssertJUnit.assertTrue(rewind(game, me, 1));
+        AssertJUnit.assertEquals(0, game.getPlayers().get(0).getCardsIn(ZoneType.Battlefield).size());
+        AssertJUnit.assertEquals(0, game.getPlayers().get(1).getCardsIn(ZoneType.Battlefield).size());
+    }
+
+    @Test
+    public void rewindRestoresTurnPhaseAndPriority() {
+        Game game = initAndCreateGame();
+        Player me = game.getPlayers().get(0);
+        Player other = game.getPlayers().get(1);
+        PhaseHandler ph = game.getPhaseHandler();
+
+        startTurn(game, me, 7);
+        game.stashTurnRewindPoint(me);
+
+        ph.devModeSet(PhaseType.COMBAT_DECLARE_ATTACKERS, other, 8);
+        ph.setPriority(other);
+
+        AssertJUnit.assertTrue(rewind(game, me, 1));
+        AssertJUnit.assertEquals(7, ph.getTurn());
+        AssertJUnit.assertEquals(PhaseType.MAIN1, ph.getPhase());
+        AssertJUnit.assertEquals(me, ph.getPriorityPlayer());
+        AssertJUnit.assertEquals(me, ph.getPlayerTurn());
+    }
+
+    @Test
+    public void onlyOnePointPerTurnAndOnlyAtTheRightMoment() {
+        Game game = initAndCreateGame();
+        Player p = game.getPlayers().get(0);
+        Player other = game.getPlayers().get(1);
+
+        startTurn(game, p, 3);
+        game.stashTurnRewindPoint(p);
+        game.stashTurnRewindPoint(p);   // same turn again: ignored
+        AssertJUnit.assertEquals(1, game.getAvailableRewindSteps(p));
+
+        // Not the turn player.
+        game.getPhaseHandler().devModeSet(PhaseType.MAIN1, other, 4);
+        game.stashTurnRewindPoint(p);
+        AssertJUnit.assertEquals(1, game.getAvailableRewindSteps(p));
+
+        // Own turn, but not the first main phase.
+        game.getPhaseHandler().devModeSet(PhaseType.UPKEEP, p, 5);
+        game.stashTurnRewindPoint(p);
+        AssertJUnit.assertEquals(1, game.getAvailableRewindSteps(p));
+    }
+
+    @Test
+    public void rewindIsLimitedToTheConfiguredDepth() {
+        Game game = initAndCreateGame();
+        Player p = game.getPlayers().get(0);
+
+        for (int turn = 1; turn <= 10; turn++) {
+            startTurn(game, p, turn);
+            game.stashTurnRewindPoint(p);
+        }
+
+        AssertJUnit.assertEquals(game.REWIND_STEPS, game.getAvailableRewindSteps(p));
+        AssertJUnit.assertFalse(rewind(game, p, game.REWIND_STEPS + 1));
+
+        // The oldest points were dropped, so the deepest step is not turn 1 any more.
+        AssertJUnit.assertTrue(rewind(game, p, game.REWIND_STEPS));
+        AssertJUnit.assertEquals(11 - game.REWIND_STEPS, game.getPhaseHandler().getTurn());
+    }
+
+    @Test
+    public void rewindIsOffWhenTheDepthIsZero() {
+        Game game = initAndCreateGame();
+        Player p = game.getPlayers().get(0);
+        game.REWIND_STEPS = 0;
+
+        startTurn(game, p, 3);
+        game.stashTurnRewindPoint(p);
+
+        AssertJUnit.assertEquals(0, game.getAvailableRewindSteps(p));
+        AssertJUnit.assertFalse(rewind(game, p, 1));
+    }
+}
diff --git a/forge-gui-desktop/src/test/java/forge/ai/RollbackCleanupTest.java b/forge-gui-desktop/src/test/java/forge/ai/RollbackCleanupTest.java
new file mode 100644
index 00000000..c8552b97
--- /dev/null
+++ b/forge-gui-desktop/src/test/java/forge/ai/RollbackCleanupTest.java
@@ -0,0 +1,51 @@
+package forge.ai;
+
+import forge.game.Game;
+import forge.game.GameActionUtil;
+import forge.game.card.Card;
+import forge.game.cost.CostPayment;
+import forge.game.player.Player;
+import forge.game.spellability.SpellAbility;
+import forge.game.zone.ZoneType;
+import org.testng.AssertJUnit;
+import org.testng.annotations.Test;
+
+/**
+ * Rolling back a cast via the snapshot has to clean up the ability as well: the snapshot
+ * holds cards, zones and mana, but not what the player announced, targeted, or the frozen
+ * stack. Leaving those behind is what #10049 (spell can no longer be cast after a cancel)
+ * and #8762 (cancelling freezes the game) look like.
+ */
+public class RollbackCleanupTest extends AITest {
+
+    @Test
+    public void snapshotRollbackClearsWhatTheSnapshotDoesNotHold() {
+        Game game = initAndCreateGame();
+        game.EXPERIMENTAL_RESTORE_SNAPSHOT = true;
+        Player p = game.getPlayers().get(0);
+        game.getPhaseHandler().setPriority(p);
+
+        Card card = addCardToZone("Shock", p, ZoneType.Hand);
+        SpellAbility sa = card.getFirstSpellAbility();
+        sa.setActivatingPlayer(p);
+
+        game.stashGameState();
+
+        // What casting leaves on the ability and the card.
+        sa.setXManaCostPaid(3);
+        card.setCastSA(sa);
+        card.setCastFrom(p.getZone(ZoneType.Hand));
+        game.getStack().freezeStack(sa);
+        AssertJUnit.assertTrue(game.getStack().isFrozen());
+
+        GameActionUtil.rollbackAbility(sa, p.getZone(ZoneType.Hand), 0,
+                new CostPayment(sa.getPayCosts(), sa), card);
+
+        Card after = game.getCardState(card, null);
+        AssertJUnit.assertNotNull(after);
+        AssertJUnit.assertNull("announced X is cleared", sa.getXManaCostPaid());
+        AssertJUnit.assertNull("card is no longer marked as being cast", after.getCastSA());
+        AssertJUnit.assertNull("and no longer remembers where from", after.getCastFrom());
+        AssertJUnit.assertFalse("the stack is unfrozen again", game.getStack().isFrozen());
+    }
+}
diff --git a/forge-gui-desktop/src/test/java/forge/ai/SnapshotControlTest.java b/forge-gui-desktop/src/test/java/forge/ai/SnapshotControlTest.java
new file mode 100644
index 00000000..2aae2769
--- /dev/null
+++ b/forge-gui-desktop/src/test/java/forge/ai/SnapshotControlTest.java
@@ -0,0 +1,46 @@
+package forge.ai;
+
+import forge.game.Game;
+import forge.game.card.Card;
+import forge.game.player.Player;
+import forge.game.zone.ZoneType;
+import org.testng.AssertJUnit;
+import org.testng.annotations.Test;
+
+/**
+ * Restoring a snapshot has to give a stolen creature back. Reported from play: casting
+ * Claim the Firstborn and then rewinding returned the spell to hand but left the creature
+ * under the thief's control.
+ */
+public class SnapshotControlTest extends AITest {
+
+    @Test
+    public void restoringUndoesAStolenCreature() {
+        Game game = initAndCreateGame();
+        game.EXPERIMENTAL_RESTORE_SNAPSHOT = true;
+        Player owner = game.getPlayers().get(0);
+        Player thief = game.getPlayers().get(1);
+        game.getPhaseHandler().setPriority(thief);
+
+        Card creature = addCard("Grizzly Bears", owner);
+        AssertJUnit.assertEquals(owner, creature.getController());
+
+        game.stashGameState();
+
+        // Claim the Firstborn: gain control of the creature.
+        creature.setController(thief, game.getNextTimestamp());
+        game.getAction().controllerChangeZoneCorrection(creature);
+        AssertJUnit.assertEquals(thief, creature.getController());
+        AssertJUnit.assertEquals(1, thief.getZone(ZoneType.Battlefield).getCards().size());
+
+        AssertJUnit.assertTrue(game.restoreGameState());
+
+        Card after = game.findById(creature.getId());
+        AssertJUnit.assertNotNull(after);
+        AssertJUnit.assertEquals("control goes back to the owner", owner, after.getController());
+        AssertJUnit.assertEquals("and so does the creature", 1,
+                owner.getZone(ZoneType.Battlefield).getCards().size());
+        AssertJUnit.assertEquals("the thief has nothing left", 0,
+                thief.getZone(ZoneType.Battlefield).getCards().size());
+    }
+}
diff --git a/forge-gui-desktop/src/test/java/forge/ai/SnapshotMeldTest.java b/forge-gui-desktop/src/test/java/forge/ai/SnapshotMeldTest.java
new file mode 100644
index 00000000..648fe5c6
--- /dev/null
+++ b/forge-gui-desktop/src/test/java/forge/ai/SnapshotMeldTest.java
@@ -0,0 +1,94 @@
+package forge.ai;
+
+import forge.card.CardStateName;
+import forge.game.Game;
+import forge.game.card.Card;
+import forge.game.player.Player;
+import forge.game.zone.PlayerZoneBattlefield;
+import forge.game.zone.ZoneType;
+import org.testng.AssertJUnit;
+import org.testng.annotations.Test;
+
+/**
+ * A melded permanent is two cards: the front half on the battlefield in its Meld state, and
+ * the back half held in the battlefield zone's melded collection rather than its card list.
+ * Snapshots have to carry that distinction in both directions.
+ */
+public class SnapshotMeldTest extends AITest {
+
+    private Card primary;
+    private Card secondary;
+
+    /** Melds the two cards the way MeldEffect does. */
+    private void meld(Game game, Player p, Card bruna, Card gisela) {
+        primary = bruna.hasState(CardStateName.Meld) ? bruna : gisela;
+        secondary = primary == bruna ? gisela : bruna;
+        AssertJUnit.assertTrue("one half carries the meld state", primary.hasState(CardStateName.Meld));
+        primary.changeToState(CardStateName.Meld);
+        primary.setBackSide(true);
+        primary.setMeldedWith(secondary);
+        ((PlayerZoneBattlefield) p.getZone(ZoneType.Battlefield)).addToMelded(secondary);
+    }
+
+    private Game meldableGame() {
+        Game game = initAndCreateGame();
+        game.EXPERIMENTAL_RESTORE_SNAPSHOT = true;
+        game.getPhaseHandler().setPriority(game.getPlayers().get(0));
+        return game;
+    }
+
+    @Test
+    public void restoringPastAMeldUnmeldsBothHalves() {
+        Game game = meldableGame();
+        Player p = game.getPlayers().get(0);
+        PlayerZoneBattlefield battlefield = (PlayerZoneBattlefield) p.getZone(ZoneType.Battlefield);
+
+        Card bruna = addCard("Bruna, the Fading Light", p);
+        Card gisela = addCard("Gisela, the Broken Blade", p);
+
+        game.stashGameState(); // before the meld
+
+        meld(game, p, bruna, gisela);
+        AssertJUnit.assertTrue(game.restoreGameState());
+
+        AssertJUnit.assertNotNull("both halves survive", game.findById(bruna.getId()));
+        AssertJUnit.assertNotNull("both halves survive", game.findById(gisela.getId()));
+        AssertJUnit.assertEquals("both are loose on the battlefield again", 2,
+                battlefield.getCards().size());
+        AssertJUnit.assertFalse("the back half is no longer held as melded",
+                battlefield.getMeldedCards().contains(game.findById(secondary.getId())));
+        AssertJUnit.assertNull("and the front half no longer points at it",
+                game.findById(primary.getId()).getMeldedWith());
+    }
+
+    @Test
+    public void restoringToAMeldKeepsItWhole() {
+        Game game = meldableGame();
+        Player p = game.getPlayers().get(0);
+        PlayerZoneBattlefield battlefield = (PlayerZoneBattlefield) p.getZone(ZoneType.Battlefield);
+
+        Card bruna = addCard("Bruna, the Fading Light", p);
+        Card gisela = addCard("Gisela, the Broken Blade", p);
+        meld(game, p, bruna, gisela);
+
+        game.stashGameState(); // with the meld in play
+
+        // Something to roll back. Deliberately not a new card: creating one lands in the
+        // separate null dereference that #11416 is about.
+        primary.setTapped(true);
+        AssertJUnit.assertTrue(game.restoreGameState());
+        AssertJUnit.assertFalse("the roll back happened", game.findById(primary.getId()).isTapped());
+
+        Card restoredPrimary = game.findById(primary.getId());
+        Card restoredSecondary = game.findById(secondary.getId());
+        AssertJUnit.assertNotNull(restoredPrimary);
+        AssertJUnit.assertNotNull(restoredSecondary);
+        AssertJUnit.assertEquals("the front half is still melded", CardStateName.Meld,
+                restoredPrimary.getCurrentStateName());
+        AssertJUnit.assertEquals("and still points at the back half",
+                restoredSecondary, restoredPrimary.getMeldedWith());
+        AssertJUnit.assertTrue("which is still held as melded",
+                battlefield.getMeldedCards().contains(restoredSecondary));
+        AssertJUnit.assertEquals("one permanent, not two", 1, battlefield.getCards().size());
+    }
+}
diff --git a/forge-gui-desktop/src/test/java/forge/ai/SnapshotStolenCardTest.java b/forge-gui-desktop/src/test/java/forge/ai/SnapshotStolenCardTest.java
new file mode 100644
index 00000000..662e5faa
--- /dev/null
+++ b/forge-gui-desktop/src/test/java/forge/ai/SnapshotStolenCardTest.java
@@ -0,0 +1,53 @@
+package forge.ai;
+
+import forge.game.Game;
+import forge.game.card.Card;
+import forge.game.player.Player;
+import forge.game.zone.ZoneType;
+import org.testng.AssertJUnit;
+import org.testng.annotations.Test;
+
+/**
+ * Reproduces #9297: taking a snapshot crashes with
+ * "IndexOutOfBoundsException: Index: 9, Size: 7" when a card whose controller is not its
+ * owner sits in an ordered hidden zone.
+ *
+ * Such a card belongs to its owner's graveyard, but the snapshot files it under the
+ * controller, so it is inserted into the wrong player's graveyard at the index it had in
+ * the owner's — past the end of the shorter list.
+ */
+public class SnapshotStolenCardTest extends AITest {
+
+    @Test
+    public void snapshotWithAStolenCardInAGraveyard() {
+        Game game = initAndCreateGame();
+        game.EXPERIMENTAL_RESTORE_SNAPSHOT = true;
+        Player owner = game.getPlayers().get(0);
+        Player thief = game.getPlayers().get(1);
+        game.getPhaseHandler().setPriority(owner);
+
+        // The thief's graveyard is shorter than the position the stolen card has in the
+        // owner's — 7 and 9 in the report.
+        for (int i = 0; i < 7; i++) {
+            addCardToZone("Mountain", thief, ZoneType.Graveyard);
+        }
+        for (int i = 0; i < 9; i++) {
+            addCardToZone("Forest", owner, ZoneType.Graveyard);
+        }
+        Card stolen = addCardToZone("Island", owner, ZoneType.Graveyard);
+        stolen.setController(thief, game.getNextTimestamp());
+
+        AssertJUnit.assertEquals(thief, stolen.getController());
+        AssertJUnit.assertEquals(owner, stolen.getOwner());
+        AssertJUnit.assertEquals(9, owner.getZone(ZoneType.Graveyard).getCards().indexOf(stolen));
+
+        game.stashGameState(); // threw IndexOutOfBoundsException
+
+        // The snapshot has to keep the card in the graveyard it is actually in.
+        AssertJUnit.assertTrue(game.restoreGameState());
+        Card after = game.findById(stolen.getId());
+        AssertJUnit.assertNotNull("stolen card survived the snapshot", after);
+        AssertJUnit.assertEquals(ZoneType.Graveyard, after.getZone().getZoneType());
+        AssertJUnit.assertEquals("still in its owner's graveyard", owner, after.getZone().getPlayer());
+    }
+}
diff --git a/forge-gui/res/languages/en-US.properties b/forge-gui/res/languages/en-US.properties
index 8534573c..eda66c2b 100644
--- a/forge-gui/res/languages/en-US.properties
+++ b/forge-gui/res/languages/en-US.properties
@@ -452,6 +452,20 @@ lblReleaseNotes=Release Notes
 #GameMenu.java
 lblGame=Game
 lblUndo=Undo
+lblRewind=Rewind
+lblSaveGame=Save game...
+lblLoadGame=Load game...
+lblLoadSavedGame=Load saved game...
+lblSavedGameUnreadable=That file does not look like a saved game.
+lblGameSavedTo=Game saved to:
+lblSaveNeedsPriority=Saving only works while you have priority. Finish what you are doing first.
+lblLoadNeedsPriority=Loading only works while you have priority. Finish what you are doing first.
+lblRewindToTurn=Restart turn {0}
+lblRewindNoPoints=(nothing to take back yet)
+cbpRewindSteps=Rewind turns
+nlRewindSteps=How many of your own turns the Game menu's rewind can restart. A position is recorded at the start of each of your turns, in your first main phase. Applies to the next game started.
+lblNothingToRewind=There is nothing left to rewind.
+lblRewindNeedsPriority=Rewinding only works while you have priority. Cancel what you are doing first.
 lblAlphaStrike=Alpha Strike
 lblEndTurn=End Turn
 lblTargetingArcs=Targeting Arcs
diff --git a/forge-gui/src/main/java/forge/gamemodes/match/HostedMatch.java b/forge-gui/src/main/java/forge/gamemodes/match/HostedMatch.java
index e944de68..3e5f4a76 100644
--- a/forge-gui/src/main/java/forge/gamemodes/match/HostedMatch.java
+++ b/forge-gui/src/main/java/forge/gamemodes/match/HostedMatch.java
@@ -161,6 +161,8 @@ public class HostedMatch {
 
         game = match.createGame();
         game.EXPERIMENTAL_RESTORE_SNAPSHOT = FModel.getPreferences().getPrefBoolean(FPref.MATCH_EXPERIMENTAL_RESTORE);
+        game.REWIND_STEPS = Math.max(0, FModel.getPreferences().getPrefInt(FPref.MATCH_REWIND_STEPS));
+        game.setRewindAutosave(RewindAutosave::write);
         game.AI_TIMEOUT = FModel.getPreferences().getPrefInt(FPref.MATCH_AI_TIMEOUT);
         // Android API 31 and above can use completeOnTimeout -> CompletableFuture:
         //https://developer.android.com/reference/java/util/concurrent/CompletableFuture#completeOnTimeout(T,%20long,%20java.util.concurrent.TimeUnit)
diff --git a/forge-gui/src/main/java/forge/gamemodes/match/RewindAutosave.java b/forge-gui/src/main/java/forge/gamemodes/match/RewindAutosave.java
new file mode 100644
index 00000000..3163ccb6
--- /dev/null
+++ b/forge-gui/src/main/java/forge/gamemodes/match/RewindAutosave.java
@@ -0,0 +1,83 @@
+package forge.gamemodes.match;
+
+import java.io.File;
+import java.io.IOException;
+import java.nio.charset.StandardCharsets;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.Paths;
+import java.time.LocalDateTime;
+import java.time.format.DateTimeFormatter;
+import java.util.Arrays;
+import java.util.Comparator;
+import java.util.List;
+
+import org.tinylog.Logger;
+
+import forge.localinstance.properties.ForgeConstants;
+
+/**
+ * Writes every rewind point to disk as well as into memory.
+ *
+ * Forge can end up with no window while the game itself is still running — a panel that
+ * throws while a screen is being switched aborts the layout load, and if the frame is then
+ * closed the position is only reachable by attaching to the live process. These files are
+ * the cheap way out of that: the last few turns are always on disk, loadable through
+ * <i>Forge &rarr; Load saved game</i>.
+ *
+ * The folder keeps a rolling window of the newest {@link #KEEP} files and deletes the rest,
+ * so it cannot grow without bound while still leaving a short history to pick from.
+ */
+public final class RewindAutosave {
+
+    /** How many autosaves to keep. Roughly the last hour of a game. */
+    private static final int KEEP = 12;
+
+    private static final String DIR = ForgeConstants.USER_GAMES_DIR + "autosave" + ForgeConstants.PATH_SEPARATOR;
+    private static final String PREFIX = "autosave_";
+    private static final String SUFFIX = ".txt";
+    private static final DateTimeFormatter STAMP = DateTimeFormatter.ofPattern("yyyy-MM-dd_HH-mm-ss");
+
+    private RewindAutosave() { }
+
+    /** Where the files land, so callers can tell the user. */
+    public static String getFolder() {
+        return DIR;
+    }
+
+    public static void write(final int turn, final List<String> stateText) {
+        final Path dir = Paths.get(DIR);
+        try {
+            Files.createDirectories(dir);
+        } catch (IOException e) {
+            Logger.warn(e, "Could not create the autosave folder {}", DIR);
+            return;
+        }
+
+        final Path file = dir.resolve(String.format("%s%s_turn%d%s",
+                PREFIX, LocalDateTime.now().format(STAMP), turn, SUFFIX));
+        try {
+            Files.write(file, String.join("\n", stateText).getBytes(StandardCharsets.UTF_8));
+        } catch (IOException e) {
+            Logger.warn(e, "Could not write the autosave {}", file);
+            return;
+        }
+
+        prune(dir);
+    }
+
+    /** Drops everything past the newest KEEP files. Failure here is not worth reporting twice. */
+    private static void prune(final Path dir) {
+        final File[] saves = dir.toFile().listFiles(
+                (d, name) -> name.startsWith(PREFIX) && name.endsWith(SUFFIX));
+        if (saves == null || saves.length <= KEEP) {
+            return;
+        }
+        Arrays.sort(saves, Comparator.comparingLong(File::lastModified).reversed());
+        for (int i = KEEP; i < saves.length; i++) {
+            if (!saves[i].delete()) {
+                Logger.warn("Could not remove the old autosave {}", saves[i]);
+            }
+        }
+    }
+}
diff --git a/forge-gui/src/main/java/forge/gamemodes/net/server/FServerManager.java b/forge-gui/src/main/java/forge/gamemodes/net/server/FServerManager.java
index b38e0942..dfeede7c 100644
--- a/forge-gui/src/main/java/forge/gamemodes/net/server/FServerManager.java
+++ b/forge-gui/src/main/java/forge/gamemodes/net/server/FServerManager.java
@@ -105,6 +105,20 @@ public final class FServerManager implements IHasForgeLog {
         return clients.get(ch);
     }
 
+    /**
+     * Make every connected client take a full game state on its next update instead of a
+     * delta. Needed after the host rewinds the game, since a delta cannot describe a jump
+     * backwards in time.
+     */
+    public void resyncAllClients() {
+        for (final RemoteClient client : clients.values()) {
+            final RemoteClientGuiGame gui = client.getGui();
+            if (gui != null) {
+                gui.setResyncPending();
+            }
+        }
+    }
+
     /** O(n) scan — pod size is capped at 8, so the map keyed by Channel stays the source of truth. */
     public RemoteClient getClientBySlotIndex(int slotIndex) {
         for (RemoteClient client : clients.values()) {
diff --git a/forge-gui/src/main/java/forge/localinstance/properties/ForgePreferences.java b/forge-gui/src/main/java/forge/localinstance/properties/ForgePreferences.java
index 5725898f..f672c82b 100644
--- a/forge-gui/src/main/java/forge/localinstance/properties/ForgePreferences.java
+++ b/forge-gui/src/main/java/forge/localinstance/properties/ForgePreferences.java
@@ -199,6 +199,7 @@ public class ForgePreferences extends PreferencesStore<ForgePreferences.FPref> {
         MATCH_AI_TIMEOUT("5"),
         UI_ENABLE_AI_CHEATS ("false"),
         MATCH_EXPERIMENTAL_RESTORE("false"),
+        MATCH_REWIND_STEPS("3"),
 
         ENFORCE_DECK_LEGALITY ("true"),
         PERFORMANCE_MODE ("false"),
diff --git a/forge-gui/src/main/java/forge/player/PlayerControllerHuman.java b/forge-gui/src/main/java/forge/player/PlayerControllerHuman.java
index ffb6a929..947afa93 100644
--- a/forge-gui/src/main/java/forge/player/PlayerControllerHuman.java
+++ b/forge-gui/src/main/java/forge/player/PlayerControllerHuman.java
@@ -6,6 +6,7 @@ import forge.StaticData;
 import forge.ai.AvailableActions;
 import forge.game.GameState;
 import forge.ai.PlayerControllerAi;
+import forge.gamemodes.net.server.FServerManager;
 import forge.gamemodes.net.server.RemoteClientGuiGame;
 import forge.card.*;
 import forge.card.mana.ManaCost;
@@ -94,6 +95,7 @@ import org.apache.commons.lang3.tuple.ImmutablePair;
 import org.apache.commons.lang3.tuple.Pair;
 
 import java.io.*;
+import java.text.SimpleDateFormat;
 import java.util.*;
 import java.util.Map.Entry;
 import java.util.function.Function;
@@ -1724,6 +1726,9 @@ public class PlayerControllerHuman extends PlayerController implements IGameCont
         }
 
         netLog.trace("Creating InputPassPriority for player {}", player.getName());
+        // The player is being asked, which is what the rewind held out for — from the next
+        // priority on, auto-pass behaves as configured again.
+        suppressAutoPassAfterRewind = false;
         final InputPassPriority defaultInput = new InputPassPriority(this);
         defaultInput.showAndWait();
         netLog.trace("InputPassPriority returned for player {}, chosenSa={}", player.getName(), defaultInput.getChosenSa());
@@ -2697,6 +2702,125 @@ public class PlayerControllerHuman extends PlayerController implements IGameCont
         AchievementCollection.updateAll(this);
     }
 
+    /** Set from the GUI thread, read by the game thread in PhaseHandler#mainLoopStep. */
+    private volatile int rewindStepsRequested = 0;
+
+    /** Holds off a single auto-pass so a rewind is not skipped past immediately. */
+    private volatile boolean suppressAutoPassAfterRewind = false;
+
+    /** How many of this player's own actions can currently be rewound (0 = none). */
+    public int getAvailableRewindSteps() {
+        return getGame().getAvailableRewindSteps(player);
+    }
+
+    /** Where each available rewind step leads, newest first, for labelling the menu. */
+    public List<String> describeRewindPoints() {
+        return getGame().describeRewindPoints(player);
+    }
+
+    /**
+     * Ask the game loop to undo this player's last action, along with everything that
+     * happened after it. Called from the GUI thread; the rewind itself happens on the
+     * game thread, which is why this only ends the current input and sets a flag.
+     */
+    public void requestRewind(final int steps) {
+        if (getAvailableRewindSteps() < steps) {
+            getGui().message(localizer.getMessage("lblNothingToRewind"), localizer.getMessage("lblRewind"));
+            return;
+        }
+        if (!(inputProxy.getInput() instanceof InputPassPriority)) {
+            // Mid-cast or mid-payment the game thread is deep inside an action; cancel that
+            // first, then rewind.
+            getGui().message(localizer.getMessage("lblRewindNeedsPriority"), localizer.getMessage("lblRewind"));
+            return;
+        }
+        rewindStepsRequested = steps;
+        passPriority(); // ends the input so the game loop reaches the rewind check
+    }
+
+    /**
+     * Writes the current position to a file the player picks. Reading the game is only safe
+     * while it is waiting for input, which is exactly when this is reachable from the menu.
+     */
+    public void saveGameToFile() {
+        if (!(inputProxy.getInput() instanceof InputPassPriority)) {
+            getGui().message(localizer.getMessage("lblSaveNeedsPriority"), localizer.getMessage("lblSaveGame"));
+            return;
+        }
+        final File dir = new File(ForgeConstants.USER_GAMES_DIR);
+        if (!dir.exists()) {
+            dir.mkdirs();
+        }
+        final String stamp = new SimpleDateFormat("yyyy-MM-dd_HH-mm").format(new Date());
+        final File file = GuiBase.getInterface().getSaveFile(new File(dir, "game_" + stamp + ".txt"));
+        if (file == null) {
+            return;
+        }
+        try {
+            final GameState state = new GameState();
+            state.initFromGame(getGame());
+            try (BufferedWriter bw = new BufferedWriter(new FileWriter(file))) {
+                bw.write(state.toString());
+            }
+            getGui().message(localizer.getMessage("lblGameSavedTo") + "\n" + file.getPath(),
+                    localizer.getMessage("lblSaveGame"));
+        } catch (final Exception e) {
+            getGui().showErrorDialog(e.getClass().getName() + ": " + e.getMessage());
+        }
+    }
+
+    /**
+     * Reads a saved position and hands it to the game loop, which swaps it in between
+     * actions — see PlayerController#consumePendingGameState.
+     */
+    public void loadGameFromFile() {
+        if (!(inputProxy.getInput() instanceof InputPassPriority)) {
+            getGui().message(localizer.getMessage("lblLoadNeedsPriority"), localizer.getMessage("lblLoadGame"));
+            return;
+        }
+        final File dir = new File(ForgeConstants.USER_GAMES_DIR);
+        if (!dir.exists()) {
+            dir.mkdirs();
+        }
+        final String filename = GuiBase.getInterface().showFileDialog(localizer.getMessage("lblLoadGame"),
+                ForgeConstants.USER_GAMES_DIR);
+        if (filename == null) {
+            return;
+        }
+        final GameState state = new GameState();
+        try (FileInputStream in = new FileInputStream(filename)) {
+            state.parse(in);
+        } catch (final Exception e) {
+            getGui().showErrorDialog(localizer.getMessage("lblErrorLoadingBattleSetupFile") + "\n" + filename);
+            return;
+        }
+        setPendingGameState(state);
+        passPriority(); // ends the input so the game loop reaches the load
+    }
+
+    @Override
+    public int consumeRewindRequest() {
+        final int steps = rewindStepsRequested;
+        rewindStepsRequested = 0;
+        return steps;
+    }
+
+    @Override
+    public void afterRewind() {
+        // A rewind is a deliberate stop, so nothing may race the game forward again before
+        // the player has acted in the position they went back to. "Pass until end of turn"
+        // is switched off outright — it was a decision about a turn that no longer stands —
+        // and the auto-pass at the restored priority is skipped once.
+        yieldController.setAutoPassUntilEndOfTurn(false);
+        suppressAutoPassAfterRewind = true;
+        getGui().updateAutoPassPrompt();
+
+        // Deltas can't express a jump backwards, so push the full state to every client.
+        if (FServerManager.getInstance().isHosting()) {
+            FServerManager.getInstance().resyncAllClients();
+        }
+    }
+
     public boolean canUndoLastAction() {
         if (!getGame().stack.canUndo(player)) {
             return false;
@@ -3816,6 +3940,9 @@ public class PlayerControllerHuman extends PlayerController implements IGameCont
     }
 
     public boolean mayAutoPass() {
+        if (suppressAutoPassAfterRewind) {
+            return false;
+        }
         return yieldController.shouldAutoYield()
                 || yieldController.isAutoPassingNoActions(getLocalPlayerView());
     }