diff --git a/forge-game/src/main/java/forge/game/player/PlayerFactoryUtil.java b/forge-game/src/main/java/forge/game/player/PlayerFactoryUtil.java
index 34933815924..4876d433533 100644
--- a/forge-game/src/main/java/forge/game/player/PlayerFactoryUtil.java
+++ b/forge-game/src/main/java/forge/game/player/PlayerFactoryUtil.java
@@ -2,6 +2,7 @@
 
 import forge.game.card.Card;
 import forge.game.card.CardFactoryUtil;
+import forge.game.keyword.Hexproof;
 import forge.game.keyword.KeywordInterface;
 import forge.game.replacement.ReplacementEffect;
 import forge.game.replacement.ReplacementHandler;
@@ -12,23 +13,28 @@ public class PlayerFactoryUtil {
     public static void addStaticAbility(final KeywordInterface inst, final Player player) {
         String keyword = inst.getOriginal();
 
-        if (keyword.startsWith("Hexproof")) {
-            final StringBuilder sbDesc = new StringBuilder("Hexproof");
+        if (keyword.startsWith("Hexproof")
+                && inst instanceof Hexproof hexproof) {
             final StringBuilder sbValid = new StringBuilder();
 
-            if (!keyword.equals("Hexproof")) {
-                final String[] k = keyword.split(":");
-
-                sbDesc.append(" from ").append(k[2]);
-                sbValid.append("| ValidSource$ ").append(k[1]);
+            if (!hexproof.getValidType().isEmpty()) {
+                sbValid.append("| ValidSource$ ")
+                    .append(hexproof.getValidType());
             }
 
-            String effect = "Mode$ CantTarget | ValidTarget$ Player.You | Secondary$ True "
-                    + sbValid.toString() + " | Activator$ Opponent | EffectZone$ Command | Description$ "
-                    + sbDesc.toString() + " (" + inst.getReminderText() + ")";
+            String effect = "Mode$ CantTarget"
+                + " | ValidTarget$ Player.You"
+                + " | Secondary$ True "
+                + sbValid
+                + " | Activator$ Opponent"
+                + " | EffectZone$ Command"
+                + " | Description$ "
+                + inst.getTitle()
+                + " (" + inst.getReminderText() + ")";
 
             final Card card = player.getKeywordCard();
-            inst.addStaticAbility(StaticAbility.create(effect, card, card.getCurrentState(), false));
+            inst.addStaticAbility(StaticAbility.create(
+                effect, card, card.getCurrentState(), false));
         } else if (keyword.equals("Shroud")) {
             String effect = "Mode$ CantTarget | ValidTarget$ Player.You | Secondary$ True "
                     + "| EffectZone$ Command | Description$ Shroud (" + inst.getReminderText() + ")";
diff --git a/forge-gui-mobile/src/forge/adventure/player/AdventurePlayer.java b/forge-gui-mobile/src/forge/adventure/player/AdventurePlayer.java
index c7cfba8e1bf..afd1d2d5a2f 100644
--- a/forge-gui-mobile/src/forge/adventure/player/AdventurePlayer.java
+++ b/forge-gui-mobile/src/forge/adventure/player/AdventurePlayer.java
@@ -1284,6 +1284,29 @@ public int cardSellPrice(PaperCard card) {
         return (int) (basePrice * (2.0f - townPriceModifier));
     }
 
+    /**
+     * Adventure card shop buy price (same formula as {@link forge.adventure.scene.RewardScene}).
+     *
+     * @param locationPriceModifier town × shop reputation factor from the current shop
+     */
+    public int cardShopBuyPrice(PaperCard card, float locationPriceModifier) {
+        if (card == null || card.hasNoSellValue()) {
+            return 0;
+        }
+        int price = CardUtil.getCardPrice(card);
+        price *= goldModifier();
+        price *= locationPriceModifier;
+        return Math.max(0, price);
+    }
+
+    /**
+     * Deck import buy-missing: same as a card shop in a town with no reputation (modifier 1.0),
+     * including the player's equipment/blessing shop discounts via {@link #goldModifier()}.
+     */
+    public int cardBuyPrice(PaperCard card) {
+        return cardShopBuyPrice(card, 1f);
+    }
+
     /**
      * Sells a number of copies of a card.
      * @return the number of copies successfully sold.
@@ -1587,6 +1610,40 @@ public int copyDeck() {
         return -1;
     }
 
+    /**
+     * Finds the first empty deck slot, expanding if needed.
+     * Returns -1 only if all 99 slots are occupied.
+     */
+    public int findFirstEmptySlot() {
+        for (int i = 0; i < maxDeckCount; i++) {
+            if (i >= getDeckCount()) addDeck();
+            if (isEmptyDeck(i)) return i;
+        }
+        if (getDeckCount() < 99) {
+            maxDeckCount = Math.min(maxDeckCount + 1, 99);
+            addDeck();
+            return getDeckCount() - 1;
+        }
+        return -1;
+    }
+
+    /**
+     * Replaces the contents of a deck slot with an imported deck.
+     * Clears all existing sections and copies from the source.
+     */
+    public void importIntoSlot(int slot, Deck importedDeck) {
+        Deck target = getDeck(slot);
+        for (DeckSection section : DeckSection.values()) {
+            if (target.has(section)) target.get(section).clear();
+        }
+        for (java.util.Map.Entry<DeckSection, CardPool> entry : importedDeck) {
+            target.getOrCreate(entry.getKey()).addAll(entry.getValue());
+        }
+        if (importedDeck.getName() != null && !importedDeck.getName().isEmpty()) {
+            target.setName(importedDeck.getName());
+        }
+    }
+
     private void ensureDeckLoadoutsSize() {
         while (deckLoadouts.size() < getDeckCount()) {
             deckLoadouts.add(null);
diff --git a/forge-gui-mobile/src/forge/adventure/scene/DeckSelectScene.java b/forge-gui-mobile/src/forge/adventure/scene/DeckSelectScene.java
index d2dfad086c0..6671398acf8 100644
--- a/forge-gui-mobile/src/forge/adventure/scene/DeckSelectScene.java
+++ b/forge-gui-mobile/src/forge/adventure/scene/DeckSelectScene.java
@@ -1,19 +1,29 @@
 package forge.adventure.scene;
 
+import com.badlogic.gdx.Gdx;
 import com.badlogic.gdx.graphics.Color;
 import com.badlogic.gdx.scenes.scene2d.InputEvent;
 import com.badlogic.gdx.scenes.scene2d.ui.*;
 import com.badlogic.gdx.scenes.scene2d.utils.ClickListener;
 import com.badlogic.gdx.utils.Align;
 import com.badlogic.gdx.utils.IntMap;
+import com.badlogic.gdx.utils.Timer;
 import com.github.tommyettinger.textra.TextraButton;
 import com.github.tommyettinger.textra.TextraLabel;
 import forge.Forge;
 import forge.adventure.player.AdventurePlayer;
 import forge.adventure.stage.GameHUD;
+import forge.adventure.util.AdventureDialogUtil;
+import forge.adventure.util.AdventureFilePicker;
+import forge.adventure.util.CardUtil;
 import forge.adventure.util.Controls;
 import forge.adventure.util.Current;
 
+import java.io.File;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.function.Consumer;
+
 public class DeckSelectScene extends UIScene {
     private final IntMap<TextraButton> buttons = new IntMap<>();
     private final IntMap<Label> labels = new IntMap<>();
@@ -49,6 +59,23 @@ public DeckSelectScene() {
         this.layoutDeckButtons();
 
         textInput = Controls.newTextField("");
+
+        root.row();
+        Table fileOpsTable = new Table();
+        float opsBtnH = AdventureDialogUtil.compactButtonHeight();
+        fileOpsTable.add(compactOpsButton(
+            Forge.getLocalizer().getMessage("lblAdvImportDeck"), this::importDeck, opsBtnH)).pad(1).expandX().fillX();
+        fileOpsTable.add(compactOpsButton(
+            Forge.getLocalizer().getMessage("lblAdvExportDeck"), this::exportDeck, opsBtnH)).pad(1).expandX().fillX();
+        fileOpsTable.row();
+        fileOpsTable.add(compactOpsButton(
+            Forge.getLocalizer().getMessage("lblAdvExportCollection"), this::exportCollection, opsBtnH))
+            .pad(1).expandX().fillX();
+        fileOpsTable.add(compactOpsButton(
+            Forge.getLocalizer().getMessage("lblAdvMarkForSale"), this::markForSale, opsBtnH))
+            .pad(1).expandX().fillX();
+        root.add(fileOpsTable).colspan(2).fillX();
+
         back = ui.findActor("return");
         edit = ui.findActor("edit");
         rename = ui.findActor("rename");
@@ -178,9 +205,19 @@ private void clearDeckButton(int i){
         }
     }
 
+    private static TextraButton compactOpsButton(String text, Runnable onClick, float height) {
+        TextraButton button = Controls.newTextButton(text, onClick);
+        button.getTextraLabel().layout.setTargetWidth(Scene.getIntendedWidth() * 0.22f);
+        button.setHeight(height);
+        return button;
+    }
+
     private TextraButton addDeckButton(int i) {
+        float rowH = AdventureDialogUtil.compactButtonHeight();
         TextraButton button = Controls.newTextButton("-");
         String name = Forge.getLocalizer().getMessage("lblDeck") + ": " + (i + 1);
+        button.getTextraLabel().layout.setTargetWidth(Scene.getIntendedWidth() * 0.42f);
+        button.setHeight(rowH);
         button.addListener(new ClickListener() {
             @Override
             public void clicked(InputEvent event, float x, float y) {
@@ -195,8 +232,8 @@ public void clicked(InputEvent event, float x, float y) {
 
         button.setText(Current.player().getDeck(i).getName());
         Label label = Controls.newLabel(name);
-        layout.add(Controls.newLabel(name)).pad(2);
-        layout.add(button).fill(true, false).expand(true, false).align(Align.left).expandX().pad(2);
+        layout.add(label).pad(1);
+        layout.add(button).height(rowH).fillX().expandX().align(Align.left).pad(1);
         buttons.put(i, button);
         labels.put(i, label);
         addToSelectable(new Selectable(button));
@@ -221,12 +258,25 @@ public boolean select(int slot) {
     }
 
 
+    @Override
+    protected void onDialogClosed() {
+        restoreDeckListScrollFocus();
+    }
+
+    private void restoreDeckListScrollFocus() {
+        if (scrollPane != null) {
+            stage.setScrollFocus(scrollPane);
+            stage.setKeyboardFocus(scrollPane);
+        }
+    }
+
     @Override
     public void enter() {
         refreshDeckButtons();
         GameHUD.getInstance().updateBGM();
         select(Current.player().getSelectedDeckIndex());
         performTouch(scrollPane); //can use mouse wheel if available to scroll after selection
+        restoreDeckListScrollFocus();
         super.enter();
     }
 
@@ -242,4 +292,250 @@ private void edit() {
         editScene.loadEvent(null);
         Forge.switchScene(editScene);
     }
+
+    private void importDeck() {
+        var loc = Forge.getLocalizer();
+        Dialog modeDialog = AdventureDialogUtil.buildImportDeckDialog(
+            loc.getMessage("lblAdvDeckImportIntro"),
+            loc.getMessage("lblAdvChooseImportMode"),
+            loc.getMessage("lblAdvDeckImportUseOwned"),
+            () -> {
+                removeDialog();
+                pickImportFile(CardUtil.ImportMode.REPORT_ONLY);
+            },
+            loc.getMessage("lblAdvDeckImportBuyMissing"),
+            () -> {
+                removeDialog();
+                pickImportFile(CardUtil.ImportMode.BUY_MISSING);
+            },
+            loc.getMessage("lblAdvDeckImportGiveMissing"),
+            () -> {
+                removeDialog();
+                pickImportFile(CardUtil.ImportMode.GIVE_MISSING);
+            },
+            this::removeDialog);
+        showDialog(modeDialog);
+    }
+
+    private void pickImportFile(CardUtil.ImportMode mode) {
+        var loc = Forge.getLocalizer();
+        AdventureFilePicker.chooseOpenFile(loc.getMessage("lblAdvImportDeck"), file -> {
+            if (!file.exists()) {
+                removeAllDialogs();
+                showOkDialog(loc.getMessage("lblAdvImportDeck"),
+                    loc.getMessage("lblAdvFileNotFound", file.getAbsolutePath()));
+                return;
+            }
+            if (mode == CardUtil.ImportMode.BUY_MISSING) {
+                confirmBuyImport(file);
+            } else {
+                handleImportResult(CardUtil.importDeckFromFile(file, Current.player(), mode), mode);
+            }
+        });
+    }
+
+    private void confirmBuyImport(File file) {
+        var loc = Forge.getLocalizer();
+        String title = loc.getMessage("lblAdvImportDeck");
+        AdventurePlayer player = Current.player();
+        CardUtil.ImportPreview preview = CardUtil.previewImport(file, player);
+        if (preview == null) {
+            showOkDialog(title, loc.getMessage("lblAdvImportDeckFailed", "Could not parse file"));
+            return;
+        }
+        if (preview.missingCards.isEmpty()) {
+            handleImportResult(CardUtil.importDeckFromFile(file, player, CardUtil.ImportMode.BUY_MISSING),
+                CardUtil.ImportMode.BUY_MISSING);
+            return;
+        }
+        int gold = player.getGold();
+        if (!preview.canAfford(gold)) {
+            showOkDialog(title, loc.getMessage("lblAdvBuyNotEnoughGold",
+                preview.totalCost, gold));
+            return;
+        }
+        String message = loc.getMessage("lblAdvBuyConfirm",
+            preview.missingCopyCount(), preview.missingCards.size(),
+            preview.totalCost, gold);
+        Dialog confirm = AdventureDialogUtil.buildConfirmDialog(title, message,
+            loc.getMessage("lblOK"),
+            () -> {
+                removeDialog();
+                handleImportResult(CardUtil.importDeckFromFile(file, player, CardUtil.ImportMode.BUY_MISSING),
+                    CardUtil.ImportMode.BUY_MISSING);
+            },
+            this::removeDialog);
+        showDialog(confirm);
+    }
+
+    private void handleImportResult(CardUtil.ImportResult result, CardUtil.ImportMode mode) {
+        var loc = Forge.getLocalizer();
+        String title = loc.getMessage("lblAdvImportDeck");
+        if (!result.success) {
+            removeAllDialogs();
+            showOkDialog(title, loc.getMessage("lblAdvImportDeckFailed", result.message));
+            return;
+        }
+        if (result.importedDeck()) {
+            refreshDeckButtons();
+            select(result.slot);
+            showBriefToast(loc.getMessage("lblAdvImportDone"));
+            return;
+        }
+        showMissingCardsDialog(result);
+    }
+
+    private void exportDeck() {
+        String deckName = Current.player().getSelectedDeck().getName();
+        String baseName = deckName != null && !deckName.isEmpty() ? deckName : "deck";
+        var loc = Forge.getLocalizer();
+        chooseExportFormat(loc.getMessage("lblAdvExportDeck"), CardUtil.DeckListExportFormat.values(), format -> {
+            String defaultName = CardUtil.defaultSaveFilename(baseName, format.getDefaultExtension());
+            AdventureFilePicker.chooseSaveFile(loc.getMessage("lblAdvExportDeck"), defaultName, file -> {
+                try {
+                    CardUtil.exportDeck(Current.player().getSelectedDeck(), file, format);
+                    showSavedThenReturnToDeckList();
+                } catch (Exception e) {
+                    removeAllDialogs();
+                    showOkDialog(loc.getMessage("lblAdvExportDeck"),
+                        loc.getMessage("lblAdvMissingListSaveFailed", e.getMessage()));
+                }
+            });
+        });
+    }
+
+    private void exportCollection() {
+        var loc = Forge.getLocalizer();
+        chooseExportFormat(loc.getMessage("lblAdvExportCollection"), CardUtil.CollectionExportFormat.values(), format -> {
+            String defaultName = CardUtil.defaultSaveFilename("collection", format.getDefaultExtension());
+            AdventureFilePicker.chooseSaveFile(loc.getMessage("lblAdvExportCollection"), defaultName, file -> {
+                try {
+                    CardUtil.exportCollection(Current.player(), file, format);
+                    showSavedThenReturnToDeckList();
+                } catch (Exception e) {
+                    removeAllDialogs();
+                    showOkDialog(loc.getMessage("lblAdvExportCollection"),
+                        loc.getMessage("lblAdvMissingListSaveFailed", e.getMessage()));
+                }
+            });
+        });
+    }
+
+    private void markForSale() {
+        var loc = Forge.getLocalizer();
+        AdventureFilePicker.chooseOpenFile(loc.getMessage("lblAdvMarkForSale"),
+            loc.getMessage("lblAdvMarkForSaleHelp"), file -> {
+            if (!file.exists()) {
+                removeAllDialogs();
+                showOkDialog(loc.getMessage("lblAdvMarkForSale"),
+                    loc.getMessage("lblAdvFileNotFound", file.getAbsolutePath()));
+                return;
+            }
+            CardUtil.MarkSellResult result = CardUtil.markCardsForSale(file, Current.player());
+            if (!result.success) {
+                removeAllDialogs();
+                showOkDialog(loc.getMessage("lblAdvMarkForSale"),
+                    loc.getMessage("lblAdvMarkForSaleFailed", result.message));
+            } else {
+                showMarkForSaleResult(result);
+            }
+        });
+    }
+
+    private void showMarkForSaleResult(CardUtil.MarkSellResult result) {
+        var loc = Forge.getLocalizer();
+        String title = loc.getMessage("lblAdvMarkForSale");
+        String body = result.formatMarkedReport(loc.getMessage("lblAdvLoaded"));
+        ScrollPane[] scroll = new ScrollPane[1];
+        Runnable onRollback = result.rollbackOps.isEmpty() ? null : () -> {
+            result.rollback(Current.player());
+            removeDialog();
+            showBriefToast(loc.getMessage("lblAdvRolledBack"));
+        };
+        Dialog dialog = AdventureDialogUtil.buildScrollableOkDialog(title, body,
+            this::removeDialog, onRollback, scroll);
+        removeAllDialogs();
+        showDialog(dialog, scroll[0]);
+    }
+
+    private <T extends Enum<T>> void chooseExportFormat(String title, T[] formats, Consumer<T> onChosen) {
+        var loc = Forge.getLocalizer();
+        List<AdventureDialogUtil.ChoiceOption> options = new ArrayList<>(formats.length);
+        for (T format : formats) {
+            T chosen = format;
+            options.add(new AdventureDialogUtil.ChoiceOption(formatLabel(format), () -> {
+                removeDialog();
+                onChosen.accept(chosen);
+            }));
+        }
+        Dialog dialog = AdventureDialogUtil.buildChoiceDialog(title,
+            loc.getMessage("lblAdvChooseExportFormat"), options, this::removeDialog);
+        showDialog(dialog);
+    }
+
+    private static String formatLabel(Enum<?> format) {
+        if (format instanceof CardUtil.DeckListExportFormat df) {
+            return df.getDisplayName();
+        }
+        if (format instanceof CardUtil.CollectionExportFormat cf) {
+            return cf.getDisplayName();
+        }
+        return format.name();
+    }
+
+    private void showResultDialog(String title, String message) {
+        showDialog(AdventureDialogUtil.buildMessageDialog(title, message, this::removeDialog));
+    }
+
+    private void showOkDialog(String title, String message) {
+        var loc = Forge.getLocalizer();
+        showDialog(AdventureDialogUtil.buildMessageDialog(title, message,
+            loc.getMessage("lblOK"), this::removeDialog));
+    }
+
+    private void showSavedThenReturnToDeckList() {
+        showBriefToast(Forge.getLocalizer().getMessage("lblAdvSaved"));
+    }
+
+    private void showBriefToast(String message) {
+        removeAllDialogs();
+        showDialog(AdventureDialogUtil.buildTransientMessage(message));
+        Timer.schedule(new Timer.Task() {
+            @Override
+            public void run() {
+                Gdx.app.postRunnable(DeckSelectScene.this::removeDialog);
+            }
+        }, 3f);
+    }
+
+    private void showMissingCardsDialog(CardUtil.ImportResult result) {
+        var loc = Forge.getLocalizer();
+        String title = loc.getMessage("lblAdvImportDeck");
+        String body = result.formatMissingReport();
+        if (result.missingCards == null || result.missingCards.isEmpty()) {
+            showResultDialog(title, body);
+            return;
+        }
+        String safeName = result.deckName != null
+            ? result.deckName.replaceAll("[^a-zA-Z0-9._-]+", "_") : "deck";
+        String defaultFile = "missing_" + safeName + ".txt";
+        ScrollPane[] scroll = new ScrollPane[1];
+        Dialog dialog = AdventureDialogUtil.buildScrollableReportDialog(title, body,
+            loc.getMessage("lblSave"),
+            () -> {
+                removeDialog();
+                AdventureFilePicker.chooseSaveFile(title, defaultFile, file -> {
+                    try {
+                        forge.util.FileUtil.writeFile(file, body);
+                        showSavedThenReturnToDeckList();
+                    } catch (Exception e) {
+                        removeAllDialogs();
+                        showOkDialog(title, loc.getMessage("lblAdvMissingListSaveFailed",
+                            e.getMessage()));
+                    }
+                });
+            },
+            this::removeDialog, scroll);
+        showDialog(dialog, scroll[0]);
+    }
 }
diff --git a/forge-gui-mobile/src/forge/adventure/scene/RewardScene.java b/forge-gui-mobile/src/forge/adventure/scene/RewardScene.java
index af81388d792..94e7b13927f 100644
--- a/forge-gui-mobile/src/forge/adventure/scene/RewardScene.java
+++ b/forge-gui-mobile/src/forge/adventure/scene/RewardScene.java
@@ -621,9 +621,13 @@ public BuyButton(int id, int i, RewardActor actor, Reward reward, TextraButton s
             setWidth(actor.getWidth());
             setX(actor.getX());
             setY(actor.getY() - getHeight());
-            price = CardUtil.getRewardPrice(actor.getReward());
-            price *= Current.player().goldModifier();
-            price *= shopModifier;
+            if (Reward.Type.Card.equals(reward.getType()) && reward.getCard() != null) {
+                price = Current.player().cardShopBuyPrice(reward.getCard(), shopModifier);
+            } else {
+                price = CardUtil.getRewardPrice(actor.getReward());
+                price *= Current.player().goldModifier();
+                price *= shopModifier;
+            }
             setText("[+GoldCoin] " + price);
             updateOwned();
             addListener(new ClickListener() {
diff --git a/forge-gui-mobile/src/forge/adventure/scene/UIScene.java b/forge-gui-mobile/src/forge/adventure/scene/UIScene.java
index 2e2da04dfad..e6c2d361f69 100644
--- a/forge-gui-mobile/src/forge/adventure/scene/UIScene.java
+++ b/forge-gui-mobile/src/forge/adventure/scene/UIScene.java
@@ -86,19 +86,30 @@ public float xDiff(Selectable finalOne) {
     }
 
     public void showDialog(Dialog dialog) {
+        showDialog(dialog, null);
+    }
+
+    /**
+     * @param scrollFocus when non-null, mouse wheel / scroll keys target this pane (e.g. file list)
+     */
+    public void showDialog(Dialog dialog, ScrollPane scrollFocus) {
         stage.addActor(dialog);
         possibleSelectionStack.add(new Array<>());
         addToSelectable(dialog.getContentTable());
         addToSelectable(dialog.getButtonTable());
         dialog.getColor().a = 0;
         stage.setKeyboardFocus(dialog);
-        stage.setScrollFocus(dialog);
+        stage.setScrollFocus(scrollFocus != null ? scrollFocus : dialog);
         for (Dialog otherDialogs : dialogs)
             otherDialogs.hide();
         dialogs.add(dialog);
         selectFirst();
         dialog.show(stage);
-
+        AdventureDialogUtil.fitOnStage(stage, dialog);
+        if (scrollFocus != null) {
+            stage.setScrollFocus(scrollFocus);
+            AdventureDialogUtil.retainScrollFocus(scrollFocus);
+        }
     }
 
     private void requestTextInput(String text, KeyBoardDialog.ScreenKeyboardFinished e) {
@@ -237,6 +248,19 @@ public void removeDialog() {
         } else {
             possibleSelectionStack.removeIndex(possibleSelectionStack.size - 1);
         }
+        if (dialogs.isEmpty()) {
+            onDialogClosed();
+        }
+    }
+
+    public void removeAllDialogs() {
+        while (!dialogs.isEmpty()) {
+            removeDialog();
+        }
+    }
+
+    /** Called after the last dialog is dismissed; override to restore scene focus. */
+    protected void onDialogClosed() {
     }
 
     public Dialog createGenericDialog(String title, String label, String stringYes, String stringNo, Runnable runnableYes, Runnable runnableNo) {
@@ -258,6 +282,12 @@ public Dialog createGenericDialog(String title, String label, String stringYes,
         if (cancelButton)
             dialog.button(Controls.newTextButton(stringCancel, this::removeDialog));
 
+        if (runnableNo != null) {
+            dialog.setUserObject(runnableNo);
+        } else if (runnableYes != null && stringNo == null) {
+            dialog.setUserObject(runnableYes);
+        }
+
         return dialog;
     }
 
@@ -343,6 +373,10 @@ public boolean keyReleased(int keycode) {
     public boolean keyPressed(int keycode) {
         ui.pressDown(keycode);
 
+        if (dialogShowing() && tryDialogAbort(keycode)) {
+            return true;
+        }
+
         Selectable selection = getSelected();
         if (KeyBinding.Use.isPressed(keycode)) {
             if (selection != null) {
@@ -361,7 +395,7 @@ public boolean keyPressed(int keycode) {
             }
         }
 
-        if (KeyBinding.Back.isPressed(keycode) && selection != null) {
+        if (KeyBinding.Back.isPressed(keycode) && selection != null && !dialogShowing()) {
             selection.onDeSelect();
             stage.setKeyboardFocus(null);
         }
@@ -410,6 +444,20 @@ private boolean dialogShowing() {
         return !dialogs.isEmpty();
     }
 
+    /** Escape / Back runs the top dialog's abort handler when set via {@link Dialog#setUserObject}. */
+    private boolean tryDialogAbort(int keycode) {
+        if (keycode != Input.Keys.ESCAPE && !KeyBinding.Back.isPressed(keycode)) {
+            return false;
+        }
+        Dialog top = dialogs.get(dialogs.size - 1);
+        Object handler = top.getUserObject();
+        if (handler instanceof Runnable abort) {
+            abort.run();
+            return true;
+        }
+        return false;
+    }
+
 
     @Override
     public void disconnected(final Controller controller) {
diff --git a/forge-gui-mobile/src/forge/adventure/stage/ConsoleCommandInterpreter.java b/forge-gui-mobile/src/forge/adventure/stage/ConsoleCommandInterpreter.java
index 73a433a9d32..6fdaf844d07 100644
--- a/forge-gui-mobile/src/forge/adventure/stage/ConsoleCommandInterpreter.java
+++ b/forge-gui-mobile/src/forge/adventure/stage/ConsoleCommandInterpreter.java
@@ -27,8 +27,11 @@
 import forge.model.CardBlock;
 import forge.model.FModel;
 import forge.screens.CoverScreen;
+import forge.deck.io.DeckSerializer;
 import forge.util.Aggregates;
+import forge.util.FileUtil;
 
+import java.io.File;
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.HashMap;
@@ -561,5 +564,66 @@ private ConsoleCommandInterpreter() {
             
             return "Exit the map to reset it.";
         });
+        registerCommand(new String[]{"load", "deck"}, s -> {
+            if (s.length < 1) return "Command needs 1 parameter: file path.";
+            File file = CardUtil.resolveFilePath(s[0]);
+            if (!file.exists()) return "File not found: " + file.getAbsolutePath();
+            CardUtil.ImportResult result = CardUtil.importDeckFromFile(file, Current.player(), CardUtil.ImportMode.GIVE_MISSING);
+            if (!result.success) return "Import failed: " + result.message;
+            return String.format("Imported '%s' into slot %d (%d cards added to collection)",
+                result.deckName, result.slot + 1, result.cardsAdded);
+        });
+        registerCommand(new String[]{"load", "deck", "buy"}, s -> {
+            if (s.length < 1) return "Command needs 1 parameter: file path.";
+            File file = CardUtil.resolveFilePath(s[0]);
+            if (!file.exists()) return "File not found: " + file.getAbsolutePath();
+            CardUtil.ImportResult result = CardUtil.importDeckFromFile(file, Current.player(), CardUtil.ImportMode.BUY_MISSING);
+            if (!result.success) return "Import failed: " + result.message;
+            return String.format("Imported '%s' into slot %d (%d cards purchased)",
+                result.deckName, result.slot + 1, result.cardsAdded);
+        });
+        registerCommand(new String[]{"check", "deck"}, s -> {
+            if (s.length < 1) return "Command needs 1 parameter: file path.";
+            File file = CardUtil.resolveFilePath(s[0]);
+            if (!file.exists()) return "File not found: " + file.getAbsolutePath();
+            CardUtil.ImportResult result = CardUtil.importDeckFromFile(file, Current.player(), CardUtil.ImportMode.REPORT_ONLY);
+            if (!result.success) return "Import failed: " + result.message;
+            if (result.importedDeck()) {
+                return String.format("You own all cards. Imported '%s' into slot %d.",
+                    result.deckName, result.slot + 1);
+            }
+            return result.formatMissingReport();
+        });
+        registerCommand(new String[]{"save", "deck"}, s -> {
+            if (s.length < 1) return "Command needs 1 parameter: file path.";
+            File file = CardUtil.resolveFilePath(s[0]);
+            try {
+                DeckSerializer.writeDeck(Current.player().getSelectedDeck(), file);
+                return "Saved deck to " + file.getAbsolutePath();
+            } catch (Exception e) {
+                return "Save failed: " + e.getMessage();
+            }
+        });
+        registerCommand(new String[]{"export", "collection"}, s -> {
+            if (s.length < 1) return "Command needs 1 parameter: file path.";
+            File file = CardUtil.resolveFilePath(s[0]);
+            try {
+                String arenaList = CardUtil.exportCollectionAsArena(Current.player());
+                FileUtil.writeFile(file, arenaList);
+                return String.format("Exported %d unique cards to %s (Arena format)",
+                    Current.player().getCards().countDistinct(), file.getAbsolutePath());
+            } catch (Exception e) {
+                return "Export failed: " + e.getMessage();
+            }
+        });
+        registerCommand(new String[]{"mark", "sell"}, s -> {
+            if (s.length < 1) return "Command needs 1 parameter: file path.";
+            File file = CardUtil.resolveFilePath(s[0]);
+            if (!file.exists()) return "File not found: " + file.getAbsolutePath();
+            CardUtil.MarkSellResult result = CardUtil.markCardsForSale(file, Current.player());
+            if (!result.success) return "Mark failed: " + result.message;
+            return String.format("Marked %d cards for sale (%d skipped: in decks/already marked/not owned)",
+                result.marked, result.skipped);
+        });
     }
 }
diff --git a/forge-gui-mobile/src/forge/adventure/util/AdventureDialogUtil.java b/forge-gui-mobile/src/forge/adventure/util/AdventureDialogUtil.java
new file mode 100644
index 00000000000..de25e2d8529
--- /dev/null
+++ b/forge-gui-mobile/src/forge/adventure/util/AdventureDialogUtil.java
@@ -0,0 +1,630 @@
+package forge.adventure.util;
+
+import java.util.List;
+
+import org.apache.commons.lang3.StringUtils;
+
+import com.badlogic.gdx.graphics.Color;
+import com.badlogic.gdx.graphics.g2d.BitmapFont;
+import com.badlogic.gdx.graphics.g2d.GlyphLayout;
+import com.badlogic.gdx.scenes.scene2d.Actor;
+import com.badlogic.gdx.scenes.scene2d.InputEvent;
+import com.badlogic.gdx.scenes.scene2d.InputListener;
+import com.badlogic.gdx.scenes.scene2d.Stage;
+import com.badlogic.gdx.scenes.scene2d.ui.Cell;
+import com.badlogic.gdx.scenes.scene2d.ui.Dialog;
+import com.badlogic.gdx.scenes.scene2d.ui.Label;
+import com.badlogic.gdx.scenes.scene2d.ui.ScrollPane;
+import com.badlogic.gdx.scenes.scene2d.ui.Table;
+import com.badlogic.gdx.scenes.scene2d.ui.TextField;
+import com.badlogic.gdx.utils.Align;
+import com.github.tommyettinger.textra.TextraButton;
+import com.github.tommyettinger.textra.TextraLabel;
+
+import forge.Forge;
+import forge.adventure.scene.Scene;
+
+/**
+ * Adventure deck-list dialogs: fixed width, measured row heights, UI-window sizing.
+ * <p>
+ * Layout pattern (top to bottom): title → body line(s) → option rows → abort.
+ * Row heights come from wrapped text measurement, not {@link TextraButton#getPrefHeight()}.
+ */
+public final class AdventureDialogUtil {
+    private static final float H_PAD = 6f;
+    private static final float V_PAD = 4f;
+    private static final float GAP = 2f;
+    private static final float BUTTON_TEXT_INSET = 8f;
+    private static final float OPTION_ROW_MIN = 14f;
+    private static final float OPTION_ROW_MAX = 24f;
+    private static final float IMPORT_BODY_MAX = 70f;
+    private static final float DIALOG_CHROME_W = 16f;
+    private static final GlyphLayout GLYPH = new GlyphLayout();
+
+    private static float bodyScrollMax() {
+        return Math.min(96f, Math.max(56f, windowHeight() * 0.38f));
+    }
+
+    private AdventureDialogUtil() { }
+
+    public static final class ChoiceOption {
+        public final String label;
+        public final Runnable action;
+
+        public ChoiceOption(String label, Runnable action) {
+            this.label = label;
+            this.action = action;
+        }
+    }
+
+    public static float windowWidth() {
+        return Scene.getIntendedWidth();
+    }
+
+    public static float windowHeight() {
+        return Scene.getIntendedHeight();
+    }
+
+    public static float dialogWidth() {
+        return Math.min(300f, Math.max(240f, windowWidth() * 0.72f));
+    }
+
+    public static float maxDialogHeight() {
+        return windowHeight() * 0.88f;
+    }
+
+    public static float choiceButtonHeight() {
+        return OPTION_ROW_MIN;
+    }
+
+    public static float actionButtonHeight() {
+        return OPTION_ROW_MIN;
+    }
+
+    public static float compactButtonHeight() {
+        return OPTION_ROW_MIN;
+    }
+
+    public static float compactFieldHeight() {
+        return 13f;
+    }
+
+    public static float fileListRowHeight() {
+        return 11f;
+    }
+
+    public static float filePickerMaxHeight() {
+        return windowHeight() * 0.86f;
+    }
+
+    public static float filePickerChromeHeight(boolean hasHelpText) {
+        float h = V_PAD * 2f + 12f;
+        if (hasHelpText) {
+            h += 18f;
+        }
+        h += actionButtonHeight() + compactFieldHeight() + 8f;
+        h += compactFieldHeight() + 8f;
+        h += actionButtonHeight() + GAP + 8f;
+        return h;
+    }
+
+    public static float filePickerListHeightMax(boolean hasHelpText) {
+        return Math.max(28f, filePickerMaxHeight() - filePickerChromeHeight(hasHelpText));
+    }
+
+    public static TextraLabel wrappedLabel(String text, float width) {
+        float wrapW = Math.max(36f, width - 8f);
+        TextraLabel label = Controls.newTextraLabel("");
+        label.setWrap(true);
+        label.setWidth(wrapW);
+        label.layout.setTargetWidth(wrapW);
+        label.setText(text);
+        return label;
+    }
+
+    private static BitmapFont defaultFont() {
+        return Controls.getSkin().getFont("default");
+    }
+
+    /** Wrapped text height via {@link GlyphLayout} (matches what Label will draw). */
+    public static float measureWrappedHeight(String text, float width) {
+        if (StringUtils.isEmpty(text)) {
+            return 0f;
+        }
+        float wrapW = Math.max(40f, width - 8f);
+        GLYPH.setText(defaultFont(), text, Color.WHITE, wrapW, Align.left, true);
+        return GLYPH.height + 4f;
+    }
+
+    public static float textBlockHeight(String text, float width, float maxH) {
+        return Math.min(maxH, Math.max(12f, measureWrappedHeight(text, width)));
+    }
+
+    public static float optionRowHeight(String text, float width) {
+        float inner = Math.max(40f, width - BUTTON_TEXT_INSET);
+        float h = measureWrappedHeight(text, inner) + 2f;
+        return Math.min(OPTION_ROW_MAX, Math.max(OPTION_ROW_MIN, h));
+    }
+
+    public static void addBodyLine(Table parent, String text, float width) {
+        addBodyLine(parent, text, width, bodyScrollMax());
+    }
+
+    public static void addBodyLine(Table parent, String text, float width, float maxH) {
+        if (StringUtils.isEmpty(text)) {
+            return;
+        }
+        float h = textBlockHeight(text, width, maxH);
+        Label label = new Label(text, Controls.getSkin());
+        label.setWrap(true);
+        label.setAlignment(Align.topLeft);
+        parent.add(label).width(width - 4f).height(h).align(Align.topLeft).padBottom(GAP).row();
+    }
+
+    /**
+     * Body text with scroll when it exceeds {@link #bodyScrollMax()}.
+     *
+     * @return scroll pane when scrollable, else null
+     */
+    public static ScrollPane addBodyContent(Table parent, float width, String text) {
+        if (StringUtils.isEmpty(text)) {
+            return null;
+        }
+        float maxH = bodyScrollMax();
+        float fullH = measureWrappedHeight(text, width);
+        if (fullH <= maxH) {
+            addBodyLine(parent, text, width, fullH);
+            return null;
+        }
+        Label bodyLabel = new Label(text, Controls.getSkin());
+        bodyLabel.setWrap(true);
+        bodyLabel.setAlignment(Align.topLeft);
+        bodyLabel.setWidth(width - 8f);
+        bodyLabel.setHeight(multiLineLabelHeight(text, width));
+        ScrollPane scroll = new ScrollPane(bodyLabel, Controls.getSkin());
+        configureScrollPane(scroll);
+        scroll.setScrollingDisabled(true, false);
+        retainScrollFocus(scroll);
+        parent.add(scroll).width(width).height(maxH).align(Align.topLeft).padBottom(GAP).row();
+        return scroll;
+    }
+
+    private static void finishDialog(Dialog dialog, float contentWidth) {
+        dialog.pack();
+        float minW = contentWidth + DIALOG_CHROME_W;
+        if (dialog.getWidth() < minW) {
+            dialog.setWidth(minW);
+            dialog.invalidate();
+            dialog.layout();
+        }
+    }
+
+    private static void addDialogButtonRow(Dialog dialog, float width, String primaryLabel, Runnable onPrimary,
+            String secondaryLabel, Runnable onSecondary) {
+        Table actions = new Table();
+        actions.defaults().pad(0);
+        if (secondaryLabel == null || onSecondary == null) {
+            float rowH = optionRowHeight(primaryLabel, width);
+            TextraButton btn = choiceButton(primaryLabel, width, onPrimary);
+            btn.setSize(width, rowH);
+            actions.add(btn).width(width).height(rowH);
+        } else {
+            addSideBySideActions(actions, width, primaryLabel, onPrimary, secondaryLabel, onSecondary);
+        }
+        dialog.getButtonTable().pad(V_PAD, H_PAD, V_PAD, H_PAD);
+        dialog.getButtonTable().add(actions).width(width);
+    }
+
+    /**
+     * Content area plus OK | secondary in the button row (e.g. rename with extra fields).
+     */
+    public static Dialog buildFormDialog(String title, String confirmLabel, Runnable onConfirm,
+            Runnable onCancel, java.util.function.Consumer<Table> extendContent) {
+        float w = dialogWidth();
+        Dialog dialog = newEmptyDialog(onCancel);
+        Table root = newRoot();
+        dialog.getContentTable().add(root).width(w).top().left();
+        if (StringUtils.isNotEmpty(title)) {
+            root.add(titleLabel(title, w)).width(w).align(Align.topLeft).padBottom(GAP).row();
+        }
+        extendContent.accept(root);
+        var loc = Forge.getLocalizer();
+        addDialogButtonRow(dialog, w, confirmLabel, onConfirm, loc.getMessage("lblAbort"), onCancel);
+        finishDialog(dialog, w);
+        return dialog;
+    }
+
+    public static Label titleLabel(String text, float width) {
+        Label label = new Label(text, Controls.getSkin());
+        label.setAlignment(Align.topLeft);
+        label.setWrap(true);
+        label.setWidth(Math.max(36f, width - 8f));
+        return label;
+    }
+
+    public static void addWrappedBody(Table parent, String body, float width) {
+        addBodyLine(parent, body, width);
+    }
+
+    public static ScrollPane newFileListScrollPane(Table fileTable) {
+        ScrollPane scroll = new ScrollPane(fileTable, Controls.getSkin(), "paper");
+        configureScrollPane(scroll);
+        return scroll;
+    }
+
+    public static void configureScrollPane(ScrollPane scroll) {
+        scroll.setFadeScrollBars(false);
+        scroll.setScrollbarsVisible(true);
+        scroll.setScrollingDisabled(true, false);
+        scroll.setOverscroll(false, false);
+    }
+
+    /** Keep wheel / scroll keys on this pane while the pointer is over it. */
+    public static void retainScrollFocus(ScrollPane scroll) {
+        scroll.addListener(new InputListener() {
+            @Override
+            public void enter(InputEvent event, float x, float y, int pointer, Actor fromActor) {
+                event.getStage().setScrollFocus(scroll);
+            }
+        });
+    }
+
+    private static float multiLineLabelHeight(String text, float width) {
+        if (StringUtils.isEmpty(text)) {
+            return defaultFont().getLineHeight();
+        }
+        int lines = 1;
+        for (int i = 0; i < text.length(); i++) {
+            if (text.charAt(i) == '\n') {
+                lines++;
+            }
+        }
+        float lineH = defaultFont().getLineHeight();
+        float wrapW = Math.max(40f, width - 8f);
+        float wrapped = measureWrappedHeight(text, width);
+        return Math.max(lines * lineH + 4f, wrapped);
+    }
+
+    public static void fitOnStage(Stage stage, Dialog dialog) {
+        if (stage == null || dialog == null) {
+            return;
+        }
+        dialog.pack();
+        float margin = 4f;
+        float sw = stage.getWidth();
+        float sh = stage.getHeight();
+        float maxW = sw - margin * 2f;
+        float maxH = maxDialogHeight();
+        float dw = dialog.getWidth();
+        float dh = dialog.getHeight();
+        if (dw > maxW) {
+            dw = maxW;
+        }
+        if (dh > maxH) {
+            dh = maxH;
+        }
+        dialog.setSize(dw, dh);
+        dialog.invalidate();
+        dialog.layout();
+        float x = (sw - dw) * 0.5f;
+        float y = (sh - dh) * 0.5f;
+        if (x < margin) {
+            x = margin;
+        }
+        if (x + dw > sw - margin) {
+            x = sw - margin - dw;
+        }
+        if (y < margin) {
+            y = margin;
+        }
+        if (y + dh > sh - margin) {
+            y = sh - margin - dh;
+        }
+        dialog.setPosition(x, y);
+    }
+
+    private static Dialog newEmptyDialog(Runnable onEscape) {
+        Dialog dialog = new Dialog("", Controls.getSkin());
+        dialog.getTitleTable().clearChildren();
+        dialog.getButtonTable().clearChildren();
+        dialog.getContentTable().clear();
+        dialog.setUserObject(onEscape);
+        return dialog;
+    }
+
+    private static Table newRoot() {
+        Table root = new Table();
+        root.pad(V_PAD, H_PAD, V_PAD, H_PAD);
+        root.defaults().pad(0);
+        return root;
+    }
+
+    /**
+     * Import-deck menu: title, intro, prompt, three modes, abort.
+     */
+    public static Dialog buildImportDeckDialog(String intro, String prompt,
+            String ownedLabel, Runnable onOwned,
+            String buyLabel, Runnable onBuy,
+            String giveLabel, Runnable onGive,
+            Runnable onAbort) {
+        float w = dialogWidth();
+        Dialog dialog = newEmptyDialog(onAbort);
+        Table root = newRoot();
+        dialog.getContentTable().add(root).width(w).top().left();
+
+        root.add(titleLabel(Forge.getLocalizer().getMessage("lblAdvImportDeck"), w))
+            .width(w).align(Align.topLeft).padBottom(GAP).row();
+
+        String bodyText = intro + "\n\n" + prompt;
+        float bodyH = textBlockHeight(bodyText, w, IMPORT_BODY_MAX);
+        Label bodyLabel = new Label(bodyText, Controls.getSkin());
+        bodyLabel.setWrap(true);
+        bodyLabel.setAlignment(Align.topLeft);
+        ScrollPane bodyScroll = new ScrollPane(bodyLabel, Controls.getSkin());
+        configureScrollPane(bodyScroll);
+        bodyScroll.setScrollingDisabled(true, false);
+        root.add(bodyScroll).width(w).height(bodyH).align(Align.topLeft).padBottom(GAP).row();
+
+        addCompactOptionRow(root, w, ownedLabel, onOwned);
+        addCompactOptionRow(root, w, buyLabel, onBuy);
+        addCompactOptionRow(root, w, giveLabel, onGive);
+        addCompactOptionRow(root, w, Forge.getLocalizer().getMessage("lblAbort"), onAbort);
+
+        finishDialog(dialog, w);
+        return dialog;
+    }
+
+    public static Dialog buildChoiceDialog(String title, String body,
+            List<ChoiceOption> options, Runnable onAbort) {
+        float w = dialogWidth();
+        Dialog dialog = newEmptyDialog(onAbort);
+        Table root = newRoot();
+        dialog.getContentTable().add(root).width(w).top().left();
+
+        if (StringUtils.isNotEmpty(title)) {
+            root.add(titleLabel(title, w)).width(w).align(Align.topLeft).padBottom(GAP).row();
+        }
+        addBodyContent(root, w, body);
+        for (ChoiceOption option : options) {
+            addCompactOptionRow(root, w, option.label, option.action);
+        }
+        if (onAbort != null) {
+            addDialogButtonRow(dialog, w, Forge.getLocalizer().getMessage("lblAbort"), onAbort,
+                null, null);
+        }
+
+        finishDialog(dialog, w);
+        return dialog;
+    }
+
+    public static Dialog buildMessageDialog(String title, String body, Runnable onClose) {
+        return buildMessageDialog(title, body, Forge.getLocalizer().getMessage("lblAbort"), onClose);
+    }
+
+    /** Brief status with no buttons (caller dismisses). */
+    public static Dialog buildTransientMessage(String message) {
+        float w = dialogWidth();
+        Dialog dialog = new Dialog("", Controls.getSkin());
+        dialog.getTitleTable().clearChildren();
+        dialog.getButtonTable().clearChildren();
+        dialog.getContentTable().clear();
+        Table root = newRoot();
+        dialog.getContentTable().add(root).width(w).top().left();
+        root.add(titleLabel(message, w)).width(w).align(Align.center).row();
+        finishDialog(dialog, w);
+        return dialog;
+    }
+
+    public static Dialog buildMessageDialog(String title, String body, String closeLabel, Runnable onClose) {
+        float w = dialogWidth();
+        Dialog dialog = newEmptyDialog(onClose);
+        Table root = newRoot();
+        dialog.getContentTable().add(root).width(w).top().left();
+
+        if (StringUtils.isNotEmpty(title)) {
+            root.add(titleLabel(title, w)).width(w).align(Align.topLeft).padBottom(GAP).row();
+        }
+        addBodyContent(root, w, body);
+        addDialogButtonRow(dialog, w, closeLabel, onClose, null, null);
+        finishDialog(dialog, w);
+        return dialog;
+    }
+
+    /**
+     * Long report (e.g. missing-card list): fixed-height scroll body, Save | Abort in button row.
+     *
+     * @param scrollOut optional single-element array; receives the scroll pane for {@code showDialog(dialog, scroll)}
+     */
+    public static Dialog buildScrollableReportDialog(String title, String body, String saveLabel,
+            Runnable onSave, Runnable onClose, ScrollPane[] scrollOut) {
+        float w = dialogWidth();
+        float scrollH = Math.min(132f, Math.max(72f, windowHeight() * 0.48f));
+        Dialog dialog = newEmptyDialog(onClose);
+        Table root = newRoot();
+        dialog.getContentTable().add(root).width(w).top().left();
+
+        if (StringUtils.isNotEmpty(title)) {
+            root.add(titleLabel(title, w)).width(w).align(Align.topLeft).padBottom(GAP).row();
+        }
+
+        Label bodyLabel = new Label(body, Controls.getSkin());
+        bodyLabel.setAlignment(Align.topLeft);
+        bodyLabel.setWrap(true);
+        bodyLabel.setWidth(w - 8f);
+        bodyLabel.setHeight(multiLineLabelHeight(body, w));
+
+        ScrollPane scroll = new ScrollPane(bodyLabel, Controls.getSkin());
+        configureScrollPane(scroll);
+        scroll.setScrollingDisabled(true, false);
+        retainScrollFocus(scroll);
+        root.add(scroll).width(w).height(scrollH).align(Align.topLeft).row();
+
+        addDialogButtonRow(dialog, w, saveLabel, onSave,
+            Forge.getLocalizer().getMessage("lblAbort"), onClose);
+
+        if (scrollOut != null && scrollOut.length > 0) {
+            scrollOut[0] = scroll;
+        }
+        finishDialog(dialog, w);
+        return dialog;
+    }
+
+    /**
+     * Scrollable report with a single OK button (e.g. mark-for-sale results).
+     */
+    public static Dialog buildScrollableOkDialog(String title, String body, Runnable onOk,
+            ScrollPane[] scrollOut) {
+        return buildScrollableOkDialog(title, body, onOk, null, scrollOut);
+    }
+
+    public static Dialog buildScrollableOkDialog(String title, String body, Runnable onOk,
+            Runnable onRollback, ScrollPane[] scrollOut) {
+        float w = dialogWidth();
+        float scrollH = Math.min(132f, Math.max(72f, windowHeight() * 0.48f));
+        Dialog dialog = newEmptyDialog(onOk);
+        Table root = newRoot();
+        dialog.getContentTable().add(root).width(w).top().left();
+
+        if (StringUtils.isNotEmpty(title)) {
+            root.add(titleLabel(title, w)).width(w).align(Align.topLeft).padBottom(GAP).row();
+        }
+
+        Label bodyLabel = new Label(body, Controls.getSkin());
+        bodyLabel.setAlignment(Align.topLeft);
+        bodyLabel.setWrap(true);
+        bodyLabel.setWidth(w - 8f);
+        bodyLabel.setHeight(multiLineLabelHeight(body, w));
+
+        ScrollPane scroll = new ScrollPane(bodyLabel, Controls.getSkin());
+        configureScrollPane(scroll);
+        scroll.setScrollingDisabled(true, false);
+        retainScrollFocus(scroll);
+        root.add(scroll).width(w).height(scrollH).align(Align.topLeft).row();
+
+        if (onRollback != null) {
+            addDialogButtonRow(dialog, w, Forge.getLocalizer().getMessage("lblOK"), onOk,
+                Forge.getLocalizer().getMessage("lblAdvRollback"), onRollback);
+        } else {
+            addDialogButtonRow(dialog, w, Forge.getLocalizer().getMessage("lblOK"), onOk, null, null);
+        }
+
+        if (scrollOut != null && scrollOut.length > 0) {
+            scrollOut[0] = scroll;
+        }
+        finishDialog(dialog, w);
+        return dialog;
+    }
+
+    public static Dialog buildConfirmDialog(String title, String body, String confirmLabel,
+            Runnable onConfirm, Runnable onAbort) {
+        return buildConfirmDialog(title, body, confirmLabel, onConfirm,
+            Forge.getLocalizer().getMessage("lblAbort"), onAbort);
+    }
+
+    public static Dialog buildConfirmDialog(String title, String body, String confirmLabel,
+            Runnable onConfirm, String cancelLabel, Runnable onCancel) {
+        float w = dialogWidth();
+        Dialog dialog = newEmptyDialog(onCancel);
+        Table root = newRoot();
+        dialog.getContentTable().add(root).width(w).top().left();
+
+        if (StringUtils.isNotEmpty(title)) {
+            root.add(titleLabel(title, w)).width(w).align(Align.topLeft).padBottom(GAP).row();
+        }
+        addBodyContent(root, w, body);
+        addDialogButtonRow(dialog, w, confirmLabel, onConfirm, cancelLabel, onCancel);
+        finishDialog(dialog, w);
+        return dialog;
+    }
+
+    private static void addCompactOptionRow(Table parent, float width, String text, Runnable action) {
+        float rowH = optionRowHeight(text, width);
+        TextraButton button = choiceButton(text, width, action);
+        button.setSize(width, rowH);
+        parent.add(button).width(width).height(rowH).padTop(1f).row();
+    }
+
+    private static void addOptionRow(Table parent, float width, String text, Runnable action) {
+        addCompactOptionRow(parent, width, text, action);
+    }
+
+    public static void addSideBySideActions(Table parent, float width, String primaryLabel,
+            Runnable onPrimary, Runnable onAbort) {
+        addSideBySideActions(parent, width, primaryLabel, onPrimary,
+            Forge.getLocalizer().getMessage("lblAbort"), onAbort);
+    }
+
+    public static void addSideBySideActions(Table parent, float width, String primaryLabel,
+            Runnable onPrimary, String secondaryLabel, Runnable onSecondary) {
+        float half = (width - GAP) * 0.5f;
+        float rowH = Math.max(optionRowHeight(primaryLabel, half),
+            optionRowHeight(secondaryLabel, half));
+        parent.defaults().pad(0);
+        TextraButton ok = choiceButton(primaryLabel, half, onPrimary);
+        TextraButton cancel = choiceButton(secondaryLabel, half, onSecondary);
+        ok.setSize(half, rowH);
+        cancel.setSize(half, rowH);
+        parent.add(ok).width(half).height(rowH);
+        parent.add(cancel).width(half).height(rowH).padLeft(GAP);
+    }
+
+    public static void addSideBySideActions(Table parent, String primaryLabel, Runnable onPrimary,
+            Runnable onAbort) {
+        addSideBySideActions(parent, dialogWidth(), primaryLabel, onPrimary, onAbort);
+    }
+
+    public static void addAbortRow(Table parent, Runnable onAbort) {
+        if (onAbort == null) {
+            return;
+        }
+        addOptionRow(parent, dialogWidth(), Forge.getLocalizer().getMessage("lblAbort"), onAbort);
+    }
+
+    public static TextraButton choiceButton(String text, float cellWidth, Runnable onClick) {
+        float innerW = Math.max(32f, cellWidth - BUTTON_TEXT_INSET);
+        TextraButton button = Controls.newTextButton(text, onClick);
+        TextraLabel lbl = button.getTextraLabel();
+        lbl.setWrap(true);
+        lbl.setWidth(innerW);
+        lbl.layout.setTargetWidth(innerW);
+        button.setText(text);
+        lbl.setWrap(true);
+        lbl.layout.setTargetWidth(innerW);
+        lbl.setWidth(innerW);
+        float rowH = optionRowHeight(text, cellWidth);
+        button.setSize(cellWidth, rowH);
+        return button;
+    }
+
+    public static TextraButton choiceButton(String text, Runnable onClick) {
+        return choiceButton(text, dialogWidth(), onClick);
+    }
+
+    public static Cell<TextraButton> addFullWidthButton(Table table, String text, Runnable onClick) {
+        float w = dialogWidth();
+        float h = optionRowHeight(text, w);
+        TextraButton button = choiceButton(text, w, onClick);
+        return table.add(button).width(w).height(h).fillX().padTop(GAP);
+    }
+
+    public static TextraButton compactButton(String text, Runnable onClick) {
+        return choiceButton(text, onClick);
+    }
+
+    public static TextField compactTextField(String text) {
+        return Controls.newTextField(text);
+    }
+
+    public static TextraLabel compactLabel(String text, boolean wrap) {
+        return wrappedLabel(text, dialogWidth());
+    }
+
+    public static void addDialogActions(Table parent, String primaryLabel, Runnable onPrimary,
+            Runnable onAbort) {
+        addSideBySideActions(parent, primaryLabel, onPrimary, onAbort);
+    }
+
+    public static void centerOnStage(Stage stage, Dialog dialog) {
+        fitOnStage(stage, dialog);
+    }
+}
diff --git a/forge-gui-mobile/src/forge/adventure/util/AdventureFilePicker.java b/forge-gui-mobile/src/forge/adventure/util/AdventureFilePicker.java
new file mode 100644
index 00000000000..c30fc1df064
--- /dev/null
+++ b/forge-gui-mobile/src/forge/adventure/util/AdventureFilePicker.java
@@ -0,0 +1,338 @@
+package forge.adventure.util;
+
+import java.io.File;
+import java.util.Arrays;
+import java.util.Comparator;
+import java.util.function.Consumer;
+
+import org.apache.commons.lang3.StringUtils;
+
+import com.badlogic.gdx.Gdx;
+import com.badlogic.gdx.graphics.Color;
+import com.badlogic.gdx.scenes.scene2d.InputEvent;
+import com.badlogic.gdx.scenes.scene2d.ui.Dialog;
+import com.badlogic.gdx.scenes.scene2d.ui.Label;
+import com.badlogic.gdx.scenes.scene2d.ui.ScrollPane;
+import com.badlogic.gdx.scenes.scene2d.ui.Table;
+import com.badlogic.gdx.scenes.scene2d.ui.TextField;
+import com.badlogic.gdx.scenes.scene2d.utils.ClickListener;
+import com.badlogic.gdx.utils.Align;
+import com.github.tommyettinger.textra.TextraButton;
+
+import forge.Forge;
+import forge.adventure.scene.UIScene;
+import forge.gui.GuiBase;
+import forge.toolbox.FFileChooser;
+import forge.toolbox.FFileChooser.ChoiceType;
+
+/**
+ * File picker for Adventure deck import/export.
+ */
+public final class AdventureFilePicker {
+    private static final float PAD = 4f;
+    private static final float FIELD_H = 14f;
+    private static final float LIST_H = 58f;
+    private static final float ROW_H = 12f;
+    private static final float BTN_H = 16f;
+    private static final float LIST_H_WITH_HELP = 46f;
+
+    private AdventureFilePicker() { }
+
+    public static String getDefaultBaseDir() {
+        String downloads = Forge.getDeviceAdapter().getDownloadsDir();
+        if (StringUtils.isNotEmpty(downloads)) {
+            File dir = new File(downloads);
+            if (dir.isDirectory()) {
+                String path = dir.getAbsolutePath();
+                return path.endsWith(File.separator) ? path : path + File.separator;
+            }
+        }
+        String home = System.getProperty("user.home");
+        if (home != null) {
+            File fallback = new File(home, "Downloads");
+            if (!fallback.isDirectory()) {
+                fallback = new File(home);
+            }
+            String path = fallback.getAbsolutePath();
+            return path.endsWith(File.separator) ? path : path + File.separator;
+        }
+        return File.separator;
+    }
+
+    public static void requestStorageAccessIfNeeded() {
+        if (GuiBase.isAndroid() && Forge.getDeviceAdapter().needFileAccess()) {
+            Forge.getDeviceAdapter().requestFileAcces();
+        }
+    }
+
+    public static void chooseOpenFile(final String title, final Consumer<File> onChosen) {
+        chooseOpenFile(title, null, onChosen);
+    }
+
+    public static void chooseOpenFile(final String title, final String helpText,
+            final Consumer<File> onChosen) {
+        chooseFile(title, false, "", helpText, onChosen);
+    }
+
+    public static void chooseSaveFile(final String title,
+            final String defaultFilename, final Consumer<File> onChosen) {
+        chooseSaveFile(title, defaultFilename, null, onChosen);
+    }
+
+    public static void chooseSaveFile(final String title,
+            final String defaultFilename, final String helpText,
+            final Consumer<File> onChosen) {
+        chooseFile(title, true, defaultFilename, helpText, onChosen);
+    }
+
+    private static void chooseFile(final String title, final boolean save,
+            final String defaultFilename, final String helpText,
+            final Consumer<File> onChosen) {
+        requestStorageAccessIfNeeded();
+        Runnable showPicker = () -> {
+            if (Forge.getCurrentScene() instanceof UIScene uiScene) {
+                showSceneFileDialog(uiScene, save, title, defaultFilename, helpText, onChosen);
+            } else {
+                ChoiceType type = save ? ChoiceType.SaveFile : ChoiceType.OpenFile;
+                FFileChooser.show(title, type,
+                        defaultFilename != null ? defaultFilename : "",
+                        getDefaultBaseDir(), path -> {
+                    if (!StringUtils.isEmpty(path)) {
+                        onChosen.accept(CardUtil.resolveFilePath(path));
+                    }
+                });
+            }
+        };
+        Gdx.app.postRunnable(showPicker);
+    }
+
+    private static void setFieldText(TextField field, String text) {
+        field.setText(text);
+        field.setCursorPosition(0);
+    }
+
+    private static TextraButton actionButton(String text, float width, Runnable onClick) {
+        TextraButton button = Controls.newTextButton(text, onClick);
+        float inner = Math.max(24f, width - 8f);
+        var lbl = button.getTextraLabel();
+        lbl.setWrap(true);
+        lbl.layout.setTargetWidth(inner);
+        lbl.setWidth(inner);
+        button.setText(text);
+        return button;
+    }
+
+    private static Label fieldLabel(String text) {
+        Label label = new Label(text, Controls.getSkin());
+        label.setAlignment(Align.topLeft);
+        return label;
+    }
+
+    private static Label listRowLabel(String text) {
+        Label label = new Label(text, Controls.getSkin());
+        label.setAlignment(Align.topLeft);
+        label.setColor(Color.WHITE);
+        return label;
+    }
+
+    private static void showSceneFileDialog(final UIScene uiScene, final boolean save,
+            final String title, final String defaultFilename, final String helpText,
+            final Consumer<File> onChosen) {
+        var loc = Forge.getLocalizer();
+        final boolean hasHelp = StringUtils.isNotEmpty(helpText);
+        final float w = AdventureDialogUtil.dialogWidth();
+
+        File startDir = new File(getDefaultBaseDir());
+        final TextField folderField = Controls.newTextField(startDir.getAbsolutePath());
+        final TextField nameField = Controls.newTextField(
+            StringUtils.isNotEmpty(defaultFilename) ? defaultFilename : "");
+        setFieldText(folderField, startDir.getAbsolutePath());
+
+        final Table fileTable = new Table();
+        fileTable.top().left();
+        fileTable.pad(0);
+        fileTable.defaults().left().pad(0);
+
+        final ScrollPane listScroll = new ScrollPane(fileTable, Controls.getSkin());
+        AdventureDialogUtil.configureScrollPane(listScroll);
+        listScroll.setScrollingDisabled(true, false);
+        AdventureDialogUtil.retainScrollFocus(listScroll);
+
+        Dialog dialog = new Dialog("", Controls.getSkin());
+        dialog.getTitleTable().clearChildren();
+        dialog.getButtonTable().clearChildren();
+        dialog.setUserObject((Runnable) uiScene::removeDialog);
+        dialog.getContentTable().clear();
+
+        Table root = new Table();
+        root.top().left();
+        root.pad(PAD);
+        root.defaults().left().pad(0);
+        dialog.getContentTable().add(root).width(w).top().left();
+
+        root.add(fieldLabel(title)).width(w).height(12f).left().padBottom(2f).row();
+
+        if (hasHelp) {
+            AdventureDialogUtil.addBodyContent(root, w, helpText);
+        }
+
+        root.add(fieldLabel(loc.getMessage("lblAdvFolder"))).width(w).height(10f).left().row();
+        root.add(folderField).width(w).height(FIELD_H).left().padBottom(2f).row();
+        root.add(fieldLabel(loc.getMessage("lblAdvFileName"))).width(w).height(10f).left().row();
+        root.add(nameField).width(w).height(FIELD_H).left().padBottom(2f).row();
+        root.add(fieldLabel(loc.getMessage("lblAdvFiles"))).width(w).height(10f).left().padBottom(1f).row();
+        float listH = hasHelp ? LIST_H_WITH_HELP : LIST_H;
+        root.add(listScroll).width(w).height(listH).left().row();
+
+        float half = (w - 4f) * 0.5f;
+        String okText = save ? loc.getMessage("lblSave") : loc.getMessage("lblOK");
+        Runnable onOk = () -> {
+            File result = resolveFolderAndName(folderField.getText(), nameField.getText());
+            if (result == null) {
+                return;
+            }
+            if (save) {
+                if (result.isDirectory()) {
+                    return;
+                }
+                Runnable finishSave = () -> {
+                    uiScene.removeDialog();
+                    onChosen.accept(result);
+                };
+                if (result.exists()) {
+                    String overwriteBody = loc.getMessage("lblAdvOverwriteConfirm", result.getName());
+                    Dialog overwriteDlg = AdventureDialogUtil.buildConfirmDialog(title, overwriteBody,
+                        loc.getMessage("lblAdvOverwrite"),
+                        () -> {
+                            uiScene.removeDialog();
+                            finishSave.run();
+                        },
+                        loc.getMessage("lblAbort"),
+                        uiScene::removeDialog);
+                    uiScene.showDialog(overwriteDlg);
+                } else {
+                    finishSave.run();
+                }
+            } else {
+                if (!result.exists() || result.isDirectory()) {
+                    return;
+                }
+                uiScene.removeDialog();
+                onChosen.accept(result);
+            }
+        };
+        Table actions = new Table();
+        actions.defaults().pad(0);
+        actions.add(actionButton(okText, half, onOk)).width(half).height(BTN_H);
+        actions.add(actionButton(loc.getMessage("lblAbort"), half, uiScene::removeDialog))
+            .width(half).height(BTN_H).padLeft(4f);
+        dialog.getButtonTable().pad(PAD);
+        dialog.getButtonTable().add(actions).width(w).height(BTN_H + 2f);
+
+        final Runnable[] refreshHolder = new Runnable[1];
+        refreshHolder[0] = () -> {
+            fileTable.clearChildren();
+            File dir = directoryForPath(folderField.getText(), getDefaultBaseDir());
+            if (dir == null || !dir.isDirectory()) {
+                listScroll.setScrollY(0);
+                listScroll.setScrollX(0);
+                return;
+            }
+            setFieldText(folderField, dir.getAbsolutePath());
+            float rowW = w - 14f;
+            File parent = dir.getParentFile();
+            if (parent != null) {
+                Label upRow = listRowLabel("..");
+                upRow.addListener(new ClickListener() {
+                    @Override
+                    public void clicked(InputEvent event, float x, float y) {
+                        setFieldText(folderField, parent.getAbsolutePath());
+                        nameField.setText("");
+                        refreshHolder[0].run();
+                    }
+                });
+                fileTable.add(upRow).height(ROW_H).width(rowW).left();
+                fileTable.row();
+            }
+            File[] entries = dir.listFiles(AdventureFilePicker::showInFileList);
+            if (entries == null) {
+                listScroll.setScrollY(0);
+                listScroll.setScrollX(0);
+                listScroll.layout();
+                return;
+            }
+            Arrays.sort(entries, Comparator.comparing(File::getName, String.CASE_INSENSITIVE_ORDER));
+            for (File entry : entries) {
+                String labelText = entry.isDirectory() ? "[ " + entry.getName() + " ]" : entry.getName();
+                Label row = listRowLabel(labelText);
+                row.addListener(new ClickListener() {
+                    @Override
+                    public void clicked(InputEvent event, float x, float y) {
+                        if (entry.isDirectory()) {
+                            setFieldText(folderField, entry.getAbsolutePath());
+                            nameField.setText("");
+                            refreshHolder[0].run();
+                        } else {
+                            setFieldText(folderField, entry.getParentFile().getAbsolutePath());
+                            setFieldText(nameField, entry.getName());
+                            if (getTapCount() >= 2) {
+                                onOk.run();
+                            }
+                        }
+                    }
+                });
+                fileTable.add(row).height(ROW_H).width(rowW).left();
+                fileTable.row();
+            }
+            listScroll.setScrollY(0);
+            listScroll.setScrollX(0);
+            listScroll.layout();
+        };
+
+        folderField.setTextFieldListener((f, c) -> {
+            if (c == '\n' || c == '\t') {
+                refreshHolder[0].run();
+            }
+        });
+
+        dialog.pack();
+        float chrome = 16f;
+        dialog.setWidth(w + chrome);
+        refreshHolder[0].run();
+        uiScene.showDialog(dialog, listScroll);
+    }
+
+    private static boolean showInFileList(File dir, String name) {
+        return !name.startsWith(".");
+    }
+
+    private static File resolveFolderAndName(String folderText, String nameText) {
+        if (StringUtils.isBlank(folderText)) {
+            return null;
+        }
+        File folder = new File(folderText.trim());
+        if (StringUtils.isBlank(nameText)) {
+            return folder.isDirectory() ? folder : null;
+        }
+        String name = nameText.trim();
+        if (name.contains(File.separator) || name.contains("/")) {
+            return CardUtil.resolveFilePath(name);
+        }
+        return new File(folder, name);
+    }
+
+    private static File directoryForPath(String pathText, String defaultBaseDir) {
+        if (StringUtils.isBlank(pathText)) {
+            return new File(defaultBaseDir);
+        }
+        File file = new File(pathText.trim());
+        if (file.isDirectory()) {
+            return file;
+        }
+        File parent = file.getParentFile();
+        if (parent != null && parent.isDirectory()) {
+            return parent;
+        }
+        return new File(defaultBaseDir);
+    }
+}
diff --git a/forge-gui-mobile/src/forge/adventure/util/CardUtil.java b/forge-gui-mobile/src/forge/adventure/util/CardUtil.java
index 3484e3bd46c..92fd6efc406 100644
--- a/forge-gui-mobile/src/forge/adventure/util/CardUtil.java
+++ b/forge-gui-mobile/src/forge/adventure/util/CardUtil.java
@@ -12,10 +12,15 @@
 import forge.card.DeckHints.Type;
 import forge.card.mana.ManaCost;
 import forge.card.mana.ManaCostShard;
+import forge.adventure.player.AdventurePlayer;
+import forge.deck.CardPool;
 import forge.deck.Deck;
+import forge.deck.DeckRecognizer;
 import forge.deck.DeckSection;
 import forge.deck.DeckgenUtil;
 import forge.deck.io.DeckSerializer;
+import forge.util.FileUtil;
+import forge.util.ItemPool;
 import forge.game.GameFormat;
 import forge.game.GameType;
 import forge.item.BoosterPack;
@@ -27,6 +32,11 @@
 import forge.util.Aggregates;
 import forge.util.IterableUtil;
 import forge.card.MagicColor;
+import forge.Forge;
+import forge.gui.GuiBase;
+import com.badlogic.gdx.Gdx;
+import java.io.File;
+import java.io.IOException;
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
@@ -977,4 +987,566 @@ public static PaperCard ensureAllowedEdition(PaperCard card) {
         }
         return card;
     }
+
+    // ===== Deck Import/Export Feature =====
+
+    public enum ImportMode {
+        GIVE_MISSING,
+        BUY_MISSING,
+        /** Import when collection has enough copies (any printing); otherwise report missing. */
+        REPORT_ONLY
+    }
+
+    public enum DeckListExportFormat {
+        FORGE_DCK,
+        PLAINTEXT,
+        ARENA,
+        MTGO;
+
+        public String getDisplayName() {
+            return switch (this) {
+                case FORGE_DCK -> "Forge (.dck)";
+                case PLAINTEXT -> "Plain text";
+                case ARENA -> "Arena";
+                case MTGO -> "MTGO";
+            };
+        }
+
+        public String getDefaultExtension() {
+            return switch (this) {
+                case FORGE_DCK -> ".dck";
+                case PLAINTEXT, ARENA, MTGO -> ".txt";
+            };
+        }
+    }
+
+    public enum CollectionExportFormat {
+        PLAINTEXT,
+        ARENA,
+        MTGO;
+
+        public String getDisplayName() {
+            return switch (this) {
+                case PLAINTEXT -> "Plain text";
+                case ARENA -> "Arena";
+                case MTGO -> "MTGO";
+            };
+        }
+
+        public String getDefaultExtension() {
+            return ".txt";
+        }
+    }
+
+    /** Base filename with the extension for the chosen export format (adds ext if missing). */
+    public static String defaultSaveFilename(String baseName, String extension) {
+        String name = baseName != null ? baseName.trim() : "";
+        if (name.isEmpty()) {
+            name = "file";
+        }
+        String ext = extension != null && extension.startsWith(".") ? extension : "." + extension;
+        if (name.toLowerCase().endsWith(ext.toLowerCase())) {
+            return name;
+        }
+        return name + ext;
+    }
+
+    public static class MissingCard {
+        public final PaperCard card;
+        public final int quantity;
+        public MissingCard(PaperCard card, int quantity) {
+            this.card = card;
+            this.quantity = quantity;
+        }
+    }
+
+    public static class ImportResult {
+        public final boolean success;
+        public final String message;
+        public final String deckName;
+        public final int slot;
+        public final int cardsAdded;
+        public final List<MissingCard> missingCards;
+
+        private ImportResult(boolean success, String message, String deckName, int slot, int cardsAdded, List<MissingCard> missingCards) {
+            this.success = success;
+            this.message = message;
+            this.deckName = deckName;
+            this.slot = slot;
+            this.cardsAdded = cardsAdded;
+            this.missingCards = missingCards != null ? missingCards : new ArrayList<>();
+        }
+
+        public static ImportResult success(int slot, String deckName, int cardsAdded) {
+            return new ImportResult(true, null, deckName, slot, cardsAdded, null);
+        }
+
+        public static ImportResult failure(String message) {
+            return new ImportResult(false, message, null, -1, 0, null);
+        }
+
+        public static ImportResult reportOnly(String deckName, List<MissingCard> missing) {
+            return new ImportResult(true, null, deckName, -1, 0, missing);
+        }
+
+        public static ImportResult reportWithImport(int slot, String deckName, List<MissingCard> missing) {
+            return new ImportResult(true, null, deckName, slot, 0, missing);
+        }
+
+        public boolean importedDeck() {
+            return success && slot >= 0;
+        }
+
+        public String formatMissingReport() {
+            if (missingCards.isEmpty()) return "You own all cards in this deck!";
+            StringBuilder sb = new StringBuilder();
+            sb.append("Missing cards for \"").append(deckName != null ? deckName : "Unknown").append("\":\n");
+            for (MissingCard mc : missingCards) {
+                sb.append(mc.quantity).append("x ").append(mc.card.getName()).append('\n');
+            }
+            sb.append("(").append(missingCards.size()).append(" unique cards missing)");
+            return sb.toString();
+        }
+    }
+
+    public static final class MarkedForSaleEntry {
+        public final String cardName;
+        public final int quantity;
+
+        public MarkedForSaleEntry(String cardName, int quantity) {
+            this.cardName = cardName;
+            this.quantity = quantity;
+        }
+    }
+
+    /**
+     * Auto-sell state before this mark-for-sale run (card identity + prior marked copy count).
+     * Rollback restores that count so cards already marked stay marked.
+     */
+    public static final class MarkedForSaleOp {
+        public final PaperCard card;
+        public final int previousAutoSellCount;
+
+        public MarkedForSaleOp(PaperCard card, int previousAutoSellCount) {
+            this.card = card;
+            this.previousAutoSellCount = previousAutoSellCount;
+        }
+    }
+
+    public static class MarkSellResult {
+        public final boolean success;
+        public final String message;
+        public final int marked;
+        public final int skipped;
+        public final List<MarkedForSaleEntry> markedEntries;
+        public final List<MarkedForSaleOp> rollbackOps;
+
+        private MarkSellResult(boolean success, String message, int marked, int skipped,
+                List<MarkedForSaleEntry> markedEntries, List<MarkedForSaleOp> rollbackOps) {
+            this.success = success;
+            this.message = message;
+            this.marked = marked;
+            this.skipped = skipped;
+            this.markedEntries = markedEntries != null ? markedEntries : List.of();
+            this.rollbackOps = rollbackOps != null ? rollbackOps : List.of();
+        }
+
+        public static MarkSellResult success(int marked, int skipped, List<MarkedForSaleEntry> markedEntries,
+                List<MarkedForSaleOp> rollbackOps) {
+            return new MarkSellResult(true, null, marked, skipped, markedEntries, rollbackOps);
+        }
+
+        public void rollback(AdventurePlayer player) {
+            ItemPool<PaperCard> autoSell = player.getAutoSellCards();
+            for (MarkedForSaleOp op : rollbackOps) {
+                autoSell.removeAll(op.card);
+                if (op.previousAutoSellCount > 0) {
+                    autoSell.add(op.card, op.previousAutoSellCount);
+                }
+            }
+        }
+
+        public static MarkSellResult failure(String message) {
+            return new MarkSellResult(false, message, 0, 0, List.of(), List.of());
+        }
+
+        public String formatMarkedReport(String loadedMessage) {
+            StringBuilder sb = new StringBuilder();
+            sb.append(loadedMessage).append("\n\n");
+            if (markedEntries.isEmpty()) {
+                sb.append(Forge.getLocalizer().getMessage("lblAdvMarkForSaleNone")).append('\n');
+            } else {
+                for (MarkedForSaleEntry entry : markedEntries) {
+                    sb.append(entry.quantity).append("x ").append(entry.cardName).append('\n');
+                }
+            }
+            if (skipped > 0) {
+                sb.append('\n').append("(").append(skipped).append(" copies skipped)");
+            }
+            return sb.toString();
+        }
+    }
+
+    public static File resolveFilePath(String rawPath) {
+        if (rawPath == null || rawPath.isBlank()) {
+            return new File("");
+        }
+        String normalized = rawPath.trim().replace('\\', File.separatorChar)
+                                   .replace('/', File.separatorChar);
+        if (normalized.startsWith("~" + File.separator) || normalized.equals("~")) {
+            String home = System.getProperty("user.home");
+            normalized = (home != null ? home : "") + normalized.substring(1);
+        }
+
+        File direct = new File(normalized);
+        if (direct.isAbsolute() && direct.exists()) {
+            return direct;
+        }
+
+        String home = System.getProperty("user.home");
+        if (home != null) {
+            File fromHome = new File(home, normalized);
+            if (fromHome.exists()) {
+                return fromHome;
+            }
+            if (!direct.isAbsolute()) {
+                direct = fromHome;
+            }
+        }
+
+        if (GuiBase.isAndroid()) {
+            File downloads = new File(Forge.getDeviceAdapter().getDownloadsDir(), normalized);
+            if (downloads.exists()) {
+                return downloads;
+            }
+            try {
+                if (Gdx.files.local(normalized).exists()) {
+                    return Gdx.files.local(normalized).file();
+                }
+                if (Gdx.files.external(normalized).exists()) {
+                    return Gdx.files.external(normalized).file();
+                }
+            } catch (Exception ignored) {
+            }
+        }
+
+        return direct;
+    }
+
+    /**
+     * Missing copies by card name (any printing in the collection counts toward ownership).
+     */
+    public static List<MissingCard> findMissingCards(Deck importedDeck, AdventurePlayer player) {
+        Map<String, Integer> neededByName = new LinkedHashMap<>();
+        Map<String, PaperCard> representativeByName = new HashMap<>();
+        for (java.util.Map.Entry<DeckSection, CardPool> entry : importedDeck) {
+            for (java.util.Map.Entry<PaperCard, Integer> cardEntry : entry.getValue()) {
+                String name = cardEntry.getKey().getName();
+                neededByName.merge(name, cardEntry.getValue(), Integer::sum);
+                representativeByName.putIfAbsent(name, cardEntry.getKey());
+            }
+        }
+        List<MissingCard> missingCards = new ArrayList<>();
+        for (java.util.Map.Entry<String, Integer> needed : neededByName.entrySet()) {
+            int owned = player.getCards().countByName(needed.getKey());
+            int qty = needed.getValue();
+            if (owned < qty) {
+                missingCards.add(new MissingCard(representativeByName.get(needed.getKey()), qty - owned));
+            }
+        }
+        return missingCards;
+    }
+
+    public static Deck parseDeckFile(File file) {
+        if (!file.exists()) return null;
+        List<String> lines = FileUtil.readFile(file);
+        if (lines == null || lines.isEmpty()) return null;
+
+        boolean isNativeDck = lines.stream().anyMatch(l ->
+            l.trim().equals("[metadata]") || l.trim().equals("[Main]"));
+
+        if (isNativeDck) {
+            return DeckSerializer.fromFile(file);
+        }
+
+        DeckRecognizer recognizer = new DeckRecognizer();
+        List<DeckRecognizer.Token> tokens = recognizer.parseCardList(
+            lines.toArray(new String[0]));
+
+        Deck deck = new Deck();
+        for (DeckRecognizer.Token t : tokens) {
+            if (t.getType() == DeckRecognizer.TokenType.DECK_NAME) {
+                deck.setName(t.getText());
+            } else if (t.isTokenForDeck()) {
+                deck.getOrCreate(t.getTokenSection()).add(t.getCard(), t.getQuantity());
+            }
+        }
+
+        if (deck.getName() == null || deck.getName().isEmpty()) {
+            String fname = file.getName();
+            int dot = fname.lastIndexOf('.');
+            deck.setName(dot > 0 ? fname.substring(0, dot) : fname);
+        }
+        return deck;
+    }
+
+    public static class ImportPreview {
+        public final Deck deck;
+        public final List<MissingCard> missingCards;
+        public final int totalCost;
+
+        public ImportPreview(Deck deck, List<MissingCard> missingCards, int totalCost) {
+            this.deck = deck;
+            this.missingCards = missingCards;
+            this.totalCost = totalCost;
+        }
+
+        public int missingCopyCount() {
+            int n = 0;
+            for (MissingCard mc : missingCards) {
+                n += mc.quantity;
+            }
+            return n;
+        }
+
+        public boolean canAfford(int playerGold) {
+            return playerGold >= totalCost;
+        }
+    }
+
+    public static ImportPreview previewImport(File file, AdventurePlayer player) {
+        Deck deck = parseDeckFile(file);
+        if (deck == null) {
+            return null;
+        }
+        List<MissingCard> missingCards = findMissingCards(deck, player);
+        int totalCost = 0;
+        for (MissingCard mc : missingCards) {
+            totalCost += player.cardBuyPrice(mc.card) * mc.quantity;
+        }
+        return new ImportPreview(deck, missingCards, totalCost);
+    }
+
+    public static ImportResult importDeckFromFile(File file, AdventurePlayer player, ImportMode mode) {
+        Deck importedDeck = parseDeckFile(file);
+        if (importedDeck == null) return ImportResult.failure("Could not parse file");
+
+        List<MissingCard> missingCards = findMissingCards(importedDeck, player);
+
+        if (mode == ImportMode.REPORT_ONLY) {
+            if (!missingCards.isEmpty()) {
+                return ImportResult.reportOnly(importedDeck.getName(), missingCards);
+            }
+            int slot = player.findFirstEmptySlot();
+            if (slot == -1) return ImportResult.failure("All deck slots full (max 99)");
+            player.importIntoSlot(slot, importedDeck);
+            return ImportResult.reportWithImport(slot, importedDeck.getName(), missingCards);
+        }
+
+        if (mode == ImportMode.BUY_MISSING) {
+            int totalCost = 0;
+            for (MissingCard mc : missingCards) {
+                totalCost += player.cardBuyPrice(mc.card) * mc.quantity;
+            }
+            if (player.getGold() < totalCost) {
+                return ImportResult.failure(String.format(
+                    "Not enough gold. Need %d, have %d. Missing %d cards.",
+                    totalCost, player.getGold(), missingCards.size()));
+            }
+            player.giveGold(-totalCost);
+        }
+
+        int cardsAdded = 0;
+        for (MissingCard mc : missingCards) {
+            player.addCard(mc.card, mc.quantity);
+            cardsAdded += mc.quantity;
+        }
+
+        int slot = player.findFirstEmptySlot();
+        if (slot == -1) return ImportResult.failure("All deck slots full (max 99)");
+        player.importIntoSlot(slot, importedDeck);
+
+        return ImportResult.success(slot, importedDeck.getName(), cardsAdded);
+    }
+
+    public static MarkSellResult markCardsForSale(File file, AdventurePlayer player) {
+        Deck parsed = parseDeckFile(file);
+        if (parsed == null) return MarkSellResult.failure("Could not parse file");
+
+        int marked = 0;
+        int skipped = 0;
+        CardPool collection = player.getCards();
+        ItemPool<PaperCard> autoSell = player.getAutoSellCards();
+        Map<String, Integer> markedByName = new LinkedHashMap<>();
+        Map<PaperCard, Integer> previousAutoSellByCard = new LinkedHashMap<>();
+
+        for (java.util.Map.Entry<DeckSection, CardPool> entry : parsed) {
+            for (java.util.Map.Entry<PaperCard, Integer> cardEntry : entry.getValue()) {
+                PaperCard card = cardEntry.getKey();
+                int requestedQty = cardEntry.getValue();
+
+                int owned = collection.count(card);
+                int inDecks = player.getCopiesUsedInDecks(card);
+                int alreadyMarked = autoSell.count(card);
+                int canMark = owned - inDecks - alreadyMarked;
+
+                if (card.getMarkedFlags() != null && card.getMarkedFlags().noSellValue) {
+                    skipped += requestedQty;
+                    continue;
+                }
+
+                int toMark = Math.min(requestedQty, Math.max(canMark, 0));
+                if (toMark > 0) {
+                    previousAutoSellByCard.putIfAbsent(card, alreadyMarked);
+                    autoSell.add(card, toMark);
+                    marked += toMark;
+                    markedByName.merge(card.getName(), toMark, Integer::sum);
+                }
+                skipped += (requestedQty - toMark);
+            }
+        }
+
+        List<MarkedForSaleEntry> entries = new ArrayList<>(markedByName.size());
+        for (Map.Entry<String, Integer> nameEntry : markedByName.entrySet()) {
+            entries.add(new MarkedForSaleEntry(nameEntry.getKey(), nameEntry.getValue()));
+        }
+        List<MarkedForSaleOp> rollbackOps = new ArrayList<>(previousAutoSellByCard.size());
+        for (Map.Entry<PaperCard, Integer> snap : previousAutoSellByCard.entrySet()) {
+            rollbackOps.add(new MarkedForSaleOp(snap.getKey(), snap.getValue()));
+        }
+        return MarkSellResult.success(marked, skipped, entries, rollbackOps);
+    }
+
+    public static void exportDeck(Deck deck, File file, DeckListExportFormat format) throws IOException {
+        switch (format) {
+            case FORGE_DCK -> DeckSerializer.writeDeck(deck, file);
+            case PLAINTEXT -> FileUtil.writeFile(file, deck.generateTextExport());
+            case ARENA -> FileUtil.writeFile(file, exportDeckAsArena(deck));
+            case MTGO -> FileUtil.writeFile(file, exportDeckAsMtgo(deck));
+            default -> throw new IllegalArgumentException("Unknown deck export format: " + format);
+        }
+    }
+
+    public static void exportCollection(AdventurePlayer player, File file,
+            CollectionExportFormat format) throws IOException {
+        switch (format) {
+            case PLAINTEXT -> FileUtil.writeFile(file, exportCollectionAsPlaintext(player));
+            case ARENA -> FileUtil.writeFile(file, exportCollectionAsArena(player));
+            case MTGO -> FileUtil.writeFile(file, exportCollectionAsMtgo(player));
+            default -> throw new IllegalArgumentException(
+                    "Unknown collection export format: " + format);
+        }
+    }
+
+    public static String exportDeckAsArena(Deck deck) {
+        StringBuilder sb = new StringBuilder();
+        String name = deck.getName();
+        if (name != null && !name.isEmpty()) {
+            sb.append("Deck: ").append(name).append('\n').append('\n');
+        }
+        appendPoolAsArena(sb, deck, DeckSection.Main, "Main");
+        appendPoolAsArena(sb, deck, DeckSection.Sideboard, "Sideboard");
+        appendPoolAsArena(sb, deck, DeckSection.Commander, "Commander");
+        return sb.toString();
+    }
+
+    private static void appendPoolAsArena(StringBuilder sb, Deck deck, DeckSection section, String label) {
+        if (!deck.has(section) || deck.get(section).isEmpty()) {
+            return;
+        }
+        sb.append(label).append(":\n");
+        appendCardsArenaStyle(sb, deck.get(section));
+        sb.append('\n');
+    }
+
+    private static void appendCardsArenaStyle(StringBuilder sb, CardPool pool) {
+        List<java.util.Map.Entry<PaperCard, Integer>> sorted = new ArrayList<>();
+        for (java.util.Map.Entry<PaperCard, Integer> e : pool) {
+            sorted.add(e);
+        }
+        sorted.sort(java.util.Comparator.comparing(e -> e.getKey().getName()));
+        for (java.util.Map.Entry<PaperCard, Integer> entry : sorted) {
+            appendArenaLine(sb, entry.getKey(), entry.getValue());
+        }
+    }
+
+    private static void appendArenaLine(StringBuilder sb, PaperCard card, int count) {
+        sb.append(count).append(' ').append(card.getName());
+        String set = card.getEdition();
+        String collNum = card.getCollectorNumber();
+        if (set != null && !set.isEmpty()) {
+            sb.append(" (").append(set).append(')');
+            if (collNum != null && !collNum.isEmpty()) {
+                sb.append(' ').append(collNum);
+            }
+        }
+        sb.append('\n');
+    }
+
+    public static String exportDeckAsMtgo(Deck deck) {
+        StringBuilder sb = new StringBuilder();
+        String name = deck.getName();
+        if (name != null && !name.isEmpty()) {
+            sb.append("// ").append(name).append('\n');
+        }
+        appendPoolAsMtgo(sb, deck, DeckSection.Main);
+        appendPoolAsMtgo(sb, deck, DeckSection.Sideboard);
+        appendPoolAsMtgo(sb, deck, DeckSection.Commander);
+        return sb.toString();
+    }
+
+    private static void appendPoolAsMtgo(StringBuilder sb, Deck deck, DeckSection section) {
+        if (!deck.has(section) || deck.get(section).isEmpty()) {
+            return;
+        }
+        if (section == DeckSection.Sideboard) {
+            sb.append("Sideboard:\n");
+        }
+        appendCardsMtgoStyle(sb, deck.get(section));
+    }
+
+    private static void appendCardsMtgoStyle(StringBuilder sb, CardPool pool) {
+        List<java.util.Map.Entry<PaperCard, Integer>> sorted = new ArrayList<>();
+        for (java.util.Map.Entry<PaperCard, Integer> e : pool) {
+            sorted.add(e);
+        }
+        sorted.sort(java.util.Comparator.comparing(e -> e.getKey().getName()));
+        for (java.util.Map.Entry<PaperCard, Integer> entry : sorted) {
+            PaperCard card = entry.getKey();
+            sb.append(entry.getValue()).append(' ').append(card.getName());
+            String set = card.getEdition();
+            if (set != null && !set.isEmpty()) {
+                sb.append(" (").append(set).append(')');
+            }
+            sb.append('\n');
+        }
+    }
+
+    public static String exportCollectionAsArena(AdventurePlayer player) {
+        StringBuilder sb = new StringBuilder();
+        appendCardsArenaStyle(sb, player.getCards());
+        return sb.toString();
+    }
+
+    public static String exportCollectionAsMtgo(AdventurePlayer player) {
+        StringBuilder sb = new StringBuilder();
+        sb.append("// Collection").append('\n');
+        appendCardsMtgoStyle(sb, player.getCards());
+        return sb.toString();
+    }
+
+    public static String exportCollectionAsPlaintext(AdventurePlayer player) {
+        final String nl = System.lineSeparator();
+        final StringBuilder collectionList = new StringBuilder();
+        Set<String> accounted = new HashSet<>();
+        CardPool pool = player.getCards();
+        for (final java.util.Map.Entry<PaperCard, Integer> entry : pool) {
+            String cardName = entry.getKey().getCardName();
+            if (!accounted.contains(cardName)) {
+                collectionList.append(pool.countByName(cardName)).append(" ").append(cardName).append(nl);
+                accounted.add(cardName);
+            }
+        }
+        return collectionList.toString();
+    }
 }
diff --git a/forge-gui-mobile/src/forge/toolbox/FFileChooser.java b/forge-gui-mobile/src/forge/toolbox/FFileChooser.java
index b8e0c2405fb..624ca21322b 100644
--- a/forge-gui-mobile/src/forge/toolbox/FFileChooser.java
+++ b/forge-gui-mobile/src/forge/toolbox/FFileChooser.java
@@ -140,6 +140,7 @@ private void setFileListForDir(File dir) {
             //don't list files if getting directory
             filter = (dir1, name) -> new File(dir1, name).isDirectory();
         }
+        // Open/save: no extension filter — show all files (deck lists often lack extensions)
         lstFiles.setListData(dir.listFiles(filter));
     }
 
diff --git a/forge-gui/res/adventure/common/skin/ui_skin.json b/forge-gui/res/adventure/common/skin/ui_skin.json
index 637bfdc7b89..640996ebc95 100644
--- a/forge-gui/res/adventure/common/skin/ui_skin.json
+++ b/forge-gui/res/adventure/common/skin/ui_skin.json
@@ -520,10 +520,18 @@
 },
 "ScrollPaneStyle": {
 	"default": {
-		"background": "windowMain10Patch"
+		"background": "windowMain10Patch",
+		"vScroll": "scroll",
+		"vScrollKnob": "scroll",
+		"hScroll": "bar",
+		"hScrollKnob": "bar"
 	},
 	"paper": {
-		"background": "paper10Patch"
+		"background": "paper10Patch",
+		"vScroll": "scroll",
+		"vScrollKnob": "scroll",
+		"hScroll": "bar",
+		"hScrollKnob": "bar"
 	},
 	"gold": {
 		"background": "9patch4"
diff --git a/forge-gui/res/languages/en-US.properties b/forge-gui/res/languages/en-US.properties
index cbf27b4d1a1..1ba3cb0bade 100644
--- a/forge-gui/res/languages/en-US.properties
+++ b/forge-gui/res/languages/en-US.properties
@@ -3536,6 +3536,41 @@ lblEffectDialogDescription=Strange magical energies flow within this place...
 lblEffectDataHeader=All opponents get:
 lblDefeatedDescription=Defeated and unable to continue, you use the last of your power to escape the area.
 lblAdventureDeckError=Deck {0}\nStarting a game with an incomplete deck may have unexpected results. Continue?
+lblAdvImportDeck=Import Deck
+lblAdvChooseImportMode=Choose import mode:
+lblAdvDeckImportIntro=Import lists from your favorite MTG site (same formats as the deck editor), or export your collection to a card library manager, build decks there, and re-import them here.
+lblAdvDeckImportUseOwned=Use cards from your collection
+lblAdvDeckImportUseOwnedDetail=Imports the deck if you own every card (any printing). Otherwise lists missing cards.
+lblAdvDeckImportBuyMissing=Buy missing cards (sorta cheat!)
+lblAdvDeckImportGiveMissing=Add missing cards free (Cheat!)
+lblAdvExportDeck=Export Deck
+lblAdvExportCollection=Export Collection
+lblAdvMarkForSale=Mark for Sale
+lblAdvChooseExportFormat=Choose export format:
+lblAdvImportDeckSuccessOwned=Imported ''{0}'' into slot {1} (you already owned every card).
+lblAdvImportDeckSuccessBuy=Imported ''{0}'' into slot {1} ({2} cards purchased).
+lblAdvImportDeckSuccessGive=Imported ''{0}'' into slot {1} ({2} cards added to collection).
+lblAdvImportDeckFailed=Import failed: {0}
+lblAdvFileNotFound=File not found: {0}
+lblFilePath=Path:
+lblAdvFolder=Folder:
+lblAdvFiles=Files:
+lblAdvFileName=File name:
+lblAdvMarkForSaleHelp=Pick a deck list file. Owned cards not used in any deck (and not already marked) will auto-sell when you get duplicates.
+lblAdvOverwriteConfirm=File ''{0}'' already exists. Overwrite it?
+lblAdvOverwrite=Overwrite
+lblAdvMarkForSaleFailed=Mark for sale failed: {0}
+lblAdvMarkForSaleSuccess=Marked {0} cards for auto-sell ({1} skipped: not owned, in decks, or already marked).
+lblAdvMarkForSaleNone=No cards were marked for auto-sell.
+lblAdvRollback=Rollback
+lblAdvRolledBack=Rolled back.
+lblAdvBuyConfirm=This deck needs {0} card copies ({1} unique cards) you do not own. Buy them for {2} gold and import? (You have {3} gold.)
+lblAdvBuyNotEnoughGold=You need {0} gold to buy the missing cards but only have {1}.
+lblAdvMissingListSaved=Missing card list saved to {0}
+lblAdvSaved=Saved...
+lblAdvLoaded=Loaded...
+lblAdvImportDone=Deck imported.
+lblAdvMissingListSaveFailed=Could not save file: {0}
 lblReversePromptButton=Reversed Prompt Buttons
 nlReversePromptButton=If enabled, the OK and Cancel Prompt buttons are reversed.
 lblPrepareDatabase=Preparing database...