feat(board): generate physical oak quest boards

.gitignore

@@ -1,5 +1,6 @@
 .gradle/
 build/
+.local-server/
 out/
 .idea/
 *.iml

README.md

@@ -6,7 +6,7 @@ The approved behavior is specified in the [OKF knowledge bundle](knowledge/index
 
 ## Status
 
-Administrators can register persistent shared quest boards by targeting a block within five blocks and running `/questadmin createboard`. Right-clicking any registered board opens a native dialog where a player can request a block and quantity while escrowing the exact reward stack held in their main hand. Every board and `/quests list` show the same active quests with requested blocks, rewards, issuers, and time remaining. Players can complete quests at any board or with `/quests complete <quest>` by delivering the required blocks. Exact escrowed rewards are granted immediately, and delivered blocks are held for the issuer. Issuers can cancel their own active quests at any board or with `/quests cancel <quest>`. Completed deliveries and rewards from cancelled or seven-day-expired quests are held durably and can be collected at any board or with `/quests claim`; inventory overflow drops at the claimant's feet.
+Administrators can register persistent shared quest boards by targeting a block within five blocks and running `/questadmin createboard`. They can instead run `/questadmin createboard physical` to generate a five-wide oak board above the targeted ground anchor and register its visible panel blocks and signs. Right-clicking any registered board opens a compact native dashboard with dedicated browsing, creation, and claim screens. A player can request a block and quantity while escrowing the exact reward stack held in their main hand. Every board and `/quests list` show the same active quests with requested blocks, rewards, issuers, and time remaining. Players can complete quests at any board or with `/quests complete <quest>` by delivering the required blocks. Exact escrowed rewards are granted immediately, and delivered blocks are held for the issuer. Issuers can cancel their own active quests at any board or with `/quests cancel <quest>`. Completed deliveries and rewards from cancelled or seven-day-expired quests are held durably and can be collected at any board or with `/quests claim`; inventory overflow drops at the claimant's feet.
 
 ## Requirements
 
@@ -40,6 +40,7 @@ The `spigotquestboard.admin` permission is granted to server operators by defaul
 
 ```text
 /questadmin createboard
+/questadmin createboard physical
 /questadmin commands <enable|disable>
 ```
 

knowledge/log.md

@@ -76,3 +76,18 @@ description: Chronological record of material decisions affecting Spigot Quest B
 - Added persistent `/questadmin commands enable|disable` control with permission-aware autocomplete and failure-safe updates.
 - Kept administrative board creation available independently of the player-command setting.
 - Verified 82 tests and the plugin JAR with `./gradlew clean check jar`.
+
+## 2026-09-05 — Screen-fitting quest-board dialogs
+
+- Replaced the clipped 800-pixel combined board screen with a compact 420-pixel dashboard.
+- Split browsing, creation, and claims into dedicated native dialog screens with Back navigation.
+- Presented active quests as individual detail dialogs while retaining completion and issuer cancellation actions.
+- Verified 88 tests, including a 250-quest navigation case, and the plugin JAR with `./gradlew clean check jar`.
+
+## 2026-09-05 — Generated physical quest boards
+
+- Added `/questadmin createboard physical` to generate a five-wide, four-tall board above the targeted ground anchor facing the administrator.
+- Used oak-log pillars, an oak-plank face, and three oak wall signs with obfuscated decorative text.
+- Registered all visible planks and signs in one durable operation and added obstruction checks plus block rollback when construction or persistence fails.
+- Preserved existing single-block board creation and persisted board compatibility.
+- Verified 103 tests and the plugin JAR with `./gradlew clean check jar`.

knowledge/user-stories/index.md

@@ -14,3 +14,5 @@ description: Catalog of user stories for the Spigot Quest Board plugin.
 6. [US-006: Cancel an owned quest](us-006-cancel-an-owned-quest.md)
 7. [US-007: Expire quests and claim held items](us-007-expire-quests-and-claim-held-items.md)
 8. [US-008: Control player quest commands](us-008-control-player-quest-commands.md)
+9. [US-009: Use a screen-fitting quest-board interface](us-009-use-a-screen-fitting-quest-board-interface.md)
+10. [US-010: Generate a physical quest-board structure](us-010-generate-a-physical-quest-board.md)

knowledge/user-stories/us-009-use-a-screen-fitting-quest-board-interface.md

@@ -0,0 +1,30 @@
+---
+type: User Story
+title: "US-009: Use a screen-fitting quest-board interface"
+description: Split the oversized quest-board dialog into compact navigable screens that fit the player's display.
+status: done
+---
+
+# US-009: Use a screen-fitting quest-board interface
+
+As a **player**, I want the quest-board interface to fit on screen so that I can read quest information and reach every action.
+
+## Acceptance criteria
+
+- [x] The oversized combined dialog is replaced by a compact dashboard.
+- [x] Dialog message bodies use a maximum width of 420 pixels.
+- [x] Browsing, quest creation, and pending claims use dedicated screens rather than one combined body.
+- [x] Active quests are presented as individual navigable entries instead of one unbounded text listing.
+- [x] Each quest detail shows its issuer, requested material and quantity, reward, and time remaining.
+- [x] Completion, issuer-only cancellation, creation, and claim collection remain available through the board.
+- [x] Nested screens provide Back controls that return toward the quest-board dashboard.
+- [x] Large active-quest collections remain navigable without producing an unbounded single dialog.
+- [x] Automated tests verify width limits, screen separation, navigation, displayed content, and action routing.
+
+## Related
+
+- [US-002: Create and use shared quest boards](us-002-create-and-use-shared-quest-boards.md)
+- [US-003: Create a block-delivery quest](us-003-create-a-block-delivery-quest.md)
+- [US-004: Browse available quests](us-004-browse-available-quests.md)
+- [US-005: Deliver blocks and complete a quest](us-005-deliver-blocks-and-complete-a-quest.md)
+- [US-007: Expire quests and claim held items](us-007-expire-quests-and-claim-held-items.md)

knowledge/user-stories/us-010-generate-a-physical-quest-board.md

@@ -0,0 +1,29 @@
+---
+type: User Story
+title: "US-010: Generate a physical quest-board structure"
+description: Let an administrator generate and register a decorative oak quest board at a targeted ground anchor.
+status: done
+---
+
+# US-010: Generate a physical quest-board structure
+
+As an **administrator**, I want quest-board creation to optionally construct a recognizable physical board so that I do not need to build each board manually.
+
+## Acceptance criteria
+
+- [x] `/questadmin createboard physical` generates and registers a physical quest board while the existing `/questadmin createboard` behavior remains unchanged.
+- [x] The targeted block is treated as the ground anchor and remains unchanged.
+- [x] The generated board faces the administrator and is five blocks wide and four blocks tall.
+- [x] The outer columns use oak-log pillars and the center uses oak planks.
+- [x] Oak wall signs on the front display decorative obfuscated or gibberish text.
+- [x] Clicking generated visible planks or signs opens the same globally shared quest-board interface.
+- [x] Generation requires empty space and refuses to overwrite an existing structure.
+- [x] Structure generation and interaction-location registration form one failure-safe transaction; failure restores changed blocks and registers nothing.
+- [x] Generated interaction locations persist across restarts and remain compatible with existing registered boards.
+- [x] The `physical` argument is offered through permission-aware command autocomplete.
+- [x] Automated tests verify geometry, facing direction, obstruction handling, rollback, registration, persistence, and autocomplete.
+
+## Related
+
+- [US-002: Create and use shared quest boards](us-002-create-and-use-shared-quest-boards.md)
+- [US-009: Use a screen-fitting quest-board interface](us-009-use-a-screen-fitting-quest-board-interface.md)

src/main/java/games/dmg/spigotquestboard/BoardFacing.java

@@ -0,0 +1,54 @@
+package games.dmg.spigotquestboard;
+
+import org.bukkit.block.BlockFace;
+
+/** The direction from the board toward its viewer. */
+enum BoardFacing {
+    NORTH(0, -1),
+    EAST(1, 0),
+    SOUTH(0, 1),
+    WEST(-1, 0);
+
+    private final int x;
+    private final int z;
+
+    BoardFacing(int x, int z) {
+        this.x = x;
+        this.z = z;
+    }
+
+    int x() {
+        return x;
+    }
+
+    int z() {
+        return z;
+    }
+
+    int rightX() {
+        return -z;
+    }
+
+    int rightZ() {
+        return x;
+    }
+
+    BlockFace blockFace() {
+        return switch (this) {
+            case NORTH -> BlockFace.NORTH;
+            case EAST -> BlockFace.EAST;
+            case SOUTH -> BlockFace.SOUTH;
+            case WEST -> BlockFace.WEST;
+        };
+    }
+
+    static BoardFacing towardPlayer(BlockFace playerFacing) {
+        return switch (playerFacing) {
+            case NORTH -> SOUTH;
+            case EAST -> WEST;
+            case SOUTH -> NORTH;
+            case WEST -> EAST;
+            default -> throw new IllegalArgumentException("Player must face a cardinal direction");
+        };
+    }
+}

src/main/java/games/dmg/spigotquestboard/BoardRegistry.java

@@ -1,6 +1,7 @@
 package games.dmg.spigotquestboard;
 
 import java.io.IOException;
+import java.util.Collection;
 import java.util.LinkedHashMap;
 import java.util.Map;
 import java.util.Objects;
@@ -16,12 +17,22 @@ final class BoardRegistry {
     }
 
     synchronized BoardRegistrationResult register(RegisteredBoard board) throws IOException {
-        Objects.requireNonNull(board, "board");
+        return registerAll(Set.of(Objects.requireNonNull(board, "board")));
-        if (boards.containsKey(board.id())) {
+    }
-            return BoardRegistrationResult.ALREADY_REGISTERED;
+
-        }
+    synchronized BoardRegistrationResult registerAll(Collection<RegisteredBoard> additions)
+        throws IOException {
+        Objects.requireNonNull(additions, "additions");
         Map<BoardId, RegisteredBoard> candidate = new LinkedHashMap<>(boards);
-        candidate.put(board.id(), board);
+        for (RegisteredBoard board : additions) {
+            Objects.requireNonNull(board, "board");
+            if (candidate.putIfAbsent(board.id(), board) != null) {
+                return BoardRegistrationResult.ALREADY_REGISTERED;
+            }
+        }
+        if (additions.isEmpty()) {
+            return BoardRegistrationResult.CREATED;
+        }
         repository.save(new BoardState(Set.copyOf(candidate.values())));
         boards = Map.copyOf(candidate);
         return BoardRegistrationResult.CREATED;

src/main/java/games/dmg/spigotquestboard/BukkitPhysicalBoardWorld.java

@@ -0,0 +1,79 @@
+package games.dmg.spigotquestboard;
+
+import java.util.Objects;
+import net.kyori.adventure.text.Component;
+import net.kyori.adventure.text.format.NamedTextColor;
+import net.kyori.adventure.text.format.TextDecoration;
+import org.bukkit.Material;
+import org.bukkit.World;
+import org.bukkit.block.Block;
+import org.bukkit.block.BlockState;
+import org.bukkit.block.Sign;
+import org.bukkit.block.data.BlockData;
+import org.bukkit.block.data.type.WallSign;
+import org.bukkit.block.sign.Side;
+
+final class BukkitPhysicalBoardWorld implements PhysicalBoardWorld {
+    private static final Component DECORATIVE_TEXT = Component.text("xxxxxxxx")
+        .color(NamedTextColor.DARK_GREEN)
+        .decorate(TextDecoration.OBFUSCATED);
+    private final World world;
+
+    BukkitPhysicalBoardWorld(World world) {
+        this.world = Objects.requireNonNull(world, "world");
+    }
+
+    @Override
+    public boolean isEmpty(BoardId location) {
+        return block(location).getType().isAir();
+    }
+
+    @Override
+    public Object snapshot(BoardId location) {
+        return block(location).getState();
+    }
+
+    @Override
+    public void place(PhysicalBoardPlan.Placement placement, BoardFacing facing) {
+        Block block = block(placement.location());
+        Material material = Objects.requireNonNull(
+            Material.matchMaterial(placement.material()),
+            "Unknown physical board material " + placement.material()
+        );
+        block.setType(material, false);
+        if (!placement.sign()) {
+            return;
+        }
+
+        BlockData data = block.getBlockData();
+        if (!(data instanceof WallSign wallSign)) {
+            throw new IllegalStateException("Oak wall sign did not create wall-sign data");
+        }
+        wallSign.setFacing(facing.blockFace());
+        block.setBlockData(wallSign, false);
+        BlockState state = block.getState();
+        if (!(state instanceof Sign sign)) {
+            throw new IllegalStateException("Oak wall sign did not create sign state");
+        }
+        for (int line = 0; line < 4; line++) {
+            sign.getSide(Side.FRONT).line(line, DECORATIVE_TEXT);
+        }
+        if (!sign.update(true, false)) {
+            throw new IllegalStateException("Could not configure physical quest-board sign");
+        }
+    }
+
+    @Override
+    public void restore(BoardId location, Object snapshot) {
+        if (!(snapshot instanceof BlockState state) || !state.update(true, false)) {
+            throw new IllegalStateException("Could not restore block at " + location);
+        }
+    }
+
+    private Block block(BoardId location) {
+        if (!world.getUID().equals(location.worldId())) {
+            throw new IllegalArgumentException("Physical board location belongs to another world");
+        }
+        return world.getBlockAt(location.x(), location.y(), location.z());
+    }
+}

src/main/java/games/dmg/spigotquestboard/PhysicalBoardCreationResult.java

@@ -0,0 +1,7 @@
+package games.dmg.spigotquestboard;
+
+enum PhysicalBoardCreationResult {
+    CREATED,
+    OBSTRUCTED,
+    ALREADY_REGISTERED
+}

src/main/java/games/dmg/spigotquestboard/PhysicalBoardCreator.java

@@ -0,0 +1,93 @@
+package games.dmg.spigotquestboard;
+
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Objects;
+import org.bukkit.block.Block;
+
+final class PhysicalBoardCreator {
+    interface WorldFactory {
+        PhysicalBoardWorld open(Block anchor);
+    }
+
+    private final BoardRegistry registry;
+    private final WorldFactory worlds;
+
+    PhysicalBoardCreator(BoardRegistry registry, WorldFactory worlds) {
+        this.registry = Objects.requireNonNull(registry, "registry");
+        this.worlds = Objects.requireNonNull(worlds, "worlds");
+    }
+
+    PhysicalBoardCreationResult create(Block anchorBlock, BoardFacing facing) throws IOException {
+        Objects.requireNonNull(anchorBlock, "anchorBlock");
+        BoardId anchor = BoardId.from(anchorBlock);
+        String worldName = anchorBlock.getWorld().getName();
+        PhysicalBoardPlan plan = PhysicalBoardPlan.create(anchor, facing);
+        PhysicalBoardWorld world = worlds.open(anchorBlock);
+
+        for (PhysicalBoardPlan.Placement placement : plan.placements()) {
+            if (!world.isEmpty(placement.location())) {
+                return PhysicalBoardCreationResult.OBSTRUCTED;
+            }
+        }
+        for (BoardId location : plan.interactionLocations()) {
+            if (registry.contains(location)) {
+                return PhysicalBoardCreationResult.ALREADY_REGISTERED;
+            }
+        }
+
+        Map<BoardId, Object> snapshots = new LinkedHashMap<>();
+        try {
+            for (PhysicalBoardPlan.Placement placement : plan.placements()) {
+                snapshots.put(placement.location(), world.snapshot(placement.location()));
+            }
+            for (PhysicalBoardPlan.Placement placement : plan.placements()) {
+                world.place(placement, facing);
+            }
+            List<RegisteredBoard> registrations = plan.interactionLocations().stream()
+                .map(location -> new RegisteredBoard(location, worldName))
+                .toList();
+            BoardRegistrationResult result = registry.registerAll(registrations);
+            if (result != BoardRegistrationResult.CREATED) {
+                rollback(world, snapshots, null);
+                return PhysicalBoardCreationResult.ALREADY_REGISTERED;
+            }
+            return PhysicalBoardCreationResult.CREATED;
+        } catch (RuntimeException | IOException exception) {
+            rollback(world, snapshots, exception);
+            if (exception instanceof IOException ioException) {
+                throw ioException;
+            }
+            throw new IOException("Could not generate physical quest board", exception);
+        }
+    }
+
+    private static void rollback(
+        PhysicalBoardWorld world, Map<BoardId, Object> snapshots, Throwable failure
+    ) throws IOException {
+        RuntimeException rollbackFailure = null;
+        List<Map.Entry<BoardId, Object>> entries = new ArrayList<>(snapshots.entrySet());
+        for (int index = entries.size() - 1; index >= 0; index--) {
+            Map.Entry<BoardId, Object> entry = entries.get(index);
+            try {
+                world.restore(entry.getKey(), entry.getValue());
+            } catch (RuntimeException exception) {
+                if (rollbackFailure == null) {
+                    rollbackFailure = exception;
+                } else {
+                    rollbackFailure.addSuppressed(exception);
+                }
+            }
+        }
+        if (rollbackFailure != null) {
+            if (failure != null) {
+                failure.addSuppressed(rollbackFailure);
+            } else {
+                throw new IOException("Could not fully restore physical quest board", rollbackFailure);
+            }
+        }
+    }
+}

src/main/java/games/dmg/spigotquestboard/PhysicalBoardPlan.java

@@ -0,0 +1,67 @@
+package games.dmg.spigotquestboard;
+
+import java.util.ArrayList;
+import java.util.LinkedHashSet;
+import java.util.List;
+import java.util.Objects;
+import java.util.Set;
+
+record PhysicalBoardPlan(
+    BoardFacing facing,
+    List<Placement> placements,
+    Set<BoardId> interactionLocations
+) {
+    PhysicalBoardPlan {
+        Objects.requireNonNull(facing, "facing");
+        placements = List.copyOf(Objects.requireNonNull(placements, "placements"));
+        interactionLocations = Set.copyOf(Objects.requireNonNull(
+            interactionLocations, "interactionLocations"
+        ));
+    }
+
+    static PhysicalBoardPlan create(BoardId anchor, BoardFacing facing) {
+        Objects.requireNonNull(anchor, "anchor");
+        Objects.requireNonNull(facing, "facing");
+        List<Placement> placements = new ArrayList<>(23);
+        Set<BoardId> interactions = new LinkedHashSet<>(15);
+
+        for (int height = 1; height <= 4; height++) {
+            for (int lateral = -2; lateral <= 2; lateral++) {
+                BoardId location = offset(anchor, facing, lateral, height, 0);
+                String material = Math.abs(lateral) == 2 ? "OAK_LOG" : "OAK_PLANKS";
+                placements.add(new Placement(location, material));
+                if ("OAK_PLANKS".equals(material)) {
+                    interactions.add(location);
+                }
+            }
+        }
+        for (int lateral = -1; lateral <= 1; lateral++) {
+            BoardId location = offset(anchor, facing, lateral, 2, 1);
+            placements.add(new Placement(location, "OAK_WALL_SIGN"));
+            interactions.add(location);
+        }
+        return new PhysicalBoardPlan(facing, placements, interactions);
+    }
+
+    private static BoardId offset(
+        BoardId anchor, BoardFacing facing, int lateral, int vertical, int forward
+    ) {
+        return new BoardId(
+            anchor.worldId(),
+            anchor.x() + lateral * facing.rightX() + forward * facing.x(),
+            anchor.y() + vertical,
+            anchor.z() + lateral * facing.rightZ() + forward * facing.z()
+        );
+    }
+
+    record Placement(BoardId location, String material) {
+        Placement {
+            Objects.requireNonNull(location, "location");
+            Objects.requireNonNull(material, "material");
+        }
+
+        boolean sign() {
+            return "OAK_WALL_SIGN".equals(material);
+        }
+    }
+}

src/main/java/games/dmg/spigotquestboard/PhysicalBoardWorld.java

@@ -0,0 +1,11 @@
+package games.dmg.spigotquestboard;
+
+interface PhysicalBoardWorld {
+    boolean isEmpty(BoardId location);
+
+    Object snapshot(BoardId location);
+
+    void place(PhysicalBoardPlan.Placement placement, BoardFacing facing);
+
+    void restore(BoardId location, Object snapshot);
+}

src/main/java/games/dmg/spigotquestboard/QuestAdminCommand.java

@@ -15,10 +15,26 @@ final class QuestAdminCommand implements CommandExecutor, TabCompleter {
     private static final String PERMISSION = "spigotquestboard.admin";
     private final BoardRegistry registry;
     private final PlayerCommandSettings playerCommands;
+    private final PhysicalBoardCreator physicalBoards;
 
     QuestAdminCommand(BoardRegistry registry, PlayerCommandSettings playerCommands) {
+        this(
+            registry,
+            playerCommands,
+            new PhysicalBoardCreator(
+                registry, anchor -> new BukkitPhysicalBoardWorld(anchor.getWorld())
+            )
+        );
+    }
+
+    QuestAdminCommand(
+        BoardRegistry registry,
+        PlayerCommandSettings playerCommands,
+        PhysicalBoardCreator physicalBoards
+    ) {
         this.registry = Objects.requireNonNull(registry, "registry");
         this.playerCommands = Objects.requireNonNull(playerCommands, "playerCommands");
+        this.physicalBoards = Objects.requireNonNull(physicalBoards, "physicalBoards");
     }
 
     @Override
@@ -32,13 +48,19 @@ final class QuestAdminCommand implements CommandExecutor, TabCompleter {
         if (arguments.length == 2 && "commands".equalsIgnoreCase(arguments[0])) {
             return updatePlayerCommands(sender, arguments[1]);
         }
-        if (arguments.length != 1 || !"createboard".equalsIgnoreCase(arguments[0])) {
+        if (arguments.length == 1 && "createboard".equalsIgnoreCase(arguments[0])) {
-            sender.sendMessage(
+            createBoard(sender);
-                "Usage: /questadmin createboard | /questadmin commands enable|disable"
-            );
             return true;
         }
-        createBoard(sender);
+        if (arguments.length == 2
+            && "createboard".equalsIgnoreCase(arguments[0])
+            && "physical".equalsIgnoreCase(arguments[1])) {
+            createPhysicalBoard(sender);
+            return true;
+        }
+        sender.sendMessage(
+            "Usage: /questadmin createboard [physical] | /questadmin commands enable|disable"
+        );
         return true;
     }
 
@@ -84,6 +106,36 @@ final class QuestAdminCommand implements CommandExecutor, TabCompleter {
         }
     }
 
+    private void createPhysicalBoard(CommandSender sender) {
+        if (!(sender instanceof Player player)) {
+            sender.sendMessage("A player must target the ground anchor block.");
+            return;
+        }
+        Block target = player.getTargetBlockExact(5);
+        if (target == null) {
+            sender.sendMessage("Target a ground anchor within five blocks.");
+            return;
+        }
+        try {
+            PhysicalBoardCreationResult result = physicalBoards.create(
+                target, BoardFacing.towardPlayer(player.getFacing())
+            );
+            switch (result) {
+                case CREATED -> sender.sendMessage("Physical quest board created.");
+                case OBSTRUCTED -> sender.sendMessage(
+                    "The physical quest board needs 23 empty placement blocks."
+                );
+                case ALREADY_REGISTERED -> sender.sendMessage(
+                    "A physical quest-board interaction location is already registered."
+                );
+            }
+        } catch (IOException | IllegalArgumentException exception) {
+            sender.sendMessage(
+                "The physical quest board could not be created. All changed blocks were restored."
+            );
+        }
+    }
+
     @Override
     public List<String> onTabComplete(
         CommandSender sender, Command command, String alias, String[] arguments
@@ -97,6 +149,9 @@ final class QuestAdminCommand implements CommandExecutor, TabCompleter {
         if (arguments.length == 2 && "commands".equalsIgnoreCase(arguments[0])) {
             return startsWith(List.of("enable", "disable"), arguments[1]);
         }
+        if (arguments.length == 2 && "createboard".equalsIgnoreCase(arguments[0])) {
+            return startsWith(List.of("physical"), arguments[1]);
+        }
         return List.of();
     }
 

src/main/java/games/dmg/spigotquestboard/QuestBoardDialogSpec.java

@@ -0,0 +1,87 @@
+package games.dmg.spigotquestboard;
+
+import java.util.List;
+import java.util.Objects;
+
+/** A server-independent description of the quest-board dialog hierarchy. */
+record QuestBoardDialogSpec(
+    int maximumBodyWidth,
+    Screen dashboard,
+    Screen browse,
+    Screen create,
+    Screen claims,
+    List<QuestEntry> questEntries
+) {
+    QuestBoardDialogSpec {
+        if (maximumBodyWidth <= 0) {
+            throw new IllegalArgumentException("Maximum body width must be positive");
+        }
+        Objects.requireNonNull(dashboard, "dashboard");
+        Objects.requireNonNull(browse, "browse");
+        Objects.requireNonNull(create, "create");
+        Objects.requireNonNull(claims, "claims");
+        questEntries = List.copyOf(Objects.requireNonNull(questEntries, "questEntries"));
+    }
+
+    List<String> dashboardActions() {
+        return dashboard.actions().stream().map(Action::label).toList();
+    }
+
+    record Screen(
+        String title,
+        String externalTitle,
+        String message,
+        List<Action> actions,
+        List<Input> inputs,
+        boolean hasBackAction
+    ) {
+        Screen {
+            Objects.requireNonNull(title, "title");
+            Objects.requireNonNull(externalTitle, "externalTitle");
+            Objects.requireNonNull(message, "message");
+            actions = List.copyOf(Objects.requireNonNull(actions, "actions"));
+            inputs = List.copyOf(Objects.requireNonNull(inputs, "inputs"));
+        }
+    }
+
+    record QuestEntry(
+        String title,
+        String message,
+        List<Action> actions,
+        boolean hasBackAction
+    ) {
+        QuestEntry {
+            Objects.requireNonNull(title, "title");
+            Objects.requireNonNull(message, "message");
+            actions = List.copyOf(Objects.requireNonNull(actions, "actions"));
+        }
+    }
+
+    record Action(String label, Route route, String questId) {
+        Action {
+            Objects.requireNonNull(label, "label");
+            Objects.requireNonNull(route, "route");
+        }
+    }
+
+    record Input(String key, String label, String initial, int maximumLength) {
+        Input {
+            Objects.requireNonNull(key, "key");
+            Objects.requireNonNull(label, "label");
+            Objects.requireNonNull(initial, "initial");
+            if (maximumLength <= 0) {
+                throw new IllegalArgumentException("Maximum input length must be positive");
+            }
+        }
+    }
+
+    enum Route {
+        OPEN_BROWSE,
+        OPEN_CREATE,
+        OPEN_CLAIMS,
+        SUBMIT_CREATE,
+        COMPLETE,
+        CANCEL,
+        COLLECT
+    }
+}

src/main/java/games/dmg/spigotquestboard/QuestBoardDialogUi.java

@@ -1,16 +1,17 @@
 package games.dmg.spigotquestboard;
 
 import io.papermc.paper.dialog.Dialog;
+import io.papermc.paper.registry.RegistryKey;
 import io.papermc.paper.registry.data.dialog.ActionButton;
 import io.papermc.paper.registry.data.dialog.DialogBase;
 import io.papermc.paper.registry.data.dialog.action.DialogAction;
 import io.papermc.paper.registry.data.dialog.body.DialogBody;
 import io.papermc.paper.registry.data.dialog.input.DialogInput;
 import io.papermc.paper.registry.data.dialog.type.DialogType;
+import io.papermc.paper.registry.set.RegistrySet;
 import java.io.IOException;
 import java.time.Clock;
 import java.time.Duration;
-import java.util.ArrayList;
 import java.util.List;
 import java.util.Objects;
 import net.kyori.adventure.text.Component;
@@ -18,6 +19,12 @@ import net.kyori.adventure.text.event.ClickCallback;
 import org.bukkit.entity.Player;
 
 final class QuestBoardDialogUi implements QuestBoardUi {
+    private static final int DIALOG_WIDTH = 420;
+    private static final ClickCallback.Options CALLBACK_OPTIONS = ClickCallback.Options.builder()
+        .uses(1)
+        .lifetime(Duration.ofMinutes(10))
+        .build();
+
     private final QuestCreationGateway creator;
     private final QuestBrowser browser;
     private final QuestCompletionGateway completer;
@@ -66,9 +73,131 @@ final class QuestBoardDialogUi implements QuestBoardUi {
 
     @Override
     public void open(Player player) {
+        Objects.requireNonNull(player, "player");
+        player.showDialog(renderDashboard(specification(player), player));
+    }
+
+    QuestBoardDialogSpec specification(Player player) {
+        Objects.requireNonNull(player, "player");
+        java.time.Instant now = clock.instant();
+        List<QuestBoardDialogSpec.QuestEntry> entries = browser.activeQuests(now).stream()
+            .map(quest -> questEntry(quest, player, now))
+            .toList();
+        List<QuestBoardDialogSpec.Action> dashboardActions = List.of(
+            action("Browse quests", QuestBoardDialogSpec.Route.OPEN_BROWSE),
+            action("Create quest", QuestBoardDialogSpec.Route.OPEN_CREATE),
+            action("Pending claims", QuestBoardDialogSpec.Route.OPEN_CLAIMS)
+        );
+        QuestBoardDialogSpec.Screen dashboard = new QuestBoardDialogSpec.Screen(
+            "Quest Board",
+            "Quest Board",
+            "Choose what you want to do.",
+            dashboardActions,
+            List.of(),
+            false
+        );
+        QuestBoardDialogSpec.Screen browse = new QuestBoardDialogSpec.Screen(
+            "Browse Quests",
+            "Browse quests",
+            entries.isEmpty()
+                ? "No active quests."
+                : "Select a quest to view its request, reward, issuer, and time remaining.",
+            List.of(),
+            List.of(),
+            true
+        );
+        QuestBoardDialogSpec.Screen create = new QuestBoardDialogSpec.Screen(
+            "Create Quest",
+            "Create quest",
+            "Hold the reward in your main hand. The entire exact stack, including all item "
+                + "metadata, is escrowed only if the quest saves successfully.",
+            List.of(action("Create quest", QuestBoardDialogSpec.Route.SUBMIT_CREATE)),
+            List.of(
+                new QuestBoardDialogSpec.Input("requested_material", "Requested block", "", 64),
+                new QuestBoardDialogSpec.Input("requested_quantity", "Quantity", "64", 10)
+            ),
+            true
+        );
+        QuestBoardDialogSpec.Screen claims = new QuestBoardDialogSpec.Screen(
+            "Pending Claims",
+            "Pending claims",
+            claimListingText(player),
+            claimant == null
+                ? List.of()
+                : List.of(action("Collect pending claims", QuestBoardDialogSpec.Route.COLLECT)),
+            List.of(),
+            true
+        );
+        return new QuestBoardDialogSpec(
+            DIALOG_WIDTH, dashboard, browse, create, claims, entries
+        );
+    }
+
+    private QuestBoardDialogSpec.QuestEntry questEntry(
+        Quest quest,
+        Player player,
+        java.time.Instant now
+    ) {
+        List<QuestBoardDialogSpec.Action> actions = new java.util.ArrayList<>();
+        if (completer != null) {
+            actions.add(new QuestBoardDialogSpec.Action(
+                "Complete quest", QuestBoardDialogSpec.Route.COMPLETE, quest.id().toString()
+            ));
+        }
+        if (canceller != null && quest.issuerId().equals(player.getUniqueId())) {
+            actions.add(new QuestBoardDialogSpec.Action(
+                "Cancel quest", QuestBoardDialogSpec.Route.CANCEL, quest.id().toString()
+            ));
+        }
+        return new QuestBoardDialogSpec.QuestEntry(
+            quest.requestedAmount() + " × " + quest.requestedMaterial(),
+            QuestListingFormatter.format(quest, now),
+            actions,
+            true
+        );
+    }
+
+    private static QuestBoardDialogSpec.Action action(
+        String label,
+        QuestBoardDialogSpec.Route route
+    ) {
+        return new QuestBoardDialogSpec.Action(label, route, null);
+    }
+
+    private Dialog renderDashboard(QuestBoardDialogSpec specification, Player player) {
+        List<Dialog> screens = List.of(
+            renderBrowse(specification, player),
+            renderCreate(specification, player),
+            renderClaims(specification, player)
+        );
+        return dialog(
+            specification.dashboard(),
+            DialogType.dialogList(
+                RegistrySet.valueSet(RegistryKey.DIALOG, screens), null, 1, 260
+            )
+        );
+    }
+
+    private Dialog renderBrowse(QuestBoardDialogSpec specification, Player player) {
+        ActionButton back = backToDashboard(player);
+        if (specification.questEntries().isEmpty()) {
+            return dialog(specification.browse(), DialogType.notice(back));
+        }
+        List<Dialog> quests = specification.questEntries().stream()
+            .map(entry -> renderQuest(entry, player))
+            .toList();
+        return dialog(
+            specification.browse(),
+            DialogType.dialogList(
+                RegistrySet.valueSet(RegistryKey.DIALOG, quests), back, 1, 260
+            )
+        );
+    }
+
+    private Dialog renderCreate(QuestBoardDialogSpec specification, Player player) {
         ActionButton create = ActionButton.builder(Component.text("Create quest"))
             .tooltip(Component.text("Escrow your held stack and publish this quest"))
-            .width(150)
+            .width(180)
             .action(DialogAction.customClick((response, audience) -> {
                 if (audience instanceof Player respondingPlayer) {
                     submit(
@@ -77,64 +206,111 @@ final class QuestBoardDialogUi implements QuestBoardUi {
                         response.getText("requested_quantity")
                     );
                 }
-            }, ClickCallback.Options.builder()
+            }, CALLBACK_OPTIONS))
-                .uses(1)
-                .lifetime(Duration.ofMinutes(10))
-                .build()))
             .build();
-        java.time.Instant now = clock.instant();
+        return dialog(
-        List<Quest> activeQuests = browser.activeQuests(now);
+            specification.create(),
-        String listing = QuestListingFormatter.formatAll(activeQuests, now);
+            DialogType.multiAction(List.of(create), backToDashboard(player), 1)
-        String claimListing = claimListingText(player);
+        );
-        List<ActionButton> actions = new ArrayList<>();
+    }
-        actions.add(create);
+
-        if (claimant != null) {
+    private Dialog renderClaims(QuestBoardDialogSpec specification, Player player) {
-            actions.add(ActionButton.builder(Component.text("Collect pending claims"))
+        ActionButton back = backToDashboard(player);
-                .tooltip(Component.text("Collect delivered blocks and returned rewards"))
+        if (claimant == null) {
-                .width(250)
+            return dialog(specification.claims(), DialogType.notice(back));
-                .action(DialogAction.customClick((response, audience) -> {
-                    if (audience instanceof Player respondingPlayer) {
-                        submitClaim(respondingPlayer);
-                    }
-                }, ClickCallback.Options.builder()
-                    .uses(1)
-                    .lifetime(Duration.ofMinutes(10))
-                    .build()))
-                .build());
         }
-        for (Quest quest : activeQuests) {
+        ActionButton collect = callbackButton(
-            if (completer != null) {
+            "Collect pending claims",
-                actions.add(completionButton(quest));
+            "Collect delivered blocks and returned rewards",
-            }
+            250,
-            if (canceller != null && quest.issuerId().equals(player.getUniqueId())) {
+            respondingPlayer -> submitClaim(respondingPlayer)
-                actions.add(cancellationButton(quest));
+        );
-            }
+        return dialog(
-        }
+            specification.claims(), DialogType.multiAction(List.of(collect), back, 1)
-        DialogBase base = DialogBase.builder(Component.text("Quest Board"))
+        );
-            .externalTitle(Component.text("Quest Board — Active quests and create"))
+    }
-            .body(List.of(DialogBody.plainMessage(Component.text(
+
-                "ACTIVE QUESTS\n" + listing + "\n\nYOUR PENDING CLAIMS\n" + claimListing
+    private Dialog renderQuest(QuestBoardDialogSpec.QuestEntry entry, Player player) {
-                    + "\n\nCREATE A QUEST\n"
+        QuestBoardDialogSpec.Screen screen = new QuestBoardDialogSpec.Screen(
-                    + "Hold the reward in your main hand. The entire exact stack, including all item metadata, "
+            entry.title(), entry.title(), entry.message(), entry.actions(), List.of(), true
-                    + "will be removed and held in escrow only if this quest saves successfully."
+        );
-            ), 800)))
+        ActionButton back = backToBrowse(player);
-            .inputs(List.of(
+        List<ActionButton> actions = entry.actions().stream()
-                DialogInput.text("requested_material", Component.text("Requested block"))
+            .map(action -> renderQuestAction(action))
-                    .initial("")
+            .toList();
-                    .maxLength(64)
+        return dialog(
-                    .build(),
+            screen,
-                DialogInput.text("requested_quantity", Component.text("Quantity"))
+            actions.isEmpty() ? DialogType.notice(back) : DialogType.multiAction(actions, back, 1)
-                    .initial("64")
+        );
-                    .maxLength(10)
+    }
-                    .build()
+
-            ))
+    private ActionButton renderQuestAction(QuestBoardDialogSpec.Action action) {
+        return switch (action.route()) {
+            case COMPLETE -> callbackButton(
+                action.label(), "Deliver the requested blocks", 180,
+                player -> submitCompletion(player, action.questId())
+            );
+            case CANCEL -> callbackButton(
+                action.label(), "Return the escrowed reward to pending claims", 180,
+                player -> submitCancellation(player, action.questId())
+            );
+            default -> throw new IllegalArgumentException("Unsupported quest action route");
+        };
+    }
+
+    private Dialog dialog(QuestBoardDialogSpec.Screen screen, DialogType type) {
+        DialogBase.Builder base = DialogBase.builder(Component.text(screen.title()))
+            .externalTitle(Component.text(screen.externalTitle()))
+            .body(List.of(DialogBody.plainMessage(Component.text(screen.message()), DIALOG_WIDTH)))
             .canCloseWithEscape(true)
             .pause(false)
-            .afterAction(DialogBase.DialogAfterAction.CLOSE)
+            .afterAction(DialogBase.DialogAfterAction.CLOSE);
+        if (!screen.inputs().isEmpty()) {
+            base.inputs(screen.inputs().stream().map(input -> DialogInput.text(
+                    input.key(), Component.text(input.label())
+                )
+                .initial(input.initial())
+                .maxLength(input.maximumLength())
+                .build()).toList());
+        }
+        DialogBase builtBase = base.build();
+        return Dialog.create(factory -> factory.empty().base(builtBase).type(type));
+    }
+
+    private ActionButton backToDashboard(Player player) {
+        return callbackButton(
+            "Back", "Return to the quest-board dashboard", 120,
+            respondingPlayer -> respondingPlayer.showDialog(
+                renderDashboard(specification(respondingPlayer), respondingPlayer)
+            )
+        );
+    }
+
+    private ActionButton backToBrowse(Player player) {
+        return callbackButton(
+            "Back", "Return to active quests", 120,
+            respondingPlayer -> {
+                QuestBoardDialogSpec current = specification(respondingPlayer);
+                respondingPlayer.showDialog(renderBrowse(current, respondingPlayer));
+            }
+        );
+    }
+
+    private ActionButton callbackButton(
+        String label,
+        String tooltip,
+        int width,
+        java.util.function.Consumer<Player> callback
+    ) {
+        return ActionButton.builder(Component.text(label))
+            .tooltip(Component.text(tooltip))
+            .width(width)
+            .action(DialogAction.customClick((response, audience) -> {
+                if (audience instanceof Player respondingPlayer) {
+                    callback.accept(respondingPlayer);
+                }
+            }, CALLBACK_OPTIONS))
             .build();
-        player.showDialog(Dialog.create(factory -> factory.empty()
-            .base(base)
-            .type(DialogType.multiAction(actions).columns(1).build())));
     }
 
     String listingText() {
@@ -161,42 +337,6 @@ final class QuestBoardDialogUi implements QuestBoardUi {
         }).reduce((left, right) -> left + "\n" + right).orElseThrow();
     }
 
-    private ActionButton completionButton(Quest quest) {
-        String id = quest.id().toString();
-        return ActionButton.builder(Component.text(
-                "Complete " + quest.requestedAmount() + " " + quest.requestedMaterial()
-            ))
-            .tooltip(Component.text("Deliver blocks for quest " + id))
-            .width(250)
-            .action(DialogAction.customClick((response, audience) -> {
-                if (audience instanceof Player respondingPlayer) {
-                    submitCompletion(respondingPlayer, id);
-                }
-            }, ClickCallback.Options.builder()
-                .uses(1)
-                .lifetime(Duration.ofMinutes(10))
-                .build()))
-            .build();
-    }
-
-    private ActionButton cancellationButton(Quest quest) {
-        String id = quest.id().toString();
-        return ActionButton.builder(Component.text(
-                "Cancel " + quest.requestedAmount() + " " + quest.requestedMaterial()
-            ))
-            .tooltip(Component.text("Return the escrowed reward to claims for quest " + id))
-            .width(250)
-            .action(DialogAction.customClick((response, audience) -> {
-                if (audience instanceof Player respondingPlayer) {
-                    submitCancellation(respondingPlayer, id);
-                }
-            }, ClickCallback.Options.builder()
-                .uses(1)
-                .lifetime(Duration.ofMinutes(10))
-                .build()))
-            .build();
-    }
-
     List<String> cancellableQuestIds(Player player) {
         return browser.cancellableQuestIds(player.getUniqueId(), clock.instant());
     }

src/main/resources/plugin.yml

@@ -10,7 +10,7 @@ commands:
     usage: /quests [list|create|complete|cancel|claim]
   questadmin:
     description: Administer Spigot Quest Board.
-    usage: /questadmin <createboard|commands>
+    usage: /questadmin <createboard [physical]|commands>
     permission: spigotquestboard.admin
 permissions:
   spigotquestboard.admin:

src/test/java/games/dmg/spigotquestboard/BoardRegistryTest.java

@@ -26,6 +26,40 @@ final class BoardRegistryTest {
         assertEquals(Set.of(BOARD), repository.saved.boards());
     }
 
+    @Test
+    void registersManyLocationsInOneRepositorySave() throws IOException {
+        RegisteredBoard second = new RegisteredBoard(
+            new BoardId(BOARD.id().worldId(), 2, 64, 2), "world"
+        );
+        RecordingRepository repository = new RecordingRepository(BoardState.empty());
+        BoardRegistry registry = new BoardRegistry(repository);
+
+        assertEquals(
+            BoardRegistrationResult.CREATED,
+            registry.registerAll(Set.of(BOARD, second))
+        );
+
+        assertEquals(1, repository.saveCount);
+        assertEquals(Set.of(BOARD, second), repository.saved.boards());
+        assertTrue(registry.contains(BOARD.id()));
+        assertTrue(registry.contains(second.id()));
+    }
+
+    @Test
+    void duplicateInBatchPublishesAndPersistsNothing() throws IOException {
+        RegisteredBoard conflict = new RegisteredBoard(BOARD.id(), "renamed-world");
+        RecordingRepository repository = new RecordingRepository(new BoardState(Set.of(BOARD)));
+        BoardRegistry registry = new BoardRegistry(repository);
+
+        assertEquals(
+            BoardRegistrationResult.ALREADY_REGISTERED,
+            registry.registerAll(Set.of(conflict))
+        );
+
+        assertEquals(0, repository.saveCount);
+        assertEquals(1, registry.size());
+    }
+
     @Test
     void duplicateDoesNotWrite() throws IOException {
         RecordingRepository repository = new RecordingRepository(new BoardState(Set.of(BOARD)));

src/test/java/games/dmg/spigotquestboard/BukkitPhysicalBoardWorldTest.java

@@ -0,0 +1,72 @@
+package games.dmg.spigotquestboard;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.times;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
+import java.util.UUID;
+import net.kyori.adventure.text.Component;
+import net.kyori.adventure.text.format.TextDecoration;
+import org.bukkit.Material;
+import org.bukkit.World;
+import org.bukkit.block.Block;
+import org.bukkit.block.BlockState;
+import org.bukkit.block.Sign;
+import org.bukkit.block.data.type.WallSign;
+import org.bukkit.block.sign.Side;
+import org.bukkit.block.sign.SignSide;
+import org.junit.jupiter.api.Test;
+import org.mockito.ArgumentCaptor;
+
+final class BukkitPhysicalBoardWorldTest {
+    @Test
+    void configuresWallSignFacingAndDecorativeObfuscatedText() {
+        UUID worldId = UUID.randomUUID();
+        BoardId location = new BoardId(worldId, 1, 65, 2);
+        World world = mock(World.class);
+        Block block = mock(Block.class);
+        WallSign wallSign = mock(WallSign.class);
+        Sign sign = mock(Sign.class);
+        SignSide signSide = mock(SignSide.class);
+        when(world.getUID()).thenReturn(worldId);
+        when(world.getBlockAt(1, 65, 2)).thenReturn(block);
+        when(block.getBlockData()).thenReturn(wallSign);
+        when(block.getState()).thenReturn(sign);
+        when(sign.getSide(Side.FRONT)).thenReturn(signSide);
+        when(sign.update(true, false)).thenReturn(true);
+        BukkitPhysicalBoardWorld adapter = new BukkitPhysicalBoardWorld(world);
+
+        adapter.place(
+            new PhysicalBoardPlan.Placement(location, "OAK_WALL_SIGN"),
+            BoardFacing.NORTH
+        );
+
+        verify(block).setType(Material.OAK_WALL_SIGN, false);
+        verify(wallSign).setFacing(org.bukkit.block.BlockFace.NORTH);
+        verify(block).setBlockData(wallSign, false);
+        ArgumentCaptor<Component> text = ArgumentCaptor.forClass(Component.class);
+        verify(signSide, times(4)).line(any(Integer.class), text.capture());
+        assertEquals(4, text.getAllValues().size());
+        assertTrue(text.getAllValues().stream().allMatch(component ->
+            component.decoration(TextDecoration.OBFUSCATED) == TextDecoration.State.TRUE
+        ));
+    }
+
+    @Test
+    void restoresCapturedBukkitBlockState() {
+        UUID worldId = UUID.randomUUID();
+        BoardId location = new BoardId(worldId, 1, 65, 2);
+        World world = mock(World.class);
+        BlockState snapshot = mock(BlockState.class);
+        when(world.getUID()).thenReturn(worldId);
+        when(snapshot.update(true, false)).thenReturn(true);
+
+        new BukkitPhysicalBoardWorld(world).restore(location, snapshot);
+
+        verify(snapshot).update(true, false);
+    }
+}

src/test/java/games/dmg/spigotquestboard/PhysicalBoardCreatorTest.java

@@ -0,0 +1,161 @@
+package games.dmg.spigotquestboard;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
+
+import java.io.IOException;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Set;
+import java.util.UUID;
+import org.bukkit.World;
+import org.bukkit.block.Block;
+import org.junit.jupiter.api.Test;
+
+final class PhysicalBoardCreatorTest {
+    private static final UUID WORLD_ID = UUID.fromString(
+        "00000000-0000-0000-0000-000000000010"
+    );
+    private static final BoardId ANCHOR = new BoardId(WORLD_ID, 10, 64, 20);
+
+    @Test
+    void buildsAndAtomicallyRegistersEveryVisiblePanelBlock() throws Exception {
+        RecordingRepository repository = new RecordingRepository(false);
+        BoardRegistry registry = new BoardRegistry(repository);
+        FakeWorld world = new FakeWorld();
+        PhysicalBoardCreator creator = creator(registry, world);
+
+        assertEquals(
+            PhysicalBoardCreationResult.CREATED,
+            creator.create(anchorBlock(), BoardFacing.NORTH)
+        );
+
+        assertEquals(23, world.placed.size());
+        assertEquals("AIR", world.materials.getOrDefault(ANCHOR, "AIR"));
+        assertEquals(15, registry.size());
+        assertEquals(15, repository.state.boards().size());
+        assertEquals(1, repository.saves);
+        assertTrue(repository.state.boards().stream().allMatch(
+            board -> board.worldName().equals("survival")
+        ));
+    }
+
+    @Test
+    void obstructionPreflightChangesAndRegistersNothing() throws Exception {
+        RecordingRepository repository = new RecordingRepository(false);
+        BoardRegistry registry = new BoardRegistry(repository);
+        FakeWorld world = new FakeWorld();
+        BoardId obstruction = PhysicalBoardPlan.create(ANCHOR, BoardFacing.EAST)
+            .placements().get(7).location();
+        world.materials.put(obstruction, "STONE");
+
+        assertEquals(
+            PhysicalBoardCreationResult.OBSTRUCTED,
+            creator(registry, world).create(anchorBlock(), BoardFacing.EAST)
+        );
+
+        assertTrue(world.placed.isEmpty());
+        assertEquals("STONE", world.materials.get(obstruction));
+        assertEquals(0, repository.saves);
+        assertEquals(0, registry.size());
+    }
+
+    @Test
+    void placementFailureRestoresEveryChangedBlockAndRegistersNothing() throws Exception {
+        RecordingRepository repository = new RecordingRepository(false);
+        BoardRegistry registry = new BoardRegistry(repository);
+        FakeWorld world = new FakeWorld();
+        world.failPlacement = 11;
+
+        assertThrows(IOException.class, () -> creator(registry, world).create(
+            anchorBlock(), BoardFacing.SOUTH
+        ));
+
+        assertTrue(world.materials.values().stream().allMatch("AIR"::equals));
+        assertEquals(0, repository.saves);
+        assertEquals(0, registry.size());
+    }
+
+    @Test
+    void persistenceFailureRestoresWholeStructureAndPublishesNothing() throws Exception {
+        RecordingRepository repository = new RecordingRepository(true);
+        BoardRegistry registry = new BoardRegistry(repository);
+        FakeWorld world = new FakeWorld();
+
+        assertThrows(IOException.class, () -> creator(registry, world).create(
+            anchorBlock(), BoardFacing.WEST
+        ));
+
+        assertTrue(world.materials.values().stream().allMatch("AIR"::equals));
+        assertEquals(1, repository.saves);
+        assertEquals(0, registry.size());
+    }
+
+    private static PhysicalBoardCreator creator(BoardRegistry registry, FakeWorld world) {
+        return new PhysicalBoardCreator(registry, ignored -> world);
+    }
+
+    private static Block anchorBlock() {
+        World world = mock(World.class);
+        when(world.getUID()).thenReturn(WORLD_ID);
+        when(world.getName()).thenReturn("survival");
+        Block block = mock(Block.class);
+        when(block.getWorld()).thenReturn(world);
+        when(block.getX()).thenReturn(ANCHOR.x());
+        when(block.getY()).thenReturn(ANCHOR.y());
+        when(block.getZ()).thenReturn(ANCHOR.z());
+        return block;
+    }
+
+    private static final class FakeWorld implements PhysicalBoardWorld {
+        private final Map<BoardId, String> materials = new HashMap<>();
+        private final Map<BoardId, String> placed = new HashMap<>();
+        private int placements;
+        private int failPlacement = -1;
+
+        @Override public boolean isEmpty(BoardId location) {
+            return "AIR".equals(materials.getOrDefault(location, "AIR"));
+        }
+
+        @Override public Object snapshot(BoardId location) {
+            return materials.getOrDefault(location, "AIR");
+        }
+
+        @Override public void place(PhysicalBoardPlan.Placement placement, BoardFacing facing) {
+            if (placements++ == failPlacement) {
+                throw new IllegalStateException("simulated sign configuration failure");
+            }
+            materials.put(placement.location(), placement.material());
+            placed.put(placement.location(), placement.material());
+        }
+
+        @Override public void restore(BoardId location, Object snapshot) {
+            materials.put(location, (String) snapshot);
+        }
+    }
+
+    private static final class RecordingRepository implements BoardRepository {
+        private BoardState state = new BoardState(Set.of());
+        private final boolean failSave;
+        private int saves;
+
+        private RecordingRepository(boolean failSave) {
+            this.failSave = failSave;
+        }
+
+        @Override public BoardState load() {
+            return state;
+        }
+
+        @Override public void save(BoardState state) throws IOException {
+            saves++;
+            if (failSave) {
+                throw new IOException("disk full");
+            }
+            this.state = state;
+        }
+    }
+}

src/test/java/games/dmg/spigotquestboard/PhysicalBoardPlanTest.java

@@ -0,0 +1,90 @@
+package games.dmg.spigotquestboard;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+import java.util.HashSet;
+import java.util.UUID;
+import org.junit.jupiter.api.Test;
+
+final class PhysicalBoardPlanTest {
+    @Test
+    void createsFiveWideFourTallOakBoardAboveGroundAnchor() {
+        BoardId anchor = new BoardId(UUID.randomUUID(), 0, 64, 0);
+
+        PhysicalBoardPlan plan = PhysicalBoardPlan.create(anchor, BoardFacing.NORTH);
+
+        assertEquals(8, plan.placements().stream()
+            .filter(block -> block.material().equals("OAK_LOG")).count());
+        assertEquals(12, plan.placements().stream()
+            .filter(block -> block.material().equals("OAK_PLANKS")).count());
+        assertEquals(3, plan.placements().stream()
+            .filter(block -> block.material().equals("OAK_WALL_SIGN")).count());
+        assertEquals(15, plan.interactionLocations().size());
+        assertFalse(plan.placements().stream().anyMatch(block -> block.location().equals(anchor)));
+        assertEquals(-2, plan.placements().stream().mapToInt(block -> block.location().x()).min().orElseThrow());
+        assertEquals(2, plan.placements().stream().mapToInt(block -> block.location().x()).max().orElseThrow());
+        assertEquals(65, plan.placements().stream().mapToInt(block -> block.location().y()).min().orElseThrow());
+        assertEquals(68, plan.placements().stream().mapToInt(block -> block.location().y()).max().orElseThrow());
+    }
+
+    @Test
+    void rotatesWidthAndFrontMountedSignsForEveryFacing() {
+        BoardId anchor = new BoardId(UUID.randomUUID(), 10, 64, 20);
+
+        for (BoardFacing facing : BoardFacing.values()) {
+            PhysicalBoardPlan plan = PhysicalBoardPlan.create(anchor, facing);
+            assertEquals(23, plan.placements().size());
+            assertEquals(23, new HashSet<>(plan.placements().stream()
+                .map(PhysicalBoardPlan.Placement::location).toList()).size());
+
+            var backing = plan.placements().stream().filter(
+                placement -> !placement.sign()
+            ).toList();
+            assertEquals(20, backing.size());
+            assertTrue(backing.stream().allMatch(placement ->
+                forward(anchor, placement.location(), facing) == 0
+                    && Math.abs(lateral(anchor, placement.location(), facing)) <= 2
+                    && placement.location().y() >= anchor.y() + 1
+                    && placement.location().y() <= anchor.y() + 4
+            ));
+
+            var signs = plan.placements().stream().filter(
+                PhysicalBoardPlan.Placement::sign
+            ).toList();
+            assertEquals(3, signs.size());
+            assertTrue(signs.stream().allMatch(sign ->
+                forward(anchor, sign.location(), facing) == 1
+                    && Math.abs(lateral(anchor, sign.location(), facing)) <= 1
+                    && sign.location().y() == anchor.y() + 2
+            ));
+            assertEquals(15, plan.interactionLocations().size());
+            assertTrue(plan.interactionLocations().containsAll(signs.stream()
+                .map(PhysicalBoardPlan.Placement::location).toList()));
+            assertTrue(backing.stream()
+                .filter(placement -> placement.material().equals("OAK_PLANKS"))
+                .allMatch(placement -> plan.interactionLocations().contains(
+                    placement.location()
+                )));
+        }
+    }
+
+    private static int forward(BoardId anchor, BoardId location, BoardFacing facing) {
+        return (location.x() - anchor.x()) * facing.x()
+            + (location.z() - anchor.z()) * facing.z();
+    }
+
+    private static int lateral(BoardId anchor, BoardId location, BoardFacing facing) {
+        return (location.x() - anchor.x()) * facing.rightX()
+            + (location.z() - anchor.z()) * facing.rightZ();
+    }
+
+    @Test
+    void boardFrontFacesOppositeTheAdministratorsLookDirection() {
+        assertEquals(BoardFacing.SOUTH, BoardFacing.towardPlayer(org.bukkit.block.BlockFace.NORTH));
+        assertEquals(BoardFacing.WEST, BoardFacing.towardPlayer(org.bukkit.block.BlockFace.EAST));
+        assertEquals(BoardFacing.NORTH, BoardFacing.towardPlayer(org.bukkit.block.BlockFace.SOUTH));
+        assertEquals(BoardFacing.EAST, BoardFacing.towardPlayer(org.bukkit.block.BlockFace.WEST));
+    }
+}

src/test/java/games/dmg/spigotquestboard/QuestAdminCommandTest.java

@@ -12,7 +12,9 @@ import java.io.IOException;
 import java.util.List;
 import java.util.Set;
 import java.util.UUID;
+import java.util.concurrent.atomic.AtomicInteger;
 import org.bukkit.World;
+import org.bukkit.block.BlockFace;
 import org.bukkit.block.Block;
 import org.bukkit.command.Command;
 import org.bukkit.command.CommandSender;
@@ -126,9 +128,12 @@ final class QuestAdminCommandTest {
         assertEquals(List.of("disable"), executor.onTabComplete(
             authorized, command, "questadmin", new String[] {"commands", "di"}
         ));
-        assertTrue(executor.onTabComplete(
+        assertEquals(List.of("physical"), executor.onTabComplete(
             authorized, command, "questadmin", new String[] {"createboard", ""}
-        ).isEmpty());
+        ));
+        assertEquals(List.of("physical"), executor.onTabComplete(
+            authorized, command, "questadmin", new String[] {"createboard", "phy"}
+        ));
         assertTrue(executor.onTabComplete(
             unauthorized, command, "questadmin", new String[] {""}
         ).isEmpty());
@@ -161,6 +166,95 @@ final class QuestAdminCommandTest {
         )));
     }
 
+    @Test
+    void physicalArgumentBuildsAndRegistersAllInteractionLocations() throws Exception {
+        MemoryBoardRepository repository = new MemoryBoardRepository();
+        BoardRegistry registry = new BoardRegistry(repository);
+        AtomicInteger placements = new AtomicInteger();
+        PhysicalBoardWorld worldAdapter = new PhysicalBoardWorld() {
+            @Override public boolean isEmpty(BoardId location) { return true; }
+            @Override public Object snapshot(BoardId location) { return "AIR"; }
+            @Override public void place(
+                PhysicalBoardPlan.Placement placement, BoardFacing facing
+            ) {
+                assertEquals(BoardFacing.SOUTH, facing);
+                placements.incrementAndGet();
+            }
+            @Override public void restore(BoardId location, Object snapshot) { }
+        };
+        QuestAdminCommand executor = new QuestAdminCommand(
+            registry,
+            new PlayerCommandSettings(new MemoryPlayerCommandSettingsRepository()),
+            new PhysicalBoardCreator(registry, ignored -> worldAdapter)
+        );
+        Player player = mock(Player.class);
+        Block anchor = mock(Block.class);
+        World world = mock(World.class);
+        UUID worldId = UUID.randomUUID();
+        when(player.hasPermission("spigotquestboard.admin")).thenReturn(true);
+        when(player.getTargetBlockExact(5)).thenReturn(anchor);
+        when(player.getFacing()).thenReturn(BlockFace.NORTH);
+        when(anchor.getWorld()).thenReturn(world);
+        when(world.getUID()).thenReturn(worldId);
+        when(world.getName()).thenReturn("world");
+        when(anchor.getX()).thenReturn(3);
+        when(anchor.getY()).thenReturn(70);
+        when(anchor.getZ()).thenReturn(4);
+
+        assertTrue(executor.onCommand(
+            player, mock(Command.class), "questadmin",
+            new String[] {"createboard", "physical"}
+        ));
+
+        assertEquals(23, placements.get());
+        assertEquals(15, repository.state.boards().size());
+        verify(player).sendMessage("Physical quest board created.");
+    }
+
+    @Test
+    void physicalBoardObstructionIsReportedWithoutRegistration() throws Exception {
+        MemoryBoardRepository repository = new MemoryBoardRepository();
+        BoardRegistry registry = new BoardRegistry(repository);
+        PhysicalBoardWorld obstructedWorld = new PhysicalBoardWorld() {
+            @Override public boolean isEmpty(BoardId location) { return false; }
+            @Override public Object snapshot(BoardId location) {
+                throw new AssertionError("obstructed generation must not snapshot");
+            }
+            @Override public void place(
+                PhysicalBoardPlan.Placement placement, BoardFacing facing
+            ) {
+                throw new AssertionError("obstructed generation must not place");
+            }
+            @Override public void restore(BoardId location, Object snapshot) {
+                throw new AssertionError("obstructed generation must not restore");
+            }
+        };
+        QuestAdminCommand executor = new QuestAdminCommand(
+            registry,
+            new PlayerCommandSettings(new MemoryPlayerCommandSettingsRepository()),
+            new PhysicalBoardCreator(registry, ignored -> obstructedWorld)
+        );
+        Player player = mock(Player.class);
+        Block anchor = mock(Block.class);
+        World world = mock(World.class);
+        when(player.hasPermission("spigotquestboard.admin")).thenReturn(true);
+        when(player.getTargetBlockExact(5)).thenReturn(anchor);
+        when(player.getFacing()).thenReturn(BlockFace.SOUTH);
+        when(anchor.getWorld()).thenReturn(world);
+        when(world.getUID()).thenReturn(UUID.randomUUID());
+        when(world.getName()).thenReturn("world");
+
+        executor.onCommand(
+            player, mock(Command.class), "questadmin",
+            new String[] {"createboard", "physical"}
+        );
+
+        assertTrue(repository.state.boards().isEmpty());
+        verify(player).sendMessage(
+            "The physical quest board needs 23 empty placement blocks."
+        );
+    }
+
     @Test
     void consoleAndMissingTargetDoNotChangeState() throws Exception {
         MemoryBoardRepository repository = new MemoryBoardRepository();

src/test/java/games/dmg/spigotquestboard/QuestBoardDialogUiTest.java

@@ -1,8 +1,11 @@
 package games.dmg.spigotquestboard;
 
 import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertTrue;
 import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
 
 import java.io.IOException;
 import java.time.Clock;
@@ -16,6 +19,144 @@ import org.junit.jupiter.api.Test;
 final class QuestBoardDialogUiTest {
     private static final Instant NOW = Instant.parse("2026-09-05T03:00:00Z");
 
+    @Test
+    void dashboardUsesCompactDedicatedNavigableScreens() {
+        RecordingCreator creator = new RecordingCreator(false);
+        QuestBoardDialogUi ui = new QuestBoardDialogUi(
+            creator, now -> List.of(creator.quest(NOW)), Clock.fixed(NOW, ZoneOffset.UTC)
+        );
+
+        QuestBoardDialogSpec specification = ui.specification(mock(Player.class));
+
+        assertEquals(420, specification.maximumBodyWidth());
+        assertEquals(List.of("Browse quests", "Create quest", "Pending claims"),
+            specification.dashboardActions());
+        assertEquals(1, specification.questEntries().size());
+        org.junit.jupiter.api.Assertions.assertTrue(
+            specification.questEntries().getFirst().hasBackAction()
+        );
+    }
+
+    @Test
+    void dedicatedScreensKeepContentSeparateAndProvideBackNavigation() {
+        RecordingCreator creator = new RecordingCreator(false);
+        QuestBoardDialogUi ui = new QuestBoardDialogUi(
+            creator, now -> List.of(creator.quest(NOW)), null, null, player ->
+                new ClaimCollectionResult(0, 0), Clock.fixed(NOW, ZoneOffset.UTC)
+        );
+
+        QuestBoardDialogSpec specification = ui.specification(mock(Player.class));
+
+        assertEquals("Choose what you want to do.", specification.dashboard().message());
+        assertTrue(specification.browse().message().contains("Select a quest"));
+        assertTrue(specification.create().message().contains("reward in your main hand"));
+        assertEquals("No pending claims.", specification.claims().message());
+        assertFalse(specification.dashboard().hasBackAction());
+        assertTrue(specification.browse().hasBackAction());
+        assertTrue(specification.create().hasBackAction());
+        assertTrue(specification.claims().hasBackAction());
+        assertTrue(specification.questEntries().stream().allMatch(
+            QuestBoardDialogSpec.QuestEntry::hasBackAction
+        ));
+    }
+
+    @Test
+    void questDetailsShowRequiredContentAndRouteAvailableActions() {
+        RecordingCreator creator = new RecordingCreator(false);
+        Quest quest = creator.quest(NOW);
+        Player issuer = mock(Player.class);
+        when(issuer.getUniqueId()).thenReturn(quest.issuerId());
+        QuestBoardDialogUi ui = new QuestBoardDialogUi(
+            creator, now -> List.of(quest), new RecordingCompleter(), new RecordingCanceller(),
+            null, Clock.fixed(NOW, ZoneOffset.UTC)
+        );
+
+        QuestBoardDialogSpec specification = ui.specification(issuer);
+        QuestBoardDialogSpec.QuestEntry entry = specification.questEntries().getFirst();
+
+        assertTrue(entry.message().contains("64 × STONE"));
+        assertTrue(entry.message().contains("Reward: 1 × DIAMOND"));
+        assertTrue(entry.message().contains("Issuer: Issuer"));
+        assertTrue(entry.message().contains("Time remaining: 7d"));
+        assertEquals(
+            List.of(QuestBoardDialogSpec.Route.COMPLETE, QuestBoardDialogSpec.Route.CANCEL),
+            entry.actions().stream().map(QuestBoardDialogSpec.Action::route).toList()
+        );
+        assertTrue(entry.actions().stream().allMatch(
+            action -> quest.id().toString().equals(action.questId())
+        ));
+    }
+
+    @Test
+    void dashboardCreationAndClaimsDeclareTheirActionRoutesAndInputs() {
+        RecordingCreator creator = new RecordingCreator(false);
+        QuestBoardDialogUi ui = new QuestBoardDialogUi(
+            creator, now -> List.of(), null, null, player ->
+                new ClaimCollectionResult(0, 0), Clock.fixed(NOW, ZoneOffset.UTC)
+        );
+
+        QuestBoardDialogSpec specification = ui.specification(mock(Player.class));
+
+        assertEquals(
+            List.of(
+                QuestBoardDialogSpec.Route.OPEN_BROWSE,
+                QuestBoardDialogSpec.Route.OPEN_CREATE,
+                QuestBoardDialogSpec.Route.OPEN_CLAIMS
+            ),
+            specification.dashboard().actions().stream()
+                .map(QuestBoardDialogSpec.Action::route)
+                .toList()
+        );
+        assertEquals(List.of("requested_material", "requested_quantity"),
+            specification.create().inputs().stream()
+                .map(QuestBoardDialogSpec.Input::key)
+                .toList());
+        assertEquals(QuestBoardDialogSpec.Route.SUBMIT_CREATE,
+            specification.create().actions().getFirst().route());
+        assertEquals(QuestBoardDialogSpec.Route.COLLECT,
+            specification.claims().actions().getFirst().route());
+    }
+
+    @Test
+    void largeQuestCollectionsRemainIndividualNavigableEntries() {
+        RecordingCreator creator = new RecordingCreator(false);
+        List<Quest> quests = java.util.stream.IntStream.range(0, 250)
+            .mapToObj(index -> new Quest(
+                new UUID(0, index + 100L), new UUID(0, index + 1L), "Issuer " + index,
+                "STONE", index + 1, List.of(new EscrowItem("DIAMOND", 1, null)),
+                NOW, NOW.plusSeconds(604800)
+            ))
+            .toList();
+        QuestBoardDialogUi ui = new QuestBoardDialogUi(
+            creator, now -> quests, Clock.fixed(NOW, ZoneOffset.UTC)
+        );
+
+        QuestBoardDialogSpec specification = ui.specification(mock(Player.class));
+
+        assertEquals(250, specification.questEntries().size());
+        assertTrue(specification.questEntries().stream().allMatch(
+            QuestBoardDialogSpec.QuestEntry::hasBackAction
+        ));
+        assertFalse(specification.browse().message().contains(quests.getLast().id().toString()));
+    }
+
+    @Test
+    void nonIssuersCannotReceiveCancellationRoutes() {
+        RecordingCreator creator = new RecordingCreator(false);
+        Player player = mock(Player.class);
+        when(player.getUniqueId()).thenReturn(UUID.randomUUID());
+        QuestBoardDialogUi ui = new QuestBoardDialogUi(
+            creator, now -> List.of(creator.quest(NOW)), new RecordingCompleter(),
+            new RecordingCanceller(), Clock.fixed(NOW, ZoneOffset.UTC)
+        );
+
+        QuestBoardDialogSpec.QuestEntry entry = ui.specification(player)
+            .questEntries().getFirst();
+
+        assertEquals(List.of(QuestBoardDialogSpec.Route.COMPLETE),
+            entry.actions().stream().map(QuestBoardDialogSpec.Action::route).toList());
+    }
+
     @Test
     void disabledPlayerCommandsDoNotGateBoardUiGateways() throws Exception {
         PlayerCommandSettings settings = new PlayerCommandSettings(

src/test/java/games/dmg/spigotquestboard/YamlBoardRepositoryTest.java

@@ -3,6 +3,7 @@ package games.dmg.spigotquestboard;
 import static org.junit.jupiter.api.Assertions.assertEquals;
 import static org.junit.jupiter.api.Assertions.assertTrue;
 
+import java.nio.file.Files;
 import java.nio.file.Path;
 import java.util.Set;
 import java.util.UUID;
@@ -21,6 +22,45 @@ final class YamlBoardRepositoryTest {
         assertTrue(repository.load().boards().isEmpty());
     }
 
+    @Test
+    void loadsExistingSingleLocationBoardsFileWithoutMigration() throws Exception {
+        Path path = temporaryDirectory.resolve("boards.yml");
+        Files.writeString(path, """
+            boards:
+            - world-id: 00000000-0000-0000-0000-000000000001
+              world-name: survival
+              x: 4
+              y: 70
+              z: -8
+            """);
+
+        BoardState state = new YamlBoardRepository(path).load();
+
+        assertEquals(Set.of(new RegisteredBoard(
+            new BoardId(UUID.fromString("00000000-0000-0000-0000-000000000001"), 4, 70, -8),
+            "survival"
+        )), state.boards());
+    }
+
+    @Test
+    void persistsAllGeneratedInteractionLocationsAcrossRegistryRestart() throws Exception {
+        UUID worldId = UUID.fromString("00000000-0000-0000-0000-000000000003");
+        PhysicalBoardPlan plan = PhysicalBoardPlan.create(
+            new BoardId(worldId, 10, 64, 20), BoardFacing.WEST
+        );
+        Set<RegisteredBoard> generated = plan.interactionLocations().stream()
+            .map(location -> new RegisteredBoard(location, "survival"))
+            .collect(java.util.stream.Collectors.toSet());
+        Path path = temporaryDirectory.resolve("boards.yml");
+        BoardRegistry first = new BoardRegistry(new YamlBoardRepository(path));
+
+        assertEquals(BoardRegistrationResult.CREATED, first.registerAll(generated));
+        BoardRegistry restarted = new BoardRegistry(new YamlBoardRepository(path));
+
+        assertEquals(15, restarted.size());
+        assertTrue(generated.stream().allMatch(board -> restarted.contains(board.id())));
+    }
+
     @Test
     void roundTripsWorldIdentityAndCoordinates() throws Exception {
         Path path = temporaryDirectory.resolve("boards.yml");