fix(ignis): retain Echo recovery warnings during shutdown

Report failed reward saves independently of the tick callback with owner and receipt identifiers. Verify the approved lightweight consumption, inert-copy and failure/retry contract using native inventories and real persistence. Keep cross-save hard-crash recovery an explicit operator limitation; add no autosave-length restrictions or transaction protocol.

.gitea/scripts/git-credential-ignis.sh

@@ -13,6 +13,6 @@ while IFS='=' read -r key value && [ -n "$key" ]; do
 done
 [ "$protocol" = https ] || exit 0
 [ "$host" = git.garvis.dev ] || exit 0
-[ "$path" = dmg/spigot-ignis.git ] || exit 0
+[ "$path" = dmg/purpur-ignis.git ] || exit 0
 [ -n "${IGNIS_RELEASE_TOKEN:-}" ] || exit 0
 printf 'username=dmg\npassword=%s\n\n' "$IGNIS_RELEASE_TOKEN"

.gitea/workflows/ci.yml

@@ -35,6 +35,6 @@ jobs:
       - name: Upload development artifact
         uses: actions/upload-artifact@v3
         with:
-          name: spigot-ignis-${{ github.sha }}
+          name: purpur-ignis-${{ github.sha }}
           path: build/libs/*.jar
           if-no-files-found: error

.gitea/workflows/release.yml

@@ -47,7 +47,7 @@ jobs:
           set -euo pipefail
           test -n "$IGNIS_RELEASE_TOKEN" || { echo 'RELEASE_TOKEN is required'; exit 1; }
           test "$GITEA_SERVER_URL" = 'https://git.garvis.dev'
-          test "$REPOSITORY" = 'dmg/spigot-ignis'
+          test "$REPOSITORY" = 'dmg/purpur-ignis'
           # semantic-release overrides GIT_ASKPASS; use Git's credential protocol instead.
           # Token stays in environment/credential stdout, never in the remote URL or argv.
           export GIT_TERMINAL_PROMPT=0
@@ -85,8 +85,8 @@ jobs:
         if: steps.release.outputs.created == 'true'
         uses: actions/upload-artifact@v3
         with:
-          name: spigot-ignis-${{ steps.release.outputs.version }}
-          path: build/libs/spigot-ignis-${{ steps.release.outputs.version }}.jar
+          name: purpur-ignis-${{ steps.release.outputs.version }}
+          path: build/libs/purpur-ignis-${{ steps.release.outputs.version }}.jar
           if-no-files-found: error
 
       - name: Publish versioned Gitea asset
@@ -102,9 +102,9 @@ jobs:
         run: |
           set -euo pipefail
           test "$GITEA_SERVER_URL" = 'https://git.garvis.dev'
-          test "$REPOSITORY" = 'dmg/spigot-ignis'
+          test "$REPOSITORY" = 'dmg/purpur-ignis'
           api_url="${GITEA_SERVER_URL}/api/v1/repos/${REPOSITORY}/releases"
-          jar="build/libs/spigot-ignis-${VERSION}.jar"
+          jar="build/libs/purpur-ignis-${VERSION}.jar"
           payload=$(mktemp)
           response=$(mktemp)
           trap 'rm -f "$payload" "$response"' EXIT
@@ -127,4 +127,4 @@ jobs:
             curl --fail --silent --show-error --max-time 120 --proto '=https' \
               --header @- --header 'Content-Type: application/octet-stream' \
               --data-binary "@$jar" --output /dev/null \
-              "${api_url}/${release_id}/assets?name=spigot-ignis-${VERSION}.jar"
+              "${api_url}/${release_id}/assets?name=purpur-ignis-${VERSION}.jar"

AGENTS.md

@@ -1,8 +1,8 @@
-# Spigot Ignis agent entrypoint
+# Purpur Ignis agent entrypoint
 
 The canonical knowledge bundle is the sibling `../somc-okf/` repository, remotely at https://git.garvis.dev/dmg/somc-okf/src/branch/main/index.md.
 
-Before changes read its root index, `processes/development.md`, `runbooks/development-cycle.md`, `projects/spigot-ignis/index.md`, `projects/spigot-ignis/engineering.md`, and the relevant `user-stories/spigot-ignis/` documents. Follow the parent workspace instructions. Do not create a local knowledge/design bundle.
+Before changes read its root index, `processes/development.md`, `runbooks/development-cycle.md`, `projects/purpur-ignis/index.md`, `projects/purpur-ignis/engineering.md`, and the relevant `user-stories/purpur-ignis/` documents. Follow the parent workspace instructions. Do not create a local knowledge/design bundle.
 
 Use Java 25 and the declared Purpur API. Test behavior first with meaningful failures, implement minimally, then run `./gradlew clean check jar`. Never mark server/client behavior verified through domain tests alone.
 

README.md

@@ -1,6 +1,8 @@
-# Spigot Ignis
+# Purpur Ignis
 
-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.
+Server-wide earned shadow progression for Social Minecraft. **Echo of the Abyss, advancement-name scrambling, The Mask, The Dagger, and The Heart of Shadows are implemented in source; live-server/client verification is pending.**
+
+The repository, checkout and new artifacts use `purpur-ignis`. Runtime `SpigotIgnis`, Java packages/entrypoint, `plugins/SpigotIgnis/state.bin`, all `spigotignis:` item/recipe/provenance keys and existing gameplay are retained. Replace the old JAR rather than installing both distributions. Old tags/assets remain available. This rename does not close known Echo consumption/recovery gaps.
 
 ## Build
 
@@ -11,20 +13,20 @@ 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` 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.
+The runtime requires Java 25. New JARs are `build/libs/purpur-ignis-<version>.jar`. 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.
+The [canonical project](https://git.garvis.dev/dmg/somc-okf/src/branch/main/projects/purpur-ignis/index.md) and stories live in the shared private SoMC wiki. There is no repository-local knowledge bundle.
 
-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.
+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 Git credential helper scoped exclusively to `https://git.garvis.dev/dmg/purpur-ignis.git` 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, 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.
+- 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. Mask/Dagger validity additionally requires the holder's personal unlock and the issuer's matching track receipt/generation.
 - `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.
 
 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.
@@ -35,9 +37,9 @@ Take uncancelled void damage, ascend while gliding with elytra in the same world
 
 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.
+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, so it can be retried. Failed challenge-completion saves log the owner UUID and receipt ID for administrator recovery even if shutdown prevents the player callback; an online player is also notified when scheduling remains available. Pending delivery acknowledgements can retry without offering another copy while the original remains in the inventory.
 
-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.
+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. An advancement-only ProtocolLib output backstop also covers Purpur's affected-player-only branch, which sends the original pre-event component rather than the event's replacement. The backstop identifies an unambiguous player UUID in the name slot's entity hover and checks saved activation; it does not infer identity from name text, touch titles/descriptions or broaden recipients. Ordinary/custom chat remains unchanged. Native activation/reopen, event/delivery branches, packet codecs and plugin lifecycle tests cover this fix; the exact live report setting/format remains unconfirmed. Existing Stealth outbound masking sees the obfuscated alias rather than the original name. Live coexistence remains unverified.
 
 ## The Mask
 
@@ -53,9 +55,41 @@ A crafter's generation can share a recipe receipt across multiple legitimately p
 
 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.
 
+## The Dagger
+
+The default unlock is **313 consumed ender-pearl throws**, configurable through `limits set pearls`. A launch event alone does not count: the adapter correlates the pending pearl launch with its decreased item-stack mirror and the subsequent vanilla `USE_ITEM` notification. Cancelled launches, unsuccessful spawns without that notification, unconsumed/free throws, unrelated statistics, and duplicate notifications earn nothing. Cancelling the statistic update itself does not undo a pearl already consumed. This does not read or import players' vanilla statistic totals. Exact Purpur event ordering and servers/plugins suppressing those notifications remain live-verification requirements.
+
+Counts save off-thread, with in-memory retry of failed credit. Checkpoints wait for reserved writes rather than acknowledging early; reset generations discard stale buffers. Administrative counter edits drain old credits before applying the requested value. Shutdown drains the pearl tracker before closing the persistence worker. Unacknowledged credit cannot be guaranteed through a hard crash or unavailable storage.
+
+The authenticated Ominous Key is named **The Dagger**. Its unchanged recipe is:
+
+| | | |
+| --- | --- | --- |
+| Heart of the Sea | Heavy Core | Heart of the Sea |
+| Nether Star | Ominous Key | Nether Star |
+| Heart of the Sea | Dragon Egg | Heart of the Sea |
+
+Dagger crafting uses the same durable issuance policy as the Mask: vanilla retains ingredient consumption, locked/reset outputs and automated Crafters are denied, and pending admin gifts are not used as paid-craft receipts. `TradableRewards` shares the ledger rules without changing existing Mask PDC identities or schema version. Both issuer and holder need their own unlock; issuer reset invalidates traded copies.
+
+Right-click normally attempts **three blocks along the aim direction**. A visible player within **eight blocks** and a **three-dimensional 15-degree half-angle** cone instead selects a destination **1.5 horizontal blocks behind their facing direction**. Closest-to-crosshair selection uses UUID order for ties. Invisible/vanished, dead, and spectator targets are excluded. The user's look orientation is retained. Line-of-sight queries first check that their chunk corridor is loaded.
+
+A valid attempt starts a **two-second per-player cooldown**, shared across copies, even if unsafe or cancelled. Further attempts do not extend it. A blocked selected destination does not fall back to a different teleport. Item-use vetoes are respected, while vanilla's default denied block interaction with air does not suppress custom item use. Authenticated keys are prevented from being consumed as vanilla vault keys, including revoked copies.
+
+Safety uses the player's current bounding box, a continuous sweep against block collision shapes (including neighboring protruding shapes), a supported exit, world/build boundaries, and conservative liquid/hazard rejection. It does not sample past thin walls or load missing chunks. Work is capped at 32,768 candidate block cells; extreme body sizes/routes can be refused. Unsupported mid-air exits and campfire/hazard surfaces are conservatively refused. Native `Player.teleport(..., PLUGIN)` preserves the normal protection/cancellation event path and leaves the reusable item intact. Actual terrain, scaled/posed player collisions, and protection-plugin behavior still require live tests.
+
 ## 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.
+All players may use `/ignis umbra` to privately see the three active item tracks. No passive progress UI is added.
+
+### The Heart of Shadows
+
+Earn the personal unlock through six uninterrupted online hours at total light zero (configurable). Uncancelled positive final damage, leaving darkness, disconnecting, or restarting interrupts unfinished progress. Completed unlocks persist until administrative reset. Light observation never loads chunks; unavailable lighting cannot qualify.
+
+Craft a Creaking Heart surrounded orthogonally by four Ominous Bottle V items, with four Lingering Potions of Instant Health II in the corners. The registered recipe uses exact vanilla potion/bottle metadata, and preparation/click checks independently validate the matrix. Automated Crafters are denied; issued Hearts, including revoked copies, cannot be placed as blocks.
+
+Carrying an authenticated Heart requires both the holder's unlock and a valid issuer receipt/generation. It grants Regeneration II at total light zero, or at night in natural skylit worlds. Multiple copies do not stack. Existing stronger regeneration is left alone; weaker regeneration overlaid by Ignis is restored with its remaining server-tick duration on withdrawal. External clears/replacements and cancellation take precedence. Cleanup and native potion-event ordering still require live verification.
+
+Heart counters checkpoint periodically off-thread. Startup durably clears unfinished streaks before enabling gameplay; shutdown drains interruption writes before closing persistence. Administrator progress edits flush and rebase the active interval rather than replaying older elapsed progress.
 
 Administration requires **`ignis.admin`** (default: operators), checked independently during execution and autocomplete:
 
@@ -65,12 +99,14 @@ Administration requires **`ignis.admin`** (default: operators), checked independ
 /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 give <online-name|known-UUID> <echo|mask|dagger|heart>
 /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.
+`inspect` reports saved progress for all four tracks (Mask/Heart milliseconds and Dagger pearls), pending/issued reward counts, recipe unlock eligibility, and Echo eligibility separately from permanent advancement-name-scrambling activation. It also reports the active void attempt: `awaiting-elytra-ascent`, `awaiting-end-stone`, or `none`, including world UUID and original damage height when active. Inspection is read-only: it does not checkpoint progress, advance/cancel challenges, deliver items or write state. Counters exclude uncommitted tracker time; recipe unlocks do not mean item effects are currently equipped or active. Known offline UUIDs remain inspectable; unfinished void attempts are not restored after disconnect/restart.
+
+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/Dagger grants unlock use and queue authenticated items for inventory-ready delivery; new Masks also require profile resolution. Mask/Dagger delivery retries remember an already offered gift while its acknowledgement save is failing, so trading it away does not cause another offer in the same plugin session. This marker is not durable across process restart; failed-acknowledgement/restart recovery still requires operator review. 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.
 
@@ -80,12 +116,14 @@ Offline targets use UUIDs already present in Ignis state; online exact names are
 
 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.
 
+For a reported failed Echo award, restore writable storage first and match the logged owner UUID/receipt to the player. Inspect saved activation and pending rewards before granting anything: pending rewards retry automatically when inventory space is available. If the failed award needs replacement, use the existing operator-only `/ignisadmin give <target> echo` after review. A UUID not yet saved in Ignis must reconnect so its exact online name can be targeted. Do not reset earned progression merely to remove an inert leftover item, and do not grant a second reward for an already activated benefit.
+
 If loading fails, preserve the original file for investigation. Under an approved maintenance plan, stop the server, back up current data, restore a verified matching-version backup, and restart. Do not delete state to recover: that loses earned progress and invalidation records. Do not hand-edit the binary file or import another plugin's state. Restoring an old backup can also restore older revocation/progress state; review that consequence before doing it.
 
 ## Verification limits
 
 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.
+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. The approved lightweight contract guarantees one-item consumption in uninterrupted play and one permanent owner activation, not crash-atomic physical consumption. Hard crashes between the two saves may require administrator recovery; extra copies left by interruptions cannot activate again. No cross-save transaction protocol, forced player saves or autosave-length item restrictions are added. This is not a claim of live verification or permission to deploy.
 
-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.
+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; real consumed-pearl launch/statistic ordering; Dagger regular/shift/Crafter recipes, stale receipts, vault-key protection, target visibility, thin obstacles, scaled/posed bodies, hazardous/unsupported exits, world/chunk boundaries, cooldowns across copies/disconnect, and cancelled or redirected protection-plugin teleports.

build.gradle.kts

@@ -1,3 +1,6 @@
+import java.net.URI
+import java.security.MessageDigest
+
 plugins { java }
 
 group = "games.dmg"
@@ -24,7 +27,62 @@ dependencies {
     testRuntimeOnly("org.junit.platform:junit-platform-launcher")
 }
 
-tasks.test { useJUnitPlatform() }
+tasks.test {
+    useJUnitPlatform()
+    dependsOn(tasks.jar)
+    systemProperty("distribution.jar", tasks.jar.get().archiveFile.get().asFile.absolutePath)
+    systemProperty("distribution.version", project.version.toString())
+}
+// Native API/event/delivery regressions run without starting a listening server.
+val ignisRuntime = layout.buildDirectory.dir("ignis-runtime")
+val downloadIgnisRuntime = tasks.register("downloadIgnisRuntime") {
+    val launcher = ignisRuntime.map { it.file("purpur-26.2-2618.jar") }
+    outputs.file(launcher)
+    doLast {
+        val file = launcher.get().asFile
+        file.parentFile.mkdirs()
+        val connection = URI("https://api.purpurmc.org/v2/purpur/26.2/2618/download").toURL().openConnection()
+        connection.connectTimeout = 30_000
+        connection.readTimeout = 120_000
+        val bytes = connection.getInputStream().use { it.readBytes() }
+        val digest = MessageDigest.getInstance("SHA-256").digest(bytes).joinToString("") { "%02x".format(it) }
+        check(digest == "4a32d046a118804d89ca74ba89b798c98f6d8d1f310c18077ac573597049de31") { "Purpur 2618 checksum mismatch" }
+        file.writeBytes(bytes)
+    }
+}
+val prepareIgnisRuntime = tasks.register<JavaExec>("prepareIgnisRuntime") {
+    dependsOn(downloadIgnisRuntime)
+    javaLauncher = javaToolchains.launcherFor { languageVersion = JavaLanguageVersion.of(25) }
+    classpath = files(ignisRuntime.map { it.file("purpur-26.2-2618.jar") })
+    mainClass = "io.papermc.paperclip.Main"
+    jvmArgs("-Dpaperclip.patchonly=true")
+    workingDir(ignisRuntime)
+    outputs.dir(ignisRuntime.map { it.dir("versions") })
+    outputs.dir(ignisRuntime.map { it.dir("libraries") })
+}
+val nativeTest = sourceSets.create("nativeTest")
+dependencies {
+    add(nativeTest.implementationConfigurationName, platform("org.junit:junit-bom:5.13.4"))
+    add(nativeTest.implementationConfigurationName, "org.junit.jupiter:junit-jupiter")
+    add(nativeTest.implementationConfigurationName, "org.mockito:mockito-core:5.18.0")
+    add(nativeTest.implementationConfigurationName, "net.dmulloy2:ProtocolLib:5.4.0")
+    add(nativeTest.compileOnlyConfigurationName, "org.jetbrains:annotations:26.0.2")
+    add(nativeTest.compileOnlyConfigurationName, "org.checkerframework:checker-qual:3.49.2")
+    add(nativeTest.runtimeOnlyConfigurationName, "org.junit.platform:junit-platform-launcher")
+}
+val nativeRuntimeJars = files(fileTree(ignisRuntime) { include("versions/**/*.jar", "libraries/**/*.jar") }).builtBy(prepareIgnisRuntime)
+nativeTest.compileClasspath += sourceSets.main.get().output + nativeRuntimeJars
+nativeTest.runtimeClasspath += sourceSets.main.get().output + nativeRuntimeJars
+val nativeIgnisTest = tasks.register<Test>("nativeIgnisTest") {
+    description = "Runs native Purpur regressions without starting a server"
+    testClassesDirs = nativeTest.output.classesDirs
+    classpath = nativeTest.runtimeClasspath
+    useJUnitPlatform()
+    maxHeapSize = "1G"
+    workingDir(ignisRuntime)
+}
+tasks.check { dependsOn(nativeIgnisTest) }
+
 val pluginVersion = version
 tasks.processResources {
     filesMatching("plugin.yml") { expand("version" to pluginVersion) }

settings.gradle.kts

@@ -1,2 +1,2 @@
 plugins { id("org.gradle.toolchains.foojay-resolver-convention") version "1.0.0" }
-rootProject.name = "spigot-ignis"
+rootProject.name = "purpur-ignis"

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

@@ -14,11 +14,33 @@ public final class AdvancementMasker {
     private AdvancementMasker() { }
 
     public static Component mask(Component original) {
+        return maskNameSlots(original, name -> true);
+    }
+
+    /** Packet-only fallback requires a single authenticated player UUID in the name slot, never a text-name guess. */
+    public static Component maskIdentified(Component original, java.util.function.Predicate<java.util.UUID> activated) {
+        return maskNameSlots(original, name -> {
+            var identities = new java.util.HashSet<java.util.UUID>();
+            collectIdentities(name, identities);
+            return identities.size() == 1 && activated.test(identities.iterator().next());
+        });
+    }
+
+    private static void collectIdentities(Component component, java.util.Set<java.util.UUID> identities) {
+        if (component.hoverEvent() != null && component.hoverEvent().value() instanceof net.kyori.adventure.text.event.HoverEvent.ShowEntity entity
+                && entity.type().equals(net.kyori.adventure.key.Key.key("minecraft:player"))) {
+            identities.add(entity.id());
+        }
+        for (var child : component.children()) { collectIdentities(child, identities); }
+    }
+
+    private static Component maskNameSlots(Component original, java.util.function.Predicate<Component> authorized) {
         if (original == null) return null;
         Component result = original;
         boolean changed = false;
         if (result instanceof TranslatableComponent translation && KEYS.contains(translation.key())
-                && !translation.arguments().isEmpty()) {
+                && !translation.arguments().isEmpty()
+                && translation.arguments().getFirst().value() instanceof Component name && authorized.test(name)) {
             var arguments = new ArrayList<ComponentLike>(translation.arguments());
             arguments.set(0, Component.text("Anonymous").decorate(TextDecoration.OBFUSCATED).insertion(""));
             result = translation.arguments(arguments);
@@ -26,7 +48,7 @@ public final class AdvancementMasker {
         }
         var children = new ArrayList<Component>();
         for (Component child : original.children()) {
-            Component masked = mask(child);
+            Component masked = maskNameSlots(child, authorized);
             children.add(masked);
             changed |= masked != child;
         }

src/main/java/games/dmg/spigotignis/AnnouncementPacketListener.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 java.util.UUID;
+import java.util.function.Consumer;
+import java.util.function.Predicate;
+import org.bukkit.plugin.Plugin;
+
+/** Advancement-only wire backstop for native delivery paths which do not use the event's replacement component. */
+public final class AnnouncementPacketListener extends PacketAdapter {
+    private final Predicate<UUID> activated;
+    private final Consumer<String> warning;
+    private final java.lang.reflect.Method content, overlay, asAdventure, asVanilla;
+    private final java.lang.reflect.Constructor<?> packet;
+    private final java.util.concurrent.atomic.AtomicBoolean warned = new java.util.concurrent.atomic.AtomicBoolean();
+
+    public AnnouncementPacketListener(Plugin plugin, Predicate<UUID> activated, Consumer<String> warning) {
+        super(plugin, ListenerPriority.HIGHEST, PacketType.Play.Server.SYSTEM_CHAT);
+        this.activated = java.util.Objects.requireNonNull(activated);
+        this.warning = java.util.Objects.requireNonNull(warning);
+        try {
+            var nativeComponent = Class.forName("net.minecraft.network.chat.Component");
+            var packetType = Class.forName("net.minecraft.network.protocol.game.ClientboundSystemChatPacket");
+            var adventure = Class.forName("io.papermc.paper.adventure.PaperAdventure");
+            content = packetType.getMethod("content");
+            overlay = packetType.getMethod("overlay");
+            asAdventure = adventure.getMethod("asAdventure", nativeComponent);
+            asVanilla = adventure.getMethod("asVanilla", net.kyori.adventure.text.Component.class);
+            packet = packetType.getConstructor(nativeComponent, boolean.class);
+        } catch (ReflectiveOperationException failure) { throw new IllegalStateException("Unsupported native announcement packet layout", failure); }
+    }
+
+    @Override public void onPacketSending(PacketEvent event) {
+        if (event.isCancelled()) { return; }
+        try {
+            Object originalPacket = event.getPacket().getHandle();
+            if ((boolean) overlay.invoke(originalPacket)) { return; }
+            var original = (net.kyori.adventure.text.Component) asAdventure.invoke(null, content.invoke(originalPacket));
+            var masked = AdvancementMasker.maskIdentified(original, activated);
+            if (masked != original) {
+                Object projected = packet.newInstance(asVanilla.invoke(null, masked), false);
+                event.setPacket(new com.comphenix.protocol.events.PacketContainer(PacketType.Play.Server.SYSTEM_CHAT, projected));
+            }
+        } catch (ReflectiveOperationException | RuntimeException failure) {
+            if (warned.compareAndSet(false, true)) { warning.accept("Ignis announcement projection unavailable; original delivery retained: " + failure.getClass().getSimpleName()); }
+        }
+    }
+}

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

@@ -0,0 +1,18 @@
+package games.dmg.spigotignis;
+
+import java.util.UUID;
+import java.util.function.LongSupplier;
+
+/** Server-thread, per-player activation gate, independent of item copies and teleport outcome. */
+public final class DaggerCooldown {
+    private final LongSupplier clock;
+    private final java.util.Map<UUID, Long> started = new java.util.HashMap<>();
+    public DaggerCooldown(LongSupplier clock) { this.clock = clock; }
+    public boolean attempt(UUID player) {
+        long now = clock.getAsLong();
+        started.entrySet().removeIf(entry -> now - entry.getValue() >= 2_000_000_000L);
+        if (started.containsKey(player)) return false;
+        started.put(player, now);
+        return true;
+    }
+}

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

@@ -0,0 +1,28 @@
+package games.dmg.spigotignis;
+
+import java.util.function.Function;
+import org.bukkit.Material;
+import org.bukkit.NamespacedKey;
+import org.bukkit.inventory.ItemStack;
+import org.bukkit.inventory.ShapedRecipe;
+import org.bukkit.plugin.java.JavaPlugin;
+
+public final class DaggerCrafting extends ReceiptCrafting {
+    public static final NamespacedKey RECIPE = new NamespacedKey("spigotignis", "dagger");
+    public DaggerCrafting(JavaPlugin plugin, StateService states, DaggerItems items, EchoGameplay dispatch) {
+        this(plugin, states, items, dispatch, result -> new ShapedRecipe(RECIPE, result));
+    }
+    DaggerCrafting(JavaPlugin plugin, StateService states, DaggerItems items, EchoGameplay dispatch,
+            Function<ItemStack, ShapedRecipe> recipeFactory) {
+        super(plugin, states, items, dispatch, Track.DAGGER, RECIPE, recipeFactory);
+    }
+    @Override protected void configure(ShapedRecipe recipe) { configureRecipe(recipe); }
+    static void configureRecipe(ShapedRecipe recipe) {
+        recipe.shape("HCH", "NKN", "HEH");
+        recipe.setIngredient('H', Material.HEART_OF_THE_SEA);
+        recipe.setIngredient('C', Material.HEAVY_CORE);
+        recipe.setIngredient('N', Material.NETHER_STAR);
+        recipe.setIngredient('K', Material.OMINOUS_TRIAL_KEY);
+        recipe.setIngredient('E', Material.DRAGON_EGG);
+    }
+}

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

@@ -0,0 +1,12 @@
+package games.dmg.spigotignis;
+
+import java.util.function.Supplier;
+import org.bukkit.Material;
+import org.bukkit.inventory.ItemStack;
+
+public final class DaggerItems extends ReceiptItems {
+    public DaggerItems() { this(() -> new ItemStack(Material.OMINOUS_TRIAL_KEY)); }
+    DaggerItems(Supplier<ItemStack> factory) {
+        super(Material.OMINOUS_TRIAL_KEY, "dagger_identity", "The Dagger", factory);
+    }
+}

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

@@ -0,0 +1,65 @@
+package games.dmg.spigotignis;
+
+import org.bukkit.Location;
+import org.bukkit.Material;
+import org.bukkit.entity.Player;
+import org.bukkit.util.BoundingBox;
+
+/** Server-thread collision policy; never loads chunks or performs a teleport. */
+public final class DaggerSafety {
+    private static final long MAX_CELLS = 32768;
+    private DaggerSafety() { }
+    public static boolean safe(Player player, Location destination) {
+        var world = player.getWorld();
+        if (destination == null || destination.getWorld() != world
+                || !Double.isFinite(destination.getX()) || !Double.isFinite(destination.getY()) || !Double.isFinite(destination.getZ())) return false;
+        var motion = destination.toVector().subtract(player.getLocation().toVector());
+        var body = player.getBoundingBox().clone();
+        var end = body.clone().shift(motion);
+        if (end.getMinY() < world.getMinHeight() || end.getMaxY() > world.getMaxHeight()) return false;
+        var border = world.getWorldBorder();
+        for (double x : new double[]{end.getMinX(), end.getMaxX()}) {
+            for (double z : new double[]{end.getMinZ(), end.getMaxZ()}) {
+                if (!border.isInside(new Location(world, x, end.getMinY(), z))) return false;
+            }
+        }
+        var swept = body.clone().union(end);
+        if (swept.getMinX() <= Integer.MIN_VALUE + 2 || swept.getMaxX() >= Integer.MAX_VALUE - 2
+                || swept.getMinZ() <= Integer.MIN_VALUE + 2 || swept.getMaxZ() >= Integer.MAX_VALUE - 2) return false;
+        // A one-cell halo includes shapes protruding beyond their owning block.
+        int minX = (int) Math.floor(swept.getMinX()) - 1, maxX = (int) Math.floor(swept.getMaxX()) + 1;
+        int minZ = (int) Math.floor(swept.getMinZ()) - 1, maxZ = (int) Math.floor(swept.getMaxZ()) + 1;
+        int minY = Math.max(world.getMinHeight(), (int) Math.floor(swept.getMinY()) - 1);
+        int maxY = Math.min(world.getMaxHeight() - 1, (int) Math.floor(swept.getMaxY()) + 1);
+        long nx = (long) maxX - minX + 1, ny = (long) maxY - minY + 1, nz = (long) maxZ - minZ + 1;
+        if (nx <= 0 || ny <= 0 || nz <= 0 || nx > MAX_CELLS || ny > MAX_CELLS || nz > MAX_CELLS || nx * ny * nz > MAX_CELLS) return false;
+        for (int x = minX >> 4; x <= maxX >> 4; x++) {
+            for (int z = minZ >> 4; z <= maxZ >> 4; z++) {
+                if (!world.isChunkLoaded(x, z)) return false;
+            }
+        }
+        var supportedBody = end.clone().shift(0, -.05, 0);
+        for (int x = minX; x <= maxX; x++) {
+            for (int y = minY; y <= maxY; y++) {
+                for (int z = minZ; z <= maxZ; z++) {
+                    var block = world.getBlockAt(x, y, z);
+                    var cell = new BoundingBox(x, y, z, x + 1, y + 1, z + 1);
+                    if ((block.isLiquid() || dangerous(block.getType()))
+                            && (DaggerSweep.hits(body, motion, cell) || supportedBody.overlaps(cell))) return false;
+                    for (var local : block.getCollisionShape().getBoundingBoxes()) {
+                        if (DaggerSweep.hits(body, motion, local.clone().shift(x, y, z))) return false;
+                    }
+                }
+            }
+        }
+        return player.wouldCollideUsing(supportedBody);
+    }
+
+    private static boolean dangerous(Material material) {
+        return switch (material) {
+            case LAVA, FIRE, SOUL_FIRE, CACTUS, MAGMA_BLOCK, SWEET_BERRY_BUSH, WITHER_ROSE,
+                    POWDER_SNOW, POINTED_DRIPSTONE, CAMPFIRE, SOUL_CAMPFIRE -> true;
+            default -> false;
+        };
+    }
+}

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

@@ -0,0 +1,33 @@
+package games.dmg.spigotignis;
+
+import org.bukkit.util.BoundingBox;
+import org.bukkit.util.Vector;
+
+/** Continuous body sweep, avoiding thin-wall gaps introduced by point sampling. */
+public final class DaggerSweep {
+    private DaggerSweep() { }
+    public static boolean hits(BoundingBox body, Vector motion, BoundingBox obstacle) {
+        Vector center = body.getCenter();
+        // Shrink by a numerical tolerance so resting on a floor is not penetration.
+        double hx = Math.max(0, body.getWidthX() / 2 - 1e-7);
+        double hy = Math.max(0, body.getHeight() / 2 - 1e-7);
+        double hz = Math.max(0, body.getWidthZ() / 2 - 1e-7);
+        double[] start = {center.getX(), center.getY(), center.getZ()};
+        double[] delta = {motion.getX(), motion.getY(), motion.getZ()};
+        double[] min = {obstacle.getMinX() - hx, obstacle.getMinY() - hy, obstacle.getMinZ() - hz};
+        double[] max = {obstacle.getMaxX() + hx, obstacle.getMaxY() + hy, obstacle.getMaxZ() + hz};
+        double enter = 0, exit = 1;
+        for (int axis = 0; axis < 3; axis++) {
+            if (delta[axis] == 0) {
+                if (start[axis] < min[axis] || start[axis] > max[axis]) return false;
+            } else {
+                double a = (min[axis] - start[axis]) / delta[axis];
+                double b = (max[axis] - start[axis]) / delta[axis];
+                enter = Math.max(enter, Math.min(a, b));
+                exit = Math.min(exit, Math.max(a, b));
+                if (enter > exit) return false;
+            }
+        }
+        return true;
+    }
+}

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

@@ -0,0 +1,39 @@
+package games.dmg.spigotignis;
+
+import java.util.Collection;
+import java.util.Optional;
+import java.util.UUID;
+import org.bukkit.util.Vector;
+
+/** Geometry only; visibility and world safety are supplied by the server-thread adapter. */
+public final class DaggerTargeting {
+    private DaggerTargeting() { }
+    public record Target(UUID id, Vector eye, boolean visible) { }
+
+    public static Vector forward(Vector feet, Vector direction) {
+        return feet.clone().add(direction.clone().normalize().multiply(3));
+    }
+    public static Vector behind(Vector feet, float yaw) {
+        double radians = Math.toRadians(yaw);
+        return feet.clone().add(new Vector(Math.sin(radians) * 1.5, 0, -Math.cos(radians) * 1.5));
+    }
+
+    public static Optional<Target> select(Vector eye, Vector direction, Collection<Target> candidates) {
+        if (!Double.isFinite(direction.lengthSquared()) || direction.lengthSquared() <= 0) return Optional.empty();
+        Vector facing = direction.clone().normalize();
+        Target best = null;
+        double bestAlignment = -1;
+        for (Target target : candidates) {
+            Vector offset = target.eye().clone().subtract(eye);
+            double distanceSquared = offset.lengthSquared();
+            if (!target.visible() || distanceSquared <= 0 || distanceSquared > 64) continue;
+            double alignment = offset.dot(facing) / Math.sqrt(distanceSquared);
+            if (alignment < Math.cos(Math.toRadians(15))) continue;
+            if (alignment > bestAlignment || (alignment == bestAlignment && best != null && target.id().compareTo(best.id()) < 0)) {
+                best = target;
+                bestAlignment = alignment;
+            }
+        }
+        return Optional.ofNullable(best);
+    }
+}

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

@@ -0,0 +1,70 @@
+package games.dmg.spigotignis;
+
+import java.util.function.BiPredicate;
+import java.util.function.Supplier;
+import org.bukkit.Location;
+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.block.Action;
+import org.bukkit.event.player.PlayerInteractEvent;
+import org.bukkit.event.player.PlayerTeleportEvent.TeleportCause;
+
+public final class DaggerUse implements Listener {
+    private static final TradableRewards REWARDS = new TradableRewards(Track.DAGGER);
+    private final Supplier<IgnisState> states;
+    private final DaggerItems items;
+    private final DaggerCooldown cooldown;
+    private final BiPredicate<Player, Location> safety;
+    public DaggerUse(Supplier<IgnisState> states, DaggerItems items, DaggerCooldown cooldown, BiPredicate<Player, Location> safety) {
+        this.states = states; this.items = items; this.cooldown = cooldown; this.safety = safety;
+    }
+
+    // Air interactions can have block use denied by vanilla while item use remains allowed.
+    @EventHandler(priority = EventPriority.HIGHEST)
+    public void onUse(PlayerInteractEvent event) {
+        if (event.getAction() != Action.RIGHT_CLICK_AIR && event.getAction() != Action.RIGHT_CLICK_BLOCK) return;
+        if (event.useItemInHand() == Event.Result.DENY
+                || event.getAction() == Action.RIGHT_CLICK_BLOCK && event.useInteractedBlock() == Event.Result.DENY) return;
+        var identity = items.identify(event.getItem());
+        if (identity.isEmpty()) return;
+        // A Dagger must never be consumed as a vanilla vault key, including revoked copies.
+        event.setUseItemInHand(Event.Result.DENY);
+        event.setUseInteractedBlock(Event.Result.DENY);
+        Player player = event.getPlayer();
+        if (!player.isOnline() || player.isDead() || player.getGameMode() == org.bukkit.GameMode.SPECTATOR
+                || !REWARDS.valid(states.get(), player.getUniqueId(), identity.orElseThrow())
+                || !cooldown.attempt(player.getUniqueId())) return;
+        var feet = player.getLocation();
+        var eye = player.getEyeLocation();
+        var candidates = new java.util.ArrayList<DaggerTargeting.Target>();
+        var positions = new java.util.HashMap<java.util.UUID, Location>();
+        for (var other : player.getWorld().getPlayers()) {
+            if (other.getUniqueId().equals(player.getUniqueId()) || !other.isOnline() || other.isDead()
+                    || other.isInvisible() || other.getGameMode() == org.bukkit.GameMode.SPECTATOR
+                    || !player.canSee(other)) continue;
+            var otherEye = other.getEyeLocation();
+            if (otherEye.distanceSquared(eye) > 64 || !loadedLine(eye, otherEye)) continue;
+            candidates.add(new DaggerTargeting.Target(other.getUniqueId(), otherEye.toVector(), player.hasLineOfSight(other)));
+            positions.put(other.getUniqueId(), other.getLocation());
+        }
+        var selected = DaggerTargeting.select(eye.toVector(), eye.getDirection(), candidates);
+        var point = selected.map(target -> {
+            var position = positions.get(target.id());
+            return DaggerTargeting.behind(position.toVector(), position.getYaw());
+        }).orElseGet(() -> DaggerTargeting.forward(feet.toVector(), eye.getDirection()));
+        var destination = new Location(player.getWorld(), point.getX(), point.getY(), point.getZ(), feet.getYaw(), feet.getPitch());
+        if (safety.test(player, destination)) player.teleport(destination, TeleportCause.PLUGIN);
+    }
+
+    private static boolean loadedLine(Location from, Location to) {
+        for (int x = Math.min(from.getBlockX(), to.getBlockX()) >> 4; x <= Math.max(from.getBlockX(), to.getBlockX()) >> 4; x++) {
+            for (int z = Math.min(from.getBlockZ(), to.getBlockZ()) >> 4; z <= Math.max(from.getBlockZ(), to.getBlockZ()) >> 4; z++) {
+                if (!from.getWorld().isChunkLoaded(x, z)) return false;
+            }
+        }
+        return true;
+    }
+}

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

@@ -0,0 +1,100 @@
+package games.dmg.spigotignis;
+
+import java.util.HashMap;
+import java.util.Map;
+import java.util.UUID;
+import java.util.concurrent.CompletableFuture;
+import java.util.function.LongSupplier;
+
+/** Session identity prevents interrupted intervals from being replayed by queued writes. */
+public final class DarknessProgress {
+    private final StateService states;
+    private final LongSupplier clock;
+    private final Map<UUID, Session> sessions = new HashMap<>();
+    private static final class Session {
+        final long generation;
+        final DarknessStreak streak;
+        DarknessStreak.Progress desired;
+        boolean active;
+        Session(long generation, long seed, LongSupplier clock) {
+            this.generation = generation;
+            streak = new DarknessStreak(clock, seed);
+            desired = new DarknessStreak.Progress(seed, false);
+        }
+    }
+    public DarknessProgress(StateService states, LongSupplier clock) { this.states = states; this.clock = clock; }
+    private Session session(UUID player) {
+        var track = states.snapshot().players().getOrDefault(player, PlayerState.empty()).track(Track.HEART);
+        return sessions.compute(player, (ignored, old) -> old == null || old.generation != track.generation()
+                ? new Session(track.generation(), track.progress(), clock) : old);
+    }
+    public synchronized void observe(UUID player, boolean dark) {
+        if (!dark) { interrupt(player); return; }
+        Session session = session(player);
+        session.active = true;
+        session.desired = session.streak.sample(true, states.snapshot().limits().darknessMillis());
+    }
+    public synchronized void interrupt(UUID player) {
+        Session session = session(player);
+        if (session.desired.complete()) return;
+        if (session.active || session.desired.millis() != 0) {
+            sessions.put(player, new Session(session.generation, 0, clock));
+        }
+    }
+    public synchronized CompletableFuture<IgnisState> edit(UUID player, long value, boolean add) {
+        Session before = session(player);
+        return checkpoint(player).thenCompose(ignored -> states.update(state ->
+                ProgressAdministration.progress(state, player, Track.HEART, value, add))).thenApply(state -> {
+                    synchronized (this) { sessions.remove(player, before); }
+                    return state;
+                });
+    }
+    private record Capture(Session session, DarknessStreak.Progress desired) { }
+    private CompletableFuture<Void> batch;
+    public synchronized CompletableFuture<Void> checkpointAll() {
+        if (batch == null || batch.isDone()) batch = saveBatch();
+        return batch;
+    }
+    public synchronized CompletableFuture<Void> stopAll() {
+        new java.util.ArrayList<>(sessions.keySet()).forEach(this::interrupt);
+        // Shutdown must persist the new interruptions even if an older batch is in flight.
+        batch = saveBatch();
+        return batch;
+    }
+    private CompletableFuture<Void> saveBatch() {
+        var captured = new HashMap<UUID, Capture>();
+        sessions.forEach((id, session) -> captured.put(id, new Capture(session, session.desired)));
+        if (captured.isEmpty()) return CompletableFuture.completedFuture(null);
+        return states.update(state -> {
+            var players = new HashMap<>(state.players());
+            captured.forEach((id, capture) -> {
+                var current = players.getOrDefault(id, PlayerState.empty());
+                var heart = current.track(Track.HEART);
+                synchronized (this) {
+                    if (sessions.get(id) != capture.session() || heart.generation() != capture.session().generation || heart.unlocked()) return;
+                }
+                var tracks = new HashMap<>(current.tracks());
+                tracks.put(Track.HEART, new TrackState(capture.desired().millis(), capture.desired().complete(), heart.activated(), heart.generation()));
+                players.put(id, new PlayerState(tracks, current.pendingRewards(), current.issuedRewards()));
+            });
+            return new IgnisState(state.limits(), players).evaluate(state.limits());
+        }).thenApply(ignored -> null);
+    }
+
+    public synchronized CompletableFuture<IgnisState> checkpoint(UUID player) {
+        Session session = session(player);
+        var desired = session.desired;
+        return states.update(state -> {
+            var current = state.players().getOrDefault(player, PlayerState.empty());
+            var heart = current.track(Track.HEART);
+            synchronized (this) {
+                if (sessions.get(player) != session || heart.generation() != session.generation || heart.unlocked()) return state;
+            }
+            var tracks = new HashMap<>(current.tracks());
+            tracks.put(Track.HEART, new TrackState(desired.millis(), desired.complete(), heart.activated(), heart.generation()));
+            var players = new HashMap<>(state.players());
+            players.put(player, new PlayerState(tracks, current.pendingRewards(), current.issuedRewards()));
+            return new IgnisState(state.limits(), players).evaluate(state.limits());
+        });
+    }
+}

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

@@ -0,0 +1,38 @@
+package games.dmg.spigotignis;
+
+import java.util.function.LongSupplier;
+
+/** Online-session clock only; persistence and environmental observations are separate adapters. */
+public final class DarknessStreak {
+    public record Progress(long millis, boolean complete) { }
+    private final LongSupplier clock;
+    private boolean active;
+    private long started;
+    private Progress progress = new Progress(0, false);
+    public DarknessStreak(LongSupplier clock) { this.clock = clock; }
+    private long baseMillis;
+    public DarknessStreak(LongSupplier clock, long seedMillis) {
+        this(clock);
+        if (seedMillis < 0) throw new IllegalArgumentException("Negative streak seed.");
+        baseMillis = seedMillis;
+        progress = new Progress(seedMillis, false);
+    }
+    public Progress sample(boolean dark, long requiredMillis) {
+        if (requiredMillis <= 0) throw new IllegalArgumentException("Darkness limit must be positive.");
+        if (progress.complete()) return progress;
+        if (!dark) return interrupt();
+        long now = clock.getAsLong();
+        if (!active) { started = now; active = true; }
+        long elapsed = Math.max(progress.millis(), Math.addExact(baseMillis, Math.max(0, now - started) / 1_000_000));
+        progress = new Progress(elapsed, elapsed >= requiredMillis);
+        return progress;
+    }
+    public Progress interrupt() {
+        active = false;
+        if (!progress.complete()) {
+            baseMillis = 0;
+            progress = new Progress(0, false);
+        }
+        return progress;
+    }
+}

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

@@ -60,13 +60,19 @@ public final class EchoGameplay implements Listener {
             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(() -> {
+                    ? EchoRewards.award(state, owner, receipt) : state).whenComplete((state, error) -> {
+                        // Report independently of the tick callback: disable can prevent its delivery.
                         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();
-                    }));
+                            plugin.getLogger().warning("Echo reward save failed for " + owner + " (receipt " + receipt
+                                    + "); administrator recovery is required.");
+                        }
+                        onServer(() -> {
+                            if (error != null) {
+                                Player online = plugin.getServer().getPlayer(owner);
+                                if (online != null) online.sendMessage("Your void reward could not be saved. Please contact an administrator.");
+                            } else retryDeliveries();
+                        });
+                    });
         }
     }
 
@@ -76,6 +82,11 @@ public final class EchoGameplay implements Listener {
     @EventHandler public void onQuit(PlayerQuitEvent event) { cancel(event.getPlayer().getUniqueId()); }
     public void cancel(UUID player) { trial.cancel(player); }
 
+    /** Read-only server-thread inspection; does not advance, cancel or persist the attempt. */
+    public java.util.Optional<VoidTrial.Snapshot> trialSnapshot(UUID player) {
+        return trial.snapshot(player);
+    }
+
     public boolean activated(UUID player) {
         return states.snapshot().players().getOrDefault(player, PlayerState.empty()).track(Track.VOID).activated();
     }

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

@@ -0,0 +1,7 @@
+package games.dmg.spigotignis;
+
+/** Night only supplies the alternative activation condition in normal day/night worlds. */
+public final class HeartConditions {
+    private HeartConditions() { }
+    public static boolean active(boolean darkness, boolean normalWorld, boolean night) { return darkness || (normalWorld && night); }
+}

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

@@ -0,0 +1,31 @@
+package games.dmg.spigotignis;
+
+import org.bukkit.NamespacedKey;
+import org.bukkit.inventory.RecipeChoice;
+import org.bukkit.inventory.ShapedRecipe;
+import org.bukkit.plugin.java.JavaPlugin;
+
+public final class HeartCrafting extends ReceiptCrafting {
+    public static final NamespacedKey RECIPE = new NamespacedKey("spigotignis", "heart");
+    public HeartCrafting(JavaPlugin plugin, StateService states, HeartItems items, EchoGameplay dispatch) {
+        super(plugin, states, items, dispatch, Track.HEART, RECIPE, result -> new ShapedRecipe(RECIPE, result));
+    }
+    @Override protected boolean accepts(org.bukkit.inventory.ItemStack[] matrix) { return HeartIngredients.matrix(matrix); }
+    @Override protected void configure(ShapedRecipe recipe) {
+        var bottle = new org.bukkit.inventory.ItemStack(org.bukkit.Material.OMINOUS_BOTTLE);
+        var omen = (org.bukkit.inventory.meta.OminousBottleMeta) bottle.getItemMeta();
+        omen.setAmplifier(4);
+        bottle.setItemMeta(omen);
+        var potion = new org.bukkit.inventory.ItemStack(org.bukkit.Material.LINGERING_POTION);
+        var meta = (org.bukkit.inventory.meta.PotionMeta) potion.getItemMeta();
+        meta.setBasePotionType(org.bukkit.potion.PotionType.STRONG_HEALING);
+        potion.setItemMeta(meta);
+        configureRecipe(recipe, new RecipeChoice.ExactChoice(bottle), new RecipeChoice.ExactChoice(potion));
+    }
+    static void configureRecipe(ShapedRecipe recipe, RecipeChoice bottle, RecipeChoice healing) {
+        recipe.shape("PBP", "BCB", "PBP");
+        recipe.setIngredient('B', bottle);
+        recipe.setIngredient('P', healing);
+        recipe.setIngredient('C', org.bukkit.Material.CREAKING_HEART);
+    }
+}

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

@@ -0,0 +1,68 @@
+package games.dmg.spigotignis;
+
+import java.util.Arrays;
+import java.util.function.Function;
+import java.util.function.Predicate;
+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.plugin.java.JavaPlugin;
+import org.bukkit.potion.PotionEffect;
+import org.bukkit.potion.PotionEffectType;
+
+public final class HeartEffects implements Listener, Runnable {
+    private final JavaPlugin plugin;
+    private final HeartRegeneration regeneration;
+    private final Predicate<Player> eligible;
+    private final Function<Player, HeartRegeneration.Channel> channels;
+
+    public HeartEffects(JavaPlugin plugin, StateService states, HeartItems items) {
+        this(plugin, new HeartRegeneration(() -> Integer.toUnsignedLong(plugin.getServer().getCurrentTick())), player -> {
+            var world = player.getWorld();
+            var tokens = Arrays.stream(player.getInventory().getContents()).flatMap(item -> items.identify(item).stream()).toList();
+            return !player.isDead() && HeartEligibility.eligible(states.snapshot(), player.getUniqueId(), tokens,
+                    HeartEnvironment.dark(player.getLocation()),
+                    world.isNatural() && world.hasSkyLight(), !world.isDayTime());
+        }, HeartEffects::channel);
+    }
+    HeartEffects(JavaPlugin plugin, HeartRegeneration regeneration, Predicate<Player> eligible,
+            Function<Player, HeartRegeneration.Channel> channels) {
+        this.plugin = plugin; this.regeneration = regeneration; this.eligible = eligible; this.channels = channels;
+    }
+    @Override public void run() {
+        for (var player : plugin.getServer().getOnlinePlayers()) {
+            regeneration.tick(player.getUniqueId(), eligible.test(player), channels.apply(player));
+        }
+    }
+    @EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = true)
+    public void onEffect(EntityPotionEffectEvent event) {
+        if (event.getEntity() instanceof Player player && event.getModifiedType().equals(PotionEffectType.REGENERATION)) {
+            regeneration.changed(player.getUniqueId(), event.getAction() != EntityPotionEffectEvent.Action.CHANGED || event.isOverride(),
+                    event.getNewEffect() != null);
+        }
+    }
+    @EventHandler public void onQuit(PlayerQuitEvent event) { withdraw(event.getPlayer()); }
+    private void withdraw(Player player) {
+        regeneration.tick(player.getUniqueId(), false, channels.apply(player));
+        regeneration.forget(player.getUniqueId());
+    }
+    public void close() { plugin.getServer().getOnlinePlayers().forEach(this::withdraw); }
+
+    private static HeartRegeneration.Channel channel(Player player) {
+        return new HeartRegeneration.Channel() {
+            @Override public HeartRegeneration.Effect current() {
+                var current = player.getPotionEffect(PotionEffectType.REGENERATION);
+                return current == null ? null : new HeartRegeneration.Effect(current.getAmplifier(), current.getDuration(),
+                        current.isAmbient(), current.hasParticles(), current.hasIcon());
+            }
+            @Override public void apply(HeartRegeneration.Effect effect) {
+                player.addPotionEffect(new PotionEffect(PotionEffectType.REGENERATION, effect.ticks(), effect.amplifier(),
+                        effect.ambient(), effect.particles(), effect.icon()));
+            }
+            @Override public void remove() { player.removePotionEffect(PotionEffectType.REGENERATION); }
+        };
+    }
+}

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

@@ -0,0 +1,14 @@
+package games.dmg.spigotignis;
+
+import java.util.Collection;
+import java.util.UUID;
+
+public final class HeartEligibility {
+    private static final TradableRewards REWARDS = new TradableRewards(Track.HEART);
+    private HeartEligibility() { }
+    public static boolean eligible(IgnisState state, UUID holder, Collection<ItemToken> items,
+            boolean dark, boolean normalWorld, boolean night) {
+        return HeartConditions.active(dark, normalWorld, night)
+                && items.stream().anyMatch(token -> REWARDS.valid(state, holder, token));
+    }
+}

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

@@ -0,0 +1,14 @@
+package games.dmg.spigotignis;
+
+import org.bukkit.Location;
+
+/** Read-only light observation; never loads a chunk to establish eligibility. */
+public final class HeartEnvironment {
+    private HeartEnvironment() { }
+    public static boolean dark(Location location) {
+        if (location == null || location.getWorld() == null) return false;
+        var world = location.getWorld();
+        return world.isChunkLoaded(location.getBlockX() >> 4, location.getBlockZ() >> 4)
+                && world.getBlockAt(location.getBlockX(), location.getBlockY(), location.getBlockZ()).getLightLevel() == 0;
+    }
+}

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

@@ -0,0 +1,24 @@
+package games.dmg.spigotignis;
+
+import org.bukkit.inventory.ItemStack;
+
+public final class HeartIngredients {
+    private HeartIngredients() { }
+    public static boolean matrix(ItemStack[] items) {
+        if (items == null || items.length != 9 || items[4] == null || items[4].getType() != org.bukkit.Material.CREAKING_HEART) return false;
+        for (int slot : new int[]{0, 2, 6, 8}) if (!healing(items[slot])) return false;
+        for (int slot : new int[]{1, 3, 5, 7}) if (!bottle(items[slot])) return false;
+        return true;
+    }
+
+    public static boolean bottle(ItemStack item) {
+        return item != null && item.getType() == org.bukkit.Material.OMINOUS_BOTTLE
+                && item.getItemMeta() instanceof org.bukkit.inventory.meta.OminousBottleMeta meta
+                && meta.hasAmplifier() && meta.getAmplifier() == 4;
+    }
+    public static boolean healing(ItemStack item) {
+        return item != null && item.getType() == org.bukkit.Material.LINGERING_POTION
+                && item.getItemMeta() instanceof org.bukkit.inventory.meta.PotionMeta meta
+                && meta.getBasePotionType() == org.bukkit.potion.PotionType.STRONG_HEALING && !meta.hasCustomEffects();
+    }
+}

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

@@ -0,0 +1,12 @@
+package games.dmg.spigotignis;
+
+import java.util.function.Supplier;
+import org.bukkit.Material;
+import org.bukkit.inventory.ItemStack;
+
+public final class HeartItems extends ReceiptItems {
+    public HeartItems() { this(() -> new ItemStack(Material.CREAKING_HEART)); }
+    HeartItems(Supplier<ItemStack> factory) {
+        super(Material.CREAKING_HEART, "heart_identity", "The Heart of Shadows", factory);
+    }
+}

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

@@ -0,0 +1,14 @@
+package games.dmg.spigotignis;
+
+import org.bukkit.event.Listener;
+import org.bukkit.event.block.BlockPlaceEvent;
+
+/** Issued Hearts are inventory rewards, not placeable vanilla blocks. */
+public final class HeartPlacement implements Listener {
+    private final HeartItems items;
+    public HeartPlacement(HeartItems items) { this.items = items; }
+    @org.bukkit.event.EventHandler(priority = org.bukkit.event.EventPriority.HIGHEST, ignoreCancelled = true)
+    public void onPlace(BlockPlaceEvent event) {
+        if (items.identify(event.getItemInHand()).isPresent()) event.setCancelled(true);
+    }
+}

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

@@ -0,0 +1,56 @@
+package games.dmg.spigotignis;
+
+import java.util.UUID;
+import java.util.function.Consumer;
+import java.util.function.Predicate;
+import org.bukkit.Location;
+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.EntityDamageEvent;
+import org.bukkit.event.player.PlayerMoveEvent;
+import org.bukkit.event.player.PlayerTeleportEvent;
+import org.bukkit.event.player.PlayerQuitEvent;
+import org.bukkit.plugin.java.JavaPlugin;
+
+/** Main-thread observations; persistence is delegated to the serialized state worker. */
+public final class HeartProgressListener implements Listener, Runnable {
+    private final JavaPlugin plugin;
+    private final DarknessProgress progress;
+    private final Predicate<Location> dark;
+    private final Consumer<Throwable> errors;
+    public HeartProgressListener(JavaPlugin plugin, DarknessProgress progress, Consumer<Throwable> errors) {
+        this(plugin, progress, HeartEnvironment::dark, errors);
+    }
+    HeartProgressListener(JavaPlugin plugin, DarknessProgress progress, Predicate<Location> dark, Consumer<Throwable> errors) {
+        this.plugin = plugin; this.progress = progress; this.dark = dark; this.errors = errors;
+    }
+    @Override public void run() {
+        for (var player : plugin.getServer().getOnlinePlayers()) {
+            progress.observe(player.getUniqueId(), !player.isDead() && dark.test(player.getLocation()));
+        }
+    }
+    @EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = true)
+    public void onDamage(EntityDamageEvent event) {
+        if (!event.isCancelled() && event.getFinalDamage() > 0 && event.getEntity() instanceof Player player) {
+            interruptAndSave(player.getUniqueId());
+        }
+    }
+    @EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = true)
+    public void onMove(PlayerMoveEvent event) {
+        if (!event.isCancelled() && event.getTo() != null && !dark.test(event.getTo())) {
+            progress.interrupt(event.getPlayer().getUniqueId());
+        }
+    }
+    @EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = true)
+    public void onTeleport(PlayerTeleportEvent event) { onMove(event); }
+    @EventHandler public void onQuit(PlayerQuitEvent event) { interruptAndSave(event.getPlayer().getUniqueId()); }
+    private void interruptAndSave(UUID player) {
+        progress.interrupt(player);
+        progress.checkpoint(player).whenComplete((ignored, error) -> { if (error != null) errors.accept(error); });
+    }
+    public void checkpoint() {
+        progress.checkpointAll().whenComplete((ignored, error) -> { if (error != null) errors.accept(error); });
+    }
+}

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

@@ -0,0 +1,26 @@
+package games.dmg.spigotignis;
+
+/** Durable restart normalization for unfinished online-only darkness streaks. */
+public final class HeartProgressState {
+    private HeartProgressState() { }
+    public static java.util.concurrent.CompletableFuture<StateService> prepare(StateService service) {
+        return service.update(HeartProgressState::restart).handle((state, error) -> {
+            if (error != null) {
+                service.close();
+                throw new java.util.concurrent.CompletionException(error);
+            }
+            return service;
+        });
+    }
+    public static IgnisState restart(IgnisState state) {
+        var players = new java.util.HashMap<>(state.players());
+        players.replaceAll((id, player) -> {
+            var heart = player.track(Track.HEART);
+            if (heart.unlocked() || heart.progress() == 0) return player;
+            var tracks = new java.util.HashMap<>(player.tracks());
+            tracks.put(Track.HEART, new TrackState(0, false, heart.activated(), heart.generation()));
+            return new PlayerState(tracks, player.pendingRewards(), player.issuedRewards());
+        });
+        return new IgnisState(state.limits(), players);
+    }
+}

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

@@ -0,0 +1,65 @@
+package games.dmg.spigotignis;
+
+import java.util.UUID;
+import java.util.function.LongSupplier;
+
+/** Regeneration II overlay with restoration of an existing weaker effect. */
+public final class HeartRegeneration {
+    public record Effect(int amplifier, int ticks, boolean ambient, boolean particles, boolean icon) { }
+    public interface Channel {
+        Effect current();
+        void apply(Effect effect);
+        void remove();
+    }
+    private record Backup(Effect effect, long tick) { }
+    private final LongSupplier ticks;
+    private final EffectOwnership ownership = new EffectOwnership();
+    private final java.util.Set<UUID> changing = new java.util.HashSet<>();
+    private final java.util.Map<UUID, Backup> backups = new java.util.HashMap<>();
+    public HeartRegeneration(LongSupplier ticks) { this.ticks = ticks; }
+    public void changed(UUID player, boolean actual, boolean remains) {
+        if (actual && !changing.contains(player)) backups.remove(player);
+        ownership.changed(player, actual, remains);
+    }
+    public void tick(UUID player, boolean eligible, Channel channel) {
+        var current = channel.current();
+        if (!eligible) {
+            if (!ownership.owns(player)) return;
+            mutate(player, channel::remove);
+            var after = channel.current();
+            if (after != null) {
+                if (!after.equals(current)) forget(player); // Preserve an external replacement.
+                return; // Removal was cancelled or another effect is now present.
+            }
+            ownership.forget(player); // Disabled plugins may not receive removal events.
+            Backup backup = backups.remove(player);
+            if (backup != null) {
+                long elapsed = (ticks.getAsLong() - backup.tick()) & 0xffff_ffffL;
+                int remaining = backup.effect().ticks() == -1 ? -1 : (int) Math.max(0L, backup.effect().ticks() - elapsed);
+                if (remaining != 0) {
+                    Effect old = backup.effect();
+                    channel.apply(new Effect(old.amplifier(), remaining, old.ambient(), old.particles(), old.icon()));
+                }
+            }
+            return;
+        }
+        if (current == null || current.amplifier() < 1
+                || ownership.owns(player) && current.ticks() >= 0 && current.ticks() <= 20) {
+            if (!ownership.owns(player) && current != null) backups.put(player, new Backup(current, ticks.getAsLong()));
+            mutate(player, () -> channel.apply(new Effect(1, 40, true, false, true)));
+            if (!ownership.owns(player)) backups.remove(player);
+        }
+    }
+    public void forget(UUID player) {
+        ownership.forget(player);
+        changing.remove(player);
+        backups.remove(player);
+    }
+
+    private void mutate(UUID player, Runnable change) {
+        changing.add(player);
+        ownership.applying(player, true);
+        try { change.run(); }
+        finally { changing.remove(player); ownership.applying(player, false); }
+    }
+}

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

@@ -19,6 +19,8 @@ public final class IgnisCommands implements CommandExecutor, TabCompleter {
     private final StateService states;
     private final EchoGameplay gameplay;
     private final InvisibilityProgress maskTracker;
+    private final PearlProgress pearlTracker;
+    private final DarknessProgress heartTracker;
     private final Map<CommandSender, Confirmation> confirmations = new HashMap<>();
 
     public IgnisCommands(JavaPlugin plugin, StateService states, EchoGameplay gameplay) {
@@ -26,10 +28,22 @@ public final class IgnisCommands implements CommandExecutor, TabCompleter {
     }
 
     public IgnisCommands(JavaPlugin plugin, StateService states, EchoGameplay gameplay, InvisibilityProgress maskTracker) {
+        this(plugin, states, gameplay, maskTracker, null);
+    }
+
+    public IgnisCommands(JavaPlugin plugin, StateService states, EchoGameplay gameplay,
+            InvisibilityProgress maskTracker, PearlProgress pearlTracker) {
+        this(plugin, states, gameplay, maskTracker, pearlTracker, null);
+    }
+
+    public IgnisCommands(JavaPlugin plugin, StateService states, EchoGameplay gameplay,
+            InvisibilityProgress maskTracker, PearlProgress pearlTracker, DarknessProgress heartTracker) {
         this.plugin = plugin;
         this.states = states;
         this.gameplay = gameplay;
         this.maskTracker = maskTracker;
+        this.pearlTracker = pearlTracker;
+        this.heartTracker = heartTracker;
     }
 
     @Override public boolean onCommand(CommandSender sender, Command command, String label, String[] args) {
@@ -55,8 +69,19 @@ public final class IgnisCommands implements CommandExecutor, TabCompleter {
             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());
+                String progress = java.util.Arrays.stream(Track.values())
+                        .map(track -> track + "=" + player.track(track).progress())
+                        .collect(java.util.stream.Collectors.joining(", "));
+                sender.sendMessage(id + ": saved progress (MASK/HEART milliseconds, DAGGER pearls): " + progress
+                        + "; pending=" + player.pendingRewards().size() + "; issued=" + player.issuedRewards().size());
+                sender.sendMessage("Recipe unlocks: mask=" + status(player, Track.MASK)
+                        + ", dagger=" + status(player, Track.DAGGER) + ", heart=" + status(player, Track.HEART));
+                sender.sendMessage("Echo: eligibility=" + status(player, Track.VOID) + "; advancement-name scrambling="
+                        + (player.track(Track.VOID).activated() ? "active" : "inactive"));
+                sender.sendMessage("Void challenge: " + gameplay.trialSnapshot(id)
+                        .map(attempt -> (attempt.escaped() ? "awaiting-end-stone" : "awaiting-elytra-ascent")
+                                + "; world=" + attempt.world() + "; damage-y=" + attempt.damageHeight())
+                        .orElse("none"));
             } 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")) {
@@ -76,12 +101,15 @@ public final class IgnisCommands implements CommandExecutor, TabCompleter {
                 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());
+                        ? maskTracker.checkpoint(id) : track == Track.DAGGER && pearlTracker != null
+                        ? pearlTracker.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")) {
+                        track == Track.HEART && heartTracker != null ? heartTracker.edit(id, value, add)
+                                : checkpoint.thenCompose(ignored -> states.update(state -> ProgressAdministration.progress(state, id, track, value, add))));
+            } else if (args.length == 3 && args[0].equalsIgnoreCase("give") && Set.of("mask", "dagger", "heart").contains(args[2].toLowerCase(Locale.ROOT))) {
                 UUID id = resolve(args[1]), receipt = UUID.randomUUID();
-                mutation(sender, "grant Mask " + id, states.update(state -> MaskRewards.issue(state, id, receipt, true)));
+                var rewards = new TradableRewards(Track.valueOf(args[2].toUpperCase(Locale.ROOT)));
+                mutation(sender, "grant " + args[2] + " " + id, states.update(state -> rewards.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();
@@ -106,7 +134,7 @@ public final class IgnisCommands implements CommandExecutor, TabCompleter {
                 } 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].");
+                    + "give <player|UUID> <echo|mask|dagger|heart>; reset <player|UUID> <track|all> [confirm].");
         } catch (IllegalArgumentException | ArithmeticException exception) {
             sender.sendMessage("Invalid Ignis command: " + exception.getMessage());
         }
@@ -165,7 +193,7 @@ public final class IgnisCommands implements CommandExecutor, TabCompleter {
             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("give")) options = List.of("echo", "mask", "dagger", "heart");
         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");

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

@@ -0,0 +1,13 @@
+package games.dmg.spigotignis;
+
+import java.util.Objects;
+import java.util.UUID;
+
+/** Receipt identity; the item's PDC key and reward service supply the track. */
+public record ItemToken(UUID issuer, UUID receipt, long generation) {
+    public ItemToken {
+        Objects.requireNonNull(issuer);
+        Objects.requireNonNull(receipt);
+        if (generation < 0) throw new IllegalArgumentException("Invalid item generation.");
+    }
+}

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

@@ -27,6 +27,7 @@ public final class MaskCrafting implements Listener, Runnable {
     private final EchoGameplay dispatch;
     private final Set<UUID> preparing = new HashSet<>();
     private final Set<MaskToken> delivering = new HashSet<>();
+    private final Set<MaskToken> offered = new HashSet<>();
     private boolean registered;
     private final java.util.function.Function<org.bukkit.inventory.ItemStack, ShapedRecipe> recipeFactory;
 
@@ -90,10 +91,15 @@ public final class MaskCrafting implements Listener, Runnable {
             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;
+                if (delivering.contains(token)) continue;
+                if (!offered.contains(token) && !items.offer(player, token)) continue;
+                offered.add(token);
                 delivering.add(token);
                 states.update(current -> MaskRewards.acknowledge(current, token))
-                        .whenComplete((ignored, error) -> dispatch.onServer(() -> delivering.remove(token)));
+                        .whenComplete((ignored, error) -> dispatch.onServer(() -> {
+                            delivering.remove(token);
+                            if (error == null) offered.remove(token);
+                        }));
             }
         }
     }

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

@@ -1,58 +1,26 @@
 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. */
+/** Compatibility facade preserving existing Mask tokens and persisted identities. */
 public final class MaskRewards {
+    private static final TradableRewards REWARDS = new TradableRewards(Track.MASK);
     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));
+        return REWARDS.issue(state, issuer, receipt, adminGrant);
     }
-
     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;
+        return REWARDS.valid(state, holder, convert(token));
     }
-
     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()));
+        return REWARDS.craftingToken(state, issuer).map(token -> new MaskToken(token.issuer(), token.receipt(), token.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()));
+        return REWARDS.acknowledge(state, convert(token));
     }
-
-    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);
+    private static ItemToken convert(MaskToken token) {
+        return new ItemToken(token.issuer(), token.receipt(), token.generation());
     }
 }

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

@@ -0,0 +1,53 @@
+package games.dmg.spigotignis;
+
+import java.util.UUID;
+import java.util.function.Consumer;
+import com.destroystokyo.paper.event.player.PlayerLaunchProjectileEvent;
+import org.bukkit.event.Listener;
+import org.bukkit.event.player.PlayerStatisticIncrementEvent;
+
+/** Correlates a launch with the post-consumption vanilla USE_ITEM notification. */
+public final class PearlLaunchListener implements Listener {
+    private record Probe(PlayerLaunchProjectileEvent event, int before) { }
+    private final java.util.Map<UUID, java.util.Deque<Probe>> pending = new java.util.HashMap<>();
+    private final Consumer<Runnable> nextTick;
+    private final Consumer<UUID> credit;
+    public PearlLaunchListener(Consumer<Runnable> nextTick, Consumer<UUID> credit) {
+        this.nextTick = nextTick;
+        this.credit = credit;
+    }
+
+    @org.bukkit.event.EventHandler(priority = org.bukkit.event.EventPriority.MONITOR, ignoreCancelled = true)
+    public void onLaunch(PlayerLaunchProjectileEvent event) {
+        if (event.isCancelled() || !(event.getProjectile() instanceof org.bukkit.entity.EnderPearl)
+                || event.getItemStack().getType() != org.bukkit.Material.ENDER_PEARL) return;
+        UUID player = event.getPlayer().getUniqueId();
+        var probe = new Probe(event, event.getItemStack().getAmount());
+        pending.computeIfAbsent(player, ignored -> new java.util.ArrayDeque<>()).addFirst(probe);
+        nextTick.accept(() -> {
+            var probes = pending.get(player);
+            if (probes != null) {
+                probes.remove(probe);
+                if (probes.isEmpty()) pending.remove(player);
+            }
+        });
+    }
+
+    @org.bukkit.event.EventHandler(priority = org.bukkit.event.EventPriority.MONITOR)
+    public void onUse(PlayerStatisticIncrementEvent event) {
+        if (event.getStatistic() != org.bukkit.Statistic.USE_ITEM || event.getMaterial() != org.bukkit.Material.ENDER_PEARL) return;
+        UUID player = event.getPlayer().getUniqueId();
+        var probes = pending.get(player);
+        if (probes == null) return;
+        var iterator = probes.iterator();
+        while (iterator.hasNext()) {
+            Probe probe = iterator.next();
+            if (probe.event().isCancelled() || !probe.event().shouldConsume()
+                    || probe.event().getItemStack().getAmount() >= probe.before()) continue;
+            iterator.remove();
+            if (probes.isEmpty()) pending.remove(player);
+            credit.accept(player);
+            break;
+        }
+    }
+}

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

@@ -0,0 +1,56 @@
+package games.dmg.spigotignis;
+
+import java.util.UUID;
+import java.util.concurrent.CompletableFuture;
+
+/** Buffers observed consumed throws until acknowledged by the persistence worker. */
+public final class PearlProgress {
+    private final StateService states;
+    public PearlProgress(StateService states) { this.states = states; }
+    private static final class Buffer {
+        final long generation;
+        long count;
+        CompletableFuture<IgnisState> saving;
+        Buffer(long generation) { this.generation = generation; }
+    }
+    private final java.util.Map<UUID, Buffer> pending = new java.util.HashMap<>();
+    private Buffer buffer(UUID player) {
+        long generation = generation(states.snapshot(), player);
+        return pending.compute(player, (ignored, old) -> old == null || old.generation != generation ? new Buffer(generation) : old);
+    }
+    private static long generation(IgnisState state, UUID player) {
+        return state.players().getOrDefault(player, PlayerState.empty()).track(Track.DAGGER).generation();
+    }
+    public synchronized void record(UUID player) {
+        Buffer buffer = buffer(player);
+        buffer.count = Math.addExact(buffer.count, 1);
+    }
+    public synchronized CompletableFuture<Void> checkpointAll() {
+        return CompletableFuture.allOf(new java.util.ArrayList<>(pending.keySet()).stream()
+                .map(this::checkpoint).toArray(CompletableFuture<?>[]::new));
+    }
+
+    public synchronized CompletableFuture<IgnisState> checkpoint(UUID player) {
+        Buffer buffer = buffer(player);
+        if (buffer.saving != null) return buffer.saving.thenCompose(ignored -> checkpoint(player));
+        long count = buffer.count;
+        buffer.count = 0;
+        if (count == 0) {
+            pending.remove(player, buffer);
+            return CompletableFuture.completedFuture(states.snapshot());
+        }
+        var acknowledgement = new CompletableFuture<IgnisState>();
+        buffer.saving = acknowledgement;
+        states.update(state -> generation(state, player) == buffer.generation
+                ? ProgressAdministration.progress(state, player, Track.DAGGER, count, true) : state)
+                .whenComplete((state, error) -> {
+                    synchronized (this) {
+                        if (error != null) buffer.count = Math.addExact(buffer.count, count);
+                        buffer.saving = null;
+                    }
+                    if (error != null) acknowledgement.completeExceptionally(error);
+                    else acknowledgement.complete(state);
+                });
+        return acknowledgement;
+    }
+}

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

@@ -0,0 +1,125 @@
+package games.dmg.spigotignis;
+
+import java.util.HashSet;
+import java.util.Set;
+import java.util.UUID;
+import java.util.function.Function;
+import org.bukkit.Keyed;
+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.ItemStack;
+import org.bukkit.inventory.Recipe;
+import org.bukkit.inventory.ShapedRecipe;
+import org.bukkit.plugin.java.JavaPlugin;
+
+/** Shared preissued-receipt crafting and delivery; vanilla owns ingredient consumption. */
+public abstract class ReceiptCrafting implements Listener, Runnable {
+    private final JavaPlugin plugin;
+    private final StateService states;
+    private final ReceiptItems items;
+    private final EchoGameplay dispatch;
+    private final Track track;
+    private final NamespacedKey key;
+    private final TradableRewards rewards;
+    private final Function<ItemStack, ShapedRecipe> recipeFactory;
+    private boolean registered;
+    private final Set<UUID> preparing = new HashSet<>();
+    private final Set<ItemToken> delivering = new HashSet<>();
+    private final Set<ItemToken> offered = new HashSet<>();
+
+    protected ReceiptCrafting(JavaPlugin plugin, StateService states, ReceiptItems items, EchoGameplay dispatch,
+            Track track, NamespacedKey key, Function<ItemStack, ShapedRecipe> recipeFactory) {
+        this.plugin = plugin; this.states = states; this.items = items; this.dispatch = dispatch;
+        this.track = track; this.key = key; this.recipeFactory = recipeFactory;
+        rewards = new TradableRewards(track);
+    }
+    protected abstract void configure(ShapedRecipe recipe);
+    protected boolean accepts(ItemStack[] matrix) { return true; }
+
+    @Override public void run() {
+        if (!registered) {
+            var recipe = recipeFactory.apply(items.prototype());
+            configure(recipe);
+            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).unlocked()) {
+                if (player.hasDiscoveredRecipe(key)) player.undiscoverRecipe(key);
+                continue;
+            }
+            ensureReceipt(player);
+            if (!player.hasDiscoveredRecipe(key)) player.discoverRecipe(key);
+            for (var entry : state.pendingRewards().entrySet()) {
+                if (entry.getValue() != track) continue;
+                var token = new ItemToken(player.getUniqueId(), entry.getKey(), state.track(track).generation());
+                if (delivering.contains(token)) continue;
+                if (!offered.contains(token) && !items.offer(player, token)) continue;
+                offered.add(token);
+                delivering.add(token);
+                states.update(current -> rewards.acknowledge(current, token)).whenComplete((ignored, error) -> dispatch.onServer(() -> {
+                    delivering.remove(token);
+                    if (error == null) offered.remove(token);
+                }));
+            }
+        }
+    }
+    private void ensureReceipt(Player player) {
+        var owner = player.getUniqueId();
+        var snapshot = states.snapshot();
+        var state = snapshot.players().getOrDefault(owner, PlayerState.empty()).track(track);
+        if (!state.unlocked() || rewards.craftingToken(snapshot, owner).isPresent() || !preparing.add(owner)) return;
+        var receipt = UUID.randomUUID();
+        long generation = state.generation();
+        states.update(current -> {
+            var now = current.players().getOrDefault(owner, PlayerState.empty()).track(track);
+            return now.unlocked() && now.generation() == generation ? rewards.issue(current, owner, receipt, false) : current;
+        }).whenComplete((ignored, error) -> dispatch.onServer(() -> {
+            preparing.remove(owner);
+            var online = plugin.getServer().getPlayer(owner);
+            if (error != null || online == null) return;
+            var view = online.getOpenInventory();
+            if (view.getTopInventory() instanceof CraftingInventory inventory && matches(inventory.getRecipe())) {
+                inventory.setResult(items.prototype());
+                plugin.getServer().getPluginManager().callEvent(new PrepareItemCraftEvent(inventory, view, false));
+                online.updateInventory();
+            }
+        }));
+    }
+    public void close() { if (registered) plugin.getServer().removeRecipe(key); }
+
+    @EventHandler(priority = EventPriority.HIGHEST, ignoreCancelled = true)
+    public void onCraft(CraftItemEvent event) {
+        if (!matches(event.getRecipe())) return;
+        var identity = items.identify(event.getInventory().getResult());
+        if (!accepts(event.getInventory().getMatrix()) || !(event.getWhoClicked() instanceof Player player) || identity.isEmpty()
+                || !identity.orElseThrow().issuer().equals(player.getUniqueId())
+                || !rewards.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 (matches(event.getRecipe())) event.setCancelled(true); }
+
+    @EventHandler(priority = EventPriority.HIGHEST)
+    public void onPrepare(PrepareItemCraftEvent event) {
+        if (!matches(event.getInventory().getRecipe()) || event.getInventory().getResult() == null) return;
+        if (!accepts(event.getInventory().getMatrix()) || !(event.getView().getPlayer() instanceof Player player)) {
+            event.getInventory().setResult(null);
+            return;
+        }
+        var token = rewards.craftingToken(states.snapshot(), player.getUniqueId());
+        event.getInventory().setResult(token.map(items::create).orElse(null));
+        if (token.isEmpty()) ensureReceipt(player);
+    }
+    private boolean matches(Recipe recipe) { return recipe instanceof Keyed keyed && keyed.getKey().equals(key); }
+}

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

@@ -0,0 +1,53 @@
+package games.dmg.spigotignis;
+
+import java.util.Optional;
+import java.util.function.Supplier;
+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;
+
+/** Plain-item receipt encoding and delivery; appearance and track identity are fixed by adapters. */
+public class ReceiptItems {
+    private final Material material;
+    private final NamespacedKey identity;
+    private final String title;
+    private final Supplier<ItemStack> factory;
+    protected ReceiptItems(Material material, String key, String title, Supplier<ItemStack> factory) {
+        this.material = material;
+        this.identity = new NamespacedKey("spigotignis", key);
+        this.title = title;
+        this.factory = factory;
+    }
+    public ItemStack prototype() {
+        var item = factory.get();
+        var meta = item.getItemMeta();
+        meta.displayName(Component.text(title, NamedTextColor.DARK_PURPLE));
+        item.setItemMeta(meta);
+        return item;
+    }
+    public ItemStack create(ItemToken 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 boolean offer(Player player, ItemToken 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();
+    }
+    public Optional<ItemToken> identify(ItemStack item) {
+        if (item == null || item.getType() != material || !item.hasItemMeta()) return Optional.empty();
+        return EchoIdentity.decode(item.getItemMeta().getPersistentDataContainer().get(identity, PersistentDataType.STRING))
+                .map(token -> new ItemToken(token.owner(), token.receipt(), token.generation()));
+    }
+}

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

@@ -6,17 +6,26 @@ import org.bukkit.plugin.java.JavaPlugin;
 /** Registers gameplay only after durable state initialization succeeds. */
 public final class SpigotIgnisPlugin extends JavaPlugin {
     private CompletableFuture<StateService> initialization;
+    private AnnouncementPacketListener announcementPackets;
     private MaskProgressListener maskProgress;
     private MaskCrafting maskCrafting;
     private MaskEffects maskEffects;
     private MaskEquipmentListener maskEquipment;
+    private PearlProgress pearlProgress;
+    private DaggerCrafting daggerCrafting;
+    private DarknessProgress heartProgress;
+    private HeartCrafting heartCrafting;
+    private HeartEffects heartEffects;
+    private final java.util.concurrent.atomic.AtomicBoolean heartSaveWarning = new java.util.concurrent.atomic.AtomicBoolean();
+    private final java.util.concurrent.atomic.AtomicBoolean pearlSaveWarning = new java.util.concurrent.atomic.AtomicBoolean();
 
     @Override
     public void onEnable() {
-        initialization = StateService.open(new FileStateRepository(getDataFolder().toPath().resolve("state.bin")));
+        initialization = StateService.open(new FileStateRepository(getDataFolder().toPath().resolve("state.bin")))
+                .thenCompose(HeartProgressState::prepare);
         initialization.whenComplete((service, error) -> {
             if (error != null) {
-                getLogger().severe("Ignis state unavailable; original data retained. Restore a verified backup before retrying.");
+                getLogger().severe("Ignis state initialization failed; original data retained. Check storage and validated recovery guidance before retrying.");
             } else {
                 if (!isEnabled()) { service.close(); return; }
                 try {
@@ -25,6 +34,8 @@ public final class SpigotIgnisPlugin extends JavaPlugin {
                         var gameplay = new EchoGameplay(this, service, new EchoItems());
                         getServer().getPluginManager().registerEvents(gameplay, this);
                         getServer().getPluginManager().registerEvents(new AnnouncementListener(gameplay::activated), this);
+                        announcementPackets = new AnnouncementPacketListener(this, gameplay::activated, getLogger()::warning);
+                        com.comphenix.protocol.ProtocolLibrary.getProtocolManager().addPacketListener(announcementPackets);
                         getServer().getScheduler().runTaskTimer(this, gameplay::retryDeliveries, 1L, 100L);
                         var maskTracker = new InvisibilityProgress(service, System::nanoTime);
                         maskProgress = new MaskProgressListener(this, maskTracker);
@@ -41,13 +52,40 @@ public final class SpigotIgnisPlugin extends JavaPlugin {
                         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);
+                        pearlProgress = new PearlProgress(service);
+                        var pearlListener = new PearlLaunchListener(action -> getServer().getScheduler().runTask(this, action), id -> {
+                            pearlProgress.record(id);
+                            pearlProgress.checkpoint(id).whenComplete((saved, failure) -> reportPearlSave(failure));
+                        });
+                        getServer().getPluginManager().registerEvents(pearlListener, this);
+                        getServer().getScheduler().runTaskTimer(this,
+                                () -> pearlProgress.checkpointAll().whenComplete((saved, failure) -> reportPearlSave(failure)), 20L, 20L);
+                        var daggerItems = new DaggerItems();
+                        daggerCrafting = new DaggerCrafting(this, service, daggerItems, gameplay);
+                        getServer().getPluginManager().registerEvents(daggerCrafting, this);
+                        getServer().getPluginManager().registerEvents(new DaggerUse(service::snapshot, daggerItems,
+                                new DaggerCooldown(System::nanoTime), DaggerSafety::safe), this);
+                        getServer().getScheduler().runTaskTimer(this, daggerCrafting, 1L, 20L);
+                        heartProgress = new DarknessProgress(service, System::nanoTime);
+                        var heartListener = new HeartProgressListener(this, heartProgress, this::reportHeartSave);
+                        var heartItems = new HeartItems();
+                        heartCrafting = new HeartCrafting(this, service, heartItems, gameplay);
+                        heartEffects = new HeartEffects(this, service, heartItems);
+                        getServer().getPluginManager().registerEvents(heartListener, this);
+                        getServer().getPluginManager().registerEvents(heartCrafting, this);
+                        getServer().getPluginManager().registerEvents(heartEffects, this);
+                        getServer().getPluginManager().registerEvents(new HeartPlacement(heartItems), this);
+                        getServer().getScheduler().runTaskTimer(this, heartListener, 1L, 1L);
+                        getServer().getScheduler().runTaskTimer(this, heartListener::checkpoint, 100L, 100L);
+                        getServer().getScheduler().runTaskTimer(this, heartCrafting, 1L, 20L);
+                        getServer().getScheduler().runTaskTimer(this, heartEffects, 1L, 1L);
+                        var commands = new IgnisCommands(this, service, gameplay, maskTracker, pearlProgress, heartProgress);
                         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.");
+                        getLogger().info("Ignis Echo, Mask, Dagger and Heart enabled.");
                     });
                 } catch (org.bukkit.plugin.IllegalPluginAccessException ignored) {
                     service.close();
@@ -58,10 +96,37 @@ public final class SpigotIgnisPlugin extends JavaPlugin {
 
     @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);
+        try {
+            if (announcementPackets != null) com.comphenix.protocol.ProtocolLibrary.getProtocolManager().removePacketListener(announcementPackets);
+            if (heartEffects != null) heartEffects.close();
+            if (heartCrafting != null) heartCrafting.close();
+            if (maskEffects != null) maskEffects.close();
+            if (maskEquipment != null) com.comphenix.protocol.ProtocolLibrary.getProtocolManager().removePacketListener(maskEquipment);
+            if (maskCrafting != null) maskCrafting.close();
+            if (daggerCrafting != null) daggerCrafting.close();
+            if (maskProgress != null) maskProgress.stop();
+        } finally {
+            var pearlDrain = (pearlProgress == null ? CompletableFuture.<Void>completedFuture(null) : pearlProgress.checkpointAll())
+                    .whenComplete((saved, failure) -> reportPearlSave(failure));
+            var heartDrain = (heartProgress == null ? CompletableFuture.<Void>completedFuture(null) : heartProgress.stopAll())
+                    .whenComplete((saved, failure) -> reportHeartSave(failure));
+            CompletableFuture.allOf(pearlDrain, heartDrain).whenComplete((saved, failure) -> {
+                if (initialization != null) initialization.thenAccept(StateService::close);
+            });
+        }
+    }
+
+    private void reportHeartSave(Throwable failure) {
+        if (failure == null) heartSaveWarning.set(false);
+        else if (heartSaveWarning.compareAndSet(false, true)) {
+            getLogger().warning("Heart progress save failed; desired state remains in memory for retry while enabled.");
+        }
+    }
+
+    private void reportPearlSave(Throwable failure) {
+        if (failure == null) pearlSaveWarning.set(false);
+        else if (pearlSaveWarning.compareAndSet(false, true)) {
+            getLogger().warning("Pearl progress save failed; unacknowledged credit remains in memory for retry while enabled.");
+        }
     }
 }

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

@@ -0,0 +1,62 @@
+package games.dmg.spigotignis;
+
+import java.util.HashMap;
+import java.util.Optional;
+import java.util.UUID;
+
+/** Track-specific durable issuance and personal-use validation for tradable rewards. */
+public final class TradableRewards {
+    private final Track track;
+    public TradableRewards(Track track) {
+        if (track == null || track == Track.VOID) throw new IllegalArgumentException("Echo uses bound activation rewards.");
+        this.track = track;
+    }
+
+    public IgnisState issue(IgnisState state, UUID issuer, UUID receipt, boolean adminGrant) {
+        PlayerState player = state.players().getOrDefault(issuer, PlayerState.empty());
+        TrackState previous = player.track(track);
+        if (!adminGrant && !previous.unlocked()) throw new IllegalArgumentException("Crafting is not unlocked.");
+        if (player.issuedRewards().containsKey(receipt)) {
+            if (player.issuedRewards().get(receipt) != track) throw new IllegalArgumentException("Receipt is already used.");
+            return state;
+        }
+        var tracks = new HashMap<>(player.tracks());
+        tracks.put(track, new TrackState(previous.progress(), true, previous.activated(), previous.generation()));
+        var issued = new HashMap<>(player.issuedRewards());
+        issued.put(receipt, track);
+        var pending = new HashMap<>(player.pendingRewards());
+        if (adminGrant) pending.put(receipt, track);
+        return replace(state, issuer, new PlayerState(tracks, pending, issued));
+    }
+
+    public boolean valid(IgnisState state, UUID holder, ItemToken token) {
+        PlayerState origin = state.players().getOrDefault(token.issuer(), PlayerState.empty());
+        return state.players().getOrDefault(holder, PlayerState.empty()).track(track).unlocked()
+                && origin.track(track).unlocked()
+                && origin.track(track).generation() == token.generation()
+                && origin.issuedRewards().get(token.receipt()) == track;
+    }
+
+    public Optional<ItemToken> craftingToken(IgnisState state, UUID issuer) {
+        PlayerState player = state.players().getOrDefault(issuer, PlayerState.empty());
+        if (!player.track(track).unlocked()) return Optional.empty();
+        return player.issuedRewards().entrySet().stream().filter(entry -> entry.getValue() == track)
+                .filter(entry -> !player.pendingRewards().containsKey(entry.getKey()))
+                .map(java.util.Map.Entry::getKey).sorted().findFirst()
+                .map(id -> new ItemToken(issuer, id, player.track(track).generation()));
+    }
+
+    public IgnisState acknowledge(IgnisState state, ItemToken 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/VoidTrial.java

@@ -6,6 +6,7 @@ import java.util.UUID;
 
 /** Server-thread transient attempts. Never persisted across disconnect/restart. */
 public final class VoidTrial {
+    public record Snapshot(UUID world, double damageHeight, boolean escaped) { }
     private record Attempt(UUID world, double damageHeight, boolean escaped) { }
     private final Map<UUID, Attempt> attempts = new HashMap<>();
 
@@ -30,5 +31,12 @@ public final class VoidTrial {
         return false;
     }
 
+    /** Server-thread read only: never advances, cancels or persists an attempt. */
+    public java.util.Optional<Snapshot> snapshot(UUID player) {
+        Attempt attempt = attempts.get(player);
+        return attempt == null ? java.util.Optional.empty()
+            : java.util.Optional.of(new Snapshot(attempt.world(), attempt.damageHeight(), attempt.escaped()));
+    }
+
     public void cancel(UUID player) { attempts.remove(player); }
 }

src/main/resources/plugin.yml

@@ -2,7 +2,7 @@ name: SpigotIgnis
 version: '${version}'
 main: games.dmg.spigotignis.SpigotIgnisPlugin
 api-version: '1.21'
-description: Earnable shadow progression with Echo of the Abyss and The Mask.
+description: Earnable shadow progression with Echo of the Abyss, The Mask, and The Dagger.
 depend: [ProtocolLib]
 commands:
   ignis:

src/nativeTest/java/games/dmg/spigotignis/AnnouncementPluginLifecycleTest.java

@@ -0,0 +1,83 @@
+package games.dmg.spigotignis;
+
+import static org.junit.jupiter.api.Assertions.*;
+import static org.mockito.Mockito.*;
+import com.comphenix.protocol.ProtocolLibrary;
+import com.comphenix.protocol.ProtocolManager;
+import com.comphenix.protocol.events.PacketListener;
+import java.nio.file.Path;
+import java.util.ArrayList;
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.LinkedBlockingQueue;
+import java.util.concurrent.TimeUnit;
+import org.bukkit.Bukkit;
+import org.bukkit.craftbukkit.CraftServer;
+import org.bukkit.craftbukkit.scheduler.CraftScheduler;
+import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.io.TempDir;
+
+class AnnouncementPluginLifecycleTest {
+    @TempDir Path directory;
+    @BeforeAll static void bootstrap() throws Exception { NativeRuntime.bootstrap(); }
+
+    @Test
+    @SuppressWarnings({"try", "unchecked"})
+    void actualEntrypointRegistersAndRemovesTheAnnouncementWireBackstop() throws Exception {
+        var server = mock(CraftServer.class);
+        try (var protocol = mockStatic(ProtocolLibrary.class);
+                var platform = mockStatic(Bukkit.class, call -> switch (call.getMethod().getName()) {
+                    case "getServer" -> server;
+                    case "isPrimaryThread" -> true;
+                    case "getVersion" -> "Purpur 2618 (MC: 26.2)";
+                    case "getMinecraftVersion" -> "26.2";
+                    case "getBukkitVersion" -> "26.2-R0.1-SNAPSHOT";
+                    default -> call.callRealMethod();
+                })) {
+            var packets = new ArrayList<PacketListener>();
+            var manager = mock(ProtocolManager.class);
+            protocol.when(ProtocolLibrary::getProtocolManager).thenReturn(manager);
+            doAnswer(call -> { packets.add(call.getArgument(0)); return null; }).when(manager).addPacketListener(any());
+            doAnswer(call -> { packets.remove(call.getArgument(0)); return null; }).when(manager).removePacketListener(any());
+            var plugin = mock(SpigotIgnisPlugin.class, CALLS_REAL_METHODS);
+            doReturn(true).when(plugin).isEnabled();
+            doReturn(server).when(plugin).getServer();
+            doReturn("SpigotIgnis").when(plugin).getName();
+            doReturn(directory.toFile()).when(plugin).getDataFolder();
+            doReturn(java.util.logging.Logger.getAnonymousLogger()).when(plugin).getLogger();
+            doReturn(mock(org.bukkit.command.PluginCommand.class)).when(plugin).getCommand(anyString());
+            for (var name : java.util.List.of("heartSaveWarning", "pearlSaveWarning")) {
+                var field = SpigotIgnisPlugin.class.getDeclaredField(name);
+                field.setAccessible(true);
+                field.set(plugin, new java.util.concurrent.atomic.AtomicBoolean());
+            }
+            var scheduler = mock(CraftScheduler.class);
+            when(server.getScheduler()).thenReturn(scheduler);
+            var callbacks = new LinkedBlockingQueue<Runnable>();
+            when(scheduler.runTask(eq(plugin), any(Runnable.class))).thenAnswer(call -> { callbacks.add(call.getArgument(1)); return null; });
+            var events = new ArrayList<org.bukkit.event.Listener>();
+            var plugins = mock(org.bukkit.plugin.PluginManager.class);
+            when(server.getPluginManager()).thenReturn(plugins);
+            doAnswer(call -> { events.add(call.getArgument(0)); return null; }).when(plugins).registerEvents(any(), eq(plugin));
+            plugin.onEnable();
+            var initialization = SpigotIgnisPlugin.class.getDeclaredField("initialization");
+            initialization.setAccessible(true);
+            var service = ((CompletableFuture<StateService>) initialization.get(plugin)).get(5, TimeUnit.SECONDS);
+            try {
+                var callback = callbacks.poll(5, TimeUnit.SECONDS);
+                assertNotNull(callback);
+                callback.run();
+                assertTrue(events.stream().anyMatch(AnnouncementListener.class::isInstance));
+                assertTrue(packets.stream().anyMatch(AnnouncementPacketListener.class::isInstance), "native delivery backstop must be registered by the real plugin");
+                verify(server, never()).createPlayerProfile(anyString());
+            } finally {
+                plugin.onDisable();
+                service.close();
+                var worker = StateService.class.getDeclaredField("worker");
+                worker.setAccessible(true);
+                assertTrue(((java.util.concurrent.ExecutorService) worker.get(service)).awaitTermination(5, TimeUnit.SECONDS));
+            }
+            assertTrue(packets.stream().noneMatch(AnnouncementPacketListener.class::isInstance), "disable must remove the wire listener");
+        }
+    }
+}

src/nativeTest/java/games/dmg/spigotignis/NativeEchoAnnouncementTest.java

@@ -0,0 +1,190 @@
+package games.dmg.spigotignis;
+
+import static org.junit.jupiter.api.Assertions.*;
+import static org.mockito.Mockito.*;
+import com.comphenix.protocol.PacketType;
+import com.comphenix.protocol.events.PacketContainer;
+import com.comphenix.protocol.events.PacketEvent;
+import io.papermc.paper.adventure.PaperAdventure;
+import java.nio.file.Path;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+import java.util.Optional;
+import java.util.UUID;
+import java.util.concurrent.LinkedBlockingQueue;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicReference;
+import net.kyori.adventure.text.Component;
+import net.kyori.adventure.text.TranslatableComponent;
+import net.kyori.adventure.text.format.TextDecoration;
+import net.minecraft.advancements.Advancement;
+import net.minecraft.advancements.AdvancementHolder;
+import net.minecraft.advancements.AdvancementType;
+import net.minecraft.network.protocol.Packet;
+import net.minecraft.network.protocol.game.ClientboundSystemChatPacket;
+import net.minecraft.server.PlayerAdvancements;
+import net.minecraft.server.level.ServerPlayer;
+import org.bukkit.Bukkit;
+import org.bukkit.craftbukkit.CraftServer;
+import org.bukkit.craftbukkit.entity.CraftPlayer;
+import org.bukkit.craftbukkit.inventory.CraftInventoryPlayer;
+import org.bukkit.craftbukkit.scheduler.CraftScheduler;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.player.PlayerAdvancementDoneEvent;
+import org.bukkit.plugin.EventExecutor;
+import org.bukkit.plugin.RegisteredListener;
+import org.bukkit.plugin.java.JavaPlugin;
+import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.api.io.TempDir;
+
+class NativeEchoAnnouncementTest {
+    @TempDir Path directory;
+    @BeforeAll static void bootstrap() throws Exception { NativeRuntime.bootstrap(); }
+
+    @org.junit.jupiter.params.ParameterizedTest
+    @org.junit.jupiter.params.provider.MethodSource("cases")
+    @SuppressWarnings("try")
+    void consumedEchoSurvivesReopenAndMasksNativeAnnouncementDelivery(AdvancementType type, String mode) throws Exception {
+        boolean onlyAffected = !mode.equals("broadcast");
+        var server = mock(CraftServer.class);
+        try (var platform = mockStatic(Bukkit.class, call -> switch (call.getMethod().getName()) {
+            case "getServer" -> server;
+            case "isPrimaryThread" -> true;
+            case "getVersion" -> "Purpur 2618 (MC: 26.2)";
+            case "getMinecraftVersion" -> "26.2";
+            case "getBukkitVersion" -> "26.2-R0.1-SNAPSHOT";
+            default -> call.callRealMethod();
+        })) {
+            UUID owner = UUID.randomUUID(), receipt = UUID.randomUUID();
+            var token = new EchoToken(owner, receipt, 0);
+            var player = mock(CraftPlayer.class);
+            when(player.getUniqueId()).thenReturn(owner);
+            when(player.getName()).thenReturn("EchoOwner");
+            var nativePlayer = mock(ServerPlayer.class);
+            when(player.getHandle()).thenReturn(nativePlayer);
+            when(nativePlayer.getBukkitEntity()).thenReturn(player);
+            var inventory = mock(CraftInventoryPlayer.class);
+            when(player.getInventory()).thenReturn(inventory);
+            when(inventory.getSize()).thenReturn(41);
+            var items = new EchoItems();
+            var slot = new AtomicReference<>(items.create(token));
+            when(inventory.getItem(0)).thenAnswer(call -> slot.get());
+            doAnswer(call -> { slot.set(call.getArgument(1)); return null; }).when(inventory).setItem(eq(0), any());
+            var plugin = mock(JavaPlugin.class);
+            when(plugin.isEnabled()).thenReturn(true);
+            when(plugin.getServer()).thenReturn(server);
+            when(server.getPlayer(owner)).thenReturn(player);
+            var scheduler = mock(CraftScheduler.class);
+            when(server.getScheduler()).thenReturn(scheduler);
+            var callbacks = new LinkedBlockingQueue<Runnable>();
+            when(scheduler.runTask(eq(plugin), any(Runnable.class))).thenAnswer(call -> { callbacks.add(call.getArgument(1)); return null; });
+            var repository = new FileStateRepository(directory.resolve("state.bin"));
+            try (var states = StateService.open(repository).get(5, TimeUnit.SECONDS)) {
+                states.update(state -> EchoRewards.award(state, owner, receipt)).get(5, TimeUnit.SECONDS);
+                var gameplay = new EchoGameplay(plugin, states, items);
+                var use = new org.bukkit.event.player.PlayerInteractEvent(player, org.bukkit.event.block.Action.RIGHT_CLICK_AIR,
+                        slot.get(), null, org.bukkit.block.BlockFace.SELF, org.bukkit.inventory.EquipmentSlot.HAND);
+                gameplay.onUse(use);
+                var callback = callbacks.poll(5, TimeUnit.SECONDS);
+                assertNotNull(callback);
+                callback.run();
+                assertNull(slot.get(), "happy-path consumption must remove the real receipt item");
+                assertTrue(gameplay.activated(owner));
+            }
+            try (var states = StateService.open(repository).get(5, TimeUnit.SECONDS)) {
+                var gameplay = new EchoGameplay(plugin, states, items);
+                assertTrue(gameplay.activated(owner), "saved activation must survive service reopen");
+                if (mode.equals("reset")) { states.update(state -> ProgressAdministration.reset(state, owner, java.util.Set.of(Track.VOID))).get(5, TimeUnit.SECONDS); }
+                if (mode.equals("ordinary")) { when(player.getUniqueId()).thenReturn(UUID.randomUUID()); }
+                var listener = new AnnouncementListener(gameplay::activated);
+                var warnings = new ArrayList<String>();
+                var packets = new AnnouncementPacketListener(plugin, gameplay::activated, warnings::add);
+                var delivered = new ArrayList<Component>();
+                nativePlayer.connection = mock(net.minecraft.server.network.ServerGamePacketListenerImpl.class);
+                org.mockito.stubbing.Answer<Void> capture = call -> {
+                    var raw = call.getArgument(0, ClientboundSystemChatPacket.class);
+                    var outgoing = PacketEvent.fromServer(this, new PacketContainer(PacketType.Play.Server.SYSTEM_CHAT, raw), player);
+                    if (mode.equals("wire-cancelled")) { outgoing.setCancelled(true); }
+                    var before = raw.content();
+                    packets.onPacketSending(outgoing);
+                    assertSame(before, raw.content(), "shared native packet content must not be mutated");
+                    if (!outgoing.isCancelled()) {
+                        var projected = (ClientboundSystemChatPacket) outgoing.getPacket().getHandle();
+                        var buffer = new net.minecraft.network.RegistryFriendlyByteBuf(io.netty.buffer.Unpooled.buffer(), org.bukkit.craftbukkit.CraftRegistry.getMinecraftRegistry());
+                        try {
+                            ClientboundSystemChatPacket.STREAM_CODEC.encode(buffer, projected);
+                            var decoded = ClientboundSystemChatPacket.STREAM_CODEC.decode(buffer);
+                            assertFalse(decoded.overlay());
+                            delivered.add(PaperAdventure.asAdventure(decoded.content()));
+                        } finally { buffer.release(); }
+                    }
+                    return null;
+                };
+                doAnswer(capture).when(nativePlayer.connection).send(org.mockito.ArgumentMatchers.<Packet<?>>any());
+                doAnswer(capture).when(nativePlayer.connection).send(org.mockito.ArgumentMatchers.<Packet<?>>any(), any(io.netty.channel.ChannelFutureListener.class));
+                doCallRealMethod().when(player).sendMessage(any(Component.class));
+                doCallRealMethod().when(nativePlayer).sendMessage(any(Component.class));
+                doCallRealMethod().when(nativePlayer).sendSystemMessage(any(net.minecraft.network.chat.Component.class));
+                doCallRealMethod().when(nativePlayer).sendSystemMessage(any(net.minecraft.network.chat.Component.class), anyBoolean());
+                var nativeWorld = mock(net.minecraft.server.level.ServerLevel.class);
+                when(nativePlayer.level()).thenReturn(nativeWorld);
+                var rules = mock(net.minecraft.world.level.gamerules.GameRules.class);
+                when(rules.get(net.minecraft.world.level.gamerules.GameRules.SHOW_ADVANCEMENT_MESSAGES)).thenReturn(!mode.equals("rule-off"));
+                when(nativeWorld.getGameRules()).thenReturn(rules);
+                var players = mock(net.minecraft.server.players.PlayerList.class);
+                doAnswer(call -> { player.sendMessage(PaperAdventure.asAdventure(call.getArgument(0, net.minecraft.network.chat.Component.class))); return null; })
+                        .when(players).broadcastSystemMessage(any(net.minecraft.network.chat.Component.class), eq(false));
+                var advancements = mock(PlayerAdvancements.class);
+                set(advancements, "player", nativePlayer);
+                set(advancements, "playerList", players);
+                var name = Component.text("EchoOwner").hoverEvent(net.kyori.adventure.text.event.HoverEvent.showEntity(
+                        net.kyori.adventure.key.Key.key("minecraft:player"), player.getUniqueId(), Component.text("EchoOwner")));
+                when(nativePlayer.getDisplayName()).thenReturn(PaperAdventure.asVanilla(name));
+                var title = Component.text("EchoOwner's Challenge").hoverEvent(Component.text("Keep the description"));
+                var advancement = new Advancement(Optional.empty(), Optional.empty(), net.minecraft.advancements.AdvancementRewards.EMPTY,
+                        Map.of(), net.minecraft.advancements.AdvancementRequirements.EMPTY, false, Optional.of(PaperAdventure.asVanilla(title)));
+                var holder = new AdvancementHolder(net.minecraft.resources.Identifier.withDefaultNamespace("echo_regression"), advancement);
+                var original = PaperAdventure.asAdventure(type.createAnnouncement(holder, nativePlayer));
+                var event = new PlayerAdvancementDoneEvent(player, holder.toBukkit(), original);
+                if (mode.equals("silent")) { event.message(null); }
+                var method = AnnouncementListener.class.getMethod("onAdvancement", PlayerAdvancementDoneEvent.class);
+                var annotation = method.getAnnotation(EventHandler.class);
+                new RegisteredListener(listener, EventExecutor.create(method, PlayerAdvancementDoneEvent.class), annotation.priority(), plugin, annotation.ignoreCancelled()).callEvent(event);
+                var nativeDelivery = PlayerAdvancements.class.getDeclaredMethod("lambda$award$1", PlayerAdvancementDoneEvent.class, Component.class, net.minecraft.advancements.DisplayInfo.class);
+                nativeDelivery.setAccessible(true);
+                boolean previous = org.purpurmc.purpur.PurpurConfig.advancementOnlyBroadcastToAffectedPlayer;
+                try {
+                    org.purpurmc.purpur.PurpurConfig.advancementOnlyBroadcastToAffectedPlayer = onlyAffected;
+                    nativeDelivery.invoke(advancements, event, original, null);
+                } finally { org.purpurmc.purpur.PurpurConfig.advancementOnlyBroadcastToAffectedPlayer = previous; }
+                if (java.util.Set.of("silent", "rule-off", "wire-cancelled").contains(mode)) {
+                    assertTrue(delivered.isEmpty());
+                    assertTrue(warnings.isEmpty());
+                    return;
+                }
+                assertEquals(1, delivered.size());
+                var message = assertInstanceOf(TranslatableComponent.class, delivered.getFirst());
+                var alias = assertInstanceOf(Component.class, message.arguments().getFirst().value());
+                boolean eligible = !java.util.Set.of("ordinary", "reset").contains(mode);
+                assertEquals(eligible ? TextDecoration.State.TRUE : TextDecoration.State.NOT_SET, alias.decoration(TextDecoration.OBFUSCATED), "native delivery must honor current activation");
+                if (eligible) { assertNull(alias.hoverEvent()); }
+                else { assertEquals(name, alias); }
+                assertEquals(title, message.arguments().get(1).value());
+                assertTrue(warnings.isEmpty(), warnings.toString());
+            }
+        }
+    }
+
+    private static java.util.stream.Stream<org.junit.jupiter.params.provider.Arguments> cases() {
+        return java.util.Arrays.stream(AdvancementType.values()).flatMap(type -> java.util.stream.Stream.of(
+                "broadcast", "only-affected", "ordinary", "reset", "silent", "rule-off", "wire-cancelled")
+                .map(mode -> org.junit.jupiter.params.provider.Arguments.of(type, mode)));
+    }
+
+    private static void set(PlayerAdvancements target, String name, Object value) throws Exception {
+        var field = PlayerAdvancements.class.getDeclaredField(name);
+        field.setAccessible(true);
+        field.set(target, value);
+    }
+}

src/nativeTest/java/games/dmg/spigotignis/NativeEchoLifecycleTest.java

@@ -0,0 +1,229 @@
+package games.dmg.spigotignis;
+
+import static org.junit.jupiter.api.Assertions.*;
+import static org.mockito.Mockito.*;
+import java.io.IOException;
+import java.nio.file.Path;
+import java.util.List;
+import java.util.UUID;
+import java.util.concurrent.LinkedBlockingQueue;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicBoolean;
+import net.minecraft.server.level.ServerPlayer;
+import net.minecraft.world.entity.EntityEquipment;
+import net.minecraft.world.entity.player.Inventory;
+import org.bukkit.Bukkit;
+import org.bukkit.craftbukkit.CraftServer;
+import org.bukkit.craftbukkit.entity.CraftPlayer;
+import org.bukkit.craftbukkit.inventory.CraftInventoryPlayer;
+import org.bukkit.craftbukkit.scheduler.CraftScheduler;
+import org.bukkit.event.block.Action;
+import org.bukkit.event.player.PlayerInteractEvent;
+import org.bukkit.inventory.EquipmentSlot;
+import org.bukkit.plugin.java.JavaPlugin;
+import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.api.io.TempDir;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.CsvSource;
+
+class NativeEchoLifecycleTest {
+    @TempDir Path directory;
+    @BeforeAll static void bootstrap() throws Exception { NativeRuntime.bootstrap(); }
+
+    @ParameterizedTest
+    @CsvSource({"0,1", "0,3", "40,1", "40,3"})
+    void actualInventoryConsumesExactlyOneOnceAndReopensActivated(int slot, int amount) throws Exception {
+        try (var f = new Fixture(directory)) {
+            var echo = f.items.create(f.token);
+            echo.setAmount(amount);
+            f.inventory.setItem(slot, echo);
+            var use = f.use(slot);
+            f.gameplay.onUse(use);
+            f.gameplay.onUse(use);
+            f.callback();
+            assertTrue(f.gameplay.activated(f.owner));
+            assertEquals(amount - 1, f.count());
+            f.gameplay.onUse(use);
+            assertEquals(amount - 1, f.count());
+            assertFalse(EchoRewards.valid(f.states.snapshot(), f.owner, f.token));
+            try (var reopened = StateService.open(f.disk).get(5, TimeUnit.SECONDS)) {
+                assertTrue(new EchoGameplay(f.plugin, reopened, f.items).activated(f.owner));
+                assertFalse(EchoRewards.valid(reopened.snapshot(), f.owner, f.token));
+            }
+        }
+    }
+
+    @ParameterizedTest
+    @org.junit.jupiter.params.provider.ValueSource(strings = {"disconnect", "death", "disable"})
+    void interruptedCopiesRemainInertAfterReopen(String interruption) throws Exception {
+        try (var f = new Fixture(directory)) {
+            var copy = f.items.create(f.token);
+            f.inventory.setItem(0, copy);
+            f.gameplay.onUse(f.use(0));
+            var callback = f.awaitCallback();
+            assertTrue(f.gameplay.activated(f.owner));
+            if (interruption.equals("disconnect")) {
+                var quit = mock(org.bukkit.event.player.PlayerQuitEvent.class);
+                when(quit.getPlayer()).thenReturn(f.player);
+                f.gameplay.onQuit(quit);
+                when(f.server.getPlayer(f.owner)).thenReturn(null);
+                callback.run();
+                assertEquals(1, f.count());
+            } else if (interruption.equals("death")) {
+                // The world/drop boundary removes the item before the pending callback.
+                f.inventory.clear();
+                var death = mock(org.bukkit.event.entity.PlayerDeathEvent.class);
+                when(death.getEntity()).thenReturn(f.player);
+                f.gameplay.onDeath(death);
+                callback.run();
+                f.inventory.setItem(0, copy); // later pickup of the retained drop
+            } else {
+                f.enabled.set(false); // Bukkit cancels the queued callback on disable; do not execute it.
+                assertEquals(1, f.count());
+            }
+            try (var reopened = StateService.open(f.disk).get(5, TimeUnit.SECONDS)) {
+                var resumed = new EchoGameplay(f.plugin, reopened, f.items);
+                f.enabled.set(true);
+                when(f.server.getPlayer(f.owner)).thenReturn(f.player);
+                assertTrue(resumed.activated(f.owner));
+                resumed.onUse(f.use(0));
+                assertEquals(1, f.count(), "interrupted copies are inert, not consumed a second time");
+                assertFalse(EchoRewards.valid(reopened.snapshot(), f.owner, f.token));
+                assertTrue(f.callbacks.isEmpty(), "a spent receipt cannot schedule another activation");
+            }
+        }
+    }
+
+    @ParameterizedTest
+    @org.junit.jupiter.params.provider.ValueSource(strings = {"foreign", "unknown", "reset", "denied"})
+    void onlyTheCurrentOwnerReceiptCanActivateAndProtectionIsRespected(String rejection) throws Exception {
+        try (var f = new Fixture(directory)) {
+            var token = rejection.equals("unknown") ? new EchoToken(f.owner, UUID.randomUUID(), 0) : f.token;
+            var echo = f.items.create(token);
+            f.inventory.setItem(0, echo);
+            if (rejection.equals("foreign")) { when(f.player.getUniqueId()).thenReturn(UUID.randomUUID()); }
+            if (rejection.equals("reset")) {
+                f.states.update(state -> ProgressAdministration.reset(state, f.owner, java.util.Set.of(Track.VOID))).get(5, TimeUnit.SECONDS);
+                f.states.update(state -> EchoRewards.award(state, f.owner, UUID.randomUUID())).get(5, TimeUnit.SECONDS);
+            }
+            var use = f.use(0);
+            if (rejection.equals("denied")) { use.setUseItemInHand(org.bukkit.event.Event.Result.DENY); }
+            f.gameplay.onUse(use);
+            assertFalse(f.gameplay.activated(f.owner));
+            assertEquals(echo, f.inventory.getItem(0));
+            assertTrue(f.callbacks.isEmpty());
+        }
+    }
+
+    @org.junit.jupiter.api.Test
+    void failedActivationLeavesRealItemsUnconsumedAndCanBeRetried() throws Exception {
+        try (var f = new Fixture(directory)) {
+            var echo = f.items.create(f.token);
+            echo.setAmount(3);
+            f.inventory.setItem(0, echo);
+            f.failSave.set(true);
+            f.gameplay.onUse(f.use(0));
+            f.callback();
+            assertFalse(f.gameplay.activated(f.owner));
+            assertEquals(3, f.count());
+            verify(f.player).sendMessage(contains("It has not been consumed; try again"));
+            f.failSave.set(false);
+            f.gameplay.onUse(f.use(0));
+            f.callback();
+            assertTrue(f.gameplay.activated(f.owner));
+            assertEquals(2, f.count());
+        }
+    }
+
+    @org.junit.jupiter.api.Test
+    void actualFullInventoryDefersAndFailedAcknowledgementRetriesWithoutAnotherOffer() throws Exception {
+        try (var f = new Fixture(directory)) {
+            for (int slot = 0; slot < 36; slot++) {
+                f.inventory.setItem(slot, new org.bukkit.inventory.ItemStack(org.bukkit.Material.COBBLESTONE, 64));
+            }
+            f.gameplay.retryDeliveries();
+            assertEquals(0, f.count());
+            assertTrue(f.states.snapshot().players().get(f.owner).pendingRewards().containsKey(f.token.receipt()));
+            assertTrue(f.callbacks.isEmpty());
+            f.inventory.setItem(5, null);
+            f.failSave.set(true);
+            f.gameplay.retryDeliveries();
+            f.gameplay.retryDeliveries();
+            f.callback();
+            assertEquals(1, f.count());
+            assertTrue(f.states.snapshot().players().get(f.owner).pendingRewards().containsKey(f.token.receipt()));
+            f.failSave.set(false);
+            f.gameplay.retryDeliveries();
+            f.callback();
+            f.gameplay.retryDeliveries();
+            assertEquals(1, f.count());
+            assertTrue(f.states.snapshot().players().get(f.owner).pendingRewards().isEmpty());
+            try (var reopened = StateService.open(f.disk).get(5, TimeUnit.SECONDS)) {
+                assertTrue(reopened.snapshot().players().get(f.owner).pendingRewards().isEmpty());
+                assertTrue(EchoRewards.valid(reopened.snapshot(), f.owner, f.token));
+            }
+        }
+    }
+
+    private static final class Fixture implements AutoCloseable {
+        final UUID owner = UUID.randomUUID();
+        final EchoToken token = new EchoToken(owner, UUID.randomUUID(), 0);
+        final EchoItems items = new EchoItems();
+        final CraftServer server = mock(CraftServer.class);
+        final org.mockito.MockedStatic<Bukkit> platform;
+        final JavaPlugin plugin = mock(JavaPlugin.class);
+        final CraftPlayer player = mock(CraftPlayer.class);
+        final CraftInventoryPlayer inventory;
+        final LinkedBlockingQueue<Runnable> callbacks = new LinkedBlockingQueue<>();
+        final AtomicBoolean enabled = new AtomicBoolean(true), failSave = new AtomicBoolean();
+        final FileStateRepository disk;
+        final StateService states;
+        final EchoGameplay gameplay;
+        Fixture(Path directory) throws Exception {
+            platform = mockStatic(Bukkit.class, call -> switch (call.getMethod().getName()) {
+                case "getServer" -> server;
+                case "isPrimaryThread" -> true;
+                default -> call.callRealMethod();
+            });
+            var nativePlayer = mock(ServerPlayer.class);
+            when(nativePlayer.getBukkitEntity()).thenReturn(player);
+            when(player.getHandle()).thenReturn(nativePlayer);
+            inventory = new CraftInventoryPlayer(new Inventory(nativePlayer, new EntityEquipment()));
+            when(player.getInventory()).thenReturn(inventory);
+            when(player.getUniqueId()).thenReturn(owner);
+            when(plugin.getServer()).thenReturn(server);
+            when(plugin.getLogger()).thenReturn(java.util.logging.Logger.getAnonymousLogger());
+            when(plugin.isEnabled()).thenAnswer(call -> enabled.get());
+            when(server.getPlayer(owner)).thenReturn(player);
+            doReturn(List.of(player)).when(server).getOnlinePlayers();
+            var scheduler = mock(CraftScheduler.class);
+            when(server.getScheduler()).thenReturn(scheduler);
+            when(scheduler.runTask(eq(plugin), any(Runnable.class))).thenAnswer(call -> { callbacks.add(call.getArgument(1)); return null; });
+            disk = new FileStateRepository(directory.resolve("state.bin"));
+            states = StateService.open(new StateRepository() {
+                @Override public IgnisState load() throws IOException { return disk.load(); }
+                @Override public void save(IgnisState state) throws IOException {
+                    if (failSave.get()) { throw new IOException("simulated unavailable storage"); }
+                    disk.save(state);
+                }
+            }).get(5, TimeUnit.SECONDS);
+            states.update(state -> EchoRewards.award(state, owner, token.receipt())).get(5, TimeUnit.SECONDS);
+            gameplay = new EchoGameplay(plugin, states, items);
+        }
+        PlayerInteractEvent use(int slot) {
+            return new PlayerInteractEvent(player, Action.RIGHT_CLICK_AIR, inventory.getItem(slot), null,
+                    org.bukkit.block.BlockFace.SELF, slot == 40 ? EquipmentSlot.OFF_HAND : EquipmentSlot.HAND);
+        }
+        Runnable awaitCallback() throws InterruptedException {
+            var callback = callbacks.poll(5, TimeUnit.SECONDS);
+            assertNotNull(callback);
+            return callback;
+        }
+        void callback() throws InterruptedException { awaitCallback().run(); }
+        int count() {
+            return java.util.Arrays.stream(inventory.getContents()).filter(item -> items.identify(item).filter(token::equals).isPresent())
+                    .mapToInt(org.bukkit.inventory.ItemStack::getAmount).sum();
+        }
+        @Override public void close() { states.close(); platform.close(); }
+    }
+}

src/nativeTest/java/games/dmg/spigotignis/NativeRuntime.java

@@ -0,0 +1,60 @@
+package games.dmg.spigotignis;
+
+import java.util.List;
+import java.util.stream.Stream;
+import net.minecraft.SharedConstants;
+import net.minecraft.commands.Commands;
+import net.minecraft.core.HolderLookup;
+import net.minecraft.core.LayeredRegistryAccess;
+import net.minecraft.core.Registry;
+import net.minecraft.core.RegistryAccess;
+import net.minecraft.resources.Identifier;
+import net.minecraft.resources.RegistryDataLoader;
+import net.minecraft.server.Bootstrap;
+import net.minecraft.server.MinecraftServer;
+import net.minecraft.server.RegistryLayer;
+import net.minecraft.server.ReloadableServerResources;
+import net.minecraft.server.packs.PackType;
+import net.minecraft.server.packs.repository.ServerPacksSource;
+import net.minecraft.server.packs.resources.MultiPackResourceManager;
+import net.minecraft.server.permissions.LevelBasedPermissionSet;
+import net.minecraft.tags.TagLoader;
+import net.minecraft.util.Util;
+import net.minecraft.world.flag.FeatureFlags;
+import net.minecraft.world.level.DataPackConfig;
+import net.minecraft.world.level.WorldDataConfiguration;
+import org.bukkit.craftbukkit.CraftRegistry;
+
+/** Vanilla registry/tag/component bootstrap, shared in approach with the other Purpur native suites. */
+final class NativeRuntime {
+    private NativeRuntime() { }
+    private static boolean ready;
+    static synchronized void bootstrap() throws Exception {
+        if (ready) { return; }
+        SharedConstants.tryDetectVersion();
+        Bootstrap.bootStrap();
+        var flags = FeatureFlags.VANILLA_SET;
+        var packs = ServerPacksSource.createVanillaTrustedRepository();
+        MinecraftServer.configurePackRepository(packs, new WorldDataConfiguration(new DataPackConfig(
+                FeatureFlags.REGISTRY.toNames(flags).stream().map(Identifier::getPath).toList(), List.of()), flags), true, false);
+        try (var resources = new MultiPackResourceManager(PackType.SERVER_DATA, packs.openAllSelected())) {
+            LayeredRegistryAccess<RegistryLayer> layers = RegistryLayer.createRegistryAccess();
+            List<Registry.PendingTags<?>> tags = TagLoader.loadTagsForExistingRegistries(resources, layers.getLayer(RegistryLayer.STATIC));
+            List<HolderLookup.RegistryLookup<?>> lookups = TagLoader.buildUpdatedLookups(layers.getAccessForLoading(RegistryLayer.WORLDGEN), tags);
+            RegistryAccess.Frozen worldgen = RegistryDataLoader.load(resources, lookups,
+                    RegistryDataLoader.WORLDGEN_REGISTRIES, Util.backgroundExecutor()).join();
+            layers = layers.replaceFrom(RegistryLayer.WORLDGEN, worldgen);
+            RegistryAccess.Frozen dimensions = RegistryDataLoader.load(resources,
+                    Stream.concat(lookups.stream(), worldgen.listRegistries()).toList(),
+                    RegistryDataLoader.DIMENSION_REGISTRIES, Util.backgroundExecutor()).join();
+            layers = layers.replaceFrom(RegistryLayer.DIMENSIONS, dimensions);
+            Class.forName(org.bukkit.Registry.class.getName());
+            var datapack = ReloadableServerResources.loadResources(resources, layers, tags, flags,
+                    Commands.CommandSelection.DEDICATED, LevelBasedPermissionSet.ALL_PERMISSIONS,
+                    Util.backgroundExecutor(), Runnable::run).join();
+            datapack.updateComponentsAndStaticRegistryTags();
+            CraftRegistry.setMinecraftRegistry(layers.compositeAccess().freeze());
+        }
+        ready = true;
+    }
+}

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

@@ -30,6 +30,27 @@ class AdvancementMaskerTest {
         assertNull(AdvancementMasker.mask(null));
     }
 
+    @Test
+    void packetFallbackUsesOnlyAnUnambiguousPlayerIdentityInTheNameSlot() {
+        var active = java.util.UUID.randomUUID();
+        var other = java.util.UUID.randomUUID();
+        var name = Component.text("Player").hoverEvent(net.kyori.adventure.text.event.HoverEvent.showEntity(
+                net.kyori.adventure.key.Key.key("minecraft:player"), active, Component.text("Player")));
+        var ordinary = Component.text("Player").hoverEvent(net.kyori.adventure.text.event.HoverEvent.showEntity(
+                net.kyori.adventure.key.Key.key("minecraft:player"), other, Component.text("Player")));
+        var title = Component.text("Player's title").hoverEvent(name);
+        var announcement = Component.translatable("chat.type.advancement.task", name, title);
+        assertEquals(AdvancementMasker.mask(announcement), AdvancementMasker.maskIdentified(announcement, active::equals));
+        for (var candidate : java.util.List.<Component>of(
+                Component.translatable("chat.type.advancement.task", ordinary, title),
+                Component.translatable("chat.type.advancement.task", Component.text("Player"), title),
+                Component.translatable("chat.type.advancement.task", Component.empty().append(name).append(ordinary), title),
+                Component.translatable("chat.type.text", name, title),
+                Component.text("A custom Player announcement"))) {
+            assertSame(candidate, AdvancementMasker.maskIdentified(candidate, active::equals));
+        }
+    }
+
     @Test
     void replacesOnlyAdvancementNameAndPreservesAdvancementDetails() {
         var name = Component.text("RealPlayer").clickEvent(ClickEvent.suggestCommand("/msg RealPlayer "))

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

@@ -0,0 +1,23 @@
+package games.dmg.spigotignis;
+
+import static org.junit.jupiter.api.Assertions.*;
+import java.util.UUID;
+import java.util.concurrent.atomic.AtomicLong;
+import org.junit.jupiter.api.Test;
+
+class DaggerCooldownTest {
+    @Test
+    void failedAttemptStillGatesEveryCopyForTwoSecondsWithoutExtendingOnSpam() {
+        var time = new AtomicLong();
+        var cooldown = new DaggerCooldown(time::get);
+        var player = UUID.randomUUID();
+        assertTrue(cooldown.attempt(player));
+        assertFalse(cooldown.attempt(player));
+        assertTrue(cooldown.attempt(UUID.randomUUID()));
+        time.set(1_999_999_999L);
+        assertFalse(cooldown.attempt(player));
+        time.incrementAndGet();
+        assertTrue(cooldown.attempt(player));
+        assertFalse(cooldown.attempt(player));
+    }
+}

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

@@ -0,0 +1,101 @@
+package games.dmg.spigotignis;
+
+import static org.mockito.Mockito.*;
+import org.bukkit.event.inventory.CraftItemEvent;
+import org.bukkit.event.block.CrafterCraftEvent;
+import org.bukkit.inventory.CraftingInventory;
+import org.bukkit.inventory.ShapedRecipe;
+import org.junit.jupiter.api.Test;
+
+class DaggerCraftingTest {
+    @org.junit.jupiter.api.io.TempDir java.nio.file.Path directory;
+    @Test
+    void discoversUnlockedRecipeIssuesSeparateCraftReceiptAndAcknowledgesDeliveredGift() throws Exception {
+        var plugin = mock(org.bukkit.plugin.java.JavaPlugin.class);
+        var server = mock(org.bukkit.Server.class);
+        when(plugin.getServer()).thenReturn(server);
+        var player = mock(org.bukkit.entity.Player.class);
+        var id = java.util.UUID.randomUUID();
+        when(player.getUniqueId()).thenReturn(id);
+        doReturn(java.util.List.of(player)).when(server).getOnlinePlayers();
+        var recipe = mock(ShapedRecipe.class);
+        when(server.addRecipe(recipe)).thenReturn(true);
+        var items = mock(DaggerItems.class);
+        var gift = java.util.UUID.randomUUID();
+        when(items.offer(player, new ItemToken(id, gift, 0))).thenReturn(true);
+        var dispatch = mock(EchoGameplay.class);
+        try (var states = StateService.open(new FileStateRepository(directory.resolve("state.bin"))).get()) {
+            var rewards = new TradableRewards(Track.DAGGER);
+            states.update(state -> rewards.issue(state, id, gift, true)).get();
+            var crafting = new DaggerCrafting(plugin, states, items, dispatch, ignored -> recipe);
+            crafting.run();
+            states.update(state -> state).get();
+            verify(server).addRecipe(recipe);
+            verify(player).discoverRecipe(DaggerCrafting.RECIPE);
+            org.junit.jupiter.api.Assertions.assertTrue(states.snapshot().players().get(id).pendingRewards().isEmpty());
+            org.junit.jupiter.api.Assertions.assertEquals(2, states.snapshot().players().get(id).issuedRewards().size());
+        }
+    }
+
+    @Test
+    void previewRequiresDurablePersonalReceiptAndResetRevokesIt() throws Exception {
+        var id = java.util.UUID.randomUUID();
+        var receipt = java.util.UUID.randomUUID();
+        var recipe = mock(ShapedRecipe.class);
+        when(recipe.getKey()).thenReturn(DaggerCrafting.RECIPE);
+        var inventory = mock(CraftingInventory.class);
+        when(inventory.getRecipe()).thenReturn(recipe);
+        when(inventory.getResult()).thenReturn(mock(org.bukkit.inventory.ItemStack.class));
+        var player = mock(org.bukkit.entity.Player.class);
+        when(player.getUniqueId()).thenReturn(id);
+        var view = mock(org.bukkit.inventory.InventoryView.class);
+        when(view.getPlayer()).thenReturn(player);
+        var event = mock(org.bukkit.event.inventory.PrepareItemCraftEvent.class);
+        when(event.getInventory()).thenReturn(inventory);
+        when(event.getView()).thenReturn(view);
+        var items = mock(DaggerItems.class);
+        var product = mock(org.bukkit.inventory.ItemStack.class);
+        when(items.create(new ItemToken(id, receipt, 0))).thenReturn(product);
+        try (var states = StateService.open(new FileStateRepository(directory.resolve("state.bin"))).get()) {
+            var rewards = new TradableRewards(Track.DAGGER);
+            states.update(state -> rewards.issue(ProgressAdministration.progress(state, id, Track.DAGGER, 313, false), id, receipt, false)).get();
+            var crafting = new DaggerCrafting(null, states, items, null);
+            crafting.onPrepare(event);
+            verify(inventory).setResult(product);
+            states.update(state -> ProgressAdministration.reset(state, id, java.util.Set.of(Track.DAGGER))).get();
+            crafting.onPrepare(event);
+            verify(inventory).setResult(null);
+        }
+    }
+
+    @Test
+    void retainsExactExpensiveRecipeWithoutIngredientSubstitutions() {
+        var recipe = mock(ShapedRecipe.class);
+        DaggerCrafting.configureRecipe(recipe);
+        verify(recipe).shape("HCH", "NKN", "HEH");
+        verify(recipe).setIngredient('H', org.bukkit.Material.HEART_OF_THE_SEA);
+        verify(recipe).setIngredient('C', org.bukkit.Material.HEAVY_CORE);
+        verify(recipe).setIngredient('N', org.bukkit.Material.NETHER_STAR);
+        verify(recipe).setIngredient('K', org.bukkit.Material.OMINOUS_TRIAL_KEY);
+        verify(recipe).setIngredient('E', org.bukkit.Material.DRAGON_EGG);
+    }
+
+    @Test
+    void unauthenticatedOutputsAndAutomatedCraftersCannotConsumeIngredients() {
+        var recipe = mock(ShapedRecipe.class);
+        when(recipe.getKey()).thenReturn(DaggerCrafting.RECIPE);
+        var inventory = mock(CraftingInventory.class);
+        var craft = mock(CraftItemEvent.class);
+        when(craft.getRecipe()).thenReturn(recipe);
+        when(craft.getInventory()).thenReturn(inventory);
+        var automatic = mock(CrafterCraftEvent.class);
+        when(automatic.getRecipe()).thenReturn(recipe);
+        var crafting = new DaggerCrafting(null, null, new DaggerItems(), null);
+        crafting.onCraft(craft);
+        crafting.onCrafter(automatic);
+        verify(craft).setCancelled(true);
+        verify(inventory).setResult(null);
+        verify(inventory, never()).setMatrix(any());
+        verify(automatic).setCancelled(true);
+    }
+}

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

@@ -0,0 +1,77 @@
+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.NamespacedKey;
+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 DaggerItemsTest {
+    @Test
+    void fullInventoryDefersGiftAndExistingCursorReceiptPreventsDuplicateDelivery() {
+        var player = mock(org.bukkit.entity.Player.class);
+        var inventory = mock(org.bukkit.inventory.PlayerInventory.class);
+        when(player.getInventory()).thenReturn(inventory);
+        when(inventory.getContents()).thenReturn(new ItemStack[0]);
+        when(inventory.firstEmpty()).thenReturn(-1);
+        var item = mock(ItemStack.class);
+        var meta = mock(ItemMeta.class);
+        var tags = mock(PersistentDataContainer.class);
+        when(item.getItemMeta()).thenReturn(meta);
+        when(meta.getPersistentDataContainer()).thenReturn(tags);
+        var token = new ItemToken(UUID.randomUUID(), UUID.randomUUID(), 0);
+        var items = new DaggerItems(() -> item);
+        assertFalse(items.offer(player, token));
+        when(inventory.firstEmpty()).thenReturn(0);
+        when(inventory.addItem(item)).thenReturn(new java.util.HashMap<>());
+        assertTrue(items.offer(player, token));
+        when(item.getType()).thenReturn(Material.OMINOUS_TRIAL_KEY);
+        when(item.hasItemMeta()).thenReturn(true);
+        when(tags.get(new NamespacedKey("spigotignis", "dagger_identity"), PersistentDataType.STRING))
+                .thenReturn(EchoIdentity.encode(new EchoToken(token.issuer(), token.receipt(), 0)));
+        when(player.getItemOnCursor()).thenReturn(item);
+        when(inventory.firstEmpty()).thenReturn(-1);
+        assertTrue(items.offer(player, token));
+        verify(inventory, times(1)).addItem(item);
+    }
+
+    @Test
+    void createsNamedAuthenticatedReusableKey() {
+        var item = mock(ItemStack.class);
+        var meta = mock(ItemMeta.class);
+        var tags = mock(PersistentDataContainer.class);
+        when(item.getItemMeta()).thenReturn(meta);
+        when(meta.getPersistentDataContainer()).thenReturn(tags);
+        var token = new ItemToken(UUID.randomUUID(), UUID.randomUUID(), 4);
+        var items = new DaggerItems(() -> item);
+        assertSame(item, items.create(token));
+        verify(meta).displayName(net.kyori.adventure.text.Component.text("The Dagger", net.kyori.adventure.text.format.NamedTextColor.DARK_PURPLE));
+        verify(tags).set(new NamespacedKey("spigotignis", "dagger_identity"), PersistentDataType.STRING,
+                EchoIdentity.encode(new EchoToken(token.issuer(), token.receipt(), token.generation())));
+        verify(item, never()).setAmount(0);
+    }
+
+    @Test
+    void onlyOminousKeysWithDaggerIdentityParseAsDaggerItems() {
+        var items = new DaggerItems();
+        var item = mock(ItemStack.class);
+        var meta = mock(ItemMeta.class);
+        var tags = mock(PersistentDataContainer.class);
+        when(item.getType()).thenReturn(Material.OMINOUS_TRIAL_KEY);
+        when(item.hasItemMeta()).thenReturn(true);
+        when(item.getItemMeta()).thenReturn(meta);
+        when(meta.getPersistentDataContainer()).thenReturn(tags);
+        assertTrue(items.identify(item).isEmpty());
+        UUID issuer = UUID.randomUUID(), receipt = UUID.randomUUID();
+        when(tags.get(new NamespacedKey("spigotignis", "dagger_identity"), PersistentDataType.STRING))
+                .thenReturn(EchoIdentity.encode(new EchoToken(issuer, receipt, 3)));
+        assertEquals(new ItemToken(issuer, receipt, 3), items.identify(item).orElseThrow());
+        when(item.getType()).thenReturn(Material.TRIAL_KEY);
+        assertTrue(items.identify(item).isEmpty());
+    }
+}

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

@@ -0,0 +1,67 @@
+package games.dmg.spigotignis;
+
+import static org.junit.jupiter.api.Assertions.*;
+import static org.mockito.Mockito.*;
+import org.bukkit.Location;
+import org.bukkit.Material;
+import org.bukkit.World;
+import org.bukkit.WorldBorder;
+import org.bukkit.block.Block;
+import org.bukkit.entity.Player;
+import org.bukkit.util.BoundingBox;
+import org.bukkit.util.VoxelShape;
+import org.junit.jupiter.api.Test;
+
+class DaggerSafetyTest {
+    @Test
+    void requiresClearLoadedSupportedInBorderDestinationWithoutMutatingPlayerBounds() {
+        var world = mock(World.class);
+        var border = mock(WorldBorder.class);
+        when(world.getWorldBorder()).thenReturn(border);
+        when(border.isInside(any())).thenReturn(true);
+        when(world.getMinHeight()).thenReturn(-64);
+        when(world.getMaxHeight()).thenReturn(320);
+        when(world.isChunkLoaded(anyInt(), anyInt())).thenReturn(true);
+        var air = mock(Block.class);
+        var shape = mock(VoxelShape.class);
+        when(air.getType()).thenReturn(Material.AIR);
+        when(air.getCollisionShape()).thenReturn(shape);
+        when(shape.getBoundingBoxes()).thenReturn(java.util.List.of());
+        when(world.getBlockAt(anyInt(), anyInt(), anyInt())).thenReturn(air);
+        var player = mock(Player.class);
+        var body = new BoundingBox(-.3, 64, -.3, .3, 65.8, .3);
+        when(player.getWorld()).thenReturn(world);
+        when(player.getLocation()).thenReturn(new Location(world, 0, 64, 0));
+        when(player.getBoundingBox()).thenReturn(body);
+        when(player.wouldCollideUsing(any())).thenReturn(true); // Supporting floor beneath candidate.
+        var destination = new Location(world, 0, 64, 3);
+        assertTrue(DaggerSafety.safe(player, destination));
+        var protruding = mock(Block.class);
+        var protrudingShape = mock(VoxelShape.class);
+        when(protruding.getType()).thenReturn(Material.STONE);
+        when(protruding.getCollisionShape()).thenReturn(protrudingShape);
+        when(protrudingShape.getBoundingBoxes()).thenReturn(java.util.List.of(new BoundingBox(-1, 0, 0, 0, 1, 1)));
+        when(world.getBlockAt(1, 64, 0)).thenReturn(protruding);
+        assertFalse(DaggerSafety.safe(player, destination), "Neighbor collision shapes can protrude outside their block cell");
+        when(world.getBlockAt(1, 64, 0)).thenReturn(air);
+        assertEquals(new BoundingBox(-.3, 64, -.3, .3, 65.8, .3), body);
+        when(player.wouldCollideUsing(any())).thenReturn(false);
+        assertFalse(DaggerSafety.safe(player, destination));
+        when(player.wouldCollideUsing(any())).thenReturn(true);
+        when(air.getType()).thenReturn(Material.LAVA);
+        assertFalse(DaggerSafety.safe(player, destination));
+        when(air.getType()).thenReturn(Material.AIR);
+        when(shape.getBoundingBoxes()).thenReturn(java.util.List.of(new BoundingBox(0, 0, 0, 1, 1, 1)));
+        assertFalse(DaggerSafety.safe(player, destination));
+        when(shape.getBoundingBoxes()).thenReturn(java.util.List.of());
+        when(world.isChunkLoaded(anyInt(), anyInt())).thenReturn(false);
+        clearInvocations(world);
+        assertFalse(DaggerSafety.safe(player, destination));
+        verify(world, never()).getBlockAt(anyInt(), anyInt(), anyInt());
+        when(world.isChunkLoaded(anyInt(), anyInt())).thenReturn(true);
+        when(border.isInside(any())).thenReturn(false);
+        assertFalse(DaggerSafety.safe(player, destination));
+        assertFalse(DaggerSafety.safe(player, new Location(world, Double.NaN, 64, 0)));
+        assertFalse(DaggerSafety.safe(player, new Location(world, 0, 320, 0)));
+    }
+}

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

@@ -0,0 +1,19 @@
+package games.dmg.spigotignis;
+
+import static org.junit.jupiter.api.Assertions.*;
+import org.bukkit.util.BoundingBox;
+import org.bukkit.util.Vector;
+import org.junit.jupiter.api.Test;
+
+class DaggerSweepTest {
+    @Test
+    void continuousSweepCatchesThinWallsButNotFloorContactOrOffPathObstacles() {
+        var body = new BoundingBox(-.3, 0, -.3, .3, 1.8, .3);
+        assertTrue(DaggerSweep.hits(body, new Vector(3, 0, 0), new BoundingBox(1.01, 0, -1, 1.02, 3, 1)));
+        assertTrue(DaggerSweep.hits(body, new Vector(3, 0, 0), new BoundingBox(3, 0, -1, 4, 3, 1)));
+        assertFalse(DaggerSweep.hits(body, new Vector(3, 0, 0), new BoundingBox(-1, -1, -1, 5, 0, 1)));
+        assertFalse(DaggerSweep.hits(body, new Vector(3, 0, 3), new BoundingBox(0, 0, 2, .5, 2, 3)));
+        assertTrue(DaggerSweep.hits(body, new Vector(), new BoundingBox(0, 0, 0, 1, 1, 1)));
+        assertEquals(new BoundingBox(-.3, 0, -.3, .3, 1.8, .3), body);
+    }
+}

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

@@ -0,0 +1,46 @@
+package games.dmg.spigotignis;
+
+import static org.junit.jupiter.api.Assertions.*;
+import java.util.List;
+import java.util.UUID;
+import org.bukkit.util.Vector;
+import org.junit.jupiter.api.Test;
+
+class DaggerTargetingTest {
+    @Test
+    void forwardIsThreeBlocksAlongAimAndBehindIsHorizontalRelativeToTargetYaw() {
+        var feet = new Vector(10, 64, 10);
+        assertEquals(new Vector(10, 64, 13), DaggerTargeting.forward(feet, new Vector(0, 0, 2)));
+        assertEquals(new Vector(10, 67, 10), DaggerTargeting.forward(feet, new Vector(0, 1, 0)));
+        assertEquals(new Vector(10, 64, 8.5), DaggerTargeting.behind(feet, 0));
+        assertEquals(11.5, DaggerTargeting.behind(feet, 90).getX(), 1e-10);
+        assertEquals(64, DaggerTargeting.behind(feet, 90).getY());
+        assertEquals(new Vector(10, 64, 10), feet);
+    }
+
+    @Test
+    void tiesUseUuidRatherThanIterationOrderAndInvalidAimHasNoTarget() {
+        var first = new DaggerTargeting.Target(new UUID(0, 1), new Vector(0, 0, 2), true);
+        var second = new DaggerTargeting.Target(new UUID(0, 2), new Vector(0, 0, 4), true);
+        assertEquals(first, DaggerTargeting.select(new Vector(), new Vector(0, 0, 1), List.of(second, first)).orElseThrow());
+        assertEquals(first, DaggerTargeting.select(new Vector(), new Vector(0, 0, 1), List.of(first, second)).orElseThrow());
+        assertTrue(DaggerTargeting.select(new Vector(), new Vector(), List.of(first)).isEmpty());
+        assertTrue(DaggerTargeting.select(new Vector(), new Vector(Double.NaN, 0, 1), List.of(first)).isEmpty());
+    }
+
+    @Test
+    void selectsClosestCrosshairVisiblePlayerInsideEightBlockThreeDimensionalCone() {
+        var centered = new DaggerTargeting.Target(new UUID(0, 2), new Vector(0, 0, 8), true);
+        var nearButOffCenter = new DaggerTargeting.Target(new UUID(0, 1), new Vector(.4, 0, 2), true);
+        var blocked = new DaggerTargeting.Target(new UUID(0, 0), new Vector(0, 0, 1), false);
+        var outsideRange = new DaggerTargeting.Target(new UUID(0, 0), new Vector(0, 0, 8.01), true);
+        var outsideCone = new DaggerTargeting.Target(new UUID(0, 0), new Vector(0, 2, 2), true);
+        var behind = new DaggerTargeting.Target(new UUID(0, 0), new Vector(0, 0, -1), true);
+        var origin = new Vector();
+        var direction = new Vector(0, 0, 3);
+        assertEquals(centered, DaggerTargeting.select(origin, direction,
+                List.of(blocked, outsideRange, outsideCone, behind, nearButOffCenter, centered)).orElseThrow());
+        assertTrue(DaggerTargeting.select(origin, direction, List.of(blocked, outsideRange, outsideCone, behind)).isEmpty());
+        assertEquals(new Vector(0, 0, 3), direction, "Caller vectors must not be mutated");
+    }
+}

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

@@ -0,0 +1,106 @@
+package games.dmg.spigotignis;
+
+import static org.junit.jupiter.api.Assertions.*;
+import static org.mockito.Mockito.*;
+import java.util.UUID;
+import java.util.concurrent.atomic.AtomicLong;
+import java.util.concurrent.atomic.AtomicReference;
+import org.bukkit.Location;
+import org.bukkit.World;
+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.event.player.PlayerTeleportEvent.TeleportCause;
+import org.bukkit.inventory.ItemStack;
+import org.junit.jupiter.api.Test;
+
+class DaggerUseTest {
+    @Test
+    void visibleTargetUsesBehindDestinationWithoutUnsafeFallbackAndHonorsItemVetoes() {
+        var player = mock(Player.class);
+        var target = mock(Player.class);
+        var id = UUID.randomUUID();
+        var receipt = UUID.randomUUID();
+        when(player.getUniqueId()).thenReturn(id);
+        when(target.getUniqueId()).thenReturn(UUID.randomUUID());
+        when(player.isOnline()).thenReturn(true);
+        when(target.isOnline()).thenReturn(true);
+        when(player.canSee(target)).thenReturn(true);
+        when(player.hasLineOfSight(target)).thenReturn(true);
+        var world = mock(World.class);
+        when(world.getPlayers()).thenReturn(java.util.List.of(player, target));
+        when(world.isChunkLoaded(anyInt(), anyInt())).thenReturn(true);
+        when(player.getWorld()).thenReturn(world);
+        when(player.getLocation()).thenReturn(new Location(world, 0, 64, 0));
+        when(player.getEyeLocation()).thenReturn(new Location(world, 0, 65.62, 0));
+        when(target.getLocation()).thenReturn(new Location(world, 0, 64, 5));
+        when(target.getEyeLocation()).thenReturn(new Location(world, 0, 65.62, 5));
+        var item = mock(ItemStack.class);
+        var items = mock(DaggerItems.class);
+        when(items.identify(item)).thenReturn(java.util.Optional.of(new ItemToken(id, receipt, 0)));
+        var state = new TradableRewards(Track.DAGGER).issue(IgnisState.empty(), id, receipt, true);
+        var checked = new AtomicReference<Location>();
+        var allowed = new java.util.concurrent.atomic.AtomicBoolean(false);
+        var clock = new AtomicLong();
+        var use = new DaggerUse(() -> state, items, new DaggerCooldown(clock::get), (actor, destination) -> {
+            checked.set(destination); return allowed.get();
+        });
+        var event = mock(PlayerInteractEvent.class);
+        when(event.getPlayer()).thenReturn(player);
+        when(event.getItem()).thenReturn(item);
+        when(event.getAction()).thenReturn(Action.RIGHT_CLICK_AIR);
+        when(event.useItemInHand()).thenReturn(Event.Result.DENY);
+        use.onUse(event);
+        assertNull(checked.get());
+        when(event.useItemInHand()).thenReturn(Event.Result.DEFAULT);
+        use.onUse(event);
+        assertEquals(new Location(world, 0, 64, 3.5), checked.get());
+        verify(player, never()).teleport(any(Location.class), any(TeleportCause.class));
+        allowed.set(true);
+        clock.set(2_000_000_000L);
+        when(target.isInvisible()).thenReturn(true);
+        use.onUse(event);
+        verify(player).teleport(new Location(world, 0, 64, 3), TeleportCause.PLUGIN);
+        when(target.isInvisible()).thenReturn(false);
+        when(world.isChunkLoaded(anyInt(), anyInt())).thenReturn(false);
+        clock.set(4_000_000_000L);
+        clearInvocations(player);
+        use.onUse(event);
+        verify(player, never()).hasLineOfSight(target);
+    }
+
+    @Test
+    void rightClickAirUsesPluginTeleportRetainsItemAndKeepsCooldownOnCancellation() {
+        var player = mock(Player.class);
+        UUID id = UUID.randomUUID(), receipt = UUID.randomUUID();
+        when(player.getUniqueId()).thenReturn(id);
+        when(player.isOnline()).thenReturn(true);
+        var world = mock(World.class);
+        when(player.getWorld()).thenReturn(world);
+        when(player.getLocation()).thenReturn(new Location(world, 0, 64, 0));
+        when(player.getEyeLocation()).thenReturn(new Location(world, 0, 65.62, 0));
+        var item = mock(ItemStack.class);
+        var items = mock(DaggerItems.class);
+        when(items.identify(item)).thenReturn(java.util.Optional.of(new ItemToken(id, receipt, 0)));
+        var state = new AtomicReference<>(new TradableRewards(Track.DAGGER).issue(IgnisState.empty(), id, receipt, true));
+        var time = new AtomicLong();
+        var use = new DaggerUse(state::get, items, new DaggerCooldown(time::get), (actor, destination) -> true);
+        var event = mock(PlayerInteractEvent.class);
+        when(event.getPlayer()).thenReturn(player);
+        when(event.getItem()).thenReturn(item);
+        when(event.getAction()).thenReturn(Action.RIGHT_CLICK_AIR);
+        when(event.useItemInHand()).thenReturn(Event.Result.DEFAULT);
+        when(event.useInteractedBlock()).thenReturn(Event.Result.DENY); // Default air interaction, not an item veto.
+        use.onUse(event); use.onUse(event);
+        verify(player, times(1)).teleport(new Location(world, 0, 64, 3), TeleportCause.PLUGIN);
+        verify(event, atLeastOnce()).setUseItemInHand(Event.Result.DENY);
+        verify(event, atLeastOnce()).setUseInteractedBlock(Event.Result.DENY);
+        verify(item, never()).setAmount(anyInt());
+        time.set(2_000_000_000L);
+        state.set(ProgressAdministration.reset(state.get(), id, java.util.Set.of(Track.DAGGER)));
+        use.onUse(event);
+        verify(player, times(1)).teleport(any(Location.class), eq(TeleportCause.PLUGIN));
+        assertFalse(state.get().players().get(id).track(Track.DAGGER).unlocked());
+    }
+}

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

@@ -0,0 +1,32 @@
+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 DarknessAdministrationTest {
+    @TempDir Path directory;
+    @Test
+    void editsFlushElapsedProgressAndRebaseRatherThanReplayingTheOldInterval() throws Exception {
+        for (boolean add : new boolean[]{false, true}) {
+            try (var states = StateService.open(new FileStateRepository(directory.resolve(add + ".bin"))).get()) {
+                var clock = new AtomicLong();
+                var tracker = new DarknessProgress(states, clock::get);
+                var id = UUID.randomUUID();
+                tracker.observe(id, true);
+                clock.set(100_000_000L);
+                tracker.observe(id, true);
+                tracker.edit(id, 500, add).get();
+                tracker.observe(id, true);
+                tracker.checkpoint(id).get();
+                assertEquals(add ? 600 : 500, states.snapshot().players().get(id).track(Track.HEART).progress());
+                tracker.interrupt(id);
+                tracker.checkpoint(id).get();
+                assertEquals(0, states.snapshot().players().get(id).track(Track.HEART).progress());
+            }
+        }
+    }
+}

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

@@ -0,0 +1,74 @@
+package games.dmg.spigotignis;
+
+import static org.junit.jupiter.api.Assertions.*;
+import java.util.UUID;
+import java.util.concurrent.atomic.AtomicInteger;
+import java.util.concurrent.atomic.AtomicLong;
+import org.junit.jupiter.api.Test;
+
+class DarknessBatchTest {
+    @Test
+    void periodicCallsCoalesceButShutdownQueuesFreshInterruptionsBehindAnInflightSave() throws Exception {
+        var started = new java.util.concurrent.CountDownLatch(1);
+        var release = new java.util.concurrent.CountDownLatch(1);
+        var writes = new AtomicInteger();
+        var repository = new StateRepository() {
+            @Override public IgnisState load() { return IgnisState.empty(); }
+            @Override public void save(IgnisState state) throws java.io.IOException {
+                if (writes.incrementAndGet() == 1) {
+                    started.countDown();
+                    try {
+                        if (!release.await(3, java.util.concurrent.TimeUnit.SECONDS)) throw new java.io.IOException("fixture timeout");
+                    } catch (InterruptedException error) {
+                        Thread.currentThread().interrupt();
+                        throw new java.io.IOException(error);
+                    }
+                }
+            }
+        };
+        try (var states = StateService.open(repository).get()) {
+            var clock = new AtomicLong();
+            var tracker = new DarknessProgress(states, clock::get);
+            var id = UUID.randomUUID();
+            tracker.observe(id, true);
+            clock.set(100_000_000L);
+            tracker.observe(id, true);
+            var first = tracker.checkpointAll();
+            try {
+                assertTrue(started.await(3, java.util.concurrent.TimeUnit.SECONDS));
+                clock.set(200_000_000L);
+                tracker.observe(id, true);
+                assertSame(first, tracker.checkpointAll());
+                var stopping = tracker.stopAll();
+                assertNotSame(first, stopping);
+                release.countDown();
+                stopping.get();
+                assertEquals(2, writes.get());
+                assertEquals(0, states.snapshot().players().get(id).track(Track.HEART).progress());
+            } finally { release.countDown(); }
+        }
+    }
+
+    @Test
+    void checkpointsAndShutdownUseOneWriteForAllRememberedPlayers() throws Exception {
+        var writes = new AtomicInteger();
+        var repository = new StateRepository() {
+            @Override public IgnisState load() { return IgnisState.empty(); }
+            @Override public void save(IgnisState state) { writes.incrementAndGet(); }
+        };
+        try (var states = StateService.open(repository).get()) {
+            var clock = new AtomicLong();
+            var tracker = new DarknessProgress(states, clock::get);
+            var players = java.util.stream.IntStream.range(0, 20).mapToObj(ignored -> UUID.randomUUID()).toList();
+            players.forEach(id -> tracker.observe(id, true));
+            clock.set(100_000_000L);
+            players.forEach(id -> tracker.observe(id, true));
+            tracker.checkpointAll().get();
+            assertEquals(1, writes.get());
+            for (var id : players) assertEquals(100, states.snapshot().players().get(id).track(Track.HEART).progress());
+            tracker.stopAll().get();
+            assertEquals(2, writes.get());
+            for (var id : players) assertEquals(0, states.snapshot().players().get(id).track(Track.HEART).progress());
+        }
+    }
+}

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

@@ -0,0 +1,105 @@
+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 DarknessProgressTest {
+    @TempDir Path directory;
+    @Test
+    void shutdownClearsUnfinishedStreakAndFailedResetRemainsRetryable() throws Exception {
+        var disk = new FileStateRepository(directory.resolve("shutdown.bin"));
+        var fail = new java.util.concurrent.atomic.AtomicBoolean(false);
+        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 storage failure");
+                disk.save(state);
+            }
+        };
+        var clock = new AtomicLong();
+        var id = UUID.randomUUID();
+        try (var states = StateService.open(boundary).get()) {
+            var tracker = new DarknessProgress(states, clock::get);
+            tracker.observe(id, true);
+            clock.set(500_000_000L);
+            tracker.observe(id, true);
+            tracker.checkpoint(id).get();
+            fail.set(true);
+            assertThrows(java.util.concurrent.ExecutionException.class, () -> tracker.stopAll().get());
+            assertEquals(500, states.snapshot().players().get(id).track(Track.HEART).progress());
+            fail.set(false);
+            tracker.checkpointAll().get();
+            assertEquals(0, states.snapshot().players().get(id).track(Track.HEART).progress());
+            clock.set(10_000_000_000L);
+            tracker.observe(id, true);
+            tracker.checkpointAll().get();
+            assertEquals(0, states.snapshot().players().get(id).track(Track.HEART).progress());
+        }
+    }
+
+    @Test
+    void queuedOldIntervalCannotRestoreProgressAfterInterruptionOrAdministratorReset() throws Exception {
+        for (boolean adminReset : new boolean[]{false, true}) {
+            var clock = new AtomicLong();
+            var entered = new java.util.concurrent.CountDownLatch(1);
+            var release = new java.util.concurrent.CountDownLatch(1);
+            var id = UUID.randomUUID();
+            try (var states = StateService.open(new FileStateRepository(directory.resolve(adminReset + ".bin"))).get()) {
+                var tracker = new DarknessProgress(states, clock::get);
+                tracker.observe(id, true);
+                clock.set(500_000_000L);
+                tracker.observe(id, true);
+                var blocker = states.update(state -> {
+                    entered.countDown();
+                    try { if (!release.await(5, java.util.concurrent.TimeUnit.SECONDS)) throw new IllegalStateException("Timed out"); }
+                    catch (InterruptedException error) { Thread.currentThread().interrupt(); throw new IllegalStateException(error); }
+                    return state;
+                });
+                try {
+                    assertTrue(entered.await(2, java.util.concurrent.TimeUnit.SECONDS));
+                    if (adminReset) states.update(state -> ProgressAdministration.reset(state, id, java.util.Set.of(Track.HEART)));
+                    var stale = tracker.checkpoint(id);
+                    if (!adminReset) tracker.interrupt(id);
+                    release.countDown();
+                    blocker.get(); stale.get();
+                    assertEquals(0, states.snapshot().players().getOrDefault(id, PlayerState.empty()).track(Track.HEART).progress());
+                    tracker.observe(id, true);
+                    clock.addAndGet(200_000_000L);
+                    tracker.observe(id, true);
+                    tracker.checkpoint(id).get();
+                    assertEquals(200, states.snapshot().players().get(id).track(Track.HEART).progress());
+                } finally { release.countDown(); }
+            }
+        }
+    }
+
+    @Test
+    void savesContinuousProgressResetsInterruptionsAndRetainsCompletedUnlock() throws Exception {
+        var clock = new AtomicLong();
+        UUID id = UUID.randomUUID();
+        try (var states = StateService.open(new FileStateRepository(directory.resolve("state.bin"))).get()) {
+            states.configure(1000, 313, 1000).get();
+            var tracker = new DarknessProgress(states, clock::get);
+            tracker.observe(id, true);
+            clock.set(500_000_000L);
+            tracker.observe(id, true);
+            tracker.checkpoint(id).get();
+            assertEquals(500, states.snapshot().players().getOrDefault(id, PlayerState.empty()).track(Track.HEART).progress());
+            tracker.interrupt(id);
+            tracker.checkpoint(id).get();
+            assertEquals(0, states.snapshot().players().get(id).track(Track.HEART).progress());
+            tracker.observe(id, true);
+            clock.addAndGet(1_000_000_000L);
+            tracker.observe(id, true);
+            tracker.checkpoint(id).get();
+            assertTrue(states.snapshot().players().get(id).track(Track.HEART).unlocked());
+            tracker.interrupt(id);
+            tracker.checkpoint(id).get();
+            assertTrue(states.snapshot().players().get(id).track(Track.HEART).unlocked());
+        }
+    }
+}

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

@@ -0,0 +1,37 @@
+package games.dmg.spigotignis;
+
+import static org.junit.jupiter.api.Assertions.*;
+import java.util.concurrent.atomic.AtomicLong;
+import org.junit.jupiter.api.Test;
+
+class DarknessStreakTest {
+    @Test
+    void administratorSeedCountsOnlyUntilAnUnfinishedStreakIsInterrupted() {
+        var time = new AtomicLong();
+        var streak = new DarknessStreak(time::get, 500);
+        assertEquals(500, streak.sample(true, 1000).millis());
+        time.set(200_000_000L);
+        assertEquals(700, streak.sample(true, 1000).millis());
+        assertEquals(0, streak.interrupt().millis());
+        time.set(900_000_000L);
+        assertEquals(0, streak.sample(true, 1000).millis());
+        assertThrows(IllegalArgumentException.class, () -> new DarknessStreak(time::get, -1));
+    }
+
+    @Test
+    void requiresOneUninterruptedSixHourStreakAndRetainsCompletedUnlock() {
+        long hour = 3_600_000;
+        var time = new AtomicLong();
+        var streak = new DarknessStreak(time::get);
+        assertEquals(new DarknessStreak.Progress(0, false), streak.sample(true, 6 * hour));
+        time.set(3 * hour * 1_000_000);
+        assertEquals(new DarknessStreak.Progress(3 * hour, false), streak.sample(true, 6 * hour));
+        assertEquals(new DarknessStreak.Progress(0, false), streak.sample(false, 6 * hour));
+        time.set(10 * hour * 1_000_000); // Time outside qualifying darkness earns nothing.
+        assertEquals(new DarknessStreak.Progress(0, false), streak.sample(true, 6 * hour));
+        time.set(16 * hour * 1_000_000);
+        assertEquals(new DarknessStreak.Progress(6 * hour, true), streak.sample(true, 6 * hour));
+        assertEquals(new DarknessStreak.Progress(6 * hour, true), streak.interrupt());
+        assertTrue(streak.sample(false, 12 * hour).complete(), "Higher thresholds do not revoke completion");
+    }
+}

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

@@ -0,0 +1,92 @@
+package games.dmg.spigotignis;
+
+import static org.junit.jupiter.api.Assertions.*;
+import static org.mockito.Mockito.*;
+import java.io.IOException;
+import java.util.UUID;
+import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicBoolean;
+import org.bukkit.Location;
+import org.bukkit.Material;
+import org.bukkit.Server;
+import org.bukkit.World;
+import org.bukkit.block.Block;
+import org.bukkit.entity.Player;
+import org.bukkit.event.entity.EntityDamageEvent;
+import org.bukkit.event.player.PlayerMoveEvent;
+import org.bukkit.plugin.java.JavaPlugin;
+
+class EchoRewardFailureTest {
+    @org.junit.jupiter.params.ParameterizedTest
+    @org.junit.jupiter.params.provider.ValueSource(strings = {"online", "offline", "disabled", "scheduler-rejected"})
+    void failedEarnedRewardReportsRecoveryEvenWithoutPlayerCallback(String mode) throws Exception {
+        var entered = new CountDownLatch(1);
+        var release = new CountDownLatch(1);
+        var repository = new StateRepository() {
+            @Override public IgnisState load() { return IgnisState.empty(); }
+            @Override public void save(IgnisState state) throws IOException {
+                entered.countDown();
+                try { if (!release.await(5, TimeUnit.SECONDS)) { throw new IOException("test barrier timeout"); } }
+                catch (InterruptedException failure) { Thread.currentThread().interrupt(); throw new IOException(failure); }
+                throw new IOException("simulated unavailable storage");
+            }
+        };
+        var enabled = new AtomicBoolean(true);
+        var plugin = mock(JavaPlugin.class);
+        when(plugin.isEnabled()).thenAnswer(call -> enabled.get());
+        var server = mock(Server.class);
+        when(plugin.getServer()).thenReturn(server);
+        var logger = mock(java.util.logging.Logger.class);
+        when(plugin.getLogger()).thenReturn(logger);
+        var player = mock(Player.class);
+        UUID owner = UUID.randomUUID();
+        when(player.getUniqueId()).thenReturn(owner);
+        if (mode.equals("online")) { when(server.getPlayer(owner)).thenReturn(player); }
+        var callbacks = new java.util.concurrent.LinkedBlockingQueue<Runnable>();
+        var scheduler = mock(org.bukkit.scheduler.BukkitScheduler.class);
+        when(server.getScheduler()).thenReturn(scheduler);
+        when(scheduler.runTask(eq(plugin), any(Runnable.class))).thenAnswer(call -> {
+            if (mode.equals("scheduler-rejected")) { throw new org.bukkit.plugin.IllegalPluginAccessException("simulated shutdown"); }
+            callbacks.add(call.getArgument(1));
+            return null;
+        });
+        var world = mock(World.class);
+        when(world.getUID()).thenReturn(UUID.randomUUID());
+        when(player.getWorld()).thenReturn(world);
+        var block = mock(Block.class);
+        when(block.getType()).thenReturn(Material.END_STONE);
+        when(world.getBlockAt(any(Location.class))).thenReturn(block);
+        try (var states = StateService.open(repository).get(5, TimeUnit.SECONDS)) {
+            var gameplay = new EchoGameplay(plugin, states, new EchoItems());
+            var damage = mock(EntityDamageEvent.class);
+            when(damage.getEntity()).thenReturn(player);
+            when(damage.getCause()).thenReturn(EntityDamageEvent.DamageCause.VOID);
+            when(damage.getFinalDamage()).thenReturn(4.0);
+            gameplay.onDamage(damage);
+            var move = mock(PlayerMoveEvent.class);
+            when(move.getPlayer()).thenReturn(player);
+            when(move.hasChangedPosition()).thenReturn(true);
+            when(move.getTo()).thenReturn(new Location(world, 0, 10, 0));
+            when(player.isGliding()).thenReturn(true);
+            gameplay.onMove(move);
+            when(player.isOnGround()).thenReturn(true);
+            gameplay.onMove(move);
+            assertTrue(entered.await(5, TimeUnit.SECONDS));
+            enabled.set(!mode.equals("disabled"));
+            release.countDown();
+            states.update(state -> state).handle((state, failure) -> null).get(5, TimeUnit.SECONDS);
+            verify(logger).warning(contains("administrator recovery"));
+            verify(logger).warning(contains(owner.toString()));
+            assertFalse(states.snapshot().players().containsKey(owner));
+            verify(server, never()).getPlayer(any(UUID.class));
+            if (mode.equals("online") || mode.equals("offline")) {
+                var callback = callbacks.poll(5, TimeUnit.SECONDS);
+                assertNotNull(callback);
+                callback.run();
+            } else { assertTrue(callbacks.isEmpty()); }
+            if (mode.equals("online")) { verify(player).sendMessage(contains("contact an administrator")); }
+            else { verify(player, never()).sendMessage(anyString()); }
+        } finally { release.countDown(); }
+    }
+}

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

@@ -0,0 +1,17 @@
+package games.dmg.spigotignis;
+
+import static org.junit.jupiter.api.Assertions.*;
+import org.junit.jupiter.api.Test;
+
+class HeartConditionsTest {
+    @Test
+    void darknessWorksEverywhereButNightOnlyWorksInNormalCycleWorlds() {
+        assertTrue(HeartConditions.active(true, true, false));
+        assertTrue(HeartConditions.active(true, false, false));
+        assertTrue(HeartConditions.active(true, false, true));
+        assertTrue(HeartConditions.active(false, true, true));
+        assertFalse(HeartConditions.active(false, true, false));
+        assertFalse(HeartConditions.active(false, false, true));
+        assertFalse(HeartConditions.active(false, false, false));
+    }
+}

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

@@ -0,0 +1,54 @@
+package games.dmg.spigotignis;
+
+import static org.mockito.Mockito.*;
+import java.nio.file.Path;
+import java.util.UUID;
+import org.bukkit.Material;
+import org.bukkit.entity.Player;
+import org.bukkit.event.inventory.CraftItemEvent;
+import org.bukkit.inventory.CraftingInventory;
+import org.bukkit.inventory.ItemStack;
+import org.bukkit.inventory.RecipeChoice;
+import org.bukkit.inventory.ShapedRecipe;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.io.TempDir;
+
+class HeartCraftingTest {
+    @TempDir Path directory;
+    @Test
+    void ingredientValidationCannotBeBypassedWithAnAuthenticatedPreview() throws Exception {
+        UUID owner = UUID.randomUUID(), receipt = UUID.randomUUID();
+        try (var states = StateService.open(new FileStateRepository(directory.resolve("state.bin"))).get()) {
+            states.update(state -> new TradableRewards(Track.HEART).issue(state, owner, receipt, true)).get();
+            var items = mock(HeartItems.class);
+            var product = mock(ItemStack.class);
+            when(items.identify(product)).thenReturn(java.util.Optional.of(new ItemToken(owner, receipt, 0)));
+            var player = mock(Player.class);
+            when(player.getUniqueId()).thenReturn(owner);
+            var recipe = mock(ShapedRecipe.class);
+            when(recipe.getKey()).thenReturn(HeartCrafting.RECIPE);
+            var inventory = mock(CraftingInventory.class);
+            when(inventory.getResult()).thenReturn(product);
+            when(inventory.getMatrix()).thenReturn(new ItemStack[9]);
+            var event = mock(CraftItemEvent.class);
+            when(event.getInventory()).thenReturn(inventory);
+            when(event.getRecipe()).thenReturn(recipe);
+            when(event.getWhoClicked()).thenReturn(player);
+            new HeartCrafting(null, states, items, null).onCraft(event);
+            verify(event).setCancelled(true);
+            verify(inventory).setResult(null);
+            verify(inventory, never()).setMatrix(any());
+        }
+    }
+    @Test
+    void recipeUsesOrthogonalBottlesAndCornerHealingWithCentralHeart() {
+        var recipe = mock(ShapedRecipe.class);
+        var bottle = mock(RecipeChoice.ExactChoice.class);
+        var healing = mock(RecipeChoice.ExactChoice.class);
+        HeartCrafting.configureRecipe(recipe, bottle, healing);
+        verify(recipe).shape("PBP", "BCB", "PBP");
+        verify(recipe).setIngredient('B', bottle);
+        verify(recipe).setIngredient('P', healing);
+        verify(recipe).setIngredient('C', Material.CREAKING_HEART);
+    }
+}

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

@@ -0,0 +1,31 @@
+package games.dmg.spigotignis;
+
+import static org.mockito.Mockito.*;
+import java.util.UUID;
+import org.bukkit.Server;
+import org.bukkit.entity.Player;
+import org.bukkit.plugin.java.JavaPlugin;
+import org.junit.jupiter.api.Test;
+
+class HeartEffectsTest {
+    @Test
+    void ticksEachPlayerOnceAndWithdrawsBeforeDiscardingSessionOwnership() {
+        var plugin = mock(JavaPlugin.class);
+        var server = mock(Server.class);
+        when(plugin.getServer()).thenReturn(server);
+        var player = mock(Player.class);
+        var id = UUID.randomUUID();
+        when(player.getUniqueId()).thenReturn(id);
+        doReturn(java.util.List.of(player)).when(server).getOnlinePlayers();
+        var regeneration = mock(HeartRegeneration.class);
+        var channel = mock(HeartRegeneration.Channel.class);
+        var effects = new HeartEffects(plugin, regeneration, ignored -> true, ignored -> channel);
+        effects.run();
+        verify(regeneration, times(1)).tick(id, true, channel);
+        effects.close();
+        var ordered = inOrder(regeneration);
+        ordered.verify(regeneration).tick(id, true, channel);
+        ordered.verify(regeneration).tick(id, false, channel);
+        ordered.verify(regeneration).forget(id);
+    }
+}

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

@@ -0,0 +1,24 @@
+package games.dmg.spigotignis;
+
+import static org.junit.jupiter.api.Assertions.*;
+import java.util.List;
+import java.util.Set;
+import java.util.UUID;
+import org.junit.jupiter.api.Test;
+
+class HeartEligibilityTest {
+    @Test
+    void inventoryPresenceNeedsPersonalUnlockValidIssuerAndDarknessOrNormalNight() {
+        UUID issuer = UUID.randomUUID(), holder = UUID.randomUUID(), receipt = UUID.randomUUID();
+        var token = new ItemToken(issuer, receipt, 0);
+        var state = new TradableRewards(Track.HEART).issue(IgnisState.empty(), issuer, receipt, true);
+        assertFalse(HeartEligibility.eligible(state, holder, List.of(token), true, true, true));
+        state = ProgressAdministration.progress(state, holder, Track.HEART, state.limits().darknessMillis(), false);
+        assertTrue(HeartEligibility.eligible(state, holder, List.of(token, token), false, true, true));
+        assertFalse(HeartEligibility.eligible(state, holder, List.of(token), false, false, true));
+        assertTrue(HeartEligibility.eligible(state, holder, List.of(token), true, false, false));
+        assertFalse(HeartEligibility.eligible(state, holder, List.of(), true, true, true));
+        state = ProgressAdministration.reset(state, issuer, Set.of(Track.HEART));
+        assertFalse(HeartEligibility.eligible(state, holder, List.of(token), true, true, true));
+    }
+}

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

@@ -0,0 +1,27 @@
+package games.dmg.spigotignis;
+
+import static org.junit.jupiter.api.Assertions.*;
+import static org.mockito.Mockito.*;
+import org.bukkit.Location;
+import org.bukkit.World;
+import org.bukkit.block.Block;
+import org.junit.jupiter.api.Test;
+
+class HeartEnvironmentTest {
+    @Test
+    void totalLightMustBeZeroAndUnloadedChunksAreNotQueried() {
+        var world = mock(World.class);
+        var block = mock(Block.class);
+        var location = new Location(world, -1, 64, 32);
+        assertFalse(HeartEnvironment.dark(location));
+        verify(world, never()).getBlockAt(anyInt(), anyInt(), anyInt());
+        when(world.isChunkLoaded(-1, 2)).thenReturn(true);
+        when(world.getBlockAt(-1, 64, 32)).thenReturn(block);
+        when(block.getLightLevel()).thenReturn((byte) 0);
+        assertTrue(HeartEnvironment.dark(location));
+        when(block.getLightLevel()).thenReturn((byte) 1);
+        assertFalse(HeartEnvironment.dark(location));
+        assertFalse(HeartEnvironment.dark(null));
+        assertFalse(HeartEnvironment.dark(new Location(null, 0, 0, 0)));
+    }
+}

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

@@ -0,0 +1,67 @@
+package games.dmg.spigotignis;
+
+import static org.junit.jupiter.api.Assertions.*;
+import static org.mockito.Mockito.*;
+import org.bukkit.Material;
+import org.bukkit.inventory.ItemStack;
+import org.bukkit.inventory.meta.OminousBottleMeta;
+import org.bukkit.inventory.meta.PotionMeta;
+import org.bukkit.potion.PotionType;
+import org.junit.jupiter.api.Test;
+
+class HeartIngredientsTest {
+    @Test
+    void validatesAllNineRecipePositionsRatherThanOnlyMaterialNames() {
+        var bottle = mock(ItemStack.class);
+        var omen = mock(OminousBottleMeta.class);
+        when(bottle.getType()).thenReturn(Material.OMINOUS_BOTTLE);
+        when(bottle.getItemMeta()).thenReturn(omen);
+        when(omen.hasAmplifier()).thenReturn(true);
+        when(omen.getAmplifier()).thenReturn(4);
+        var potion = mock(ItemStack.class);
+        var meta = mock(PotionMeta.class);
+        when(potion.getType()).thenReturn(Material.LINGERING_POTION);
+        when(potion.getItemMeta()).thenReturn(meta);
+        when(meta.getBasePotionType()).thenReturn(PotionType.STRONG_HEALING);
+        var center = mock(ItemStack.class);
+        when(center.getType()).thenReturn(Material.CREAKING_HEART);
+        ItemStack[] grid = {potion, bottle, potion, bottle, center, bottle, potion, bottle, potion};
+        assertTrue(HeartIngredients.matrix(grid));
+        grid[0] = bottle;
+        assertFalse(HeartIngredients.matrix(grid));
+        grid[0] = potion;
+        grid[4] = potion;
+        assertFalse(HeartIngredients.matrix(grid));
+        assertFalse(HeartIngredients.matrix(new ItemStack[4]));
+        assertFalse(HeartIngredients.matrix(null));
+    }
+
+    @Test
+    void requiresBottleFiveAndLingeringInstantHealthTwoWithoutAddedEffects() {
+        var bottle = mock(ItemStack.class);
+        var omen = mock(OminousBottleMeta.class);
+        when(bottle.getType()).thenReturn(Material.OMINOUS_BOTTLE);
+        when(bottle.getItemMeta()).thenReturn(omen);
+        when(omen.hasAmplifier()).thenReturn(true);
+        when(omen.getAmplifier()).thenReturn(4); // Zero-based amplifier: level V.
+        assertTrue(HeartIngredients.bottle(bottle));
+        when(omen.getAmplifier()).thenReturn(3);
+        assertFalse(HeartIngredients.bottle(bottle));
+        var potion = mock(ItemStack.class);
+        var meta = mock(PotionMeta.class);
+        when(potion.getType()).thenReturn(Material.LINGERING_POTION);
+        when(potion.getItemMeta()).thenReturn(meta);
+        when(meta.getBasePotionType()).thenReturn(PotionType.STRONG_HEALING);
+        assertTrue(HeartIngredients.healing(potion));
+        when(meta.hasCustomEffects()).thenReturn(true);
+        assertFalse(HeartIngredients.healing(potion));
+        when(meta.hasCustomEffects()).thenReturn(false);
+        when(meta.getBasePotionType()).thenReturn(PotionType.HEALING);
+        assertFalse(HeartIngredients.healing(potion));
+        when(meta.getBasePotionType()).thenReturn(PotionType.STRONG_HEALING);
+        when(potion.getType()).thenReturn(Material.SPLASH_POTION);
+        assertFalse(HeartIngredients.healing(potion));
+        assertFalse(HeartIngredients.bottle(null));
+        assertFalse(HeartIngredients.healing(null));
+    }
+}

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

@@ -0,0 +1,40 @@
+package games.dmg.spigotignis;
+
+import static org.junit.jupiter.api.Assertions.*;
+import java.io.IOException;
+import java.util.UUID;
+import java.util.concurrent.CompletionException;
+import java.util.concurrent.RejectedExecutionException;
+import org.junit.jupiter.api.Test;
+
+class HeartInitializationTest {
+    @Test
+    void initializationAcknowledgesOnlyDurablyClearedUnfinishedProgress() throws Exception {
+        var id = UUID.randomUUID();
+        class Repository implements StateRepository {
+            IgnisState saved = ProgressAdministration.progress(IgnisState.empty(), id, Track.HEART, 123, false);
+            @Override public IgnisState load() { return saved; }
+            @Override public void save(IgnisState state) { saved = state; }
+        }
+        var repository = new Repository();
+        try (var service = StateService.open(repository).get()) {
+            assertSame(service, HeartProgressState.prepare(service).get());
+            assertEquals(0, service.snapshot().players().get(id).track(Track.HEART).progress());
+            assertEquals(0, repository.saved.players().get(id).track(Track.HEART).progress());
+        }
+    }
+    @Test
+    void failedNormalizationKeepsOriginalStateAndClosesTheWorker() throws Exception {
+        var original = ProgressAdministration.progress(IgnisState.empty(), UUID.randomUUID(), Track.HEART, 123, false);
+        var repository = new StateRepository() {
+            @Override public IgnisState load() { return original; }
+            @Override public void save(IgnisState state) throws IOException { throw new IOException("fixture storage failure"); }
+        };
+        try (var service = StateService.open(repository).get()) {
+            assertThrows(CompletionException.class, () -> HeartProgressState.prepare(service).join());
+            assertEquals(original, service.snapshot());
+            var failure = assertThrows(CompletionException.class, () -> service.update(state -> state).join());
+            assertInstanceOf(RejectedExecutionException.class, failure.getCause());
+        }
+    }
+}

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

@@ -0,0 +1,34 @@
+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.NamespacedKey;
+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 HeartItemsTest {
+    @Test
+    void onlyHeartMaterialAndItsOwnReceiptNamespaceAuthenticate() {
+        var item = mock(ItemStack.class);
+        var meta = mock(ItemMeta.class);
+        var tags = mock(PersistentDataContainer.class);
+        when(item.getType()).thenReturn(Material.CREAKING_HEART);
+        when(item.hasItemMeta()).thenReturn(true);
+        when(item.getItemMeta()).thenReturn(meta);
+        when(meta.getPersistentDataContainer()).thenReturn(tags);
+        var items = new HeartItems();
+        assertTrue(items.identify(item).isEmpty());
+        var token = new ItemToken(UUID.randomUUID(), UUID.randomUUID(), 2);
+        when(tags.get(new NamespacedKey("spigotignis", "heart_identity"), PersistentDataType.STRING))
+                .thenReturn(EchoIdentity.encode(new EchoToken(token.issuer(), token.receipt(), token.generation())));
+        assertEquals(token, items.identify(item).orElseThrow());
+        assertTrue(new DaggerItems().identify(item).isEmpty());
+        when(item.getType()).thenReturn(Material.OMINOUS_TRIAL_KEY);
+        assertTrue(items.identify(item).isEmpty());
+    }
+}

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

@@ -0,0 +1,31 @@
+package games.dmg.spigotignis;
+
+import static org.mockito.Mockito.*;
+import java.util.Optional;
+import java.util.UUID;
+import org.bukkit.event.block.BlockPlaceEvent;
+import org.bukkit.inventory.ItemStack;
+import org.junit.jupiter.api.Test;
+
+class HeartPlacementTest {
+    @Test
+    void issuedCopiesCannotBecomeBlocksEvenWhenTheirReceiptIsRevoked() {
+        var items = mock(HeartItems.class);
+        var item = mock(ItemStack.class);
+        var event = mock(BlockPlaceEvent.class);
+        when(event.getItemInHand()).thenReturn(item);
+        when(items.identify(item)).thenReturn(Optional.of(new ItemToken(UUID.randomUUID(), UUID.randomUUID(), 0)));
+        new HeartPlacement(items).onPlace(event);
+        verify(event).setCancelled(true);
+    }
+    @Test
+    void ordinaryCreakingHeartsRemainPlaceable() {
+        var items = mock(HeartItems.class);
+        var item = mock(ItemStack.class);
+        var event = mock(BlockPlaceEvent.class);
+        when(event.getItemInHand()).thenReturn(item);
+        when(items.identify(item)).thenReturn(Optional.empty());
+        new HeartPlacement(items).onPlace(event);
+        verify(event, never()).setCancelled(anyBoolean());
+    }
+}

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

@@ -0,0 +1,68 @@
+package games.dmg.spigotignis;
+
+import static org.mockito.Mockito.*;
+import java.util.UUID;
+import java.util.concurrent.CompletableFuture;
+import org.bukkit.Server;
+import org.bukkit.Location;
+import org.bukkit.entity.Player;
+import org.bukkit.event.entity.EntityDamageEvent;
+import org.bukkit.event.player.PlayerMoveEvent;
+import org.bukkit.event.player.PlayerQuitEvent;
+import org.bukkit.plugin.java.JavaPlugin;
+import org.junit.jupiter.api.Test;
+
+class HeartProgressListenerTest {
+    @Test
+    void observesOnlinePlayersAndInterruptsOnlyUncancelledPositiveDamage() {
+        var plugin = mock(JavaPlugin.class);
+        var server = mock(Server.class);
+        var player = mock(Player.class);
+        var id = UUID.randomUUID();
+        when(plugin.getServer()).thenReturn(server);
+        when(player.getUniqueId()).thenReturn(id);
+        doReturn(java.util.List.of(player)).when(server).getOnlinePlayers();
+        var progress = mock(DarknessProgress.class);
+        when(progress.checkpoint(id)).thenReturn(CompletableFuture.completedFuture(IgnisState.empty()));
+        var listener = new HeartProgressListener(plugin, progress, ignored -> true, error -> { throw new AssertionError(error); });
+        listener.run();
+        verify(progress).observe(id, true);
+        var damage = mock(EntityDamageEvent.class);
+        when(damage.getEntity()).thenReturn(player);
+        when(damage.getFinalDamage()).thenReturn(1.0);
+        when(damage.isCancelled()).thenReturn(true);
+        listener.onDamage(damage);
+        verify(progress, never()).interrupt(id);
+        when(damage.isCancelled()).thenReturn(false);
+        when(damage.getFinalDamage()).thenReturn(0.0);
+        listener.onDamage(damage);
+        verify(progress, never()).interrupt(id);
+        when(damage.getFinalDamage()).thenReturn(1.0);
+        listener.onDamage(damage);
+        verify(progress).interrupt(id);
+        verify(progress).checkpoint(id);
+    }
+    @Test
+    void enteringLightAndDisconnectingInterruptButCancelledMovementDoesNot() {
+        var player = mock(Player.class);
+        var id = UUID.randomUUID();
+        when(player.getUniqueId()).thenReturn(id);
+        var progress = mock(DarknessProgress.class);
+        when(progress.checkpoint(id)).thenReturn(CompletableFuture.completedFuture(IgnisState.empty()));
+        var listener = new HeartProgressListener(null, progress, ignored -> false, error -> { throw new AssertionError(error); });
+        var move = mock(PlayerMoveEvent.class);
+        when(move.getPlayer()).thenReturn(player);
+        when(move.getTo()).thenReturn(new Location(null, 0, 0, 0));
+        when(move.isCancelled()).thenReturn(true);
+        listener.onMove(move);
+        verifyNoInteractions(progress);
+        when(move.isCancelled()).thenReturn(false);
+        listener.onMove(move);
+        verify(progress).interrupt(id);
+        var quit = mock(PlayerQuitEvent.class);
+        when(quit.getPlayer()).thenReturn(player);
+        listener.onQuit(quit);
+        verify(progress, times(2)).interrupt(id);
+        verify(progress).checkpoint(id);
+    }
+}

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

@@ -0,0 +1,21 @@
+package games.dmg.spigotignis;
+
+import static org.junit.jupiter.api.Assertions.*;
+import java.util.UUID;
+import org.junit.jupiter.api.Test;
+
+class HeartProgressStateTest {
+    @Test
+    void restartClearsOnlyUnfinishedDarknessWithoutRevokingCompletedRewardsOrOtherTracks() {
+        UUID unfinished = UUID.randomUUID(), finished = UUID.randomUUID(), receipt = UUID.randomUUID();
+        var state = ProgressAdministration.progress(IgnisState.empty(), unfinished, Track.HEART, 1000, false);
+        state = ProgressAdministration.progress(state, unfinished, Track.DAGGER, 11, false);
+        state = new TradableRewards(Track.HEART).issue(state, finished, receipt, true);
+        var restarted = HeartProgressState.restart(state);
+        assertEquals(0, restarted.players().get(unfinished).track(Track.HEART).progress());
+        assertEquals(11, restarted.players().get(unfinished).track(Track.DAGGER).progress());
+        assertEquals(state.players().get(finished), restarted.players().get(finished));
+        assertEquals(1000, state.players().get(unfinished).track(Track.HEART).progress());
+        assertEquals(state.limits(), restarted.limits());
+    }
+}

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

@@ -0,0 +1,129 @@
+package games.dmg.spigotignis;
+
+import static org.junit.jupiter.api.Assertions.*;
+import java.util.UUID;
+import java.util.concurrent.atomic.AtomicLong;
+import org.junit.jupiter.api.Test;
+
+class HeartRegenerationTest {
+    @Test
+    void shutdownRestoresWeakerEffectsEvenWhenDisabledListenersReceiveNoEvents() {
+        var controller = new HeartRegeneration(() -> 0L);
+        var id = UUID.randomUUID();
+        class Channel implements HeartRegeneration.Channel {
+            HeartRegeneration.Effect effect = new HeartRegeneration.Effect(0, 200, false, true, true);
+            boolean events = true;
+            @Override public HeartRegeneration.Effect current() { return effect; }
+            @Override public void apply(HeartRegeneration.Effect next) {
+                effect = next;
+                if (events) controller.changed(id, true, true);
+            }
+            @Override public void remove() { effect = null; }
+        }
+        var channel = new Channel();
+        controller.tick(id, true, channel);
+        channel.events = false;
+        controller.tick(id, false, channel);
+        assertEquals(new HeartRegeneration.Effect(0, 200, false, true, true), channel.effect);
+    }
+
+    @Test
+    void endingSessionDropsOwnershipRatherThanRestoringAnOfflineAgedBackupLater() {
+        var controller = new HeartRegeneration(() -> 0L);
+        var id = UUID.randomUUID();
+        class Channel implements HeartRegeneration.Channel {
+            HeartRegeneration.Effect effect;
+            int removals;
+            @Override public HeartRegeneration.Effect current() { return effect; }
+            @Override public void apply(HeartRegeneration.Effect next) { effect = next; controller.changed(id, true, true); }
+            @Override public void remove() { removals++; } // External plugin vetoes removal.
+        }
+        var channel = new Channel();
+        controller.tick(id, true, channel);
+        controller.tick(id, false, channel);
+        controller.forget(id);
+        controller.tick(id, false, channel);
+        assertEquals(1, channel.removals);
+    }
+
+    @Test
+    void cancellationAndStrongerExternalEffectsTakePrecedenceAndInfiniteBackupStaysInfinite() {
+        var controller = new HeartRegeneration(() -> 1000L);
+        var id = UUID.randomUUID();
+        class Channel implements HeartRegeneration.Channel {
+            HeartRegeneration.Effect effect = new HeartRegeneration.Effect(0, -1, false, true, true);
+            boolean allowApply, allowRemove;
+            int removals;
+            @Override public HeartRegeneration.Effect current() { return effect; }
+            @Override public void apply(HeartRegeneration.Effect next) {
+                if (allowApply) { effect = next; controller.changed(id, true, true); }
+            }
+            @Override public void remove() {
+                if (allowRemove) { removals++; effect = null; controller.changed(id, true, false); }
+            }
+        }
+        var channel = new Channel();
+        controller.tick(id, true, channel);
+        controller.tick(id, false, channel);
+        assertEquals(0, channel.effect.amplifier());
+        channel.allowApply = true;
+        controller.tick(id, true, channel);
+        controller.tick(id, false, channel);
+        assertEquals(1, channel.effect.amplifier(), "Cancelled removal is respected");
+        channel.allowRemove = true;
+        controller.tick(id, false, channel);
+        assertEquals(-1, channel.effect.ticks());
+        channel.effect = new HeartRegeneration.Effect(2, 400, false, true, true);
+        controller.changed(id, true, true);
+        controller.tick(id, true, channel);
+        controller.tick(id, false, channel);
+        assertEquals(2, channel.effect.amplifier());
+        assertEquals(1, channel.removals);
+    }
+
+    @Test
+    void anExternalClearCannotResurrectTheWeakerEffectOnLaterUnequip() {
+        var controller = new HeartRegeneration(() -> 0L);
+        var id = UUID.randomUUID();
+        class Channel implements HeartRegeneration.Channel {
+            HeartRegeneration.Effect effect = new HeartRegeneration.Effect(0, 200, false, true, true);
+            @Override public HeartRegeneration.Effect current() { return effect; }
+            @Override public void apply(HeartRegeneration.Effect next) { effect = next; controller.changed(id, true, true); }
+            @Override public void remove() { effect = null; controller.changed(id, true, false); }
+        }
+        var channel = new Channel();
+        controller.tick(id, true, channel);
+        channel.effect = null;
+        controller.changed(id, true, false); // Milk or another plugin cleared regeneration.
+        controller.tick(id, true, channel);
+        controller.tick(id, false, channel);
+        assertNull(channel.effect);
+    }
+
+    @Test
+    void overlaysRegenerationTwoAndRestoresOnlyTheRemainingWeakerEffect() {
+        var clock = new AtomicLong();
+        var controller = new HeartRegeneration(clock::get);
+        var id = UUID.randomUUID();
+        class Channel implements HeartRegeneration.Channel {
+            HeartRegeneration.Effect effect = new HeartRegeneration.Effect(0, 200, false, true, true);
+            @Override public HeartRegeneration.Effect current() { return effect; }
+            @Override public void apply(HeartRegeneration.Effect next) { effect = next; controller.changed(id, true, true); }
+            @Override public void remove() { effect = null; controller.changed(id, true, false); }
+        }
+        var channel = new Channel();
+        controller.tick(id, true, channel);
+        assertEquals(1, channel.effect.amplifier());
+        assertEquals(40, channel.effect.ticks());
+        for (int tick = 10; tick <= 100; tick += 10) {
+            clock.set(tick);
+            var old = channel.effect;
+            channel.effect = new HeartRegeneration.Effect(old.amplifier(), old.ticks() - 10, old.ambient(), old.particles(), old.icon());
+            controller.tick(id, true, channel);
+        }
+        controller.tick(id, false, channel);
+        assertEquals(new HeartRegeneration.Effect(0, 100, false, true, true), channel.effect);
+        controller.tick(id, false, channel);
+        assertEquals(0, channel.effect.amplifier(), "Restored external regeneration is not claimed as ours");
+    }
+}

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

@@ -10,6 +10,60 @@ import org.junit.jupiter.api.Test;
 class IgnisCommandsTest {
     @org.junit.jupiter.api.io.TempDir java.nio.file.Path directory;
 
+    @Test
+    void administrativeHeartSetUsesTheTrackerRebaseBarrier() 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 saved = new java.util.concurrent.CountDownLatch(1);
+        doAnswer(call -> { saved.countDown(); return null; }).when(sender).sendMessage("Ignis change saved.");
+        var command = mock(Command.class);
+        when(command.getName()).thenReturn("ignisadmin");
+        var dispatch = mock(EchoGameplay.class);
+        doAnswer(call -> { ((Runnable) call.getArgument(0)).run(); return null; }).when(dispatch).onServer(any());
+        var owner = java.util.UUID.randomUUID();
+        try (var states = StateService.open(new FileStateRepository(directory.resolve("heart.bin"))).get()) {
+            states.update(state -> ProgressAdministration.progress(state, owner, Track.HEART, 0, false)).get();
+            var clock = new java.util.concurrent.atomic.AtomicLong();
+            var tracker = new DarknessProgress(states, clock::get);
+            tracker.observe(owner, true);
+            clock.set(100_000_000L);
+            tracker.observe(owner, true);
+            var commands = new IgnisCommands(plugin, states, dispatch, null, null, tracker);
+            commands.onCommand(sender, command, "ignisadmin", new String[]{"progress", "set", owner.toString(), "heart", "2"});
+            assertTrue(saved.await(3, java.util.concurrent.TimeUnit.SECONDS));
+            tracker.observe(owner, true);
+            tracker.checkpoint(owner).get();
+            assertEquals(2, states.snapshot().players().get(owner).track(Track.HEART).progress());
+        }
+    }
+
+    @Test
+    void administrativePearlSetFlushesOlderCreditsBeforeOverwritingCounter() 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 saved = new java.util.concurrent.CountDownLatch(1);
+        doAnswer(call -> { saved.countDown(); return null; }).when(sender).sendMessage("Ignis change saved.");
+        var command = mock(Command.class);
+        when(command.getName()).thenReturn("ignisadmin");
+        var dispatch = mock(EchoGameplay.class);
+        doAnswer(call -> { ((Runnable) call.getArgument(0)).run(); return null; }).when(dispatch).onServer(any());
+        var owner = java.util.UUID.randomUUID();
+        try (var states = StateService.open(new FileStateRepository(directory.resolve("state.bin"))).get()) {
+            states.update(state -> ProgressAdministration.progress(state, owner, Track.DAGGER, 0, false)).get();
+            var tracker = new PearlProgress(states);
+            tracker.record(owner);
+            var commands = new IgnisCommands(plugin, states, dispatch, null, tracker);
+            commands.onCommand(sender, command, "ignisadmin", new String[]{"progress", "set", owner.toString(), "dagger", "2"});
+            assertTrue(saved.await(3, java.util.concurrent.TimeUnit.SECONDS));
+            tracker.checkpoint(owner).get();
+            assertEquals(2, states.snapshot().players().get(owner).track(Track.DAGGER).progress());
+        }
+    }
+
     @Test
     void grantsLimitsProgressAndAutocompleteUseKnownOfflineUuid() throws Exception {
         var plugin = mock(JavaPlugin.class);
@@ -33,10 +87,18 @@ class IgnisCommandsTest {
             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(), ""}));
+            assertEquals(java.util.List.of("dagger", "echo", "heart", "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));
+            handler.onCommand(sender, command, "ignisadmin", new String[]{"give", owner.toString(), "dagger"});
+            states.update(state -> state).get();
+            assertTrue(states.snapshot().players().get(owner).pendingRewards().containsValue(Track.DAGGER));
+            assertTrue(states.snapshot().players().get(owner).track(Track.DAGGER).unlocked());
+            handler.onCommand(sender, command, "ignisadmin", new String[]{"give", owner.toString(), "heart"});
+            states.update(state -> state).get();
+            assertTrue(states.snapshot().players().get(owner).pendingRewards().containsValue(Track.HEART));
+            assertTrue(states.snapshot().players().get(owner).track(Track.HEART).unlocked());
         }
     }
 

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

@@ -0,0 +1,77 @@
+package games.dmg.spigotignis;
+
+import static org.junit.jupiter.api.Assertions.*;
+import static org.mockito.Mockito.*;
+import java.util.ArrayList;
+import java.util.UUID;
+import com.destroystokyo.paper.event.player.PlayerLaunchProjectileEvent;
+import org.bukkit.Material;
+import org.bukkit.Statistic;
+import org.bukkit.entity.EnderPearl;
+import org.bukkit.entity.Player;
+import org.bukkit.event.player.PlayerStatisticIncrementEvent;
+import org.bukkit.inventory.ItemStack;
+import org.junit.jupiter.api.Test;
+
+class PearlLaunchListenerTest {
+    @Test
+    void rejectsCancelledFreeUnconsumedAndUnrelatedSignals() {
+        for (String scenario : java.util.List.of("cancelled", "free", "unconsumed", "wrong-stat", "wrong-item", "wrong-projectile", "expired")) {
+            var player = mock(Player.class);
+            when(player.getUniqueId()).thenReturn(UUID.randomUUID());
+            var item = mock(ItemStack.class);
+            when(item.getType()).thenReturn(scenario.equals("wrong-item") ? Material.SNOWBALL : Material.ENDER_PEARL);
+            when(item.getAmount()).thenReturn(2);
+            var launch = mock(PlayerLaunchProjectileEvent.class);
+            when(launch.getPlayer()).thenReturn(player);
+            when(launch.getItemStack()).thenReturn(item);
+            when(launch.getProjectile()).thenReturn(scenario.equals("wrong-projectile") ? mock(org.bukkit.entity.Snowball.class) : mock(EnderPearl.class));
+            when(launch.shouldConsume()).thenReturn(!scenario.equals("free"));
+            var used = mock(PlayerStatisticIncrementEvent.class);
+            when(used.getPlayer()).thenReturn(player);
+            when(used.getStatistic()).thenReturn(scenario.equals("wrong-stat") ? Statistic.DROP : Statistic.USE_ITEM);
+            when(used.getMaterial()).thenReturn(Material.ENDER_PEARL);
+            var credits = new ArrayList<UUID>();
+            var cleanup = new ArrayList<Runnable>();
+            var listener = new PearlLaunchListener(cleanup::add, credits::add);
+            listener.onLaunch(launch);
+            when(launch.isCancelled()).thenReturn(scenario.equals("cancelled"));
+            when(item.getAmount()).thenReturn(scenario.equals("unconsumed") ? 2 : 1);
+            if (scenario.equals("expired")) cleanup.forEach(Runnable::run);
+            listener.onUse(used);
+            assertTrue(credits.isEmpty(), scenario);
+        }
+    }
+
+    @Test
+    void creditsConsumedSuccessfulLaunchOnceEvenIfStatisticUpdateIsCancelled() {
+        var player = mock(Player.class);
+        UUID id = UUID.randomUUID();
+        when(player.getUniqueId()).thenReturn(id);
+        var item = mock(ItemStack.class);
+        when(item.getType()).thenReturn(Material.ENDER_PEARL);
+        when(item.getAmount()).thenReturn(2);
+        var launch = mock(PlayerLaunchProjectileEvent.class);
+        when(launch.getPlayer()).thenReturn(player);
+        when(launch.getProjectile()).thenReturn(mock(EnderPearl.class));
+        when(launch.getItemStack()).thenReturn(item);
+        when(launch.shouldConsume()).thenReturn(true);
+        var used = mock(PlayerStatisticIncrementEvent.class);
+        when(used.getPlayer()).thenReturn(player);
+        when(used.getStatistic()).thenReturn(Statistic.USE_ITEM);
+        when(used.getMaterial()).thenReturn(Material.ENDER_PEARL);
+        when(used.isCancelled()).thenReturn(true); // Pearl consumption already happened.
+        var credits = new ArrayList<UUID>();
+        var cleanup = new ArrayList<Runnable>();
+        var listener = new PearlLaunchListener(cleanup::add, credits::add);
+        listener.onLaunch(launch);
+        assertTrue(credits.isEmpty(), "Launch precedes the cancellable spawn and actual consumption");
+        when(item.getAmount()).thenReturn(1);
+        listener.onUse(used);
+        listener.onUse(used);
+        assertEquals(java.util.List.of(id), credits);
+        cleanup.forEach(Runnable::run);
+        listener.onUse(used);
+        assertEquals(1, credits.size());
+    }
+}

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

@@ -0,0 +1,93 @@
+package games.dmg.spigotignis;
+
+import static org.junit.jupiter.api.Assertions.*;
+import java.nio.file.Path;
+import java.util.UUID;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.io.TempDir;
+
+class PearlProgressTest {
+    @TempDir Path directory;
+
+    @Test
+    void checkpointWaitsForReservedWritesAndDrainsNewCreditsBeforeAcknowledging() throws Exception {
+        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(5, java.util.concurrent.TimeUnit.SECONDS)) throw new java.io.IOException("Timed out"); }
+                catch (InterruptedException error) { Thread.currentThread().interrupt(); throw new java.io.IOException(error); }
+                disk.save(state);
+            }
+        };
+        try (var states = StateService.open(boundary).get()) {
+            var progress = new PearlProgress(states);
+            var player = UUID.randomUUID();
+            progress.record(player);
+            var first = progress.checkpoint(player);
+            try {
+                assertTrue(entered.await(2, java.util.concurrent.TimeUnit.SECONDS));
+                var duplicate = progress.checkpoint(player);
+                assertFalse(duplicate.isDone(), "A reserved write is not yet durable");
+                progress.record(player);
+                var drain = progress.checkpoint(player);
+                release.countDown();
+                first.get(); duplicate.get(); drain.get();
+                assertEquals(2, states.snapshot().players().get(player).track(Track.DAGGER).progress());
+            } finally { release.countDown(); }
+        }
+    }
+
+
+    @Test
+    void retriesFailedCreditsButResetDropsOldGenerationCredits() throws Exception {
+        var disk = new FileStateRepository(directory.resolve("state.bin"));
+        var fail = new java.util.concurrent.atomic.AtomicBoolean(true);
+        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 save failure");
+                disk.save(state);
+            }
+        };
+        UUID player = UUID.randomUUID();
+        try (var states = StateService.open(boundary).get()) {
+            var progress = new PearlProgress(states);
+            progress.record(player);
+            assertThrows(java.util.concurrent.ExecutionException.class, () -> progress.checkpoint(player).get());
+            fail.set(false);
+            progress.checkpoint(player).get();
+            assertEquals(1, states.snapshot().players().getOrDefault(player, PlayerState.empty()).track(Track.DAGGER).progress());
+            progress.record(player);
+            states.update(state -> ProgressAdministration.reset(state, player, java.util.Set.of(Track.DAGGER))).get();
+            progress.checkpoint(player).get();
+            assertEquals(0, states.snapshot().players().get(player).track(Track.DAGGER).progress());
+            progress.record(player);
+            progress.checkpoint(player).get();
+            assertEquals(1, states.snapshot().players().get(player).track(Track.DAGGER).progress());
+        }
+    }
+
+    @Test
+    void consumedPearlsAccumulateUnlockAtConfiguredLimitAndPersistByUuid() throws Exception {
+        var disk = new FileStateRepository(directory.resolve("state.bin"));
+        UUID player = UUID.randomUUID();
+        try (var states = StateService.open(disk).get()) {
+            states.configure(1000, 2, 1000).get();
+            var progress = new PearlProgress(states);
+            progress.record(player);
+            progress.checkpointAll().get();
+            assertEquals(1, states.snapshot().players().get(player).track(Track.DAGGER).progress());
+            assertFalse(states.snapshot().players().get(player).track(Track.DAGGER).unlocked());
+            progress.record(player);
+            progress.checkpoint(player).get();
+            assertTrue(states.snapshot().players().get(player).track(Track.DAGGER).unlocked());
+        }
+        try (var states = StateService.open(disk).get()) {
+            assertEquals(2, states.snapshot().players().get(player).track(Track.DAGGER).progress());
+        }
+    }
+}

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

@@ -0,0 +1,140 @@
+package games.dmg.spigotignis;
+
+import static org.junit.jupiter.api.Assertions.*;
+import static org.mockito.Mockito.*;
+
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+import java.util.UUID;
+import org.bukkit.Location;
+import org.bukkit.Server;
+import org.bukkit.World;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+import org.bukkit.event.entity.EntityDamageEvent;
+import org.bukkit.event.player.PlayerMoveEvent;
+import org.bukkit.event.player.PlayerQuitEvent;
+import org.bukkit.plugin.java.JavaPlugin;
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.io.TempDir;
+
+class ProgressInspectionTest {
+    @TempDir Path directory;
+    private final UUID owner = UUID.randomUUID(), worldId = UUID.randomUUID();
+    private final JavaPlugin plugin = mock(JavaPlugin.class);
+    private final Server server = mock(Server.class);
+    private final Player player = mock(Player.class);
+    private final World world = mock(World.class);
+    private final CommandSender admin = mock(CommandSender.class);
+    private final Command command = mock(Command.class);
+    private final EchoItems items = mock(EchoItems.class);
+    private final List<String> messages = new ArrayList<>();
+    private StateService states;
+    private EchoGameplay gameplay;
+    private IgnisCommands handler;
+    private Path file;
+
+    @BeforeEach
+    void setup() throws Exception {
+        file = directory.resolve("state.bin");
+        states = StateService.open(new FileStateRepository(file)).get();
+        states.update(state -> new IgnisState(state.limits(), Map.of(owner, PlayerState.empty()))).get();
+        when(plugin.getServer()).thenReturn(server);
+        when(player.getUniqueId()).thenReturn(owner);
+        when(player.getName()).thenReturn("Target");
+        when(player.getWorld()).thenReturn(world);
+        when(player.getY()).thenReturn(-65.0);
+        when(world.getUID()).thenReturn(worldId);
+        when(server.getPlayerExact("Target")).thenReturn(player);
+        when(admin.hasPermission("ignis.admin")).thenReturn(true);
+        when(command.getName()).thenReturn("ignisadmin");
+        doAnswer(call -> { messages.add(call.getArgument(0, String.class)); return null; })
+            .when(admin).sendMessage(anyString());
+        gameplay = new EchoGameplay(plugin, states, items);
+        handler = new IgnisCommands(plugin, states, gameplay);
+    }
+
+    @AfterEach
+    void close() { if (states != null) states.close(); }
+
+    @Test
+    void commandReportsRealGameplayAttemptStagesWithoutSavingOrInterruptingThem() throws Exception {
+        var before = states.snapshot();
+        byte[] bytes = Files.readAllBytes(file);
+        EntityDamageEvent damage = mock(EntityDamageEvent.class);
+        when(damage.getEntity()).thenReturn(player);
+        when(damage.getCause()).thenReturn(EntityDamageEvent.DamageCause.VOID);
+        when(damage.getFinalDamage()).thenReturn(1.0);
+        gameplay.onDamage(damage);
+        inspect("Target");
+        assertContains("Void challenge: awaiting-elytra-ascent");
+        assertContains("world=" + worldId);
+        assertContains("damage-y=-65.0");
+        when(player.isGliding()).thenReturn(true);
+        gameplay.onMove(new PlayerMoveEvent(player, new Location(world, 0, -65, 0), new Location(world, 0, 20, 0)));
+        messages.clear();
+        inspect("Target");
+        assertContains("Void challenge: awaiting-end-stone");
+        var quit = mock(PlayerQuitEvent.class);
+        when(quit.getPlayer()).thenReturn(player);
+        gameplay.onQuit(quit);
+        messages.clear();
+        inspect(owner.toString());
+        assertContains("Void challenge: none");
+        assertSame(before, states.snapshot());
+        assertArrayEquals(bytes, Files.readAllBytes(file));
+        verifyNoInteractions(items);
+        verify(plugin, never()).getLogger();
+        verify(server, never()).getScheduler();
+    }
+
+    @Test
+    void savedProgressAndRecipeUnlocksDoNotMisreportAnUnconsumedEchoAsActive() throws Exception {
+        UUID receipt = UUID.randomUUID();
+        states.update(state -> EchoRewards.award(ProgressAdministration.progress(
+            ProgressAdministration.progress(state, owner, Track.MASK, state.limits().invisibilityMillis(), false),
+            owner, Track.DAGGER, 3, false), owner, receipt)).get();
+        var before = states.snapshot();
+        byte[] bytes = Files.readAllBytes(file);
+        inspect(owner.toString());
+        assertContains("MASK=" + before.limits().invisibilityMillis());
+        assertContains("DAGGER=3");
+        assertContains("HEART=0");
+        assertContains("Recipe unlocks: mask=unlocked, dagger=locked, heart=locked");
+        assertContains("Echo: eligibility=unlocked; advancement-name scrambling=inactive");
+        assertContains("pending=1");
+        assertContains("issued=1");
+        assertSame(before, states.snapshot());
+        assertArrayEquals(bytes, Files.readAllBytes(file));
+        verify(server, never()).getPlayerExact(anyString());
+        verifyNoInteractions(items);
+        states.update(state -> EchoRewards.activate(state, owner, new EchoToken(owner, receipt, 0))).get();
+        messages.clear();
+        inspect(owner.toString());
+        assertContains("advancement-name scrambling=active");
+    }
+
+    @Test
+    void nonAdminInspectionIsDeniedBeforeReadingOrResolvingState() {
+        when(admin.hasPermission("ignis.admin")).thenReturn(false);
+        var denied = new IgnisCommands(plugin, null, null);
+        denied.onCommand(admin, command, "ignisadmin", new String[] {"inspect", "Target"});
+        assertEquals(List.of("You do not have permission to administer Ignis."), messages);
+        verifyNoInteractions(server);
+    }
+
+    private void inspect(String target) {
+        assertTrue(handler.onCommand(admin, command, "ignisadmin", new String[] {"inspect", target}));
+    }
+
+    private void assertContains(String fragment) {
+        assertTrue(messages.stream().anyMatch(message -> message.contains(fragment)),
+            () -> "Missing '" + fragment + "' in " + messages);
+    }
+}

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

@@ -0,0 +1,56 @@
+package games.dmg.spigotignis;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+import java.io.DataInputStream;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.util.Map;
+import java.util.jar.JarFile;
+import org.junit.jupiter.api.Test;
+import org.yaml.snakeyaml.Yaml;
+
+class PurpurDistributionTest {
+    @Test
+    void packagesNewNameWithoutChangingRuntimeIdentityOrBundlingTheApi() throws Exception {
+        Path artifact = Path.of(System.getProperty("distribution.jar"));
+        String version = System.getProperty("distribution.version");
+        assertEquals("purpur-ignis-" + version + ".jar", artifact.getFileName().toString());
+        try (var jar = new JarFile(artifact.toFile())) {
+            Map<?, ?> metadata = new Yaml().load(jar.getInputStream(jar.getJarEntry("plugin.yml")));
+            assertEquals(version, metadata.get("version"));
+            assertEquals("SpigotIgnis", metadata.get("name"), "Retain the data directory and persistent namespace");
+            assertEquals("games.dmg.spigotignis.SpigotIgnisPlugin", metadata.get("main"));
+            assertTrue(((Map<?, ?>) metadata.get("permissions")).containsKey("ignis.admin"));
+            assertEquals(java.util.List.of("ProtocolLib"), metadata.get("depend"));
+            var descriptor = new org.bukkit.plugin.PluginDescriptionFile(jar.getInputStream(jar.getJarEntry("plugin.yml")));
+            assertEquals("spigotignis", descriptor.namespace());
+            assertFalse(jar.stream().anyMatch(entry -> entry.getName().startsWith("org/bukkit/")
+                || entry.getName().startsWith("org/purpurmc/") || entry.getName().startsWith("com/comphenix/") || entry.getName().endsWith("Test.class")));
+        }
+    }
+
+    @Test
+    void pluginBytecodeTargetsJava25() throws Exception {
+        try (var jar = new JarFile(System.getProperty("distribution.jar"));
+             var bytecode = new DataInputStream(jar.getInputStream(
+                 jar.getJarEntry("games/dmg/spigotignis/SpigotIgnisPlugin.class")))) {
+            assertEquals(0xCAFEBABE, bytecode.readInt());
+            bytecode.readUnsignedShort();
+            assertEquals(69, bytecode.readUnsignedShort());
+        }
+    }
+
+    @Test
+    void releaseAndCiAgreeWithThePurpurDistributionNameAndToolchain() throws Exception {
+        String build = Files.readString(Path.of("build.gradle.kts"));
+        assertTrue(build.contains("purpur-api:26.2.build.2618-stable"));
+        assertFalse(build.contains("org.spigotmc:spigot-api"));
+        for (String workflow : new String[] {"ci.yml", "release.yml"}) {
+            String content = Files.readString(Path.of(".gitea/workflows", workflow));
+            assertTrue(content.contains("java-version: 25"));
+            assertTrue(content.contains("purpur-ignis-"), workflow);
+            assertFalse(content.contains("spigot-ignis-"), workflow);
+        }
+    }
+}

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

@@ -0,0 +1,68 @@
+package games.dmg.spigotignis;
+
+import static org.junit.jupiter.api.Assertions.*;
+import static org.mockito.Mockito.*;
+import java.io.IOException;
+import java.nio.file.Path;
+import java.util.UUID;
+import java.util.concurrent.atomic.AtomicBoolean;
+import org.bukkit.Server;
+import org.bukkit.entity.Player;
+import org.bukkit.inventory.ShapedRecipe;
+import org.bukkit.plugin.java.JavaPlugin;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.io.TempDir;
+
+class RecipeDeliveryRetryTest {
+    @TempDir Path directory;
+    @Test void daggerGiftAcknowledgementRetryDoesNotOfferAnotherPhysicalCopy() throws Exception { verifyRetry(false); }
+    @Test void maskGiftAcknowledgementRetryDoesNotOfferAnotherPhysicalCopy() throws Exception { verifyRetry(true); }
+
+    private void verifyRetry(boolean mask) throws Exception {
+        var track = mask ? Track.MASK : Track.DAGGER;
+        UUID owner = UUID.randomUUID(), receipt = UUID.randomUUID();
+        var failAcknowledgement = new AtomicBoolean(true);
+        var disk = new FileStateRepository(directory.resolve(track + ".bin"));
+        StateRepository boundary = new StateRepository() {
+            @Override public IgnisState load() throws IOException { return disk.load(); }
+            @Override public void save(IgnisState state) throws IOException {
+                if (failAcknowledgement.get() && !state.players().get(owner).pendingRewards().containsKey(receipt)) {
+                    throw new IOException("Simulated gift acknowledgement failure");
+                }
+                disk.save(state);
+            }
+        };
+        var plugin = mock(JavaPlugin.class);
+        var server = mock(Server.class);
+        when(plugin.getServer()).thenReturn(server);
+        var player = mock(Player.class);
+        when(player.getUniqueId()).thenReturn(owner);
+        doReturn(java.util.List.of(player)).when(server).getOnlinePlayers();
+        var recipe = mock(ShapedRecipe.class);
+        when(server.addRecipe(recipe)).thenReturn(true);
+        var maskItems = mock(MaskItems.class);
+        when(maskItems.ready()).thenReturn(true);
+        var maskToken = new MaskToken(owner, receipt, 0);
+        when(maskItems.offer(player, maskToken)).thenReturn(true, false);
+        var daggerItems = mock(DaggerItems.class);
+        var daggerToken = new ItemToken(owner, receipt, 0);
+        when(daggerItems.offer(player, daggerToken)).thenReturn(true, false);
+        var dispatch = mock(EchoGameplay.class);
+        doAnswer(call -> { ((Runnable) call.getArgument(0)).run(); return null; }).when(dispatch).onServer(any());
+        try (var states = StateService.open(boundary).get()) {
+            states.update(state -> new TradableRewards(track).issue(state, owner, receipt, true)).get();
+            Runnable crafting = mask ? new MaskCrafting(plugin, states, maskItems, dispatch, ignored -> recipe)
+                    : new DaggerCrafting(plugin, states, daggerItems, dispatch, ignored -> recipe);
+            crafting.run();
+            states.update(state -> state).get();
+            assertTrue(states.snapshot().players().get(owner).pendingRewards().containsKey(receipt));
+            // The recipient can trade the gift away while the acknowledgement save is failing.
+            failAcknowledgement.set(false);
+            crafting.run();
+            states.update(state -> state).get();
+            assertFalse(states.snapshot().players().get(owner).pendingRewards().containsKey(receipt));
+            if (mask) verify(maskItems, times(1)).offer(player, maskToken);
+            else verify(daggerItems, times(1)).offer(player, daggerToken);
+        }
+    }
+}

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

@@ -11,8 +11,9 @@ class ReleaseCredentialTest {
     void credentialHelperRefusesOtherHostsProtocolsRepositoriesAndOperations() throws Exception {
         Path helper = Path.of(".gitea/scripts/git-credential-ignis.sh").toAbsolutePath();
         for (String request : java.util.List.of(
-                "protocol=https\nhost=evil.example\npath=dmg/spigot-ignis.git\n\n",
-                "protocol=http\nhost=git.garvis.dev\npath=dmg/spigot-ignis.git\n\n",
+                "protocol=https\nhost=evil.example\npath=dmg/purpur-ignis.git\n\n",
+                "protocol=http\nhost=git.garvis.dev\npath=dmg/purpur-ignis.git\n\n",
+                "protocol=https\nhost=git.garvis.dev\npath=dmg/spigot-ignis.git\n\n",
                 "protocol=https\nhost=git.garvis.dev\npath=dmg/other.git\n\n")) {
             var builder = new ProcessBuilder("sh", helper.toString(), "get");
             builder.environment().put("IGNIS_RELEASE_TOKEN", "synthetic-test-token");
@@ -38,7 +39,7 @@ class ReleaseCredentialTest {
         builder.environment().put("GIT_TERMINAL_PROMPT", "0");
         Process process = builder.start();
         try (var input = process.getOutputStream()) {
-            input.write("protocol=https\nhost=git.garvis.dev\npath=dmg/spigot-ignis.git\n\n".getBytes(StandardCharsets.UTF_8));
+            input.write("protocol=https\nhost=git.garvis.dev\npath=dmg/purpur-ignis.git\n\n".getBytes(StandardCharsets.UTF_8));
         }
         assertTrue(process.waitFor(3, TimeUnit.SECONDS));
         assertEquals(0, process.exitValue());

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

@@ -12,7 +12,9 @@ class ReleaseWorkflowTest {
         Path path = Path.of(".gitea/workflows/release.yml");
         assertTrue(Files.exists(path), "Release workflow must exist");
         String workflow = Files.readString(path);
-        assertTrue(workflow.contains("spigot-ignis-${VERSION}.jar"));
+        assertTrue(workflow.contains("purpur-ignis-${VERSION}.jar"));
+        assertEquals(2, workflow.split("test \\\"\\$REPOSITORY\\\" = 'dmg/purpur-ignis'", -1).length - 1);
+        assertFalse(workflow.contains("dmg/spigot-ignis"));
         assertTrue(workflow.contains("--header @-"));
         assertTrue(workflow.contains("git-credential-ignis.sh"));
         assertTrue(workflow.contains("credential.useHttpPath true"));

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

@@ -0,0 +1,26 @@
+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 TradableRewardsTest {
+    @Test
+    void daggerRequiresBothUnlocksAndMatchingTrackReceiptAndResetGeneration() {
+        var rewards = new TradableRewards(Track.DAGGER);
+        UUID issuer = UUID.randomUUID(), holder = UUID.randomUUID(), receipt = UUID.randomUUID();
+        var token = new ItemToken(issuer, receipt, 0);
+        var empty = IgnisState.empty();
+        assertThrows(IllegalArgumentException.class, () -> rewards.issue(empty, issuer, receipt, false));
+        var issued = rewards.issue(empty, issuer, receipt, true);
+        assertTrue(rewards.valid(issued, issuer, token));
+        assertFalse(rewards.valid(issued, holder, token));
+        var holderUnlocked = ProgressAdministration.progress(issued, holder, Track.DAGGER, 313, false);
+        assertTrue(rewards.valid(holderUnlocked, holder, token));
+        assertFalse(new TradableRewards(Track.MASK).valid(holderUnlocked, holder, token));
+        var reset = ProgressAdministration.reset(holderUnlocked, issuer, Set.of(Track.DAGGER));
+        var earnedAgain = ProgressAdministration.progress(reset, issuer, Track.DAGGER, 313, false);
+        assertFalse(rewards.valid(earnedAgain, holder, token));
+    }
+}

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

@@ -5,6 +5,42 @@ import java.util.UUID;
 import org.junit.jupiter.api.Test;
 
 class VoidTrialTest {
+    @Test
+    void inspectionIsImmutableAndDoesNotChangeChallengeCompletion() {
+        var trial = new VoidTrial();
+        UUID player = UUID.randomUUID(), world = UUID.randomUUID();
+        assertTrue(trial.snapshot(player).isEmpty());
+        trial.damaged(player, world, -65);
+        assertTrue(trial.snapshot(player).isPresent(), "Active attempt must be inspectable");
+        var initial = trial.snapshot(player).orElseThrow();
+        assertEquals(world, initial.world());
+        assertEquals(-65, initial.damageHeight());
+        assertFalse(initial.escaped());
+        assertEquals(initial, trial.snapshot(player).orElseThrow());
+        trial.moved(player, world, 20, false, false, false);
+        assertFalse(trial.snapshot(player).orElseThrow().escaped());
+        trial.moved(player, world, 20, true, false, false);
+        assertTrue(trial.snapshot(player).orElseThrow().escaped());
+        assertFalse(initial.escaped(), "A returned snapshot must not change after later events");
+        assertTrue(trial.moved(player, world, 60, false, true, true));
+        assertTrue(trial.snapshot(player).isEmpty());
+        assertFalse(trial.moved(player, world, 60, false, true, true));
+    }
+
+    @Test
+    void inspectionClearsAfterCancellationWorldChangeAndRestart() {
+        var trial = new VoidTrial();
+        UUID player = UUID.randomUUID(), world = UUID.randomUUID();
+        trial.damaged(player, world, -65);
+        trial.cancel(player);
+        assertTrue(trial.snapshot(player).isEmpty());
+        trial.damaged(player, world, -65);
+        trial.moved(player, UUID.randomUUID(), 60, true, false, false);
+        assertTrue(trial.snapshot(player).isEmpty());
+        trial.damaged(player, world, -65);
+        assertTrue(new VoidTrial().snapshot(player).isEmpty());
+    }
+
     @Test
     void requiresDamageAscentWhileGlidingAndFirstLandingOnEndStone() {
         var trial = new VoidTrial();