diff --git a/api/controllers/game/load-fixture-gamestate.js b/api/controllers/game/load-fixture-gamestate.js
index 0c757005c..cd6b710ec 100644
--- a/api/controllers/game/load-fixture-gamestate.js
+++ b/api/controllers/game/load-fixture-gamestate.js
@@ -22,6 +22,12 @@ module.exports = async function (req, res) {
       secondCard = null,
       scrap = [],
       deck,
+      // Overrides so tests can stage states no live move can produce anymore -- notably the
+      // legacy RESOLVING_FOUR phase, which stored games still hold and replay.
+      phase = GamePhase.MAIN,
+      turn = 0,
+      resolved = null,
+      oneOff = null,
     } = req.body;
 
     const allFixtureCards = new Set(Object.values(req.body).flat()
@@ -58,15 +64,15 @@ module.exports = async function (req, res) {
       scrap: populatedScrap,
       twos: [],
       discardedCards: [],
-      oneOff: null,
+      oneOff,
       oneOffTarget: null,
-      resolved: null,
+      resolved,
       playedCard: null,
       gameId: game.id,
       playedBy: 0,
       moveType: MoveType.LOADFIXTURE,
-      turn: 0,
-      phase: GamePhase.MAIN,
+      turn,
+      phase,
       targetCard: null,
     };
 
diff --git a/api/helpers/game-states/ai/get-legal-moves.js b/api/helpers/game-states/ai/get-legal-moves.js
index 5eeb71382..cc9d7e6a4 100644
--- a/api/helpers/game-states/ai/get-legal-moves.js
+++ b/api/helpers/game-states/ai/get-legal-moves.js
@@ -24,7 +24,9 @@ module.exports = {
   },
   sync: true,
   fn: ({ currentState, playedBy, priorStates }, exits) => {
-    const disallowedMoveTypes = [ 'DEAL', 'CONCEDE', 'STALEMATE_REQUEST', 'STALEMATE_ACCEPT', 'FIZZLE', 'LOADFIXTURE' ];
+    // RESOLVE_FOUR is retained in the enum so stored games still render, but its move helper is
+    // gone -- fours resolve immediately now -- so it must not be looked up here.
+    const disallowedMoveTypes = [ 'DEAL', 'CONCEDE', 'STALEMATE_REQUEST', 'STALEMATE_ACCEPT', 'FIZZLE', 'LOADFIXTURE', 'RESOLVE_FOUR' ];
     const moveTypes = Object.values(_.omit(MoveType, disallowedMoveTypes));
     const res = [];
     for (let moveType of moveTypes) {
diff --git a/api/helpers/game-states/ai/get-move-bodies-for-move-type.js b/api/helpers/game-states/ai/get-move-bodies-for-move-type.js
index 37fee3fab..60322e2b6 100644
--- a/api/helpers/game-states/ai/get-move-bodies-for-move-type.js
+++ b/api/helpers/game-states/ai/get-move-bodies-for-move-type.js
@@ -130,30 +130,6 @@ module.exports = {
         res = scrap.map((card) => ({ moveType, playedBy, cardId: card.id }));
         break;
 
-      case MoveType.RESOLVE_FOUR: {
-
-        if (playerHand.length === 1) {
-          res = [
-            {
-              moveType,
-              playedBy,
-              cardId1: playerHand[0].id,
-            },
-          ];
-        }
-
-        for (let i = 0; i < playerHand.length; i++) {
-          for (let j = i + 1; j < playerHand.length; j++) {
-            res.push({
-              moveType,
-              playedBy,
-              cardId1: playerHand[i].id,
-              cardId2: playerHand[j].id
-            });
-          }
-        }
-        break;
-      }
 
       case MoveType.RESOLVE_FIVE:
         if (!playerHand.length) {
diff --git a/api/helpers/game-states/get-log.js b/api/helpers/game-states/get-log.js
index 1cae92aee..d6839aace 100644
--- a/api/helpers/game-states/get-log.js
+++ b/api/helpers/game-states/get-log.js
@@ -91,8 +91,17 @@ module.exports = {
               return `The ${resolvedCardName} resolves; the ${targetCardName} is scrapped.`;
             case 3:
               return `The ${resolvedCardName} one-off resolves; ${opponent} will draw one card of their choice from the Scrap pile.`;
-            case 4:
-              return `The ${resolvedCardName} one-off resolves; ${player} must discard two cards.`;
+            case 4: {
+              // Legacy rows (rules < 3.0.0) deferred the discard to a separate resolveFour
+              // move, so the cards are named on that row and this one carries none.
+              if (!discardedCards?.length) {
+                return `The ${resolvedCardName} one-off resolves; ${player} must discard two cards.`;
+              }
+              const discardNames = discardedCards.map(getFullCardName);
+              const discardList =
+                discardNames.length > 1 ? `the ${discardNames[0]} and the ${discardNames[1]}` : `the ${discardNames[0]}`;
+              return `The ${resolvedCardName} one-off resolves, discarding ${discardList} at random from ${player}'s hand.`;
+            }
             case 5:
               return `The ${resolvedCardName} one-off resolves; ${opponent} must discard 1 card, and will draw up to 3.`;
             case 6:
diff --git a/api/helpers/game-states/moves/one-off/validate.js b/api/helpers/game-states/moves/one-off/validate.js
index e1cb41517..4c2d9de29 100644
--- a/api/helpers/game-states/moves/one-off/validate.js
+++ b/api/helpers/game-states/moves/one-off/validate.js
@@ -125,11 +125,9 @@ module.exports = {
           }
           return exits.success();
 
-        // Four requires opponent to have cards in hand
+        // Fours discard at random, so an empty hand just discards nothing. The arm has to
+        // stay: the default below rejects any rank that isn't explicitly allowed here.
         case 4:
-          if (!opponent.hand.length) {
-            throw new Error('game.snackbar.oneOffs.four.opponentHasNoCards');
-          }
           return exits.success();
 
         // Five and sevens require cards in deck
diff --git a/api/helpers/game-states/moves/resolve-four/execute.js b/api/helpers/game-states/moves/resolve-four/execute.js
deleted file mode 100644
index 9a5a8f723..000000000
--- a/api/helpers/game-states/moves/resolve-four/execute.js
+++ /dev/null
@@ -1,73 +0,0 @@
-const GamePhase = require('../../../../../utils/GamePhase.json');
-
-module.exports = {
-  friendlyName: 'Resolve four',
-
-  description: 'Returns new GameState resulting from requested resolve four move',
-
-  inputs: {
-    currentState: {
-      type: 'ref',
-      description: 'The latest GameState before the requesting player resolves a four card',
-      required: true,
-    },
-    /**
-     * @param { Object } requestedMove - Object describing the request to resolve a four
-     * @param { String } requestedMove.cardId1 - First card to be discarded
-     * @param { String } requestedMove.cardId2 - Second card to be discarded
-     * @param { MoveType.RESOLVE_FOUR } requestedMove.moveType - Specifies that this is a Resolve Four move
-     */
-    requestedMove: {
-      type: 'ref',
-      description: 'The move being requested. Specifies which player is asking to resolve a four',
-    },
-    playedBy: {
-      type: 'number',
-      description: 'Player number of player requesting move.',
-    },
-    priorStates: {
-      type: 'ref',
-      description: 'List of packed gameStateRows for this game\'s prior states',
-      required: true,
-    }
-  },
-  sync: true, // synchronous helper
-  fn: ({ currentState, requestedMove, playedBy }, exits) => {
-    const { cardId1, cardId2 } = requestedMove;
-    let result = _.cloneDeep(currentState);
-
-    const player = playedBy ? result.p1 : result.p0;
-    const discardedCards = [];
-
-    const cardIndex1 = player.hand.findIndex(({ id }) => id === cardId1);
-
-    discardedCards.push(player.hand[cardIndex1]);
-    result.scrap.push(result.oneOff, ...player.hand.splice(cardIndex1, 1));
-  
-    const cardIndex2 = cardId2 ? player.hand.findIndex(({ id }) => id === cardId2) : -1;
-
-    if (cardIndex2 !== -1) {
-      discardedCards.push(player.hand[cardIndex2]);
-      result.scrap.push(...player.hand.splice(cardIndex2, 1));
-    }
-
-    // active player is the opposite of the one who discarded
-    const activePlayer = playedBy ? result.p0 : result.p1;
-    const playerMustDiscard = activePlayer.hand.length > 8;
-
-    result = {
-      ...result,
-      ...requestedMove,
-      phase: playerMustDiscard ? GamePhase.DISCARDING_TO_HAND_LIMIT : GamePhase.MAIN,
-      turn: playerMustDiscard ? result.turn : result.turn + 1,
-      playedBy,
-      playedCard: null,
-      targetCard: null,
-      discardedCards,
-      resolved: result.oneOff,
-      oneOff: null,
-    };
-
-    return exits.success(result);
-  },
-};
diff --git a/api/helpers/game-states/moves/resolve-four/validate.js b/api/helpers/game-states/moves/resolve-four/validate.js
deleted file mode 100644
index 63a7cfa89..000000000
--- a/api/helpers/game-states/moves/resolve-four/validate.js
+++ /dev/null
@@ -1,67 +0,0 @@
-const GamePhase = require('../../../../../utils/GamePhase.json');
-const BadRequestError = require('../../../../errors/badRequestError');
-
-module.exports = {
-  friendlyName: 'Validate request to resolve a four',
-
-  description: 'Verifies whether a request to resolve a four is legal, throwing explanatory error if not.',
-
-  inputs: {
-    currentState: {
-      type: 'ref',
-      descriptions: 'Object containing the current game state',
-      required: true,
-    },
-    /**
-     * @param { Object } requestedMove - Object describing the request to resolve a four
-     * @param { String } requestedMove.cardId1 - First card to be discarded
-     * @param { String } requestedMove.cardId2 - Second card to be discarded
-     * @param { MoveType.RESOLVE_FOUR } requestedMove.moveType - Specifies that this is a Resolve Four move
-     */
-    requestedMove: {
-      type: 'ref',
-      description: 'Object containing data needed for current move',
-      required: true,
-    },
-    playedBy: {
-      type: 'number',
-      description: 'Player number of player requesting move',
-      required: true,
-    },
-    priorStates: {
-      type: 'ref',
-      description: 'List of packed gameStateRows for this game\'s prior states',
-      required: true,
-    }
-  },
-  sync: true,
-  fn: ({ requestedMove, currentState, playedBy }, exits) => {
-    try {
-      if (currentState.turn % 2 === playedBy) {
-        throw new BadRequestError('game.snackbar.oneOffs.four.notYourTurn');
-      }
-
-      if (currentState.phase !== GamePhase.RESOLVING_FOUR) {
-        throw new BadRequestError('game.snackbar.oneOffs.four.notResolvingFourPhase');
-      }
-
-      const player = playedBy ? currentState.p1 : currentState.p0;
-      const { cardId1, cardId2 } = requestedMove;
-
-      const selectedCard1 = player.hand.find(card => card.id === cardId1);
-      const selectedCard2 = player.hand.find(card => card.id === cardId2);
-
-      if ((requestedMove.cardId1 && !selectedCard1) || (requestedMove.cardId2 && !selectedCard2)) {
-        throw new BadRequestError('game.snackbar.oneOffs.four.mustSelectCards');
-      }
-
-      if (!selectedCard2 && player.hand.length > 1) {
-        throw new BadRequestError('game.snackbar.oneOffs.four.mustSelectCards');
-      }
-
-      return exits.success();
-    } catch (err) {
-      return exits.error(err);
-    }
-  },
-};
diff --git a/api/helpers/game-states/moves/resolve/execute.js b/api/helpers/game-states/moves/resolve/execute.js
index 728b0eedb..558af2e19 100644
--- a/api/helpers/game-states/moves/resolve/execute.js
+++ b/api/helpers/game-states/moves/resolve/execute.js
@@ -79,8 +79,10 @@ module.exports = {
       case 6:
         result = sails.helpers.gameStates.moves.resolve.six(result);
         break;
-      case 3:
       case 4:
+        result = sails.helpers.gameStates.moves.resolve.four(result, playedBy);
+        break;
+      case 3:
       case 5:
       case 7:
         // These one-offs require an additional user input after resolving
diff --git a/api/helpers/game-states/moves/resolve/four.js b/api/helpers/game-states/moves/resolve/four.js
new file mode 100644
index 000000000..88670ea9f
--- /dev/null
+++ b/api/helpers/game-states/moves/resolve/four.js
@@ -0,0 +1,39 @@
+module.exports = {
+  friendlyName: 'Resolve Four One-Off',
+
+  description:
+    'Returns new GameState resulting from resolving a four, which discards two cards at random from the ' +
+    'hand of the player resolving it. A hand of fewer than two cards discards whatever it holds.',
+
+  inputs: {
+    currentState: {
+      type: 'ref',
+      description: 'The latest GameState before the four discards its two cards',
+      required: true,
+    },
+    playedBy: {
+      type: 'number',
+      description: 'Player number of player requesting move.',
+    }
+  },
+
+  sync: true, // synchronous helper
+  fn: ({ currentState, playedBy }, exits) => {
+    const result = _.cloneDeep(currentState);
+
+    // The player resolving the one-off is the opposite of the one who played it, so `playedBy`
+    // identifies the player whose hand is discarded -- not the four's caster.
+    const victim = playedBy ? result.p1 : result.p0;
+
+    // sampleSize returns *up to* two cards, so a short hand simply discards everything it has
+    const discardedCards = _.sampleSize(victim.hand, 2);
+    const discardedIds = new Set(discardedCards.map(({ id }) => id));
+
+    // Filter by id rather than splicing -- sampleSize returns the cards, not their positions
+    victim.hand = victim.hand.filter(({ id }) => !discardedIds.has(id));
+    result.scrap.push(...discardedCards);
+    result.discardedCards = discardedCards;
+
+    return exits.success(result);
+  },
+};
diff --git a/api/helpers/game-states/moves/seven-one-off/validate.js b/api/helpers/game-states/moves/seven-one-off/validate.js
index 219b3006e..616aec686 100644
--- a/api/helpers/game-states/moves/seven-one-off/validate.js
+++ b/api/helpers/game-states/moves/seven-one-off/validate.js
@@ -114,10 +114,9 @@ module.exports = {
           return exits.success();
 
         // Four requires opponent to have cards in hand
+        // Fours discard at random, so an empty hand just discards nothing. The arm has to
+        // stay: the default below rejects any rank that isn't explicitly allowed here.
         case 4:
-          if (!opponent.hand.length) {
-            throw new BadRequestError('game.snackbar.oneOffs.four.opponentHasNoCards');
-          }
           return exits.success();
 
         // Five and sevens require cards in deck
diff --git a/api/models/GameStateRow.js b/api/models/GameStateRow.js
index f04539b53..1e77c3e0f 100644
--- a/api/models/GameStateRow.js
+++ b/api/models/GameStateRow.js
@@ -66,7 +66,7 @@ module.exports = {
      * 1 - MAIN
      * 2 - COUNTERING
      * 3 - RESOLVING_THREE
-     * 4 - RESOLVING_FOUR
+     * 4 - RESOLVING_FOUR (legacy; rules < 3.0.0 only -- fours resolve immediately now)
      * 5 - RESOLVING_FIVE
      * 7 - RESOLVING_SEVEN
      */
diff --git a/api/policies/hasValidMoveBody.js b/api/policies/hasValidMoveBody.js
index 69a3a0ed4..6fcf808ce 100644
--- a/api/policies/hasValidMoveBody.js
+++ b/api/policies/hasValidMoveBody.js
@@ -10,7 +10,7 @@ const DeckIds = require('../../utils/DeckIds.json');
  *
  */
 module.exports = function (req, res, next) {
-  const { moveType, cardId, cardId1, cardId2, targetId, targetType } = req.body;
+  const { moveType, cardId, targetId, targetType } = req.body;
 
   switch (moveType) {
     // These moves require no extra data
@@ -43,22 +43,6 @@ module.exports = function (req, res, next) {
       }
       return next();
 
-    // Requires `cardId1` and optionally accepts `cardId2`
-    case MoveType.RESOLVE_FOUR:
-      {
-        if (!cardId1) {
-          return res.badRequest({ message: 'Must specify a card' });
-        }
-
-        if (!DeckIds.includes(cardId1)) {
-          return res.badRequest({ message: `${cardId1} is not a valid cardId` });
-        }
-
-        if (cardId2 && !DeckIds.includes(cardId2)) {
-          return res.badRequest({ message: `${cardId2} is not a valid cardId` });
-        }
-      }
-      return next();
 
     // Requires a non-empty `discardedCards` array of valid card IDs
     case MoveType.DISCARD_TO_HAND_LIMIT:
diff --git a/docs/game-rules.md b/docs/game-rules.md
index ca77309b3..bf389741b 100644
--- a/docs/game-rules.md
+++ b/docs/game-rules.md
@@ -44,7 +44,7 @@ On your turn you must make exactly one of the following actions below.
   1. Counter **target One-Off** (play this when an opponent plays a **One-Off** effect to stop it from happening)
   2. Scrap **target Royal or Glasses Eight**
 - **Three**: Choose one card from the **Scrap Pile** and put it in your hand.
-- **Four**: Your opponent discards two cards of their choice from their hand to the **Scrap Pile**
+- **Four**: Two cards are discarded at random from your opponent's hand to the **Scrap Pile**. If they hold fewer than two cards, they discard whatever they have.
 - **Five**: Discard one card then draw up to three cards from the **Deck** up to the 8 card hand limit.
 - **Six**: Scrap all **Royals and Glasses Eights**, including your own.
 - **Seven**: Reveal the top two cards from the **Deck** and choose one of them to play immediately. Play this card however you would like. The other card is placed back on top of the deck.
diff --git a/docs/game-state-api.md b/docs/game-state-api.md
index 206f52c19..df19137d2 100644
--- a/docs/game-state-api.md
+++ b/docs/game-state-api.md
@@ -27,7 +27,7 @@ Enum describing the phase of a turn the game is currently in. Used to validate w
    * counter  
    * resolve  
 * resolvingThree \- Picking card from scrap. Only legal move is resolveThree  
-* resolvingFour \- Choosing cards to discard due to opponent four. Only legal move is resolveFour  
+* resolvingFour \- **Legacy (rules \< 3.0.0).** Choosing cards to discard due to opponent four; the only legal move was resolveFour. As of rules 3.0.0 a four discards two cards at random the moment it resolves, so no new game enters this phase. The value is retained because stored games still hold it and are re-rendered on replay.  
 * resolvingFive \- Choosing card to discard before drawing. Only legal move is resolveFive  
 * resolvingSeven \- Picking one of the top cards from the deck. Must play a seven move next. Legal next moves:  
    * sevenPoints  
@@ -56,7 +56,7 @@ Enum designating which kind of move was made.
 * resolve  
 * fizzle \- a one-off was countered, so it and everything played on it are scrapped  
 * resolveThree (picking a card from the scrap)  
-* resolveFour (discarding from hand)  
+* resolveFour (discarding from hand) \- **Legacy (rules \< 3.0.0);** no longer accepted, retained so stored games still render  
 * resolveFive (discarding before drawing)  
 * discardToHandLimit  
 * sevenPoints  
diff --git a/src/plugins/sockets/inGameEvents.js b/src/plugins/sockets/inGameEvents.js
index f239d1bd8..a4e9d12c6 100644
--- a/src/plugins/sockets/inGameEvents.js
+++ b/src/plugins/sockets/inGameEvents.js
@@ -63,6 +63,15 @@ export async function handleInGameEvents(evData, newRoute = null) {
       break;
     case SocketEvent.RESOLVE:
       switch (evData.game.lastEvent?.oneOff?.rank) {
+        // playedBy on a resolve is the player who resolved it -- the one whose hand was
+        // discarded -- so anyone else watching is the caster, who needs the reveal
+        case 4:
+          if (evData.playedBy !== gameStore.myPNum) {
+            await gameStore.processFours(evData.discardedCards, evData.game);
+          } else {
+            gameStore.updateGame(evData.game);
+          }
+          break;
         case 7:
           await gameStore.processSevens(evData.game);
           break;
@@ -80,6 +89,8 @@ export async function handleInGameEvents(evData, newRoute = null) {
     case SocketEvent.RESOLVE_THREE:
       await gameStore.processThrees(evData.chosenCard, evData.game);
       break;
+    // Legacy: fours resolve immediately as of rules 3.0.0, but stored games still step
+    // through a separate resolveFour frame, and this switch has no default to fall back on
     case SocketEvent.RESOLVE_FOUR:
       if (evData.playedBy !== gameStore.myPNum) {
         await gameStore.processFours(evData.discardedCards, evData.game);
diff --git a/src/routes/game/GameView.vue b/src/routes/game/GameView.vue
index 6eab6d613..c2a901949 100644
--- a/src/routes/game/GameView.vue
+++ b/src/routes/game/GameView.vue
@@ -466,7 +466,6 @@ export default {
       targeting: false,
       targetingMoveName: null,
       targetingMoveDisplayName: null,
-      showFourDialog: false,
       topCardIsSelected: false,
       secondCardIsSelected: false,
       showHistoryDrawer: false,
diff --git a/src/routes/game/components/dialogs/GameDialogs.vue b/src/routes/game/components/dialogs/GameDialogs.vue
index ef63e3daf..e13211967 100644
--- a/src/routes/game/components/dialogs/GameDialogs.vue
+++ b/src/routes/game/components/dialogs/GameDialogs.vue
@@ -154,13 +154,17 @@ export default {
       this.gameStore.requestCounter(twoId).then(this.clearSelection)
         .catch(this.handleError);
     },
+    // Legacy: no live game can enter the four-discard phase as of rules 3.0.0, but the dialog
+    // is still rendered when replaying a stored game that did, so the handler stays wired.
     discard(cardIds) {
       const [ cardId1 ] = cardIds;
       const cardId2 = cardIds.length > 1 ? cardIds[1] : null;
-      this.gameStore.requestDiscard({
-        cardId1,
-        cardId2,
-      });
+      this.gameStore
+        .requestDiscard({
+          cardId1,
+          cardId2,
+        })
+        .catch(this.handleError);
     },
     discardToHandLimit(cardIds) {
       this.gameStore.requestDiscardToHandLimit(cardIds);
diff --git a/src/routes/game/components/dialogs/components/FourDialog.vue b/src/routes/game/components/dialogs/components/FourDialog.vue
index 429e0554c..57d29d9c6 100644
--- a/src/routes/game/components/dialogs/components/FourDialog.vue
+++ b/src/routes/game/components/dialogs/components/FourDialog.vue
@@ -1,3 +1,8 @@
+<!--
+  Legacy dialog: fours discard two cards at random as of rules 3.0.0, so no live game can
+  enter the four-discard phase. Retained because replaying a stored pre-3.0.0 game renders
+  dialogs from the historical phase.
+-->
 <template>
   <BaseDialog
     id="four-discard-dialog"
diff --git a/src/routes/home/components/announcementDialog/data/announcementData.js b/src/routes/home/components/announcementDialog/data/announcementData.js
index c58d423fb..efbabb4bd 100644
--- a/src/routes/home/components/announcementDialog/data/announcementData.js
+++ b/src/routes/home/components/announcementDialog/data/announcementData.js
@@ -1,12 +1,14 @@
 // import { Card } from '../../../../../../tests/e2e/fixtures/cards';
 
 export const announcementData = {
-  id: 'myCurrentGames2026Announcement',
+  id: 'randomFours2026Announcement',
   activatorText: 'announcement.activatorText',
   title: 'announcement.title',
-  displayCards: [],
-  imgSrc: '/img/announcement/my-current-games.png',
-  startTime: '2026-10-05',
+  displayCards: [
+    { suit: 3, rank: 4 },
+    { suit: 1, rank: 4 },
+  ],
+  startTime: '2026-09-19',
   endTime: '2027-01-05',
   announcementText: [
     {
@@ -15,7 +17,13 @@ export const announcementData = {
     },
     {
       heading: 'announcement.heading2',
-      paragraph: [ { text: 'announcement.paragraph2' } ],
+      paragraph: [
+        { text: 'announcement.paragraph2' },
+        {
+          text: 'announcement.patreonLink',
+          url: 'https://www.patreon.com/cuttle/posts/help-refine-4-9-169762967',
+        },
+      ],
     },
   ],
 };
diff --git a/src/stores/game.js b/src/stores/game.js
index 06c3b820a..e0a01b5fe 100644
--- a/src/stores/game.js
+++ b/src/stores/game.js
@@ -218,6 +218,8 @@ export const useGameStore = defineStore('game', () => {
     () => phase.value === GamePhase.RESOLVING_THREE && !isPlayersTurn.value,
   );
   const pickingFromScrap = computed(() => phase.value === GamePhase.RESOLVING_THREE && isPlayersTurn.value);
+  // Legacy: no live game enters RESOLVING_FOUR as of rules 3.0.0 (fours discard at random the
+  // moment they resolve), but replaying a stored game that did still renders the dialog.
   const showResolveFour = computed(() => phase.value === GamePhase.RESOLVING_FOUR && !isPlayersTurn.value);
   const waitingForOpponentToDiscard = computed(() => {
     switch (phase.value) {
@@ -484,7 +486,9 @@ export const useGameStore = defineStore('game', () => {
   }
   async function processFours(discardedCards, game) {
     phase.value = GamePhase.MAIN;
-    if (!showOpponentHand.value) {
+    // A four against an empty hand discards nothing, and create-socket-events sends null
+    // rather than an empty array, so this has to guard the way processFives does
+    if (discardedCards?.length && !showOpponentHand.value) {
       opponent.value.hand = [
         ...opponent.value.hand.slice(0, opponent.value.hand.length - discardedCards.length),
         ...discardedCards,
@@ -720,6 +724,8 @@ export const useGameStore = defineStore('game', () => {
     const moveType = MoveType.JACK;
     await makeSocketRequest('jack', { moveType, cardId, targetId });
   }
+  // Legacy: only reachable from the four-discard dialog, which only appears when replaying a
+  // pre-3.0.0 game. The server no longer accepts the move and answers 400.
   async function requestDiscard({ cardId1, cardId2 }) {
     const moveType = MoveType.RESOLVE_FOUR;
     const reqData = cardId2 ? { moveType, cardId1, cardId2 } : { moveType, cardId1 };
diff --git a/src/translations/de.json b/src/translations/de.json
index 916d57a70..06ef57ba6 100644
--- a/src/translations/de.json
+++ b/src/translations/de.json
@@ -236,7 +236,7 @@
         "1": "Alle Punktkarten abwerfen",
         "2": "Ziel-König oder Gläser Acht abwerfen",
         "3": "Wähle 1 Karte, die keine 3 ist, aus dem Abwurfstapel und nimm sie auf die Hand",
-        "4": "Dein Gegner wirft zwei Karten seiner Wahl ab",
+        "4": "Dein Gegner wirft zwei zufällige Karten von seiner Hand ab",
         "5": "Werfe 1 Karte ab und ziehe bis zu 3 Karten",
         "6": "Alle Könige und Gläser Acht abwerfen",
         "7": "Spiele eine der obersten zwei Karten des Decks und lege die andere zurück (beide sind aufgedeckt)",
@@ -339,12 +339,6 @@
           "mustPickFromScrap": "Du musst eine Karte aus dem Abwurfstapel wählen",
           "cannotTargetThree": "Du kannst keine 3 mit einer 3 als Ziel wählen"
         },
-        "four": {
-          "opponentHasNoCards": "Du kannst keine 4 als One-Off spielen, während dein Gegner keine Karten auf der Hand hat",
-          "notYourTurn": "Es ist nicht dein Zug zum Abwerfen",
-          "notResolvingFourPhase": "Kann nicht abgeworfen werden, es sei denn, dein Gegner hat eine 4 gespielt",
-          "mustSelectCards": "Du musst zwei Karten zum Abwerfen auswählen"
-        },
         "discardToHandLimit": {
           "notDiscardingPhase": "Du kannst nur während der Ablegephase auf die Handkartenobergrenze ablegen",
           "handNotOverLimit": "Deine Hand ist nicht über der Obergrenze",
@@ -466,7 +460,7 @@
       "three": "Drei",
       "threeDescription": "Wähle eine (nicht-Drei) Karte aus dem Ablagestapel und nimm sie auf die Hand.",
       "four": "Vier",
-      "fourDescription": "Dein Gegner legt zwei Karten seiner Wahl ab.",
+      "fourDescription": "Dein Gegner wirft zwei zufällige Karten ab.",
       "five": "Fünf",
       "fiveDescription": "Lege eine Karte ab und ziehe dann bis zu drei Karten vom Stapel.",
       "six": "Sechs",
@@ -599,12 +593,13 @@
     }
   },
   "announcement": {
-    "activatorText": "Finde deine laufenden Spiele!",
-    "title": "Deine Aktuellen Spiele",
-    "heading": "Mach da weiter, wo du aufgehört hast",
-    "paragraph": "Tab zu einem Spiel geschlossen? Deine laufenden Spiele erscheinen jetzt ganz oben im Tab Spielen. Drücke auf Fortsetzen, um direkt wieder ins Spiel zu kommen – genau da, wo du aufgehört hast.",
-    "heading2": "Aufgegebene Spiele aufräumen",
-    "paragraph2": "Fertig mit einem Spiel, zu dem niemand zurückkehrt? Das × neben Fortsetzen archiviert es und entfernt es aus den Listen beider Spieler. Spiele, die gerade gespielt werden, lassen sich nicht archivieren – und Spiele aus der Rangliste der aktuellen Woche ebenso wenig, denn die zählen noch für dein Match."
+    "activatorText": "Vierer werden verbessert!",
+    "title": "Regel-Beta: Zufällige Vierer",
+    "heading": "Vierer werfen jetzt zufällig ab",
+    "paragraph": "Der Vierer ist die schwächste Karte im Spiel: ein schwacher Effekt auf einem niedrigen Rang mit wenig Punkten und kaum Versenkungswert. Und weil dein Gegner die beiden Karten aussuchte, verlor er immer nur seine zwei schlechtesten. Jetzt werden die beiden Karten zufällig gewählt, sodass ein Vierer auch wirklich wehtun kann. Hat dein Gegner weniger als zwei Karten, wirft er ab, was er hat.",
+    "heading2": "Eine von vier Testregeln der Pik-Saison",
+    "paragraph2": "Das ist eine Beta und eine von vier Regelvarianten, die wir in der Pik-Saison testen — zwei Verbesserungen für Neuner und zwei für Vierer. Gegen Ende des Jahres stellen wir sie in einer Community-Umfrage zur Abstimmung. Den vollständigen Hintergrund zu allen vier findest du unter",
+    "patreonLink": "Die 4 und die 9 verbessern"
   },
   "profile": {
     "myGames": "Meine Spiele",
diff --git a/src/translations/en.json b/src/translations/en.json
index d0be8e940..60cbd4bfe 100644
--- a/src/translations/en.json
+++ b/src/translations/en.json
@@ -236,7 +236,7 @@
         "1": "Scrap all points",
         "2": "Scrap target Royal or Glasses eight",
         "3": "Choose 1 (non-three) card in the Scrap and put it to your hand",
-        "4": "Your opponent discards two cards of their choice from their hand",
+        "4": "Your opponent discards two cards at random from their hand",
         "5": "Discard 1 card, and draw up to 3",
         "6": "Scrap all Royals and Glasses eights",
         "7": "Play one of the top two cards of the deck and put the other back (both are revealed)",
@@ -340,12 +340,6 @@
           "mustPickFromScrap": "You must pick a card from the scrap",
           "cannotTargetThree": "You cannot target a three with a three"
         },
-        "four": {
-          "opponentHasNoCards": "You cannot play a 4 as a one-off while your opponent has no cards in hand",
-          "notYourTurn": "It's not your turn to discard",
-          "notResolvingFourPhase": "Can't discard unless your opponent played a four",
-          "mustSelectCards": "You must select two cards to discard"
-        },
         "discardToHandLimit": {
           "notDiscardingPhase": "You can only discard to the hand limit during the discard phase",
           "handNotOverLimit": "Your hand is not over the limit",
@@ -467,7 +461,7 @@
       "three": "Three",
       "threeDescription": "Choose a (non-three) card from the scrap pile and put it in your hand.",
       "four": "Four",
-      "fourDescription": "Your opponent discards two cards of their choice.",
+      "fourDescription": "Your opponent discards two cards at random.",
       "five": "Five",
       "fiveDescription": "Discard one card then draw up to three cards from the deck.",
       "six": "Six",
@@ -600,12 +594,13 @@
     }
   },
   "announcement": {
-    "activatorText": "Find your games in progress!",
-    "title": "Your Current Games",
-    "heading": "Pick up where you left off",
-    "paragraph": "Closed the tab on a game? The games you have in progress now appear at the top of the Play tab. Press Continue to drop straight back into the game, exactly where you left it.",
-    "heading2": "Clearing out abandoned games",
-    "paragraph2": "Done with a game nobody is coming back to? The × beside Continue archives it, taking it off both players' lists. Games that are still being played can't be archived, and neither can Ranked games from the current week — those still count toward your match."
+    "activatorText": "Fours are getting a buff!",
+    "title": "Rules Beta: Random Fours",
+    "heading": "Fours now discard at random",
+    "paragraph": "The Four is the weakest card in the game: a weak effect on a low rank with poor points and scuttling value. And because your opponent picked the two cards to discard, it always stripped their two worst ones. Now the two cards are chosen at random, so a Four can take something that actually hurts. If your opponent holds fewer than two cards, they discard whatever they have.",
+    "heading2": "One of four Spades season trials",
+    "paragraph2": "This is a beta, and one of four rules variations we're trialling over the Spades season — two Nine buffs and two Four buffs. We'll put them to a community poll toward the end of the year to decide what stays. For the full context and reasoning behind all four, see",
+    "patreonLink": "Help refine the 4 and the 9"
   },
   "profile": {
     "myGames": "My Games",
diff --git a/src/translations/es.json b/src/translations/es.json
index 2c1566b7e..b0fd3cbc1 100644
--- a/src/translations/es.json
+++ b/src/translations/es.json
@@ -236,7 +236,7 @@
         "1": "Descarta todas las cartas de puntos en juego",
         "2": "Descarta la Figura o las Gafas Ocho objetivo",
         "3": "Elige una carta que no sea un 3 del mazo de descarte y ponla en tu mano",
-        "4": "Tu rival descarta dos cartas de su mano a su elección",
+        "4": "Tu rival descarta dos cartas al azar de su mano",
         "5": "Descarta 1 carta y roba hasta 3.",
         "6": "Descarta todas las Figuras y Gafas Ocho en juego",
         "7": "Revela las dos primeras cartas del mazo de robo y elige una de ellas para jugarla como quieras",
@@ -339,12 +339,6 @@
           "mustPickFromScrap": "Debes elegir una carta del mazo de descartes",
           "cannotTargetThree": "No puedes apuntar a un 3 con un 3"
         },
-        "four": {
-          "opponentHasNoCards": "No puedes jugar un 4 como carta de habilidad única mientras tu oponente no tenga cartas en su mano",
-          "notYourTurn": "No es tu turno para descartar",
-          "notResolvingFourPhase": "No es posible descartar salvo que tu oponente haya jugado un cuatro",
-          "mustSelectCards": "Debes seleccionar dos cartas para descartar"
-        },
         "discardToHandLimit": {
           "notDiscardingPhase": "Solo puedes descartar hasta el límite de la mano durante la fase de descarte",
           "handNotOverLimit": "Tu mano no supera el límite",
@@ -466,7 +460,7 @@
       "three": "Tres",
       "threeDescription": "Elige una carta (no-tres) del mazo de descarte y ponla en tu mano.",
       "four": "Cuatro",
-      "fourDescription": "Tu rival descarta dos cartas de su mano a su elección.",
+      "fourDescription": "Tu rival descarta dos cartas al azar.",
       "five": "Cinco",
       "fiveDescription": "Descarta una carta y luego roba hasta tres cartas de la baraja.",
       "six": "Seis",
@@ -599,12 +593,13 @@
     }
   },
   "announcement": {
-    "activatorText": "¡Encuentra tus partidas en curso!",
-    "title": "Tus Partidas Actuales",
-    "heading": "Retoma donde lo dejaste",
-    "paragraph": "¿Cerraste la pestaña de una partida? Las partidas que tienes en curso ahora aparecen al principio de la pestaña Jugar. Pulsa Continuar para volver directamente a la partida, justo donde la dejaste.",
-    "heading2": "Despejar partidas abandonadas",
-    "paragraph2": "¿Terminaste con una partida a la que nadie va a volver? La × junto a Continuar la archiva y la quita de la lista de ambos jugadores. Las partidas que se siguen jugando no se pueden archivar, ni tampoco las partidas de Competitivo de la semana actual: esas todavía cuentan para tu enfrentamiento."
+    "activatorText": "¡Los Cuatros reciben una mejora!",
+    "title": "Beta de reglas: Cuatros al azar",
+    "heading": "Los Cuatros ahora descartan al azar",
+    "paragraph": "El Cuatro es la carta más débil del juego: un efecto flojo en un rango bajo, con pocos puntos y escaso valor para hundir. Y como tu rival elegía las dos cartas a descartar, siempre se deshacía de sus dos peores. Ahora las dos cartas se eligen al azar, así que un Cuatro puede llevarse algo que de verdad duela. Si tu rival tiene menos de dos cartas, descarta las que tenga.",
+    "heading2": "Una de cuatro pruebas de la temporada de Picas",
+    "paragraph2": "Esto es una beta, y una de cuatro variantes de reglas que probaremos durante la temporada de Picas: dos mejoras para el Nueve y dos para el Cuatro. Las someteremos a una votación de la comunidad hacia final de año para decidir qué se queda. Para conocer el contexto completo y el razonamiento de las cuatro, consulta",
+    "patreonLink": "Ayuda a refinar el 4 y el 9"
   },
   "profile": {
     "myGames": "Mis juegos",
diff --git a/src/translations/fr.json b/src/translations/fr.json
index a674eafe0..68397c046 100644
--- a/src/translations/fr.json
+++ b/src/translations/fr.json
@@ -236,7 +236,7 @@
         "1": "Élimine tous les points.",
         "2": "Cible et élimine une figure ou un huit en lunettes.",
         "3": "Récupérez une carte autre qu'un 3 dans la défausse et mettez-la dans votre main.",
-        "4": "Votre adversaire défausse deux cartes de son choix.",
+        "4": "Votre adversaire défausse deux cartes au hasard de sa main.",
         "5": "Défaussez 1 carte et piochez-en jusqu'à 3",
         "6": "Élimine toutes les figures et les huit en lunettes.",
         "7": "Dévoilez deux cartes de la pioche et jouez en une.",
@@ -339,12 +339,6 @@
           "mustPickFromScrap": "Vous devez choisir une carte de la défausse",
           "cannotTargetThree": "Vous ne pouvez pas cibler un 3 avec un 3"
         },
-        "four": {
-          "opponentHasNoCards": "La capacité du Quatre n'est possible que si votre adversaire a des cartes en main.",
-          "notYourTurn": "Ce n'est pas à vous de défausser",
-          "notResolvingFourPhase": "Vous ne pouvez pas défausser à moins que votre adversaire n'ait joué un Quatre",
-          "mustSelectCards": "Vous devez sélectionner deux cartes à défausser"
-        },
         "discardToHandLimit": {
           "notDiscardingPhase": "Vous ne pouvez vous défausser jusqu'à la limite de main que pendant la phase de défausse",
           "handNotOverLimit": "Votre main ne dépasse pas la limite",
@@ -466,7 +460,7 @@
       "three": "Trois",
       "threeDescription": "Vous permet de récupérer de la défausse une carte (non-trois) de votre choix.",
       "four": "Quatre",
-      "fourDescription": "Votre adversaire doit défausse deux cartes de son choix.",
+      "fourDescription": "Votre adversaire défausse deux cartes au hasard.",
       "five": "Cinq",
       "fiveDescription": "Défaussez une carte, puis piochez jusqu'à trois cartes du jeu.",
       "six": "Six",
@@ -599,12 +593,13 @@
     }
   },
   "announcement": {
-    "activatorText": "Retrouvez vos parties en cours !",
-    "title": "Vos Parties En Cours",
-    "heading": "Reprenez là où vous en étiez",
-    "paragraph": "Vous avez fermé l'onglet d'une partie ? Les parties que vous avez en cours apparaissent désormais en haut de l'onglet Jouer. Appuyez sur Continuer pour revenir directement dans la partie, exactement où vous l'aviez laissée.",
-    "heading2": "Faire le ménage dans les parties abandonnées",
-    "paragraph2": "Vous en avez fini avec une partie que personne ne reprendra ? Le × à côté de Continuer l'archive et la retire de la liste des deux joueurs. Les parties encore en cours de jeu ne peuvent pas être archivées, ni les parties classées de la semaine en cours : celles-ci comptent toujours pour votre match."
+    "activatorText": "Le Quatre est amélioré !",
+    "title": "Bêta de règles : Quatre aléatoire",
+    "heading": "Le Quatre défausse désormais au hasard",
+    "paragraph": "Le Quatre est la carte la plus faible du jeu : un effet peu puissant sur un rang bas, avec peu de points et une faible valeur de sabordage. Et comme votre adversaire choisissait les deux cartes à défausser, il se séparait toujours de ses deux plus mauvaises. Désormais les deux cartes sont tirées au hasard, et un Quatre peut donc emporter quelque chose qui compte vraiment. Si votre adversaire a moins de deux cartes, il défausse ce qu'il a.",
+    "heading2": "L'une des quatre expérimentations de la saison des Piques",
+    "paragraph2": "Il s'agit d'une bêta, et de l'une des quatre variantes de règles que nous testerons pendant la saison des Piques : deux améliorations du Neuf et deux du Quatre. Nous les soumettrons à un vote de la communauté vers la fin de l'année pour décider de ce qui reste. Pour le contexte complet et le raisonnement derrière les quatre, voir",
+    "patreonLink": "Aidez-nous à affiner le 4 et le 9"
   },
   "profile": {
     "myGames": "Mes jeux",
diff --git a/src/translations/ukr.json b/src/translations/ukr.json
index d0bb524b1..2577b379e 100644
--- a/src/translations/ukr.json
+++ b/src/translations/ukr.json
@@ -236,7 +236,7 @@
         "1": "Знищити всі карти з очками",
         "2": "Знищити обрану королівську карту або восьмірку окулярів",
         "3": "Виберіть одну карту (не трійку) зі стопки відкинутих карток і покладіть її до своєї руки",
-        "4": "Ваш суперник відкидає дві карти на свій вибір з руки",
+        "4": "Ваш суперник відкидає дві випадкові карти з руки",
         "5": "Відкидайте 1 карту та тягніть до 3 карт",
         "6": "Знищити всі королівські карти та восьмірки окулярів",
         "7": "Зіграти одну з перших двох карт з колоди та повернути іншу назад (обидві відкриті)",
@@ -339,12 +339,6 @@
           "mustPickFromScrap": "Ви повинні вибрати картку з відкинутих карток",
           "cannotTargetThree": "Ви не можете націлити трійкою на трійку"
         },
-        "four": {
-          "opponentHasNoCards": "Ви не можете зіграти чотвірку як ONE-OFF, поки у вашого суперника немає карт у руці",
-          "notYourTurn": "Не ваш хід для відкидання картки",
-          "notResolvingFourPhase": "Не можна відкидати картки, якщо ваш суперник не зіграв чотвірку",
-          "mustSelectCards": "Ви повинні вибрати дві картки для відкидання"
-        },
         "discardToHandLimit": {
           "notDiscardingPhase": "Ви можете скидати карти до ліміту руки лише під час фази скидання",
           "handNotOverLimit": "Ваша рука не перевищує ліміт",
@@ -466,7 +460,7 @@
       "three": "Три",
       "threeDescription": "оберіть будь-яку карту (не трійку) зі скиду та покладіть собі в руку Чотири - ваш опонент скидує свої дві будь-які карти.",
       "four": "Чотири",
-      "fourDescription": "ваш опонент скидує свої дві будь-які карти.",
+      "fourDescription": "Ваш суперник відкидає дві випадкові карти.",
       "five": "П'ять",
       "fiveDescription": "скиньте будь-яку свою карту та доберіть три карти з верху колоди.",
       "six": "Шість",
@@ -599,12 +593,13 @@
     }
   },
   "announcement": {
-    "activatorText": "Знайдіть свої незавершені ігри!",
-    "title": "Ваші Поточні Ігри",
-    "heading": "Продовжте з того місця, де зупинилися",
-    "paragraph": "Закрили вкладку з грою? Ваші незавершені ігри тепер з'являються вгорі вкладки Грати. Натисніть Продовжити, щоб одразу повернутися до гри — саме туди, де ви зупинилися.",
-    "heading2": "Прибирання покинутих ігор",
-    "paragraph2": "Закінчили з грою, до якої ніхто не повернеться? Хрестик × поруч із Продовжити архівує її та прибирає зі списків обох гравців. Ігри, які ще тривають, архівувати не можна, як і рейтингові ігри поточного тижня — вони ще враховуються у вашому матчі."
+    "activatorText": "Четвірки отримують посилення!",
+    "title": "Бета правил: випадкові четвірки",
+    "heading": "Четвірки тепер відкидають випадково",
+    "paragraph": "Четвірка — найслабша карта у грі: слабкий ефект на низькому ранзі, мало очок і кепський потенціал для затоплення. А оскільки суперник сам обирав дві карти для відкидання, він завжди позбувався двох найгірших. Тепер дві карти обираються випадково, тож четвірка може забрати щось справді цінне. Якщо у суперника менше двох карт, він відкидає те, що має.",
+    "heading2": "Одна з чотирьох проб сезону Пік",
+    "paragraph2": "Це бета-версія й одна з чотирьох варіацій правил, які ми тестуємо впродовж сезону Пік — два посилення дев'ятки та два четвірки. Наприкінці року проведемо опитування спільноти, щоб вирішити, що залишити. Повний контекст і обґрунтування всіх чотирьох див. тут:",
+    "patreonLink": "Допоможіть удосконалити 4 та 9"
   },
   "profile": {
     "myGames": "Мої ігри",
diff --git a/tests/e2e/fixtures/snackbarError.js b/tests/e2e/fixtures/snackbarError.js
index 558915769..8b71a0dbd 100644
--- a/tests/e2e/fixtures/snackbarError.js
+++ b/tests/e2e/fixtures/snackbarError.js
@@ -8,7 +8,6 @@ const SnackBarError = {
   CANT_FIND_GAME: 'Can\'t find game',
   ONE_OFF: {
     THREE_EMPTY_SCRAP: 'You can only play a 3 as a one-off if there are non-three cards in the scrap pile',
-    FOUR_EMPTY_HAND: 'You cannot play a 4 as a one-off while your opponent has no cards in hand',
     EMPTY_DECK: 'You can\'t play that one-off unless there are cards in the deck',
   }
 };
diff --git a/tests/e2e/specs/in-game/handLimit.spec.js b/tests/e2e/specs/in-game/handLimit.spec.js
index 7253422b2..c8815e012 100644
--- a/tests/e2e/specs/in-game/handLimit.spec.js
+++ b/tests/e2e/specs/in-game/handLimit.spec.js
@@ -153,9 +153,8 @@ describe('Hand Limit — Discard to Hand Limit Phase', () => {
           p1FaceCards: [],
         });
 
-        // Player plays four — opponent must discard 2 cards
+        // Player plays four — the opponent's two cards discard at random on resolve
         cy.playOneOffAndResolveAsPlayer(Card.FOUR_OF_CLUBS);
-        cy.discardOpponent(Card.ACE_OF_SPADES, Card.TWO_OF_SPADES);
 
         // Discard-to-hand-limit dialog appears — player (P0) still has 9 cards after playing the four
         cy.get('#discard-to-hand-limit-dialog').should('be.visible');
diff --git a/tests/e2e/specs/in-game/layout.spec.js b/tests/e2e/specs/in-game/layout.spec.js
index bd259cc4d..fa45494e0 100644
--- a/tests/e2e/specs/in-game/layout.spec.js
+++ b/tests/e2e/specs/in-game/layout.spec.js
@@ -167,49 +167,6 @@ describe('Game View Layout', () => {
   });
 });
 
-describe('Four dialogs layout', () => {
-  beforeEach(() => {
-    cy.setupGameAsP1();
-  });
-
-  it('Four dialogs', () => {
-    cy.loadGameFixture(1, {
-      p0Hand: [ Card.FOUR_OF_CLUBS, Card.ACE_OF_HEARTS ],
-      p0Points: [],
-      p0FaceCards: [],
-      p1Hand: [ Card.FOUR_OF_SPADES, Card.ACE_OF_DIAMONDS, Card.TEN_OF_HEARTS ],
-      p1Points: [],
-      p1FaceCards: [],
-    });
-
-    // Opponent plays four
-    cy.playOneOffOpponent(Card.FOUR_OF_CLUBS);
-    // Player cannot counter
-    cy.get('#cannot-counter-dialog').should('be.visible')
-      .get('[data-cy=cannot-counter-resolve]')
-      .click();
-
-    // Four Dialog appears (you must discard)
-    cy.get('#four-discard-dialog').should('be.visible');
-    // Choosing cards to discard
-    cy.log('Choosing two cards to discard');
-    cy.get('[data-cy=submit-four-dialog]').should('be.disabled'); // can't prematurely submit
-    cy.get('[data-discard-card=1-1]').click(); // ace of diamonds
-    cy.get('[data-cy=submit-four-dialog]').should('be.disabled'); // can't prematurely submit
-    cy.get('[data-discard-card=4-3]').click(); // four of spades
-    cy.get('[data-cy=submit-four-dialog]').click(); // submit choice to discard
-
-    assertGameState(1, {
-      p0Hand: [ Card.ACE_OF_HEARTS ],
-      p0Points: [],
-      p0FaceCards: [],
-      p1Hand: [ Card.TEN_OF_HEARTS ],
-      p1Points: [],
-      p1FaceCards: [],
-      scrap: [ Card.FOUR_OF_CLUBS, Card.FOUR_OF_SPADES, Card.ACE_OF_DIAMONDS ],
-    });
-  });
-});
 
 describe.skip('Aesthetic tests', () => {
   beforeEach(() => {
diff --git a/tests/e2e/specs/in-game/one-offs/4_fours.spec.js b/tests/e2e/specs/in-game/one-offs/4_fours.spec.js
index e3d1b8740..83c797c94 100644
--- a/tests/e2e/specs/in-game/one-offs/4_fours.spec.js
+++ b/tests/e2e/specs/in-game/one-offs/4_fours.spec.js
@@ -1,107 +1,89 @@
-import { assertGameState, assertSnackbar } from '../../../support/helpers';
+import { assertGameState } from '../../../support/helpers';
 import { Card } from '../../../fixtures/cards';
-import { SnackBarError } from '../../../fixtures/snackbarError';
 
+/**
+ * Fours discard at random as of rules 3.0.0, so there is no choice to make and no discard
+ * dialog. Most cases below give the victim exactly two cards, which makes the outcome
+ * deterministic and assertable; the randomness itself is covered by its own test, which
+ * asserts counts and membership rather than identities.
+ */
 describe('FOURS', () => {
   describe('Playing FOURS', () => {
     beforeEach(() => {
       cy.setupGameAsP0();
     });
 
-    it('Plays a 4 to make opponent discard two cards of their choice', () => {
-      // Set Up
+    it('Plays a 4 to discard the opponent\'s two cards at random', () => {
       cy.loadGameFixture(0, {
         p0Hand: [ Card.FOUR_OF_SPADES, Card.FOUR_OF_CLUBS ],
         p0Points: [],
         p0FaceCards: [],
-        p1Hand: [ Card.ACE_OF_HEARTS, Card.ACE_OF_DIAMONDS, Card.TEN_OF_HEARTS ],
+        p1Hand: [ Card.ACE_OF_HEARTS, Card.TEN_OF_HEARTS ],
         p1Points: [],
         p1FaceCards: [],
       });
 
       cy.playOneOffAndResolveAsPlayer(Card.FOUR_OF_SPADES);
 
-      cy.get('[data-cy=history-log]').should('contain', 'The 4♠️ one-off resolves; definitelyNotTheGovernment6969 must discard two cards.');
-      // Opponent chooses two cards to discard
-      cy.discardOpponent(Card.ACE_OF_HEARTS, Card.TEN_OF_HEARTS);
+      // Resolves immediately -- no discard step, so no scrim and no dialog
       cy.get('#waiting-for-opponent-discard-scrim').should('not.exist');
-      cy.get('[data-opponent-hand-card=1-2]').should('be.visible');
-      cy.get('[data-opponent-hand-card=10-2]').should('be.visible');
-      cy.get('[data-cy=history-log]').should('contain', 'definitelyNotTheGovernment6969 discarded the A♥️ and the 10♥️.');
-      assertGameState(0, {
-        p0Hand: [ Card.FOUR_OF_CLUBS ],
-        p0Points: [],
-        p0FaceCards: [],
-        p1Hand: [ Card.ACE_OF_DIAMONDS ],
-        p1Points: [],
-        p1FaceCards: [],
-        scrap: [ Card.FOUR_OF_SPADES, Card.ACE_OF_HEARTS, Card.TEN_OF_HEARTS ],
-      });
-    });
+      cy.get('#four-discard-dialog').should('not.exist');
 
-    it('Plays a 4 to make opponent discard two cards of their choice while player has glasses', () => {
-      // Set Up
-      cy.loadGameFixture(0, {
-        p0Hand: [ Card.FOUR_OF_SPADES, Card.FOUR_OF_CLUBS ],
-        p0Points: [],
-        p0FaceCards: [ Card.EIGHT_OF_CLUBS ],
-        p1Hand: [ Card.ACE_OF_HEARTS, Card.ACE_OF_DIAMONDS, Card.TEN_OF_HEARTS ],
-        p1Points: [],
-        p1FaceCards: [],
-      });
-
-      cy.playOneOffAndResolveAsPlayer(Card.FOUR_OF_SPADES);
+      // The log is the only channel naming what was lost
+      cy.get('[data-cy=history-log]').should(
+        'contain',
+        'The 4♠️ one-off resolves, discarding the A♥️ and the 10♥️ at random from definitelyNotTheGovernment6969\'s hand.',
+      );
 
-      cy.get('[data-cy=history-log]').should('contain', 'The 4♠️ one-off resolves; definitelyNotTheGovernment6969 must discard two cards.');
-      // Opponent chooses two cards to discard
-      cy.discardOpponent(Card.ACE_OF_DIAMONDS, Card.TEN_OF_HEARTS);
-      cy.get('#waiting-for-opponent-discard-scrim').should('not.exist');
-      cy.get('[data-opponent-hand-card=1-2]').should('be.visible');
-      cy.get('[data-opponent-hand-card=10-2]').should('be.visible');
-      cy.get('[data-cy=history-log]').should('contain', 'definitelyNotTheGovernment6969 discarded the A♦️ and the 10♥️.');
       assertGameState(0, {
         p0Hand: [ Card.FOUR_OF_CLUBS ],
         p0Points: [],
-        p0FaceCards: [ Card.EIGHT_OF_CLUBS ],
-        p1Hand: [ Card.ACE_OF_HEARTS ],
+        p0FaceCards: [],
+        p1Hand: [],
         p1Points: [],
         p1FaceCards: [],
-        scrap: [ Card.FOUR_OF_SPADES, Card.ACE_OF_DIAMONDS, Card.TEN_OF_HEARTS ],
+        scrap: [ Card.FOUR_OF_SPADES, Card.ACE_OF_HEARTS, Card.TEN_OF_HEARTS ],
       });
     });
 
-    it('Plays a 4 to make opponent discard their only two cards', () => {
-      // Set Up
+    it('Discards two of a larger hand at random, leaving the rest', () => {
+      const startingHand = [
+        Card.ACE_OF_HEARTS,
+        Card.ACE_OF_DIAMONDS,
+        Card.TEN_OF_HEARTS,
+        Card.KING_OF_SPADES,
+      ];
       cy.loadGameFixture(0, {
-        p0Hand: [ Card.FOUR_OF_CLUBS ],
+        p0Hand: [ Card.FOUR_OF_SPADES ],
         p0Points: [],
         p0FaceCards: [],
-        p1Hand: [ Card.ACE_OF_HEARTS, Card.ACE_OF_DIAMONDS ],
+        p1Hand: startingHand,
         p1Points: [],
         p1FaceCards: [],
       });
 
-      cy.playOneOffAndResolveAsPlayer(Card.FOUR_OF_CLUBS);
-
-      cy.get('#waiting-for-opponent-discard-scrim').should('be.visible');
-      // Opponent chooses two cards to discard
-      cy.log('Opponent discards both their remaining cards');
-      cy.discardOpponent(Card.ACE_OF_HEARTS, Card.ACE_OF_DIAMONDS);
-      cy.get('#waiting-for-opponent-discard-scrim').should('not.exist');
-
-      assertGameState(0, {
-        p0Hand: [],
-        p0Points: [],
-        p0FaceCards: [],
-        p1Hand: [],
-        p1Points: [],
-        p1FaceCards: [],
-        scrap: [ Card.FOUR_OF_CLUBS, Card.ACE_OF_HEARTS, Card.ACE_OF_DIAMONDS ],
-      });
+      cy.playOneOffAndResolveAsPlayer(Card.FOUR_OF_SPADES);
+      cy.get('#four-discard-dialog').should('not.exist');
+
+      // Which two cards go is random, so assert the shape rather than the identities
+      cy.window()
+        .its('cuttle.gameStore')
+        .then((game) => {
+          expect(game.players[1].hand).to.have.length(2, 'Opponent should have discarded exactly two cards');
+          expect(game.scrap).to.have.length(3, 'Scrap should hold the four plus the two discards');
+
+          const discarded = game.scrap.filter((card) => card.rank !== 4 || card.suit !== 3);
+          expect(discarded).to.have.length(2);
+          discarded.forEach((card) => {
+            const cameFromHand = startingHand.some(
+              ({ rank, suit }) => rank === card.rank && suit === card.suit,
+            );
+            expect(cameFromHand).to.eq(true, `Discarded ${card.rank}-${card.suit} was not in the opening hand`);
+          });
+        });
     });
 
-    it('Plays a 4 to make opponent discard the last card in their hand', () => {
-      // Set Up
+    it('Discards the opponent\'s only card when they hold just one', () => {
       cy.loadGameFixture(0, {
         p0Hand: [ Card.FOUR_OF_CLUBS ],
         p0Points: [],
@@ -111,13 +93,12 @@ describe('FOURS', () => {
         p1FaceCards: [],
       });
 
-      // Play the four of clubs
       cy.playOneOffAndResolveAsPlayer(Card.FOUR_OF_CLUBS);
-      cy.get('#waiting-for-opponent-discard-scrim').should('be.visible');
-      // Opponent chooses two cards to discard
-      cy.log('Opponent discards both their remaining cards');
-      cy.discardOpponent(Card.ACE_OF_HEARTS);
-      cy.get('#waiting-for-opponent-discard-scrim').should('not.exist');
+
+      cy.get('[data-cy=history-log]').should(
+        'contain',
+        'The 4♣️ one-off resolves, discarding the A♥️ at random from definitelyNotTheGovernment6969\'s hand.',
+      );
 
       assertGameState(0, {
         p0Hand: [],
@@ -130,8 +111,7 @@ describe('FOURS', () => {
       });
     });
 
-    it('Prevents playing a 4 when opponent has no cards in hand', () => {
-      // Set Up
+    it('Can play a 4 against an empty hand, discarding nothing', () => {
       cy.loadGameFixture(0, {
         p0Hand: [ Card.FOUR_OF_CLUBS ],
         p0Points: [],
@@ -141,90 +121,40 @@ describe('FOURS', () => {
         p1FaceCards: [],
       });
 
-      // Play the four of spades
-      cy.log('Attempting to playing Four of clubs as one off');
-      cy.get('[data-player-hand-card=4-0]').click(); // four of clubs
-      cy.get('[data-move-choice=oneOff]').click();
-
-      assertSnackbar(SnackBarError.ONE_OFF.FOUR_EMPTY_HAND);
+      // Used to be blocked; a random discard against no cards simply discards nothing
+      cy.playOneOffAndResolveAsPlayer(Card.FOUR_OF_CLUBS);
 
       assertGameState(0, {
-        p0Hand: [ Card.FOUR_OF_CLUBS ],
+        p0Hand: [],
         p0Points: [],
         p0FaceCards: [],
         p1Hand: [],
         p1Points: [],
         p1FaceCards: [],
+        scrap: [ Card.FOUR_OF_CLUBS ],
       });
     });
 
-    it('Prevents opponent from discarding illegally', () => {
-      // Set Up
+    it('Plays a 4 while the player has glasses', () => {
       cy.loadGameFixture(0, {
         p0Hand: [ Card.FOUR_OF_SPADES, Card.FOUR_OF_CLUBS ],
         p0Points: [],
-        p0FaceCards: [],
-        p1Hand: [ Card.ACE_OF_HEARTS, Card.ACE_OF_DIAMONDS, Card.TEN_OF_HEARTS ],
+        p0FaceCards: [ Card.EIGHT_OF_CLUBS ],
+        p1Hand: [ Card.ACE_OF_DIAMONDS, Card.TEN_OF_HEARTS ],
         p1Points: [],
         p1FaceCards: [],
       });
 
       cy.playOneOffAndResolveAsPlayer(Card.FOUR_OF_SPADES);
-      cy.get('#waiting-for-opponent-discard-scrim').should('be.visible');
-
-      // Illegal Discard 1: Only 1 card selected
-      cy.log('Opponent illegally discards: No cards selected');
-      cy.discardOpponent(); // Discard with no selection
-      cy.get('#waiting-for-opponent-discard-scrim').should('be.visible');
-      assertGameState(0, {
-        p0Hand: [ Card.FOUR_OF_CLUBS ],
-        p0Points: [],
-        p0FaceCards: [],
-        p1Hand: [ Card.ACE_OF_HEARTS, Card.ACE_OF_DIAMONDS, Card.TEN_OF_HEARTS ],
-        p1Points: [],
-        p1FaceCards: [],
-      });
-      cy.log('Successfully prevented discarding with no cards selected');
 
-      // Illegal Discard 2: Only 1 card selected
-      cy.log('Opponent illegally discards: Chooses only 1 card');
-      cy.discardOpponent(Card.ACE_OF_HEARTS); // Only 1 card selected (should have 2)
-      cy.get('#waiting-for-opponent-discard-scrim').should('be.visible');
       assertGameState(0, {
         p0Hand: [ Card.FOUR_OF_CLUBS ],
         p0Points: [],
-        p0FaceCards: [],
-        p1Hand: [ Card.ACE_OF_HEARTS, Card.ACE_OF_DIAMONDS, Card.TEN_OF_HEARTS ],
-        p1Points: [],
-        p1FaceCards: [],
-      });
-      cy.log('Successfully prevented discarding only 1 card');
-
-      // Illegal Discard 3: Card not in hand
-      cy.log('Opponent illegally discards: Chooses a card not in their hand');
-      cy.discardOpponent(Card.ACE_OF_HEARTS, Card.TEN_OF_SPADES); // Ten of spades not in hand
-      cy.get('#waiting-for-opponent-discard-scrim').should('be.visible');
-      assertGameState(0, {
-        p0Hand: [ Card.FOUR_OF_CLUBS ],
-        p0Points: [],
-        p0FaceCards: [],
-        p1Hand: [ Card.ACE_OF_HEARTS, Card.ACE_OF_DIAMONDS, Card.TEN_OF_HEARTS ],
-        p1Points: [],
-        p1FaceCards: [],
-      });
-      cy.log('Successfully prevented discarding a card not in hand');
-
-      // Legal Discard
-      cy.discardOpponent(Card.ACE_OF_HEARTS, Card.ACE_OF_DIAMONDS);
-      cy.get('#waiting-for-opponent-discard-scrim').should('not.be.exist');
-      assertGameState(0, {
-        p0Hand: [ Card.FOUR_OF_CLUBS ],
-        p0Points: [],
-        p0FaceCards: [],
-        p1Hand: [ Card.TEN_OF_HEARTS ],
+        p0FaceCards: [ Card.EIGHT_OF_CLUBS ],
+        p1Hand: [],
         p1Points: [],
         p1FaceCards: [],
-        scrap: [ Card.FOUR_OF_SPADES, Card.ACE_OF_HEARTS, Card.ACE_OF_DIAMONDS ],
+        scrap: [ Card.FOUR_OF_SPADES, Card.ACE_OF_DIAMONDS, Card.TEN_OF_HEARTS ],
       });
     });
   });
@@ -234,76 +164,44 @@ describe('FOURS', () => {
       cy.setupGameAsP1();
     });
 
-    it('Discards two cards when opponent plays a four, repeated fours', () => {
+    it('Discards the player\'s two cards when the opponent plays a four', () => {
       cy.loadGameFixture(1, {
         p0Hand: [ Card.FOUR_OF_CLUBS, Card.FOUR_OF_DIAMONDS ],
         p0Points: [],
         p0FaceCards: [],
-        p1Hand: [ Card.FOUR_OF_SPADES, Card.ACE_OF_DIAMONDS, Card.TEN_OF_HEARTS ],
+        p1Hand: [ Card.ACE_OF_DIAMONDS, Card.TEN_OF_HEARTS ],
         p1Points: [],
         p1FaceCards: [],
         topCard: Card.SIX_OF_DIAMONDS,
       });
 
-      // Opponent plays four
       cy.playOneOffOpponent(Card.FOUR_OF_CLUBS);
-      // Player cannot counter
-      cy.get('#cannot-counter-dialog').should('be.visible')
+      cy.get('#cannot-counter-dialog')
+        .should('be.visible')
         .get('[data-cy=cannot-counter-resolve]')
         .click();
-      cy.log('Player resolves opponent\'s Four');
 
-      // Four Dialog appears (you must discard)
-      cy.get('#four-discard-dialog').should('be.visible');
-      // Choosing cards to discard
-      cy.log('Choosing two cards to discard');
-      cy.get('[data-cy=submit-four-dialog]').should('be.disabled'); // can't prematurely submit
-      cy.get('[data-discard-card=1-1]').click(); // ace of diamonds
-      cy.get('[data-cy=submit-four-dialog]').should('be.disabled'); // can't prematurely submit
-      cy.get('[data-discard-card=4-3]').click(); // four of spades
-      cy.get('[data-cy=submit-four-dialog]').click(); // submit choice to discard
+      // No dialog to answer -- the discard has already happened
+      cy.get('#four-discard-dialog').should('not.exist');
 
       assertGameState(1, {
         p0Hand: [ Card.FOUR_OF_DIAMONDS ],
         p0Points: [],
         p0FaceCards: [],
-        p1Hand: [ Card.TEN_OF_HEARTS ],
+        p1Hand: [],
         p1Points: [],
         p1FaceCards: [],
-        scrap: [ Card.FOUR_OF_CLUBS, Card.FOUR_OF_SPADES, Card.ACE_OF_DIAMONDS ],
+        scrap: [ Card.FOUR_OF_CLUBS, Card.ACE_OF_DIAMONDS, Card.TEN_OF_HEARTS ],
       });
 
-      // Player draws the 6 of diamonds
+      // A second four against the now-empty hand is still legal and discards nothing
       cy.get('#deck').click();
-
-      // Opponent plays 2nd four
       cy.playOneOffOpponent(Card.FOUR_OF_DIAMONDS);
-      // Player cannot counter
-      cy.get('#cannot-counter-dialog').should('be.visible')
+      cy.get('#cannot-counter-dialog')
+        .should('be.visible')
         .get('[data-cy=cannot-counter-resolve]')
         .click();
 
-      // Choosing cards to discard
-      cy.log('Choosing two cards to discard');
-      cy.get('[data-cy=submit-four-dialog]').should('be.disabled'); // can't prematurely submit
-      // Discard dialog should still be open
-      cy.get('#four-discard-dialog').should('be.visible');
-      // Validate game state same as above
-      assertGameState(1, {
-        p0Hand: [],
-        p0Points: [],
-        p0FaceCards: [],
-        p1Hand: [ Card.TEN_OF_HEARTS, Card.SIX_OF_DIAMONDS ],
-        p1Points: [],
-        p1FaceCards: [],
-      });
-      // Properly discard as expected
-      cy.log('Choosing two cards to discard - second time');
-      cy.get('[data-discard-card=10-2]').click(); // 10 of hearts
-      cy.get('[data-cy=submit-four-dialog]').should('be.disabled'); // can't prematurely submit
-      cy.get('[data-discard-card=6-1]').click(); // six of diamonds
-      cy.get('[data-cy=submit-four-dialog]').click(); // submit choice to discard
-
       assertGameState(1, {
         p0Hand: [],
         p0Points: [],
@@ -313,48 +211,30 @@ describe('FOURS', () => {
         p1FaceCards: [],
         scrap: [
           Card.FOUR_OF_CLUBS,
-          Card.FOUR_OF_SPADES,
+          Card.FOUR_OF_DIAMONDS,
           Card.ACE_OF_DIAMONDS,
           Card.TEN_OF_HEARTS,
           Card.SIX_OF_DIAMONDS,
-          Card.FOUR_OF_DIAMONDS,
         ],
       });
     });
 
-    it('Minimizes FourDialog and reopens it before discarding', () => {
+    it('Discards the player\'s last card when FOURd with one card in hand', () => {
       cy.loadGameFixture(1, {
         p0Hand: [ Card.FOUR_OF_CLUBS ],
         p0Points: [],
         p0FaceCards: [],
-        p1Hand: [ Card.ACE_OF_DIAMONDS, Card.FOUR_OF_SPADES ],
+        p1Hand: [ Card.ACE_OF_DIAMONDS ],
         p1Points: [],
         p1FaceCards: [],
       });
 
-      // Opponent plays four
       cy.playOneOffOpponent(Card.FOUR_OF_CLUBS);
-      // Player cannot counter
-      cy.get('#cannot-counter-dialog').should('be.visible')
+      cy.get('#cannot-counter-dialog')
+        .should('be.visible')
         .get('[data-cy=cannot-counter-resolve]')
         .click();
 
-      // Four Dialog appears (you must discard)
-      cy.get('[data-cy=four-discard-dialog]').should('be.visible');
-      // Minimize the dialog
-      cy.get('[data-cy="minimize-dialog-button"]').click();
-      // Reopen the dialog
-      cy.get('[data-cy="four-discard-dialog-activator"] button').click();
-      // Verify dialog is open again
-      cy.get('[data-cy=four-discard-dialog]').should('be.visible');
-      // Choosing cards to discard
-      cy.log('Choosing two cards to discard');
-      cy.get('[data-cy=submit-four-dialog]').should('be.disabled'); // can't prematurely submit
-      cy.get('[data-discard-card=1-1]').click(); // ace of diamonds
-      cy.get('[data-cy=submit-four-dialog]').should('be.disabled'); // can't prematurely submit
-      cy.get('[data-discard-card=4-3]').click(); // four of spades
-      cy.get('[data-cy=submit-four-dialog]').click(); // submit choice to discard
-
       assertGameState(1, {
         p0Hand: [],
         p0Points: [],
@@ -362,43 +242,36 @@ describe('FOURS', () => {
         p1Hand: [],
         p1Points: [],
         p1FaceCards: [],
-        scrap: [ Card.FOUR_OF_CLUBS, Card.ACE_OF_DIAMONDS, Card.FOUR_OF_SPADES ],
+        scrap: [ Card.FOUR_OF_CLUBS, Card.ACE_OF_DIAMONDS ],
       });
     });
-    it('Discards last card when FOURd with one card in hand', () => {
+  });
+
+  /**
+   * Fours resolved into a separate `resolveFour` move before rules 3.0.0, and stored games
+   * still hold that phase. The move is gone, but the rendering path has to survive: unpacking
+   * the phase, resolving the active player from it, and showing the discard dialog.
+   */
+  describe('Legacy four-discard states (pre-3.0.0 games)', () => {
+    it('Renders a stored RESOLVING_FOUR state', () => {
+      cy.setupGameAsP1();
       cy.loadGameFixture(1, {
-        p0Hand: [ Card.FOUR_OF_CLUBS ],
+        p0Hand: [],
         p0Points: [],
         p0FaceCards: [],
-        p1Hand: [ Card.ACE_OF_DIAMONDS ],
+        p1Hand: [ Card.ACE_OF_DIAMONDS, Card.TEN_OF_HEARTS ],
         p1Points: [],
         p1FaceCards: [],
+        // GamePhase.RESOLVING_FOUR -- unreachable through play, staged directly. The four
+        // sat in oneOff while the victim chose, which is where a real legacy row holds it.
+        phase: 4,
+        oneOff: Card.FOUR_OF_CLUBS,
       });
 
-      // Opponent plays four
-      cy.playOneOffOpponent(Card.FOUR_OF_CLUBS);
-      // Player cannot counter
-      cy.get('#cannot-counter-dialog').should('be.visible')
-        .get('[data-cy=cannot-counter-resolve]')
-        .click();
-
-      // Four Dialog appears (you must discard)
+      // The frame must render rather than erroring on an unknown phase or active player
       cy.get('#four-discard-dialog').should('be.visible');
-      // Choosing cards to discard
-      cy.log('Choosing (only) card to discard');
-      cy.get('[data-cy=submit-four-dialog]').should('be.disabled'); // can't prematurely submit
-      cy.get('[data-discard-card=1-1]').click(); // ace of diamonds
-      cy.get('[data-cy=submit-four-dialog]').click();
-
-      assertGameState(1, {
-        p0Hand: [],
-        p0Points: [],
-        p0FaceCards: [],
-        p1Hand: [],
-        p1Points: [],
-        p1FaceCards: [],
-        scrap: [ Card.FOUR_OF_CLUBS, Card.ACE_OF_DIAMONDS ],
-      });
+      cy.get('[data-discard-card=1-1]').should('be.visible');
+      cy.get('[data-discard-card=10-2]').should('be.visible');
     });
   });
 });
diff --git a/tests/e2e/specs/in-game/one-offs/7_sevens/player_sevens.spec.js b/tests/e2e/specs/in-game/one-offs/7_sevens/player_sevens.spec.js
index e717f0fce..a570cae0c 100644
--- a/tests/e2e/specs/in-game/one-offs/7_sevens/player_sevens.spec.js
+++ b/tests/e2e/specs/in-game/one-offs/7_sevens/player_sevens.spec.js
@@ -671,7 +671,7 @@ describe('Playing SEVENS', () => {
       assertSnackbar(SnackBarError.ONE_OFF.THREE_EMPTY_SCRAP);
     });
 
-    it('Cannot play 4 from seven when opponent has no cards in hand', () => {
+    it('Plays a 4 from a seven against an empty hand, discarding nothing', () => {
       cy.loadGameFixture(0, {
         p0Hand: [ Card.SEVEN_OF_CLUBS ],
         p0Points: [],
@@ -686,16 +686,27 @@ describe('Playing SEVENS', () => {
       // Play seven of clubs
       cy.playOneOffAndResolveAsPlayer(Card.SEVEN_OF_CLUBS);
 
-      // Play Four of hearts
+      // Play Four of hearts -- a random discard against no cards is legal and does nothing
       cy.get('[data-top-card=4-2]').should('exist')
         .and('be.visible')
         .click();
       cy.get('[data-move-choice=oneOff]').click();
-
-      // Should not allow playing 4 as one-off
+      cy.get('#waiting-for-opponent-counter-scrim').should('be.visible');
+      // Opponent does not counter (resolves stack)
+      cy.resolveOpponent();
       cy.get('#waiting-for-opponent-counter-scrim').should('not.exist');
+
       cy.get('#waiting-for-opponent-discard-scrim').should('not.exist');
-      assertSnackbar(SnackBarError.ONE_OFF.FOUR_EMPTY_HAND);
+      cy.get('#four-discard-dialog').should('not.exist');
+      assertGameState(0, {
+        p0Hand: [],
+        p0Points: [],
+        p0FaceCards: [],
+        p1Hand: [],
+        p1Points: [ Card.SEVEN_OF_SPADES, Card.TEN_OF_SPADES ],
+        p1FaceCards: [],
+        scrap: [ Card.SEVEN_OF_CLUBS, Card.FOUR_OF_HEARTS ],
+      });
     });
   }); // End player seven one-off describe
 
diff --git a/tests/e2e/specs/in-game/reconnecting.spec.js b/tests/e2e/specs/in-game/reconnecting.spec.js
index 4a88d7ed2..a6cfa5611 100644
--- a/tests/e2e/specs/in-game/reconnecting.spec.js
+++ b/tests/e2e/specs/in-game/reconnecting.spec.js
@@ -669,7 +669,7 @@ describe('Reconnecting to a game', () => {
       });
     }); // End 3's reconnect
 
-    it('Resolve 4 after reconnect - Player discards', () => {
+    it('Resolve 4 after reconnect - random discard persists', () => {
       cy.setupGameAsP1();
       cy.loadGameFixture(1, {
         p0Hand: [ Card.FOUR_OF_CLUBS ],
@@ -680,24 +680,13 @@ describe('Reconnecting to a game', () => {
         p1FaceCards: [],
       });
 
-      // Opponent plays four of clubs, player resolves
+      // Opponent plays four of clubs, player resolves -- both cards discard immediately
       cy.playOneOffOpponent(Card.FOUR_OF_CLUBS);
       cy.get('#cannot-counter-dialog').should('be.visible')
         .get('[data-cy=cannot-counter-resolve]')
         .click();
 
-      // Disconnect & Reconnect
-      cy.reload();
-      // Four dialog appears, player discards as normal
-      // Choosing cards to discard
-      cy.log('Choosing two cards to discard');
-      cy.get('[data-cy=submit-four-dialog]').should('be.disabled'); // can't prematurely submit
-      cy.get('[data-discard-card=3-1]').click(); // ace of diamonds
-      cy.get('[data-cy=submit-four-dialog]').should('be.disabled'); // can't prematurely submit
-      cy.get('[data-discard-card=3-0]').click(); // four of spades
-      cy.get('[data-cy=submit-four-dialog]').click(); // submit choice to discard
-
-      assertGameState(1, {
+      const expectedState = {
         p0Hand: [],
         p0Points: [],
         p0FaceCards: [],
@@ -705,7 +694,13 @@ describe('Reconnecting to a game', () => {
         p1Points: [],
         p1FaceCards: [],
         scrap: [ Card.THREE_OF_DIAMONDS, Card.THREE_OF_CLUBS, Card.FOUR_OF_CLUBS ],
-      });
+      };
+      assertGameState(1, expectedState);
+
+      // Disconnect & Reconnect -- the resolved discard must survive the reload
+      cy.reload();
+      cy.get('#four-discard-dialog').should('not.exist');
+      assertGameState(1, expectedState);
     });
 
     it('Resolve 7 after reconnect - Player', () => {
diff --git a/tests/e2e/specs/playground/videoPlayground.spec.js b/tests/e2e/specs/playground/videoPlayground.spec.js
index ca0b7b074..438fe48f8 100644
--- a/tests/e2e/specs/playground/videoPlayground.spec.js
+++ b/tests/e2e/specs/playground/videoPlayground.spec.js
@@ -553,9 +553,10 @@ describe('Video Playground', () => {
     cy.wait(1000);
     cy.get('#waiting-for-opponent-counter-scrim').should('be.visible');
     cy.resolveOpponent();
-    cy.get('#waiting-for-opponent-discard-scrim').should('be.visible');
-    cy.wait(1000);
-    cy.discardOpponent(Card.ACE_OF_DIAMONDS, Card.JACK_OF_SPADES);
+
+    // Two of the opponent's three cards discard at random as the four resolves
+    cy.get('#scrap').contains('(3)');
+    cy.wait(3000);
   });
 
   it('Playing Fives', () => {
diff --git a/tests/e2e/support/commands.js b/tests/e2e/support/commands.js
index b70a00d4c..62559e436 100644
--- a/tests/e2e/support/commands.js
+++ b/tests/e2e/support/commands.js
@@ -36,7 +36,6 @@ const transformGameUrl = (api, slug, gameId = null) => {
     case 'counter':
     case 'resolve':
     case 'resolveThree':
-    case 'resolveFour':
     case 'resolveFive':
     case 'discardToHandLimit':
     case 'seven/points':
@@ -474,32 +473,6 @@ Cypress.Commands.add('discardToHandLimitOpponent', (...cards) => {
   });
 });
 
-Cypress.Commands.add('discardOpponent', (card1, card2) => {
-
-  const moveType = MoveType.RESOLVE_FOUR;
-  // dont use makeSocketRequest due to edge case checking error on opponent side
-  transformGameUrl('game', 'resolveFour').then((url) => {
-    io.socket.request({
-      method: 'post',
-      url,
-      data: {
-        moveType,
-        cardId1: card1?.id,
-        cardId2: card2?.id,
-      },
-    });
-  }),
-  function handleResponse(res, jwres) {
-    try {
-      if (jwres.statusCode !== 200) {
-        throw new Error(jwres.error.message);
-      }
-      return res;
-    } catch (err) {
-      return err;
-    }
-  };
-});
 
 /**
  * @param card {suit: number, rank: number}
diff --git a/tests/unit/fixtures/gameStates/ai/resolvingFour1CanDiscardTwoCards.js b/tests/unit/fixtures/gameStates/ai/resolvingFour1CanDiscardTwoCards.js
deleted file mode 100644
index 66b04d175..000000000
--- a/tests/unit/fixtures/gameStates/ai/resolvingFour1CanDiscardTwoCards.js
+++ /dev/null
@@ -1,93 +0,0 @@
-import { Card } from '../../Card';
-import GamePhase from '../../../../../utils/GamePhase.json';
-import MoveType from '../../../../../utils/MoveType.json';
-import { omit } from 'lodash';
-
-const gameState = {
-  p0: {
-    hand: [ Card.ACE_OF_HEARTS, Card.ACE_OF_DIAMONDS ],
-    points: [
-      Card.TEN_OF_SPADES,
-      {
-        ...Card.EIGHT_OF_DIAMONDS,
-        attachments: [ Card.JACK_OF_SPADES, Card.JACK_OF_CLUBS ],
-      },
-    ],
-    faceCards: [ Card.KING_OF_SPADES ],
-  },
-  p1: {
-    hand: [
-      Card.ACE_OF_SPADES,
-      Card.THREE_OF_HEARTS,
-      Card.SEVEN_OF_DIAMONDS,
-      Card.JACK_OF_HEARTS,
-      Card.QUEEN_OF_DIAMONDS,
-      Card.KING_OF_CLUBS,
-    ],
-    points: [ Card.TEN_OF_HEARTS, Card.ACE_OF_CLUBS ],
-    faceCards: [],
-  },
-  deck: [ Card.SEVEN_OF_SPADES, Card.SEVEN_OF_CLUBS,
-    Card.TWO_OF_CLUBS, Card.THREE_OF_CLUBS, Card.FOUR_OF_CLUBS, Card.FIVE_OF_CLUBS,
-    Card.EIGHT_OF_CLUBS, Card.NINE_OF_CLUBS, Card.TEN_OF_CLUBS, Card.QUEEN_OF_CLUBS,
-    Card.TWO_OF_DIAMONDS, Card.THREE_OF_DIAMONDS, Card.FOUR_OF_DIAMONDS, Card.FIVE_OF_DIAMONDS, 
-    Card.SIX_OF_DIAMONDS, Card.NINE_OF_DIAMONDS, Card.TEN_OF_DIAMONDS, 
-    Card.JACK_OF_DIAMONDS, Card.KING_OF_DIAMONDS, 
-    Card.TWO_OF_HEARTS, Card.FOUR_OF_HEARTS, Card.FIVE_OF_HEARTS, 
-    Card.SIX_OF_HEARTS, Card.SEVEN_OF_HEARTS, Card.EIGHT_OF_HEARTS, Card.NINE_OF_HEARTS, 
-    Card.QUEEN_OF_HEARTS, Card.KING_OF_HEARTS, 
-    Card.TWO_OF_SPADES, Card.THREE_OF_SPADES, Card.FOUR_OF_SPADES, Card.FIVE_OF_SPADES, 
-    Card.SIX_OF_SPADES,  Card.EIGHT_OF_SPADES, Card.NINE_OF_SPADES, 
-    Card.QUEEN_OF_SPADES
-  ],
-  scrap: [ Card.SIX_OF_CLUBS ],
-  twos: [],
-  discardedCards: [],
-  oneOff: null,
-  oneOffTarget: null,
-  oneOffTargetType: null,
-  resolved: null,
-  playedCard: Card.TEN_OF_SPADES,
-  gameId: 1,
-  playedBy: 1,
-  moveType: MoveType.RESOLVE,
-  turn: 4,
-  phase: GamePhase.RESOLVING_FOUR,
-  targetCard: null,
-};
-
-const resolveFourMoveBodies = [
-  { moveType: MoveType.RESOLVE_FOUR, playedBy: 1, cardId1: 'AS', cardId2: '3H', isValid: true },
-  { moveType: MoveType.RESOLVE_FOUR, playedBy: 1, cardId1: 'AS', cardId2: '7D', isValid: true },
-  { moveType: MoveType.RESOLVE_FOUR, playedBy: 1, cardId1: 'AS', cardId2: 'JH', isValid: true },
-  { moveType: MoveType.RESOLVE_FOUR, playedBy: 1, cardId1: 'AS', cardId2: 'QD', isValid: true },
-  { moveType: MoveType.RESOLVE_FOUR, playedBy: 1, cardId1: 'AS', cardId2: 'KC', isValid: true },
-  { moveType: MoveType.RESOLVE_FOUR, playedBy: 1, cardId1: '3H', cardId2: '7D', isValid: true },
-  { moveType: MoveType.RESOLVE_FOUR, playedBy: 1, cardId1: '3H', cardId2: 'JH', isValid: true },
-  { moveType: MoveType.RESOLVE_FOUR, playedBy: 1, cardId1: '3H', cardId2: 'QD', isValid: true },
-  { moveType: MoveType.RESOLVE_FOUR, playedBy: 1, cardId1: '3H', cardId2: 'KC', isValid: true },
-  { moveType: MoveType.RESOLVE_FOUR, playedBy: 1, cardId1: '7D', cardId2: 'JH', isValid: true },
-  { moveType: MoveType.RESOLVE_FOUR, playedBy: 1, cardId1: '7D', cardId2: 'QD', isValid: true },
-  { moveType: MoveType.RESOLVE_FOUR, playedBy: 1, cardId1: '7D', cardId2: 'KC', isValid: true },
-  { moveType: MoveType.RESOLVE_FOUR, playedBy: 1, cardId1: 'JH', cardId2: 'QD', isValid: true },
-  { moveType: MoveType.RESOLVE_FOUR, playedBy: 1, cardId1: 'JH', cardId2: 'KC', isValid: true },
-  { moveType: MoveType.RESOLVE_FOUR, playedBy: 1, cardId1: 'QD', cardId2: 'KC', isValid: true },
-];
-
-const validMoveBodies = [
-  ...resolveFourMoveBodies,
-].filter((move) => move.isValid).map((validMove) => omit(validMove, 'isValid'));
-
-function omitIsValid(moveList) {
-  return moveList.map((validMove) => omit(validMove, 'isValid'));
-}
-
-export const resolvingFourPhase1CanDiscardTwoCards = {
-  name: 'resolvingFourPhase1',
-  gameState,
-  playedBy: 1,
-  moveBodiesByType: [
-    { moveType: MoveType.RESOLVE_FOUR, moves: omitIsValid(resolveFourMoveBodies) }
-  ],
-  validMoveBodies,
-};
diff --git a/tests/unit/fixtures/gameStates/ai/resolvingFour2HasOnlyTwoCards.js b/tests/unit/fixtures/gameStates/ai/resolvingFour2HasOnlyTwoCards.js
deleted file mode 100644
index 9823f8982..000000000
--- a/tests/unit/fixtures/gameStates/ai/resolvingFour2HasOnlyTwoCards.js
+++ /dev/null
@@ -1,79 +0,0 @@
-import { Card } from '../../Card';
-import GamePhase from '../../../../../utils/GamePhase.json';
-import MoveType from '../../../../../utils/MoveType.json';
-import { omit } from 'lodash';
-
-const gameState = {
-  p0: {
-    hand: [ Card.ACE_OF_HEARTS, Card.ACE_OF_DIAMONDS ],
-    points: [
-      Card.TEN_OF_SPADES,
-      {
-        ...Card.EIGHT_OF_DIAMONDS,
-        attachments: [ Card.JACK_OF_SPADES, Card.JACK_OF_CLUBS ],
-      },
-    ],
-    faceCards: [ Card.KING_OF_SPADES ],
-  },
-  p1: {
-    hand: [
-      Card.QUEEN_OF_DIAMONDS,
-      Card.KING_OF_CLUBS,
-    ],
-    points: [ Card.TEN_OF_HEARTS, Card.ACE_OF_CLUBS ],
-    faceCards: [],
-  },
-  deck: [ Card.SEVEN_OF_SPADES, Card.SEVEN_OF_CLUBS,
-    Card.TWO_OF_CLUBS, Card.THREE_OF_CLUBS, Card.FOUR_OF_CLUBS, Card.FIVE_OF_CLUBS,
-    Card.EIGHT_OF_CLUBS, Card.NINE_OF_CLUBS, Card.TEN_OF_CLUBS, Card.QUEEN_OF_CLUBS,
-    Card.TWO_OF_DIAMONDS, Card.THREE_OF_DIAMONDS, Card.FOUR_OF_DIAMONDS, Card.FIVE_OF_DIAMONDS, 
-    Card.SIX_OF_DIAMONDS, Card.NINE_OF_DIAMONDS, Card.TEN_OF_DIAMONDS, 
-    Card.JACK_OF_DIAMONDS, Card.KING_OF_DIAMONDS, 
-    Card.TWO_OF_HEARTS, Card.FOUR_OF_HEARTS, Card.FIVE_OF_HEARTS, 
-    Card.SIX_OF_HEARTS, Card.SEVEN_OF_HEARTS, Card.EIGHT_OF_HEARTS, Card.NINE_OF_HEARTS, 
-    Card.QUEEN_OF_HEARTS, Card.KING_OF_HEARTS, 
-    Card.TWO_OF_SPADES, Card.THREE_OF_SPADES, Card.FOUR_OF_SPADES, Card.FIVE_OF_SPADES, 
-    Card.SIX_OF_SPADES,  Card.EIGHT_OF_SPADES, Card.NINE_OF_SPADES, 
-    Card.QUEEN_OF_SPADES,
-    Card.ACE_OF_SPADES,
-    Card.THREE_OF_HEARTS,
-    Card.SEVEN_OF_DIAMONDS,
-    Card.JACK_OF_HEARTS,
-  ],
-  scrap: [ Card.SIX_OF_CLUBS ],
-  twos: [],
-  discardedCards: [],
-  oneOff: null,
-  oneOffTarget: null,
-  oneOffTargetType: null,
-  resolved: null,
-  playedCard: Card.TEN_OF_SPADES,
-  gameId: 1,
-  playedBy: 1,
-  moveType: MoveType.RESOLVE,
-  turn: 4,
-  phase: GamePhase.RESOLVING_FOUR,
-  targetCard: null,
-};
-
-const resolveFourMoveBodies = [
-  { moveType: MoveType.RESOLVE_FOUR, playedBy: 1, cardId1: 'QD', cardId2: 'KC', isValid: true },
-];
-
-const validMoveBodies = [
-  ...resolveFourMoveBodies,
-].filter((move) => move.isValid).map((validMove) => omit(validMove, 'isValid'));
-
-function omitIsValid(moveList) {
-  return moveList.map((validMove) => omit(validMove, 'isValid'));
-}
-
-export const resolvingFourPhase2HasOnlyTwoCards = {
-  name: 'resolvingFourPhase2: user has only two cards',
-  gameState,
-  playedBy: 1,
-  moveBodiesByType: [
-    { moveType: MoveType.RESOLVE_FOUR, moves: omitIsValid(resolveFourMoveBodies) }
-  ],
-  validMoveBodies,
-};
diff --git a/tests/unit/fixtures/gameStates/ai/resolvingFourPhase3HasOnlyOneCard.js b/tests/unit/fixtures/gameStates/ai/resolvingFourPhase3HasOnlyOneCard.js
deleted file mode 100644
index 61bf74bb9..000000000
--- a/tests/unit/fixtures/gameStates/ai/resolvingFourPhase3HasOnlyOneCard.js
+++ /dev/null
@@ -1,77 +0,0 @@
-import { Card } from '../../Card';
-import GamePhase from '../../../../../utils/GamePhase.json';
-import MoveType from '../../../../../utils/MoveType.json';
-import { omit } from 'lodash';
-
-const gameState = {
-  p0: {
-    hand: [ Card.ACE_OF_HEARTS, Card.ACE_OF_DIAMONDS ],
-    points: [
-      Card.TEN_OF_SPADES,
-      {
-        ...Card.EIGHT_OF_DIAMONDS,
-        attachments: [ Card.JACK_OF_SPADES, Card.JACK_OF_CLUBS ],
-      },
-    ],
-    faceCards: [ Card.KING_OF_SPADES ],
-  },
-  p1: {
-    hand: [ Card.QUEEN_OF_DIAMONDS ],
-    points: [ Card.TEN_OF_HEARTS, Card.ACE_OF_CLUBS ],
-    faceCards: [],
-  },
-  deck: [ Card.SEVEN_OF_SPADES, Card.SEVEN_OF_CLUBS,
-    Card.TWO_OF_CLUBS, Card.THREE_OF_CLUBS, Card.FOUR_OF_CLUBS, Card.FIVE_OF_CLUBS,
-    Card.EIGHT_OF_CLUBS, Card.NINE_OF_CLUBS, Card.TEN_OF_CLUBS, Card.QUEEN_OF_CLUBS,
-    Card.TWO_OF_DIAMONDS, Card.THREE_OF_DIAMONDS, Card.FOUR_OF_DIAMONDS, Card.FIVE_OF_DIAMONDS, 
-    Card.SIX_OF_DIAMONDS, Card.NINE_OF_DIAMONDS, Card.TEN_OF_DIAMONDS, 
-    Card.JACK_OF_DIAMONDS, Card.KING_OF_DIAMONDS, 
-    Card.TWO_OF_HEARTS, Card.FOUR_OF_HEARTS, Card.FIVE_OF_HEARTS, 
-    Card.SIX_OF_HEARTS, Card.SEVEN_OF_HEARTS, Card.EIGHT_OF_HEARTS, Card.NINE_OF_HEARTS, 
-    Card.QUEEN_OF_HEARTS, Card.KING_OF_HEARTS, 
-    Card.TWO_OF_SPADES, Card.THREE_OF_SPADES, Card.FOUR_OF_SPADES, Card.FIVE_OF_SPADES, 
-    Card.SIX_OF_SPADES,  Card.EIGHT_OF_SPADES, Card.NINE_OF_SPADES, 
-    Card.QUEEN_OF_SPADES,
-    Card.ACE_OF_SPADES,
-    Card.THREE_OF_HEARTS,
-    Card.SEVEN_OF_DIAMONDS,
-    Card.JACK_OF_HEARTS,
-    Card.KING_OF_CLUBS,
-  ],
-  scrap: [ Card.SIX_OF_CLUBS ],
-  twos: [],
-  discardedCards: [],
-  oneOff: null,
-  oneOffTarget: null,
-  oneOffTargetType: null,
-  resolved: null,
-  playedCard: Card.TEN_OF_SPADES,
-  gameId: 1,
-  playedBy: 1,
-  moveType: MoveType.RESOLVE,
-  turn: 4,
-  phase: GamePhase.RESOLVING_FOUR,
-  targetCard: null,
-};
-
-const resolveFourMoveBodies = [
-  { moveType: MoveType.RESOLVE_FOUR, playedBy: 1, cardId1: 'QD', isValid: true },
-];
-
-const validMoveBodies = [
-  ...resolveFourMoveBodies,
-].filter((move) => move.isValid).map((validMove) => omit(validMove, 'isValid'));
-
-function omitIsValid(moveList) {
-  return moveList.map((validMove) => omit(validMove, 'isValid'));
-}
-
-export const resolvingFourPhase3HasOnlyOneCard = {
-  name: 'resolvingFourPhase3: user has only one card',
-  gameState,
-  playedBy: 1,
-  moveBodiesByType: [
-    { moveType: MoveType.RESOLVE_FOUR, moves: omitIsValid(resolveFourMoveBodies) }
-  ],
-  validMoveBodies,
-};
diff --git a/tests/unit/specs/sails/ai.spec.js b/tests/unit/specs/sails/ai.spec.js
index 2b2cc4f31..832364cbd 100644
--- a/tests/unit/specs/sails/ai.spec.js
+++ b/tests/unit/specs/sails/ai.spec.js
@@ -6,9 +6,6 @@ import { mainPhase3AdditionalPenalties } from '../../fixtures/gameStates/ai/mini
 import { resolvingSevenPhase1 } from '../../fixtures/gameStates/ai/resolvingSevenPhase1';
 import { resolvingSevenPhase2 } from '../../fixtures/gameStates/ai/resolvingSevenPhase2';
 import { resolvingSevenPhase3 } from '../../fixtures/gameStates/ai/resolvingSevenPhase3DoubleJack';
-import { resolvingFourPhase1CanDiscardTwoCards } from '../../fixtures/gameStates/ai/resolvingFour1CanDiscardTwoCards';
-import { resolvingFourPhase2HasOnlyTwoCards } from '../../fixtures/gameStates/ai/resolvingFour2HasOnlyTwoCards';
-import { resolvingFourPhase3HasOnlyOneCard } from '../../fixtures/gameStates/ai/resolvingFourPhase3HasOnlyOneCard';
 import { resolvingFivePhase1HasMultipleCardsInHand } from '../../fixtures/gameStates/ai/resolvingFivePhase1HasMultipleCardsInHand';
 import { resolvingFivePhase2HasOneCardInHand } from '../../fixtures/gameStates/ai/resolvingFivePhase2HasOneCardInHand';
 import { resolvingFivePhase3HasNoCardsInHand } from '../../fixtures/gameStates/ai/resolvingFivePhase3HasNoCardsInHand';
@@ -20,9 +17,6 @@ const fixturesForLegalMoves = [
   resolvingSevenPhase1,
   resolvingSevenPhase2,
   resolvingSevenPhase3,
-  resolvingFourPhase1CanDiscardTwoCards,
-  resolvingFourPhase2HasOnlyTwoCards,
-  resolvingFourPhase3HasOnlyOneCard,
   resolvingFivePhase1HasMultipleCardsInHand,
   resolvingFivePhase2HasOneCardInHand,
   resolvingFivePhase3HasNoCardsInHand,
diff --git a/utils/rulesVersion.js b/utils/rulesVersion.js
index 5026b1eee..959c21099 100644
--- a/utils/rulesVersion.js
+++ b/utils/rulesVersion.js
@@ -24,7 +24,8 @@
  * 1.0.1 (#1320) => Cannot Three for a Three
  * 1.0.2 (#1359) => Hand limit rework: discard down to 8 at end of your turn
  * 2.0.0 (#1379) => Nine rework: put target card on top of the deck instead of returning it frozen to hand
+ * 3.0.0 (#1384) => Four rework: opponent discards two cards at random instead of choosing
  */
 module.exports = {
-  CURRENT_RULES_VERSION: '2.0.0',
+  CURRENT_RULES_VERSION: '3.0.0',
 };