feat(quests): add atomic block delivery completion

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

@@ -0,0 +1,54 @@
+package games.dmg.spigotquestboard;
+
+import java.io.IOException;
+import java.util.Objects;
+import java.util.UUID;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+import org.bukkit.Server;
+import org.bukkit.entity.Player;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.Listener;
+import org.bukkit.event.player.PlayerJoinEvent;
+
+final class BukkitIssuerNotifier implements IssuerNotifier, Listener {
+    private final QuestService quests;
+    private final Server server;
+    private final Logger logger;
+
+    BukkitIssuerNotifier(QuestService quests, Server server, Logger logger) {
+        this.quests = Objects.requireNonNull(quests, "quests");
+        this.server = Objects.requireNonNull(server, "server");
+        this.logger = Objects.requireNonNull(logger, "logger");
+    }
+
+    @Override
+    public void notifyIfOnline(UUID issuerId) {
+        Player player = server.getPlayer(issuerId);
+        if (player != null && player.isOnline()) {
+            deliver(player);
+        }
+    }
+
+    @EventHandler
+    public void onPlayerJoin(PlayerJoinEvent event) {
+        deliver(event.getPlayer());
+    }
+
+    void deliver(Player player) {
+        for (IssuerNotification notification
+            : quests.pendingNotifications(player.getUniqueId())) {
+            player.sendMessage(notification.message());
+            try {
+                quests.markNotificationDelivered(notification.id());
+            } catch (IOException exception) {
+                logger.log(
+                    Level.WARNING,
+                    "Could not persist delivery of issuer notification " + notification.id()
+                        + "; it will be retried",
+                    exception
+                );
+            }
+        }
+    }
+}

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

@@ -0,0 +1,92 @@
+package games.dmg.spigotquestboard;
+
+import java.util.ArrayList;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Objects;
+import org.bukkit.Material;
+import org.bukkit.entity.Item;
+import org.bukkit.entity.Player;
+import org.bukkit.inventory.ItemStack;
+import org.bukkit.inventory.PlayerInventory;
+
+final class BukkitQuestCompletionInventory implements QuestCompletionInventory {
+    @Override
+    public RemovedDelivery remove(Player player, String materialName, int amount) {
+        Objects.requireNonNull(player, "player");
+        Material material = Objects.requireNonNull(Material.matchMaterial(materialName), "material");
+        PlayerInventory inventory = player.getInventory();
+        ItemStack[] contents = inventory.getStorageContents();
+        int available = 0;
+        for (ItemStack stack : contents) {
+            if (stack != null && stack.getType() == material) {
+                available += stack.getAmount();
+            }
+        }
+        if (available < amount) {
+            throw new IllegalArgumentException(
+                "You need exactly " + amount + " " + material.name()
+                    + " to complete this quest (you have " + available + ")."
+            );
+        }
+
+        Map<Integer, ItemStack> snapshots = new LinkedHashMap<>();
+        List<EscrowItem> removedItems = new ArrayList<>();
+        int remaining = amount;
+        for (int slot = 0; slot < contents.length && remaining > 0; slot++) {
+            ItemStack stack = contents[slot];
+            if (stack == null || stack.getType() != material) {
+                continue;
+            }
+            snapshots.put(slot, stack.clone());
+            int removedAmount = Math.min(stack.getAmount(), remaining);
+            ItemStack removed = stack.clone();
+            removed.setAmount(removedAmount);
+            removedItems.add(EscrowItem.fromItemStack(removed));
+            if (removedAmount == stack.getAmount()) {
+                inventory.clear(slot);
+            } else {
+                ItemStack reduced = stack.clone();
+                reduced.setAmount(stack.getAmount() - removedAmount);
+                inventory.setItem(slot, reduced);
+            }
+            remaining -= removedAmount;
+        }
+
+        return new RemovedDelivery() {
+            private boolean rolledBack;
+
+            @Override
+            public List<EscrowItem> items() {
+                return List.copyOf(removedItems);
+            }
+
+            @Override
+            public void rollback() {
+                if (rolledBack) {
+                    return;
+                }
+                snapshots.forEach(inventory::setItem);
+                rolledBack = true;
+            }
+        };
+    }
+
+    @Override
+    public PreparedReward prepare(List<EscrowItem> reward) {
+        List<ItemStack> stacks = reward.stream().map(EscrowItem::toItemStack).toList();
+        return player -> {
+            int overflow = 0;
+            for (ItemStack stack : stacks) {
+                Map<Integer, ItemStack> leftovers = player.getInventory().addItem(stack.clone());
+                for (ItemStack leftover : leftovers.values()) {
+                    Item dropped = player.getWorld().dropItem(player.getLocation(), leftover);
+                    dropped.setOwner(player.getUniqueId());
+                    overflow += leftover.getAmount();
+                }
+            }
+            return overflow;
+        };
+    }
+}

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

@@ -0,0 +1,23 @@
+package games.dmg.spigotquestboard;
+
+import java.time.Instant;
+import java.util.Objects;
+import java.util.UUID;
+
+record IssuerNotification(
+    UUID id,
+    UUID questId,
+    UUID recipientId,
+    String message,
+    Instant createdAt
+) {
+    IssuerNotification {
+        Objects.requireNonNull(id, "id");
+        Objects.requireNonNull(questId, "questId");
+        Objects.requireNonNull(recipientId, "recipientId");
+        if (Objects.requireNonNull(message, "message").isBlank()) {
+            throw new IllegalArgumentException("Notification message must not be blank");
+        }
+        Objects.requireNonNull(createdAt, "createdAt");
+    }
+}

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

@@ -0,0 +1,7 @@
+package games.dmg.spigotquestboard;
+
+import java.util.UUID;
+
+interface IssuerNotifier {
+    void notifyIfOnline(UUID issuerId);
+}

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

@@ -10,6 +10,7 @@ import io.papermc.paper.registry.data.dialog.type.DialogType;
 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;
@@ -19,11 +20,22 @@ import org.bukkit.entity.Player;
 final class QuestBoardDialogUi implements QuestBoardUi {
     private final QuestCreationGateway creator;
     private final QuestBrowser browser;
+    private final QuestCompletionGateway completer;
     private final Clock clock;
 
     QuestBoardDialogUi(QuestCreationGateway creator, QuestBrowser browser, Clock clock) {
+        this(creator, browser, null, clock);
+    }
+
+    QuestBoardDialogUi(
+        QuestCreationGateway creator,
+        QuestBrowser browser,
+        QuestCompletionGateway completer,
+        Clock clock
+    ) {
         this.creator = Objects.requireNonNull(creator, "creator");
         this.browser = Objects.requireNonNull(browser, "browser");
+        this.completer = completer;
         this.clock = Objects.requireNonNull(clock, "clock");
     }
 
@@ -45,7 +57,16 @@ final class QuestBoardDialogUi implements QuestBoardUi {
                 .lifetime(Duration.ofMinutes(10))
                 .build()))
             .build();
-        String listing = listingText();
+        java.time.Instant now = clock.instant();
+        List<Quest> activeQuests = browser.activeQuests(now);
+        String listing = QuestListingFormatter.formatAll(activeQuests, now);
+        List<ActionButton> actions = new ArrayList<>();
+        actions.add(create);
+        if (completer != null) {
+            for (Quest quest : activeQuests) {
+                actions.add(completionButton(quest));
+            }
+        }
         DialogBase base = DialogBase.builder(Component.text("Quest Board"))
             .externalTitle(Component.text("Quest Board — Active quests and create"))
             .body(List.of(DialogBody.plainMessage(Component.text(
@@ -69,7 +90,7 @@ final class QuestBoardDialogUi implements QuestBoardUi {
             .build();
         player.showDialog(Dialog.create(factory -> factory.empty()
             .base(base)
-            .type(DialogType.notice(create))));
+            .type(DialogType.multiAction(actions).columns(1).build())));
     }
 
     String listingText() {
@@ -77,6 +98,40 @@ final class QuestBoardDialogUi implements QuestBoardUi {
         return QuestListingFormatter.formatAll(browser.activeQuests(now), now);
     }
 
+    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();
+    }
+
+    void submitCompletion(Player player, String questId) {
+        if (completer == null) {
+            player.sendMessage("Quest completion is unavailable.");
+            return;
+        }
+        try {
+            completer.complete(player, questId, clock.instant());
+        } catch (IllegalArgumentException | IllegalStateException exception) {
+            player.sendMessage(exception.getMessage());
+        } catch (IOException exception) {
+            player.sendMessage(
+                "The quest could not be saved. Your delivered blocks were restored."
+            );
+        }
+    }
+
     void submit(Player player, String material, String quantityText) {
         final int quantity;
         try {

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

@@ -0,0 +1,25 @@
+package games.dmg.spigotquestboard;
+
+import java.time.Instant;
+import java.util.List;
+import java.util.Objects;
+import java.util.UUID;
+
+record QuestClaim(
+    UUID id,
+    UUID questId,
+    UUID ownerId,
+    List<EscrowItem> items,
+    Instant createdAt
+) {
+    QuestClaim {
+        Objects.requireNonNull(id, "id");
+        Objects.requireNonNull(questId, "questId");
+        Objects.requireNonNull(ownerId, "ownerId");
+        items = List.copyOf(Objects.requireNonNull(items, "items"));
+        if (items.isEmpty()) {
+            throw new IllegalArgumentException("Claim items must not be empty");
+        }
+        Objects.requireNonNull(createdAt, "createdAt");
+    }
+}

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

@@ -16,11 +16,22 @@ final class QuestCommand implements CommandExecutor, TabCompleter {
     private static final List<String> QUANTITIES = List.of("1", "16", "32", "64");
     private final QuestCreationGateway creator;
     private final QuestBrowser browser;
+    private final QuestCompletionGateway completer;
     private final Clock clock;
 
     QuestCommand(QuestCreationGateway creator, QuestBrowser browser, Clock clock) {
+        this(creator, browser, null, clock);
+    }
+
+    QuestCommand(
+        QuestCreationGateway creator,
+        QuestBrowser browser,
+        QuestCompletionGateway completer,
+        Clock clock
+    ) {
         this.creator = Objects.requireNonNull(creator, "creator");
         this.browser = Objects.requireNonNull(browser, "browser");
+        this.completer = completer;
         this.clock = Objects.requireNonNull(clock, "clock");
     }
 
@@ -34,6 +45,26 @@ final class QuestCommand implements CommandExecutor, TabCompleter {
             sender.sendMessage(QuestListingFormatter.formatAll(browser.activeQuests(now), now));
             return true;
         }
+        if (arguments.length == 2 && "complete".equalsIgnoreCase(arguments[0])) {
+            if (!(sender instanceof Player player)) {
+                sender.sendMessage("Only players can complete quests with inventory items.");
+                return true;
+            }
+            if (completer == null) {
+                sender.sendMessage("Quest completion is unavailable.");
+                return true;
+            }
+            try {
+                completer.complete(player, arguments[1], clock.instant());
+            } catch (IllegalArgumentException | IllegalStateException exception) {
+                sender.sendMessage(exception.getMessage());
+            } catch (IOException exception) {
+                sender.sendMessage(
+                    "The quest could not be saved. Your delivered blocks were restored."
+                );
+            }
+            return true;
+        }
         if (arguments.length != 3 || !"create".equalsIgnoreCase(arguments[0])) {
             usage(sender);
             return true;
@@ -68,7 +99,7 @@ final class QuestCommand implements CommandExecutor, TabCompleter {
             return List.of();
         }
         if (arguments.length == 1) {
-            return startsWith(List.of("create", "list"), arguments[0]);
+            return startsWith(List.of("create", "list", "complete"), arguments[0]);
         }
         if (arguments.length == 2 && "create".equalsIgnoreCase(arguments[0])) {
             return creator.suggestBlockMaterials(arguments[1]);
@@ -96,7 +127,10 @@ final class QuestCommand implements CommandExecutor, TabCompleter {
     }
 
     private static void usage(CommandSender sender) {
-        sender.sendMessage("Usage: /quests [list] | /quests create <block> <quantity>");
+        sender.sendMessage(
+            "Usage: /quests [list] | /quests create <block> <quantity> | "
+                + "/quests complete <quest>"
+        );
         sender.sendMessage("Hold the entire reward stack in your main hand; its exact metadata will be escrowed.");
     }
 }

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

@@ -0,0 +1,9 @@
+package games.dmg.spigotquestboard;
+
+import java.util.List;
+
+record QuestCompletion(Quest quest, QuestClaim claim, List<EscrowItem> reward) {
+    QuestCompletion {
+        reward = List.copyOf(reward);
+    }
+}

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

@@ -0,0 +1,57 @@
+package games.dmg.spigotquestboard;
+
+import java.io.IOException;
+import java.time.Instant;
+import java.util.Objects;
+import java.util.UUID;
+import org.bukkit.entity.Player;
+
+final class QuestCompletionController implements QuestCompletionGateway {
+    private final QuestService quests;
+    private final QuestCompletionInventory inventory;
+    private final IssuerNotifier notifier;
+
+    QuestCompletionController(
+        QuestService quests, QuestCompletionInventory inventory, IssuerNotifier notifier
+    ) {
+        this.quests = Objects.requireNonNull(quests, "quests");
+        this.inventory = Objects.requireNonNull(inventory, "inventory");
+        this.notifier = Objects.requireNonNull(notifier, "notifier");
+    }
+
+    @Override
+    public QuestCompletion complete(Player player, String questId, Instant completedAt)
+        throws IOException {
+        Objects.requireNonNull(player, "player");
+        final UUID id;
+        try {
+            id = UUID.fromString(Objects.requireNonNull(questId, "questId"));
+        } catch (IllegalArgumentException exception) {
+            throw new IllegalArgumentException("Quest identifier must be a valid UUID.", exception);
+        }
+        Quest quest = quests.completionCandidate(id, completedAt);
+        QuestCompletionInventory.PreparedReward reward = inventory.prepare(quest.reward());
+        QuestCompletionInventory.RemovedDelivery delivery = inventory.remove(
+            player, quest.requestedMaterial(), quest.requestedAmount()
+        );
+        final QuestCompletion completion;
+        try {
+            completion = quests.complete(id, delivery.items(), completedAt);
+        } catch (IOException | RuntimeException exception) {
+            delivery.rollback();
+            throw exception;
+        }
+
+        int overflow = reward.grantAndDropOverflow(player);
+        player.sendMessage(
+            "Quest " + id + " completed. You received the exact escrowed reward."
+        );
+        if (overflow > 0) {
+            player.sendMessage(
+                overflow + " reward item(s) did not fit and were dropped safely at your feet."
+            );
+        }
+        notifier.notifyIfOnline(completion.quest().issuerId());
+        return completion;
+    }
+}

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

@@ -0,0 +1,9 @@
+package games.dmg.spigotquestboard;
+
+import java.io.IOException;
+import java.time.Instant;
+import org.bukkit.entity.Player;
+
+interface QuestCompletionGateway {
+    QuestCompletion complete(Player player, String questId, Instant completedAt) throws IOException;
+}

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

@@ -0,0 +1,19 @@
+package games.dmg.spigotquestboard;
+
+import java.util.List;
+import org.bukkit.entity.Player;
+
+interface QuestCompletionInventory {
+    RemovedDelivery remove(Player player, String material, int amount);
+
+    PreparedReward prepare(List<EscrowItem> reward);
+
+    interface RemovedDelivery {
+        List<EscrowItem> items();
+        void rollback();
+    }
+
+    interface PreparedReward {
+        int grantAndDropOverflow(Player player);
+    }
+}

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

@@ -3,20 +3,21 @@ package games.dmg.spigotquestboard;
 import java.io.IOException;
 import java.time.Instant;
 import java.time.temporal.ChronoUnit;
+import java.util.ArrayList;
 import java.util.LinkedHashMap;
 import java.util.List;
-import java.util.Map;
 import java.util.Locale;
+import java.util.Map;
 import java.util.Objects;
 import java.util.UUID;
 
 final class QuestService implements QuestBrowser {
     private final QuestRepository repository;
-    private Map<UUID, Quest> quests;
+    private QuestState state;
 
     QuestService(QuestRepository repository) throws IOException {
         this.repository = Objects.requireNonNull(repository, "repository");
-        quests = new LinkedHashMap<>(repository.load().quests());
+        state = repository.load();
     }
 
     synchronized Quest create(
@@ -38,23 +39,105 @@ final class QuestService implements QuestBrowser {
             UUID.randomUUID(), issuerId, issuerName, material, requestedAmount,
             reward, createdAt, createdAt.plus(7, ChronoUnit.DAYS)
         );
-        Map<UUID, Quest> candidate = new LinkedHashMap<>(quests);
-        candidate.put(quest.id(), quest);
-        repository.save(new QuestState(candidate));
-        quests = Map.copyOf(candidate);
+        Map<UUID, Quest> quests = new LinkedHashMap<>(state.quests());
+        quests.put(quest.id(), quest);
+        save(new QuestState(quests, state.claims(), state.notifications()));
         return quest;
     }
 
+    synchronized Quest completionCandidate(UUID questId, Instant now) {
+        Objects.requireNonNull(questId, "questId");
+        Objects.requireNonNull(now, "now");
+        Quest quest = state.quests().get(questId);
+        if (quest == null) {
+            throw new IllegalArgumentException("Quest not found: " + questId);
+        }
+        if (quest.status() != QuestStatus.ACTIVE || !now.isBefore(quest.expiresAt())) {
+            throw new IllegalStateException("That quest is no longer active or has expired.");
+        }
+        return quest;
+    }
+
+    synchronized QuestCompletion complete(
+        UUID questId, EscrowItem delivered, Instant completedAt
+    ) throws IOException {
+        return complete(questId, List.of(delivered), completedAt);
+    }
+
+    synchronized QuestCompletion complete(
+        UUID questId, List<EscrowItem> delivered, Instant completedAt
+    ) throws IOException {
+        Quest active = completionCandidate(questId, completedAt);
+        List<EscrowItem> delivery = List.copyOf(Objects.requireNonNull(delivered, "delivered"));
+        if (delivery.isEmpty()
+            || delivery.stream().anyMatch(item -> !item.material().equals(active.requestedMaterial()))
+            || delivery.stream().mapToInt(EscrowItem::amount).sum() != active.requestedAmount()) {
+            throw new IllegalArgumentException(
+                "Delivery must contain exactly " + active.requestedAmount() + " "
+                    + active.requestedMaterial() + "."
+            );
+        }
+
+        Quest completed = new Quest(
+            active.id(), active.issuerId(), active.issuerName(), active.requestedMaterial(),
+            active.requestedAmount(), active.reward(), active.createdAt(), active.expiresAt(),
+            QuestStatus.COMPLETED
+        );
+        QuestClaim claim = new QuestClaim(
+            UUID.randomUUID(), active.id(), active.issuerId(), delivery, completedAt
+        );
+        IssuerNotification notification = new IssuerNotification(
+            UUID.randomUUID(), active.id(), active.issuerId(),
+            "Quest " + active.id() + " was completed. Your delivered "
+                + active.requestedMaterial() + " blocks can be claimed at a quest board.",
+            completedAt
+        );
+
+        Map<UUID, Quest> quests = new LinkedHashMap<>(state.quests());
+        quests.put(active.id(), completed);
+        Map<UUID, List<QuestClaim>> claims = new LinkedHashMap<>(state.claims());
+        List<QuestClaim> ownerClaims = new ArrayList<>(
+            claims.getOrDefault(active.issuerId(), List.of())
+        );
+        ownerClaims.add(claim);
+        claims.put(active.issuerId(), ownerClaims);
+        Map<UUID, IssuerNotification> notifications = new LinkedHashMap<>(state.notifications());
+        notifications.put(notification.id(), notification);
+        save(new QuestState(quests, claims, notifications));
+        return new QuestCompletion(completed, claim, completed.reward());
+    }
+
+    synchronized List<IssuerNotification> pendingNotifications(UUID recipientId) {
+        Objects.requireNonNull(recipientId, "recipientId");
+        return state.notifications().values().stream()
+            .filter(notification -> notification.recipientId().equals(recipientId))
+            .toList();
+    }
+
+    synchronized void markNotificationDelivered(UUID notificationId) throws IOException {
+        if (!state.notifications().containsKey(notificationId)) {
+            return;
+        }
+        Map<UUID, IssuerNotification> notifications = new LinkedHashMap<>(state.notifications());
+        notifications.remove(notificationId);
+        save(new QuestState(state.quests(), state.claims(), notifications));
+    }
+
     @Override
     public synchronized List<Quest> activeQuests(Instant now) {
         Objects.requireNonNull(now, "now");
-        return quests.values().stream()
+        return state.quests().values().stream()
             .filter(quest -> quest.status() == QuestStatus.ACTIVE)
             .filter(quest -> now.isBefore(quest.expiresAt()))
             .toList();
     }
 
     synchronized QuestState state() {
-        return new QuestState(quests);
+        return state;
+    }
+
+    private void save(QuestState candidate) throws IOException {
+        repository.save(candidate);
+        state = candidate;
     }
 }

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

@@ -1,10 +1,16 @@
 package games.dmg.spigotquestboard;
 
+import java.util.LinkedHashMap;
+import java.util.List;
 import java.util.Map;
 import java.util.Objects;
 import java.util.UUID;
 
-record QuestState(Map<UUID, Quest> quests) {
+record QuestState(
+    Map<UUID, Quest> quests,
+    Map<UUID, List<QuestClaim>> claims,
+    Map<UUID, IssuerNotification> notifications
+) {
     QuestState {
         quests = Map.copyOf(Objects.requireNonNull(quests, "quests"));
         for (Map.Entry<UUID, Quest> entry : quests.entrySet()) {
@@ -12,9 +18,29 @@ record QuestState(Map<UUID, Quest> quests) {
                 throw new IllegalArgumentException("Quest map key does not match quest id");
             }
         }
+        Map<UUID, List<QuestClaim>> immutableClaims = new LinkedHashMap<>();
+        for (Map.Entry<UUID, List<QuestClaim>> entry
+            : Objects.requireNonNull(claims, "claims").entrySet()) {
+            List<QuestClaim> ownerClaims = List.copyOf(entry.getValue());
+            if (ownerClaims.stream().anyMatch(claim -> !claim.ownerId().equals(entry.getKey()))) {
+                throw new IllegalArgumentException("Claim map key does not match owner id");
+            }
+            immutableClaims.put(entry.getKey(), ownerClaims);
+        }
+        claims = Map.copyOf(immutableClaims);
+        notifications = Map.copyOf(Objects.requireNonNull(notifications, "notifications"));
+        for (Map.Entry<UUID, IssuerNotification> entry : notifications.entrySet()) {
+            if (!entry.getKey().equals(entry.getValue().id())) {
+                throw new IllegalArgumentException("Notification map key does not match id");
+            }
+        }
+    }
+
+    QuestState(Map<UUID, Quest> quests) {
+        this(quests, Map.of(), Map.of());
     }
 
     static QuestState empty() {
-        return new QuestState(Map.of());
+        return new QuestState(Map.of(), Map.of(), Map.of());
     }
 }

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

@@ -31,12 +31,20 @@ public final class SpigotQuestBoardPlugin extends JavaPlugin {
         QuestCreationGateway creator = new QuestCreationController(
             quests, new BukkitBlockMaterialCatalog(), new BukkitHeldRewardInventory()
         );
-        QuestCommand questCommand = new QuestCommand(creator, quests, Clock.systemUTC());
+        Clock clock = Clock.systemUTC();
+        BukkitIssuerNotifier notifier = new BukkitIssuerNotifier(
+            quests, getServer(), getLogger()
+        );
+        QuestCompletionGateway completer = new QuestCompletionController(
+            quests, new BukkitQuestCompletionInventory(), notifier
+        );
+        QuestCommand questCommand = new QuestCommand(creator, quests, completer, clock);
         command("quests").setExecutor(questCommand);
         command("quests").setTabCompleter(questCommand);
+        getServer().getPluginManager().registerEvents(notifier, this);
         getServer().getPluginManager().registerEvents(
             new QuestBoardInteractionListener(
-                boards, new QuestBoardDialogUi(creator, quests, Clock.systemUTC())
+                boards, new QuestBoardDialogUi(creator, quests, completer, clock)
             ),
             this
         );

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

@@ -34,6 +34,8 @@ final class YamlQuestRepository implements QuestRepository {
             throw new IOException("Invalid quest state", exception);
         }
         Map<UUID, Quest> quests = new LinkedHashMap<>();
+        Map<UUID, List<QuestClaim>> claims = new LinkedHashMap<>();
+        Map<UUID, IssuerNotification> notifications = new LinkedHashMap<>();
         try {
             for (Map<?, ?> entry : yaml.getMapList("quests")) {
                 UUID id = UUID.fromString(requiredString(entry, "id"));
@@ -43,7 +45,7 @@ final class YamlQuestRepository implements QuestRepository {
                     requiredString(entry, "issuer-name"),
                     requiredString(entry, "requested-material"),
                     requiredInteger(entry, "requested-amount"),
-                    readRewards(entry.get("reward")),
+                    readItems(entry.get("reward"), "reward"),
                     Instant.parse(requiredString(entry, "created-at")),
                     Instant.parse(requiredString(entry, "expires-at")),
                     readStatus(entry.get("status"))
@@ -52,10 +54,34 @@ final class YamlQuestRepository implements QuestRepository {
                     throw new IllegalArgumentException("Duplicate quest id: " + id);
                 }
             }
+            for (Map<?, ?> entry : yaml.getMapList("claims")) {
+                QuestClaim claim = new QuestClaim(
+                    UUID.fromString(requiredString(entry, "id")),
+                    UUID.fromString(requiredString(entry, "quest-id")),
+                    UUID.fromString(requiredString(entry, "owner-id")),
+                    readItems(entry.get("items"), "claim items"),
+                    Instant.parse(requiredString(entry, "created-at"))
+                );
+                claims.computeIfAbsent(claim.ownerId(), ignored -> new ArrayList<>()).add(claim);
+            }
+            for (Map<?, ?> entry : yaml.getMapList("notifications")) {
+                IssuerNotification notification = new IssuerNotification(
+                    UUID.fromString(requiredString(entry, "id")),
+                    UUID.fromString(requiredString(entry, "quest-id")),
+                    UUID.fromString(requiredString(entry, "recipient-id")),
+                    requiredString(entry, "message"),
+                    Instant.parse(requiredString(entry, "created-at"))
+                );
+                if (notifications.put(notification.id(), notification) != null) {
+                    throw new IllegalArgumentException(
+                        "Duplicate notification id: " + notification.id()
+                    );
+                }
+            }
         } catch (IllegalArgumentException | DateTimeParseException exception) {
             throw new IOException("Invalid quest record", exception);
         }
-        return new QuestState(quests);
+        return new QuestState(quests, claims, notifications);
     }
 
     @Override
@@ -72,20 +98,36 @@ final class YamlQuestRepository implements QuestRepository {
             serialized.put("created-at", quest.createdAt().toString());
             serialized.put("expires-at", quest.expiresAt().toString());
             serialized.put("status", quest.status().name());
-            List<Map<String, Object>> rewards = new ArrayList<>();
-            for (EscrowItem reward : quest.reward()) {
-                Map<String, Object> serializedReward = new LinkedHashMap<>();
-                serializedReward.put("material", reward.material());
-                serializedReward.put("amount", reward.amount());
-                if (reward.serializedItem() != null) {
-                    serializedReward.put("item-data", reward.serializedItem());
-                }
-                rewards.add(serializedReward);
-            }
-            serialized.put("reward", rewards);
+            serialized.put("reward", writeItems(quest.reward()));
             serializedQuests.add(serialized);
         }
         yaml.set("quests", serializedQuests);
+
+        List<Map<String, Object>> serializedClaims = new ArrayList<>();
+        for (List<QuestClaim> ownerClaims : state.claims().values()) {
+            for (QuestClaim claim : ownerClaims) {
+                Map<String, Object> serialized = new LinkedHashMap<>();
+                serialized.put("id", claim.id().toString());
+                serialized.put("quest-id", claim.questId().toString());
+                serialized.put("owner-id", claim.ownerId().toString());
+                serialized.put("created-at", claim.createdAt().toString());
+                serialized.put("items", writeItems(claim.items()));
+                serializedClaims.add(serialized);
+            }
+        }
+        yaml.set("claims", serializedClaims);
+
+        List<Map<String, Object>> serializedNotifications = new ArrayList<>();
+        for (IssuerNotification notification : state.notifications().values()) {
+            Map<String, Object> serialized = new LinkedHashMap<>();
+            serialized.put("id", notification.id().toString());
+            serialized.put("quest-id", notification.questId().toString());
+            serialized.put("recipient-id", notification.recipientId().toString());
+            serialized.put("message", notification.message());
+            serialized.put("created-at", notification.createdAt().toString());
+            serializedNotifications.add(serialized);
+        }
+        yaml.set("notifications", serializedNotifications);
         writeAtomically(yaml);
     }
 
@@ -106,24 +148,38 @@ final class YamlQuestRepository implements QuestRepository {
         }
     }
 
-    private static List<EscrowItem> readRewards(Object value) {
+    private static List<EscrowItem> readItems(Object value, String description) {
         if (!(value instanceof List<?> entries) || entries.isEmpty()) {
-            throw new IllegalArgumentException("Missing reward");
+            throw new IllegalArgumentException("Missing " + description);
         }
-        List<EscrowItem> rewards = new ArrayList<>();
+        List<EscrowItem> items = new ArrayList<>();
         for (Object rawEntry : entries) {
             if (!(rawEntry instanceof Map<?, ?> entry)) {
-                throw new IllegalArgumentException("Invalid reward");
+                throw new IllegalArgumentException("Invalid " + description);
             }
             Object data = entry.get("item-data");
             if (data != null && !(data instanceof String)) {
                 throw new IllegalArgumentException("Invalid item-data");
             }
-            rewards.add(new EscrowItem(
+            items.add(new EscrowItem(
                 requiredString(entry, "material"), requiredInteger(entry, "amount"), (String) data
             ));
         }
-        return rewards;
+        return items;
+    }
+
+    private static List<Map<String, Object>> writeItems(List<EscrowItem> items) {
+        List<Map<String, Object>> serializedItems = new ArrayList<>();
+        for (EscrowItem item : items) {
+            Map<String, Object> serialized = new LinkedHashMap<>();
+            serialized.put("material", item.material());
+            serialized.put("amount", item.amount());
+            if (item.serializedItem() != null) {
+                serialized.put("item-data", item.serializedItem());
+            }
+            serializedItems.add(serialized);
+        }
+        return serializedItems;
     }
 
     private static QuestStatus readStatus(Object value) {