feat(settings): add native base control dialog

README.md

@@ -26,10 +26,11 @@ The plugin JAR is written to `build/libs/`.
 /base (alias: /home)
 /gotobase <player> (alias: /visit <player>)
 /basesettings (alias: /homesettings)
+/basesettings ui
 /basesettings status
 /basesettings upgrade
 /basesettings pocket upgrade
-/basesettings pocket mobs <enable|disable>
+/basesettings pocket mobs <hostile|passive> <enable|disable>
 /basesettings pocket type <void|nether|overworld> <subtype>
 /basesettings visitors <allowed|blocked>
 /basesettings navigation <enable|disable>
@@ -39,13 +40,15 @@ The plugin JAR is written to `build/libs/`.
 /basesettings bossbar <enable|disable>
 ```
 
+`/basesettings` and `/basesettings ui` open Minecraft's native dialog dashboard. The dashboard summarizes Base and Pocket Base progression, provides unlocked setting controls and purchase confirmations, and marks unavailable controls as locked. `/basesettings status` retains the detailed chat report.
+
 Navigation particles appear only in the base's world and when the player is more than 25 blocks beyond the current base border.
 
 After 250 Survival-mode block placements anywhere by default, the spawnable overlay can mark nearby dark hostile-mob spawning surfaces inside the player's base with owner-only red particles. The threshold is configurable.
 
 `/base` has a stationary warm-up. Looking around is allowed, while movement between blocks, damage, teleportation, world changes, death, logout, and conflicting teleport commands cancel it without consuming the cooldown.
 
-Base IV owners can purchase and expand a persistent Pocket Base with `/basesettings pocket upgrade`. Activating a complete diamond-block portal frame inside the normal base with flint and steel opens one public entrance to the owner's grass platform in a private void world. The owner can move the return portal by building and igniting another complete frame inside the unlocked Pocket Base boundary; only the newly activated return portal remains functional. Natural hostile and passive mob spawning is disabled by default and can be controlled by the owner with `/basesettings pocket mobs <enable|disable>`.
+Base IV owners can purchase and expand a persistent Pocket Base with `/basesettings pocket upgrade`. Activating a complete diamond-block portal frame inside the normal base with flint and steel opens one public entrance to the owner's grass platform in a private void world. The owner can move the return portal by building and igniting another complete frame inside the unlocked Pocket Base boundary; only the newly activated return portal remains functional. Natural hostile and passive mob spawning is disabled by default. Owners can control each category independently with `/basesettings pocket mobs <hostile|passive> <enable|disable>`.
 
 Owners can change biome metadata without altering Pocket Base blocks, entities, inventories, or portals by using `/basesettings pocket type <void|nether|overworld> <subtype>`. Void uses `the_void`; Nether and Overworld accept their compatible vanilla biome names, such as `crimson_forest` or `plains`. Each change defaults to 16 netherite blocks, is configurable, and affects applicable natural mob selection when spawning is enabled. The Pocket Base remains a void-generated normal-environment world; dimension-specific mechanics do not change.
 

design/log.md

@@ -95,8 +95,9 @@ description: Chronological record of material decisions affecting the Spigot Bas
 ## 2026-08-24 — Pocket Base mob-spawning control
 
 - Disabled natural hostile and passive mob spawning by default in new and existing Pocket Bases without a saved preference.
-- Added the persisted owner setting `/basesettings pocket mobs enable|disable`, contextual autocomplete, and status reporting.
-- Reapplied saved spawn flags when Pocket Base worlds load and restored the prior world setting when persistence fails.
+- Added independent persisted owner settings through `/basesettings pocket mobs <hostile|passive> <enable|disable>`, contextual autocomplete, and status reporting.
+- Migrated each legacy combined mob-spawning preference to both categories to preserve existing behavior.
+- Reapplied both saved spawn flags when Pocket Base worlds load and restored both prior world settings when persistence fails.
 - Verified the feature with `./gradlew clean check jar`.
 
 ## 2026-08-24 — Relocatable Pocket Base return portals
@@ -113,3 +114,11 @@ description: Chronological record of material decisions affecting the Spigot Bas
 - Applied biome metadata across unlocked columns and new expansion rings without changing blocks, entities, inventories, portals, progression, or mob-spawning preferences.
 - Added an atomic, configurable biome-change payment that defaults to 16 netherite blocks and restores the prior biome and payment on failure.
 - Verified the feature with `./gradlew clean check jar`.
+
+## 2026-08-24 — Native base settings dialog
+
+- Changed `/basesettings` and `/homesettings` with no arguments to open a native Minecraft dialog dashboard, with explicit `ui` subcommands providing the same behavior.
+- Added progression summaries, current and locked setting states, toggles, Pocket Base controls, biome selection, and confirmations for Base IV, Pocket Base, and biome purchases.
+- Retained the detailed chat report under `/basesettings status` and kept dialog actions routed through the existing validated command behavior.
+- Added dialog routing, autocomplete, alias, non-player, generated-control, locked-state, and purchase-confirmation coverage.
+- Verified the feature with `./gradlew clean check jar`.

design/user-stories/index.md

@@ -25,3 +25,4 @@ description: Catalog of user stories for the Spigot Base plugin.
 17. [US-017: Expand a Pocket Base](us-017-expand-a-pocket-base.md)
 18. [US-018: Control Pocket Base mob spawning](us-018-control-pocket-base-mob-spawning.md)
 19. [US-019: Change a Pocket Base biome](us-019-change-a-pocket-base-biome.md)
+20. [US-020: Control a base through a dialog UI](us-020-control-base-through-dialog-ui.md)

design/user-stories/us-009-view-progression-and-notifications.md

@@ -11,7 +11,7 @@ As a **player**, I want to inspect my progression and receive timely milestone f
 
 ## Acceptance criteria
 
-- [x] `/basesettings` and `/basesettings status` show the player's Base, Base Size, Base Flight, Teleport Warm-up, and Teleport Cooldown paths plus current visitor, navigation, flight, and boss-bar settings.
+- [x] `/basesettings status` shows the player's Base, Base Size, Base Flight, Teleport Warm-up, and Teleport Cooldown paths plus current visitor, navigation, flight, and boss-bar settings.
 - [x] Each path identifies earned levels, unmet prerequisites, current progress, the next threshold, and the next reward.
 - [x] Locked secondary paths clearly identify Base I or another sequential level as their prerequisite.
 - [x] Relevant qualifying activity briefly displays a configurable progress boss bar for the active milestone.
@@ -19,7 +19,7 @@ As a **player**, I want to inspect my progression and receive timely milestone f
 - [x] The automatic boss bar disappears after a configurable number of seconds.
 - [x] `/basesettings bossbar enable` enables automatic progress boss bars idempotently, and `/basesettings bossbar disable` disables them idempotently.
 - [x] Invalid boss-bar arguments show command usage, and `enable` and `disable` are offered through autocomplete.
-- [x] Disabling automatic boss bars does not prevent `/basesettings` from displaying progress.
+- [x] Disabling automatic boss bars does not prevent `/basesettings status` from displaying progress.
 - [x] The boss-bar preference persists across reconnects and restarts.
 - [x] Each newly unlocked level displays prominent full-screen title and subtitle text describing the reward.
 - [x] Unlock notifications occur once per earned level and do not repeat after reconnecting or restarting.

design/user-stories/us-018-control-pocket-base-mob-spawning.md

@@ -1,25 +1,27 @@
 ---
 type: User Story
 title: "US-018: Control Pocket Base mob spawning"
-description: Let Pocket Base owners control natural mob spawning in their private world, with spawning disabled by default.
+description: Let Pocket Base owners control hostile and passive natural mob spawning independently in their private world, with both disabled by default.
 status: done
 ---
 
 # US-018: Control Pocket Base mob spawning
 
-As a **Pocket Base owner**, I want to enable or disable natural mob spawning in my Pocket Base so that I can choose whether the private world supports normal mob activity.
+As a **Pocket Base owner**, I want to enable or disable hostile and passive natural mob spawning independently in my Pocket Base so that I can choose which kinds of normal mob activity its private world supports.
 
 ## Acceptance criteria
 
-- [x] Natural mob spawning is disabled by default in every new Pocket Base and in existing Pocket Bases that have no saved preference.
-- [x] A Pocket Base owner can use `/basesettings pocket mobs enable|disable` to control natural mob spawning in their own Pocket Base.
-- [x] The setting controls both hostile and passive natural spawning only in the owner's Pocket Base.
-- [x] The command is unavailable until Pocket Base I is unlocked.
-- [x] The command and its modes are offered through contextual autocomplete.
-- [x] `/basesettings status` displays the current Pocket Base mob-spawning setting.
-- [x] The preference persists across restarts and is reapplied when the Pocket Base world loads.
-- [x] Disabling natural spawning does not remove existing mobs or prevent explicitly spawned or summoned mobs.
-- [x] Persistence or world-application failures produce a clear failure message without reporting a successful change.
+- [x] Hostile and passive natural mob spawning are both disabled by default in every new Pocket Base and in existing Pocket Bases that have no saved preference.
+- [x] A Pocket Base owner can use `/basesettings pocket mobs hostile enable|disable` to control hostile natural mob spawning in their own Pocket Base.
+- [x] A Pocket Base owner can use `/basesettings pocket mobs passive enable|disable` to control passive natural mob spawning in their own Pocket Base.
+- [x] Changing one mob category does not change the other category.
+- [x] The commands are unavailable until Pocket Base I is unlocked.
+- [x] The commands, categories, and modes are offered through contextual autocomplete.
+- [x] `/basesettings status` displays the current hostile and passive Pocket Base mob-spawning settings.
+- [x] Both preferences persist across restarts and are reapplied when the Pocket Base world loads.
+- [x] Existing saved `mob-spawning-enabled` values migrate to both category preferences, preserving prior behavior.
+- [x] Disabling either natural-spawning category does not remove existing mobs or prevent explicitly spawned or summoned mobs.
+- [x] Persistence or world-application failures produce a clear failure message, restore both prior world flags, and do not report a successful change.
 
 ## Related
 

design/user-stories/us-020-control-base-through-dialog-ui.md

@@ -0,0 +1,31 @@
+---
+type: User Story
+title: "US-020: Control a base through a dialog UI"
+description: Let players inspect and control their base through Minecraft's native dialog interface.
+status: done
+---
+
+# US-020: Control a base through a dialog UI
+
+As a **player**, I want a dialog-based base dashboard so that I can inspect progression and manage my base without remembering command arguments.
+
+## Acceptance criteria
+
+- [x] `/basesettings` and `/basesettings ui` open the base-control dialog.
+- [x] `/homesettings` and `/homesettings ui` behave identically.
+- [x] `/basesettings status` retains the chat-based progression report.
+- [x] The dialog summarizes current Base and Pocket Base progression.
+- [x] Dialog controls cover visitors, navigation, flight, border, spawnable overlay, boss bar, Pocket Base mob spawning, upgrades, and biome selection when applicable.
+- [x] Controls indicate their current or locked state.
+- [x] Purchases require confirmation and continue using existing validation, payment, and persistence logic.
+- [x] `ui` is offered through command autocomplete.
+- [x] Non-player execution remains safely rejected.
+- [x] Automated tests verify dialog routing and generated controls.
+
+## Related
+
+- [US-008: Unlock Base IV visitor access](us-008-unlock-visitor-access.md)
+- [US-009: View progression and unlock notifications](us-009-view-progression-and-notifications.md)
+- [US-015: Unlock a Pocket Base](us-015-unlock-a-pocket-base.md)
+- [US-018: Control Pocket Base mob spawning](us-018-control-pocket-base-mob-spawning.md)
+- [US-019: Change a Pocket Base biome](us-019-change-a-pocket-base-biome.md)

src/main/java/games/dmg/spigotbase/BaseSettingsCommand.java

@@ -15,7 +15,7 @@ import org.bukkit.inventory.PlayerInventory;
 
 final class BaseSettingsCommand implements CommandExecutor, TabCompleter {
     private static final List<String> SETTINGS = List.of(
-        "status", "upgrade", "pocket", "visitors", "navigation", "flight", "border",
+        "ui", "status", "upgrade", "pocket", "visitors", "navigation", "flight", "border",
         "spawnable", "bossbar"
     );
     private static final List<String> VISITOR_MODES = List.of("allowed", "blocked");
@@ -58,7 +58,11 @@ final class BaseSettingsCommand implements CommandExecutor, TabCompleter {
         }
         PlayerState state = stateManager.player(player.getUniqueId(), player.getName());
         if (arguments.length == 0
-                || arguments.length == 1 && arguments[0].equalsIgnoreCase("status")) {
+                || arguments.length == 1 && arguments[0].equalsIgnoreCase("ui")) {
+            showDialog(player, state);
+            return true;
+        }
+        if (arguments.length == 1 && arguments[0].equalsIgnoreCase("status")) {
             showStatus(player, state);
             return true;
         }
@@ -69,9 +73,9 @@ final class BaseSettingsCommand implements CommandExecutor, TabCompleter {
                 && arguments[1].equalsIgnoreCase("upgrade")) {
             return purchasePocketUpgrade(player, state);
         }
-        if (arguments.length == 3 && arguments[0].equalsIgnoreCase("pocket")
+        if (arguments.length == 4 && arguments[0].equalsIgnoreCase("pocket")
                 && arguments[1].equalsIgnoreCase("mobs")) {
-            return updatePocketMobSpawning(player, arguments[2]);
+            return updatePocketMobSpawning(player, arguments[2], arguments[3]);
         }
         if (arguments.length == 4 && arguments[0].equalsIgnoreCase("pocket")
                 && arguments[1].equalsIgnoreCase("type")) {
@@ -240,7 +244,11 @@ final class BaseSettingsCommand implements CommandExecutor, TabCompleter {
         return true;
     }
 
-    private boolean updatePocketMobSpawning(Player player, String mode) {
+    private boolean updatePocketMobSpawning(
+        Player player,
+        String category,
+        String mode
+    ) {
         if (pocketBases == null) {
             player.sendMessage(ChatColor.RED + "Pocket Bases are currently unavailable.");
             return true;
@@ -256,17 +264,30 @@ final class BaseSettingsCommand implements CommandExecutor, TabCompleter {
             return true;
         }
         final PocketBaseState updated;
+        final boolean settingEnabled;
         try {
-            updated = pocketBases.setMobSpawning(player.getUniqueId(), enabled);
+            if (category.equalsIgnoreCase("hostile")) {
+                updated = pocketBases.setHostileMobSpawning(
+                    player.getUniqueId(), enabled
+                );
+                settingEnabled = updated.hostileMobSpawningEnabled();
+            } else if (category.equalsIgnoreCase("passive")) {
+                updated = pocketBases.setPassiveMobSpawning(
+                    player.getUniqueId(), enabled
+                );
+                settingEnabled = updated.passiveMobSpawningEnabled();
+            } else {
+                sendUsage(player);
+                return true;
+            }
         } catch (IOException | RuntimeException exception) {
             player.sendMessage(ChatColor.RED
                 + "The Pocket Base mob-spawning setting could not be changed.");
             return true;
         }
-        player.sendMessage(ChatColor.YELLOW + "Pocket Base mob spawning is now "
-            + (updated.mobSpawningEnabled()
-                ? ChatColor.GREEN + "enabled"
-                : ChatColor.RED + "disabled")
+        player.sendMessage(ChatColor.YELLOW + "Pocket Base "
+            + category.toLowerCase(Locale.ROOT) + " mob spawning is now "
+            + (settingEnabled ? ChatColor.GREEN + "enabled" : ChatColor.RED + "disabled")
             + ChatColor.YELLOW + ".");
         return true;
     }
@@ -424,6 +445,13 @@ final class BaseSettingsCommand implements CommandExecutor, TabCompleter {
         return true;
     }
 
+    private void showDialog(Player player, PlayerState state) {
+        PocketBaseState pocket = pocketBases == null
+            ? PocketBaseState.locked(state.playerId())
+            : pocketBases.state(state.playerId());
+        player.showDialog(new BaseSettingsDialogFactory(settings.current()).create(state, pocket));
+    }
+
     private void showStatus(Player player, PlayerState state) {
         player.sendMessage(ChatColor.GOLD + "=== Base Progress ===");
         showBasePath(player, state);
@@ -514,8 +542,10 @@ final class BaseSettingsCommand implements CommandExecutor, TabCompleter {
             + settings.current().pocketBaseCurrencyMaterial().toLowerCase(Locale.ROOT)
             + " → /basesettings pocket upgrade; type="
             + pocket.biome().worldType().commandName() + "/" + pocket.biome().commandName()
-            + "; mob spawning="
-            + (pocket.mobSpawningEnabled() ? "enabled" : "disabled"));
+            + "; hostile spawning="
+            + (pocket.hostileMobSpawningEnabled() ? "enabled" : "disabled")
+            + "; passive spawning="
+            + (pocket.passiveMobSpawningEnabled() ? "enabled" : "disabled"));
     }
 
     private void showCooldownPath(Player player, PlayerState state) {
@@ -557,7 +587,9 @@ final class BaseSettingsCommand implements CommandExecutor, TabCompleter {
         if (arguments.length == 3 && arguments[0].equalsIgnoreCase("pocket")) {
             String prefix = arguments[2].toLowerCase(Locale.ROOT);
             if (arguments[1].equalsIgnoreCase("mobs")) {
-                return ENABLE_MODES.stream().filter(mode -> mode.startsWith(prefix)).toList();
+                return List.of("hostile", "passive").stream()
+                    .filter(category -> category.startsWith(prefix))
+                    .toList();
             }
             if (arguments[1].equalsIgnoreCase("type")) {
                 return POCKET_WORLD_TYPES.stream()
@@ -565,9 +597,16 @@ final class BaseSettingsCommand implements CommandExecutor, TabCompleter {
                     .toList();
             }
         }
-        if (arguments.length == 4 && arguments[0].equalsIgnoreCase("pocket")
-                && arguments[1].equalsIgnoreCase("type")) {
+        if (arguments.length == 4 && arguments[0].equalsIgnoreCase("pocket")) {
             String prefix = arguments[3].toLowerCase(Locale.ROOT);
+            if (arguments[1].equalsIgnoreCase("mobs")
+                    && (arguments[2].equalsIgnoreCase("hostile")
+                        || arguments[2].equalsIgnoreCase("passive"))) {
+                return ENABLE_MODES.stream()
+                    .filter(mode -> mode.startsWith(prefix))
+                    .toList();
+            }
+            if (arguments[1].equalsIgnoreCase("type")) {
                 return PocketBaseWorldType.fromCommand(arguments[2])
                     .map(PocketBaseBiome::commandNames)
                     .orElse(List.of())
@@ -575,6 +614,7 @@ final class BaseSettingsCommand implements CommandExecutor, TabCompleter {
                     .filter(biome -> biome.startsWith(prefix))
                     .toList();
             }
+        }
         return List.of();
     }
 
@@ -634,7 +674,8 @@ final class BaseSettingsCommand implements CommandExecutor, TabCompleter {
 
     private static void sendUsage(Player player) {
         player.sendMessage(ChatColor.RED + "Usage: /basesettings "
-            + "[status|upgrade|pocket upgrade|pocket mobs <enable|disable>"
+            + "[ui|status|upgrade|pocket upgrade|pocket mobs "
+            + "<hostile|passive> <enable|disable>"
             + "|pocket type <void|nether|overworld> <subtype>"
             + "|visitors <allowed|blocked>|navigation <enable|disable>"
             + "|flight <enable|disable>|border <enable|disable>"

src/main/java/games/dmg/spigotbase/BaseSettingsDialogFactory.java

@@ -0,0 +1,353 @@
+package games.dmg.spigotbase;
+
+import java.util.Arrays;
+import java.util.List;
+import java.util.Locale;
+import net.md_5.bungee.api.chat.BaseComponent;
+import net.md_5.bungee.api.chat.TextComponent;
+import net.md_5.bungee.api.dialog.ConfirmationDialog;
+import net.md_5.bungee.api.dialog.Dialog;
+import net.md_5.bungee.api.dialog.DialogBase;
+import net.md_5.bungee.api.dialog.DialogListDialog;
+import net.md_5.bungee.api.dialog.MultiActionDialog;
+import net.md_5.bungee.api.dialog.NoticeDialog;
+import net.md_5.bungee.api.dialog.action.ActionButton;
+import net.md_5.bungee.api.dialog.action.RunCommandAction;
+import net.md_5.bungee.api.dialog.body.PlainMessageBody;
+
+final class BaseSettingsDialogFactory {
+    private static final int DIALOG_WIDTH = 420;
+    private final PluginSettings settings;
+
+    BaseSettingsDialogFactory(PluginSettings settings) {
+        this.settings = settings;
+    }
+
+    Dialog create(PlayerState owner, PocketBaseState pocket) {
+        return new DialogListDialog(
+            base(
+                "Base Settings",
+                "Base Settings",
+                "Base " + owner.baseLevel() + "/4 • Size " + owner.sizeLevel() + "/3"
+                    + " • Flight " + owner.flightLevel() + "/3\n"
+                    + "Pocket Base " + pocket.level() + " • "
+                    + humanize(pocket.biome().commandName())
+            ),
+            List.of(
+                generalSettings(owner),
+                progressReport(),
+                baseUpgrade(owner),
+                pocketSettings(owner, pocket)
+            ),
+            null,
+            2,
+            190
+        );
+    }
+
+    private Dialog generalSettings(PlayerState owner) {
+        return new MultiActionDialog(
+            base(
+                "Base Controls",
+                "Base Controls",
+                "Select a setting to change it. Locked controls remain visible and explain "
+                    + "their requirement in chat when selected."
+            ),
+            List.of(
+                toggle(
+                    "Visitors",
+                    owner.baseLevel() >= 4,
+                    owner.visitorsEnabled(),
+                    "Allowed",
+                    "Blocked",
+                    "basesettings visitors "
+                        + (owner.visitorsEnabled() ? "blocked" : "allowed")
+                ),
+                toggle(
+                    "Navigation",
+                    owner.baseLevel() >= 2,
+                    owner.navigationEnabled(),
+                    "Enabled",
+                    "Disabled",
+                    "basesettings navigation "
+                        + mode(!owner.navigationEnabled())
+                ),
+                toggle(
+                    "Flight",
+                    owner.flightLevel() >= 1,
+                    owner.flightEnabled(),
+                    "Enabled",
+                    "Disabled",
+                    "basesettings flight " + mode(!owner.flightEnabled())
+                ),
+                toggle(
+                    "Border",
+                    owner.baseLevel() >= 1 && owner.base().isPresent(),
+                    owner.borderEnabled(),
+                    "Enabled",
+                    "Disabled",
+                    "basesettings border " + mode(!owner.borderEnabled())
+                ),
+                toggle(
+                    "Spawnable Overlay",
+                    owner.baseLevel() >= 1
+                        && owner.base().isPresent()
+                        && owner.totalBlocksPlaced()
+                            >= settings.spawnableOverlayUnlockPlacements(),
+                    owner.spawnableOverlayEnabled(),
+                    "Enabled",
+                    "Disabled",
+                    "basesettings spawnable " + mode(!owner.spawnableOverlayEnabled())
+                ),
+                toggle(
+                    "Progress Boss Bar",
+                    true,
+                    owner.bossBarEnabled(),
+                    "Enabled",
+                    "Disabled",
+                    "basesettings bossbar " + mode(!owner.bossBarEnabled())
+                )
+            ),
+            2,
+            null
+        );
+    }
+
+    private Dialog progressReport() {
+        return new NoticeDialog(base(
+            "Progress Report",
+            "Progress Report",
+            "Display the detailed progression report in chat."
+        )).action(commandButton("Show in Chat", "basesettings status"));
+    }
+
+    private Dialog baseUpgrade(PlayerState owner) {
+        if (owner.baseLevel() >= 4) {
+            return notice("Base IV", "Base IV and visitor access are already unlocked.");
+        }
+        if (owner.baseLevel() < 3 || owner.base().isEmpty()) {
+            return notice(
+                "Base IV — Locked",
+                "Unlock and establish Base III before purchasing Base IV visitor access."
+            );
+        }
+        int price = settings.visitorUnlockDiamondCost();
+        return confirmation(
+            "Unlock Base IV",
+            "Purchase visitor access for " + price + " diamonds?",
+            "basesettings upgrade"
+        );
+    }
+
+    private Dialog pocketSettings(PlayerState owner, PocketBaseState pocket) {
+        return new DialogListDialog(
+            base(
+                "Pocket Base",
+                "Pocket Base " + pocket.level(),
+                pocket.level() == 0
+                    ? "Pocket Base is locked."
+                    : "Biome: " + pocket.biome().worldType().commandName() + "/"
+                        + pocket.biome().commandName() + "\nHostile mobs: "
+                        + enabled(pocket.hostileMobSpawningEnabled()) + " • Passive mobs: "
+                        + enabled(pocket.passiveMobSpawningEnabled())
+            ),
+            List.of(
+                pocketUpgrade(owner, pocket),
+                pocketMobSettings(pocket),
+                pocketBiomeSettings(pocket)
+            ),
+            null,
+            1,
+            260
+        );
+    }
+
+    private Dialog pocketUpgrade(PlayerState owner, PocketBaseState pocket) {
+        if (owner.baseLevel() < 4 || owner.base().isEmpty()) {
+            return notice(
+                "Pocket Upgrade — Locked",
+                "Establish Base IV before purchasing a Pocket Base."
+            );
+        }
+        int price = pocket.level() == 0
+            ? settings.pocketBaseUnlockCost()
+            : settings.pocketBaseUpgradeCost();
+        String currency = humanize(settings.pocketBaseCurrencyMaterial());
+        String title = pocket.level() == 0
+            ? "Unlock Pocket Base I"
+            : "Upgrade to Pocket Base " + (pocket.level() + 1);
+        return confirmation(
+            title,
+            "Purchase this upgrade for " + price + " " + currency + "?",
+            "basesettings pocket upgrade"
+        );
+    }
+
+    private Dialog pocketMobSettings(PocketBaseState pocket) {
+        if (pocket.level() < 1) {
+            return notice(
+                "Mob Spawning — Locked",
+                "Unlock Pocket Base I to control natural mob spawning."
+            );
+        }
+        return new MultiActionDialog(
+            base(
+                "Mob Spawning",
+                "Mob Spawning",
+                "Control natural spawning independently for each mob category."
+            ),
+            List.of(
+                toggle(
+                    "Hostile Mobs",
+                    true,
+                    pocket.hostileMobSpawningEnabled(),
+                    "Enabled",
+                    "Disabled",
+                    "basesettings pocket mobs hostile "
+                        + mode(!pocket.hostileMobSpawningEnabled())
+                ),
+                toggle(
+                    "Passive Mobs",
+                    true,
+                    pocket.passiveMobSpawningEnabled(),
+                    "Enabled",
+                    "Disabled",
+                    "basesettings pocket mobs passive "
+                        + mode(!pocket.passiveMobSpawningEnabled())
+                )
+            ),
+            1,
+            null
+        );
+    }
+
+    private Dialog pocketBiomeSettings(PocketBaseState pocket) {
+        if (pocket.level() < 1) {
+            return notice(
+                "Change Biome — Locked",
+                "Unlock Pocket Base I to purchase biome changes."
+            );
+        }
+        List<Dialog> worldTypes = Arrays.stream(PocketBaseWorldType.values())
+            .map(type -> pocketBiomeType(pocket, type))
+            .map(Dialog.class::cast)
+            .toList();
+        return new DialogListDialog(
+            base(
+                "Change Biome",
+                "Change Biome",
+                "Current biome: " + pocket.biome().worldType().commandName() + "/"
+                    + pocket.biome().commandName() + "\nEach change costs "
+                    + settings.pocketBaseBiomeChangeCost() + " "
+                    + humanize(settings.pocketBaseBiomeCurrencyMaterial()) + "."
+            ),
+            worldTypes,
+            null,
+            1,
+            220
+        );
+    }
+
+    private DialogListDialog pocketBiomeType(
+        PocketBaseState pocket,
+        PocketBaseWorldType worldType
+    ) {
+        List<Dialog> biomes = Arrays.stream(PocketBaseBiome.values())
+            .filter(biome -> biome.worldType() == worldType)
+            .map(biome -> biomeConfirmation(pocket, biome))
+            .map(Dialog.class::cast)
+            .toList();
+        return new DialogListDialog(
+            base(
+                humanize(worldType.commandName()),
+                humanize(worldType.commandName()) + " Biomes",
+                "Choose a biome subtype. The active biome is marked as selected."
+            ),
+            biomes,
+            null,
+            2,
+            190
+        );
+    }
+
+    private Dialog biomeConfirmation(PocketBaseState pocket, PocketBaseBiome biome) {
+        String title = humanize(biome.commandName())
+            + (pocket.biome() == biome ? " — Selected" : "");
+        if (pocket.biome() == biome) {
+            return notice(title, "This is your Pocket Base's current biome.");
+        }
+        return confirmation(
+            title,
+            "Change the Pocket Base biome for " + settings.pocketBaseBiomeChangeCost()
+                + " " + humanize(settings.pocketBaseBiomeCurrencyMaterial()) + "?",
+            "basesettings pocket type " + biome.worldType().commandName() + " "
+                + biome.commandName()
+        );
+    }
+
+    private static Dialog confirmation(String title, String message, String command) {
+        return new ConfirmationDialog(base(title, title, message))
+            .yes(commandButton("Confirm", command));
+    }
+
+    private static Dialog notice(String title, String message) {
+        return new NoticeDialog(base(title, title, message));
+    }
+
+    private static ActionButton toggle(
+        String name,
+        boolean unlocked,
+        boolean active,
+        String activeLabel,
+        String inactiveLabel,
+        String command
+    ) {
+        String state = unlocked ? (active ? activeLabel : inactiveLabel) : "Locked";
+        String tooltip = unlocked
+            ? "Click to change this setting."
+            : "This setting has not been unlocked yet.";
+        return new ActionButton(
+            text(name + ": " + state),
+            text(tooltip),
+            190,
+            new RunCommandAction("/" + command)
+        );
+    }
+
+    private static ActionButton commandButton(String label, String command) {
+        return new ActionButton(text(label), new RunCommandAction("/" + command));
+    }
+
+    private static DialogBase base(String title, String externalTitle, String message) {
+        return new DialogBase(text(title))
+            .externalTitle(text(externalTitle))
+            .body(List.of(new PlainMessageBody(text(message), DIALOG_WIDTH)))
+            .canCloseWithEscape(true)
+            .pause(false)
+            .afterAction(DialogBase.AfterAction.CLOSE);
+    }
+
+    private static BaseComponent text(String value) {
+        return new TextComponent(value);
+    }
+
+    private static String mode(boolean active) {
+        return active ? "enable" : "disable";
+    }
+
+    private static String enabled(boolean active) {
+        return active ? "enabled" : "disabled";
+    }
+
+    private static String humanize(String value) {
+        String normalized = value.toLowerCase(Locale.ROOT).replace('_', ' ');
+        StringBuilder result = new StringBuilder(normalized.length());
+        boolean capitalize = true;
+        for (int index = 0; index < normalized.length(); index++) {
+            char character = normalized.charAt(index);
+            result.append(capitalize ? Character.toUpperCase(character) : character);
+            capitalize = character == ' ';
+        }
+        return result.toString();
+    }
+}

src/main/java/games/dmg/spigotbase/PocketBaseManager.java

@@ -92,20 +92,48 @@ final class PocketBaseManager {
         }
     }
 
-    PocketBaseState setMobSpawning(UUID ownerId, boolean enabled) throws IOException {
+    PocketBaseState setHostileMobSpawning(UUID ownerId, boolean enabled)
+            throws IOException {
         PocketBaseState current = states.state(ownerId);
+        return setMobSpawning(
+            current,
+            enabled,
+            current.passiveMobSpawningEnabled(),
+            state -> state.withHostileMobSpawningEnabled(enabled)
+        );
+    }
+
+    PocketBaseState setPassiveMobSpawning(UUID ownerId, boolean enabled)
+            throws IOException {
+        PocketBaseState current = states.state(ownerId);
+        return setMobSpawning(
+            current,
+            current.hostileMobSpawningEnabled(),
+            enabled,
+            state -> state.withPassiveMobSpawningEnabled(enabled)
+        );
+    }
+
+    private PocketBaseState setMobSpawning(
+        PocketBaseState current,
+        boolean hostileEnabled,
+        boolean passiveEnabled,
+        java.util.function.UnaryOperator<PocketBaseState> update
+    ) throws IOException {
         if (current.level() < 1) {
             throw new IllegalStateException("Pocket Base I is still locked");
         }
-        worlds.setMobSpawning(ownerId, enabled);
+        UUID ownerId = current.ownerId();
+        worlds.setMobSpawning(ownerId, hostileEnabled, passiveEnabled);
         try {
-            return states.updateAndSave(
-                ownerId,
-                state -> state.withMobSpawningEnabled(enabled)
-            );
+            return states.updateAndSave(ownerId, update);
         } catch (IOException | RuntimeException exception) {
             try {
-                worlds.setMobSpawning(ownerId, current.mobSpawningEnabled());
+                worlds.setMobSpawning(
+                    ownerId,
+                    current.hostileMobSpawningEnabled(),
+                    current.passiveMobSpawningEnabled()
+                );
             } catch (RuntimeException rollbackFailure) {
                 exception.addSuppressed(rollbackFailure);
             }

src/main/java/games/dmg/spigotbase/PocketBaseState.java

@@ -8,7 +8,8 @@ public record PocketBaseState(
     int level,
     Optional<PocketPortalLocation> entrance,
     Optional<PocketPortalLocation> returnPortal,
-    boolean mobSpawningEnabled,
+    boolean hostileMobSpawningEnabled,
+    boolean passiveMobSpawningEnabled,
     PocketBaseBiome biome
 ) {
     public PocketBaseState {
@@ -32,73 +33,64 @@ public record PocketBaseState(
         Optional<PocketPortalLocation> entrance
     ) {
         this(
-            ownerId, level, entrance, Optional.empty(), false, PocketBaseBiome.THE_VOID
-        );
-    }
-
-    public PocketBaseState(
-        UUID ownerId,
-        int level,
-        Optional<PocketPortalLocation> entrance,
-        boolean mobSpawningEnabled
-    ) {
-        this(
-            ownerId, level, entrance, Optional.empty(), mobSpawningEnabled,
-            PocketBaseBiome.THE_VOID
-        );
-    }
-
-    public PocketBaseState(
-        UUID ownerId,
-        int level,
-        Optional<PocketPortalLocation> entrance,
-        Optional<PocketPortalLocation> returnPortal,
-        boolean mobSpawningEnabled
-    ) {
-        this(
-            ownerId, level, entrance, returnPortal, mobSpawningEnabled,
+            ownerId, level, entrance, Optional.empty(), false, false,
             PocketBaseBiome.THE_VOID
         );
     }
 
     public static PocketBaseState locked(UUID ownerId) {
         return new PocketBaseState(
-            ownerId, 0, Optional.empty(), Optional.empty(), false,
+            ownerId, 0, Optional.empty(), Optional.empty(), false, false,
             PocketBaseBiome.THE_VOID
         );
     }
 
     public PocketBaseState withLevel(int newLevel) {
         return new PocketBaseState(
-            ownerId, newLevel, entrance, returnPortal, mobSpawningEnabled, biome
+            ownerId, newLevel, entrance, returnPortal, hostileMobSpawningEnabled,
+            passiveMobSpawningEnabled, biome
         );
     }
 
     public PocketBaseState withEntrance(PocketPortalLocation portal) {
         return new PocketBaseState(
-            ownerId, level, Optional.of(portal), returnPortal, mobSpawningEnabled, biome
+            ownerId, level, Optional.of(portal), returnPortal,
+            hostileMobSpawningEnabled, passiveMobSpawningEnabled, biome
         );
     }
 
     public PocketBaseState withoutEntrance() {
         return new PocketBaseState(
-            ownerId, level, Optional.empty(), returnPortal, mobSpawningEnabled, biome
+            ownerId, level, Optional.empty(), returnPortal, hostileMobSpawningEnabled,
+            passiveMobSpawningEnabled, biome
         );
     }
 
     public PocketBaseState withReturnPortal(PocketPortalLocation portal) {
         return new PocketBaseState(
-            ownerId, level, entrance, Optional.of(portal), mobSpawningEnabled, biome
+            ownerId, level, entrance, Optional.of(portal), hostileMobSpawningEnabled,
+            passiveMobSpawningEnabled, biome
         );
     }
 
-    public PocketBaseState withMobSpawningEnabled(boolean enabled) {
-        return new PocketBaseState(ownerId, level, entrance, returnPortal, enabled, biome);
+    public PocketBaseState withHostileMobSpawningEnabled(boolean enabled) {
+        return new PocketBaseState(
+            ownerId, level, entrance, returnPortal, enabled,
+            passiveMobSpawningEnabled, biome
+        );
+    }
+
+    public PocketBaseState withPassiveMobSpawningEnabled(boolean enabled) {
+        return new PocketBaseState(
+            ownerId, level, entrance, returnPortal, hostileMobSpawningEnabled,
+            enabled, biome
+        );
     }
 
     public PocketBaseState withBiome(PocketBaseBiome selectedBiome) {
         return new PocketBaseState(
-            ownerId, level, entrance, returnPortal, mobSpawningEnabled, selectedBiome
+            ownerId, level, entrance, returnPortal, hostileMobSpawningEnabled,
+            passiveMobSpawningEnabled, selectedBiome
         );
     }
 }

src/main/java/games/dmg/spigotbase/PocketBaseWorldService.java

@@ -42,7 +42,11 @@ final class PocketBaseWorldService {
         for (PocketBaseState state : states.values()) {
             if (state.level() > 0) {
                 setBiome(state.ownerId(), state.level(), state.biome());
-                setMobSpawning(state.ownerId(), state.mobSpawningEnabled());
+                setMobSpawning(
+                    state.ownerId(),
+                    state.hostileMobSpawningEnabled(),
+                    state.passiveMobSpawningEnabled()
+                );
             }
         }
     }
@@ -91,8 +95,12 @@ final class PocketBaseWorldService {
         return ensureWorld(ownerId);
     }
 
-    void setMobSpawning(UUID ownerId, boolean enabled) {
-        ensureWorld(ownerId).setSpawnFlags(enabled, enabled);
+    void setMobSpawning(
+        UUID ownerId,
+        boolean hostileEnabled,
+        boolean passiveEnabled
+    ) {
+        ensureWorld(ownerId).setSpawnFlags(hostileEnabled, passiveEnabled);
     }
 
     void setBiome(UUID ownerId, int level, PocketBaseBiome biome) {

src/main/java/games/dmg/spigotbase/YamlPocketBaseRepository.java

@@ -44,7 +44,8 @@ public final class YamlPocketBaseRepository {
                     level,
                     loadPortal(yaml, path + ".entrance"),
                     loadPortal(yaml, path + ".return-portal"),
-                    yaml.getBoolean(path + ".mob-spawning-enabled", false),
+                    loadMobPreference(yaml, path, "hostile-mob-spawning-enabled"),
+                    loadMobPreference(yaml, path, "passive-mob-spawning-enabled"),
                     loadBiome(yaml, path)
                 );
                 states.put(ownerId, state);
@@ -64,7 +65,14 @@ public final class YamlPocketBaseRepository {
         for (PocketBaseState state : states.values()) {
             String path = "owners." + state.ownerId();
             yaml.set(path + ".level", state.level());
-            yaml.set(path + ".mob-spawning-enabled", state.mobSpawningEnabled());
+            yaml.set(
+                path + ".hostile-mob-spawning-enabled",
+                state.hostileMobSpawningEnabled()
+            );
+            yaml.set(
+                path + ".passive-mob-spawning-enabled",
+                state.passiveMobSpawningEnabled()
+            );
             yaml.set(path + ".world-type", state.biome().worldType().commandName());
             yaml.set(path + ".biome", state.biome().commandName());
             state.entrance().ifPresent(portal -> savePortal(yaml, path + ".entrance", portal));
@@ -90,6 +98,17 @@ public final class YamlPocketBaseRepository {
         }
     }
 
+    private static boolean loadMobPreference(
+        YamlConfiguration yaml,
+        String path,
+        String categoryKey
+    ) {
+        return yaml.getBoolean(
+            path + "." + categoryKey,
+            yaml.getBoolean(path + ".mob-spawning-enabled", false)
+        );
+    }
+
     private static PocketBaseBiome loadBiome(YamlConfiguration yaml, String path) {
         String worldTypeName = yaml.getString(path + ".world-type");
         String biomeName = yaml.getString(path + ".biome");

src/main/resources/plugin.yml

@@ -19,7 +19,7 @@ commands:
     aliases: [visit]
   basesettings:
     description: View progression, upgrade, and manage base settings.
-    usage: /basesettings [status|upgrade|pocket|visitors|navigation|flight|border|spawnable|bossbar]
+    usage: /basesettings [ui|status|upgrade|pocket|visitors|navigation|flight|border|spawnable|bossbar]
     aliases: [homesettings]
   baseadmin:
     description: Administer Spigot Base.

src/test/java/games/dmg/spigotbase/BaseSettingsCommandTest.java

@@ -20,13 +20,29 @@ import java.util.concurrent.atomic.AtomicReference;
 import java.util.function.UnaryOperator;
 import org.bukkit.ChatColor;
 import org.bukkit.Material;
+import org.bukkit.command.CommandSender;
 import org.bukkit.entity.Player;
 import org.bukkit.inventory.ItemStack;
 import org.bukkit.inventory.PlayerInventory;
+import net.md_5.bungee.api.dialog.Dialog;
 import org.junit.jupiter.api.Test;
 import org.mockito.ArgumentCaptor;
 
 final class BaseSettingsCommandTest {
+    @Test
+    void rejectsNonPlayerExecution() {
+        CommandSender sender = mock(CommandSender.class);
+        BaseSettingsCommand command = new BaseSettingsCommand(
+            mock(BaseStateManager.class),
+            new PluginSettingsProvider(PluginSettings.from(Map.of())),
+            mock(BaseFlightController.class)
+        );
+
+        command.onCommand(sender, null, "basesettings", new String[0]);
+
+        verify(sender).sendMessage("Only players have base progression.");
+    }
+
     @Test
     void spawnableEnableIsIdempotentAfterUnlock() {
         UUID playerId = UUID.randomUUID();
@@ -119,10 +135,23 @@ final class BaseSettingsCommandTest {
                 new String[] {"pocket", "type", "nether", "c"}
             )
         );
+        assertEquals(
+            List.of("hostile"),
+            command.onTabComplete(
+                null, null, "basesettings", new String[] {"pocket", "mobs", "h"}
+            )
+        );
+        assertEquals(
+            List.of("passive"),
+            command.onTabComplete(
+                null, null, "basesettings", new String[] {"pocket", "mobs", "p"}
+            )
+        );
         assertEquals(
             List.of("enable"),
             command.onTabComplete(
-                null, null, "basesettings", new String[] {"pocket", "mobs", "e"}
+                null, null, "basesettings",
+                new String[] {"pocket", "mobs", "hostile", "e"}
             )
         );
         for (String setting : List.of("navigation", "flight", "border", "spawnable", "bossbar")) {
@@ -143,8 +172,8 @@ final class BaseSettingsCommandTest {
 
         assertEquals(
             List.of(
-                "status", "upgrade", "pocket", "visitors", "navigation", "flight", "border",
-                "spawnable", "bossbar"
+                "ui", "status", "upgrade", "pocket", "visitors", "navigation", "flight",
+                "border", "spawnable", "bossbar"
             ),
             command.onTabComplete(null, null, "basesettings", new String[] {""})
         );
@@ -296,7 +325,7 @@ final class BaseSettingsCommandTest {
     }
 
     @Test
-    void pocketOwnerCanEnableNaturalMobSpawning() throws Exception {
+    void pocketOwnerCanEnableHostileMobSpawningWithoutChangingPassive() throws Exception {
         UUID playerId = UUID.randomUUID();
         Player player = mock(Player.class);
         when(player.getUniqueId()).thenReturn(playerId);
@@ -305,11 +334,13 @@ final class BaseSettingsCommandTest {
         when(stateManager.player(playerId, "Builder"))
             .thenReturn(PlayerState.newPlayer(playerId, "Builder"));
         PocketBaseManager pocketBases = mock(PocketBaseManager.class);
-        when(pocketBases.state(playerId)).thenReturn(
-            new PocketBaseState(playerId, 1, java.util.Optional.empty(), false)
+        PocketBaseState current = new PocketBaseState(
+            playerId, 1, java.util.Optional.empty(), java.util.Optional.empty(),
+            false, true, PocketBaseBiome.THE_VOID
         );
-        when(pocketBases.setMobSpawning(playerId, true)).thenReturn(
-            new PocketBaseState(playerId, 1, java.util.Optional.empty(), true)
+        when(pocketBases.state(playerId)).thenReturn(current);
+        when(pocketBases.setHostileMobSpawning(playerId, true)).thenReturn(
+            current.withHostileMobSpawningEnabled(true)
         );
         BaseSettingsCommand command = new BaseSettingsCommand(
             stateManager,
@@ -318,13 +349,14 @@ final class BaseSettingsCommandTest {
             pocketBases
         );
 
-        command.onCommand(
-            player, null, "basesettings", new String[] {"pocket", "mobs", "enable"}
-        );
+        command.onCommand(player, null, "basesettings", new String[] {
+            "pocket", "mobs", "hostile", "enable"
+        });
 
-        verify(pocketBases).setMobSpawning(playerId, true);
+        verify(pocketBases).setHostileMobSpawning(playerId, true);
+        verify(pocketBases, never()).setPassiveMobSpawning(playerId, true);
         verify(player).sendMessage(org.mockito.ArgumentMatchers.<String>argThat(
-            message -> message.contains("mob spawning") && message.contains("enabled")
+            message -> message.contains("hostile mob spawning") && message.contains("enabled")
         ));
     }
 
@@ -339,9 +371,9 @@ final class BaseSettingsCommandTest {
             .thenReturn(PlayerState.newPlayer(playerId, "Builder"));
         PocketBaseManager pocketBases = mock(PocketBaseManager.class);
         when(pocketBases.state(playerId)).thenReturn(
-            new PocketBaseState(playerId, 1, java.util.Optional.empty(), false)
+            new PocketBaseState(playerId, 1, java.util.Optional.empty())
         );
-        when(pocketBases.setMobSpawning(playerId, true))
+        when(pocketBases.setPassiveMobSpawning(playerId, true))
             .thenThrow(new IOException("save failed"));
         BaseSettingsCommand command = new BaseSettingsCommand(
             stateManager,
@@ -350,9 +382,9 @@ final class BaseSettingsCommandTest {
             pocketBases
         );
 
-        command.onCommand(
-            player, null, "basesettings", new String[] {"pocket", "mobs", "enable"}
-        );
+        command.onCommand(player, null, "basesettings", new String[] {
+            "pocket", "mobs", "passive", "enable"
+        });
 
         verify(player).sendMessage(org.mockito.ArgumentMatchers.<String>argThat(
             message -> message.contains("could not be changed")
@@ -380,11 +412,11 @@ final class BaseSettingsCommandTest {
             pocketBases
         );
 
-        command.onCommand(
-            player, null, "basesettings", new String[] {"pocket", "mobs", "enable"}
-        );
+        command.onCommand(player, null, "basesettings", new String[] {
+            "pocket", "mobs", "hostile", "enable"
+        });
 
-        verify(pocketBases, never()).setMobSpawning(playerId, true);
+        verify(pocketBases, never()).setHostileMobSpawning(playerId, true);
         verify(player).sendMessage(org.mockito.ArgumentMatchers.<String>argThat(
             message -> message.contains("Pocket Base I") && message.contains("locked")
         ));
@@ -429,7 +461,7 @@ final class BaseSettingsCommandTest {
     }
 
     @Test
-    void statusDisplaysPocketMobSpawningPreference() {
+    void statusDisplaysPocketMobSpawningPreferences() {
         UUID playerId = UUID.randomUUID();
         Player player = mock(Player.class);
         when(player.getUniqueId()).thenReturn(playerId);
@@ -439,7 +471,10 @@ final class BaseSettingsCommandTest {
             .thenReturn(PlayerState.newPlayer(playerId, "Builder"));
         PocketBaseManager pocketBases = mock(PocketBaseManager.class);
         when(pocketBases.state(playerId)).thenReturn(
-            new PocketBaseState(playerId, 1, java.util.Optional.empty(), false)
+            new PocketBaseState(
+                playerId, 1, java.util.Optional.empty(), java.util.Optional.empty(),
+                true, false, PocketBaseBiome.THE_VOID
+            )
         );
         BaseSettingsCommand command = new BaseSettingsCommand(
             stateManager,
@@ -453,7 +488,8 @@ final class BaseSettingsCommandTest {
         verify(player).sendMessage(org.mockito.ArgumentMatchers.<String>argThat(
             message -> message.contains("Pocket Base 1")
                 && message.contains("type=void/the_void")
-                && message.contains("mob spawning=disabled")
+                && message.contains("hostile spawning=enabled")
+                && message.contains("passive spawning=disabled")
         ));
     }
 
@@ -506,7 +542,7 @@ final class BaseSettingsCommandTest {
     }
 
     @Test
-    void defaultAndStatusDisplayTheFullProgressReport() {
+    void defaultAndUiOpenDialogWhileStatusDisplaysTheFullProgressReport() {
         UUID playerId = UUID.randomUUID();
         Player player = mock(Player.class);
         when(player.getUniqueId()).thenReturn(playerId);
@@ -522,17 +558,19 @@ final class BaseSettingsCommandTest {
         );
 
         command.onCommand(player, null, "basesettings", new String[0]);
+        command.onCommand(player, null, "homesettings", new String[] {"ui"});
         command.onCommand(player, null, "basesettings", new String[] {"status"});
 
-        verify(player, times(2)).sendMessage(ChatColor.GOLD + "=== Base Progress ===");
-        verify(player, times(2)).sendMessage(
+        verify(player, times(2)).showDialog(any(Dialog.class));
+        verify(player).sendMessage(ChatColor.GOLD + "=== Base Progress ===");
+        verify(player).sendMessage(
             org.mockito.ArgumentMatchers.<String>argThat(message ->
                 message.contains("Spawnable Overlay:")
                     && message.contains("0/250 placements")
                     && message.contains("locked")
             )
         );
-        verify(player, times(2)).sendMessage(
+        verify(player).sendMessage(
             org.mockito.ArgumentMatchers.<String>argThat(message ->
             message.contains("Settings: visitors=")
                 && message.contains("navigation=")

src/test/java/games/dmg/spigotbase/BaseSettingsDialogFactoryTest.java

@@ -0,0 +1,152 @@
+package games.dmg.spigotbase;
+
+import static org.junit.jupiter.api.Assertions.assertInstanceOf;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+import java.time.Instant;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+import java.util.Optional;
+import java.util.UUID;
+import net.md_5.bungee.api.dialog.ConfirmationDialog;
+import net.md_5.bungee.api.dialog.Dialog;
+import net.md_5.bungee.api.dialog.DialogListDialog;
+import net.md_5.bungee.api.dialog.MultiActionDialog;
+import net.md_5.bungee.api.dialog.NoticeDialog;
+import net.md_5.bungee.api.dialog.action.Action;
+import net.md_5.bungee.api.dialog.action.ActionButton;
+import net.md_5.bungee.api.dialog.action.RunCommandAction;
+import org.junit.jupiter.api.Test;
+
+final class BaseSettingsDialogFactoryTest {
+    @Test
+    void createsControlsForEveryBaseSettingAndConfirmedPurchase() {
+        UUID playerId = UUID.randomUUID();
+        PlayerState owner = PlayerState.newPlayer(playerId, "Builder")
+            .withAdministrativeLevels(4, 2, 2, 1, 1, true, true, true)
+            .withBase(
+                new BaseLocation(UUID.randomUUID(), "world", 10, 64, 20, 10, 20),
+                Instant.EPOCH
+            )
+            .withBorderEnabled(true)
+            .withTotalBlocksPlaced(250)
+            .withSpawnableOverlayEnabled(true);
+        PocketBaseState pocket = new PocketBaseState(
+            playerId,
+            1,
+            Optional.empty(),
+            Optional.empty(),
+            true,
+            false,
+            PocketBaseBiome.PLAINS
+        );
+
+        Dialog dialog = new BaseSettingsDialogFactory(
+            PluginSettings.from(Map.of())
+        ).create(owner, pocket);
+
+        DialogListDialog root = assertInstanceOf(DialogListDialog.class, dialog);
+        assertTrue(root.getBase().body().get(0).toString().contains("Base 4/4"));
+        List<String> commands = commands(root);
+        assertTrue(commands.contains("/basesettings status"));
+        assertTrue(commands.contains("/basesettings visitors blocked"));
+        assertTrue(commands.contains("/basesettings navigation disable"));
+        assertTrue(commands.contains("/basesettings flight disable"));
+        assertTrue(commands.contains("/basesettings border disable"));
+        assertTrue(commands.contains("/basesettings spawnable disable"));
+        assertTrue(commands.contains("/basesettings bossbar disable"));
+        assertTrue(commands.contains("/basesettings pocket upgrade"));
+        assertTrue(commands.contains("/basesettings pocket mobs hostile disable"));
+        assertTrue(commands.contains("/basesettings pocket mobs passive enable"));
+        assertTrue(commands.contains("/basesettings pocket type nether crimson_forest"));
+    }
+
+    @Test
+    void requiresConfirmationForBaseIvPurchase() {
+        UUID playerId = UUID.randomUUID();
+        PlayerState owner = PlayerState.newPlayer(playerId, "Builder")
+            .withAdministrativeLevels(3, 0, 0, 0, 0, false, false, false)
+            .withBase(
+                new BaseLocation(UUID.randomUUID(), "world", 0, 64, 0, 0, 0),
+                Instant.EPOCH
+            );
+
+        DialogListDialog root = assertInstanceOf(
+            DialogListDialog.class,
+            new BaseSettingsDialogFactory(PluginSettings.from(Map.of())).create(
+                owner,
+                PocketBaseState.locked(playerId)
+            )
+        );
+        ConfirmationDialog upgrade = assertInstanceOf(
+            ConfirmationDialog.class,
+            root.dialogs().get(2)
+        );
+
+        RunCommandAction action = assertInstanceOf(
+            RunCommandAction.class,
+            upgrade.yes().action()
+        );
+        assertTrue(action.template().equals("/basesettings upgrade"));
+    }
+
+    @Test
+    void marksUnavailableControlsAsLocked() {
+        UUID playerId = UUID.randomUUID();
+        PlayerState owner = PlayerState.newPlayer(playerId, "Newcomer");
+
+        DialogListDialog root = assertInstanceOf(
+            DialogListDialog.class,
+            new BaseSettingsDialogFactory(PluginSettings.from(Map.of())).create(
+                owner,
+                PocketBaseState.locked(playerId)
+            )
+        );
+        MultiActionDialog controls = assertInstanceOf(
+            MultiActionDialog.class,
+            root.dialogs().get(0)
+        );
+        List<String> labels = controls.actions().stream()
+            .map(ActionButton::label)
+            .map(Object::toString)
+            .toList();
+
+        assertTrue(labels.stream().anyMatch(label -> label.contains("Visitors: Locked")));
+        assertTrue(labels.stream().anyMatch(label -> label.contains("Navigation: Locked")));
+        assertTrue(labels.stream().anyMatch(label -> label.contains("Flight: Locked")));
+        assertTrue(labels.stream().anyMatch(label -> label.contains("Border: Locked")));
+        assertTrue(labels.stream().anyMatch(label -> label.contains("Spawnable Overlay: Locked")));
+    }
+
+    private static List<String> commands(Dialog dialog) {
+        List<String> commands = new ArrayList<>();
+        collect(dialog, commands);
+        return commands;
+    }
+
+    private static void collect(Dialog dialog, List<String> commands) {
+        if (dialog instanceof DialogListDialog list) {
+            list.dialogs().forEach(child -> collect(child, commands));
+            collect(list.exitAction(), commands);
+        } else if (dialog instanceof MultiActionDialog actions) {
+            actions.actions().forEach(button -> collect(button, commands));
+            collect(actions.exitAction(), commands);
+        } else if (dialog instanceof ConfirmationDialog confirmation) {
+            collect(confirmation.yes(), commands);
+            collect(confirmation.no(), commands);
+        } else if (dialog instanceof NoticeDialog notice) {
+            collect(notice.action(), commands);
+        }
+    }
+
+    private static void collect(ActionButton button, List<String> commands) {
+        if (button == null) {
+            return;
+        }
+        Action action = button.action();
+        if (action instanceof RunCommandAction command) {
+            commands.add(command.template());
+        }
+    }
+}

src/test/java/games/dmg/spigotbase/PocketBaseManagerTest.java

@@ -25,7 +25,8 @@ final class PocketBaseManagerTest {
         PocketBaseStateManager states = mock(PocketBaseStateManager.class);
         PocketBaseWorldService worlds = mock(PocketBaseWorldService.class);
         when(states.state(ownerId)).thenReturn(new PocketBaseState(
-            ownerId, 1, Optional.empty(), Optional.of(relocated), false
+            ownerId, 1, Optional.empty(), Optional.of(relocated), false, false,
+            PocketBaseBiome.THE_VOID
         ));
         PocketBaseManager manager = new PocketBaseManager(
             states,
@@ -58,9 +59,12 @@ final class PocketBaseManagerTest {
     }
 
     @Test
-    void persistsAndAppliesMobSpawningPreference() throws Exception {
+    void persistsAndAppliesHostileMobSpawningWithoutChangingPassive() throws Exception {
         UUID ownerId = UUID.randomUUID();
-        PocketBaseState current = new PocketBaseState(ownerId, 1, Optional.empty(), false);
+        PocketBaseState current = new PocketBaseState(
+            ownerId, 1, Optional.empty(), Optional.empty(), false, true,
+            PocketBaseBiome.THE_VOID
+        );
         PocketBaseStateManager states = mock(PocketBaseStateManager.class);
         PocketBaseWorldService worlds = mock(PocketBaseWorldService.class);
         when(states.state(ownerId)).thenReturn(current);
@@ -76,10 +80,12 @@ final class PocketBaseManagerTest {
             new PluginSettingsProvider(PluginSettings.from(Map.of()))
         );
 
-        manager.setMobSpawning(ownerId, true);
+        PocketBaseState updated = manager.setHostileMobSpawning(ownerId, true);
 
+        assertEquals(true, updated.hostileMobSpawningEnabled());
+        assertEquals(true, updated.passiveMobSpawningEnabled());
         InOrder order = inOrder(worlds, states);
-        order.verify(worlds).setMobSpawning(ownerId, true);
+        order.verify(worlds).setMobSpawning(ownerId, true, true);
         order.verify(states).updateAndSave(
             org.mockito.ArgumentMatchers.eq(ownerId), org.mockito.ArgumentMatchers.any()
         );
@@ -137,9 +143,12 @@ final class PocketBaseManagerTest {
     }
 
     @Test
-    void restoresWorldSettingWhenPersistenceFails() throws Exception {
+    void restoresBothWorldSettingsWhenPersistenceFails() throws Exception {
         UUID ownerId = UUID.randomUUID();
-        PocketBaseState current = new PocketBaseState(ownerId, 1, Optional.empty(), false);
+        PocketBaseState current = new PocketBaseState(
+            ownerId, 1, Optional.empty(), Optional.empty(), true, false,
+            PocketBaseBiome.THE_VOID
+        );
         PocketBaseStateManager states = mock(PocketBaseStateManager.class);
         PocketBaseWorldService worlds = mock(PocketBaseWorldService.class);
         when(states.state(ownerId)).thenReturn(current);
@@ -151,9 +160,10 @@ final class PocketBaseManagerTest {
             new PluginSettingsProvider(PluginSettings.from(Map.of()))
         );
 
-        assertThrows(IOException.class, () -> manager.setMobSpawning(ownerId, true));
+        assertThrows(IOException.class,
+            () -> manager.setPassiveMobSpawning(ownerId, true));
 
-        verify(worlds).setMobSpawning(ownerId, true);
-        verify(worlds).setMobSpawning(ownerId, false);
+        verify(worlds).setMobSpawning(ownerId, true, true);
+        verify(worlds).setMobSpawning(ownerId, true, false);
     }
 }

src/test/java/games/dmg/spigotbase/PocketBaseWorldServiceTest.java

@@ -93,10 +93,13 @@ final class PocketBaseWorldServiceTest {
 
         service.loadExisting(Map.of(
             ownerId,
-            new PocketBaseState(ownerId, 1, Optional.empty(), true)
+            new PocketBaseState(
+                ownerId, 1, Optional.empty(), Optional.empty(), true, false,
+                PocketBaseBiome.THE_VOID
+            )
         ));
 
-        verify(world).setSpawnFlags(true, true);
+        verify(world).setSpawnFlags(true, false);
     }
 
     @Test

src/test/java/games/dmg/spigotbase/YamlPocketBaseRepositoryTest.java

@@ -30,6 +30,7 @@ final class YamlPocketBaseRepositoryTest {
                 worldId, "pocket", 20, 65, 12, PocketPortalAxis.Z
             )),
             true,
+            false,
             PocketBaseBiome.CRIMSON_FOREST
         );
         YamlPocketBaseRepository repository = new YamlPocketBaseRepository(
@@ -50,8 +51,23 @@ final class YamlPocketBaseRepositoryTest {
 
         PocketBaseState loaded = repository.load().get(ownerId);
 
-        assertFalse(loaded.mobSpawningEnabled());
+        assertFalse(loaded.hostileMobSpawningEnabled());
+        assertFalse(loaded.passiveMobSpawningEnabled());
         assertTrue(loaded.returnPortal().isEmpty());
         assertEquals(PocketBaseBiome.THE_VOID, loaded.biome());
     }
+
+    @Test
+    void migratesLegacyMobPreferenceToBothCategories() throws Exception {
+        UUID ownerId = UUID.randomUUID();
+        Path stateFile = temporaryDirectory.resolve("pocket-bases.yml");
+        Files.writeString(stateFile, "owners:\n  " + ownerId
+            + ":\n    level: 1\n    mob-spawning-enabled: true\n");
+        YamlPocketBaseRepository repository = new YamlPocketBaseRepository(stateFile);
+
+        PocketBaseState loaded = repository.load().get(ownerId);
+
+        assertTrue(loaded.hostileMobSpawningEnabled());
+        assertTrue(loaded.passiveMobSpawningEnabled());
+    }
 }