feat(ignis): add earned Mask crafting and invisibility

README.md

@@ -1,6 +1,6 @@
 # Spigot Ignis
 
-Server-wide earned shadow progression for Social Minecraft. **Foundation work only; no player abilities or commands are implemented yet. Do not deploy this foundation as a gameplay release.**
+Server-wide earned shadow progression for Social Minecraft. **Echo of the Abyss, advancement-name scrambling, and The Mask are implemented in source; live-server/client verification is pending.** Dagger and Heart gameplay are not implemented yet.
 
 ## Build
 
@@ -11,27 +11,72 @@ Requires Java 17+ to launch Gradle; the wrapper resolves a Java 25 toolchain for
 ./gradlew clean jar -PreleaseVersion=0.1.0
 ```
 
-Targets Purpur `26.2.build.2618-stable`. The API is not bundled. Source builds do not require the private wiki.
+Targets Purpur `26.2.build.2618-stable` and requires **ProtocolLib 5.4.0** for Mask helmet projection. Neither server API nor ProtocolLib is bundled. Source builds do not require the private wiki.
 
 ## Knowledge and delivery
 
 The [canonical project](https://git.garvis.dev/dmg/somc-okf/src/branch/main/projects/spigot-ignis/index.md) and stories live in the shared private SoMC wiki. There is no repository-local knowledge bundle.
 
-CI/release workflows are scaffolded but not remotely verified. Release publication requires the repository Actions secret `RELEASE_TOKEN`, securely provisioned separately before the first main push. The release workflow uses Git askpass and curl stdin for authentication rather than embedding a release credential in URLs or process arguments. Never enable tracing. GitOps and production release need separate approvals.
+CI/release workflows publish versioned source artifacts; verify their exact run/commit before using any artifact. Release publication requires the repository Actions secret `RELEASE_TOKEN`, provisioned separately. The release workflow uses a repository-scoped Git credential helper and curl stdin for authentication rather than embedding a release credential in URLs or process arguments. Semantic-release overrides `GIT_ASKPASS`, so askpass is not used for release authentication. Never enable tracing. GitOps and production release need separate approvals.
 
 ## Foundation interfaces and state
 
 - `StateService.open(repository)` loads on a dedicated persistence worker and completes only when ready. Failed/corrupt loads do not substitute empty state. No caller may use gameplay state before successful initialization.
 - `snapshot()` provides an immutable, last-successfully-saved view. `update(pureChange)` serializes mutations, saves first, then publishes/acknowledges. Mutation functions run off-thread and must not access Bukkit or perform gameplay side effects. Marshal downstream gameplay work back to the server thread.
 - `configure(invisibilityMillis, pearls, darknessMillis)` validates positive thresholds and atomically saves limits with resulting unlocks. Defaults are 43,200,000 ms (12 h), 313 pearls, and 21,600,000 ms (6 h). Lower limits unlock satisfied tracks during evaluation; higher limits do not revoke unlocks. VOID is objective-based and is excluded from numeric threshold grants.
-- UUID state includes per-track progress, unlock/activation flags, invalidation generations, and pending reward identifiers. This is storage infrastructure, **not implemented reward delivery, item revocation, or challenge tracking**. Issuance/transfer provenance remains a later design decision.
+- UUID state includes per-track progress, unlock/activation flags, invalidation generations, pending rewards, and issued-item receipts. Echo validity requires a matching owner, receipt, and generation; reset removes relevant receipts and advances the generation. Future tradable-item provenance remains a later design decision.
 - `close()` rejects new mutations and lets already queued writes drain without blocking the caller. Hard process termination can lose unacknowledged updates. The worker does not force Bukkit/world access from its thread.
 
-The foundation bootstrap reads only `plugins/SpigotIgnis/state.bin`; it does not read or migrate Stealth data. No commands, crafting, reset handlers, event counters, restart challenge resets, or rendering hooks are registered. Runtime settings currently have a Java service API only, not a config-file editor or admin command.
+Bootstrap reads only `plugins/SpigotIgnis/state.bin`; it does not read or migrate Stealth data. Listeners, commands, and pending-delivery retries register only after successful asynchronous initialization. Runtime limits have a Java service API and admin commands; there is no hand-edited configuration file.
+
+## Echo gameplay
+
+Take uncancelled void damage, ascend while gliding with elytra in the same world, then make the first landing on End Stone. Death, disconnect, teleport/world change, or restarting cancels an unfinished attempt. No datapack advancement ID is required.
+
+The earned Echo Shard is named **Echo of the Abyss**, with cryptic lore and a UUID-bound receipt. Right-click it to activate permanent obfuscated-name advancement announcements. It does not hide general identity or alter advancement titles/descriptions. Only the bound owner may use it, and activation cannot grant twice. Lost, unconsumed rewards can be earned again by repeating the feat. Admins can also grant a bound Echo.
+
+Full inventories retain a pending reward; online delivery retries every five seconds using the same receipt identity. Temporary inventory/drop/swap locks prevent ordinary moves during the short activation commit. Disk failures do not consume the item on activation; failed completion saves produce a player-facing recovery message rather than pretending the reward was saved.
+
+Announcement handling uses Purpur's Adventure `PlayerAdvancementDoneEvent.message`, replacing only the first name argument of the three vanilla advancement translations. It preserves silent events and unrelated/custom message formats. Advancement transformation itself needs no ProtocolLib interception; the plugin's ProtocolLib dependency serves Mask equipment projection. Existing Stealth outbound masking sees the obfuscated alias rather than the original name. Live coexistence remains unverified.
+
+## The Mask
+
+Only actual invisibility effects from directly drunk potions count toward the default **12-hour** threshold. Splash, lingering, arrows, commands, other plugins, and the Mask itself do not count. Cancelled or non-overriding effect changes do not change attribution. Time uses a monotonic clock; refresh/overlap does not double-count. Whole milliseconds persist with sub-millisecond credit retained in memory. Failed saves retain reserved credit for retry rather than silently discarding it.
+
+Checkpoints run every five seconds and on effect end, disconnect, and disable. Offline time never counts. A plugin-owned player-data provenance marker permits an existing directly drunk effect to resume online counting after reconnect/restart; marker restoration and interactions with plugins changing effects while Ignis is disabled still require live validation. A reset discards old-generation buffered credit; future qualifying time can accumulate anew. Administrator time edits flush current credit before changing the counter.
+
+Unlocked players can craft **The Mask** from eight Netherite Blocks surrounding a Nether Star. The player-head skin is `IgnisUmbra10`, resolved using the server's asynchronous profile API (20-second timeout, retry every five minutes until ready). There is no blocking profile lookup on the tick thread. Missing/incomplete skins withhold crafting and queued item creation, not ingredients. Previously issued Masks can still be identified/used from their embedded profile without a new lookup.
+
+Crafting requires a durable issuer receipt **before** an authenticated result becomes available. Vanilla crafting handles ingredient consumption, including shift-crafting; the plugin does not manually escrow/delete those expensive ingredients while waiting for disk. Locked/invalid outputs and automated Crafters are rejected. Recipe-book discovery follows personal unlocks; clients/mods may inspect global recipe definitions, but cannot bypass server crafting permission checks.
+
+A crafter's generation can share a recipe receipt across multiple legitimately paid crafts. Masks are tradable, but a holder must have their own unlock. Validity also requires the issuer's matching receipt/generation: resetting the issuer invalidates their issued copies even when traded away. Resetting a recipient removes that recipient's unlock and invalidates items issued by them; another issuer's still-valid Mask may be used again once the recipient re-earns their own unlock.
+
+Wearing a valid Mask applies managed invisibility. Effect ownership is established only when this plugin's application actually takes effect; external replacements revoke ownership, so unequipping/resetting removes only Ignis's contribution. ProtocolLib projects only the helmet slot to air for eligible invisible wearers and restores equipment presentation when eligibility changes. Other armor and server inventory contents are not mutated by projection. Actual self/other-player rendering and inventory-screen behavior remain manual acceptance checks.
+
+## Commands
+
+All players may use `/ignis umbra` to privately see the three item tracks. The Mask counter is active; Dagger/Heart natural counters and items remain unimplemented, though administrator-seeded values can be inspected. No passive progress UI is added.
+
+Administration requires **`ignis.admin`** (default: operators), checked independently during execution and autocomplete:
+
+```text
+/ignisadmin inspect <online-name|known-UUID>
+/ignisadmin limits
+/ignisadmin limits set <mask-ms|pearls|darkness-ms> <positive-value>
+/ignisadmin progress <set|add> <online-name|known-UUID> <mask|dagger|heart> <nonnegative-value>
+/ignisadmin complete <online-name|known-UUID> void
+/ignisadmin give <online-name|known-UUID> <echo|mask>
+/ignisadmin reset <online-name|known-UUID> <void|mask|dagger|heart|all>
+/ignisadmin reset <online-name|known-UUID> <void|mask|dagger|heart|all> confirm
+```
+
+Reset confirmation must match the same sender, target, and tracks within 30 seconds; `confirm` alone cannot bypass the initial request. Reset clears the selected progress/unlocks/activation, pending rewards and issuance receipts, and advances generation, making old Echo copies invalid even after re-earning. Other tracks are unchanged by a single-track reset. Echo grants unlock eligibility but still require consumption to activate scrambling; already activated players do not gain another activation. Admin Mask grants unlock use and queue the authenticated item for delivery after profile resolution/inventory availability. Admin mutations are audited, not routine private progress reads.
+
+Offline targets use UUIDs already present in Ignis state; online exact names are resolved without network profile lookups. Commands and contextual completion do not claim that unimplemented reward items are available.
 
 ### Recovery and format
 
-`state.bin` is a versioned binary data format (not Java object serialization): magic/version, positive thresholds, UUID player maps, named track states, and UUID pending rewards. Invalid versions, counts, duplicate keys, malformed flags, negative counters, truncated input, and trailing bytes are rejected. Record counts are bounded at 100,000 players and 100,000 pending rewards per player.
+`state.bin` is a versioned binary data format (not Java object serialization): magic/version, positive thresholds, UUID player maps, named track states, pending rewards, and issuance receipts. Version 2 reads version 1 and carries forward all existing pending rewards as matching issuance receipts; the next successful save writes version 2. Invalid versions, counts, duplicate keys, malformed flags, negative counters, truncated input, and trailing bytes are rejected. Record counts are bounded at 100,000 players and 100,000 pending rewards/issuance receipts per player.
 
 Writes use a same-directory temporary file, flush it to disk, and require atomic replacement. Unsupported atomic moves or write failures retain the prior active snapshot and fail the mutation; there is no non-atomic fallback. Abandoned temporary files are ignored, never auto-promoted. This does not guarantee survival of arbitrary storage hardware or power failures.
 
@@ -39,4 +84,8 @@ If loading fails, preserve the original file for investigation. Under an approve
 
 ## Verification limits
 
-JUnit tests exercise real temporary-file persistence, serialized writes, fault injection, threshold policies, metadata, and static workflow guardrails. YAML/shell parsing is not remote CI verification. No Purpur startup/shutdown, live gameplay, client presentation, command registration, or actual release publishing has been tested yet.
+JUnit tests exercise real temporary-file persistence, serialized writes, fault injection, threshold policies, receipt/owner/reset rules, challenge transitions, announcement components, command execution/completion, mocked Bukkit boundaries, metadata, and static workflow guardrails. YAML/shell parsing is not remote CI verification.
+
+Live Purpur startup/shutdown, event sequencing, item appearance/consumption, inventory durability across hard crashes, protections, and Stealth/client compatibility still require a manual smoke test. Minecraft inventory persistence and this plugin's state file are not a single atomic transaction: a hard crash between item delivery and Minecraft saving inventory needs operator recovery review. If disconnect/death happens during activation, the durable benefit can commit before the physical item is removed; any retained copy is inert, not another usable unlock. These limitations prevent claiming complete live/crash acceptance or deploying automatically.
+
+Before a later approved production release, test: void damage/elytra/End Stone success and all interruption paths; other players and lookalikes failing activation; full inventory and failed saves; logout/death during activation; reset/re-earn invalidation; all advancement types and hover/click content with Stealth; admin permission/confirmation/offline UUID cases; direct-drink attribution after reconnect/restart and external effect replacement; skin outages; manual/shift/Crafter ingredient protection; tradable Mask issuer/holder resets; own/other-player helmet rendering, inventory interactions, and preservation of external invisibility.

build.gradle.kts

@@ -15,9 +15,12 @@ tasks.withType<JavaCompile>().configureEach {
 
 dependencies {
     compileOnly("org.purpurmc.purpur:purpur-api:26.2.build.2618-stable")
+    compileOnly("net.dmulloy2:ProtocolLib:5.4.0")
+    testImplementation("net.dmulloy2:ProtocolLib:5.4.0")
     testImplementation("org.purpurmc.purpur:purpur-api:26.2.build.2618-stable")
     testImplementation(platform("org.junit:junit-bom:5.13.4"))
     testImplementation("org.junit.jupiter:junit-jupiter")
+    testImplementation("org.mockito:mockito-core:5.18.0")
     testRuntimeOnly("org.junit.platform:junit-platform-launcher")
 }
 

src/main/java/games/dmg/spigotignis/AdvancementMasker.java

@@ -0,0 +1,40 @@
+package games.dmg.spigotignis;
+
+import java.util.ArrayList;
+import java.util.Set;
+import net.kyori.adventure.text.Component;
+import net.kyori.adventure.text.ComponentLike;
+import net.kyori.adventure.text.TranslatableComponent;
+import net.kyori.adventure.text.format.TextDecoration;
+
+/** Semantic advancement name replacement; never search/replace advancement titles or user text. */
+public final class AdvancementMasker {
+    private static final Set<String> KEYS = Set.of("chat.type.advancement.task", "chat.type.advancement.goal",
+            "chat.type.advancement.challenge");
+    private AdvancementMasker() { }
+
+    public static Component mask(Component original) {
+        if (original == null) return null;
+        Component result = original;
+        boolean changed = false;
+        if (result instanceof TranslatableComponent translation && KEYS.contains(translation.key())
+                && !translation.arguments().isEmpty()) {
+            var arguments = new ArrayList<ComponentLike>(translation.arguments());
+            arguments.set(0, Component.text("Anonymous").decorate(TextDecoration.OBFUSCATED).insertion(""));
+            result = translation.arguments(arguments);
+            changed = true;
+        }
+        var children = new ArrayList<Component>();
+        for (Component child : original.children()) {
+            Component masked = mask(child);
+            children.add(masked);
+            changed |= masked != child;
+        }
+        if (changed) {
+            // Strip inherited identity actions along the name's ancestry; advancement args are untouched.
+            return result.children(children).clickEvent(null).hoverEvent((net.kyori.adventure.text.event.HoverEvent<?>) null)
+                    .insertion(null);
+        }
+        return original;
+    }
+}

src/main/java/games/dmg/spigotignis/AnnouncementListener.java

@@ -0,0 +1,21 @@
+package games.dmg.spigotignis;
+
+import java.util.Objects;
+import java.util.UUID;
+import java.util.function.Predicate;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.EventPriority;
+import org.bukkit.event.Listener;
+import org.bukkit.event.player.PlayerAdvancementDoneEvent;
+
+public final class AnnouncementListener implements Listener {
+    private final Predicate<UUID> activated;
+    public AnnouncementListener(Predicate<UUID> activated) { this.activated = Objects.requireNonNull(activated); }
+
+    @EventHandler(priority = EventPriority.HIGHEST)
+    public void onAdvancement(PlayerAdvancementDoneEvent event) {
+        if (event.message() != null && activated.test(event.getPlayer().getUniqueId())) {
+            event.message(AdvancementMasker.mask(event.message()));
+        }
+    }
+}

src/main/java/games/dmg/spigotignis/EchoGameplay.java

@@ -0,0 +1,151 @@
+package games.dmg.spigotignis;
+
+import java.util.HashSet;
+import java.util.Set;
+import java.util.UUID;
+import org.bukkit.Material;
+import org.bukkit.entity.Player;
+import org.bukkit.event.Event;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.EventPriority;
+import org.bukkit.event.Listener;
+import org.bukkit.event.entity.EntityDamageEvent;
+import org.bukkit.event.entity.PlayerDeathEvent;
+import org.bukkit.event.inventory.InventoryClickEvent;
+import org.bukkit.event.inventory.InventoryDragEvent;
+import org.bukkit.event.player.PlayerDropItemEvent;
+import org.bukkit.event.player.PlayerInteractEvent;
+import org.bukkit.event.player.PlayerMoveEvent;
+import org.bukkit.event.player.PlayerQuitEvent;
+import org.bukkit.event.player.PlayerSwapHandItemsEvent;
+import org.bukkit.event.player.PlayerTeleportEvent;
+import org.bukkit.plugin.java.JavaPlugin;
+
+/** Bukkit work stays on the tick thread; state transactions contain no Bukkit access. */
+public final class EchoGameplay implements Listener {
+    private final JavaPlugin plugin;
+    private final StateService states;
+    private final EchoItems items;
+    private final VoidTrial trial = new VoidTrial();
+    private final Set<EchoToken> delivering = new HashSet<>();
+    private final Set<UUID> activating = new HashSet<>();
+
+    public EchoGameplay(JavaPlugin plugin, StateService states, EchoItems items) {
+        this.plugin = plugin;
+        this.states = states;
+        this.items = items;
+    }
+
+    @EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = true)
+    public void onDamage(EntityDamageEvent event) {
+        if (event.getEntity() instanceof Player player && event.getCause() == EntityDamageEvent.DamageCause.VOID
+                && event.getFinalDamage() > 0 && !activated(player.getUniqueId())) {
+            trial.damaged(player.getUniqueId(), player.getWorld().getUID(), player.getY());
+        }
+    }
+
+    @EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = true)
+    public void onMove(PlayerMoveEvent event) {
+        if (event instanceof PlayerTeleportEvent || !event.hasChangedPosition()) return;
+        Player player = event.getPlayer();
+        if (player.isDead() || activated(player.getUniqueId())) {
+            cancel(player.getUniqueId());
+            return;
+        }
+        var location = event.getTo();
+        boolean grounded = player.isOnGround();
+        boolean endStone = grounded && location.clone().subtract(0, 0.1, 0).getBlock().getType() == Material.END_STONE;
+        if (trial.moved(player.getUniqueId(), location.getWorld().getUID(), location.getY(), player.isGliding(),
+                grounded, endStone)) {
+            UUID owner = player.getUniqueId(), receipt = UUID.randomUUID();
+            long generation = states.snapshot().players().getOrDefault(owner, PlayerState.empty()).track(Track.VOID).generation();
+            states.update(state -> state.players().getOrDefault(owner, PlayerState.empty()).track(Track.VOID).generation() == generation
+                    ? EchoRewards.award(state, owner, receipt) : state).whenComplete((state, error) -> onServer(() -> {
+                        if (error != null) {
+                            plugin.getLogger().warning("Echo reward save failed; administrator recovery is required.");
+                            Player online = plugin.getServer().getPlayer(owner);
+                            if (online != null) online.sendMessage("Your void reward could not be saved. Please contact an administrator.");
+                        } else retryDeliveries();
+                    }));
+        }
+    }
+
+    @EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = true)
+    public void onTeleport(PlayerTeleportEvent event) { cancel(event.getPlayer().getUniqueId()); }
+    @EventHandler public void onDeath(PlayerDeathEvent event) { cancel(event.getEntity().getUniqueId()); }
+    @EventHandler public void onQuit(PlayerQuitEvent event) { cancel(event.getPlayer().getUniqueId()); }
+    public void cancel(UUID player) { trial.cancel(player); }
+
+    public boolean activated(UUID player) {
+        return states.snapshot().players().getOrDefault(player, PlayerState.empty()).track(Track.VOID).activated();
+    }
+
+    /** Rechecks full inventories periodically and retries acknowledgements using stable receipt IDs. */
+    public void retryDeliveries() {
+        for (Player player : plugin.getServer().getOnlinePlayers()) {
+            if (activating.contains(player.getUniqueId())) continue;
+            PlayerState state = states.snapshot().players().getOrDefault(player.getUniqueId(), PlayerState.empty());
+            if (state.track(Track.VOID).activated()) continue;
+            for (var entry : state.pendingRewards().entrySet()) {
+                if (entry.getValue() != Track.VOID) continue;
+                EchoToken token = new EchoToken(player.getUniqueId(), entry.getKey(), state.track(Track.VOID).generation());
+                if (delivering.contains(token) || !items.offer(player, token)) continue;
+                delivering.add(token);
+                states.update(current -> EchoRewards.acknowledge(current, token)).whenComplete((ignored, error) ->
+                        onServer(() -> delivering.remove(token)));
+            }
+        }
+    }
+
+    @EventHandler(priority = EventPriority.HIGHEST)
+    public void onUse(PlayerInteractEvent event) {
+        if (!event.getAction().isRightClick() || event.useItemInHand() == Event.Result.DENY) return;
+        var identity = items.identify(event.getItem());
+        if (identity.isEmpty()) return;
+        event.setCancelled(true);
+        Player player = event.getPlayer();
+        EchoToken token = identity.orElseThrow();
+        UUID actor = player.getUniqueId();
+        if (activating.contains(actor)) return;
+        if (!EchoRewards.valid(states.snapshot(), actor, token)) {
+            player.sendMessage("This Echo cannot answer you.");
+            return;
+        }
+        activating.add(actor);
+        states.update(state -> EchoRewards.activate(state, actor, token)).whenComplete((ignored, error) -> onServer(() -> {
+            activating.remove(actor);
+            Player online = plugin.getServer().getPlayer(actor);
+            if (online == null) return;
+            TrackState current = states.snapshot().players().getOrDefault(actor, PlayerState.empty()).track(Track.VOID);
+            if (error == null && current.activated() && current.generation() == token.generation()) {
+                items.consumeOne(online, token);
+                online.sendMessage("The abyss remembers. Your deeds will speak alone.");
+            } else if (error == null) {
+                online.sendMessage("Your Echo activation was superseded by an administrator reset.");
+            } else online.sendMessage("The Echo remains silent. It has not been consumed; try again.");
+        }));
+    }
+
+    @EventHandler(priority = EventPriority.HIGHEST, ignoreCancelled = true)
+    public void onInventory(InventoryClickEvent event) {
+        if (activating.contains(event.getWhoClicked().getUniqueId())) event.setCancelled(true);
+    }
+    @EventHandler(priority = EventPriority.HIGHEST, ignoreCancelled = true)
+    public void onDrag(InventoryDragEvent event) {
+        if (activating.contains(event.getWhoClicked().getUniqueId())) event.setCancelled(true);
+    }
+    @EventHandler(priority = EventPriority.HIGHEST, ignoreCancelled = true)
+    public void onDrop(PlayerDropItemEvent event) {
+        if (activating.contains(event.getPlayer().getUniqueId())) event.setCancelled(true);
+    }
+    @EventHandler(priority = EventPriority.HIGHEST, ignoreCancelled = true)
+    public void onSwap(PlayerSwapHandItemsEvent event) {
+        if (activating.contains(event.getPlayer().getUniqueId())) event.setCancelled(true);
+    }
+
+    public void onServer(Runnable task) {
+        if (!plugin.isEnabled()) return;
+        try { plugin.getServer().getScheduler().runTask(plugin, task); }
+        catch (org.bukkit.plugin.IllegalPluginAccessException ignored) { /* shutdown owns cleanup */ }
+    }
+}

src/main/java/games/dmg/spigotignis/EchoIdentity.java

@@ -0,0 +1,22 @@
+package games.dmg.spigotignis;
+
+import java.util.Optional;
+import java.util.UUID;
+
+public final class EchoIdentity {
+    private EchoIdentity() { }
+    public static String encode(EchoToken token) {
+        return token.owner() + ":" + token.receipt() + ":" + token.generation();
+    }
+    public static Optional<EchoToken> decode(String value) {
+        if (value == null || value.length() > 110) return Optional.empty();
+        String[] parts = value.split(":", -1);
+        if (parts.length != 3) return Optional.empty();
+        try {
+            return Optional.of(new EchoToken(UUID.fromString(parts[0]), UUID.fromString(parts[1]),
+                    Long.parseLong(parts[2])));
+        } catch (IllegalArgumentException exception) {
+            return Optional.empty();
+        }
+    }
+}

src/main/java/games/dmg/spigotignis/EchoItems.java

@@ -0,0 +1,61 @@
+package games.dmg.spigotignis;
+
+import java.util.List;
+import java.util.Optional;
+import net.kyori.adventure.text.Component;
+import net.kyori.adventure.text.format.NamedTextColor;
+import org.bukkit.Material;
+import org.bukkit.NamespacedKey;
+import org.bukkit.entity.Player;
+import org.bukkit.inventory.ItemStack;
+import org.bukkit.persistence.PersistentDataType;
+
+/** Thin inventory adapter. Receipt validity is checked against durable state, not lore. */
+public final class EchoItems {
+    private static final NamespacedKey IDENTITY = new NamespacedKey("spigotignis", "echo_identity");
+
+    public ItemStack create(EchoToken token) {
+        var item = new ItemStack(Material.ECHO_SHARD);
+        var meta = item.getItemMeta();
+        meta.displayName(Component.text("Echo of the Abyss", NamedTextColor.DARK_PURPLE));
+        meta.lore(List.of(Component.text("You returned. Something followed.", NamedTextColor.GRAY),
+                Component.text("Offer it your name, and let your deeds speak alone.", NamedTextColor.GRAY)));
+        meta.getPersistentDataContainer().set(IDENTITY, PersistentDataType.STRING, EchoIdentity.encode(token));
+        item.setItemMeta(meta);
+        return item;
+    }
+
+    public Optional<EchoToken> identify(ItemStack item) {
+        if (item == null || item.getType() != Material.ECHO_SHARD || !item.hasItemMeta()) return Optional.empty();
+        return EchoIdentity.decode(item.getItemMeta().getPersistentDataContainer().get(IDENTITY, PersistentDataType.STRING));
+    }
+
+    public boolean contains(Player player, EchoToken token) {
+        for (ItemStack item : player.getInventory().getContents()) {
+            if (identify(item).filter(token::equals).isPresent()) return true;
+        }
+        return identify(player.getItemOnCursor()).filter(token::equals).isPresent();
+    }
+
+    public boolean offer(Player player, EchoToken token) {
+        if (contains(player, token)) return true;
+        if (player.getInventory().firstEmpty() < 0) return false;
+        return player.getInventory().addItem(create(token)).isEmpty();
+    }
+
+    public void consumeOne(Player player, EchoToken token) {
+        for (int slot = 0; slot < player.getInventory().getSize(); slot++) {
+            ItemStack item = player.getInventory().getItem(slot);
+            if (identify(item).filter(token::equals).isPresent()) {
+                item.setAmount(item.getAmount() - 1);
+                player.getInventory().setItem(slot, item.getAmount() == 0 ? null : item);
+                return;
+            }
+        }
+        ItemStack cursor = player.getItemOnCursor();
+        if (identify(cursor).filter(token::equals).isPresent()) {
+            cursor.setAmount(cursor.getAmount() - 1);
+            player.setItemOnCursor(cursor.getAmount() == 0 ? null : cursor);
+        }
+    }
+}

src/main/java/games/dmg/spigotignis/EchoRewards.java

@@ -0,0 +1,52 @@
+package games.dmg.spigotignis;
+
+import java.util.UUID;
+import java.util.HashMap;
+
+public final class EchoRewards {
+    private EchoRewards() { }
+    public static IgnisState award(IgnisState state, UUID owner, UUID receipt) {
+        PlayerState player = state.players().getOrDefault(owner, PlayerState.empty());
+        TrackState progress = player.track(Track.VOID);
+        if (progress.activated() || player.issuedRewards().containsKey(receipt)) return state;
+        var tracks = new HashMap<>(player.tracks());
+        tracks.put(Track.VOID, new TrackState(1, true, false, progress.generation()));
+        var pending = new HashMap<>(player.pendingRewards());
+        var issued = new HashMap<>(player.issuedRewards());
+        pending.put(receipt, Track.VOID);
+        issued.put(receipt, Track.VOID);
+        return replace(state, owner, new PlayerState(tracks, pending, issued));
+    }
+
+    private static IgnisState replace(IgnisState state, UUID owner, PlayerState player) {
+        var players = new HashMap<>(state.players());
+        players.put(owner, player);
+        return new IgnisState(state.limits(), players);
+    }
+    public static boolean valid(IgnisState state, UUID actor, EchoToken token) {
+        if (!actor.equals(token.owner())) return false;
+        PlayerState player = state.players().getOrDefault(actor, PlayerState.empty());
+        TrackState track = player.track(Track.VOID);
+        return track.unlocked() && !track.activated() && track.generation() == token.generation()
+                && player.issuedRewards().get(token.receipt()) == Track.VOID;
+    }
+
+    public static IgnisState acknowledge(IgnisState state, EchoToken token) {
+        if (!valid(state, token.owner(), token)) return state;
+        PlayerState player = state.players().get(token.owner());
+        var pending = new HashMap<>(player.pendingRewards());
+        pending.remove(token.receipt());
+        return replace(state, token.owner(), new PlayerState(player.tracks(), pending, player.issuedRewards()));
+    }
+
+    public static IgnisState activate(IgnisState state, UUID actor, EchoToken token) {
+        if (!valid(state, actor, token)) throw new IllegalArgumentException("This Echo cannot answer you.");
+        PlayerState player = state.players().get(actor);
+        var tracks = new HashMap<>(player.tracks());
+        TrackState previous = player.track(Track.VOID);
+        tracks.put(Track.VOID, new TrackState(previous.progress(), true, true, previous.generation()));
+        var pending = new HashMap<>(player.pendingRewards());
+        pending.entrySet().removeIf(entry -> entry.getValue() == Track.VOID);
+        return replace(state, actor, new PlayerState(tracks, pending, player.issuedRewards()));
+    }
+}

src/main/java/games/dmg/spigotignis/EchoToken.java

@@ -0,0 +1,12 @@
+package games.dmg.spigotignis;
+
+import java.util.Objects;
+import java.util.UUID;
+
+public record EchoToken(UUID owner, UUID receipt, long generation) {
+    public EchoToken {
+        Objects.requireNonNull(owner);
+        Objects.requireNonNull(receipt);
+        if (generation < 0) throw new IllegalArgumentException("Invalid Echo generation.");
+    }
+}

src/main/java/games/dmg/spigotignis/EffectOwnership.java

@@ -0,0 +1,22 @@
+package games.dmg.spigotignis;
+
+import java.util.HashSet;
+import java.util.Set;
+import java.util.UUID;
+
+/** Server-thread ownership of this plugin's effective invisibility contribution. */
+public final class EffectOwnership {
+    private final Set<UUID> applying = new HashSet<>();
+    private final Set<UUID> owned = new HashSet<>();
+
+    public void applying(UUID player, boolean active) {
+        if (active) applying.add(player); else applying.remove(player);
+    }
+    public void changed(UUID player, boolean actuallyChanged, boolean remainsPresent) {
+        if (!actuallyChanged) return;
+        if (remainsPresent && applying.contains(player)) owned.add(player);
+        else owned.remove(player);
+    }
+    public boolean owns(UUID player) { return owned.contains(player); }
+    public void forget(UUID player) { applying.remove(player); owned.remove(player); }
+}

src/main/java/games/dmg/spigotignis/FileStateRepository.java

@@ -17,7 +17,7 @@ import java.util.UUID;
 /** Versioned data, never Java object deserialization. Call from the persistence worker only. */
 public final class FileStateRepository implements StateRepository {
     private static final int MAGIC = 0x49474e49;
-    private static final int VERSION = 1;
+    private static final int VERSION = 2;
     private static final int MAX_RECORDS = 100_000;
     private final Path path;
 
@@ -27,9 +27,9 @@ public final class FileStateRepository implements StateRepository {
     public IgnisState load() throws IOException {
         if (Files.notExists(path)) return IgnisState.empty();
         try (var input = new DataInputStream(new BufferedInputStream(Files.newInputStream(path)))) {
-            if (input.readInt() != MAGIC || input.readInt() != VERSION) {
-                throw new IOException("Unsupported Ignis state header or version.");
-            }
+            if (input.readInt() != MAGIC) throw new IOException("Unsupported Ignis state header.");
+            int version = input.readInt();
+            if (version < 1 || version > VERSION) throw new IOException("Unsupported Ignis state version.");
             var limits = new ProgressLimits(input.readLong(), input.readLong(), input.readLong());
             Map<UUID, PlayerState> players = new HashMap<>();
             int count = count(input, MAX_RECORDS);
@@ -50,7 +50,20 @@ public final class FileStateRepository implements StateRepository {
                         throw new IOException("Duplicate pending reward.");
                     }
                 }
-                if (players.putIfAbsent(id, new PlayerState(tracks, pending)) != null) {
+                Map<UUID, Track> issued = new HashMap<>(pending);
+                if (version >= 2) {
+                    issued.clear();
+                    int receipts = count(input, MAX_RECORDS);
+                    for (int j = 0; j < receipts; j++) {
+                        if (issued.putIfAbsent(uuid(input), Track.valueOf(input.readUTF())) != null) {
+                            throw new IOException("Duplicate issued receipt.");
+                        }
+                    }
+                    if (!issued.entrySet().containsAll(pending.entrySet())) {
+                        throw new IOException("Pending reward has no matching issuance receipt.");
+                    }
+                }
+                if (players.putIfAbsent(id, new PlayerState(tracks, pending, issued)) != null) {
                     throw new IOException("Duplicate player.");
                 }
             }
@@ -64,7 +77,8 @@ public final class FileStateRepository implements StateRepository {
     @Override
     public void save(IgnisState state) throws IOException {
         if (state.players().size() > MAX_RECORDS
-                || state.players().values().stream().anyMatch(p -> p.pendingRewards().size() > MAX_RECORDS)) {
+                || state.players().values().stream().anyMatch(p -> p.pendingRewards().size() > MAX_RECORDS
+                        || p.issuedRewards().size() > MAX_RECORDS)) {
             throw new IOException("Ignis state exceeds supported record count.");
         }
         Files.createDirectories(path.getParent());
@@ -92,6 +106,11 @@ public final class FileStateRepository implements StateRepository {
                         uuid(output, reward.getKey());
                         output.writeUTF(reward.getValue().name());
                     }
+                    output.writeInt(entry.getValue().issuedRewards().size());
+                    for (var receipt : entry.getValue().issuedRewards().entrySet()) {
+                        uuid(output, receipt.getKey());
+                        output.writeUTF(receipt.getValue().name());
+                    }
                 }
             }
             try (var file = FileChannel.open(temporary, StandardOpenOption.WRITE)) { file.force(true); }

src/main/java/games/dmg/spigotignis/IgnisCommands.java

@@ -0,0 +1,181 @@
+package games.dmg.spigotignis;
+
+import java.util.HashMap;
+import java.util.List;
+import java.util.Locale;
+import java.util.Map;
+import java.util.Set;
+import java.util.UUID;
+import java.util.concurrent.CompletableFuture;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandExecutor;
+import org.bukkit.command.CommandSender;
+import org.bukkit.command.TabCompleter;
+import org.bukkit.plugin.java.JavaPlugin;
+
+public final class IgnisCommands implements CommandExecutor, TabCompleter {
+    private record Confirmation(UUID player, Set<Track> tracks, long expiresNanos) { }
+    private final JavaPlugin plugin;
+    private final StateService states;
+    private final EchoGameplay gameplay;
+    private final InvisibilityProgress maskTracker;
+    private final Map<CommandSender, Confirmation> confirmations = new HashMap<>();
+
+    public IgnisCommands(JavaPlugin plugin, StateService states, EchoGameplay gameplay) {
+        this(plugin, states, gameplay, null);
+    }
+
+    public IgnisCommands(JavaPlugin plugin, StateService states, EchoGameplay gameplay, InvisibilityProgress maskTracker) {
+        this.plugin = plugin;
+        this.states = states;
+        this.gameplay = gameplay;
+        this.maskTracker = maskTracker;
+    }
+
+    @Override public boolean onCommand(CommandSender sender, Command command, String label, String[] args) {
+        if (command.getName().equals("ignis")) {
+            if (!(sender instanceof org.bukkit.entity.Player player)) sender.sendMessage("This command is player-only.");
+            else if (args.length == 1 && args[0].equalsIgnoreCase("umbra")) {
+                var snapshot = states.snapshot();
+                var progress = snapshot.players().getOrDefault(player.getUniqueId(), PlayerState.empty());
+                sender.sendMessage(String.format(Locale.ROOT,
+                        "Invisibility %.2f/%.2f hours (%s); Pearls %d/%d (%s); Darkness %.2f/%.2f hours (%s).",
+                        progress.track(Track.MASK).progress() / 3_600_000.0, snapshot.limits().invisibilityMillis() / 3_600_000.0,
+                        status(progress, Track.MASK), progress.track(Track.DAGGER).progress(), snapshot.limits().pearls(),
+                        status(progress, Track.DAGGER), progress.track(Track.HEART).progress() / 3_600_000.0,
+                        snapshot.limits().darknessMillis() / 3_600_000.0, status(progress, Track.HEART)));
+            } else sender.sendMessage("Use /ignis umbra to privately inspect your progress.");
+            return true;
+        }
+        if (!sender.hasPermission("ignis.admin")) {
+            sender.sendMessage("You do not have permission to administer Ignis.");
+            return true;
+        }
+        try {
+            if (args.length == 2 && args[0].equalsIgnoreCase("inspect")) {
+                UUID id = resolve(args[1]);
+                var player = states.snapshot().players().getOrDefault(id, PlayerState.empty());
+                sender.sendMessage(id + ": " + player.tracks() + "; pending=" + player.pendingRewards().size()
+                        + "; issued=" + player.issuedRewards().size());
+            } else if (args.length == 1 && args[0].equalsIgnoreCase("limits")) {
+                sender.sendMessage(states.snapshot().limits().toString());
+            } else if (args.length == 4 && args[0].equalsIgnoreCase("limits") && args[1].equalsIgnoreCase("set")) {
+                long value = Long.parseLong(args[3]);
+                String setting = args[2].toLowerCase(Locale.ROOT);
+                if (!Set.of("mask-ms", "pearls", "darkness-ms").contains(setting)) throw new IllegalArgumentException("Unknown limit.");
+                mutation(sender, "limits " + setting + "=" + value, states.update(state -> {
+                    var limits = state.limits();
+                    return state.evaluate(new ProgressLimits(setting.equals("mask-ms") ? value : limits.invisibilityMillis(),
+                            setting.equals("pearls") ? value : limits.pearls(),
+                            setting.equals("darkness-ms") ? value : limits.darknessMillis()));
+                }));
+            } else if (args.length == 5 && args[0].equalsIgnoreCase("progress")
+                    && (args[1].equalsIgnoreCase("set") || args[1].equalsIgnoreCase("add"))) {
+                UUID id = resolve(args[2]);
+                Track track = Track.valueOf(args[3].toUpperCase(Locale.ROOT));
+                long value = Long.parseLong(args[4]);
+                boolean add = args[1].equalsIgnoreCase("add");
+                CompletableFuture<IgnisState> checkpoint = track == Track.MASK && maskTracker != null
+                        ? maskTracker.checkpoint(id) : CompletableFuture.completedFuture(states.snapshot());
+                mutation(sender, "progress " + id + " " + track + " " + args[1] + " " + value,
+                        checkpoint.thenCompose(ignored -> states.update(state -> ProgressAdministration.progress(state, id, track, value, add))));
+            } else if (args.length == 3 && args[0].equalsIgnoreCase("give") && args[2].equalsIgnoreCase("mask")) {
+                UUID id = resolve(args[1]), receipt = UUID.randomUUID();
+                mutation(sender, "grant Mask " + id, states.update(state -> MaskRewards.issue(state, id, receipt, true)));
+            } else if (args.length == 3 && (args[0].equalsIgnoreCase("give") && args[2].equalsIgnoreCase("echo")
+                    || args[0].equalsIgnoreCase("complete") && args[2].equalsIgnoreCase("void"))) {
+                UUID id = resolve(args[1]), receipt = UUID.randomUUID();
+                mutation(sender, "grant Echo " + id, states.update(state -> EchoRewards.award(state, id, receipt)));
+            } else if (args.length >= 3 && args[0].equalsIgnoreCase("reset")) {
+                UUID id = resolve(args[1]);
+                Set<Track> selected = args[2].equalsIgnoreCase("all") ? Set.of(Track.values())
+                        : Set.of(Track.valueOf(args[2].toUpperCase(Locale.ROOT)));
+                long now = System.nanoTime();
+                confirmations.values().removeIf(value -> now - value.expiresNanos() >= 0);
+                if (args.length == 3) {
+                    confirmations.put(sender, new Confirmation(id, selected, now + 30_000_000_000L));
+                    sender.sendMessage("Repeat /ignisadmin reset " + id + " " + args[2] + " confirm within 30 seconds.");
+                } else if (args.length == 4 && args[3].equalsIgnoreCase("confirm")) {
+                    Confirmation pending = confirmations.remove(sender);
+                    if (pending == null || !pending.player().equals(id) || !pending.tracks().equals(selected)) {
+                        throw new IllegalArgumentException("Request this reset before confirming it.");
+                    }
+                    if (selected.contains(Track.VOID)) gameplay.cancel(id);
+                    mutation(sender, "reset " + id + " " + selected,
+                            states.update(state -> ProgressAdministration.reset(state, id, selected)));
+                } else throw new IllegalArgumentException("Use reset <player|UUID> <track|all> [confirm].");
+            } else sender.sendMessage("Ignis admin: inspect <player|UUID>; limits [set <mask-ms|pearls|darkness-ms> <value>]; "
+                    + "progress <set|add> <player|UUID> <mask|dagger|heart> <value>; complete <player|UUID> void; "
+                    + "give <player|UUID> <echo|mask>; reset <player|UUID> <track|all> [confirm].");
+        } catch (IllegalArgumentException | ArithmeticException exception) {
+            sender.sendMessage("Invalid Ignis command: " + exception.getMessage());
+        }
+        return true;
+    }
+
+    private UUID resolve(String value) {
+        try {
+            UUID id = UUID.fromString(value);
+            if (states.snapshot().players().containsKey(id)) return id;
+        } catch (IllegalArgumentException ignored) { /* Try an online name without network lookups. */ }
+        var player = plugin.getServer().getPlayerExact(value);
+        if (player != null) return player.getUniqueId();
+        throw new IllegalArgumentException("Use an online player name or a known player's UUID.");
+    }
+
+    private void mutation(CommandSender sender, String description, CompletableFuture<IgnisState> result) {
+        String actor = sender.getName();
+        result.whenComplete((state, error) -> {
+            plugin.getLogger().info("Ignis admin " + actor + ": " + description + (error == null ? " succeeded" : " failed"));
+            gameplay.onServer(() -> {
+                sender.sendMessage(error == null ? "Ignis change saved." : "Ignis change failed; previous state retained.");
+                if (error == null) gameplay.retryDeliveries();
+            });
+        });
+    }
+
+    private static String status(PlayerState state, Track track) {
+        return state.track(track).unlocked() ? "unlocked" : "locked";
+    }
+
+    @Override public List<String> onTabComplete(CommandSender sender, Command command, String alias, String[] args) {
+        if (args.length == 0) return List.of();
+        if (command.getName().equals("ignis")) return sender instanceof org.bukkit.entity.Player && args.length == 1
+                ? matching(List.of("umbra"), args[0]) : List.of();
+        if (!sender.hasPermission("ignis.admin")) return List.of();
+        String sub = args[0].toLowerCase(Locale.ROOT);
+        List<String> options = List.of();
+        if (args.length == 1) options = List.of("inspect", "limits", "progress", "complete", "give", "reset");
+        else if (args.length == 2 && Set.of("inspect", "complete", "give", "reset").contains(sub)
+                || args.length == 3 && sub.equals("progress")) {
+            var players = new java.util.ArrayList<String>();
+            states.snapshot().players().keySet().forEach(id -> players.add(id.toString()));
+            plugin.getServer().getOnlinePlayers().forEach(player -> players.add(player.getName()));
+            options = players;
+        } else if (sub.equals("limits")) {
+            if (args.length == 2) options = List.of("set");
+            else if (args.length == 3) options = List.of("mask-ms", "pearls", "darkness-ms");
+            else if (args.length == 4) options = switch (args[2].toLowerCase(Locale.ROOT)) {
+                case "mask-ms" -> List.of("43200000");
+                case "pearls" -> List.of("313");
+                case "darkness-ms" -> List.of("21600000");
+                default -> List.of();
+            };
+        } else if (sub.equals("progress")) {
+            if (args.length == 2) options = List.of("set", "add");
+            else if (args.length == 4) options = List.of("mask", "dagger", "heart");
+            else if (args.length == 5) options = List.of("0", "1");
+        } else if (args.length == 3 && sub.equals("give")) options = List.of("echo", "mask");
+        else if (args.length == 3 && sub.equals("complete")) options = List.of("void");
+        else if (sub.equals("reset")) {
+            if (args.length == 3) options = List.of("void", "mask", "dagger", "heart", "all");
+            else if (args.length == 4) options = List.of("confirm");
+        }
+        return matching(options, args[args.length - 1]);
+    }
+
+    private static List<String> matching(List<String> options, String prefix) {
+        return options.stream().filter(value -> value.toLowerCase(Locale.ROOT).startsWith(prefix.toLowerCase(Locale.ROOT)))
+                .distinct().sorted().toList();
+    }
+}

src/main/java/games/dmg/spigotignis/IgnisState.java

@@ -32,7 +32,7 @@ public record IgnisState(ProgressLimits limits, Map<UUID, PlayerState> players)
                             previous.activated(), previous.generation()));
                 }
             }
-            evaluated.put(id, new PlayerState(tracks, player.pendingRewards()));
+            evaluated.put(id, new PlayerState(tracks, player.pendingRewards(), player.issuedRewards()));
         });
         return new IgnisState(nextLimits, evaluated);
     }

src/main/java/games/dmg/spigotignis/InvisibilityAttribution.java

@@ -0,0 +1,12 @@
+package games.dmg.spigotignis;
+
+/** Attributes only actual, uncancelled invisibility changes to their source. */
+public final class InvisibilityAttribution {
+    public enum Transition { KEEP, START, STOP }
+    private InvisibilityAttribution() { }
+    public static Transition transition(boolean invisibility, boolean cancelled, boolean changed,
+            boolean remainsPresent, boolean directlyDrank) {
+        if (!invisibility || cancelled || !changed) return Transition.KEEP;
+        return remainsPresent && directlyDrank ? Transition.START : Transition.STOP;
+    }
+}

src/main/java/games/dmg/spigotignis/InvisibilityProgress.java

@@ -0,0 +1,92 @@
+package games.dmg.spigotignis;
+
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Objects;
+import java.util.UUID;
+import java.util.concurrent.CompletableFuture;
+import java.util.function.LongSupplier;
+
+/** Monotonic qualifying intervals. No wall-clock/offline time and no Bukkit access. */
+public final class InvisibilityProgress {
+    private static final class Session {
+        private long generation;
+        private long lastNanos;
+        private long pendingNanos;
+        private boolean active;
+        private CompletableFuture<IgnisState> pendingSave;
+        private Session(long generation, long now) { this.generation = generation; lastNanos = now; }
+    }
+    private final StateService states;
+    private final LongSupplier nanoTime;
+    private final Map<UUID, Session> sessions = new HashMap<>();
+
+    public InvisibilityProgress(StateService states, LongSupplier nanoTime) {
+        this.states = Objects.requireNonNull(states);
+        this.nanoTime = Objects.requireNonNull(nanoTime);
+    }
+
+    public synchronized void drink(UUID player) {
+        Session session = accrue(player);
+        session.active = true;
+    }
+
+    public synchronized CompletableFuture<IgnisState> stop(UUID player) {
+        Session session = accrue(player);
+        session.active = false;
+        return checkpoint(player);
+    }
+
+    public synchronized CompletableFuture<IgnisState> checkpoint(UUID player) {
+        Session session = accrue(player);
+        long milliseconds = session.pendingNanos / 1_000_000L;
+        if (milliseconds == 0) return session.pendingSave != null ? session.pendingSave
+                : CompletableFuture.completedFuture(states.snapshot());
+        long reservedNanos = milliseconds * 1_000_000L;
+        long generation = session.generation;
+        session.pendingNanos -= reservedNanos;
+        var result = states.update(state -> {
+            long currentGeneration = state.players().getOrDefault(player, PlayerState.empty()).track(Track.MASK).generation();
+            return currentGeneration == generation
+                    ? ProgressAdministration.progress(state, player, Track.MASK, milliseconds, true) : state;
+        });
+        var acknowledgement = new CompletableFuture<IgnisState>();
+        session.pendingSave = acknowledgement;
+        result.whenComplete((saved, error) -> {
+            synchronized (this) {
+                if (error != null && session.generation == generation) {
+                    session.pendingNanos = Math.addExact(session.pendingNanos, reservedNanos);
+                }
+                if (session.pendingSave == acknowledgement) session.pendingSave = null;
+            }
+            if (error != null) acknowledgement.completeExceptionally(error);
+            else acknowledgement.complete(saved);
+        });
+        return acknowledgement;
+    }
+
+    public synchronized CompletableFuture<Void> checkpointAll() {
+        return CompletableFuture.allOf(java.util.List.copyOf(sessions.keySet()).stream()
+                .map(this::checkpoint).toArray(CompletableFuture[]::new));
+    }
+
+    public synchronized CompletableFuture<Void> stopAll() {
+        return CompletableFuture.allOf(java.util.List.copyOf(sessions.keySet()).stream()
+                .map(this::stop).toArray(CompletableFuture[]::new));
+    }
+
+    private Session accrue(UUID player) {
+        Objects.requireNonNull(player);
+        long now = nanoTime.getAsLong();
+        long generation = states.snapshot().players().getOrDefault(player, PlayerState.empty()).track(Track.MASK).generation();
+        Session session = sessions.computeIfAbsent(player, ignored -> new Session(generation, now));
+        if (generation != session.generation) {
+            session.generation = generation;
+            session.pendingNanos = 0;
+        } else if (session.active) {
+            session.pendingNanos = Math.addExact(session.pendingNanos, Math.max(0, now - session.lastNanos));
+        }
+        session.lastNanos = now;
+        return session;
+    }
+}

src/main/java/games/dmg/spigotignis/MaskCrafting.java

@@ -0,0 +1,133 @@
+package games.dmg.spigotignis;
+
+import java.util.HashSet;
+import java.util.Set;
+import java.util.UUID;
+import org.bukkit.Keyed;
+import org.bukkit.Material;
+import org.bukkit.NamespacedKey;
+import org.bukkit.entity.Player;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.EventPriority;
+import org.bukkit.event.Listener;
+import org.bukkit.event.block.CrafterCraftEvent;
+import org.bukkit.event.inventory.CraftItemEvent;
+import org.bukkit.event.inventory.PrepareItemCraftEvent;
+import org.bukkit.inventory.CraftingInventory;
+import org.bukkit.inventory.Recipe;
+import org.bukkit.inventory.ShapedRecipe;
+import org.bukkit.plugin.java.JavaPlugin;
+
+/** Receipts precede crafting; vanilla owns all ingredient consumption, including shift-crafting. */
+public final class MaskCrafting implements Listener, Runnable {
+    public static final NamespacedKey RECIPE = new NamespacedKey("spigotignis", "mask");
+    private final JavaPlugin plugin;
+    private final StateService states;
+    private final MaskItems items;
+    private final EchoGameplay dispatch;
+    private final Set<UUID> preparing = new HashSet<>();
+    private final Set<MaskToken> delivering = new HashSet<>();
+    private boolean registered;
+    private final java.util.function.Function<org.bukkit.inventory.ItemStack, ShapedRecipe> recipeFactory;
+
+    public MaskCrafting(JavaPlugin plugin, StateService states, MaskItems items, EchoGameplay dispatch) {
+        this(plugin, states, items, dispatch, result -> new ShapedRecipe(RECIPE, result));
+    }
+
+    MaskCrafting(JavaPlugin plugin, StateService states, MaskItems items, EchoGameplay dispatch,
+            java.util.function.Function<org.bukkit.inventory.ItemStack, ShapedRecipe> recipeFactory) {
+        this.plugin = plugin; this.states = states; this.items = items; this.dispatch = dispatch;
+        this.recipeFactory = recipeFactory;
+    }
+
+    @EventHandler(priority = EventPriority.HIGHEST, ignoreCancelled = true)
+    public void onCraft(CraftItemEvent event) {
+        if (!isMask(event.getRecipe())) return;
+        var identity = items.identify(event.getInventory().getResult());
+        if (!(event.getWhoClicked() instanceof Player player) || identity.isEmpty()
+                || !identity.orElseThrow().issuer().equals(player.getUniqueId())
+                || !MaskRewards.valid(states.snapshot(), player.getUniqueId(), identity.orElseThrow())) {
+            event.setCancelled(true);
+            event.getInventory().setResult(null);
+        }
+    }
+
+    @EventHandler(priority = EventPriority.HIGHEST, ignoreCancelled = true)
+    public void onCrafter(CrafterCraftEvent event) {
+        if (isMask(event.getRecipe())) event.setCancelled(true);
+    }
+
+    @EventHandler(priority = EventPriority.HIGHEST)
+    public void onPrepare(PrepareItemCraftEvent event) {
+        if (!isMask(event.getInventory().getRecipe()) || event.getInventory().getResult() == null) return;
+        if (!(event.getView().getPlayer() instanceof Player player) || !items.ready()) {
+            event.getInventory().setResult(null);
+            return;
+        }
+        var token = MaskRewards.craftingToken(states.snapshot(), player.getUniqueId());
+        event.getInventory().setResult(token.map(items::create).orElse(null));
+        if (token.isEmpty()) ensureReceipt(player);
+    }
+
+    @Override public void run() {
+        if (!items.ready()) return;
+        if (!registered) {
+            var recipe = recipeFactory.apply(items.prototype());
+            recipe.shape("NNN", "NSN", "NNN");
+            recipe.setIngredient('N', Material.NETHERITE_BLOCK);
+            recipe.setIngredient('S', Material.NETHER_STAR);
+            registered = plugin.getServer().addRecipe(recipe);
+            if (!registered) return;
+        }
+        for (Player player : plugin.getServer().getOnlinePlayers()) {
+            var state = states.snapshot().players().getOrDefault(player.getUniqueId(), PlayerState.empty());
+            if (!state.track(Track.MASK).unlocked()) {
+                if (player.hasDiscoveredRecipe(RECIPE)) player.undiscoverRecipe(RECIPE);
+                continue;
+            }
+            ensureReceipt(player);
+            if (!player.hasDiscoveredRecipe(RECIPE)) player.discoverRecipe(RECIPE);
+            for (var entry : state.pendingRewards().entrySet()) {
+                if (entry.getValue() != Track.MASK) continue;
+                var token = new MaskToken(player.getUniqueId(), entry.getKey(), state.track(Track.MASK).generation());
+                if (delivering.contains(token) || !items.offer(player, token)) continue;
+                delivering.add(token);
+                states.update(current -> MaskRewards.acknowledge(current, token))
+                        .whenComplete((ignored, error) -> dispatch.onServer(() -> delivering.remove(token)));
+            }
+        }
+    }
+
+    private void ensureReceipt(Player player) {
+        UUID owner = player.getUniqueId();
+        var snapshot = states.snapshot();
+        var state = snapshot.players().getOrDefault(owner, PlayerState.empty()).track(Track.MASK);
+        if (!state.unlocked() || MaskRewards.craftingToken(snapshot, owner).isPresent() || !preparing.add(owner)) return;
+        UUID receipt = UUID.randomUUID();
+        long generation = state.generation();
+        states.update(current -> {
+            var now = current.players().getOrDefault(owner, PlayerState.empty()).track(Track.MASK);
+            return now.unlocked() && now.generation() == generation
+                    ? MaskRewards.issue(current, owner, receipt, false) : current;
+        }).whenComplete((ignored, error) -> dispatch.onServer(() -> {
+            preparing.remove(owner);
+            Player online = plugin.getServer().getPlayer(owner);
+            if (error != null || online == null || !items.ready()) return;
+            var view = online.getOpenInventory();
+            if (view.getTopInventory() instanceof CraftingInventory inventory && isMask(inventory.getRecipe())) {
+                // Re-run preparation so other plugins retain their chance to deny/adjust the result.
+                inventory.setResult(items.prototype());
+                plugin.getServer().getPluginManager().callEvent(new PrepareItemCraftEvent(inventory, view, false));
+                online.updateInventory();
+            }
+        }));
+    }
+
+    public void close() {
+        if (registered) plugin.getServer().removeRecipe(RECIPE);
+    }
+
+    private static boolean isMask(Recipe recipe) {
+        return recipe instanceof Keyed keyed && keyed.getKey().equals(RECIPE);
+    }
+}

src/main/java/games/dmg/spigotignis/MaskEffects.java

@@ -0,0 +1,90 @@
+package games.dmg.spigotignis;
+
+import java.util.HashSet;
+import java.util.Set;
+import java.util.concurrent.atomic.AtomicReference;
+import org.bukkit.Material;
+import org.bukkit.entity.Player;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.EventPriority;
+import org.bukkit.event.Listener;
+import org.bukkit.event.entity.EntityPotionEffectEvent;
+import org.bukkit.event.player.PlayerQuitEvent;
+import org.bukkit.inventory.EquipmentSlot;
+import org.bukkit.inventory.ItemStack;
+import org.bukkit.plugin.java.JavaPlugin;
+import org.bukkit.potion.PotionEffect;
+import org.bukkit.potion.PotionEffectType;
+
+/** Server-thread effect ownership and client-only helmet projection. */
+public final class MaskEffects implements Listener, Runnable {
+    private final JavaPlugin plugin;
+    private final StateService states;
+    private final MaskItems items;
+    private final EffectOwnership ownership = new EffectOwnership();
+    private final AtomicReference<Set<Integer>> hidden = new AtomicReference<>(Set.of());
+
+    public MaskEffects(JavaPlugin plugin, StateService states, MaskItems items) {
+        this.plugin = plugin; this.states = states; this.items = items;
+    }
+    public Set<Integer> hiddenEntityIds() { return hidden.get(); }
+
+    @EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = true)
+    public void onEffect(EntityPotionEffectEvent event) {
+        if (event.getEntity() instanceof Player player && event.getModifiedType().equals(PotionEffectType.INVISIBILITY)) {
+            ownership.changed(player.getUniqueId(), event.getAction() != EntityPotionEffectEvent.Action.CHANGED || event.isOverride(),
+                    event.getNewEffect() != null);
+        }
+    }
+    @EventHandler public void onQuit(PlayerQuitEvent event) {
+        removeOwn(event.getPlayer());
+        ownership.forget(event.getPlayer().getUniqueId());
+        var next = new HashSet<>(hidden.get());
+        next.remove(event.getPlayer().getEntityId());
+        hidden.set(Set.copyOf(next));
+    }
+
+    @Override public void run() {
+        Set<Integer> before = hidden.get();
+        Set<Integer> next = new HashSet<>();
+        for (Player player : plugin.getServer().getOnlinePlayers()) {
+            var token = items.identify(player.getInventory().getHelmet());
+            boolean eligible = !player.isDead() && token.filter(value -> MaskRewards.valid(states.snapshot(), player.getUniqueId(), value)).isPresent();
+            if (eligible) {
+                PotionEffect current = player.getPotionEffect(PotionEffectType.INVISIBILITY);
+                if (current == null || ownership.owns(player.getUniqueId()) && current.getDuration() <= 20) {
+                    ownership.applying(player.getUniqueId(), true);
+                    try { player.addPotionEffect(new PotionEffect(PotionEffectType.INVISIBILITY, 40, 0, true, false, false)); }
+                    finally { ownership.applying(player.getUniqueId(), false); }
+                }
+                if (player.hasPotionEffect(PotionEffectType.INVISIBILITY)) next.add(player.getEntityId());
+            } else removeOwn(player);
+        }
+        hidden.set(Set.copyOf(next));
+        for (Player player : plugin.getServer().getOnlinePlayers()) {
+            if (before.contains(player.getEntityId()) != next.contains(player.getEntityId())) refreshEquipment(player);
+        }
+    }
+
+    private void removeOwn(Player player) {
+        if (ownership.owns(player.getUniqueId())) {
+            player.removePotionEffect(PotionEffectType.INVISIBILITY);
+            ownership.forget(player.getUniqueId());
+        }
+    }
+
+    private void refreshEquipment(Player player) {
+        ItemStack helmet = player.getInventory().getHelmet();
+        if (helmet == null) helmet = new ItemStack(Material.AIR);
+        for (Player observer : player.getTrackedBy()) observer.sendEquipmentChange(player, EquipmentSlot.HEAD, helmet);
+        player.sendEquipmentChange(player, EquipmentSlot.HEAD, helmet);
+    }
+
+    public void close() {
+        Set<Integer> previous = hidden.getAndSet(Set.of());
+        for (Player player : plugin.getServer().getOnlinePlayers()) {
+            removeOwn(player);
+            if (previous.contains(player.getEntityId())) refreshEquipment(player);
+        }
+    }
+}

src/main/java/games/dmg/spigotignis/MaskEquipmentListener.java

@@ -0,0 +1,51 @@
+package games.dmg.spigotignis;
+
+import com.comphenix.protocol.PacketType;
+import com.comphenix.protocol.events.ListenerPriority;
+import com.comphenix.protocol.events.PacketAdapter;
+import com.comphenix.protocol.events.PacketEvent;
+import com.comphenix.protocol.wrappers.EnumWrappers;
+import com.comphenix.protocol.wrappers.Pair;
+import java.util.ArrayList;
+import java.util.Set;
+import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.function.Supplier;
+import org.bukkit.Material;
+import org.bukkit.inventory.ItemStack;
+import org.bukkit.plugin.Plugin;
+
+/** Packet thread reads an immutable entity-ID snapshot, never mutable Bukkit state. */
+public final class MaskEquipmentListener extends PacketAdapter {
+    private final Supplier<Set<Integer>> wearers;
+    private final AtomicBoolean warned = new AtomicBoolean();
+    private final java.util.function.Consumer<String> warning;
+
+    public MaskEquipmentListener(Plugin plugin, Supplier<Set<Integer>> wearers, java.util.function.Consumer<String> warning) {
+        super(plugin, ListenerPriority.HIGHEST, PacketType.Play.Server.ENTITY_EQUIPMENT);
+        this.wearers = wearers;
+        this.warning = warning;
+    }
+
+    public static java.util.List<Pair<EnumWrappers.ItemSlot, ItemStack>> project(
+            java.util.List<Pair<EnumWrappers.ItemSlot, ItemStack>> equipment, ItemStack empty) {
+        var projected = new ArrayList<Pair<EnumWrappers.ItemSlot, ItemStack>>();
+        for (var pair : equipment) {
+            projected.add(pair.getFirst() == EnumWrappers.ItemSlot.HEAD ? new Pair<>(pair.getFirst(), empty) : pair);
+        }
+        return projected;
+    }
+
+    @Override public void onPacketSending(PacketEvent event) {
+        if (event.isCancelled()) return;
+        try {
+            if (!wearers.get().contains(event.getPacket().getIntegers().read(0))) return;
+            var packet = event.getPacket().shallowClone();
+            packet.getSlotStackPairLists().write(0, project(packet.getSlotStackPairLists().read(0), new ItemStack(Material.AIR)));
+            event.setPacket(packet);
+        } catch (RuntimeException exception) {
+            if (warned.compareAndSet(false, true)) {
+                warning.accept("Mask helmet projection unavailable; original equipment packet retained. Verify ProtocolLib/server compatibility.");
+            }
+        }
+    }
+}

src/main/java/games/dmg/spigotignis/MaskItems.java

@@ -0,0 +1,59 @@
+package games.dmg.spigotignis;
+
+import java.util.Optional;
+import net.kyori.adventure.text.Component;
+import net.kyori.adventure.text.format.NamedTextColor;
+import org.bukkit.Material;
+import org.bukkit.NamespacedKey;
+import org.bukkit.entity.Player;
+import org.bukkit.inventory.ItemStack;
+import org.bukkit.inventory.meta.SkullMeta;
+import org.bukkit.persistence.PersistentDataType;
+import org.bukkit.profile.PlayerProfile;
+
+public final class MaskItems {
+    private static final NamespacedKey IDENTITY = new NamespacedKey("spigotignis", "mask_identity");
+    private PlayerProfile profile;
+
+    public boolean ready() { return profile != null; }
+    public void profile(PlayerProfile resolved) {
+        if (resolved.getUniqueId() == null || resolved.getTextures().getSkin() == null) {
+            throw new IllegalArgumentException("The Mask skin profile is incomplete.");
+        }
+        profile = resolved.clone();
+    }
+
+    public ItemStack prototype() {
+        if (!ready()) throw new IllegalStateException("The Mask skin is unavailable.");
+        var item = new ItemStack(Material.PLAYER_HEAD);
+        var meta = (SkullMeta) item.getItemMeta();
+        meta.displayName(Component.text("The Mask", NamedTextColor.DARK_PURPLE));
+        meta.setOwnerProfile(profile);
+        item.setItemMeta(meta);
+        return item;
+    }
+
+    public ItemStack create(MaskToken token) {
+        var item = prototype();
+        var meta = item.getItemMeta();
+        meta.getPersistentDataContainer().set(IDENTITY, PersistentDataType.STRING,
+                EchoIdentity.encode(new EchoToken(token.issuer(), token.receipt(), token.generation())));
+        item.setItemMeta(meta);
+        return item;
+    }
+
+    public Optional<MaskToken> identify(ItemStack item) {
+        if (item == null || item.getType() != Material.PLAYER_HEAD || !item.hasItemMeta()) return Optional.empty();
+        return EchoIdentity.decode(item.getItemMeta().getPersistentDataContainer().get(IDENTITY, PersistentDataType.STRING))
+                .map(token -> new MaskToken(token.owner(), token.receipt(), token.generation()));
+    }
+
+    public boolean offer(Player player, MaskToken token) {
+        for (var item : player.getInventory().getContents()) {
+            if (identify(item).filter(token::equals).isPresent()) return true;
+        }
+        if (identify(player.getItemOnCursor()).filter(token::equals).isPresent()) return true;
+        if (player.getInventory().firstEmpty() < 0) return false;
+        return player.getInventory().addItem(create(token)).isEmpty();
+    }
+}

src/main/java/games/dmg/spigotignis/MaskProgressListener.java

@@ -0,0 +1,78 @@
+package games.dmg.spigotignis;
+
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.atomic.AtomicBoolean;
+import org.bukkit.NamespacedKey;
+import org.bukkit.entity.Player;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.EventPriority;
+import org.bukkit.event.Listener;
+import org.bukkit.event.entity.EntityPotionEffectEvent;
+import org.bukkit.event.entity.PlayerDeathEvent;
+import org.bukkit.event.player.PlayerJoinEvent;
+import org.bukkit.event.player.PlayerQuitEvent;
+import org.bukkit.persistence.PersistentDataType;
+import org.bukkit.plugin.java.JavaPlugin;
+import org.bukkit.potion.PotionEffectType;
+
+/** Provenance marker survives offline time; online elapsed time is tracked separately. */
+public final class MaskProgressListener implements Listener {
+    private static final NamespacedKey DRANK = new NamespacedKey("spigotignis", "qualifying_invisibility");
+    private final JavaPlugin plugin;
+    private final InvisibilityProgress tracker;
+    private final AtomicBoolean warned = new AtomicBoolean();
+
+    public MaskProgressListener(JavaPlugin plugin, InvisibilityProgress tracker) {
+        this.plugin = plugin;
+        this.tracker = tracker;
+    }
+
+    @EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = true)
+    public void onEffect(EntityPotionEffectEvent event) {
+        if (!(event.getEntity() instanceof Player player)) return;
+        boolean changed = event.getAction() != EntityPotionEffectEvent.Action.CHANGED || event.isOverride();
+        var transition = InvisibilityAttribution.transition(
+                event.getModifiedType().equals(PotionEffectType.INVISIBILITY), event.isCancelled(), changed,
+                event.getNewEffect() != null, event.getCause() == EntityPotionEffectEvent.Cause.POTION_DRINK);
+        switch (transition) {
+            case START -> {
+                player.getPersistentDataContainer().set(DRANK, PersistentDataType.BYTE, (byte) 1);
+                tracker.drink(player.getUniqueId());
+            }
+            case STOP -> {
+                player.getPersistentDataContainer().remove(DRANK);
+                observe(tracker.stop(player.getUniqueId()));
+            }
+            case KEEP -> { }
+        }
+    }
+
+    public void resume(Player player) {
+        if (!player.isOnline()) return;
+        if (!player.isDead() && player.hasPotionEffect(PotionEffectType.INVISIBILITY)
+                && Byte.valueOf((byte) 1).equals(player.getPersistentDataContainer().get(DRANK, PersistentDataType.BYTE))) {
+            tracker.drink(player.getUniqueId());
+        } else player.getPersistentDataContainer().remove(DRANK);
+    }
+
+    @EventHandler public void onJoin(PlayerJoinEvent event) {
+        plugin.getServer().getScheduler().runTask(plugin, () -> resume(event.getPlayer()));
+    }
+    @EventHandler public void onQuit(PlayerQuitEvent event) { observe(tracker.stop(event.getPlayer().getUniqueId())); }
+    @EventHandler public void onDeath(PlayerDeathEvent event) {
+        event.getEntity().getPersistentDataContainer().remove(DRANK);
+        observe(tracker.stop(event.getEntity().getUniqueId()));
+    }
+
+    public void checkpoint() { observe(tracker.checkpointAll()); }
+    public void stop() { observe(tracker.stopAll()); }
+
+    private void observe(CompletableFuture<?> result) {
+        result.whenComplete((ignored, error) -> {
+            if (error == null) warned.set(false);
+            else if (warned.compareAndSet(false, true)) {
+                plugin.getLogger().warning("Mask progress save failed; elapsed credit is retained in memory for retry. Check storage before stopping the server.");
+            }
+        });
+    }
+}

src/main/java/games/dmg/spigotignis/MaskRewards.java

@@ -0,0 +1,58 @@
+package games.dmg.spigotignis;
+
+import java.util.HashMap;
+import java.util.Optional;
+import java.util.UUID;
+
+/** Crafting receipts are durable before vanilla may offer a result or consume ingredients. */
+public final class MaskRewards {
+    private MaskRewards() { }
+
+    public static IgnisState issue(IgnisState state, UUID issuer, UUID receipt, boolean adminGrant) {
+        PlayerState player = state.players().getOrDefault(issuer, PlayerState.empty());
+        TrackState previous = player.track(Track.MASK);
+        if (!adminGrant && !previous.unlocked()) throw new IllegalArgumentException("Mask crafting is not unlocked.");
+        if (player.issuedRewards().containsKey(receipt)) {
+            if (player.issuedRewards().get(receipt) != Track.MASK) throw new IllegalArgumentException("Receipt is already used.");
+            return state;
+        }
+        var tracks = new HashMap<>(player.tracks());
+        tracks.put(Track.MASK, new TrackState(previous.progress(), true, previous.activated(), previous.generation()));
+        var issued = new HashMap<>(player.issuedRewards());
+        issued.put(receipt, Track.MASK);
+        var pending = new HashMap<>(player.pendingRewards());
+        if (adminGrant) pending.put(receipt, Track.MASK);
+        return replace(state, issuer, new PlayerState(tracks, pending, issued));
+    }
+
+    public static boolean valid(IgnisState state, UUID holder, MaskToken token) {
+        PlayerState origin = state.players().getOrDefault(token.issuer(), PlayerState.empty());
+        return state.players().getOrDefault(holder, PlayerState.empty()).track(Track.MASK).unlocked()
+                && origin.track(Track.MASK).unlocked()
+                && origin.track(Track.MASK).generation() == token.generation()
+                && origin.issuedRewards().get(token.receipt()) == Track.MASK;
+    }
+
+    public static Optional<MaskToken> craftingToken(IgnisState state, UUID issuer) {
+        PlayerState player = state.players().getOrDefault(issuer, PlayerState.empty());
+        if (!player.track(Track.MASK).unlocked()) return Optional.empty();
+        return player.issuedRewards().entrySet().stream().filter(entry -> entry.getValue() == Track.MASK)
+                .filter(entry -> !player.pendingRewards().containsKey(entry.getKey()))
+                .map(java.util.Map.Entry::getKey).sorted().findFirst()
+                .map(id -> new MaskToken(issuer, id, player.track(Track.MASK).generation()));
+    }
+
+    public static IgnisState acknowledge(IgnisState state, MaskToken token) {
+        if (!valid(state, token.issuer(), token)) return state;
+        PlayerState player = state.players().get(token.issuer());
+        var pending = new HashMap<>(player.pendingRewards());
+        pending.remove(token.receipt());
+        return replace(state, token.issuer(), new PlayerState(player.tracks(), pending, player.issuedRewards()));
+    }
+
+    private static IgnisState replace(IgnisState state, UUID issuer, PlayerState player) {
+        var players = new HashMap<>(state.players());
+        players.put(issuer, player);
+        return new IgnisState(state.limits(), players);
+    }
+}

src/main/java/games/dmg/spigotignis/MaskSkinLoader.java

@@ -0,0 +1,35 @@
+package games.dmg.spigotignis;
+
+import java.util.concurrent.TimeUnit;
+import org.bukkit.plugin.java.JavaPlugin;
+
+/** Fixed, approved skin name; profile resolution uses the server's asynchronous API. */
+public final class MaskSkinLoader implements Runnable {
+    private final JavaPlugin plugin;
+    private final MaskItems items;
+    private final EchoGameplay dispatch;
+    private boolean fetching;
+
+    public MaskSkinLoader(JavaPlugin plugin, MaskItems items, EchoGameplay dispatch) {
+        this.plugin = plugin; this.items = items; this.dispatch = dispatch;
+    }
+
+    @Override public void run() {
+        if (items.ready() || fetching) return;
+        fetching = true;
+        try {
+            plugin.getServer().createPlayerProfile("IgnisUmbra10").update().orTimeout(20, TimeUnit.SECONDS)
+                    .whenComplete((profile, error) -> dispatch.onServer(() -> {
+                        fetching = false;
+                        if (error == null) {
+                            try { items.profile(profile); return; }
+                            catch (IllegalArgumentException ignored) { /* No default/wrong skin reward. */ }
+                        }
+                        plugin.getLogger().warning("Mask skin resolution unavailable; crafting and pending item delivery wait for retry.");
+                    }));
+        } catch (RuntimeException exception) {
+            fetching = false;
+            plugin.getLogger().warning("Mask profile request could not start; crafting waits for retry.");
+        }
+    }
+}

src/main/java/games/dmg/spigotignis/MaskToken.java

@@ -0,0 +1,12 @@
+package games.dmg.spigotignis;
+
+import java.util.Objects;
+import java.util.UUID;
+
+public record MaskToken(UUID issuer, UUID receipt, long generation) {
+    public MaskToken {
+        Objects.requireNonNull(issuer);
+        Objects.requireNonNull(receipt);
+        if (generation < 0) throw new IllegalArgumentException("Invalid Mask generation.");
+    }
+}

src/main/java/games/dmg/spigotignis/PlayerState.java

@@ -3,11 +3,20 @@ package games.dmg.spigotignis;
 import java.util.Map;
 import java.util.UUID;
 
-/** Pending reward identifiers are durable; gameplay delivery is a later adapter. */
-public record PlayerState(Map<Track, TrackState> tracks, Map<UUID, Track> pendingRewards) {
+/** Pending delivery and issued-item receipts are separate to permit retry without granting twice. */
+public record PlayerState(Map<Track, TrackState> tracks, Map<UUID, Track> pendingRewards,
+        Map<UUID, Track> issuedRewards) {
     public PlayerState {
         tracks = Map.copyOf(tracks);
         pendingRewards = Map.copyOf(pendingRewards);
+        issuedRewards = Map.copyOf(issuedRewards);
+        if (!issuedRewards.entrySet().containsAll(pendingRewards.entrySet())) {
+            throw new IllegalArgumentException("Pending rewards require matching issuance receipts.");
+        }
+    }
+
+    public PlayerState(Map<Track, TrackState> tracks, Map<UUID, Track> pendingRewards) {
+        this(tracks, pendingRewards, pendingRewards);
     }
 
     public static PlayerState empty() { return new PlayerState(Map.of(), Map.of()); }

src/main/java/games/dmg/spigotignis/ProgressAdministration.java

@@ -0,0 +1,35 @@
+package games.dmg.spigotignis;
+
+import java.util.Set;
+import java.util.HashMap;
+import java.util.UUID;
+
+public final class ProgressAdministration {
+    private ProgressAdministration() { }
+    public static IgnisState progress(IgnisState state, UUID player, Track track, long value, boolean add) {
+        if (value < 0 || track == Track.VOID) throw new IllegalArgumentException("Use nonnegative progress or complete void.");
+        var previous = state.players().getOrDefault(player, PlayerState.empty());
+        TrackState current = previous.track(track);
+        long updated = add ? Math.addExact(current.progress(), value) : value;
+        var tracks = new HashMap<>(previous.tracks());
+        tracks.put(track, new TrackState(updated, current.unlocked(), current.activated(), current.generation()));
+        var players = new HashMap<>(state.players());
+        players.put(player, new PlayerState(tracks, previous.pendingRewards(), previous.issuedRewards()));
+        return new IgnisState(state.limits(), players).evaluate(state.limits());
+    }
+
+    public static IgnisState reset(IgnisState state, UUID playerId, Set<Track> selected) {
+        PlayerState player = state.players().getOrDefault(playerId, PlayerState.empty());
+        var tracks = new HashMap<>(player.tracks());
+        for (Track track : selected) {
+            tracks.put(track, new TrackState(0, false, false, Math.addExact(player.track(track).generation(), 1)));
+        }
+        var pending = new HashMap<>(player.pendingRewards());
+        var issued = new HashMap<>(player.issuedRewards());
+        pending.entrySet().removeIf(entry -> selected.contains(entry.getValue()));
+        issued.entrySet().removeIf(entry -> selected.contains(entry.getValue()));
+        var players = new HashMap<>(state.players());
+        players.put(playerId, new PlayerState(tracks, pending, issued));
+        return new IgnisState(state.limits(), players);
+    }
+}

src/main/java/games/dmg/spigotignis/SpigotIgnisPlugin.java

@@ -3,9 +3,13 @@ package games.dmg.spigotignis;
 import java.util.concurrent.CompletableFuture;
 import org.bukkit.plugin.java.JavaPlugin;
 
-/** Foundation bootstrap only: no gameplay listeners or player/admin commands are registered. */
+/** Registers gameplay only after durable state initialization succeeds. */
 public final class SpigotIgnisPlugin extends JavaPlugin {
     private CompletableFuture<StateService> initialization;
+    private MaskProgressListener maskProgress;
+    private MaskCrafting maskCrafting;
+    private MaskEffects maskEffects;
+    private MaskEquipmentListener maskEquipment;
 
     @Override
     public void onEnable() {
@@ -14,13 +18,50 @@ public final class SpigotIgnisPlugin extends JavaPlugin {
             if (error != null) {
                 getLogger().severe("Ignis state unavailable; original data retained. Restore a verified backup before retrying.");
             } else {
-                getLogger().info("Ignis foundation loaded. No gameplay abilities or commands are enabled.");
+                if (!isEnabled()) { service.close(); return; }
+                try {
+                    getServer().getScheduler().runTask(this, () -> {
+                        if (!isEnabled()) { service.close(); return; }
+                        var gameplay = new EchoGameplay(this, service, new EchoItems());
+                        getServer().getPluginManager().registerEvents(gameplay, this);
+                        getServer().getPluginManager().registerEvents(new AnnouncementListener(gameplay::activated), this);
+                        getServer().getScheduler().runTaskTimer(this, gameplay::retryDeliveries, 1L, 100L);
+                        var maskTracker = new InvisibilityProgress(service, System::nanoTime);
+                        maskProgress = new MaskProgressListener(this, maskTracker);
+                        getServer().getPluginManager().registerEvents(maskProgress, this);
+                        getServer().getOnlinePlayers().forEach(maskProgress::resume);
+                        getServer().getScheduler().runTaskTimer(this, maskProgress::checkpoint, 1L, 100L);
+                        var maskItems = new MaskItems();
+                        maskCrafting = new MaskCrafting(this, service, maskItems, gameplay);
+                        maskEffects = new MaskEffects(this, service, maskItems);
+                        maskEquipment = new MaskEquipmentListener(this, maskEffects::hiddenEntityIds, getLogger()::warning);
+                        com.comphenix.protocol.ProtocolLibrary.getProtocolManager().addPacketListener(maskEquipment);
+                        getServer().getPluginManager().registerEvents(maskCrafting, this);
+                        getServer().getPluginManager().registerEvents(maskEffects, this);
+                        getServer().getScheduler().runTaskTimer(this, new MaskSkinLoader(this, maskItems, gameplay), 1L, 6000L);
+                        getServer().getScheduler().runTaskTimer(this, maskCrafting, 1L, 20L);
+                        getServer().getScheduler().runTaskTimer(this, maskEffects, 1L, 1L);
+                        var commands = new IgnisCommands(this, service, gameplay, maskTracker);
+                        for (String name : java.util.List.of("ignis", "ignisadmin")) {
+                            var command = java.util.Objects.requireNonNull(getCommand(name), "Missing command " + name);
+                            command.setExecutor(commands);
+                            command.setTabCompleter(commands);
+                        }
+                        getLogger().info("Ignis Echo and Mask enabled. Dagger and Heart remain in development.");
+                    });
+                } catch (org.bukkit.plugin.IllegalPluginAccessException ignored) {
+                    service.close();
+                }
             }
         });
     }
 
     @Override
     public void onDisable() {
+        if (maskEffects != null) maskEffects.close();
+        if (maskEquipment != null) com.comphenix.protocol.ProtocolLibrary.getProtocolManager().removePacketListener(maskEquipment);
+        if (maskCrafting != null) maskCrafting.close();
+        if (maskProgress != null) maskProgress.stop();
         if (initialization != null) initialization.thenAccept(StateService::close);
     }
 }

src/main/java/games/dmg/spigotignis/VoidTrial.java

@@ -0,0 +1,34 @@
+package games.dmg.spigotignis;
+
+import java.util.HashMap;
+import java.util.Map;
+import java.util.UUID;
+
+/** Server-thread transient attempts. Never persisted across disconnect/restart. */
+public final class VoidTrial {
+    private record Attempt(UUID world, double damageHeight, boolean escaped) { }
+    private final Map<UUID, Attempt> attempts = new HashMap<>();
+
+    public void damaged(UUID player, UUID world, double height) {
+        if (Double.isFinite(height)) attempts.put(player, new Attempt(world, height, false));
+    }
+
+    public boolean moved(UUID player, UUID world, double height, boolean gliding,
+            boolean grounded, boolean endStone) {
+        Attempt attempt = attempts.get(player);
+        if (attempt == null) return false;
+        if (!attempt.world().equals(world) || !Double.isFinite(height)) {
+            cancel(player);
+            return false;
+        }
+        boolean escaped = attempt.escaped() || gliding && height > attempt.damageHeight();
+        if (grounded) {
+            cancel(player);
+            return escaped && endStone;
+        }
+        attempts.put(player, new Attempt(world, attempt.damageHeight(), escaped));
+        return false;
+    }
+
+    public void cancel(UUID player) { attempts.remove(player); }
+}

src/main/resources/plugin.yml

@@ -2,4 +2,17 @@ name: SpigotIgnis
 version: '${version}'
 main: games.dmg.spigotignis.SpigotIgnisPlugin
 api-version: '1.21'
-description: Ignis progression foundation; gameplay is not implemented yet.
+description: Earnable shadow progression with Echo of the Abyss and The Mask.
+depend: [ProtocolLib]
+commands:
+  ignis:
+    description: Inspect private shadow progression.
+    usage: /ignis umbra
+  ignisadmin:
+    description: Administer Ignis progression and unlocked rewards.
+    usage: /ignisadmin
+    permission: ignis.admin
+permissions:
+  ignis.admin:
+    description: Inspect, configure, grant, and reset Ignis progression.
+    default: op

src/test/java/games/dmg/spigotignis/AdvancementMaskerTest.java

@@ -0,0 +1,48 @@
+package games.dmg.spigotignis;
+
+import static org.junit.jupiter.api.Assertions.*;
+import net.kyori.adventure.text.Component;
+import net.kyori.adventure.text.TranslatableComponent;
+import net.kyori.adventure.text.event.ClickEvent;
+import net.kyori.adventure.text.format.TextDecoration;
+import org.junit.jupiter.api.Test;
+
+class AdvancementMaskerTest {
+    @Test
+    void taskGoalChallengeClearInheritedIdentityActionsWithoutTouchingOtherMessages() {
+        for (String type : java.util.List.of("task", "goal", "challenge")) {
+            var achievement = Component.text("Achievement").hoverEvent(Component.text("Keep this description"));
+            var announcement = Component.translatable("chat.type.advancement." + type,
+                    Component.text("AlreadyMasked").decorate(TextDecoration.OBFUSCATED), achievement);
+            var wrapper = Component.empty().clickEvent(ClickEvent.suggestCommand("/msg RealPlayer"))
+                    .hoverEvent(Component.text("RealPlayer")).append(announcement);
+            var result = AdvancementMasker.mask(wrapper);
+            assertNull(result.clickEvent());
+            assertNull(result.hoverEvent());
+            var translated = (TranslatableComponent) result.children().getFirst();
+            assertEquals(achievement, translated.arguments().get(1).value());
+            assertEquals(result, AdvancementMasker.mask(result));
+        }
+        var chat = Component.translatable("chat.type.text", Component.text("RealPlayer"), Component.text("message"));
+        assertSame(chat, AdvancementMasker.mask(chat));
+        var custom = Component.text("RealPlayer completed a custom achievement");
+        assertSame(custom, AdvancementMasker.mask(custom));
+        assertNull(AdvancementMasker.mask(null));
+    }
+
+    @Test
+    void replacesOnlyAdvancementNameAndPreservesAdvancementDetails() {
+        var name = Component.text("RealPlayer").clickEvent(ClickEvent.suggestCommand("/msg RealPlayer "))
+                .hoverEvent(Component.text("RealPlayer identity")).insertion("RealPlayer");
+        var advancement = Component.text("RealPlayer's Challenge").hoverEvent(Component.text("Readable description"));
+        var original = Component.translatable("chat.type.advancement.challenge", name, advancement);
+        var masked = (TranslatableComponent) AdvancementMasker.mask(original);
+        var alias = (Component) masked.arguments().getFirst().value();
+        assertEquals(TextDecoration.State.TRUE, alias.decoration(TextDecoration.OBFUSCATED));
+        assertNull(alias.clickEvent());
+        assertNull(alias.hoverEvent());
+        assertEquals("", alias.insertion());
+        assertEquals(advancement, masked.arguments().get(1).value());
+        assertEquals(name, original.arguments().getFirst().value());
+    }
+}

src/test/java/games/dmg/spigotignis/AnnouncementListenerTest.java

@@ -0,0 +1,29 @@
+package games.dmg.spigotignis;
+
+import static org.mockito.Mockito.*;
+import java.util.UUID;
+import net.kyori.adventure.text.Component;
+import org.bukkit.entity.Player;
+import org.bukkit.event.player.PlayerAdvancementDoneEvent;
+import org.junit.jupiter.api.Test;
+
+class AnnouncementListenerTest {
+    @Test
+    void onlyActivatedPlayersExistingAnnouncementsAreChanged() {
+        UUID id = UUID.randomUUID();
+        var player = mock(Player.class);
+        when(player.getUniqueId()).thenReturn(id);
+        var event = mock(PlayerAdvancementDoneEvent.class);
+        when(event.getPlayer()).thenReturn(player);
+        var original = Component.translatable("chat.type.advancement.task", Component.text("Name"), Component.text("Title"));
+        when(event.message()).thenReturn(original);
+        new AnnouncementListener(ignored -> false).onAdvancement(event);
+        verify(event, never()).message(any(Component.class));
+        new AnnouncementListener(id::equals).onAdvancement(event);
+        verify(event).message(AdvancementMasker.mask(original));
+        clearInvocations(event);
+        when(event.message()).thenReturn(null);
+        new AnnouncementListener(id::equals).onAdvancement(event);
+        verify(event, never()).message(any(Component.class));
+    }
+}

src/test/java/games/dmg/spigotignis/EchoGameplayTest.java

@@ -0,0 +1,105 @@
+package games.dmg.spigotignis;
+
+import static org.junit.jupiter.api.Assertions.*;
+import static org.mockito.Mockito.*;
+import java.nio.file.Path;
+import java.util.List;
+import java.util.Optional;
+import java.util.UUID;
+import java.util.concurrent.ConcurrentLinkedQueue;
+import java.util.concurrent.TimeUnit;
+import org.bukkit.Server;
+import org.bukkit.entity.Player;
+import org.bukkit.event.Event;
+import org.bukkit.event.block.Action;
+import org.bukkit.event.player.PlayerInteractEvent;
+import org.bukkit.plugin.java.JavaPlugin;
+import org.bukkit.scheduler.BukkitScheduler;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.io.TempDir;
+
+class EchoGameplayTest {
+    @TempDir Path directory;
+
+    @Test
+    void ownerActivationCommitsOnceBeforeConsumingAndDeniedInteractionsDoNothing() throws Exception {
+        UUID owner = UUID.randomUUID(), receipt = UUID.randomUUID();
+        var token = new EchoToken(owner, receipt, 0);
+        var items = mock(EchoItems.class);
+        var player = mock(Player.class);
+        when(player.getUniqueId()).thenReturn(owner);
+        var plugin = mock(JavaPlugin.class);
+        var server = mock(Server.class);
+        when(plugin.getServer()).thenReturn(server);
+        when(plugin.isEnabled()).thenReturn(true);
+        when(server.getPlayer(owner)).thenReturn(player);
+        var scheduler = mock(BukkitScheduler.class);
+        when(server.getScheduler()).thenReturn(scheduler);
+        var callbacks = new ConcurrentLinkedQueue<Runnable>();
+        when(scheduler.runTask(eq(plugin), any(Runnable.class))).thenAnswer(call -> {
+            callbacks.add(call.getArgument(1)); return null;
+        });
+        var event = mock(PlayerInteractEvent.class);
+        when(event.getPlayer()).thenReturn(player);
+        when(event.getAction()).thenReturn(Action.RIGHT_CLICK_AIR);
+        when(event.useItemInHand()).thenReturn(Event.Result.DENY);
+        when(items.identify(null)).thenReturn(Optional.of(token));
+        try (var states = StateService.open(new FileStateRepository(directory.resolve("state.bin"))).get(3, TimeUnit.SECONDS)) {
+            states.update(state -> EchoRewards.award(state, owner, receipt)).get(3, TimeUnit.SECONDS);
+            var gameplay = new EchoGameplay(plugin, states, items);
+            gameplay.onUse(event);
+            assertFalse(gameplay.activated(owner));
+            verify(items, never()).consumeOne(any(), any());
+            when(event.useItemInHand()).thenReturn(Event.Result.DEFAULT);
+            gameplay.onUse(event);
+            gameplay.onUse(event);
+            states.update(state -> state).get(3, TimeUnit.SECONDS);
+            assertTrue(gameplay.activated(owner));
+            verify(items, never()).consumeOne(any(), any());
+            callbacks.forEach(Runnable::run);
+            verify(items, times(1)).consumeOne(player, token);
+            verify(event, times(2)).setCancelled(true);
+
+            // A later admin reset must supersede a delayed activation inventory callback.
+            callbacks.clear();
+            states.update(state -> ProgressAdministration.reset(state, owner, java.util.Set.of(Track.VOID))).get();
+            UUID replacementId = UUID.randomUUID();
+            var replacement = new EchoToken(owner, replacementId, 1);
+            states.update(state -> EchoRewards.award(state, owner, replacementId)).get();
+            when(items.identify(null)).thenReturn(Optional.of(replacement));
+            gameplay.onUse(event);
+            states.update(state -> ProgressAdministration.reset(state, owner, java.util.Set.of(Track.VOID))).get();
+            callbacks.forEach(Runnable::run);
+            verify(items, never()).consumeOne(player, replacement);
+        }
+    }
+
+    @Test
+    void fullInventoryLeavesRewardPendingAndRepeatedDeliveryDoesNotOfferTwice() throws Exception {
+        UUID owner = UUID.randomUUID(), receipt = UUID.randomUUID();
+        var token = new EchoToken(owner, receipt, 0);
+        var items = mock(EchoItems.class);
+        var player = mock(Player.class);
+        when(player.getUniqueId()).thenReturn(owner);
+        var plugin = mock(JavaPlugin.class);
+        var server = mock(Server.class);
+        when(plugin.getServer()).thenReturn(server);
+        when(plugin.isEnabled()).thenReturn(true);
+        doReturn(List.of(player)).when(server).getOnlinePlayers();
+        var scheduler = mock(BukkitScheduler.class);
+        when(server.getScheduler()).thenReturn(scheduler);
+        try (var states = StateService.open(new FileStateRepository(directory.resolve("state.bin"))).get(3, TimeUnit.SECONDS)) {
+            states.update(state -> EchoRewards.award(state, owner, receipt)).get(3, TimeUnit.SECONDS);
+            var gameplay = new EchoGameplay(plugin, states, items);
+            gameplay.retryDeliveries();
+            assertEquals(1, states.snapshot().players().get(owner).pendingRewards().size());
+            when(items.offer(player, token)).thenReturn(true);
+            gameplay.retryDeliveries();
+            gameplay.retryDeliveries();
+            states.update(state -> state).get(3, TimeUnit.SECONDS);
+            assertTrue(states.snapshot().players().get(owner).pendingRewards().isEmpty());
+            assertTrue(EchoRewards.valid(states.snapshot(), owner, token));
+            verify(items, times(2)).offer(player, token); // one full-inventory attempt, one delivery
+        }
+    }
+}

src/test/java/games/dmg/spigotignis/EchoIdentityTest.java

@@ -0,0 +1,17 @@
+package games.dmg.spigotignis;
+
+import static org.junit.jupiter.api.Assertions.*;
+import java.util.UUID;
+import org.junit.jupiter.api.Test;
+
+class EchoIdentityTest {
+    @Test
+    void authenticatedPayloadRoundTripsAndMalformedPayloadsAreIgnored() {
+        var token = new EchoToken(UUID.randomUUID(), UUID.randomUUID(), 9);
+        assertEquals(token, EchoIdentity.decode(EchoIdentity.encode(token)).orElse(null));
+        assertTrue(EchoIdentity.decode(null).isEmpty());
+        assertTrue(EchoIdentity.decode("Echo of the Abyss").isEmpty());
+        assertTrue(EchoIdentity.decode(token.owner() + ":" + token.receipt() + ":-1").isEmpty());
+        assertTrue(EchoIdentity.decode(EchoIdentity.encode(token) + ":extra").isEmpty());
+    }
+}

src/test/java/games/dmg/spigotignis/EchoItemsTest.java

@@ -0,0 +1,32 @@
+package games.dmg.spigotignis;
+
+import static org.junit.jupiter.api.Assertions.*;
+import static org.mockito.Mockito.*;
+import java.util.UUID;
+import org.bukkit.Material;
+import org.bukkit.inventory.ItemStack;
+import org.bukkit.inventory.meta.ItemMeta;
+import org.bukkit.persistence.PersistentDataContainer;
+import org.bukkit.persistence.PersistentDataType;
+import org.junit.jupiter.api.Test;
+
+class EchoItemsTest {
+    @Test
+    void displayNameAloneAndWrongMaterialNeverAuthenticate() {
+        var items = new EchoItems();
+        assertTrue(items.identify(null).isEmpty());
+        var item = mock(ItemStack.class);
+        var meta = mock(ItemMeta.class);
+        var tags = mock(PersistentDataContainer.class);
+        when(item.getType()).thenReturn(Material.ECHO_SHARD);
+        when(item.hasItemMeta()).thenReturn(true);
+        when(item.getItemMeta()).thenReturn(meta);
+        when(meta.getPersistentDataContainer()).thenReturn(tags);
+        assertTrue(items.identify(item).isEmpty());
+        var token = new EchoToken(UUID.randomUUID(), UUID.randomUUID(), 0);
+        when(tags.get(any(), eq(PersistentDataType.STRING))).thenReturn(EchoIdentity.encode(token));
+        assertEquals(token, items.identify(item).orElseThrow());
+        when(item.getType()).thenReturn(Material.DIAMOND);
+        assertTrue(items.identify(item).isEmpty());
+    }
+}

src/test/java/games/dmg/spigotignis/EchoRewardsTest.java

@@ -0,0 +1,45 @@
+package games.dmg.spigotignis;
+
+import static org.junit.jupiter.api.Assertions.*;
+import java.util.UUID;
+import org.junit.jupiter.api.Test;
+
+class EchoRewardsTest {
+    @Test
+    void foreignUnknownAndObsoleteReceiptsCannotActivateEvenWithMatchingLorePayload() {
+        UUID owner = UUID.randomUUID(), receipt = UUID.randomUUID();
+        var state = EchoRewards.award(IgnisState.empty(), owner, receipt);
+        assertFalse(EchoRewards.valid(state, owner, new EchoToken(owner, UUID.randomUUID(), 0)));
+        assertFalse(EchoRewards.valid(state, owner, new EchoToken(owner, receipt, 1)));
+        assertFalse(EchoRewards.valid(state, UUID.randomUUID(), new EchoToken(owner, receipt, 0)));
+        UUID replacement = UUID.randomUUID();
+        var repeated = EchoRewards.award(state, owner, replacement);
+        assertEquals(2, repeated.players().get(owner).pendingRewards().size());
+        assertTrue(EchoRewards.valid(repeated, owner, new EchoToken(owner, replacement, 0)));
+    }
+
+    @Test
+    void onlyOwnerCanActivateIssuedItemAndDeliveryAcknowledgementRetainsValidity() {
+        UUID owner = UUID.randomUUID(), receipt = UUID.randomUUID();
+        var token = new EchoToken(owner, receipt, 0);
+        var awarded = EchoRewards.award(IgnisState.empty(), owner, receipt);
+        assertThrows(IllegalArgumentException.class,
+                () -> EchoRewards.activate(awarded, UUID.randomUUID(), token));
+        var delivered = EchoRewards.acknowledge(awarded, token);
+        assertTrue(delivered.players().get(owner).pendingRewards().isEmpty());
+        var activated = EchoRewards.activate(delivered, owner, token);
+        assertTrue(activated.players().get(owner).track(Track.VOID).activated());
+        assertThrows(IllegalArgumentException.class, () -> EchoRewards.activate(activated, owner, token));
+        assertEquals(activated, EchoRewards.award(activated, owner, UUID.randomUUID()));
+    }
+
+    @Test
+    void completionCreatesOnePendingBoundReceiptAndRetryDoesNotDuplicateIt() {
+        UUID owner = UUID.randomUUID(), receipt = UUID.randomUUID();
+        var awarded = EchoRewards.award(IgnisState.empty(), owner, receipt);
+        assertEquals(Track.VOID, awarded.players().get(owner).pendingRewards().get(receipt));
+        assertTrue(awarded.players().get(owner).track(Track.VOID).unlocked());
+        assertFalse(awarded.players().get(owner).track(Track.VOID).activated());
+        assertEquals(awarded, EchoRewards.award(awarded, owner, receipt));
+    }
+}

src/test/java/games/dmg/spigotignis/EffectOwnershipTest.java

@@ -0,0 +1,28 @@
+package games.dmg.spigotignis;
+
+import static org.junit.jupiter.api.Assertions.*;
+import java.util.UUID;
+import org.junit.jupiter.api.Test;
+
+class EffectOwnershipTest {
+    @Test
+    void onlyAnActuallyAppliedOwnEffectCanBeRemovedAndExternalReplacementRevokesOwnership() {
+        UUID player = UUID.randomUUID();
+        var ownership = new EffectOwnership();
+        ownership.applying(player, true);
+        ownership.changed(player, false, true);
+        assertFalse(ownership.owns(player));
+        ownership.changed(player, true, true);
+        ownership.applying(player, false);
+        assertTrue(ownership.owns(player));
+        ownership.changed(player, false, true);
+        assertTrue(ownership.owns(player));
+        ownership.changed(player, true, true);
+        assertFalse(ownership.owns(player));
+        ownership.applying(player, true);
+        ownership.changed(player, true, true);
+        ownership.applying(player, false);
+        ownership.changed(player, true, false);
+        assertFalse(ownership.owns(player));
+    }
+}

src/test/java/games/dmg/spigotignis/FileStateRepositoryTest.java

@@ -10,6 +10,37 @@ import org.junit.jupiter.api.io.TempDir;
 class FileStateRepositoryTest {
     @TempDir Path directory;
 
+    @Test
+    void versionOnePendingRewardsMigrateToIssuedReceiptsWithoutDataLoss() throws Exception {
+        Path path = directory.resolve("state.bin");
+        UUID player = UUID.randomUUID(), reward = UUID.randomUUID();
+        try (var out = new java.io.DataOutputStream(java.nio.file.Files.newOutputStream(path))) {
+            out.writeInt(0x49474e49); out.writeInt(1);
+            out.writeLong(120); out.writeLong(313); out.writeLong(60);
+            out.writeInt(1);
+            out.writeLong(player.getMostSignificantBits()); out.writeLong(player.getLeastSignificantBits());
+            out.writeInt(0); out.writeInt(1);
+            out.writeLong(reward.getMostSignificantBits()); out.writeLong(reward.getLeastSignificantBits());
+            out.writeUTF("VOID");
+        }
+        var repository = new FileStateRepository(path);
+        var loaded = repository.load();
+        assertEquals(new ProgressLimits(120, 313, 60), loaded.limits());
+        assertEquals(loaded.players().get(player).pendingRewards(), loaded.players().get(player).issuedRewards());
+        assertEquals(Track.VOID, loaded.players().get(player).issuedRewards().get(reward));
+        repository.save(loaded);
+        assertEquals(loaded, repository.load());
+    }
+
+    @Test
+    void deliveredItemReceiptsSurviveRestartAfterPendingDeliveryIsAcknowledged() throws Exception {
+        Path path = directory.resolve("state.bin");
+        var expected = new IgnisState(ProgressLimits.defaults(), Map.of(UUID.randomUUID(),
+                new PlayerState(Map.of(), Map.of(), Map.of(UUID.randomUUID(), Track.VOID))));
+        new FileStateRepository(path).save(expected);
+        assertEquals(expected, new FileStateRepository(path).load());
+    }
+
     @Test
     void missingStateStartsEmptyAndInterruptedTemporaryFilesAreNeverPromoted() throws Exception {
         java.nio.file.Files.writeString(directory.resolve(".ignis-interrupted.tmp"), "incomplete");
@@ -23,7 +54,7 @@ class FileStateRepositoryTest {
         repository.save(IgnisState.empty());
         byte[] valid = java.nio.file.Files.readAllBytes(path);
         byte[] future = valid.clone();
-        future[7] = 2;
+        future[7] = 3;
         byte[] negativeCount = valid.clone();
         java.util.Arrays.fill(negativeCount, 32, 36, (byte) 0xff);
         for (byte[] invalid : java.util.List.of(new byte[0], java.util.Arrays.copyOf(valid, 12),

src/test/java/games/dmg/spigotignis/IgnisCommandsTest.java

@@ -0,0 +1,89 @@
+package games.dmg.spigotignis;
+
+import static org.junit.jupiter.api.Assertions.*;
+import static org.mockito.Mockito.*;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandSender;
+import org.bukkit.plugin.java.JavaPlugin;
+import org.junit.jupiter.api.Test;
+
+class IgnisCommandsTest {
+    @org.junit.jupiter.api.io.TempDir java.nio.file.Path directory;
+
+    @Test
+    void grantsLimitsProgressAndAutocompleteUseKnownOfflineUuid() throws Exception {
+        var plugin = mock(JavaPlugin.class);
+        when(plugin.getLogger()).thenReturn(java.util.logging.Logger.getAnonymousLogger());
+        var sender = mock(CommandSender.class);
+        when(sender.hasPermission("ignis.admin")).thenReturn(true);
+        var command = mock(Command.class);
+        when(command.getName()).thenReturn("ignisadmin");
+        var owner = java.util.UUID.randomUUID();
+        try (var states = StateService.open(new FileStateRepository(directory.resolve("state.bin"))).get()) {
+            states.update(state -> new IgnisState(state.limits(), java.util.Map.of(owner, PlayerState.empty()))).get();
+            var handler = new IgnisCommands(plugin, states, mock(EchoGameplay.class));
+            handler.onCommand(sender, command, "ignisadmin", new String[]{"give", owner.toString(), "echo"});
+            states.update(state -> state).get();
+            assertEquals(1, states.snapshot().players().get(owner).pendingRewards().size());
+            assertTrue(states.snapshot().players().get(owner).track(Track.VOID).unlocked());
+            assertFalse(states.snapshot().players().get(owner).track(Track.VOID).activated());
+            handler.onCommand(sender, command, "ignisadmin", new String[]{"limits", "set", "mask-ms", "100"});
+            handler.onCommand(sender, command, "ignisadmin", new String[]{"progress", "set", owner.toString(), "mask", "100"});
+            states.update(state -> state).get();
+            assertTrue(states.snapshot().players().get(owner).track(Track.MASK).unlocked());
+            assertEquals(100, states.snapshot().limits().invisibilityMillis());
+            assertTrue(handler.onTabComplete(sender, command, "ignisadmin", new String[]{""}).contains("inspect"));
+            assertEquals(java.util.List.of("echo", "mask"), handler.onTabComplete(sender, command, "ignisadmin", new String[]{"give", owner.toString(), ""}));
+            handler.onCommand(sender, command, "ignisadmin", new String[]{"give", owner.toString(), "mask"});
+            states.update(state -> state).get();
+            assertTrue(states.snapshot().players().get(owner).pendingRewards().containsValue(Track.MASK));
+        }
+    }
+
+    @Test
+    void ordinaryPlayerCanPrivatelyViewAllThreeTracksWithoutAdminPermission() throws Exception {
+        var player = mock(org.bukkit.entity.Player.class);
+        when(player.getUniqueId()).thenReturn(java.util.UUID.randomUUID());
+        var command = mock(Command.class);
+        when(command.getName()).thenReturn("ignis");
+        try (var states = StateService.open(new FileStateRepository(directory.resolve("state.bin"))).get()) {
+            var handler = new IgnisCommands(mock(JavaPlugin.class), states, mock(EchoGameplay.class));
+            handler.onCommand(player, command, "ignis", new String[]{"umbra"});
+            verify(player).sendMessage(argThat((String text) -> text.contains("Invisibility") && text.contains("Pearls") && text.contains("Darkness")));
+            verify(player, times(1)).sendMessage(anyString());
+        }
+    }
+
+    @Test
+    void resetRequiresMatchingPriorConfirmationAndThenRevokesTheTrack() throws Exception {
+        var plugin = mock(JavaPlugin.class);
+        when(plugin.getLogger()).thenReturn(java.util.logging.Logger.getAnonymousLogger());
+        var sender = mock(CommandSender.class);
+        when(sender.hasPermission("ignis.admin")).thenReturn(true);
+        var command = mock(Command.class);
+        when(command.getName()).thenReturn("ignisadmin");
+        var owner = java.util.UUID.randomUUID();
+        try (var states = StateService.open(new FileStateRepository(directory.resolve("state.bin"))).get()) {
+            states.update(state -> EchoRewards.award(state, owner, java.util.UUID.randomUUID())).get();
+            var handler = new IgnisCommands(plugin, states, mock(EchoGameplay.class));
+            handler.onCommand(sender, command, "ignisadmin", new String[]{"reset", owner.toString(), "void", "confirm"});
+            states.update(state -> state).get();
+            assertTrue(states.snapshot().players().get(owner).track(Track.VOID).unlocked());
+            handler.onCommand(sender, command, "ignisadmin", new String[]{"reset", owner.toString(), "void"});
+            handler.onCommand(sender, command, "ignisadmin", new String[]{"reset", owner.toString(), "void", "confirm"});
+            states.update(state -> state).get();
+            assertFalse(states.snapshot().players().get(owner).track(Track.VOID).unlocked());
+        }
+    }
+
+    @Test
+    void permissionDenialIsEnforcedAtExecutionAndAutocomplete() {
+        var sender = mock(CommandSender.class);
+        var command = mock(Command.class);
+        when(command.getName()).thenReturn("ignisadmin");
+        var handler = new IgnisCommands(mock(JavaPlugin.class), null, null);
+        handler.onCommand(sender, command, "ignisadmin", new String[]{"give", "someone", "echo"});
+        verify(sender).sendMessage("You do not have permission to administer Ignis.");
+        assertTrue(handler.onTabComplete(sender, command, "ignisadmin", new String[]{""}).isEmpty());
+    }
+}

src/test/java/games/dmg/spigotignis/InvisibilityAttributionTest.java

@@ -0,0 +1,22 @@
+package games.dmg.spigotignis;
+
+import static org.junit.jupiter.api.Assertions.*;
+import org.junit.jupiter.api.Test;
+
+class InvisibilityAttributionTest {
+    @Test
+    void directDrinkStartsAndOtherSourcesOrRemovalStopButCancelledOrIgnoredChangesDoNothing() {
+        assertEquals(InvisibilityAttribution.Transition.START,
+                InvisibilityAttribution.transition(true, false, true, true, true));
+        assertEquals(InvisibilityAttribution.Transition.STOP,
+                InvisibilityAttribution.transition(true, false, true, true, false));
+        assertEquals(InvisibilityAttribution.Transition.STOP,
+                InvisibilityAttribution.transition(true, false, true, false, true));
+        assertEquals(InvisibilityAttribution.Transition.KEEP,
+                InvisibilityAttribution.transition(true, true, true, true, true));
+        assertEquals(InvisibilityAttribution.Transition.KEEP,
+                InvisibilityAttribution.transition(false, false, true, true, true));
+        assertEquals(InvisibilityAttribution.Transition.KEEP,
+                InvisibilityAttribution.transition(true, false, false, true, false));
+    }
+}

src/test/java/games/dmg/spigotignis/InvisibilityProgressTest.java

@@ -0,0 +1,134 @@
+package games.dmg.spigotignis;
+
+import static org.junit.jupiter.api.Assertions.*;
+import java.nio.file.Path;
+import java.util.UUID;
+import java.util.concurrent.atomic.AtomicLong;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.io.TempDir;
+
+class InvisibilityProgressTest {
+    @TempDir Path directory;
+
+    @Test
+    void resetDropsOldUncheckpointedTimeAndOnlyFutureTimeCanBeEarned() throws Exception {
+        UUID player = UUID.randomUUID();
+        var clock = new AtomicLong();
+        try (var states = StateService.open(new FileStateRepository(directory.resolve("state.bin"))).get()) {
+            var tracker = new InvisibilityProgress(states, clock::get);
+            tracker.drink(player);
+            clock.set(5_000_000_000L);
+            states.update(state -> ProgressAdministration.reset(state, player, java.util.Set.of(Track.MASK))).get();
+            tracker.checkpoint(player).get();
+            assertEquals(0, states.snapshot().players().get(player).track(Track.MASK).progress());
+            clock.set(6_000_000_000L);
+            tracker.stop(player).get();
+            assertEquals(1000, states.snapshot().players().get(player).track(Track.MASK).progress());
+        }
+    }
+
+    @Test
+    void checkpointsRetainFractionalTimeUnlockAtLimitAndSurviveRestartWithoutOfflineCredit() throws Exception {
+        UUID player = UUID.randomUUID();
+        var clock = new AtomicLong();
+        var repository = new FileStateRepository(directory.resolve("state.bin"));
+        try (var states = StateService.open(repository).get()) {
+            states.configure(2, 313, 1000).get();
+            var tracker = new InvisibilityProgress(states, clock::get);
+            tracker.drink(player);
+            clock.set(600_000);
+            tracker.checkpoint(player).get();
+            clock.set(1_200_000);
+            tracker.checkpoint(player).get();
+            assertEquals(1, states.snapshot().players().get(player).track(Track.MASK).progress());
+            clock.set(2_100_000);
+            tracker.stop(player).get();
+            assertTrue(states.snapshot().players().get(player).track(Track.MASK).unlocked());
+        }
+        clock.set(1_000_000_000_000L);
+        try (var states = StateService.open(repository).get()) {
+            var tracker = new InvisibilityProgress(states, clock::get);
+            tracker.checkpoint(player).get();
+            assertEquals(2, states.snapshot().players().get(player).track(Track.MASK).progress());
+            tracker.drink(player);
+            clock.addAndGet(3_000_000);
+            tracker.stop(player).get();
+            assertEquals(5, states.snapshot().players().get(player).track(Track.MASK).progress());
+        }
+    }
+
+    @Test
+    void failedCheckpointRetainsElapsedCreditForRetry() throws Exception {
+        UUID player = UUID.randomUUID();
+        var clock = new AtomicLong();
+        var fail = new java.util.concurrent.atomic.AtomicBoolean(true);
+        var disk = new FileStateRepository(directory.resolve("state.bin"));
+        StateRepository boundary = new StateRepository() {
+            @Override public IgnisState load() throws java.io.IOException { return disk.load(); }
+            @Override public void save(IgnisState state) throws java.io.IOException {
+                if (fail.get()) throw new java.io.IOException("Simulated failure");
+                disk.save(state);
+            }
+        };
+        try (var states = StateService.open(boundary).get()) {
+            var tracker = new InvisibilityProgress(states, clock::get);
+            tracker.drink(player);
+            clock.set(5_000_000_000L);
+            assertThrows(java.util.concurrent.ExecutionException.class, () -> tracker.checkpoint(player).get());
+            fail.set(false);
+            clock.set(7_000_000_000L);
+            tracker.stop(player).get();
+            assertEquals(7000, states.snapshot().players().get(player).track(Track.MASK).progress());
+        }
+    }
+
+    @Test
+    void duplicateCheckpointMustWaitForTheAlreadyReservedWrite() throws Exception {
+        UUID player = UUID.randomUUID();
+        var clock = new AtomicLong();
+        var entered = new java.util.concurrent.CountDownLatch(1);
+        var release = new java.util.concurrent.CountDownLatch(1);
+        var disk = new FileStateRepository(directory.resolve("state.bin"));
+        StateRepository boundary = new StateRepository() {
+            @Override public IgnisState load() throws java.io.IOException { return disk.load(); }
+            @Override public void save(IgnisState state) throws java.io.IOException {
+                entered.countDown();
+                try {
+                    if (!release.await(3, java.util.concurrent.TimeUnit.SECONDS)) throw new java.io.IOException("Timed out");
+                } catch (InterruptedException exception) { Thread.currentThread().interrupt(); throw new java.io.IOException(exception); }
+                disk.save(state);
+            }
+        };
+        try (var states = StateService.open(boundary).get()) {
+            var tracker = new InvisibilityProgress(states, clock::get);
+            tracker.drink(player);
+            clock.set(1_000_000);
+            var first = tracker.checkpoint(player);
+            assertTrue(entered.await(3, java.util.concurrent.TimeUnit.SECONDS));
+            try {
+                var duplicate = tracker.checkpoint(player);
+                assertFalse(duplicate.isDone());
+                release.countDown();
+                assertEquals(first.get(), duplicate.get());
+            } finally { release.countDown(); }
+        }
+    }
+
+    @Test
+    void refreshedDirectDrinksCountElapsedTimeOnlyOnceAndStopKeepsEarnedTime() throws Exception {
+        UUID player = UUID.randomUUID();
+        var clock = new AtomicLong();
+        try (var states = StateService.open(new FileStateRepository(directory.resolve("state.bin"))).get()) {
+            var tracker = new InvisibilityProgress(states, clock::get);
+            tracker.drink(player);
+            clock.set(2_000_000_000L);
+            tracker.drink(player);
+            clock.set(5_000_000_000L);
+            tracker.stop(player).get();
+            assertEquals(5000, states.snapshot().players().get(player).track(Track.MASK).progress());
+            clock.set(50_000_000_000L);
+            tracker.checkpoint(player).get();
+            assertEquals(5000, states.snapshot().players().get(player).track(Track.MASK).progress());
+        }
+    }
+}

src/test/java/games/dmg/spigotignis/MaskCraftingTest.java

@@ -0,0 +1,81 @@
+package games.dmg.spigotignis;
+
+import static org.mockito.Mockito.*;
+import org.bukkit.entity.Player;
+import org.bukkit.event.block.CrafterCraftEvent;
+import org.bukkit.event.inventory.CraftItemEvent;
+import org.bukkit.inventory.CraftingInventory;
+import org.bukkit.inventory.ShapedRecipe;
+import org.bukkit.plugin.java.JavaPlugin;
+import org.junit.jupiter.api.Test;
+
+class MaskCraftingTest {
+    @org.junit.jupiter.api.io.TempDir java.nio.file.Path directory;
+
+    @Test
+    void recipeUsesEightNetheriteBlocksAndCentralNetherStarOnlyAfterSkinIsReady() {
+        var plugin = mock(JavaPlugin.class);
+        var server = mock(org.bukkit.Server.class);
+        when(plugin.getServer()).thenReturn(server);
+        var items = mock(MaskItems.class);
+        var recipe = mock(ShapedRecipe.class);
+        when(server.addRecipe(recipe)).thenReturn(true);
+        var crafting = new MaskCrafting(plugin, null, items, null, ignored -> recipe);
+        crafting.run();
+        verify(server, never()).addRecipe(any());
+        when(items.ready()).thenReturn(true);
+        crafting.run(); crafting.run();
+        verify(recipe).shape("NNN", "NSN", "NNN");
+        verify(recipe).setIngredient('N', org.bukkit.Material.NETHERITE_BLOCK);
+        verify(recipe).setIngredient('S', org.bukkit.Material.NETHER_STAR);
+        verify(server, times(1)).addRecipe(recipe);
+    }
+
+    @Test
+    void validCraftIsLeftToVanillaButResetBetweenPreviewAndClickRejectsIt() throws Exception {
+        var owner = java.util.UUID.randomUUID();
+        var receipt = java.util.UUID.randomUUID();
+        var token = new MaskToken(owner, receipt, 0);
+        var recipe = mock(ShapedRecipe.class);
+        when(recipe.getKey()).thenReturn(MaskCrafting.RECIPE);
+        var items = mock(MaskItems.class);
+        when(items.identify(null)).thenReturn(java.util.Optional.of(token));
+        var event = mock(CraftItemEvent.class);
+        var inventory = mock(CraftingInventory.class);
+        var player = mock(Player.class);
+        when(player.getUniqueId()).thenReturn(owner);
+        when(event.getWhoClicked()).thenReturn(player);
+        when(event.getRecipe()).thenReturn(recipe);
+        when(event.getInventory()).thenReturn(inventory);
+        try (var states = StateService.open(new FileStateRepository(directory.resolve("state.bin"))).get()) {
+            states.update(state -> MaskRewards.issue(state, owner, receipt, true)).get();
+            var crafting = new MaskCrafting(mock(JavaPlugin.class), states, items, null);
+            crafting.onCraft(event);
+            verify(event, never()).setCancelled(true);
+            verify(inventory, never()).setMatrix(any());
+            states.update(state -> ProgressAdministration.reset(state, owner, java.util.Set.of(Track.MASK))).get();
+            crafting.onCraft(event);
+            verify(event).setCancelled(true);
+        }
+    }
+
+    @Test
+    void unauthenticatedPreviewAndAutomatedCrafterCannotConsumeIngredients() {
+        var recipe = mock(ShapedRecipe.class);
+        when(recipe.getKey()).thenReturn(MaskCrafting.RECIPE);
+        var items = mock(MaskItems.class);
+        var event = mock(CraftItemEvent.class);
+        var inventory = mock(CraftingInventory.class);
+        when(event.getRecipe()).thenReturn(recipe);
+        when(event.getInventory()).thenReturn(inventory);
+        when(event.getWhoClicked()).thenReturn(mock(Player.class));
+        var crafting = new MaskCrafting(mock(JavaPlugin.class), null, items, null);
+        crafting.onCraft(event);
+        verify(event).setCancelled(true);
+        verify(inventory).setResult(null);
+        var crafter = mock(CrafterCraftEvent.class);
+        when(crafter.getRecipe()).thenReturn(recipe);
+        crafting.onCrafter(crafter);
+        verify(crafter).setCancelled(true);
+    }
+}

src/test/java/games/dmg/spigotignis/MaskEquipmentTest.java

@@ -0,0 +1,23 @@
+package games.dmg.spigotignis;
+
+import static org.junit.jupiter.api.Assertions.*;
+import static org.mockito.Mockito.*;
+import com.comphenix.protocol.wrappers.EnumWrappers;
+import com.comphenix.protocol.wrappers.Pair;
+import java.util.List;
+import org.bukkit.inventory.ItemStack;
+import org.junit.jupiter.api.Test;
+
+class MaskEquipmentTest {
+    @Test
+    void projectionHidesOnlyHeadAndDoesNotMutateServerEquipment() {
+        var helmet = mock(ItemStack.class);
+        var chest = mock(ItemStack.class);
+        var empty = mock(ItemStack.class);
+        var original = List.of(new Pair<>(EnumWrappers.ItemSlot.HEAD, helmet), new Pair<>(EnumWrappers.ItemSlot.CHEST, chest));
+        var projected = MaskEquipmentListener.project(original, empty);
+        assertSame(empty, projected.getFirst().getSecond());
+        assertSame(chest, projected.get(1).getSecond());
+        assertSame(helmet, original.getFirst().getSecond());
+    }
+}

src/test/java/games/dmg/spigotignis/MaskItemsTest.java

@@ -0,0 +1,32 @@
+package games.dmg.spigotignis;
+
+import static org.junit.jupiter.api.Assertions.*;
+import static org.mockito.Mockito.*;
+import java.util.UUID;
+import org.bukkit.Material;
+import org.bukkit.inventory.ItemStack;
+import org.bukkit.inventory.meta.SkullMeta;
+import org.bukkit.persistence.PersistentDataContainer;
+import org.bukkit.persistence.PersistentDataType;
+import org.junit.jupiter.api.Test;
+
+class MaskItemsTest {
+    @Test
+    void existingItemIdentityDoesNotDependOnLiveSkinLookupAndNameOnlyHeadsAreRejected() {
+        var items = new MaskItems();
+        var item = mock(ItemStack.class);
+        var meta = mock(SkullMeta.class);
+        var tags = mock(PersistentDataContainer.class);
+        when(item.getType()).thenReturn(Material.PLAYER_HEAD);
+        when(item.hasItemMeta()).thenReturn(true);
+        when(item.getItemMeta()).thenReturn(meta);
+        when(meta.getPersistentDataContainer()).thenReturn(tags);
+        assertFalse(items.ready());
+        assertTrue(items.identify(item).isEmpty());
+        UUID owner = UUID.randomUUID(), receipt = UUID.randomUUID();
+        when(tags.get(any(), eq(PersistentDataType.STRING))).thenReturn(EchoIdentity.encode(new EchoToken(owner, receipt, 2)));
+        assertEquals(new MaskToken(owner, receipt, 2), items.identify(item).orElseThrow());
+        when(item.getType()).thenReturn(Material.ECHO_SHARD);
+        assertTrue(items.identify(item).isEmpty());
+    }
+}

src/test/java/games/dmg/spigotignis/MaskRewardsTest.java

@@ -0,0 +1,43 @@
+package games.dmg.spigotignis;
+
+import static org.junit.jupiter.api.Assertions.*;
+import java.util.Set;
+import java.util.UUID;
+import org.junit.jupiter.api.Test;
+
+class MaskRewardsTest {
+    @Test
+    void adminGrantUnlocksUseAndDeliveryAcknowledgementPreservesTheIssuedItem() {
+        UUID player = UUID.randomUUID(), receipt = UUID.randomUUID();
+        var granted = MaskRewards.issue(IgnisState.empty(), player, receipt, true);
+        var token = new MaskToken(player, receipt, 0);
+        assertTrue(MaskRewards.valid(granted, player, token));
+        assertEquals(Track.MASK, granted.players().get(player).pendingRewards().get(receipt));
+        assertTrue(MaskRewards.craftingToken(granted, player).isEmpty(),
+                "A pending admin gift must not be reused for a paid craft and mistaken for gift delivery");
+        var delivered = MaskRewards.acknowledge(granted, token);
+        assertTrue(delivered.players().get(player).pendingRewards().isEmpty());
+        assertTrue(MaskRewards.valid(delivered, player, token));
+        assertEquals(token, MaskRewards.craftingToken(delivered, player).orElseThrow());
+        assertEquals(delivered, MaskRewards.acknowledge(delivered, token));
+    }
+
+    @Test
+    void craftingReceiptRequiresUnlockAndTradedMaskRequiresBothValidIssuanceAndHolderUnlock() {
+        UUID issuer = UUID.randomUUID(), holder = UUID.randomUUID(), receipt = UUID.randomUUID();
+        assertThrows(IllegalArgumentException.class, () -> MaskRewards.issue(IgnisState.empty(), issuer, receipt, false));
+        var unlocked = ProgressAdministration.progress(IgnisState.empty(), issuer, Track.MASK,
+                ProgressLimits.defaults().invisibilityMillis(), false);
+        var issued = MaskRewards.issue(unlocked, issuer, receipt, false);
+        var token = new MaskToken(issuer, receipt, 0);
+        assertTrue(MaskRewards.valid(issued, issuer, token));
+        assertFalse(MaskRewards.valid(issued, holder, token));
+        var holderUnlocked = ProgressAdministration.progress(issued, holder, Track.MASK,
+                ProgressLimits.defaults().invisibilityMillis(), false);
+        assertTrue(MaskRewards.valid(holderUnlocked, holder, token));
+        var reset = ProgressAdministration.reset(holderUnlocked, issuer, Set.of(Track.MASK));
+        var reearned = ProgressAdministration.progress(reset, issuer, Track.MASK,
+                ProgressLimits.defaults().invisibilityMillis(), false);
+        assertFalse(MaskRewards.valid(reearned, holder, token));
+    }
+}

src/test/java/games/dmg/spigotignis/MaskSkinLoaderTest.java

@@ -0,0 +1,49 @@
+package games.dmg.spigotignis;
+
+import static org.junit.jupiter.api.Assertions.*;
+import static org.mockito.Mockito.*;
+import java.net.URI;
+import java.util.UUID;
+import java.util.concurrent.CompletableFuture;
+import org.bukkit.Server;
+import org.bukkit.plugin.java.JavaPlugin;
+import org.bukkit.profile.PlayerProfile;
+import org.bukkit.profile.PlayerTextures;
+import org.junit.jupiter.api.Test;
+
+class MaskSkinLoaderTest {
+    @Test
+    void resolvesOnlyApprovedSkinAsynchronouslyAndReusesReadyProfile() throws Exception {
+        var plugin = mock(JavaPlugin.class);
+        var server = mock(Server.class);
+        when(plugin.getServer()).thenReturn(server);
+        var pending = mock(PlayerProfile.class);
+        when(server.createPlayerProfile("IgnisUmbra10")).thenReturn(pending);
+        var response = new CompletableFuture<PlayerProfile>();
+        doReturn(response).when(pending).update();
+        var dispatch = mock(EchoGameplay.class);
+        doAnswer(call -> { ((Runnable) call.getArgument(0)).run(); return null; }).when(dispatch).onServer(any());
+        var items = new MaskItems();
+        var loader = new MaskSkinLoader(plugin, items, dispatch);
+        loader.run(); loader.run();
+        assertFalse(items.ready());
+        var resolved = mock(PlayerProfile.class);
+        var textures = mock(PlayerTextures.class);
+        when(resolved.getUniqueId()).thenReturn(UUID.randomUUID());
+        when(resolved.getTextures()).thenReturn(textures);
+        when(textures.getSkin()).thenReturn(URI.create("https://textures.minecraft.net/texture/synthetic").toURL());
+        when(resolved.clone()).thenReturn(resolved);
+        response.complete(resolved);
+        assertTrue(items.ready());
+        loader.run();
+        verify(server, times(1)).createPlayerProfile("IgnisUmbra10");
+    }
+
+    @Test
+    void incompleteProfileCannotEnableCrafting() {
+        var items = new MaskItems();
+        assertThrows(IllegalArgumentException.class, () -> items.profile(mock(PlayerProfile.class)));
+        assertFalse(items.ready());
+        assertThrows(IllegalStateException.class, items::prototype);
+    }
+}

src/test/java/games/dmg/spigotignis/PluginPackagingTest.java

@@ -15,7 +15,11 @@ class PluginPackagingTest {
             assertFalse(descriptor.contains("${version}"));
             assertTrue(org.bukkit.plugin.java.JavaPlugin.class.isAssignableFrom(
                     Class.forName("games.dmg.spigotignis.SpigotIgnisPlugin", false, getClass().getClassLoader())));
-            assertFalse(descriptor.contains("commands:"), "Do not advertise unimplemented commands");
+            assertTrue(descriptor.contains("commands:"));
+            assertTrue(descriptor.contains("  ignis:"));
+            assertTrue(descriptor.contains("  ignisadmin:"));
+            assertTrue(descriptor.contains("permission: ignis.admin"));
+            assertTrue(descriptor.contains("default: op"));
         }
     }
 }

src/test/java/games/dmg/spigotignis/ProgressAdministrationTest.java

@@ -0,0 +1,40 @@
+package games.dmg.spigotignis;
+
+import static org.junit.jupiter.api.Assertions.*;
+import java.util.Set;
+import java.util.UUID;
+import org.junit.jupiter.api.Test;
+
+class ProgressAdministrationTest {
+    @Test
+    void progressAdjustmentIsValidatedAndUnlocksAtThresholdWithoutChangingOtherTracks() {
+        UUID id = UUID.randomUUID();
+        var state = ProgressAdministration.progress(IgnisState.empty(), id, Track.DAGGER, 312, false);
+        assertEquals(312, state.players().get(id).track(Track.DAGGER).progress());
+        assertFalse(state.players().get(id).track(Track.DAGGER).unlocked());
+        var unlocked = ProgressAdministration.progress(state, id, Track.DAGGER, 1, true);
+        assertTrue(unlocked.players().get(id).track(Track.DAGGER).unlocked());
+        assertEquals(TrackState.empty(), unlocked.players().get(id).track(Track.MASK));
+        assertThrows(IllegalArgumentException.class,
+                () -> ProgressAdministration.progress(state, id, Track.DAGGER, -1, true));
+        assertThrows(IllegalArgumentException.class,
+                () -> ProgressAdministration.progress(state, id, Track.VOID, 1, false));
+        var maximum = ProgressAdministration.progress(state, id, Track.DAGGER, Long.MAX_VALUE, false);
+        assertThrows(ArithmeticException.class,
+                () -> ProgressAdministration.progress(maximum, id, Track.DAGGER, 1, true));
+    }
+
+    @Test
+    void resetRevokesActivationAndOldTokensStayInvalidAfterReearning() {
+        UUID owner = UUID.randomUUID(), receipt = UUID.randomUUID();
+        var token = new EchoToken(owner, receipt, 0);
+        var before = EchoRewards.activate(EchoRewards.award(IgnisState.empty(), owner, receipt), owner, token);
+        var reset = ProgressAdministration.reset(before, owner, Set.of(Track.VOID));
+        assertFalse(reset.players().get(owner).track(Track.VOID).activated());
+        assertEquals(1, reset.players().get(owner).track(Track.VOID).generation());
+        UUID replacement = UUID.randomUUID();
+        var earned = EchoRewards.award(reset, owner, replacement);
+        assertFalse(EchoRewards.valid(earned, owner, token));
+        assertTrue(EchoRewards.valid(earned, owner, new EchoToken(owner, replacement, 1)));
+    }
+}

src/test/java/games/dmg/spigotignis/VoidTrialTest.java

@@ -0,0 +1,50 @@
+package games.dmg.spigotignis;
+
+import static org.junit.jupiter.api.Assertions.*;
+import java.util.UUID;
+import org.junit.jupiter.api.Test;
+
+class VoidTrialTest {
+    @Test
+    void requiresDamageAscentWhileGlidingAndFirstLandingOnEndStone() {
+        var trial = new VoidTrial();
+        UUID player = UUID.randomUUID(), world = UUID.randomUUID();
+        assertFalse(trial.moved(player, world, 60, false, true, true));
+        trial.damaged(player, world, -65);
+        trial.moved(player, world, 20, false, false, false);
+        assertFalse(trial.moved(player, world, 60, false, true, true));
+        trial.damaged(player, world, -65);
+        trial.moved(player, world, -66, true, false, false);
+        assertFalse(trial.moved(player, world, 60, false, true, true));
+        trial.damaged(player, world, -65);
+        trial.moved(player, world, 20, true, false, false);
+        assertFalse(trial.moved(player, world, 60, false, true, false));
+        assertFalse(trial.moved(player, world, 60, false, true, true));
+    }
+
+    @Test
+    void cancellationWorldChangeAndNewTrialPreventOldAttemptCompletion() {
+        UUID player = UUID.randomUUID(), world = UUID.randomUUID();
+        var trial = new VoidTrial();
+        trial.damaged(player, world, -65);
+        trial.moved(player, world, 20, true, false, false);
+        trial.cancel(player);
+        assertFalse(trial.moved(player, world, 60, false, true, true));
+        trial.damaged(player, world, -65);
+        trial.moved(player, world, 20, true, false, false);
+        assertFalse(trial.moved(player, UUID.randomUUID(), 60, false, true, true));
+        assertFalse(trial.moved(player, world, 60, false, true, true));
+        trial.damaged(player, world, -65);
+        assertFalse(new VoidTrial().moved(player, world, 60, false, true, true));
+    }
+
+    @Test
+    void survivedVoidDamageThenGlidingEscapeThenEndStoneCompletesOnlyOnce() {
+        var trial = new VoidTrial();
+        UUID player = UUID.randomUUID(), world = UUID.randomUUID();
+        trial.damaged(player, world, -65);
+        assertFalse(trial.moved(player, world, -50, true, false, false));
+        assertTrue(trial.moved(player, world, 60, false, true, true));
+        assertFalse(trial.moved(player, world, 60, false, true, true));
+    }
+}