feat(abilities): add chain lightning

.gitea/workflows/release.yml

@@ -96,9 +96,11 @@ jobs:
         uses: actions/upload-artifact@ff15f0306b3f739f7b6fd43fb5d26cd321bd4de5 # v3
         with:
           name: purpur-fantasy-stick-${{ steps.release.outputs.version }}
-          path: build/libs/purpur-fantasy-stick-${{ steps.release.outputs.version }}.jar
+          path: |
+            build/libs/purpur-fantasy-stick-${{ steps.release.outputs.version }}.jar
+            build/distributions/purpur-fantasy-stick-${{ steps.release.outputs.version }}-resource-pack.zip
           if-no-files-found: error
-      - name: Publish verified JAR through a draft release
+      - name: Publish verified JAR and resource pack through a draft release
         if: steps.release.outputs.created == 'true'
         env:
           RELEASE_CREDENTIAL: ${{ secrets.RELEASE_TOKEN }}

build.gradle.kts

@@ -1,5 +1,6 @@
 import java.net.URI
 import java.security.MessageDigest
+import org.gradle.api.tasks.bundling.Zip
 
 plugins {
     java
@@ -7,6 +8,7 @@ plugins {
 
 group = "games.dmg"
 version = providers.gradleProperty("releaseVersion").orElse("0.1.0-SNAPSHOT").get()
+val pluginVersion = version.toString()
 
 repositories {
     mavenCentral()
@@ -33,11 +35,43 @@ dependencies {
     testRuntimeOnly("org.junit.platform:junit-platform-launcher")
 }
 
+val resourcePackInput = layout.buildDirectory.dir("generated/resource-pack-input")
+val prepareResourcePack = tasks.register<Copy>("prepareResourcePack") {
+    from("src/resourcePack")
+    into(resourcePackInput)
+    filesMatching("pack.mcmeta") { expand("version" to pluginVersion) }
+}
+val sheetResourcePack = tasks.register<Zip>("sheetResourcePack") {
+    dependsOn(prepareResourcePack)
+    from(resourcePackInput)
+    archiveFileName.set("purpur-fantasy-stick-$pluginVersion-resource-pack.zip")
+    destinationDirectory.set(layout.buildDirectory.dir("distributions"))
+    isPreserveFileTimestamps = false
+    isReproducibleFileOrder = true
+}
+val resourcePackMetadata = layout.buildDirectory.dir("generated/resource-pack-metadata")
+val generateResourcePackMetadata = tasks.register("generateResourcePackMetadata") {
+    dependsOn(sheetResourcePack)
+    inputs.file(sheetResourcePack.flatMap { it.archiveFile })
+    inputs.property("pluginVersion", pluginVersion)
+    outputs.file(resourcePackMetadata.map { it.file("sheet-resource-pack.properties") })
+    doLast {
+        val pack = sheetResourcePack.get().archiveFile.get().asFile
+        val sha1 = MessageDigest.getInstance("SHA-1").digest(pack.readBytes()).joinToString("") { "%02x".format(it) }
+        val version = pluginVersion
+        val output = resourcePackMetadata.get().file("sheet-resource-pack.properties").asFile
+        output.parentFile.mkdirs()
+        output.writeText("url=https://git.garvis.dev/dmg/purpur-fantasy-stick/releases/download/v$version/purpur-fantasy-stick-$version-resource-pack.zip\nsha1=$sha1\n")
+    }
+}
+sourceSets.main.get().resources.srcDir(resourcePackMetadata)
+
 tasks.test {
     useJUnitPlatform()
-    dependsOn(tasks.jar)
+    dependsOn(tasks.jar, sheetResourcePack)
     systemProperty("distribution.jar", tasks.jar.get().archiveFile.get().asFile.absolutePath)
-    systemProperty("distribution.version", project.version.toString())
+    systemProperty("distribution.version", pluginVersion)
+    systemProperty("resource.pack.zip", sheetResourcePack.get().archiveFile.get().asFile.absolutePath)
 }
 
 // Patch the exact supported runtime for non-listening native API tests, as in Purpur Base.
@@ -88,13 +122,14 @@ nativeTest.compileClasspath += sourceSets.main.get().output + nativeRuntimeJars
 nativeTest.runtimeClasspath += sourceSets.main.get().output + nativeRuntimeJars
 val nativeCompatibilityTest = tasks.register<Test>("nativeCompatibilityTest") {
     description = "Verifies packaged metadata and native item serialization without starting a server"
-    dependsOn(tasks.jar)
+    dependsOn(tasks.jar, sheetResourcePack)
     testClassesDirs = nativeTest.output.classesDirs
     classpath = nativeTest.runtimeClasspath
     useJUnitPlatform()
     maxHeapSize = "1G"
     workingDir(nativeRuntime)
     systemProperty("distribution.jar", tasks.jar.get().archiveFile.get().asFile.absolutePath)
+    systemProperty("resource.pack.zip", sheetResourcePack.get().archiveFile.get().asFile.absolutePath)
 }
 val installReleaseTools = tasks.register<Exec>("installReleaseTools") {
     commandLine("npm", "ci", "--ignore-scripts", "--no-audit", "--no-fund")
@@ -105,9 +140,8 @@ val releaseToolCheck = tasks.register<Exec>("releaseToolCheck") {
 }
 tasks.check { dependsOn(nativeCompatibilityTest, releaseToolCheck) }
 
-val pluginVersion = version
-
 tasks.processResources {
+    dependsOn(generateResourcePackMetadata)
     inputs.property("pluginVersion", pluginVersion)
     filesMatching("plugin.yml") {
         expand("version" to pluginVersion)

scripts/publish-release.ts

@@ -9,8 +9,9 @@ try {
   if (!/^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)$/.test(version)
       || !credential || !/^[a-f0-9]{40}$/.test(commit)) throw new Error("Invalid input");
   const jar = await readFile(`build/libs/purpur-fantasy-stick-${version}.jar`);
+  const resourcePack = await readFile(`build/distributions/purpur-fantasy-stick-${version}-resource-pack.zip`);
   await publishRelease({
-    credential, version, commit, jar,
+    credential, version, commit, jar, resourcePack,
     notes: process.env.RELEASE_NOTES ?? "See the source history for changes.",
   }, fetch);
   console.log(`Published purpur-fantasy-stick v${version}.`);

scripts/release-client.test.ts

@@ -8,12 +8,15 @@ const input: ReleaseInput = {
   commit: "a".repeat(40),
   notes: "Verified changes",
   jar: new Uint8Array([0x50, 0x4b, 0x03, 0x04]),
+  resourcePack: new Uint8Array([0x50, 0x4b, 0x03, 0x05]),
 };
 
-function success(init: RequestInit): Response {
+function success(init: RequestInit, url = ""): Response {
+  const pack = url.includes("resource-pack.zip");
   return Response.json({
     id: 42, draft: init.method !== "PATCH", tag_name: "v1.2.3",
-    name: "purpur-fantasy-stick-1.2.3.jar", size: input.jar.length,
+    name: pack ? "purpur-fantasy-stick-1.2.3-resource-pack.zip" : "purpur-fantasy-stick-1.2.3.jar",
+    size: pack ? input.resourcePack.length : input.jar.length,
   });
 }
 
@@ -21,7 +24,7 @@ test("creates a draft on the fixed repository and exact source commit, without f
   const calls: { url: string; init: RequestInit }[] = [];
   const id = await publishRelease(input, async (url, init) => {
     calls.push({ url, init });
-    return success(init);
+    return success(init, url);
   });
   assert.ok(calls.length >= 1);
   const first = calls[0]!;
@@ -40,17 +43,21 @@ test("uploads the exact versioned bytes before publishing the draft", async () =
   const calls: { url: string; init: RequestInit }[] = [];
   await publishRelease(input, async (url, init) => {
     calls.push({ url, init });
-    return success(init);
+    return success(init, url);
   });
-  assert.equal(calls.length, 3);
+  assert.equal(calls.length, 4);
   assert.equal(calls[1]!.url,
     "https://git.garvis.dev/api/v1/repos/dmg/purpur-fantasy-stick/releases/42/assets?name=purpur-fantasy-stick-1.2.3.jar");
   assert.equal(calls[1]!.init.method, "POST");
   assert.deepEqual(new Uint8Array(await new Response(calls[1]!.init.body).arrayBuffer()), input.jar);
   assert.equal(new Headers(calls[1]!.init.headers).get("content-type"), "application/octet-stream");
-  assert.equal(calls[2]!.init.method, "PATCH");
-  assert.equal(calls[2]!.url, "https://git.garvis.dev/api/v1/repos/dmg/purpur-fantasy-stick/releases/42");
-  assert.deepEqual(JSON.parse(String(calls[2]!.init.body)), { draft: false });
+  assert.equal(calls[2]!.url,
+    "https://git.garvis.dev/api/v1/repos/dmg/purpur-fantasy-stick/releases/42/assets?name=purpur-fantasy-stick-1.2.3-resource-pack.zip");
+  assert.equal(calls[2]!.init.method, "POST");
+  assert.deepEqual(new Uint8Array(await new Response(calls[2]!.init.body).arrayBuffer()), input.resourcePack);
+  assert.equal(calls[3]!.init.method, "PATCH");
+  assert.equal(calls[3]!.url, "https://git.garvis.dev/api/v1/repos/dmg/purpur-fantasy-stick/releases/42");
+  assert.deepEqual(JSON.parse(String(calls[3]!.init.body)), { draft: false });
   for (const call of calls) {
     assert.equal(call.init.redirect, "error");
     assert.equal(new Headers(call.init.headers).get("authorization"), `token ${input.credential}`);
@@ -58,14 +65,14 @@ test("uploads the exact versioned bytes before publishing the draft", async () =
   }
 });
 
-for (const failureStep of [1, 2, 3]) {
+for (const failureStep of [1, 2, 3, 4]) {
   for (const status of [302, 401, 409, 500]) {
     test(`stops at step ${failureStep} on HTTP ${status} without leaking API error bodies`, async () => {
       let calls = 0;
       await assert.rejects(publishRelease(input, async (_url, init) => {
         calls++;
         if (calls === failureStep) return new Response(input.credential, { status });
-        return success(init);
+        return success(init, _url);
       }), (error: unknown) => {
         assert.ok(error instanceof Error);
         assert.ok(error.message.includes(String(status)));
@@ -85,7 +92,7 @@ test("sanitizes transport errors and does not follow a redirect with the credent
 
 for (const invalid of [
   { credential: "" }, { credential: "header\r\ninjection" }, { version: "../../latest" },
-  { version: "1.0.0-SNAPSHOT" }, { commit: "main" }, { jar: new Uint8Array() },
+  { version: "1.0.0-SNAPSHOT" }, { commit: "main" }, { jar: new Uint8Array() }, { resourcePack: new Uint8Array() },
 ]) {
   test(`rejects invalid ${Object.keys(invalid)[0]} before any network request`, async () => {
     let calls = 0;
@@ -112,16 +119,18 @@ for (const body of ["not JSON", "null", JSON.stringify({ id: -1 }), JSON.stringi
 for (const [failureStep, body] of [
   [2, {}], [2, { name: "other.jar", size: 4 }],
   [2, { name: "purpur-fantasy-stick-1.2.3.jar", size: 0 }],
-  [3, { id: 42, draft: true, tag_name: "v1.2.3" }],
-  [3, { id: 77, draft: false, tag_name: "v1.2.3" }],
-  [3, { id: 42, draft: false, tag_name: "v8.8.8" }],
+  [3, {}], [3, { name: "other.zip", size: 4 }],
+  [3, { name: "purpur-fantasy-stick-1.2.3-resource-pack.zip", size: 0 }],
+  [4, { id: 42, draft: true, tag_name: "v1.2.3" }],
+  [4, { id: 77, draft: false, tag_name: "v1.2.3" }],
+  [4, { id: 42, draft: false, tag_name: "v8.8.8" }],
 ] as const) {
   test(`requires a matching asset and completed publication: ${JSON.stringify(body)}`, async () => {
     let calls = 0;
     await assert.rejects(publishRelease(input, async (_url, init) => {
       calls++;
-      return calls === failureStep ? Response.json(body) : success(init);
-    }), { message: failureStep === 2 ? "Invalid release asset response." : "Invalid published release response." });
+      return calls === failureStep ? Response.json(body) : success(init, _url);
+    }), { message: failureStep === 2 || failureStep === 3 ? "Invalid release asset response." : "Invalid published release response." });
     assert.equal(calls, failureStep);
   });
 }

scripts/release-client.ts

@@ -4,6 +4,7 @@ export interface ReleaseInput {
   commit: string;
   notes: string;
   jar: Uint8Array;
+  resourcePack: Uint8Array;
 }
 
 export type Request = (url: string, init: RequestInit) => Promise<Response>;
@@ -13,7 +14,7 @@ const releases = "https://git.garvis.dev/api/v1/repos/dmg/purpur-fantasy-stick/r
 export async function publishRelease(input: ReleaseInput, request: Request): Promise<number> {
   if (!/^[\x21-\x7e]+$/.test(input.credential)
       || !/^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)$/.test(input.version)
-      || !/^[a-f0-9]{40}$/.test(input.commit) || input.jar.length === 0) {
+      || !/^[a-f0-9]{40}$/.test(input.commit) || input.jar.length === 0 || input.resourcePack.length === 0) {
     throw new Error("Invalid release input.");
   }
   const send: Request = async (url, init) => {
@@ -49,6 +50,16 @@ export async function publishRelease(input: ReleaseInput, request: Request): Pro
   if (asset.name !== `purpur-fantasy-stick-${input.version}.jar` || asset.size !== input.jar.length) {
     throw new Error("Invalid release asset response.");
   }
+  const packName = `purpur-fantasy-stick-${input.version}-resource-pack.zip`;
+  const packResponse = await send(`${releases}/${release.id}/assets?name=${packName}`, {
+    method: "POST", redirect: "error",
+    headers: { authorization: `token ${input.credential}`, "content-type": "application/octet-stream" },
+    body: new Uint8Array(input.resourcePack).buffer,
+  });
+  const pack = await readObject(packResponse, "Invalid release asset response.");
+  if (pack.name !== packName || pack.size !== input.resourcePack.length) {
+    throw new Error("Invalid release asset response.");
+  }
   const publishedResponse = await send(`${releases}/${release.id}`, {
     method: "PATCH", redirect: "error",
     headers: { authorization: `token ${input.credential}`, "content-type": "application/json" },

src/main/java/games/dmg/fantasystick/FantasyStickPlugin.java

@@ -9,6 +9,7 @@ import games.dmg.fantasystick.crafting.CharacterAnvilNames;
 import games.dmg.fantasystick.crafting.ManualCraftingController;
 import games.dmg.fantasystick.crafting.ManualCraftingGuard;
 import games.dmg.fantasystick.crafting.PlayerSheetDrops;
+import games.dmg.fantasystick.crafting.RecipeDiscovery;
 import games.dmg.fantasystick.items.CharacterSheets;
 import games.dmg.fantasystick.persistence.CharacterStorage;
 import games.dmg.fantasystick.persistence.EquipmentSessionStore;
@@ -18,6 +19,7 @@ import games.dmg.fantasystick.session.EquipmentSessions;
 import games.dmg.fantasystick.persistence.YamlCharacterRepository;
 import games.dmg.fantasystick.progression.ProgressionRules;
 import java.time.Clock;
+import java.util.List;
 import java.util.logging.Level;
 import org.bukkit.plugin.java.JavaPlugin;
 
@@ -27,6 +29,7 @@ public final class FantasyStickPlugin extends JavaPlugin {
     private ManualCraftingController crafting;
     private ManualCraftingGuard guard;
     private CharacterAnvilNames anvilNames;
+    private RecipeDiscovery recipeDiscovery;
     private boolean recipeRegistered;
     private EquipmentSessionStore receipts;
     private EquipmentSessions sessions;
@@ -55,9 +58,42 @@ public final class FantasyStickPlugin extends JavaPlugin {
     private games.dmg.fantasystick.persistence.LongbowSettings longbowSettings;
     private games.dmg.fantasystick.ability.Quickstep quickstep;
     private games.dmg.fantasystick.persistence.QuickstepSettings quickstepSettings;
+    private games.dmg.fantasystick.ability.SecondWind secondWind;
+    private games.dmg.fantasystick.persistence.SecondWindSettings secondWindSettings;
+    private games.dmg.fantasystick.ability.CombatMitigation combatMitigation;
+    private games.dmg.fantasystick.ability.StoneSkin stoneSkin;
+    private games.dmg.fantasystick.ability.ShieldBash shieldBash;
+    private games.dmg.fantasystick.ability.OutgoingDamageMitigation outgoingDamageMitigation;
+    private games.dmg.fantasystick.ability.Hex hex;
+    private games.dmg.fantasystick.ability.TemporaryHealth temporaryHealth;
+    private games.dmg.fantasystick.ability.Inspire inspire;
+    private games.dmg.fantasystick.persistence.InspireSettings inspireSettings;
+    private games.dmg.fantasystick.ability.MendingLight mendingLight;
+    private games.dmg.fantasystick.persistence.MendingLightSettings mendingLightSettings;
+    private games.dmg.fantasystick.ability.Purify purify;
+    private games.dmg.fantasystick.persistence.PurifySettings purifySettings;
+    private games.dmg.fantasystick.ability.GuardianBond guardianBond;
+    private games.dmg.fantasystick.persistence.GuardianBondSettings guardianBondSettings;
+    private games.dmg.fantasystick.ability.OutgoingDamageBonus outgoingDamageBonus;
+    private games.dmg.fantasystick.ability.RallyingCry rallyingCry;
+    private games.dmg.fantasystick.persistence.RallyingCrySettings rallyingCrySettings;
+    private games.dmg.fantasystick.ability.FrostNova frostNova;
+    private games.dmg.fantasystick.persistence.FrostNovaSettings frostNovaSettings;
+    private games.dmg.fantasystick.ability.ChainLightning chainLightning;
+    private games.dmg.fantasystick.persistence.ChainLightningSettings chainLightningSettings;
+    private games.dmg.fantasystick.persistence.HexSettings hexSettings;
+    private games.dmg.fantasystick.persistence.ShieldBashSettings shieldBashSettings;
+    private games.dmg.fantasystick.persistence.StoneSkinSettings stoneSkinSettings;
     private games.dmg.fantasystick.ability.GreatSword greatSword;
     private games.dmg.fantasystick.ability.Revive revive;
     private games.dmg.fantasystick.persistence.RevivalStore revivals;
+    private games.dmg.fantasystick.session.AdminRevival adminRevival;
+    private games.dmg.fantasystick.persistence.AdminReviveSettings adminReviveSettings;
+    private games.dmg.fantasystick.persistence.SwitchDelaySettings switchDelaySettings;
+    private games.dmg.fantasystick.persistence.RoleplaySettings roleplaySettings;
+    private games.dmg.fantasystick.persistence.PartySettings partySettings;
+    private games.dmg.fantasystick.persistence.SheetResourcePackSettings sheetResourcePackSettings;
+    private games.dmg.fantasystick.presentation.SheetResourcePack sheetResourcePack;
     private games.dmg.fantasystick.session.NutritionPolicy nutritionPolicy;
     private java.util.concurrent.CompletionStage<Void> configurationDrain = java.util.concurrent.CompletableFuture.completedStage(null);
 
@@ -81,7 +117,16 @@ public final class FantasyStickPlugin extends JavaPlugin {
             reloadConfig();
             var adventure = games.dmg.fantasystick.persistence.AdventureSettings.validate(getConfig().get("adventure-mode"));
             adventureSettings = new games.dmg.fantasystick.persistence.AdventureSettings(getDataFolder().toPath(), adventure);
-            var switchDelay = switchDelay();
+            var switchDelay = games.dmg.fantasystick.persistence.SwitchDelaySettings.parse(
+                getConfig().get(games.dmg.fantasystick.persistence.SwitchDelaySettings.KEY));
+            var roleplayDisabled = games.dmg.fantasystick.persistence.RoleplaySettings.parse(
+                getConfig().get(games.dmg.fantasystick.persistence.RoleplaySettings.KEY));
+            var partyMaximum = games.dmg.fantasystick.persistence.PartySettings.parse(
+                getConfig().get(games.dmg.fantasystick.persistence.PartySettings.KEY));
+            var sheetPackDefaults = games.dmg.fantasystick.persistence.SheetResourcePackSettings.packagedDefaults();
+            sheetResourcePackSettings = new games.dmg.fantasystick.persistence.SheetResourcePackSettings(getDataFolder().toPath(),
+                getConfig().get(games.dmg.fantasystick.persistence.SheetResourcePackSettings.URL_KEY),
+                getConfig().get(games.dmg.fantasystick.persistence.SheetResourcePackSettings.SHA1_KEY), sheetPackDefaults);
             var rules = progressionRules();
             var rewardRules = combatRewardRules();
             var fireballSettings = fireballSettings();
@@ -92,6 +137,30 @@ public final class FantasyStickPlugin extends JavaPlugin {
             var longbowInitial = games.dmg.fantasystick.persistence.LongbowSettings.parse(longbowConfiguration);
             var quickstepConfiguration = quickstepConfiguration();
             var quickstepInitial = games.dmg.fantasystick.persistence.QuickstepSettings.parse(quickstepConfiguration);
+            var secondWindConfiguration = secondWindConfiguration();
+            var secondWindInitial = games.dmg.fantasystick.persistence.SecondWindSettings.parse(secondWindConfiguration);
+            var stoneSkinConfiguration = stoneSkinConfiguration();
+            var stoneSkinInitial = games.dmg.fantasystick.persistence.StoneSkinSettings.parse(stoneSkinConfiguration);
+            var shieldBashConfiguration = shieldBashConfiguration();
+            var shieldBashInitial = games.dmg.fantasystick.persistence.ShieldBashSettings.parse(shieldBashConfiguration);
+            var hexConfiguration = hexConfiguration();
+            var hexInitial = games.dmg.fantasystick.persistence.HexSettings.parse(hexConfiguration);
+            var inspireConfiguration = inspireConfiguration();
+            var inspireInitial = games.dmg.fantasystick.persistence.InspireSettings.parse(inspireConfiguration);
+            var mendingLightConfiguration = mendingLightConfiguration();
+            var mendingLightInitial = games.dmg.fantasystick.persistence.MendingLightSettings.parse(mendingLightConfiguration);
+            var purifyConfiguration = purifyConfiguration();
+            var purifyInitial = games.dmg.fantasystick.persistence.PurifySettings.parse(purifyConfiguration);
+            var guardianBondConfiguration = guardianBondConfiguration();
+            var guardianBondInitial = games.dmg.fantasystick.persistence.GuardianBondSettings.parse(guardianBondConfiguration);
+            var rallyingCryConfiguration = rallyingCryConfiguration();
+            var rallyingCryInitial = games.dmg.fantasystick.persistence.RallyingCrySettings.parse(rallyingCryConfiguration);
+            var frostNovaConfiguration = frostNovaConfiguration();
+            var frostNovaInitial = games.dmg.fantasystick.persistence.FrostNovaSettings.parse(frostNovaConfiguration);
+            var chainLightningConfiguration = chainLightningConfiguration();
+            var chainLightningInitial = games.dmg.fantasystick.persistence.ChainLightningSettings.parse(chainLightningConfiguration);
+            var adminReviveTimeout = games.dmg.fantasystick.persistence.AdminReviveSettings.parse(
+                getConfig().get(games.dmg.fantasystick.persistence.AdminReviveSettings.KEY));
             var factory = new CharacterFactory();
             characters = new CharacterStorage(new YamlCharacterRepository(getDataFolder().toPath()), Clock.systemUTC());
             crafting = new ManualCraftingController(characters, () -> factory.create(rules),
@@ -128,8 +197,24 @@ public final class FantasyStickPlugin extends JavaPlugin {
                 getLogger().log(Level.WARNING, "Equipment transition/recovery for player " + problem.player()
                     + "; session " + problem.session(), problem.cause());
             gameModes = new games.dmg.fantasystick.session.AdventureModeLease();
+            switchDelaySettings = new games.dmg.fantasystick.persistence.SwitchDelaySettings(getDataFolder().toPath(), switchDelay);
+            roleplaySettings = new games.dmg.fantasystick.persistence.RoleplaySettings(getDataFolder().toPath(), roleplayDisabled);
+            partySettings = new games.dmg.fantasystick.persistence.PartySettings(getDataFolder().toPath(), partyMaximum);
+            sheetResourcePack = new games.dmg.fantasystick.presentation.SheetResourcePack(sheetResourcePackSettings,
+                (player, failure) -> getLogger().log(Level.WARNING, "Sheet resource-pack delivery failed for " + player, failure));
             sessions = new EquipmentSessions(characters, receipts, switchDelay, Clock.systemUTC(), nextTick,
                 notice -> notifyPlayer(generation, notice), diagnostics, presentation, adventureSettings::enabled, gameModes);
+            sessions.attachSwitchDelay(switchDelaySettings::delay);
+            sessions.attachRoleplayDisabled(roleplaySettings::disabled);
+            parties = new games.dmg.fantasystick.party.PartyRoster(Clock.systemUTC(), id -> {
+                var player = getServer().getPlayer(id);
+                return player != null && player.isOnline();
+            }, partySettings::maximum);
+            partyEvents = new games.dmg.fantasystick.party.PartyEvents(parties);
+            partyCombat = new games.dmg.fantasystick.party.PartyCombat(parties, sessions);
+            combatExperience = new games.dmg.fantasystick.party.CombatExperience(characters, rules, rewardRules,
+                sessions, Clock.systemUTC(), nextTick, id -> getServer().getPlayer(id),
+                problem -> getLogger().log(Level.WARNING, "Combat reward failed for character " + problem.character(), problem.cause()));
             abilityRegistry = new games.dmg.fantasystick.ability.AbilityRegistry();
             fireball = new games.dmg.fantasystick.ability.Fireball(fireballSettings);
             frostShardSettings = new games.dmg.fantasystick.persistence.FrostShardSettings(
@@ -142,6 +227,52 @@ public final class FantasyStickPlugin extends JavaPlugin {
                 getDataFolder().toPath(), quickstepConfiguration);
             quickstep = new games.dmg.fantasystick.ability.Quickstep(quickstepInitial,
                 event -> getServer().getPluginManager().callEvent(event));
+            secondWindSettings = new games.dmg.fantasystick.persistence.SecondWindSettings(
+                getDataFolder().toPath(), secondWindConfiguration);
+            secondWind = new games.dmg.fantasystick.ability.SecondWind(secondWindInitial, characters, sessions, nextTick,
+                event -> getServer().getPluginManager().callEvent(event), games.dmg.fantasystick.session.NativeHealthLimit::read);
+            stoneSkinSettings = new games.dmg.fantasystick.persistence.StoneSkinSettings(
+                getDataFolder().toPath(), stoneSkinConfiguration);
+            combatMitigation = new games.dmg.fantasystick.ability.CombatMitigation();
+            stoneSkin = new games.dmg.fantasystick.ability.StoneSkin(stoneSkinInitial, combatMitigation);
+            shieldBashSettings = new games.dmg.fantasystick.persistence.ShieldBashSettings(
+                getDataFolder().toPath(), shieldBashConfiguration);
+            shieldBash = new games.dmg.fantasystick.ability.ShieldBash(
+                shieldBashInitial,
+                event -> getServer().getPluginManager().callEvent(event));
+            outgoingDamageMitigation = new games.dmg.fantasystick.ability.OutgoingDamageMitigation(sessions, parties,
+                support -> combatExperience.support(support.target(), support.supportingCharacter(), support.aided(), support.amount()));
+            hexSettings = new games.dmg.fantasystick.persistence.HexSettings(getDataFolder().toPath(), hexConfiguration);
+            hex = new games.dmg.fantasystick.ability.Hex(hexInitial, outgoingDamageMitigation);
+            temporaryHealth = new games.dmg.fantasystick.ability.TemporaryHealth(sessions, parties, nextTick,
+                support -> combatExperience.support(support.target(), support.supportingCharacter(), support.aided(), support.amount()));
+            inspireSettings = new games.dmg.fantasystick.persistence.InspireSettings(getDataFolder().toPath(), inspireConfiguration);
+            inspire = new games.dmg.fantasystick.ability.Inspire(inspireInitial, temporaryHealth);
+            mendingLightSettings = new games.dmg.fantasystick.persistence.MendingLightSettings(
+                getDataFolder().toPath(), mendingLightConfiguration);
+            mendingLight = new games.dmg.fantasystick.ability.MendingLight(mendingLightInitial, characters, sessions, parties,
+                nextTick, event -> getServer().getPluginManager().callEvent(event),
+                games.dmg.fantasystick.session.NativeHealthLimit::read,
+                support -> combatExperience.support(support.supportingCharacter(), support.aided(), support.amount()));
+            purifySettings = new games.dmg.fantasystick.persistence.PurifySettings(getDataFolder().toPath(), purifyConfiguration);
+            purify = new games.dmg.fantasystick.ability.Purify(purifyInitial, sessions, parties,
+                support -> combatExperience.support(support.supportingCharacter(), support.aided(), support.amount()));
+            guardianBondSettings = new games.dmg.fantasystick.persistence.GuardianBondSettings(
+                getDataFolder().toPath(), guardianBondConfiguration);
+            guardianBond = new games.dmg.fantasystick.ability.GuardianBond(guardianBondInitial, sessions, parties,
+                support -> combatExperience.support(support.target(), support.supportingCharacter(), support.aided(), support.amount()));
+            outgoingDamageBonus = new games.dmg.fantasystick.ability.OutgoingDamageBonus(sessions, parties,
+                support -> combatExperience.support(support.target(), support.supportingCharacter(), support.aided(), support.amount()));
+            rallyingCrySettings = new games.dmg.fantasystick.persistence.RallyingCrySettings(
+                getDataFolder().toPath(), rallyingCryConfiguration);
+            rallyingCry = new games.dmg.fantasystick.ability.RallyingCry(
+                rallyingCryInitial, sessions, parties, outgoingDamageBonus);
+            frostNovaSettings = new games.dmg.fantasystick.persistence.FrostNovaSettings(
+                getDataFolder().toPath(), frostNovaConfiguration);
+            frostNova = new games.dmg.fantasystick.ability.FrostNova(frostNovaInitial, sessions, parties);
+            chainLightningSettings = new games.dmg.fantasystick.persistence.ChainLightningSettings(
+                getDataFolder().toPath(), chainLightningConfiguration);
+            chainLightning = new games.dmg.fantasystick.ability.ChainLightning(chainLightningInitial, sessions, parties);
             greatSword = new games.dmg.fantasystick.ability.GreatSword(greatSwordSettings);
             revivals = new games.dmg.fantasystick.persistence.RevivalStore(getDataFolder().toPath());
             revive = new games.dmg.fantasystick.ability.Revive(characters, revivals, Clock.systemUTC(), nextTick,
@@ -151,26 +282,32 @@ public final class FantasyStickPlugin extends JavaPlugin {
             abilityRegistry.register(frostShard.definition());
             abilityRegistry.register(longbow.definition());
             abilityRegistry.register(quickstep.definition());
+            abilityRegistry.register(secondWind.definition());
+            abilityRegistry.register(stoneSkin.definition());
+            abilityRegistry.register(shieldBash.definition());
+            abilityRegistry.register(hex.definition());
+            abilityRegistry.register(inspire.definition());
+            abilityRegistry.register(mendingLight.definition());
+            abilityRegistry.register(purify.definition());
+            abilityRegistry.register(guardianBond.definition());
+            abilityRegistry.register(rallyingCry.definition());
+            abilityRegistry.register(frostNova.definition());
+            abilityRegistry.register(chainLightning.definition());
             abilityRegistry.register(greatSword.definition());
             abilityRegistry.register(revive.definition());
             sessions.attachAbilityRegistry(abilityRegistry);
             vitals = new games.dmg.fantasystick.session.SessionVitals();
             sessions.attachVitals(vitals);
             nutritionPolicy = new games.dmg.fantasystick.session.NutritionPolicy(sessions);
-            parties = new games.dmg.fantasystick.party.PartyRoster(Clock.systemUTC(), id -> {
-                var player = getServer().getPlayer(id);
-                return player != null && player.isOnline();
-            });
-            partyEvents = new games.dmg.fantasystick.party.PartyEvents(parties);
-            partyCombat = new games.dmg.fantasystick.party.PartyCombat(parties, sessions);
-            combatExperience = new games.dmg.fantasystick.party.CombatExperience(characters, rules, rewardRules,
-                sessions, Clock.systemUTC(), nextTick, id -> getServer().getPlayer(id),
-                problem -> getLogger().log(Level.WARNING, "Combat reward failed for character " + problem.character(), problem.cause()));
             games.dmg.fantasystick.ability.AbilityScheduler abilityScheduler = (delay, action) -> {
                 long ticks = Math.max(1, (delay.toNanos() + 49_999_999L) / 50_000_000L);
                 var task = getServer().getScheduler().runTaskLater(this, action, ticks);
                 return task::cancel;
             };
+            adminReviveSettings = new games.dmg.fantasystick.persistence.AdminReviveSettings(getDataFolder().toPath(), adminReviveTimeout);
+            adminRevival = new games.dmg.fantasystick.session.AdminRevival(characters, revivals, Clock.systemUTC(), nextTick,
+                abilityScheduler::later, (size, title) -> getServer().createInventory(null, size, title),
+                problem -> getLogger().log(Level.WARNING, "Admin revival failed", problem));
             abilityEngine = new games.dmg.fantasystick.ability.AbilityEngine(abilityRegistry, characters, sessions, parties,
                 Clock.systemUTC(), nextTick, abilityScheduler, report -> { },
                 problem -> getLogger().log(Level.WARNING, "Ability engine failed for character " + problem.character()
@@ -195,7 +332,28 @@ public final class FantasyStickPlugin extends JavaPlugin {
                 problem -> getLogger().log(Level.WARNING, "Equipment admin " + problem.operation()
                     + " for player " + problem.player(), problem.cause()), adventureSettings,
                 frostShardSettings, frostShard, longbowSettings, longbow,
-                quickstepSettings, quickstep, abilityRegistry);
+                quickstepSettings, quickstep, secondWindSettings, secondWind,
+                stoneSkinSettings, stoneSkin, shieldBashSettings, shieldBash, hexSettings, hex,
+                inspireSettings, inspire, abilityRegistry);
+            admin.attachMendingLight(mendingLightSettings, mendingLight);
+            admin.attachPurify(purifySettings, purify);
+            admin.attachGuardianBond(guardianBondSettings, guardianBond);
+            admin.attachRallyingCry(rallyingCrySettings, rallyingCry);
+            admin.attachFrostNova(frostNovaSettings, frostNova);
+            admin.attachChainLightning(chainLightningSettings, chainLightning);
+            admin.attachAdminRevival(adminRevival, adminReviveSettings);
+            admin.attachExperienceGrant(new games.dmg.fantasystick.session.AdminExperienceGrant(
+                characters, rules, sessions, nextTick, getServer()::getPlayer,
+                problem -> getLogger().log(Level.WARNING,
+                    "Admin experience grant for character " + problem.character(), problem.cause())));
+            admin.attachSwitchDelay(switchDelaySettings);
+            admin.attachRoleplaySettings(roleplaySettings);
+            admin.attachPartySettings(partySettings);
+            admin.attachSheetResourcePack(sheetResourcePackSettings, sheetResourcePack);
+            admin.attachCharacterIssuer(new games.dmg.fantasystick.session.AdminCharacterIssuer(characters,
+                () -> factory.create(rules), nextTick, problem -> getLogger().log(Level.WARNING,
+                    "Admin character issue " + problem.operation() + " for player " + problem.player()
+                        + "; character " + problem.character(), problem.cause())));
             var command = java.util.Objects.requireNonNull(getCommand("fantasystick"), "Missing packaged fantasystick command");
             command.setExecutor(admin);
             command.setTabCompleter(admin);
@@ -211,20 +369,37 @@ public final class FantasyStickPlugin extends JavaPlugin {
             combatExperience.install(this);
             getServer().getPluginManager().registerEvents(fireball, this);
             getServer().getPluginManager().registerEvents(frostShard, this);
+            getServer().getPluginManager().registerEvents(frostNova, this);
+            getServer().getPluginManager().registerEvents(chainLightning, this);
             getServer().getPluginManager().registerEvents(longbow, this);
             getServer().getPluginManager().registerEvents(quickstep, this);
+            getServer().getPluginManager().registerEvents(combatMitigation, this);
+            getServer().getPluginManager().registerEvents(guardianBond, this);
+            guardianBond.install(this);
+            getServer().getPluginManager().registerEvents(shieldBash, this);
+            getServer().getPluginManager().registerEvents(outgoingDamageMitigation, this);
+            getServer().getPluginManager().registerEvents(outgoingDamageBonus, this);
+            rallyingCry.install(this);
+            getServer().getPluginManager().registerEvents(temporaryHealth, this);
             getServer().getPluginManager().registerEvents(greatSword, this);
             getServer().getPluginManager().registerEvents(revive, this);
+            getServer().getPluginManager().registerEvents(adminRevival, this);
             getServer().getPluginManager().registerEvents(localBasicAttack, this);
             getServer().getPluginManager().registerEvents(nutritionPolicy, this);
             getServer().getPluginManager().registerEvents(books, this);
             getServer().getPluginManager().registerEvents(gameModes, this);
+            getServer().getPluginManager().registerEvents(sheetResourcePack, this);
             sessionVisuals = new games.dmg.fantasystick.session.SessionVisuals(sessions,
                 failure -> getLogger().log(Level.WARNING, "Fantasy session particle delivery failed", failure));
             sessionVisuals.install(this);
             recipeRegistered = getServer().addRecipe(new CharacterSheets().recipe());
             if (!recipeRegistered) throw new IllegalStateException("Character-sheet recipe key is already registered");
-            for (var player : getServer().getOnlinePlayers()) { sessions.arrive(player); revive.reconcile(player); }
+            recipeDiscovery = new RecipeDiscovery(CharacterSheets.RECIPE, getLogger());
+            getServer().getPluginManager().registerEvents(recipeDiscovery, this);
+            var onlinePlayers = List.copyOf(getServer().getOnlinePlayers());
+            recipeDiscovery.discoverAll(onlinePlayers);
+            for (var player : onlinePlayers) { sessions.arrive(player); revive.reconcile(player); }
+            sheetResourcePack.deliverAll(onlinePlayers);
         } catch (RuntimeException | LinkageError failure) {
             try { onDisable(); }
             catch (RuntimeException | LinkageError cleanupFailure) { failure.addSuppressed(cleanupFailure); }
@@ -247,6 +422,7 @@ public final class FantasyStickPlugin extends JavaPlugin {
         var closingCrafting = crafting; crafting = null;
         var closingGuard = guard; guard = null;
         var closingAnvil = anvilNames; anvilNames = null;
+        var closingRecipeDiscovery = recipeDiscovery; recipeDiscovery = null;
         var closingSessions = sessions; sessions = null;
         var closingReceipts = receipts; receipts = null;
         var closingCharacters = characters; characters = null;
@@ -264,6 +440,39 @@ public final class FantasyStickPlugin extends JavaPlugin {
         var closingLongbowSettings = longbowSettings; longbowSettings = null;
         var closingQuickstep = quickstep; quickstep = null;
         var closingQuickstepSettings = quickstepSettings; quickstepSettings = null;
+        secondWind = null;
+        var closingStoneSkin = stoneSkin; stoneSkin = null;
+        var closingShieldBash = shieldBash; shieldBash = null;
+        var closingHex = hex; hex = null;
+        var closingInspire = inspire; inspire = null;
+        var closingInspireSettings = inspireSettings; inspireSettings = null;
+        mendingLight = null;
+        var closingMendingLightSettings = mendingLightSettings; mendingLightSettings = null;
+        purify = null;
+        var closingPurifySettings = purifySettings; purifySettings = null;
+        var closingGuardianBond = guardianBond; guardianBond = null;
+        var closingGuardianBondSettings = guardianBondSettings; guardianBondSettings = null;
+        var closingRallyingCry = rallyingCry; rallyingCry = null;
+        var closingRallyingCrySettings = rallyingCrySettings; rallyingCrySettings = null;
+        var closingFrostNova = frostNova; frostNova = null;
+        var closingFrostNovaSettings = frostNovaSettings; frostNovaSettings = null;
+        var closingChainLightning = chainLightning; chainLightning = null;
+        var closingChainLightningSettings = chainLightningSettings; chainLightningSettings = null;
+        var closingOutgoingDamageBonus = outgoingDamageBonus; outgoingDamageBonus = null;
+        var closingAdminRevival = adminRevival; adminRevival = null;
+        var closingAdminReviveSettings = adminReviveSettings; adminReviveSettings = null;
+        var closingSwitchDelaySettings = switchDelaySettings; switchDelaySettings = null;
+        var closingRoleplaySettings = roleplaySettings; roleplaySettings = null;
+        var closingPartySettings = partySettings; partySettings = null;
+        var closingSheetResourcePackSettings = sheetResourcePackSettings; sheetResourcePackSettings = null;
+        var closingSheetResourcePack = sheetResourcePack; sheetResourcePack = null;
+        var closingTemporaryHealth = temporaryHealth; temporaryHealth = null;
+        var closingHexSettings = hexSettings; hexSettings = null;
+        var closingOutgoingDamageMitigation = outgoingDamageMitigation; outgoingDamageMitigation = null;
+        var closingShieldBashSettings = shieldBashSettings; shieldBashSettings = null;
+        var closingCombatMitigation = combatMitigation; combatMitigation = null;
+        var closingStoneSkinSettings = stoneSkinSettings; stoneSkinSettings = null;
+        var closingSecondWindSettings = secondWindSettings; secondWindSettings = null;
         var closingGreatSword = greatSword; greatSword = null;
         var closingRevive = revive; revive = null;
         var closingRevivals = revivals; revivals = null;
@@ -277,6 +486,28 @@ public final class FantasyStickPlugin extends JavaPlugin {
         if (closingFrostSettings != null) cleanup("Frost Shard configuration", closingFrostSettings::close);
         if (closingLongbowSettings != null) cleanup("Longbow configuration", closingLongbowSettings::close);
         if (closingQuickstepSettings != null) cleanup("Quickstep configuration", closingQuickstepSettings::close);
+        if (closingSecondWindSettings != null) cleanup("Second Wind configuration", closingSecondWindSettings::close);
+        if (closingStoneSkinSettings != null) cleanup("Stone Skin configuration", closingStoneSkinSettings::close);
+        if (closingShieldBashSettings != null) cleanup("Shield Bash configuration", closingShieldBashSettings::close);
+        if (closingHexSettings != null) cleanup("Hex configuration", closingHexSettings::close);
+        if (closingInspireSettings != null) cleanup("Inspire configuration", closingInspireSettings::close);
+        if (closingMendingLightSettings != null) cleanup("Mending Light configuration", closingMendingLightSettings::close);
+        if (closingPurifySettings != null) cleanup("Purify configuration", closingPurifySettings::close);
+        if (closingGuardianBond != null) cleanup("Guardian Bond", closingGuardianBond::close);
+        if (closingGuardianBondSettings != null) cleanup("Guardian Bond configuration", closingGuardianBondSettings::close);
+        if (closingRallyingCry != null) cleanup("Rallying Cry", closingRallyingCry::close);
+        if (closingRallyingCrySettings != null) cleanup("Rallying Cry configuration", closingRallyingCrySettings::close);
+        if (closingFrostNova != null) cleanup("Frost Nova", closingFrostNova::close);
+        if (closingFrostNovaSettings != null) cleanup("Frost Nova configuration", closingFrostNovaSettings::close);
+        if (closingChainLightning != null) cleanup("Chain Lightning", closingChainLightning::close);
+        if (closingChainLightningSettings != null) cleanup("Chain Lightning configuration", closingChainLightningSettings::close);
+        if (closingOutgoingDamageBonus != null) cleanup("outgoing damage bonuses", closingOutgoingDamageBonus::close);
+        if (closingAdminReviveSettings != null) cleanup("admin revival configuration", closingAdminReviveSettings::close);
+        if (closingSwitchDelaySettings != null) cleanup("switch delay configuration", closingSwitchDelaySettings::close);
+        if (closingRoleplaySettings != null) cleanup("roleplay configuration", closingRoleplaySettings::close);
+        if (closingPartySettings != null) cleanup("party configuration", closingPartySettings::close);
+        if (closingSheetResourcePackSettings != null) cleanup("sheet resource-pack configuration", closingSheetResourcePackSettings::close);
+        if (closingSheetResourcePack != null) cleanup("sheet resource-pack", closingSheetResourcePack::close);
         configurationDrain = java.util.concurrent.CompletableFuture.allOf(
             closingSettings == null ? java.util.concurrent.CompletableFuture.completedFuture(null)
                 : closingSettings.drained().toCompletableFuture(),
@@ -285,14 +516,54 @@ public final class FantasyStickPlugin extends JavaPlugin {
             closingLongbowSettings == null ? java.util.concurrent.CompletableFuture.completedFuture(null)
                 : closingLongbowSettings.drained().toCompletableFuture(),
             closingQuickstepSettings == null ? java.util.concurrent.CompletableFuture.completedFuture(null)
-                : closingQuickstepSettings.drained().toCompletableFuture());
+                : closingQuickstepSettings.drained().toCompletableFuture(),
+            closingSecondWindSettings == null ? java.util.concurrent.CompletableFuture.completedFuture(null)
+                : closingSecondWindSettings.drained().toCompletableFuture(),
+            closingStoneSkinSettings == null ? java.util.concurrent.CompletableFuture.completedFuture(null)
+                : closingStoneSkinSettings.drained().toCompletableFuture(),
+            closingShieldBashSettings == null ? java.util.concurrent.CompletableFuture.completedFuture(null)
+                : closingShieldBashSettings.drained().toCompletableFuture(),
+            closingHexSettings == null ? java.util.concurrent.CompletableFuture.completedFuture(null)
+                : closingHexSettings.drained().toCompletableFuture(),
+            closingInspireSettings == null ? java.util.concurrent.CompletableFuture.completedFuture(null)
+                : closingInspireSettings.drained().toCompletableFuture(),
+            closingMendingLightSettings == null ? java.util.concurrent.CompletableFuture.completedFuture(null)
+                : closingMendingLightSettings.drained().toCompletableFuture(),
+            closingPurifySettings == null ? java.util.concurrent.CompletableFuture.completedFuture(null)
+                : closingPurifySettings.drained().toCompletableFuture(),
+            closingGuardianBondSettings == null ? java.util.concurrent.CompletableFuture.completedFuture(null)
+                : closingGuardianBondSettings.drained().toCompletableFuture(),
+            closingRallyingCrySettings == null ? java.util.concurrent.CompletableFuture.completedFuture(null)
+                : closingRallyingCrySettings.drained().toCompletableFuture(),
+            closingFrostNovaSettings == null ? java.util.concurrent.CompletableFuture.completedFuture(null)
+                : closingFrostNovaSettings.drained().toCompletableFuture(),
+            closingChainLightningSettings == null ? java.util.concurrent.CompletableFuture.completedFuture(null)
+                : closingChainLightningSettings.drained().toCompletableFuture(),
+            closingAdminReviveSettings == null ? java.util.concurrent.CompletableFuture.completedFuture(null)
+                : closingAdminReviveSettings.drained().toCompletableFuture(),
+            closingSwitchDelaySettings == null ? java.util.concurrent.CompletableFuture.completedFuture(null)
+                : closingSwitchDelaySettings.drained().toCompletableFuture(),
+            closingRoleplaySettings == null ? java.util.concurrent.CompletableFuture.completedFuture(null)
+                : closingRoleplaySettings.drained().toCompletableFuture(),
+            closingPartySettings == null ? java.util.concurrent.CompletableFuture.completedFuture(null)
+                : closingPartySettings.drained().toCompletableFuture(),
+            closingSheetResourcePackSettings == null ? java.util.concurrent.CompletableFuture.completedFuture(null)
+                : closingSheetResourcePackSettings.drained().toCompletableFuture());
         if (closingBooks != null) cleanup("character book", closingBooks::close);
+        if (closingAdminRevival != null) cleanup("admin revival", closingAdminRevival::close);
         if (closingBasicAttack != null) cleanup("basic attack", closingBasicAttack::close);
         if (closingCombatExperience != null) cleanup("combat experience", closingCombatExperience::close);
         if (closingFireball != null) cleanup("Fireball", closingFireball::close);
         if (closingFrostShard != null) cleanup("Frost Shard", closingFrostShard::close);
         if (closingLongbow != null) cleanup("Longbow", closingLongbow::close);
         if (closingQuickstep != null) cleanup("Quickstep", closingQuickstep::close);
+        if (closingStoneSkin != null) cleanup("Stone Skin", closingStoneSkin::close);
+        if (closingShieldBash != null) cleanup("Shield Bash", closingShieldBash::close);
+        if (closingHex != null) cleanup("Hex", closingHex::close);
+        if (closingInspire != null) cleanup("Inspire", closingInspire::close);
+        if (closingTemporaryHealth != null) cleanup("temporary health", closingTemporaryHealth::close);
+        if (closingOutgoingDamageMitigation != null) cleanup("outgoing damage mitigation", closingOutgoingDamageMitigation::close);
+        if (closingCombatMitigation != null) cleanup("combat mitigation", closingCombatMitigation::close);
         if (closingGreatSword != null) cleanup("Great Sword", closingGreatSword::close);
         if (closingRevive != null) cleanup("Revive", closingRevive::close);
         if (closingAbilityEngine != null) cleanup("ability engine", closingAbilityEngine::close);
@@ -313,8 +584,13 @@ public final class FantasyStickPlugin extends JavaPlugin {
         unregister(closingFrostShard);
         unregister(closingLongbow);
         unregister(closingQuickstep);
+        unregister(closingCombatMitigation);
+        unregister(closingShieldBash);
+        unregister(closingOutgoingDamageMitigation);
+        unregister(closingTemporaryHealth);
         unregister(closingGreatSword);
         unregister(closingRevive);
+        unregister(closingAdminRevival);
         unregister(closingBasicAttack);
         unregister(closingNutrition);
         unregister(closingBooks);
@@ -322,6 +598,7 @@ public final class FantasyStickPlugin extends JavaPlugin {
         unregister(closingCrafting);
         unregister(closingGuard);
         unregister(closingAnvil);
+        unregister(closingRecipeDiscovery);
         if (recipeRegistered) cleanup("character-sheet recipe", () -> {
             getServer().removeRecipe(CharacterSheets.RECIPE);
             recipeRegistered = false; // Retain ownership for a later retry if removal failed.
@@ -415,6 +692,113 @@ public final class FantasyStickPlugin extends JavaPlugin {
         return java.util.Map.copyOf(values);
     }
 
+    private java.util.Map<String, String> secondWindConfiguration() {
+        var values = new java.util.LinkedHashMap<String, String>();
+        for (String key : games.dmg.fantasystick.persistence.SecondWindSettings.keys()) {
+            values.put(key, getConfig().getString(key,
+                games.dmg.fantasystick.persistence.SecondWindSettings.defaultValue(key)));
+        }
+        games.dmg.fantasystick.persistence.SecondWindSettings.parse(values);
+        return java.util.Map.copyOf(values);
+    }
+
+    private java.util.Map<String, String> stoneSkinConfiguration() {
+        var values = new java.util.LinkedHashMap<String, String>();
+        for (String key : games.dmg.fantasystick.persistence.StoneSkinSettings.keys()) {
+            values.put(key, getConfig().getString(key,
+                games.dmg.fantasystick.persistence.StoneSkinSettings.defaultValue(key)));
+        }
+        games.dmg.fantasystick.persistence.StoneSkinSettings.parse(values);
+        return java.util.Map.copyOf(values);
+    }
+
+    private java.util.Map<String, String> shieldBashConfiguration() {
+        var values = new java.util.LinkedHashMap<String, String>();
+        for (String key : games.dmg.fantasystick.persistence.ShieldBashSettings.keys()) {
+            values.put(key, getConfig().getString(key,
+                games.dmg.fantasystick.persistence.ShieldBashSettings.defaultValue(key)));
+        }
+        games.dmg.fantasystick.persistence.ShieldBashSettings.parse(values);
+        return java.util.Map.copyOf(values);
+    }
+
+    private java.util.Map<String, String> hexConfiguration() {
+        var values = new java.util.LinkedHashMap<String, String>();
+        for (String key : games.dmg.fantasystick.persistence.HexSettings.keys()) {
+            values.put(key, getConfig().getString(key, games.dmg.fantasystick.persistence.HexSettings.defaultValue(key)));
+        }
+        games.dmg.fantasystick.persistence.HexSettings.parse(values);
+        return java.util.Map.copyOf(values);
+    }
+
+    private java.util.Map<String, String> inspireConfiguration() {
+        var values = new java.util.LinkedHashMap<String, String>();
+        for (String key : games.dmg.fantasystick.persistence.InspireSettings.keys()) {
+            values.put(key, getConfig().getString(key, games.dmg.fantasystick.persistence.InspireSettings.defaultValue(key)));
+        }
+        games.dmg.fantasystick.persistence.InspireSettings.parse(values);
+        return java.util.Map.copyOf(values);
+    }
+
+    private java.util.Map<String, String> mendingLightConfiguration() {
+        var values = new java.util.LinkedHashMap<String, String>();
+        for (String key : games.dmg.fantasystick.persistence.MendingLightSettings.keys()) {
+            values.put(key, getConfig().getString(key,
+                games.dmg.fantasystick.persistence.MendingLightSettings.defaultValue(key)));
+        }
+        games.dmg.fantasystick.persistence.MendingLightSettings.parse(values);
+        return java.util.Map.copyOf(values);
+    }
+
+    private java.util.Map<String, String> purifyConfiguration() {
+        var values = new java.util.LinkedHashMap<String, String>();
+        for (String key : games.dmg.fantasystick.persistence.PurifySettings.keys()) {
+            values.put(key, getConfig().getString(key, games.dmg.fantasystick.persistence.PurifySettings.defaultValue(key)));
+        }
+        games.dmg.fantasystick.persistence.PurifySettings.parse(values);
+        return java.util.Map.copyOf(values);
+    }
+
+    private java.util.Map<String, String> guardianBondConfiguration() {
+        var values = new java.util.LinkedHashMap<String, String>();
+        for (String key : games.dmg.fantasystick.persistence.GuardianBondSettings.keys()) {
+            values.put(key, getConfig().getString(key,
+                games.dmg.fantasystick.persistence.GuardianBondSettings.defaultValue(key)));
+        }
+        games.dmg.fantasystick.persistence.GuardianBondSettings.parse(values);
+        return java.util.Map.copyOf(values);
+    }
+
+    private java.util.Map<String, String> rallyingCryConfiguration() {
+        var values = new java.util.LinkedHashMap<String, String>();
+        for (String key : games.dmg.fantasystick.persistence.RallyingCrySettings.keys()) {
+            values.put(key, getConfig().getString(key,
+                games.dmg.fantasystick.persistence.RallyingCrySettings.defaultValue(key)));
+        }
+        games.dmg.fantasystick.persistence.RallyingCrySettings.parse(values);
+        return java.util.Map.copyOf(values);
+    }
+
+    private java.util.Map<String, String> frostNovaConfiguration() {
+        var values = new java.util.LinkedHashMap<String, String>();
+        for (String key : games.dmg.fantasystick.persistence.FrostNovaSettings.keys()) {
+            values.put(key, getConfig().getString(key,
+                games.dmg.fantasystick.persistence.FrostNovaSettings.defaultValue(key)));
+        }
+        games.dmg.fantasystick.persistence.FrostNovaSettings.parse(values);
+        return java.util.Map.copyOf(values);
+    }
+
+    private java.util.Map<String, String> chainLightningConfiguration() {
+        var values = new java.util.LinkedHashMap<String, String>();
+        for (String key : games.dmg.fantasystick.persistence.ChainLightningSettings.keys()) {
+            values.put(key, getConfig().getString(key,
+                games.dmg.fantasystick.persistence.ChainLightningSettings.defaultValue(key)));
+        }
+        games.dmg.fantasystick.persistence.ChainLightningSettings.parse(values);
+        return java.util.Map.copyOf(values);
+    }
+
     private games.dmg.fantasystick.ability.GreatSword.Settings greatSwordSettings() {
         try {
             var base = new java.math.BigInteger(getConfig().getString("great-sword-base-damage", "7"));
@@ -426,24 +810,6 @@ public final class FantasyStickPlugin extends JavaPlugin {
         }
     }
 
-    private java.time.Duration switchDelay() {
-        Object configured = getConfig().get("character-swap-cooldown-seconds", 900);
-        String value = String.valueOf(configured);
-        if (!value.matches("[0-9]+")) {
-            throw new IllegalArgumentException("character-swap-cooldown-seconds must be a nonnegative integer");
-        }
-        try {
-            var delay = java.time.Duration.ofSeconds(new java.math.BigInteger(value).longValueExact());
-            var deadline = java.time.Instant.now().plus(delay);
-            if (deadline.atOffset(java.time.ZoneOffset.UTC).getYear() > 9999) {
-                throw new IllegalArgumentException("character-swap-cooldown-seconds exceeds the persisted UTC timestamp range");
-            }
-            return delay;
-        } catch (ArithmeticException | java.time.DateTimeException invalid) {
-            throw new IllegalArgumentException("character-swap-cooldown-seconds exceeds the supported duration range", invalid);
-        }
-    }
-
     private void notifyPlayer(Object generation, EquipmentSessions.Notice notice) {
         Runnable delivery = () -> {
             if (lifetime != generation) return;

src/main/java/games/dmg/fantasystick/ability/ChainLightning.java

@@ -0,0 +1,203 @@
+package games.dmg.fantasystick.ability;
+
+import games.dmg.fantasystick.party.PartyRoster;
+import games.dmg.fantasystick.progression.Stat;
+import games.dmg.fantasystick.session.ControlInput;
+import games.dmg.fantasystick.session.EquipmentSessions;
+import java.math.BigDecimal;
+import java.math.BigInteger;
+import java.time.Duration;
+import java.util.ArrayList;
+import java.util.Comparator;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Objects;
+import java.util.Set;
+import java.util.UUID;
+import org.bukkit.Location;
+import org.bukkit.Material;
+import org.bukkit.Particle;
+import org.bukkit.Sound;
+import org.bukkit.damage.DamageSource;
+import org.bukkit.damage.DamageType;
+import org.bukkit.entity.Entity;
+import org.bukkit.entity.LivingEntity;
+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;
+
+/** Deterministic bounded four-target lightning chain with exact decimal decay. */
+public final class ChainLightning implements AbilityEffect, Listener, AutoCloseable {
+    public record Settings(BigInteger baseDamage, Duration cooldown, double initialRange, double jumpRange,
+                           int additionalTargets, BigDecimal jumpMultiplier) {
+        public Settings {
+            Objects.requireNonNull(baseDamage); Objects.requireNonNull(cooldown); Objects.requireNonNull(jumpMultiplier);
+            if (baseDamage.signum() < 0 || cooldown.isNegative() || cooldown.compareTo(Duration.ofDays(365)) > 0
+                    || !Double.isFinite(initialRange) || initialRange <= 0 || initialRange > 64
+                    || !Double.isFinite(jumpRange) || jumpRange <= 0 || jumpRange > 64
+                    || additionalTargets < 0 || additionalTargets > 63
+                    || jumpMultiplier.signum() <= 0 || jumpMultiplier.compareTo(BigDecimal.ONE) > 0) {
+                throw new IllegalArgumentException("Invalid Chain Lightning settings");
+            }
+        }
+        public static Settings defaults() {
+            return new Settings(BigInteger.valueOf(8), Duration.ofSeconds(18), 16, 6, 3, new BigDecimal("0.75"));
+        }
+    }
+    private static final class Attempt {
+        final AbilityExecution execution; final LivingEntity target; boolean accepted;
+        Attempt(AbilityExecution execution, LivingEntity target) { this.execution = execution; this.target = target; }
+    }
+
+    private volatile Settings settings;
+    private final EquipmentSessions sessions;
+    private final PartyRoster parties;
+    private Attempt damaging;
+    private boolean closed;
+
+    public ChainLightning(Settings settings, EquipmentSessions sessions, PartyRoster parties) {
+        this.settings = Objects.requireNonNull(settings); this.sessions = Objects.requireNonNull(sessions);
+        this.parties = Objects.requireNonNull(parties);
+    }
+    public void configure(Settings settings) { this.settings = Objects.requireNonNull(settings); }
+
+    public AbilityDefinition definition() {
+        var current = settings;
+        return new AbilityDefinition("chain_lightning", "Chain Lightning", Material.LIGHTNING_ROD,
+            List.of("Strike for " + current.baseDamage() + " + INT modifier damage, then jump up to "
+                    + current.additionalTargets() + " times.",
+                "Each jump deals " + decimal(current.jumpMultiplier().movePointRight(2))
+                    + "% of the previous defined damage within " + decimal(BigDecimal.valueOf(current.jumpRange())) + " blocks."),
+            "Use while aiming at the first visible hostile within " + decimal(BigDecimal.valueOf(current.initialRange())) + " blocks.",
+            Map.of(Stat.INT, BigInteger.valueOf(20), Stat.DEX, BigInteger.valueOf(12)), BigInteger.ONE,
+            AbilityDefinition.Activation.IMMEDIATE, ControlInput.Gesture.USE, current.cooldown(),
+            Map.of("base-damage", new BigDecimal(current.baseDamage()),
+                "initial-range", BigDecimal.valueOf(current.initialRange()).stripTrailingZeros(),
+                "jump-range", BigDecimal.valueOf(current.jumpRange()).stripTrailingZeros(),
+                "additional-targets", BigDecimal.valueOf(current.additionalTargets()),
+                "jump-multiplier", current.jumpMultiplier()), AbilityDefinition.TargetPolicy.SELECTION, this);
+    }
+
+    public static BigInteger initialDamage(BigInteger intelligence) { return initialDamage(BigInteger.valueOf(8), intelligence); }
+    static BigInteger initialDamage(BigInteger base, BigInteger intelligence) {
+        Objects.requireNonNull(base); Objects.requireNonNull(intelligence);
+        if (base.signum() < 0 || intelligence.signum() < 0) throw new IllegalArgumentException("Invalid Chain Lightning damage input");
+        var delta = intelligence.subtract(BigInteger.TEN); var divided = delta.divideAndRemainder(BigInteger.TWO);
+        var modifier = divided[0]; if (delta.signum() < 0 && divided[1].signum() != 0) modifier = modifier.subtract(BigInteger.ONE);
+        return base.add(modifier);
+    }
+
+    @Override public boolean accepts(ControlInput input) {
+        return !closed && selectInitial(input, settings.initialRange()) != null;
+    }
+
+    @Override public void activate(AbilityExecution execution) {
+        if (closed || !execution.stillCurrent()) return;
+        var captured = from(execution.definition()); var caster = execution.input().player();
+        var initial = selectInitial(execution.input(), captured.initialRange());
+        if (initial == null) return;
+        BigDecimal defined = new BigDecimal(initialDamage(captured.baseDamage(), execution.character().stats().get(Stat.INT)));
+        var visited = new HashSet<UUID>(); LivingEntity current = initial;
+        int maximum = Math.min(64, 1 + captured.additionalTargets());
+        for (int strike = 0; strike < maximum && current != null && execution.stillCurrent(); strike++) {
+            if (!visited.add(current.getUniqueId()) || !eligible(caster, current)) break;
+            strike(execution, caster, current, defined); visual(caster, current);
+            if (strike + 1 == maximum) break;
+            defined = defined.multiply(captured.jumpMultiplier());
+            current = next(caster, current, visited, captured.jumpRange());
+        }
+    }
+
+    private void strike(AbilityExecution execution, Player caster, LivingEntity target, BigDecimal defined) {
+        double amount = finite(definiteNonnegative(defined));
+        var origin = caster.getEyeLocation().clone();
+        var source = DamageSource.builder(DamageType.LIGHTNING_BOLT).withCausingEntity(caster)
+            .withDirectEntity(caster).withDamageLocation(origin).build();
+        var attempt = new Attempt(execution, target); damaging = attempt;
+        try { target.damage(amount, source); }
+        finally { if (damaging == attempt) damaging = null; }
+    }
+
+    private LivingEntity selectInitial(ControlInput input, double range) {
+        var caster = input.player();
+        if (input.target() instanceof LivingEntity supplied && eligible(caster, supplied)
+                && inRangeAndVisible(caster, supplied, range)) return supplied;
+        try {
+            var eye = caster.getEyeLocation();
+            var hit = caster.getWorld().rayTraceEntities(eye, eye.getDirection(), range, entity ->
+                entity instanceof LivingEntity target && eligible(caster, target) && inRangeAndVisible(caster, target, range));
+            if (hit == null || !(hit.getHitEntity() instanceof LivingEntity target)) return null;
+            return eligible(caster, target) && inRangeAndVisible(caster, target, range) ? target : null;
+        } catch (RuntimeException unavailable) { return null; }
+    }
+
+    private LivingEntity next(Player caster, LivingEntity previous, Set<UUID> visited, double range) {
+        List<Entity> nearby;
+        try { nearby = previous.getNearbyEntities(range, range, range); }
+        catch (RuntimeException unavailable) { return null; }
+        var candidates = new ArrayList<LivingEntity>(); var seen = new HashSet<UUID>(); int inspected = 0;
+        for (var entity : nearby) {
+            if (++inspected > 256) break;
+            if (entity instanceof LivingEntity target && seen.add(target.getUniqueId()) && !visited.contains(target.getUniqueId())
+                    && eligible(caster, target) && inRangeAndVisible(previous, target, range)) candidates.add(target);
+        }
+        var origin = previous.getLocation();
+        candidates.sort(Comparator.comparingDouble((LivingEntity target) -> distance(origin, target))
+            .thenComparing(LivingEntity::getUniqueId));
+        return candidates.isEmpty() ? null : candidates.getFirst();
+    }
+
+    private boolean eligible(Player caster, LivingEntity target) {
+        if (target == caster) return false;
+        if (!(target instanceof Player player)) return true;
+        if (sessions.active(player.getUniqueId()).filter(sessions::current).isEmpty()) return false;
+        var sourceParty = parties.partyOf(caster.getUniqueId()).orElse(null);
+        var targetParty = parties.partyOf(player.getUniqueId()).orElse(null);
+        return sourceParty == null || targetParty == null || !sourceParty.id().equals(targetParty.id());
+    }
+
+    private static boolean inRangeAndVisible(LivingEntity source, LivingEntity target, double range) {
+        try {
+            var from = source.getLocation(); var to = target.getLocation();
+            return from.getWorld() == to.getWorld() && from.distanceSquared(to) <= range * range && source.hasLineOfSight(target);
+        } catch (RuntimeException invalid) { return false; }
+    }
+    private static double distance(Location origin, LivingEntity target) {
+        try { var location = target.getLocation(); return origin.getWorld() == location.getWorld()
+            ? origin.distanceSquared(location) : Double.POSITIVE_INFINITY; }
+        catch (RuntimeException invalid) { return Double.POSITIVE_INFINITY; }
+    }
+
+    @EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = true)
+    public void acceptedDamage(EntityDamageEvent event) {
+        var attempt = damaging;
+        if (attempt == null || attempt.accepted || event.getEntity() != attempt.target
+                || event.getCause() != EntityDamageEvent.DamageCause.LIGHTNING
+                || event.getFinalDamage() <= 0 || !Double.isFinite(event.getFinalDamage())) return;
+        attempt.accepted = true;
+        attempt.execution.report(AbilityReport.Type.DAMAGE, attempt.target, BigDecimal.valueOf(event.getFinalDamage()));
+    }
+
+    private static void visual(Player caster, LivingEntity target) {
+        try {
+            var location = target.getLocation().clone().add(0, target.getHeight() / 2, 0);
+            caster.getWorld().spawnParticle(Particle.ELECTRIC_SPARK, location, 18, 0.3, 0.5, 0.3, 0.02);
+            caster.getWorld().playSound(location, Sound.ENTITY_LIGHTNING_BOLT_THUNDER, 0.35f, 1.7f);
+        } catch (RuntimeException ignored) { }
+    }
+    private static BigDecimal definiteNonnegative(BigDecimal value) { return value.signum() < 0 ? BigDecimal.ZERO : value; }
+    private static double finite(BigDecimal value) {
+        if (value.compareTo(BigDecimal.valueOf(Double.MAX_VALUE)) > 0) return Double.MAX_VALUE;
+        double result = value.doubleValue(); return Double.isFinite(result) ? result : Double.MAX_VALUE;
+    }
+    private static Settings from(AbilityDefinition definition) {
+        var p = definition.parameters();
+        return new Settings(p.get("base-damage").toBigIntegerExact(), definition.cooldown(), p.get("initial-range").doubleValue(),
+            p.get("jump-range").doubleValue(), p.get("additional-targets").intValueExact(), p.get("jump-multiplier"));
+    }
+    private static String decimal(BigDecimal value) { return value.stripTrailingZeros().toPlainString(); }
+    @Override public void close() { closed = true; damaging = null; }
+}

src/main/java/games/dmg/fantasystick/ability/CombatMitigation.java

@@ -0,0 +1,77 @@
+package games.dmg.fantasystick.ability;
+
+import java.math.BigDecimal;
+import java.util.ArrayList;
+import java.util.IdentityHashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Objects;
+import java.util.UUID;
+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.EntityDamageByEntityEvent;
+import org.bukkit.event.entity.EntityDamageEvent;
+
+/** Internal strongest-reduction stage shared by Fantasy Stick protection effects. */
+public final class CombatMitigation implements Listener, AutoCloseable {
+    private final class Grant implements AutoCloseable {
+        final AbilityExecution execution; final Player player; final BigDecimal percent; boolean closed;
+        Grant(AbilityExecution execution, Player player, BigDecimal percent) {
+            this.execution = execution; this.player = player; this.percent = percent;
+        }
+        @Override public void close() {
+            if (closed) return; closed = true;
+            var owned = grants.get(player.getUniqueId());
+            if (owned != null) { owned.remove(this); if (owned.isEmpty()) grants.remove(player.getUniqueId()); }
+        }
+    }
+    private record Prevention(Grant grant, BigDecimal amount) { }
+    private final Map<UUID, List<Grant>> grants = new java.util.HashMap<>();
+    private final Map<EntityDamageEvent, Prevention> pending = new IdentityHashMap<>();
+    private boolean closed;
+
+    public AutoCloseable grant(AbilityExecution execution, Player player, BigDecimal percent) {
+        Objects.requireNonNull(execution); Objects.requireNonNull(player); Objects.requireNonNull(percent);
+        if (closed || percent.signum() < 0 || percent.compareTo(BigDecimal.valueOf(100)) > 0)
+            throw new IllegalArgumentException("Invalid combat mitigation grant");
+        var grant = new Grant(execution, player, percent);
+        grants.computeIfAbsent(player.getUniqueId(), ignored -> new ArrayList<>()).add(grant);
+        return grant;
+    }
+
+    @EventHandler(priority = EventPriority.HIGH, ignoreCancelled = true)
+    public void reduce(EntityDamageByEntityEvent event) {
+        if (closed || !(event.getEntity() instanceof Player player)) return;
+        Grant strongest = null;
+        var owned = grants.get(player.getUniqueId());
+        if (owned == null) return;
+        for (var grant : List.copyOf(owned)) {
+            if (grant.closed || grant.player != player || !grant.execution.stillCurrent()) continue;
+            if (strongest == null || grant.percent.compareTo(strongest.percent) > 0) strongest = grant;
+        }
+        double original = event.getDamage();
+        if (strongest == null || !Double.isFinite(original) || original <= 0) return;
+        double reduced = BigDecimal.valueOf(original)
+            .multiply(BigDecimal.ONE.subtract(strongest.percent.movePointLeft(2))).doubleValue();
+        if (!Double.isFinite(reduced) || reduced < 0) return;
+        event.setDamage(reduced);
+        BigDecimal prevented = BigDecimal.valueOf(original - reduced);
+        if (prevented.signum() > 0) pending.put(event, new Prevention(strongest, prevented));
+    }
+
+    @EventHandler(priority = EventPriority.MONITOR)
+    public void accepted(EntityDamageEvent event) {
+        var prevention = pending.remove(event);
+        if (prevention == null || event.isCancelled() || event.getFinalDamage() <= 0
+                || !prevention.grant.execution.stillCurrent()) return;
+        prevention.grant.execution.report(AbilityReport.Type.PREVENTION, event.getEntity(), prevention.amount);
+    }
+
+    @Override public void close() {
+        if (closed) return; closed = true;
+        for (var owned : List.copyOf(grants.values())) for (var grant : List.copyOf(owned)) grant.close();
+        grants.clear(); pending.clear();
+    }
+}

src/main/java/games/dmg/fantasystick/ability/FrostNova.java

@@ -0,0 +1,234 @@
+package games.dmg.fantasystick.ability;
+
+import games.dmg.fantasystick.party.PartyRoster;
+import games.dmg.fantasystick.progression.Stat;
+import games.dmg.fantasystick.session.ControlInput;
+import games.dmg.fantasystick.session.EquipmentSessions;
+import java.math.BigDecimal;
+import java.math.BigInteger;
+import java.time.Duration;
+import java.util.ArrayList;
+import java.util.Comparator;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Objects;
+import java.util.UUID;
+import org.bukkit.Location;
+import org.bukkit.Material;
+import org.bukkit.Particle;
+import org.bukkit.damage.DamageSource;
+import org.bukkit.damage.DamageType;
+import org.bukkit.entity.Entity;
+import org.bukkit.entity.LivingEntity;
+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.potion.PotionEffect;
+import org.bukkit.potion.PotionEffectType;
+
+/** Bounded instantaneous Frost Nova damage and ownership-aware Slowness. */
+public final class FrostNova implements AbilityEffect, Listener, AutoCloseable {
+    public record Settings(BigInteger baseDamage, Duration cooldown, double radius,
+                           int slownessAmplifier, Duration slownessDuration) {
+        public Settings {
+            Objects.requireNonNull(baseDamage); Objects.requireNonNull(cooldown); Objects.requireNonNull(slownessDuration);
+            if (baseDamage.signum() < 0 || cooldown.isNegative() || cooldown.compareTo(Duration.ofDays(365)) > 0
+                    || !Double.isFinite(radius) || radius <= 0 || radius > 64
+                    || slownessAmplifier < 0 || slownessAmplifier > 255
+                    || slownessDuration.isNegative() || slownessDuration.isZero()
+                    || slownessDuration.compareTo(Duration.ofDays(1)) > 0) {
+                throw new IllegalArgumentException("Invalid Frost Nova settings");
+            }
+        }
+        public static Settings defaults() {
+            return new Settings(BigInteger.valueOf(5), Duration.ofSeconds(12), 5, 1, Duration.ofSeconds(3));
+        }
+    }
+
+    private static final class SlowLease implements AutoCloseable {
+        final LivingEntity target; final PotionEffect previous; final PotionEffect applied;
+        final long started = System.nanoTime(); boolean owned; boolean closed;
+        SlowLease(LivingEntity target, PotionEffect applied) {
+            this.target = target; previous = target.getPotionEffect(PotionEffectType.SLOWNESS); this.applied = applied;
+        }
+        boolean apply() { owned = target.addPotionEffect(applied); return owned; }
+        @Override public void close() {
+            if (closed) return; closed = true; if (!owned) return;
+            var current = target.getPotionEffect(PotionEffectType.SLOWNESS);
+            long elapsed = Math.max(0, (System.nanoTime() - started) / 50_000_000L);
+            int expected = (int) Math.max(0, (long) applied.getDuration() - elapsed);
+            if (current == null || current.getAmplifier() != applied.getAmplifier()
+                    || current.getDuration() > expected + 2) return;
+            target.removePotionEffect(PotionEffectType.SLOWNESS);
+            if (previous != null) {
+                int remaining = (int) Math.max(0, (long) previous.getDuration() - elapsed);
+                if (remaining > 0) target.addPotionEffect(previous.withDuration(remaining));
+            }
+        }
+    }
+    private final class LeaseGroup implements AutoCloseable {
+        final AbilityExecution execution; final List<SlowLease> leases = new ArrayList<>(); boolean closed;
+        LeaseGroup(AbilityExecution execution) { this.execution = execution; }
+        @Override public void close() {
+            if (closed) return; closed = true; active.remove(execution, this);
+            for (var lease : List.copyOf(leases)) lease.close(); leases.clear();
+        }
+    }
+    private static final class Attempt {
+        final AbilityExecution execution; final LivingEntity target; boolean accepted;
+        Attempt(AbilityExecution execution, LivingEntity target) { this.execution = execution; this.target = target; }
+    }
+
+    private volatile Settings settings;
+    private final EquipmentSessions sessions;
+    private final PartyRoster parties;
+    private final Map<AbilityExecution, LeaseGroup> active = new java.util.IdentityHashMap<>();
+    private Attempt damaging;
+    private boolean closed;
+
+    public FrostNova(Settings settings, EquipmentSessions sessions, PartyRoster parties) {
+        this.settings = Objects.requireNonNull(settings); this.sessions = Objects.requireNonNull(sessions);
+        this.parties = Objects.requireNonNull(parties);
+    }
+    public void configure(Settings settings) { this.settings = Objects.requireNonNull(settings); }
+
+    public AbilityDefinition definition() {
+        var current = settings;
+        return new AbilityDefinition("frost_nova", "Frost Nova", Material.SNOWBALL,
+            List.of("Burst in a " + decimal(BigDecimal.valueOf(current.radius())) + "-block sphere for "
+                    + current.baseDamage() + " + INT modifier damage.",
+                "Applies Slowness " + level(current.slownessAmplifier()) + " for " + seconds(current.slownessDuration()) + " seconds."),
+            "Use to affect exposed enemies; caster, party and ordinary players are excluded.",
+            Map.of(Stat.INT, BigInteger.valueOf(16), Stat.DEX, BigInteger.TEN), BigInteger.ONE,
+            AbilityDefinition.Activation.DELAYED, ControlInput.Gesture.USE, current.cooldown(),
+            Map.of("base-damage", new BigDecimal(current.baseDamage()),
+                "radius", BigDecimal.valueOf(current.radius()).stripTrailingZeros(),
+                "slowness-amplifier", BigDecimal.valueOf(current.slownessAmplifier()),
+                "slowness-duration-seconds", BigDecimal.valueOf(current.slownessDuration().toNanos()).movePointLeft(9)),
+            AbilityDefinition.TargetPolicy.AREA, this);
+    }
+
+    public static BigInteger damage(BigInteger intelligence) { return damage(BigInteger.valueOf(5), intelligence); }
+    static BigInteger damage(BigInteger base, BigInteger intelligence) {
+        Objects.requireNonNull(base); Objects.requireNonNull(intelligence);
+        if (base.signum() < 0 || intelligence.signum() < 0) throw new IllegalArgumentException("Invalid Frost Nova damage input");
+        var delta = intelligence.subtract(BigInteger.TEN); var divided = delta.divideAndRemainder(BigInteger.TWO);
+        var modifier = divided[0]; if (delta.signum() < 0 && divided[1].signum() != 0) modifier = modifier.subtract(BigInteger.ONE);
+        return base.add(modifier);
+    }
+
+    @Override public boolean accepts(ControlInput input) { return !closed && input.target() == null; }
+    @Override public void activate(AbilityExecution execution) {
+        if (closed || !execution.stillCurrent()) return;
+        var captured = from(execution.definition()); var source = execution.input().player();
+        Location origin = source.getEyeLocation().clone();
+        var group = new LeaseGroup(execution); active.put(execution, group); execution.own(group);
+        BigInteger exact = damage(captured.baseDamage(), execution.character().stats().get(Stat.INT));
+        double amount = exact.bitLength() > 1023 ? Double.MAX_VALUE : exact.doubleValue();
+        int affected = 0;
+        for (var target : candidates(source, origin, captured.radius())) {
+            if (affected == 64 || !execution.stillCurrent()) break;
+            if (!eligible(execution, target, origin, captured.radius())) continue;
+            var sourceDamage = DamageSource.builder(DamageType.FREEZE).withCausingEntity(source)
+                .withDirectEntity(source).withDamageLocation(origin).build();
+            var attempt = new Attempt(execution, target); damaging = attempt;
+            try { target.damage(amount, sourceDamage); }
+            finally { if (damaging == attempt) damaging = null; }
+            affected++;
+            if (!attempt.accepted || !execution.stillCurrent() || !eligible(execution, target, origin, captured.radius())) continue;
+            int ticks = Math.toIntExact(Math.max(1,
+                (captured.slownessDuration().toNanos() + 49_999_999L) / 50_000_000L));
+            var lease = new SlowLease(target, new PotionEffect(PotionEffectType.SLOWNESS, ticks,
+                captured.slownessAmplifier(), false, true, true));
+            if (lease.apply()) group.leases.add(lease);
+        }
+        try { source.getWorld().spawnParticle(Particle.SNOWFLAKE, origin, 32,
+            captured.radius() / 2, captured.radius() / 2, captured.radius() / 2, 0.01); }
+        catch (RuntimeException ignored) { }
+        if (group.leases.isEmpty()) execution.finish();
+        else execution.later(captured.slownessDuration(), execution::finish);
+    }
+
+    private List<LivingEntity> candidates(Player source, Location origin, double radius) {
+        List<Entity> nearby;
+        try { nearby = source.getNearbyEntities(radius, radius, radius); }
+        catch (RuntimeException unavailable) { return List.of(); }
+        var unique = new LinkedHashMap<UUID, LivingEntity>(); int inspected = 0;
+        for (var entity : nearby) {
+            if (++inspected > 256) break;
+            if (entity instanceof LivingEntity target && target != source) unique.putIfAbsent(target.getUniqueId(), target);
+        }
+        var result = new ArrayList<>(unique.values());
+        result.sort(Comparator.comparingDouble((LivingEntity target) -> distance(origin, target))
+            .thenComparing(LivingEntity::getUniqueId));
+        return result;
+    }
+
+    private boolean eligible(AbilityExecution execution, LivingEntity target, Location origin, double radius) {
+        if (target == execution.input().player() || !inside(origin, target, radius)) return false;
+        try {
+            if (!execution.input().player().hasLineOfSight(target) || !unobstructed(origin, target)) return false;
+        } catch (RuntimeException unavailable) { return false; }
+        if (!(target instanceof Player player)) return true;
+        var active = sessions.active(player.getUniqueId()).filter(sessions::current).orElse(null);
+        if (active == null) return false;
+        var sourceParty = parties.partyOf(execution.input().player().getUniqueId()).orElse(null);
+        var targetParty = parties.partyOf(player.getUniqueId()).orElse(null);
+        return sourceParty == null || targetParty == null || !sourceParty.id().equals(targetParty.id());
+    }
+
+    @EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = true)
+    public void acceptedDamage(EntityDamageEvent event) {
+        var attempt = damaging;
+        if (attempt == null || attempt.accepted || event.getEntity() != attempt.target
+                || event.getCause() != EntityDamageEvent.DamageCause.FREEZE
+                || event.getFinalDamage() <= 0 || !Double.isFinite(event.getFinalDamage())) return;
+        attempt.accepted = true;
+        attempt.execution.report(AbilityReport.Type.DAMAGE, attempt.target, BigDecimal.valueOf(event.getFinalDamage()));
+    }
+
+    private static boolean unobstructed(Location origin, LivingEntity target) {
+        var world = origin.getWorld(); if (world == null) return false;
+        var location = target.getLocation(); if (location.getWorld() != world) return false;
+        var bounds = target.getBoundingBox();
+        var center = bounds == null ? location.toVector().add(new org.bukkit.util.Vector(0, target.getHeight() / 2, 0))
+            : bounds.getCenter();
+        var offset = center.clone().subtract(origin.toVector()); double distance = offset.length();
+        if (!Double.isFinite(distance) || distance == 0) return distance == 0;
+        return world.rayTraceBlocks(origin, offset.multiply(1 / distance), distance,
+            org.bukkit.FluidCollisionMode.NEVER, true) == null;
+    }
+
+    private static boolean inside(Location origin, LivingEntity target, double radius) {
+        try { var location = target.getLocation(); return origin.getWorld() == location.getWorld()
+            && origin.distanceSquared(location) <= radius * radius; }
+        catch (RuntimeException invalid) { return false; }
+    }
+    private static double distance(Location origin, LivingEntity target) {
+        try { var location = target.getLocation(); return origin.getWorld() == location.getWorld()
+            ? origin.distanceSquared(location) : Double.POSITIVE_INFINITY; }
+        catch (RuntimeException invalid) { return Double.POSITIVE_INFINITY; }
+    }
+    private static Settings from(AbilityDefinition definition) {
+        var parameters = definition.parameters();
+        return new Settings(parameters.get("base-damage").toBigIntegerExact(), definition.cooldown(),
+            parameters.get("radius").doubleValue(), parameters.get("slowness-amplifier").intValueExact(),
+            Duration.ofNanos(parameters.get("slowness-duration-seconds").movePointRight(9).longValueExact()));
+    }
+    private static String decimal(BigDecimal value) { return value.stripTrailingZeros().toPlainString(); }
+    private static String seconds(Duration duration) {
+        return decimal(BigDecimal.valueOf(duration.toNanos()).movePointLeft(9));
+    }
+    private static String level(int amplifier) {
+        return switch (amplifier + 1) { case 1 -> "I"; case 2 -> "II"; case 3 -> "III"; case 4 -> "IV"; default -> Integer.toString(amplifier + 1); };
+    }
+
+    @Override public void close() {
+        if (closed) return; closed = true; damaging = null;
+        for (var group : List.copyOf(active.values())) { group.close(); group.execution.finish(); }
+        active.clear();
+    }
+}

src/main/java/games/dmg/fantasystick/ability/GuardianBond.java

@@ -0,0 +1,274 @@
+package games.dmg.fantasystick.ability;
+
+import games.dmg.fantasystick.party.PartyRoster;
+import games.dmg.fantasystick.progression.Stat;
+import games.dmg.fantasystick.session.ControlInput;
+import games.dmg.fantasystick.session.EquipmentSessions;
+import java.math.BigDecimal;
+import java.math.BigInteger;
+import java.time.Duration;
+import java.util.List;
+import java.util.Map;
+import java.util.Objects;
+import java.util.UUID;
+import java.util.function.Consumer;
+import org.bukkit.Material;
+import org.bukkit.entity.Entity;
+import org.bukkit.entity.Player;
+import org.bukkit.entity.Projectile;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.EventPriority;
+import org.bukkit.event.Listener;
+import org.bukkit.event.entity.EntityDamageByEntityEvent;
+import org.bukkit.projectiles.ProjectileSource;
+
+/** Conserved, non-recursive native combat redirection for Guardian Bond. */
+public final class GuardianBond implements AbilityEffect, Listener, AutoCloseable {
+    public record Settings(Duration cooldown, double range, Duration duration, BigDecimal redirectPercent) {
+        public Settings {
+            Objects.requireNonNull(cooldown); Objects.requireNonNull(duration); Objects.requireNonNull(redirectPercent);
+            if (cooldown.isNegative() || cooldown.compareTo(Duration.ofDays(365)) > 0
+                    || !Double.isFinite(range) || range <= 0 || range > 64
+                    || duration.isNegative() || duration.isZero() || duration.compareTo(Duration.ofDays(1)) > 0
+                    || redirectPercent.signum() < 0 || redirectPercent.compareTo(BigDecimal.valueOf(100)) > 0) {
+                throw new IllegalArgumentException("Invalid Guardian Bond settings");
+            }
+        }
+        public static Settings defaults() {
+            return new Settings(Duration.ofSeconds(20), 10, Duration.ofSeconds(6), BigDecimal.valueOf(30));
+        }
+    }
+
+    public record Support(UUID target, UUID supportingCharacter, EquipmentSessions.Active aided, BigDecimal amount) {
+        public Support {
+            Objects.requireNonNull(target); Objects.requireNonNull(supportingCharacter);
+            Objects.requireNonNull(aided); Objects.requireNonNull(amount);
+        }
+    }
+
+    @FunctionalInterface public interface Damage {
+        BigDecimal apply(Player guardian, Entity attacker, BigDecimal requested);
+    }
+
+    private final class State implements AutoCloseable {
+        final AbilityExecution execution;
+        final Player guardian;
+        final Player ally;
+        final EquipmentSessions.Active aided;
+        final Settings settings;
+        boolean closed;
+        State(AbilityExecution execution, Player guardian, Player ally,
+              EquipmentSessions.Active aided, Settings settings) {
+            this.execution = execution; this.guardian = guardian; this.ally = ally;
+            this.aided = aided; this.settings = settings;
+        }
+        @Override public void close() {
+            if (closed) return;
+            closed = true;
+            byGuardian.remove(guardian.getUniqueId(), this);
+            byAlly.remove(ally.getUniqueId(), this);
+        }
+    }
+
+    private static final class NativeTransfer {
+        final Player guardian; final Entity attacker; final BigDecimal requested; final BigDecimal available;
+        BigDecimal accepted = BigDecimal.ZERO;
+        NativeTransfer(Player guardian, Entity attacker, BigDecimal requested, BigDecimal available) {
+            this.guardian = guardian; this.attacker = attacker; this.requested = requested; this.available = available;
+        }
+    }
+
+    private static final ThreadLocal<Integer> REDIRECT_DEPTH = ThreadLocal.withInitial(() -> 0);
+
+    private volatile Settings settings;
+    private final EquipmentSessions sessions;
+    private final PartyRoster parties;
+    private final Damage damage;
+    private final Consumer<Support> supports;
+    private final Map<UUID, State> byGuardian = new java.util.HashMap<>();
+    private final Map<UUID, State> byAlly = new java.util.HashMap<>();
+    private int transferring;
+    private NativeTransfer nativeTransfer;
+    private org.bukkit.scheduler.BukkitTask sweepTask;
+    private boolean closed;
+
+    public GuardianBond(Settings settings, EquipmentSessions sessions, PartyRoster parties,
+                        Consumer<Support> supports) {
+        this(settings, sessions, parties, null, supports);
+    }
+
+    public GuardianBond(Settings settings, EquipmentSessions sessions, PartyRoster parties,
+                        Damage damage, Consumer<Support> supports) {
+        this.settings = Objects.requireNonNull(settings);
+        this.sessions = Objects.requireNonNull(sessions);
+        this.parties = Objects.requireNonNull(parties);
+        this.damage = damage == null ? this::nativeDamage : damage;
+        this.supports = Objects.requireNonNull(supports);
+    }
+
+    public void configure(Settings settings) { this.settings = Objects.requireNonNull(settings); }
+
+    public void install(org.bukkit.plugin.Plugin plugin) {
+        Objects.requireNonNull(plugin);
+        if (closed || sweepTask != null) throw new IllegalStateException("Guardian Bond sweep already installed or closed");
+        sweepTask = plugin.getServer().getScheduler().runTaskTimer(plugin, this::sweep, 1, 1);
+    }
+
+    /** Bound active-link validation prevents an invalid link from becoming valid again later. */
+    public void sweep() {
+        if (closed) return;
+        int checked = 0;
+        for (var state : List.copyOf(byGuardian.values())) {
+            if (!current(state)) breakBond(state);
+            if (++checked == 256) break;
+        }
+    }
+
+    public AbilityDefinition definition() {
+        var current = settings;
+        return new AbilityDefinition("guardian_bond", "Guardian Bond", Material.IRON_CHESTPLATE,
+            List.of("Redirect " + decimal(current.redirectPercent()) + "% of an aimed party ally's combat damage.",
+                "Range " + decimal(BigDecimal.valueOf(current.range())) + " blocks for " + seconds(current.duration()) + " seconds."),
+            "Use on an aimed active party ally; one guardian and one bond per ally.",
+            Map.of(Stat.CON, BigInteger.valueOf(16), Stat.WIS, BigInteger.TEN), BigInteger.ONE,
+            AbilityDefinition.Activation.DELAYED, ControlInput.Gesture.USE, current.cooldown(),
+            Map.of("range", BigDecimal.valueOf(current.range()).stripTrailingZeros(),
+                "duration-seconds", BigDecimal.valueOf(current.duration().toNanos()).movePointLeft(9),
+                "redirect-percent", current.redirectPercent()),
+            AbilityDefinition.TargetPolicy.PARTY, this);
+    }
+
+    @Override public boolean accepts(ControlInput input) {
+        if (closed || !(input.target() instanceof Player ally) || ally == input.player()) return false;
+        return byGuardian.get(input.player().getUniqueId()) == null && byAlly.get(ally.getUniqueId()) == null
+            && eligible(input.player(), ally, settings.range()) && aided(ally) != null;
+    }
+
+    @Override public void activate(AbilityExecution execution) {
+        if (closed || !execution.stillCurrent() || !(execution.input().target() instanceof Player ally)) return;
+        var guardian = execution.input().player(); var captured = from(execution.definition()); var aided = aided(ally);
+        if (ally == guardian || aided == null || !eligible(guardian, ally, captured.range())
+                || byGuardian.containsKey(guardian.getUniqueId()) || byAlly.containsKey(ally.getUniqueId())) {
+            execution.finish(); return;
+        }
+        var state = new State(execution, guardian, ally, aided, captured);
+        byGuardian.put(guardian.getUniqueId(), state); byAlly.put(ally.getUniqueId(), state);
+        execution.own(state); execution.later(captured.duration(), execution::finish);
+    }
+
+    @EventHandler(priority = EventPriority.HIGHEST, ignoreCancelled = true)
+    public void redirect(EntityDamageByEntityEvent event) {
+        if (closed || redirectedDamage() || transferring != 0 || !(event.getEntity() instanceof Player ally)) return;
+        var state = byAlly.get(ally.getUniqueId());
+        if (state == null) return;
+        if (!current(state)) { breakBond(state); return; }
+        double incoming = event.getDamage();
+        if (!Double.isFinite(incoming) || incoming <= 0) return;
+        BigDecimal requested = BigDecimal.valueOf(incoming)
+            .multiply(state.settings.redirectPercent().movePointLeft(2));
+        if (requested.signum() <= 0) return;
+        Entity attacker = attacker(event);
+        if (attacker == null) return;
+        BigDecimal accepted;
+        transferring++; REDIRECT_DEPTH.set(REDIRECT_DEPTH.get() + 1);
+        try { accepted = damage.apply(state.guardian, attacker, requested); }
+        catch (RuntimeException failure) { return; }
+        finally {
+            transferring--;
+            int depth = REDIRECT_DEPTH.get() - 1;
+            if (depth == 0) REDIRECT_DEPTH.remove(); else REDIRECT_DEPTH.set(depth);
+        }
+        if (accepted == null || accepted.signum() <= 0) return;
+        BigDecimal maximum = requested.min(BigDecimal.valueOf(incoming));
+        if (accepted.compareTo(maximum) > 0) accepted = maximum;
+        double remaining = BigDecimal.valueOf(incoming).subtract(accepted).max(BigDecimal.ZERO).doubleValue();
+        if (!Double.isFinite(remaining)) return;
+        event.setDamage(remaining);
+        state.execution.report(AbilityReport.Type.PREVENTION, ally, accepted);
+        supports.accept(new Support(attacker.getUniqueId(), state.execution.input().session().character(), state.aided, accepted));
+    }
+
+    /** Capture accepted marked damage before synchronous fantasy-defeat restoration can replace native health. */
+    private BigDecimal nativeDamage(Player guardian, Entity attacker, BigDecimal requested) {
+        Objects.requireNonNull(guardian); Objects.requireNonNull(attacker); Objects.requireNonNull(requested);
+        double amount = requested.doubleValue(); double health = effectiveHealth(guardian);
+        if (!Double.isFinite(amount) || amount <= 0 || !Double.isFinite(health) || health <= 0) return BigDecimal.ZERO;
+        var transfer = new NativeTransfer(guardian, attacker, requested, BigDecimal.valueOf(health));
+        nativeTransfer = transfer;
+        try { guardian.damage(amount, attacker); }
+        finally { nativeTransfer = null; }
+        return transfer.accepted;
+    }
+
+    @EventHandler(priority = EventPriority.MONITOR)
+    public void acceptedRedirect(EntityDamageByEntityEvent event) {
+        var transfer = nativeTransfer;
+        if (transfer == null || event.getEntity() != transfer.guardian || attacker(event) != transfer.attacker
+                || event.isCancelled() || !Double.isFinite(event.getFinalDamage()) || event.getFinalDamage() <= 0) return;
+        transfer.accepted = BigDecimal.valueOf(event.getFinalDamage()).min(transfer.requested).min(transfer.available);
+    }
+
+    /** True only during synchronous dispatch of Guardian Bond's marked redirected damage. */
+    public static boolean redirectedDamage() {
+        int depth = REDIRECT_DEPTH.get();
+        if (depth == 0) REDIRECT_DEPTH.remove();
+        return depth > 0;
+    }
+
+    private EquipmentSessions.Active aided(Player ally) {
+        return sessions.active(ally.getUniqueId()).filter(sessions::current).orElse(null);
+    }
+
+    private boolean current(State state) {
+        if (state.closed || !state.execution.stillCurrent() || state.ally != state.execution.input().target()
+                || !sessions.current(state.aided)
+                || !sessions.active(state.ally.getUniqueId()).filter(state.aided::equals).isPresent()
+                || !eligible(state.guardian, state.ally, state.settings.range())) return false;
+        var guardianParty = parties.partyOf(state.guardian.getUniqueId()).orElse(null);
+        var allyParty = parties.partyOf(state.ally.getUniqueId()).orElse(null);
+        return guardianParty != null && allyParty != null && guardianParty.id().equals(allyParty.id());
+    }
+
+    private void breakBond(State state) {
+        state.close(); state.execution.finish();
+    }
+
+    private static boolean eligible(Player guardian, Player ally, double range) {
+        try {
+            var source = guardian.getLocation(); var target = ally.getLocation();
+            return source.getWorld() == target.getWorld() && source.distanceSquared(target) <= range * range
+                && guardian.hasLineOfSight(ally);
+        } catch (RuntimeException invalid) { return false; }
+    }
+
+    private static Entity attacker(EntityDamageByEntityEvent event) {
+        Entity causing = event.getDamageSource().getCausingEntity();
+        if (causing != null) return causing;
+        if (event.getDamager() instanceof Projectile projectile) {
+            ProjectileSource shooter = projectile.getShooter();
+            if (shooter instanceof Entity entity) return entity;
+        }
+        return event.getDamager();
+    }
+
+    private static double effectiveHealth(Player player) {
+        return Math.max(0, player.getHealth()) + Math.max(0, player.getAbsorptionAmount());
+    }
+    private static Settings from(AbilityDefinition definition) {
+        var parameters = definition.parameters();
+        return new Settings(definition.cooldown(), parameters.get("range").doubleValue(),
+            Duration.ofNanos(parameters.get("duration-seconds").movePointRight(9).longValueExact()),
+            parameters.get("redirect-percent"));
+    }
+    private static String decimal(BigDecimal value) { return value.stripTrailingZeros().toPlainString(); }
+    private static String seconds(Duration duration) {
+        return decimal(BigDecimal.valueOf(duration.toNanos()).movePointLeft(9));
+    }
+
+    @Override public void close() {
+        if (closed) return; closed = true;
+        if (sweepTask != null) sweepTask.cancel();
+        for (var state : List.copyOf(byGuardian.values())) state.execution.finish();
+        byGuardian.clear(); byAlly.clear();
+    }
+}

src/main/java/games/dmg/fantasystick/ability/Hex.java

@@ -0,0 +1,49 @@
+package games.dmg.fantasystick.ability;
+
+import games.dmg.fantasystick.progression.Stat;
+import games.dmg.fantasystick.session.ControlInput;
+import java.math.BigDecimal;
+import java.math.BigInteger;
+import java.time.Duration;
+import java.util.List;
+import java.util.Map;
+import java.util.Objects;
+import java.util.UUID;
+import org.bukkit.Location;
+import org.bukkit.Material;
+import org.bukkit.entity.LivingEntity;
+
+/** Hex's aimed, owned outgoing combat-damage penalty. */
+public final class Hex implements AbilityEffect,AutoCloseable{
+    public record Settings(Duration cooldown,double range,Duration duration,BigDecimal reductionPercent){
+        public Settings{Objects.requireNonNull(cooldown);Objects.requireNonNull(duration);Objects.requireNonNull(reductionPercent);
+            if(cooldown.isNegative()||cooldown.compareTo(Duration.ofDays(365))>0||!Double.isFinite(range)||range<=0||range>64
+                ||duration.isZero()||duration.isNegative()||duration.compareTo(Duration.ofDays(1))>0
+                ||reductionPercent.signum()<0||reductionPercent.compareTo(BigDecimal.valueOf(100))>0)throw new IllegalArgumentException("Invalid Hex settings");}
+        public static Settings defaults(){return new Settings(Duration.ofSeconds(10),12,Duration.ofSeconds(4),BigDecimal.valueOf(20));}}
+    private final class State implements AutoCloseable{final AbilityExecution execution;final LivingEntity target;final AutoCloseable grant;boolean closed;
+        State(AbilityExecution execution,LivingEntity target,AutoCloseable grant){this.execution=execution;this.target=target;this.grant=grant;}
+        @Override public void close(){if(closed)return;closed=true;hexes.remove(target.getUniqueId(),this);try{grant.close();}catch(Exception failure){throw new IllegalStateException(failure);}}}
+    private volatile Settings settings;private final OutgoingDamageMitigation mitigation;private final Map<UUID,State> hexes=new java.util.HashMap<>();private boolean closed;
+    public Hex(Settings settings,OutgoingDamageMitigation mitigation){this.settings=Objects.requireNonNull(settings);this.mitigation=Objects.requireNonNull(mitigation);}
+    public void configure(Settings settings){this.settings=Objects.requireNonNull(settings);}
+    public AbilityDefinition definition(){var current=settings;return new AbilityDefinition("hex","Hex",Material.SPIDER_EYE,
+        List.of("Reduce an aimed hostile's combat damage by "+current.reductionPercent().stripTrailingZeros().toPlainString()+"%.",
+            "Range "+BigDecimal.valueOf(current.range()).stripTrailingZeros().toPlainString()+" blocks; lasts "+seconds(current.duration())+" seconds."),
+        "Use while aiming at the first visible hostile; there is no fallback target.",Map.of(Stat.CHR,BigInteger.valueOf(14),Stat.WIS,BigInteger.valueOf(12)),BigInteger.ONE,
+        AbilityDefinition.Activation.DELAYED,ControlInput.Gesture.USE,current.cooldown(),Map.of("range",BigDecimal.valueOf(current.range()).stripTrailingZeros(),
+            "duration-seconds",BigDecimal.valueOf(current.duration().toNanos()).movePointLeft(9),"damage-reduction-percent",current.reductionPercent()),
+        AbilityDefinition.TargetPolicy.HOSTILE,this);}
+    @Override public boolean accepts(ControlInput input){return !closed&&input.target() instanceof LivingEntity target&&inRange(input,target,settings.range());}
+    @Override public void activate(AbilityExecution execution){if(closed||!execution.stillCurrent()||!(execution.input().target() instanceof LivingEntity target))return;
+        var current=from(execution.definition());if(!inRange(execution.input(),target,current.range())){execution.finish();return;}
+        var state=new State(execution,target,mitigation.grant(execution,target,current.reductionPercent()));var previous=hexes.put(target.getUniqueId(),state);
+        if(previous!=null)previous.execution.finish();execution.own(state);execution.later(current.duration(),execution::finish);}
+    private static boolean inRange(ControlInput input,LivingEntity target,double range){try{Location source=input.player().getLocation(),destination=target.getLocation();
+        return source.getWorld()==destination.getWorld()&&source.distanceSquared(destination)<=range*range&&input.player().hasLineOfSight(target);
+        }catch(RuntimeException invalid){return false;}}
+    private static Settings from(AbilityDefinition definition){var p=definition.parameters();return new Settings(definition.cooldown(),p.get("range").doubleValue(),
+        Duration.ofNanos(p.get("duration-seconds").movePointRight(9).longValueExact()),p.get("damage-reduction-percent"));}
+    private static String seconds(Duration value){return BigDecimal.valueOf(value.toNanos()).movePointLeft(9).stripTrailingZeros().toPlainString();}
+    @Override public void close(){if(closed)return;closed=true;for(var state:List.copyOf(hexes.values()))state.execution.finish();hexes.clear();}
+}

src/main/java/games/dmg/fantasystick/ability/Inspire.java

@@ -0,0 +1,16 @@
+package games.dmg.fantasystick.ability;
+import games.dmg.fantasystick.progression.Stat;import games.dmg.fantasystick.session.ControlInput;import java.math.*;import java.time.Duration;import java.util.*;import org.bukkit.*;import org.bukkit.entity.Player;
+/** Inspire's self-or-aimed fantasy-player temporary health grant. */
+public final class Inspire implements AbilityEffect,AutoCloseable{
+ public record Settings(BigInteger baseTemporaryHealth,Duration cooldown,double range,Duration duration){public Settings{Objects.requireNonNull(baseTemporaryHealth);Objects.requireNonNull(cooldown);Objects.requireNonNull(duration);if(baseTemporaryHealth.signum()<0||baseTemporaryHealth.compareTo(BigDecimal.valueOf(Double.MAX_VALUE).toBigInteger())>0||cooldown.isNegative()||cooldown.compareTo(Duration.ofDays(365))>0||!Double.isFinite(range)||range<=0||range>64||duration.isZero()||duration.isNegative()||duration.compareTo(Duration.ofDays(1))>0)throw new IllegalArgumentException("Invalid Inspire settings");}public static Settings defaults(){return new Settings(BigInteger.valueOf(4),Duration.ofSeconds(15),12,Duration.ofSeconds(6));}}
+ private volatile Settings settings;private final TemporaryHealth temporaryHealth;private boolean closed;
+ public Inspire(Settings settings,TemporaryHealth temporaryHealth){this.settings=Objects.requireNonNull(settings);this.temporaryHealth=Objects.requireNonNull(temporaryHealth);}public void configure(Settings settings){this.settings=Objects.requireNonNull(settings);}
+ public AbilityDefinition definition(){var s=settings;return new AbilityDefinition("inspire","Inspire",Material.AMETHYST_SHARD,List.of("Grant "+s.baseTemporaryHealth()+" + CHR modifier temporary health for "+seconds(s.duration())+" seconds.","Range "+BigDecimal.valueOf(s.range()).stripTrailingZeros().toPlainString()+" blocks for an aimed fantasy player."),"Sneak+Use selects self; normal Use requires an aimed fantasy player.",Map.of(Stat.CHR,BigInteger.valueOf(12),Stat.WIS,BigInteger.TEN),BigInteger.ONE,AbilityDefinition.Activation.DELAYED,ControlInput.Gesture.USE,s.cooldown(),Map.of("base-temporary-health",new BigDecimal(s.baseTemporaryHealth()),"range",BigDecimal.valueOf(s.range()).stripTrailingZeros(),"duration-seconds",BigDecimal.valueOf(s.duration().toNanos()).movePointLeft(9)),AbilityDefinition.TargetPolicy.ALLY,this);}
+ @Override public boolean accepts(ControlInput input){if(closed||!(input.target() instanceof Player target))return false;if(input.player().isSneaking())return target==input.player();return target!=input.player()&&inRange(input.player(),target,settings.range());}
+ public static BigInteger amount(BigInteger charisma){return amount(BigInteger.valueOf(4),charisma);}static BigInteger amount(BigInteger base,BigInteger charisma){Objects.requireNonNull(base);Objects.requireNonNull(charisma);if(base.signum()<0||charisma.signum()<0)throw new IllegalArgumentException("Invalid Inspire amount");var delta=charisma.subtract(BigInteger.TEN);var divided=delta.divideAndRemainder(BigInteger.TWO);var modifier=divided[0];if(delta.signum()<0&&divided[1].signum()!=0)modifier=modifier.subtract(BigInteger.ONE);return base.add(modifier);}
+ @Override public void activate(AbilityExecution execution){if(closed||!execution.stillCurrent()||!(execution.input().target() instanceof Player target))return;var s=from(execution.definition());if(execution.input().player().isSneaking()?target!=execution.input().player():target==execution.input().player()||!inRange(execution.input().player(),target,s.range())){execution.finish();return;}var exact=amount(s.baseTemporaryHealth(),execution.character().stats().get(Stat.CHR));double nativeAmount=exact.bitLength()>1023?Double.MAX_VALUE:exact.doubleValue();if(!Double.isFinite(nativeAmount)||nativeAmount<=0){execution.finish();return;}execution.own(temporaryHealth.grant(execution,target,nativeAmount));execution.later(s.duration(),execution::finish);}
+ private static boolean inRange(Player source,Player target,double range){try{var a=source.getLocation();var b=target.getLocation();return a.getWorld()==b.getWorld()&&a.distanceSquared(b)<=range*range&&source.hasLineOfSight(target);}catch(RuntimeException invalid){return false;}}
+ private static Settings from(AbilityDefinition d){var p=d.parameters();return new Settings(p.get("base-temporary-health").toBigIntegerExact(),d.cooldown(),p.get("range").doubleValue(),Duration.ofNanos(p.get("duration-seconds").movePointRight(9).longValueExact()));}
+ private static String seconds(Duration d){return BigDecimal.valueOf(d.toNanos()).movePointLeft(9).stripTrailingZeros().toPlainString();}
+ @Override public void close(){closed=true;}
+}

src/main/java/games/dmg/fantasystick/ability/MendingLight.java

@@ -0,0 +1,183 @@
+package games.dmg.fantasystick.ability;
+
+import games.dmg.fantasystick.party.PartyRoster;
+import games.dmg.fantasystick.persistence.CharacterRecord;
+import games.dmg.fantasystick.persistence.CharacterStorage;
+import games.dmg.fantasystick.progression.Stat;
+import games.dmg.fantasystick.session.ControlInput;
+import games.dmg.fantasystick.session.EquipmentSessions;
+import java.math.BigDecimal;
+import java.math.BigInteger;
+import java.time.Duration;
+import java.util.List;
+import java.util.Map;
+import java.util.Objects;
+import java.util.UUID;
+import java.util.function.Consumer;
+import java.util.function.Supplier;
+import org.bukkit.Material;
+import org.bukkit.attribute.Attribute;
+import org.bukkit.entity.Player;
+import org.bukkit.event.entity.EntityRegainHealthEvent;
+
+/** Mending Light's aimed party healing with persist-before-publication support evidence. */
+public final class MendingLight implements AbilityEffect {
+    public record Settings(BigInteger baseHealing, Duration cooldown, double range) {
+        public Settings {
+            Objects.requireNonNull(baseHealing); Objects.requireNonNull(cooldown);
+            if (baseHealing.signum() < 0
+                    || baseHealing.compareTo(BigDecimal.valueOf(Double.MAX_VALUE).toBigInteger()) > 0
+                    || cooldown.isNegative() || cooldown.compareTo(Duration.ofDays(365)) > 0
+                    || !Double.isFinite(range) || range <= 0 || range > 64) {
+                throw new IllegalArgumentException("Invalid Mending Light settings");
+            }
+        }
+        public static Settings defaults() { return new Settings(BigInteger.valueOf(6), Duration.ofSeconds(8), 12); }
+    }
+
+    public record Support(UUID supportingCharacter, EquipmentSessions.Active aided, BigDecimal amount) {
+        public Support {
+            Objects.requireNonNull(supportingCharacter); Objects.requireNonNull(aided); Objects.requireNonNull(amount);
+            if (amount.signum() <= 0) throw new IllegalArgumentException("Support amount must be positive");
+        }
+    }
+
+    private record Target(Player player, EquipmentSessions.Active active, CharacterRecord record) { }
+
+    private final CharacterStorage characters;
+    private final EquipmentSessions sessions;
+    private final PartyRoster parties;
+    private final Consumer<Runnable> nextTick;
+    private final Consumer<EntityRegainHealthEvent> healingEvents;
+    private final Supplier<BigDecimal> nativeLimit;
+    private final Consumer<Support> supports;
+    private volatile Settings settings;
+
+    public MendingLight(Settings settings, CharacterStorage characters, EquipmentSessions sessions, PartyRoster parties,
+                        Consumer<Runnable> nextTick, Consumer<EntityRegainHealthEvent> healingEvents,
+                        Supplier<BigDecimal> nativeLimit, Consumer<Support> supports) {
+        this.settings = Objects.requireNonNull(settings); this.characters = Objects.requireNonNull(characters);
+        this.sessions = Objects.requireNonNull(sessions); this.parties = Objects.requireNonNull(parties);
+        this.nextTick = Objects.requireNonNull(nextTick); this.healingEvents = Objects.requireNonNull(healingEvents);
+        this.nativeLimit = Objects.requireNonNull(nativeLimit); this.supports = Objects.requireNonNull(supports);
+    }
+
+    public void configure(Settings settings) { this.settings = Objects.requireNonNull(settings); }
+
+    public AbilityDefinition definition() {
+        var current = settings;
+        return new AbilityDefinition("mending_light", "Mending Light", Material.GHAST_TEAR,
+            List.of("Restore a party ally's missing fantasy health.",
+                "Heals " + current.baseHealing() + " + WIS modifier within " + decimal(current.range()) + " blocks."),
+            "Use while aiming at an injured active party ally; self and full-health targets are refused.",
+            Map.of(Stat.WIS, BigInteger.valueOf(12), Stat.CHR, BigInteger.TEN), BigInteger.ONE,
+            AbilityDefinition.Activation.DELAYED, ControlInput.Gesture.USE, current.cooldown(),
+            Map.of("base-healing", new BigDecimal(current.baseHealing()),
+                "range", BigDecimal.valueOf(current.range()).stripTrailingZeros()),
+            AbilityDefinition.TargetPolicy.PARTY, this);
+    }
+
+    @Override public boolean accepts(ControlInput input) {
+        var target = target(input, settings.range());
+        if (target == null) return false;
+        var attribute = target.player().getAttribute(Attribute.MAX_HEALTH);
+        double health = target.player().getHealth();
+        return attribute != null && Double.isFinite(health) && health >= 0
+            && Double.isFinite(attribute.getValue()) && health < attribute.getValue();
+    }
+
+    public static BigInteger healing(BigInteger wisdom) { return healing(BigInteger.valueOf(6), wisdom); }
+
+    static BigInteger healing(BigInteger base, BigInteger wisdom) {
+        Objects.requireNonNull(base); Objects.requireNonNull(wisdom);
+        if (base.signum() < 0 || wisdom.signum() < 0) throw new IllegalArgumentException("Invalid Mending Light healing input");
+        BigInteger delta = wisdom.subtract(BigInteger.TEN); BigInteger[] divided = delta.divideAndRemainder(BigInteger.TWO);
+        BigInteger modifier = divided[0];
+        if (delta.signum() < 0 && divided[1].signum() != 0) modifier = modifier.subtract(BigInteger.ONE);
+        return base.add(modifier);
+    }
+
+    @Override public void activate(AbilityExecution execution) {
+        if (!execution.stillCurrent()) return;
+        var configured = from(execution.definition());
+        var target = target(execution.input(), configured.range());
+        if (target == null) { execution.finish(); return; }
+        var attribute = target.player().getAttribute(Attribute.MAX_HEALTH);
+        if (attribute == null) { execution.finish(); return; }
+        double current = target.player().getHealth(); double maximum = attribute.getValue(); double missing = maximum - current;
+        if (!Double.isFinite(current) || !Double.isFinite(maximum) || missing <= 0) { execution.finish(); return; }
+        BigInteger exact = healing(configured.baseHealing(), execution.character().stats().get(Stat.WIS));
+        double proposed = exact.bitLength() > 1023 ? missing : Math.min(missing, exact.doubleValue());
+        if (!Double.isFinite(proposed) || proposed <= 0) { execution.finish(); return; }
+        var event = new EntityRegainHealthEvent(target.player(), proposed, EntityRegainHealthEvent.RegainReason.CUSTOM);
+        healingEvents.accept(event);
+        double accepted = Math.min(proposed, Math.min(missing, event.getAmount()));
+        if (event.isCancelled() || !Double.isFinite(accepted) || accepted <= 0) { execution.finish(); return; }
+        var expected = target.record().revision();
+        BigDecimal persistedHealth = BigDecimal.valueOf(current + accepted);
+        BigDecimal limit = nativeLimit.get();
+        characters.saveHealth(target.record().id(), expected, persistedHealth, limit).whenComplete((saved, failure) -> {
+            try {
+                nextTick.accept(() -> complete(execution, target, expected, accepted, saved, failure));
+            } catch (RuntimeException rejected) { execution.finish(); }
+        });
+    }
+
+    private void complete(AbilityExecution execution, Target target, BigInteger expected, double accepted,
+                          java.util.Optional<CharacterRecord> saved, Throwable failure) {
+        try {
+            if (failure != null || saved == null || saved.isEmpty()) {
+                execution.input().player().sendMessage("Mending Light health could not be saved; no healing was applied.");
+                return;
+            }
+            if (!execution.stillCurrent() || !current(execution.input().player(), target, from(execution.definition()).range())) return;
+            var persisted = saved.orElseThrow();
+            if (!sessions.acknowledgeProgress(target.active(), expected, persisted)) return;
+            var attribute = target.player().getAttribute(Attribute.MAX_HEALTH);
+            if (attribute == null) return;
+            double current = target.player().getHealth(); double maximum = attribute.getValue();
+            double desired = Math.min(maximum, persisted.health().doubleValue());
+            double restored = Math.min(accepted, desired - current);
+            if (!Double.isFinite(current) || !Double.isFinite(maximum) || !Double.isFinite(restored) || restored <= 0) return;
+            target.player().setHealth(Math.min(maximum, current + restored));
+            var amount = BigDecimal.valueOf(restored).stripTrailingZeros();
+            supports.accept(new Support(execution.input().session().character(), target.active(), amount));
+            execution.input().player().sendMessage("Mending Light restored " + amount.toPlainString() + " health.");
+            target.player().sendMessage("Mending Light restored " + amount.toPlainString() + " health.");
+        } finally { execution.finish(); }
+    }
+
+    private Target target(ControlInput input, double range) {
+        if (!(input.target() instanceof Player player) || player == input.player() || !inRange(input.player(), player, range)
+                || !sameParty(input.player(), player)) return null;
+        var active = sessions.active(player.getUniqueId()).filter(sessions::current).orElse(null);
+        var record = active == null ? null : sessions.currentRecord(active).orElse(null);
+        return record == null ? null : new Target(player, active, record);
+    }
+
+    private boolean current(Player source, Target target, double range) {
+        return sessions.current(target.active())
+            && sessions.currentRecord(target.active()).filter(record -> record.id().equals(target.record().id())).isPresent()
+            && inRange(source, target.player(), range) && sameParty(source, target.player());
+    }
+
+    private boolean sameParty(Player source, Player target) {
+        var party = parties.partyOf(source.getUniqueId()).orElse(null);
+        return party != null && party.members().contains(target.getUniqueId());
+    }
+
+    private static boolean inRange(Player source, Player target, double range) {
+        try {
+            var from = source.getLocation(); var to = target.getLocation();
+            return from.getWorld() == to.getWorld() && from.distanceSquared(to) <= range * range && source.hasLineOfSight(target);
+        } catch (RuntimeException invalid) { return false; }
+    }
+
+    private static Settings from(AbilityDefinition definition) {
+        var parameters = definition.parameters();
+        return new Settings(parameters.get("base-healing").toBigIntegerExact(), definition.cooldown(),
+            parameters.get("range").doubleValue());
+    }
+
+    private static String decimal(double value) { return BigDecimal.valueOf(value).stripTrailingZeros().toPlainString(); }
+}

src/main/java/games/dmg/fantasystick/ability/OutgoingDamageBonus.java

@@ -0,0 +1,114 @@
+package games.dmg.fantasystick.ability;
+
+import games.dmg.fantasystick.party.PartyRoster;
+import games.dmg.fantasystick.session.EquipmentSessions;
+import java.math.BigDecimal;
+import java.util.ArrayList;
+import java.util.IdentityHashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Objects;
+import java.util.UUID;
+import java.util.function.BooleanSupplier;
+import java.util.function.Consumer;
+import org.bukkit.entity.Entity;
+import org.bukkit.entity.Player;
+import org.bukkit.entity.Projectile;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.EventPriority;
+import org.bukkit.event.Listener;
+import org.bukkit.event.entity.EntityDamageByEntityEvent;
+import org.bukkit.event.entity.EntityDamageEvent;
+import org.bukkit.projectiles.ProjectileSource;
+
+/** Strongest deterministic Fantasy Stick outgoing combat bonus stage. */
+public final class OutgoingDamageBonus implements Listener, AutoCloseable {
+    public record Support(UUID target, UUID supportingCharacter, EquipmentSessions.Active aided, BigDecimal amount) { }
+    private final class Grant implements AutoCloseable {
+        final long sequence; final AbilityExecution execution; final Player recipient;
+        final BigDecimal percent; final BooleanSupplier current; boolean closed;
+        Grant(AbilityExecution execution, Player recipient, BigDecimal percent, BooleanSupplier current) {
+            sequence = ++sequences; this.execution = execution; this.recipient = recipient;
+            this.percent = percent; this.current = current;
+        }
+        boolean valid() {
+            try { return !closed && execution.stillCurrent() && current.getAsBoolean(); }
+            catch (RuntimeException invalid) { return false; }
+        }
+        @Override public void close() {
+            if (closed) return; closed = true;
+            var owned = grants.get(recipient.getUniqueId());
+            if (owned != null) { owned.remove(this); if (owned.isEmpty()) grants.remove(recipient.getUniqueId()); }
+        }
+    }
+    private record Used(Grant grant, Entity target, BigDecimal amount) { }
+
+    private final EquipmentSessions sessions;
+    private final PartyRoster parties;
+    private final Consumer<Support> supports;
+    private final Map<UUID, List<Grant>> grants = new java.util.HashMap<>();
+    private final Map<EntityDamageEvent, Used> pending = new IdentityHashMap<>();
+    private long sequences;
+    private boolean closed;
+
+    public OutgoingDamageBonus(EquipmentSessions sessions, PartyRoster parties, Consumer<Support> supports) {
+        this.sessions = Objects.requireNonNull(sessions); this.parties = Objects.requireNonNull(parties);
+        this.supports = Objects.requireNonNull(supports);
+    }
+
+    public AutoCloseable grant(AbilityExecution execution, Player recipient, BigDecimal percent, BooleanSupplier current) {
+        Objects.requireNonNull(execution); Objects.requireNonNull(recipient);
+        Objects.requireNonNull(percent); Objects.requireNonNull(current);
+        if (closed || percent.signum() < 0 || percent.compareTo(BigDecimal.valueOf(1000)) > 0) {
+            throw new IllegalArgumentException("Invalid outgoing damage bonus");
+        }
+        var grant = new Grant(execution, recipient, percent, current);
+        grants.computeIfAbsent(recipient.getUniqueId(), ignored -> new ArrayList<>()).add(grant); return grant;
+    }
+
+    @EventHandler(priority = EventPriority.NORMAL, ignoreCancelled = true)
+    public void increase(EntityDamageByEntityEvent event) {
+        if (closed || GuardianBond.redirectedDamage()) return;
+        Entity attacker = attacker(event); if (!(attacker instanceof Player player)) return;
+        var owned = grants.get(player.getUniqueId()); if (owned == null) return;
+        Grant strongest = null;
+        for (var grant : List.copyOf(owned)) {
+            if (grant.recipient != player || !grant.valid()) continue;
+            if (strongest == null || grant.percent.compareTo(strongest.percent) > 0
+                    || grant.percent.compareTo(strongest.percent) == 0 && grant.sequence < strongest.sequence) strongest = grant;
+        }
+        double original = event.getDamage();
+        if (strongest == null || !Double.isFinite(original) || original <= 0) return;
+        BigDecimal added = BigDecimal.valueOf(original).multiply(strongest.percent.movePointLeft(2));
+        double increased = BigDecimal.valueOf(original).add(added).doubleValue();
+        if (!Double.isFinite(increased) || increased < 0 || added.signum() <= 0) return;
+        event.setDamage(increased); pending.put(event, new Used(strongest, event.getEntity(), added));
+    }
+
+    @EventHandler(priority = EventPriority.MONITOR)
+    public void accepted(EntityDamageEvent event) {
+        var used = pending.remove(event);
+        if (used == null || event.isCancelled() || event.getFinalDamage() <= 0 || !used.grant.valid()) return;
+        used.grant.execution.report(AbilityReport.Type.BOOST_USED, used.target, used.amount);
+        var aided = sessions.active(used.grant.recipient.getUniqueId()).filter(sessions::current).orElse(null);
+        if (aided == null || aided.character().equals(used.grant.execution.input().session().character())) return;
+        var sourceParty = parties.partyOf(used.grant.execution.input().player().getUniqueId()).orElse(null);
+        var aidedParty = parties.partyOf(used.grant.recipient.getUniqueId()).orElse(null);
+        if (sourceParty == null || aidedParty == null || !sourceParty.id().equals(aidedParty.id())) return;
+        supports.accept(new Support(used.target.getUniqueId(), used.grant.execution.input().session().character(), aided, used.amount));
+    }
+
+    private static Entity attacker(EntityDamageByEntityEvent event) {
+        Entity causing = event.getDamageSource().getCausingEntity(); if (causing != null) return causing;
+        if (event.getDamager() instanceof Projectile projectile) {
+            ProjectileSource shooter = projectile.getShooter(); if (shooter instanceof Entity entity) return entity;
+        }
+        return event.getDamager();
+    }
+
+    @Override public void close() {
+        if (closed) return; closed = true;
+        for (var owned : List.copyOf(grants.values())) for (var grant : List.copyOf(owned)) grant.close();
+        grants.clear(); pending.clear();
+    }
+}

src/main/java/games/dmg/fantasystick/ability/OutgoingDamageMitigation.java

@@ -0,0 +1,78 @@
+package games.dmg.fantasystick.ability;
+
+import games.dmg.fantasystick.party.PartyRoster;
+import games.dmg.fantasystick.session.EquipmentSessions;
+import java.math.BigDecimal;
+import java.util.ArrayList;
+import java.util.IdentityHashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Objects;
+import java.util.UUID;
+import java.util.function.Consumer;
+import org.bukkit.entity.Entity;
+import org.bukkit.entity.LivingEntity;
+import org.bukkit.entity.Player;
+import org.bukkit.entity.Projectile;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.EventPriority;
+import org.bukkit.event.Listener;
+import org.bukkit.event.entity.EntityDamageByEntityEvent;
+import org.bukkit.event.entity.EntityDamageEvent;
+import org.bukkit.projectiles.ProjectileSource;
+
+/** Internal pre-recipient strongest outgoing-damage reduction stage. */
+public final class OutgoingDamageMitigation implements Listener, AutoCloseable {
+    public record Support(UUID target, UUID supportingCharacter, EquipmentSessions.Active aided, BigDecimal amount) { }
+    private final class Grant implements AutoCloseable {
+        final long sequence; final AbilityExecution execution; final LivingEntity target; final BigDecimal percent; boolean closed;
+        Grant(AbilityExecution execution, LivingEntity target, BigDecimal percent) {
+            this.sequence=++sequences;this.execution=execution;this.target=target;this.percent=percent;
+        }
+        @Override public void close(){if(closed)return;closed=true;var owned=grants.get(target.getUniqueId());
+            if(owned!=null){owned.remove(this);if(owned.isEmpty())grants.remove(target.getUniqueId());}}
+    }
+    private record Prevention(Grant grant, Entity recipient, BigDecimal amount) { }
+    private final EquipmentSessions sessions; private final PartyRoster parties; private final Consumer<Support> supports;
+    private final Map<UUID,List<Grant>> grants=new java.util.HashMap<>();
+    private final Map<EntityDamageEvent,Prevention> pending=new IdentityHashMap<>();
+    private long sequences; private boolean closed;
+    public OutgoingDamageMitigation(EquipmentSessions sessions,PartyRoster parties,Consumer<Support> supports){
+        this.sessions=Objects.requireNonNull(sessions);this.parties=Objects.requireNonNull(parties);this.supports=Objects.requireNonNull(supports);}
+    public AutoCloseable grant(AbilityExecution execution,LivingEntity target,BigDecimal percent){
+        Objects.requireNonNull(execution);Objects.requireNonNull(target);Objects.requireNonNull(percent);
+        if(closed||percent.signum()<0||percent.compareTo(BigDecimal.valueOf(100))>0)throw new IllegalArgumentException("Invalid outgoing mitigation grant");
+        var grant=new Grant(execution,target,percent);grants.computeIfAbsent(target.getUniqueId(),ignored->new ArrayList<>()).add(grant);return grant;}
+
+    @EventHandler(priority=EventPriority.NORMAL,ignoreCancelled=true)
+    public void reduce(EntityDamageByEntityEvent event){
+        if(closed||GuardianBond.redirectedDamage())return;Entity attacker=attacker(event);if(attacker==null)return;var owned=grants.get(attacker.getUniqueId());if(owned==null)return;
+        Grant strongest=null;for(var grant:List.copyOf(owned)){if(grant.closed||grant.target!=attacker||!grant.execution.stillCurrent())continue;
+            if(strongest==null||grant.percent.compareTo(strongest.percent)>0
+                    ||grant.percent.compareTo(strongest.percent)==0&&grant.sequence>strongest.sequence)strongest=grant;}
+        double original=event.getDamage();if(strongest==null||!Double.isFinite(original)||original<=0)return;
+        double reduced=BigDecimal.valueOf(original).multiply(BigDecimal.ONE.subtract(strongest.percent.movePointLeft(2))).doubleValue();
+        if(!Double.isFinite(reduced)||reduced<0)return;event.setDamage(reduced);var prevented=BigDecimal.valueOf(original-reduced);
+        if(prevented.signum()>0)pending.put(event,new Prevention(strongest,event.getEntity(),prevented));
+    }
+
+    @EventHandler(priority=EventPriority.MONITOR)
+    public void accepted(EntityDamageEvent event){
+        var prevention=pending.remove(event);if(prevention==null||event.isCancelled()||!prevention.grant.execution.stillCurrent())return;
+        prevention.grant.execution.report(AbilityReport.Type.PREVENTION,prevention.grant.target,prevention.amount);
+        if(!(prevention.recipient instanceof Player player))return;
+        var aided=sessions.active(player.getUniqueId()).orElse(null);if(aided==null||!sessions.current(aided))return;
+        var input=prevention.grant.execution.input();if(aided.character().equals(input.session().character()))return;
+        var sourceParty=parties.partyOf(input.player().getUniqueId()).orElse(null);
+        var aidedParty=parties.partyOf(player.getUniqueId()).orElse(null);
+        if(sourceParty==null||aidedParty==null||!sourceParty.id().equals(aidedParty.id()))return;
+        supports.accept(new Support(prevention.grant.target.getUniqueId(),input.session().character(),aided,prevention.amount));
+    }
+
+    private static Entity attacker(EntityDamageByEntityEvent event){
+        Entity causing=event.getDamageSource().getCausingEntity();if(causing!=null)return causing;
+        if(event.getDamager() instanceof Projectile projectile){ProjectileSource shooter=projectile.getShooter();if(shooter instanceof Entity entity)return entity;}
+        return event.getDamager();
+    }
+    @Override public void close(){if(closed)return;closed=true;for(var owned:List.copyOf(grants.values()))for(var grant:List.copyOf(owned))grant.close();grants.clear();pending.clear();}
+}

src/main/java/games/dmg/fantasystick/ability/Purify.java

@@ -0,0 +1,128 @@
+package games.dmg.fantasystick.ability;
+
+import games.dmg.fantasystick.party.PartyRoster;
+import games.dmg.fantasystick.progression.Stat;
+import games.dmg.fantasystick.session.ControlInput;
+import games.dmg.fantasystick.session.EquipmentSessions;
+import java.math.BigDecimal;
+import java.math.BigInteger;
+import java.time.Duration;
+import java.util.List;
+import java.util.Map;
+import java.util.Objects;
+import java.util.UUID;
+import java.util.function.Consumer;
+import org.bukkit.Material;
+import org.bukkit.entity.Player;
+import org.bukkit.potion.PotionEffectType;
+
+/** Purify's self-or-aimed-party native harmful-effect removal. */
+public final class Purify implements AbilityEffect {
+    public record Settings(Duration cooldown, double range) {
+        public Settings {
+            Objects.requireNonNull(cooldown);
+            if (cooldown.isNegative() || cooldown.compareTo(Duration.ofDays(365)) > 0
+                    || !Double.isFinite(range) || range <= 0 || range > 64) {
+                throw new IllegalArgumentException("Invalid Purify settings");
+            }
+        }
+        public static Settings defaults() { return new Settings(Duration.ofSeconds(15), 12); }
+    }
+
+    public record Support(UUID supportingCharacter, EquipmentSessions.Active aided, BigDecimal amount) {
+        public Support {
+            Objects.requireNonNull(supportingCharacter); Objects.requireNonNull(aided); Objects.requireNonNull(amount);
+            if (amount.signum() <= 0) throw new IllegalArgumentException("Support amount must be positive");
+        }
+    }
+
+    private record Target(Player player, EquipmentSessions.Active active) { }
+    private static final List<PotionEffectType> HARMFUL = List.of(
+        PotionEffectType.POISON, PotionEffectType.WITHER, PotionEffectType.SLOWNESS, PotionEffectType.WEAKNESS);
+
+    private final EquipmentSessions sessions;
+    private final PartyRoster parties;
+    private final Consumer<Support> supports;
+    private volatile Settings settings;
+
+    public Purify(Settings settings, EquipmentSessions sessions, PartyRoster parties, Consumer<Support> supports) {
+        this.settings = Objects.requireNonNull(settings); this.sessions = Objects.requireNonNull(sessions);
+        this.parties = Objects.requireNonNull(parties); this.supports = Objects.requireNonNull(supports);
+    }
+
+    public void configure(Settings settings) { this.settings = Objects.requireNonNull(settings); }
+
+    public AbilityDefinition definition() {
+        var current = settings;
+        return new AbilityDefinition("purify", "Purify", Material.HONEY_BOTTLE,
+            List.of("Remove Poison, Wither, Slowness and Weakness.",
+                "Aimed party-ally range: " + decimal(current.range()) + " blocks; beneficial effects remain."),
+            "Sneak+Use cleanses self; normal Use requires an aimed active party ally.",
+            Map.of(Stat.WIS, BigInteger.valueOf(14), Stat.CHR, BigInteger.TEN), BigInteger.ONE,
+            AbilityDefinition.Activation.IMMEDIATE, ControlInput.Gesture.USE, current.cooldown(),
+            Map.of("range", BigDecimal.valueOf(current.range()).stripTrailingZeros()),
+            AbilityDefinition.TargetPolicy.PARTY, this);
+    }
+
+    @Override public boolean accepts(ControlInput input) {
+        var target = target(input, settings.range());
+        return target != null && HARMFUL.stream().anyMatch(type -> target.player().getPotionEffect(type) != null);
+    }
+
+    @Override public void activate(AbilityExecution execution) {
+        if (!execution.stillCurrent()) return;
+        var configured = from(execution.definition()); var target = target(execution.input(), configured.range());
+        if (target == null) return;
+        int removed = 0;
+        for (var type : HARMFUL) {
+            if (!execution.stillCurrent() || !current(execution.input(), target, configured.range())) break;
+            if (target.player().getPotionEffect(type) == null) continue;
+            target.player().removePotionEffect(type);
+            if (target.player().getPotionEffect(type) == null) removed++;
+        }
+        if (removed == 0) return;
+        execution.input().player().sendMessage("Purify removed " + removed + " harmful effect" + (removed == 1 ? "." : "s."));
+        if (target.player() != execution.input().player()
+                && execution.stillCurrent() && current(execution.input(), target, configured.range())) {
+            var amount = BigDecimal.valueOf(removed);
+            supports.accept(new Support(execution.input().session().character(), target.active(), amount));
+            target.player().sendMessage("Purify removed " + removed + " harmful effect" + (removed == 1 ? "." : "s."));
+        }
+    }
+
+    private Target target(ControlInput input, double range) {
+        if (!(input.target() instanceof Player player)) return null;
+        if (input.player().isSneaking()) {
+            if (player != input.player()) return null;
+        } else if (player == input.player() || !inRange(input.player(), player, range) || !sameParty(input.player(), player)) {
+            return null;
+        }
+        var active = sessions.active(player.getUniqueId()).filter(sessions::current).orElse(null);
+        return active == null ? null : new Target(player, active);
+    }
+
+    private boolean current(ControlInput input, Target target, double range) {
+        if (!sessions.current(target.active())) return false;
+        if (target.player() == input.player()) return input.player().isSneaking();
+        return !input.player().isSneaking() && inRange(input.player(), target.player(), range)
+            && sameParty(input.player(), target.player());
+    }
+
+    private boolean sameParty(Player source, Player target) {
+        var party = parties.partyOf(source.getUniqueId()).orElse(null);
+        return party != null && party.members().contains(target.getUniqueId());
+    }
+
+    private static boolean inRange(Player source, Player target, double range) {
+        try {
+            var from = source.getLocation(); var to = target.getLocation();
+            return from.getWorld() == to.getWorld() && from.distanceSquared(to) <= range * range && source.hasLineOfSight(target);
+        } catch (RuntimeException invalid) { return false; }
+    }
+
+    private static Settings from(AbilityDefinition definition) {
+        return new Settings(definition.cooldown(), definition.parameters().get("range").doubleValue());
+    }
+
+    private static String decimal(double value) { return BigDecimal.valueOf(value).stripTrailingZeros().toPlainString(); }
+}

src/main/java/games/dmg/fantasystick/ability/RallyingCry.java

@@ -0,0 +1,227 @@
+package games.dmg.fantasystick.ability;
+
+import games.dmg.fantasystick.party.PartyRoster;
+import games.dmg.fantasystick.progression.Stat;
+import games.dmg.fantasystick.session.ControlInput;
+import games.dmg.fantasystick.session.EquipmentSessions;
+import java.math.BigDecimal;
+import java.math.BigInteger;
+import java.time.Duration;
+import java.util.ArrayList;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Objects;
+import java.util.UUID;
+import org.bukkit.Material;
+import org.bukkit.entity.Entity;
+import org.bukkit.entity.Player;
+import org.bukkit.potion.PotionEffect;
+import org.bukkit.potion.PotionEffectType;
+
+/** Dynamic owned party sphere for Rallying Cry movement and outgoing damage benefits. */
+public final class RallyingCry implements AbilityEffect, AutoCloseable {
+    public record Settings(Duration cooldown, double radius, Duration duration,
+                           int speedAmplifier, BigDecimal damageBonusPercent) {
+        public Settings {
+            Objects.requireNonNull(cooldown); Objects.requireNonNull(duration); Objects.requireNonNull(damageBonusPercent);
+            if (cooldown.isNegative() || cooldown.compareTo(Duration.ofDays(365)) > 0
+                    || !Double.isFinite(radius) || radius <= 0 || radius > 64
+                    || duration.isNegative() || duration.isZero() || duration.compareTo(Duration.ofDays(1)) > 0
+                    || speedAmplifier < 0 || speedAmplifier > 255
+                    || damageBonusPercent.signum() < 0 || damageBonusPercent.compareTo(BigDecimal.valueOf(100)) > 0) {
+                throw new IllegalArgumentException("Invalid Rallying Cry settings");
+            }
+        }
+        public static Settings defaults() {
+            return new Settings(Duration.ofSeconds(25), 8, Duration.ofSeconds(6), 0, BigDecimal.valueOf(20));
+        }
+    }
+
+    private final class Area implements AutoCloseable {
+        final long sequence; final AbilityExecution execution; final Player source; final Settings settings;
+        final Map<UUID, Benefit> recipients = new java.util.HashMap<>(); boolean closed;
+        Area(AbilityExecution execution, Settings settings) {
+            sequence = ++sequences; this.execution = execution; source = execution.input().player(); this.settings = settings;
+        }
+        void refresh() {
+            if (closed) return;
+            if (!sourceCurrent()) { breakArea(this); return; }
+            var eligible = candidates();
+            for (var entry : List.copyOf(recipients.entrySet())) {
+                if (!eligible.containsKey(entry.getKey())) entry.getValue().close();
+            }
+            for (var entry : eligible.entrySet()) {
+                if (!recipients.containsKey(entry.getKey())) {
+                    var benefit = new Benefit(this, entry.getValue()); recipients.put(entry.getKey(), benefit);
+                }
+            }
+        }
+        boolean sourceCurrent() {
+            return execution.stillCurrent() && sessions.active(source.getUniqueId())
+                .filter(active -> active.equals(execution.input().session()) && sessions.current(active)).isPresent();
+        }
+        boolean eligible(Player player) {
+            if (!sourceCurrent()) return false;
+            var active = sessions.active(player.getUniqueId()).filter(sessions::current).orElse(null);
+            if (active == null || !inside(source, player, settings.radius())) return false;
+            if (player == source) return active.equals(execution.input().session());
+            var sourceParty = parties.partyOf(source.getUniqueId()).orElse(null);
+            var recipientParty = parties.partyOf(player.getUniqueId()).orElse(null);
+            return sourceParty != null && recipientParty != null && sourceParty.id().equals(recipientParty.id());
+        }
+        Map<UUID, Player> candidates() {
+            var result = new LinkedHashMap<UUID, Player>();
+            if (eligible(source)) result.put(source.getUniqueId(), source);
+            List<Entity> nearby;
+            try { nearby = source.getNearbyEntities(settings.radius(), settings.radius(), settings.radius()); }
+            catch (RuntimeException unavailable) { nearby = List.of(); }
+            int inspected = 0;
+            for (var entity : nearby) {
+                if (++inspected > 256 || result.size() == 64) break;
+                if (entity instanceof Player player && eligible(player)) result.putIfAbsent(player.getUniqueId(), player);
+            }
+            return result;
+        }
+        @Override public void close() {
+            if (closed) return; closed = true; areas.remove(sequence, this);
+            for (var benefit : List.copyOf(recipients.values())) benefit.close(); recipients.clear();
+        }
+    }
+
+    private final class Benefit implements AutoCloseable {
+        final Area area; final Player player; final AutoCloseable speed; final AutoCloseable bonus; boolean closed;
+        Benefit(Area area, Player player) {
+            this.area = area; this.player = player;
+            speed = speed(player, area.settings.speedAmplifier());
+            bonus = bonuses.grant(area.execution, player, area.settings.damageBonusPercent(), () -> !closed && area.eligible(player));
+        }
+        @Override public void close() {
+            if (closed) return; closed = true; area.recipients.remove(player.getUniqueId(), this);
+            closeResource(bonus); closeResource(speed);
+        }
+    }
+
+    private final class SpeedGrant implements AutoCloseable {
+        final SpeedState state; final long sequence; final int amplifier; boolean closed;
+        SpeedGrant(SpeedState state, int amplifier) { this.state = state; sequence = ++speedSequences; this.amplifier = amplifier; }
+        @Override public void close() { if (closed) return; closed = true; state.grants.remove(this); state.refresh(); }
+    }
+    private final class SpeedState {
+        final Player player; final List<SpeedGrant> grants = new ArrayList<>(); PotionEffect owned;
+        SpeedState(Player player) { this.player = player; }
+        void refresh() {
+            PotionEffect current;
+            try { current = player.getPotionEffect(PotionEffectType.SPEED); }
+            catch (RuntimeException unavailable) { return; }
+            if (owned != null && !same(current, owned)) owned = null;
+            SpeedGrant strongest = null;
+            for (var grant : List.copyOf(grants)) if (!grant.closed && (strongest == null
+                    || grant.amplifier > strongest.amplifier
+                    || grant.amplifier == strongest.amplifier && grant.sequence < strongest.sequence)) strongest = grant;
+            if (strongest == null) {
+                if (owned != null && same(current, owned) && !removeOwned()) return;
+                owned = null; speeds.remove(player.getUniqueId(), this); return;
+            }
+            if (owned != null && same(current, owned) && owned.getAmplifier() != strongest.amplifier) {
+                if (!removeOwned()) return;
+                current = null;
+            }
+            if (current != null && current.getAmplifier() >= strongest.amplifier) return;
+            var effect = new PotionEffect(PotionEffectType.SPEED, PotionEffect.INFINITE_DURATION,
+                strongest.amplifier, false, false, true);
+            try { if (player.addPotionEffect(effect, true)) owned = effect; }
+            catch (RuntimeException ignored) { owned = null; }
+        }
+        boolean removeOwned() {
+            try {
+                player.removePotionEffect(PotionEffectType.SPEED);
+                if (same(player.getPotionEffect(PotionEffectType.SPEED), owned)) return false;
+            } catch (RuntimeException failure) { return false; }
+            owned = null; return true;
+        }
+    }
+
+    private volatile Settings settings;
+    private final EquipmentSessions sessions;
+    private final PartyRoster parties;
+    private final OutgoingDamageBonus bonuses;
+    private final Map<Long, Area> areas = new java.util.HashMap<>();
+    private final Map<UUID, SpeedState> speeds = new java.util.HashMap<>();
+    private long sequences; private long speedSequences;
+    private org.bukkit.scheduler.BukkitTask sweepTask;
+    private boolean closed;
+
+    public RallyingCry(Settings settings, EquipmentSessions sessions, PartyRoster parties, OutgoingDamageBonus bonuses) {
+        this.settings = Objects.requireNonNull(settings); this.sessions = Objects.requireNonNull(sessions);
+        this.parties = Objects.requireNonNull(parties); this.bonuses = Objects.requireNonNull(bonuses);
+    }
+    public void configure(Settings settings) { this.settings = Objects.requireNonNull(settings); }
+    public void install(org.bukkit.plugin.Plugin plugin) {
+        Objects.requireNonNull(plugin);
+        if (closed || sweepTask != null) throw new IllegalStateException("Rallying Cry sweep already installed or closed");
+        sweepTask = plugin.getServer().getScheduler().runTaskTimer(plugin, this::sweep, 1, 1);
+    }
+    public void sweep() {
+        if (closed) return; int checked = 0;
+        for (var area : List.copyOf(areas.values())) { area.refresh(); if (++checked == 64) break; }
+        for (var state : List.copyOf(speeds.values())) state.refresh();
+    }
+
+    public AbilityDefinition definition() {
+        var current = settings;
+        return new AbilityDefinition("rallying_cry", "Rallying Cry", Material.GOAT_HORN,
+            List.of("Grant nearby active party members Speed " + (current.speedAmplifier() + 1)
+                    + " and " + decimal(current.damageBonusPercent()) + "% combat damage.",
+                "A " + decimal(BigDecimal.valueOf(current.radius())) + "-block sphere lasting " + seconds(current.duration()) + " seconds."),
+            "Use to rally yourself and nearby active party members; copies do not stack.",
+            Map.of(Stat.CHR, BigInteger.valueOf(16), Stat.CON, BigInteger.valueOf(12)), BigInteger.ONE,
+            AbilityDefinition.Activation.DELAYED, ControlInput.Gesture.USE, current.cooldown(),
+            Map.of("radius", BigDecimal.valueOf(current.radius()).stripTrailingZeros(),
+                "duration-seconds", BigDecimal.valueOf(current.duration().toNanos()).movePointLeft(9),
+                "speed-amplifier", BigDecimal.valueOf(current.speedAmplifier()),
+                "damage-bonus-percent", current.damageBonusPercent()), AbilityDefinition.TargetPolicy.AREA, this);
+    }
+
+    @Override public boolean accepts(ControlInput input) { return !closed && input.target() == null; }
+    @Override public void activate(AbilityExecution execution) {
+        if (closed || !execution.stillCurrent()) return;
+        var area = new Area(execution, from(execution.definition())); areas.put(area.sequence, area);
+        execution.own(area); area.refresh(); execution.later(area.settings.duration(), execution::finish);
+    }
+
+    private AutoCloseable speed(Player player, int amplifier) {
+        var state = speeds.computeIfAbsent(player.getUniqueId(), ignored -> new SpeedState(player));
+        var grant = new SpeedGrant(state, amplifier); state.grants.add(grant); state.refresh(); return grant;
+    }
+    private void breakArea(Area area) { area.close(); area.execution.finish(); }
+    private static boolean inside(Player source, Player target, double radius) {
+        try { var a = source.getLocation(); var b = target.getLocation();
+            return a.getWorld() == b.getWorld() && a.distanceSquared(b) <= radius * radius;
+        } catch (RuntimeException invalid) { return false; }
+    }
+    private static boolean same(PotionEffect first, PotionEffect second) {
+        return first != null && second != null && first.getType().equals(second.getType())
+            && first.getAmplifier() == second.getAmplifier() && first.isInfinite() && second.isInfinite();
+    }
+    private static void closeResource(AutoCloseable resource) {
+        try { resource.close(); } catch (Exception impossible) { throw new IllegalStateException(impossible); }
+    }
+    private static Settings from(AbilityDefinition definition) {
+        var parameters = definition.parameters();
+        return new Settings(definition.cooldown(), parameters.get("radius").doubleValue(),
+            Duration.ofNanos(parameters.get("duration-seconds").movePointRight(9).longValueExact()),
+            parameters.get("speed-amplifier").intValueExact(), parameters.get("damage-bonus-percent"));
+    }
+    private static String decimal(BigDecimal value) { return value.stripTrailingZeros().toPlainString(); }
+    private static String seconds(Duration duration) {
+        return decimal(BigDecimal.valueOf(duration.toNanos()).movePointLeft(9));
+    }
+
+    @Override public void close() {
+        if (closed) return; closed = true; if (sweepTask != null) sweepTask.cancel();
+        for (var area : List.copyOf(areas.values())) area.execution.finish(); areas.clear();
+        for (var state : List.copyOf(speeds.values())) { state.grants.clear(); state.refresh(); }
+        speeds.clear();
+    }
+}

src/main/java/games/dmg/fantasystick/ability/Revive.java

@@ -351,7 +351,9 @@ public final class Revive implements AbilityEffect, Listener, AutoCloseable {
                 target.getInventory().setItem(reservation.sourceSlot(), remaining); target.updateInventory();
             }
             var nativeLimit = games.dmg.fantasystick.session.NativeHealthLimit.read();
-            characters.restoreDeathRecord(reservation.character(), reservation.death(), nativeLimit)
+            (reservation.administrative()
+                ? characters.restoreDeathRecordAdministratively(reservation.character(), reservation.death(), nativeLimit)
+                : characters.restoreDeathRecord(reservation.character(), reservation.death(), nativeLimit))
                 .whenComplete((restored, failure) -> schedule(() -> {
                     if (failure != null) { report(failure); return; }
                     if (restored.isPresent() && installFinalSheet(target, restored.orElseThrow())) {

src/main/java/games/dmg/fantasystick/ability/SecondWind.java

@@ -0,0 +1,115 @@
+package games.dmg.fantasystick.ability;
+
+import games.dmg.fantasystick.persistence.CharacterStorage;
+import games.dmg.fantasystick.progression.Stat;
+import games.dmg.fantasystick.session.ControlInput;
+import games.dmg.fantasystick.session.EquipmentSessions;
+import java.math.BigDecimal;
+import java.math.BigInteger;
+import java.time.Duration;
+import java.util.List;
+import java.util.Map;
+import java.util.Objects;
+import java.util.function.Consumer;
+import java.util.function.Supplier;
+import org.bukkit.Material;
+import org.bukkit.attribute.Attribute;
+import org.bukkit.event.entity.EntityRegainHealthEvent;
+
+/** Second Wind's validated persist-before-publication self-heal. */
+public final class SecondWind implements AbilityEffect {
+    public record Settings(BigInteger baseHealing, Duration cooldown) {
+        public Settings {
+            Objects.requireNonNull(baseHealing); Objects.requireNonNull(cooldown);
+            if (baseHealing.signum() < 0 || baseHealing.compareTo(BigDecimal.valueOf(Double.MAX_VALUE).toBigInteger()) > 0
+                    || cooldown.isNegative() || cooldown.compareTo(Duration.ofDays(365)) > 0) {
+                throw new IllegalArgumentException("Invalid Second Wind settings");
+            }
+        }
+        public static Settings defaults() { return new Settings(BigInteger.valueOf(6), Duration.ofSeconds(15)); }
+    }
+
+    private final CharacterStorage characters;
+    private final EquipmentSessions sessions;
+    private final Consumer<Runnable> nextTick;
+    private final Consumer<EntityRegainHealthEvent> healingEvents;
+    private final Supplier<BigDecimal> nativeLimit;
+    private volatile Settings settings;
+
+    public SecondWind(Settings settings, CharacterStorage characters, EquipmentSessions sessions,
+                      Consumer<Runnable> nextTick, Consumer<EntityRegainHealthEvent> healingEvents,
+                      Supplier<BigDecimal> nativeLimit) {
+        this.settings = Objects.requireNonNull(settings); this.characters = Objects.requireNonNull(characters);
+        this.sessions = Objects.requireNonNull(sessions); this.nextTick = Objects.requireNonNull(nextTick);
+        this.healingEvents = Objects.requireNonNull(healingEvents); this.nativeLimit = Objects.requireNonNull(nativeLimit);
+    }
+    public void configure(Settings settings) { this.settings = Objects.requireNonNull(settings); }
+
+    public AbilityDefinition definition() {
+        var current = settings;
+        return new AbilityDefinition("second_wind", "Second Wind", Material.GHAST_TEAR,
+            List.of("Restore missing fantasy health.",
+                "Heals " + current.baseHealing() + " + WIS modifier, capped at maximum health."),
+            "Use while injured; full health refuses without spending cooldown.",
+            Map.of(Stat.CON, BigInteger.valueOf(12), Stat.WIS, BigInteger.valueOf(12)), BigInteger.ONE,
+            AbilityDefinition.Activation.DELAYED, ControlInput.Gesture.USE, current.cooldown(),
+            Map.of("base-healing", new BigDecimal(current.baseHealing())),
+            AbilityDefinition.TargetPolicy.SELF, this);
+    }
+
+    @Override public boolean accepts(ControlInput input) {
+        double health = input.player().getHealth();
+        var attribute = input.player().getAttribute(Attribute.MAX_HEALTH);
+        return attribute != null && Double.isFinite(health) && health >= 0
+            && Double.isFinite(attribute.getValue()) && health < attribute.getValue();
+    }
+
+    public static BigInteger healing(BigInteger wisdom) { return healing(BigInteger.valueOf(6), wisdom); }
+    static BigInteger healing(BigInteger base, BigInteger wisdom) {
+        Objects.requireNonNull(base); Objects.requireNonNull(wisdom);
+        if (base.signum() < 0 || wisdom.signum() < 0) throw new IllegalArgumentException("Invalid Second Wind healing input");
+        BigInteger delta = wisdom.subtract(BigInteger.TEN); BigInteger[] divided = delta.divideAndRemainder(BigInteger.TWO);
+        BigInteger modifier = divided[0];
+        if (delta.signum() < 0 && divided[1].signum() != 0) modifier = modifier.subtract(BigInteger.ONE);
+        return base.add(modifier);
+    }
+
+    @Override public void activate(AbilityExecution execution) {
+        if (!execution.stillCurrent()) return;
+        var definition = execution.definition();
+        BigInteger base = definition.parameters().get("base-healing").toBigIntegerExact();
+        var player = execution.input().player();
+        var attribute = player.getAttribute(Attribute.MAX_HEALTH);
+        if (attribute == null) { execution.finish(); return; }
+        double current = player.getHealth(); double maximum = attribute.getValue();
+        double missing = maximum - current;
+        if (!Double.isFinite(current) || !Double.isFinite(maximum) || missing <= 0) { execution.finish(); return; }
+        BigInteger exact = healing(base, execution.character().stats().get(Stat.WIS));
+        double proposed = exact.bitLength() > 1023 ? missing : Math.min(missing, exact.doubleValue());
+        if (!Double.isFinite(proposed) || proposed <= 0) { execution.finish(); return; }
+        var event = new EntityRegainHealthEvent(player, proposed, EntityRegainHealthEvent.RegainReason.CUSTOM);
+        healingEvents.accept(event);
+        double accepted = Math.min(missing, event.getAmount());
+        if (event.isCancelled() || !Double.isFinite(accepted) || accepted <= 0) { execution.finish(); return; }
+        var record = execution.character(); var expected = record.revision();
+        BigDecimal target = BigDecimal.valueOf(current + accepted);
+        BigDecimal limit = nativeLimit.get();
+        characters.saveHealth(record.id(), expected, target, limit).whenComplete((saved, failure) -> {
+            try {
+                nextTick.accept(() -> {
+                    try {
+                        if (failure != null || saved == null || saved.isEmpty() || !execution.stillCurrent()) {
+                            player.sendMessage("Second Wind health could not be saved; no healing was applied."); return;
+                        }
+                        var persisted = saved.orElseThrow();
+                        if (!sessions.acknowledgeProgress(execution.input().session(), expected, persisted)) {
+                            player.sendMessage("Second Wind was saved, but the session changed; no native healing was applied."); return;
+                        }
+                        double publish = Math.min(attribute.getValue(), Math.max(player.getHealth(), persisted.health().doubleValue()));
+                        player.setHealth(publish);
+                    } finally { execution.finish(); }
+                });
+            } catch (RuntimeException rejected) { execution.finish(); }
+        });
+    }
+}

src/main/java/games/dmg/fantasystick/ability/ShieldBash.java

@@ -0,0 +1,144 @@
+package games.dmg.fantasystick.ability;
+
+import games.dmg.fantasystick.progression.Stat;
+import games.dmg.fantasystick.session.ControlInput;
+import java.math.BigDecimal;
+import java.math.BigInteger;
+import java.time.Duration;
+import java.util.List;
+import java.util.Map;
+import java.util.Objects;
+import java.util.function.Consumer;
+import org.bukkit.Location;
+import org.bukkit.Material;
+import org.bukkit.damage.DamageSource;
+import org.bukkit.damage.DamageType;
+import org.bukkit.entity.LivingEntity;
+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.EntityDamageByEntityEvent;
+import org.bukkit.event.player.PlayerVelocityEvent;
+import org.bukkit.util.Vector;
+
+/** Shield Bash's contained short-range custom strike and post-damage knockback. */
+public final class ShieldBash implements AbilityEffect, Listener, AutoCloseable {
+    public record Settings(BigInteger baseDamage, Duration cooldown, double range,
+                           double horizontalKnockback, double minimumVerticalKnockback) {
+        public Settings {
+            Objects.requireNonNull(baseDamage); Objects.requireNonNull(cooldown);
+            if (baseDamage.signum() < 0 || cooldown.isNegative() || cooldown.compareTo(Duration.ofDays(365)) > 0
+                    || !Double.isFinite(range) || range <= 0 || range > 64
+                    || !Double.isFinite(horizontalKnockback) || horizontalKnockback < 0 || horizontalKnockback > 8
+                    || !Double.isFinite(minimumVerticalKnockback) || minimumVerticalKnockback < 0
+                    || minimumVerticalKnockback > 8) throw new IllegalArgumentException("Invalid Shield Bash settings");
+        }
+        public static Settings defaults() {
+            return new Settings(BigInteger.valueOf(4), Duration.ofSeconds(6), 3, 0.8, 0.35);
+        }
+    }
+    private static final class Attempt {
+        final AbilityExecution execution; final LivingEntity target; final Settings settings; boolean accepted;
+        Attempt(AbilityExecution execution, LivingEntity target, Settings settings) {
+            this.execution = execution; this.target = target; this.settings = settings;
+        }
+    }
+
+    private volatile Settings settings;
+    private final Consumer<PlayerVelocityEvent> velocityEvents;
+    private Attempt damaging;
+    private boolean closed;
+
+    public ShieldBash(Settings settings, Consumer<PlayerVelocityEvent> velocityEvents) {
+        this.settings = Objects.requireNonNull(settings); this.velocityEvents = Objects.requireNonNull(velocityEvents);
+    }
+    public void configure(Settings settings) { this.settings = Objects.requireNonNull(settings); }
+
+    public AbilityDefinition definition() {
+        var current = settings;
+        return new AbilityDefinition("shield_bash", "Shield Bash", Material.SHIELD,
+            List.of("Strike within " + decimal(current.range()) + " blocks for " + current.baseDamage() + " + STR modifier damage.",
+                "Accepted damage adds knockback; this shield never enables ordinary blocking."),
+            "Attack a visible hostile at short range.", Map.of(Stat.STR, BigInteger.valueOf(12), Stat.CON, BigInteger.valueOf(12)),
+            BigInteger.ONE, AbilityDefinition.Activation.DELAYED, ControlInput.Gesture.ATTACK, current.cooldown(),
+            Map.of("base-damage", new BigDecimal(current.baseDamage()), "range", decimalValue(current.range()),
+                "horizontal-knockback", decimalValue(current.horizontalKnockback()),
+                "minimum-vertical-knockback", decimalValue(current.minimumVerticalKnockback())),
+            AbilityDefinition.TargetPolicy.HOSTILE, this);
+    }
+
+    @Override public boolean accepts(ControlInput input) {
+        return !closed && input.target() instanceof LivingEntity target && inRange(input.player(), target, settings.range());
+    }
+
+    public static BigInteger damage(BigInteger strength) { return damage(BigInteger.valueOf(4), strength); }
+    static BigInteger damage(BigInteger base, BigInteger strength) {
+        Objects.requireNonNull(base); Objects.requireNonNull(strength);
+        if (base.signum() < 0 || strength.signum() < 0) throw new IllegalArgumentException("Invalid Shield Bash damage input");
+        var delta = strength.subtract(BigInteger.TEN); var divided = delta.divideAndRemainder(BigInteger.TWO);
+        var modifier = divided[0];
+        if (delta.signum() < 0 && divided[1].signum() != 0) modifier = modifier.subtract(BigInteger.ONE);
+        return base.add(modifier);
+    }
+
+    @Override public void activate(AbilityExecution execution) {
+        if (closed || !execution.stillCurrent() || !(execution.input().target() instanceof LivingEntity target)) return;
+        var current = from(execution.definition()); var player = execution.input().player();
+        if (!inRange(player, target, current.range())) { execution.finish(); return; }
+        var exact = damage(current.baseDamage(), execution.character().stats().get(Stat.STR));
+        double amount = exact.bitLength() > 1023 ? Double.MAX_VALUE : exact.doubleValue();
+        if (!Double.isFinite(amount) || amount <= 0) { execution.finish(); return; }
+        var source = DamageSource.builder(DamageType.PLAYER_ATTACK).withCausingEntity(player).withDirectEntity(player).build();
+        var attempt = new Attempt(execution, target, current); damaging = attempt;
+        try { target.damage(amount, source); }
+        finally { if (damaging == attempt) damaging = null; execution.finish(); }
+    }
+
+    @EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = true)
+    public void acceptedDamage(EntityDamageByEntityEvent event) {
+        var attempt = damaging;
+        if (closed || attempt == null || attempt.accepted || event.isCancelled() || event.getFinalDamage() <= 0
+                || !Double.isFinite(event.getFinalDamage()) || event.getDamager() != attempt.execution.input().player()
+                || event.getEntity() != attempt.target || !attempt.execution.stillCurrent()) return;
+        attempt.accepted = true;
+        attempt.execution.report(AbilityReport.Type.DAMAGE, event.getEntity(),
+            BigDecimal.valueOf(event.getFinalDamage()).stripTrailingZeros());
+        knockback(attempt);
+    }
+
+    private void knockback(Attempt attempt) {
+        var player = attempt.execution.input().player(); var target = attempt.target;
+        Vector away = target.getLocation().toVector().subtract(player.getLocation().toVector()); away.setY(0);
+        if (!finite(away) || away.lengthSquared() < 1.0e-12) return;
+        Vector current = target.getVelocity();
+        Vector proposed = current.clone().add(away.normalize().multiply(attempt.settings.horizontalKnockback()));
+        proposed.setY(Math.max(current.getY(), attempt.settings.minimumVerticalKnockback()));
+        if (!finite(proposed)) return;
+        if (target instanceof Player targetPlayer) {
+            var event = new PlayerVelocityEvent(targetPlayer, proposed.clone()); velocityEvents.accept(event);
+            if (event.isCancelled() || !finite(event.getVelocity())) return;
+            proposed = event.getVelocity().clone();
+        }
+        target.setVelocity(proposed);
+    }
+
+    private static boolean inRange(Player player, LivingEntity target, double range) {
+        try {
+            Location source = player.getLocation(); Location destination = target.getLocation();
+            return source.getWorld() == destination.getWorld() && source.distanceSquared(destination) <= range * range
+                && player.hasLineOfSight(target);
+        } catch (RuntimeException invalid) { return false; }
+    }
+    private static boolean finite(Vector value) {
+        return Double.isFinite(value.getX()) && Double.isFinite(value.getY()) && Double.isFinite(value.getZ());
+    }
+    private static Settings from(AbilityDefinition definition) {
+        var p = definition.parameters();
+        return new Settings(p.get("base-damage").toBigIntegerExact(), definition.cooldown(), p.get("range").doubleValue(),
+            p.get("horizontal-knockback").doubleValue(), p.get("minimum-vertical-knockback").doubleValue());
+    }
+    private static BigDecimal decimalValue(double value) { return BigDecimal.valueOf(value).stripTrailingZeros(); }
+    private static String decimal(double value) { return decimalValue(value).toPlainString(); }
+    @Override public void close() { closed = true; damaging = null; }
+}

src/main/java/games/dmg/fantasystick/ability/StoneSkin.java

@@ -0,0 +1,84 @@
+package games.dmg.fantasystick.ability;
+
+import games.dmg.fantasystick.progression.Stat;
+import games.dmg.fantasystick.session.ControlInput;
+import java.math.BigDecimal;
+import java.math.BigInteger;
+import java.time.Duration;
+import java.util.List;
+import java.util.Map;
+import java.util.Objects;
+import java.util.UUID;
+import org.bukkit.Material;
+import org.bukkit.entity.Player;
+
+/** Stone Skin's captured, owned grant into the shared strongest-reduction stage. */
+public final class StoneSkin implements AbilityEffect, AutoCloseable {
+    public record Settings(Duration cooldown, Duration duration, BigDecimal reductionPercent) {
+        public Settings {
+            Objects.requireNonNull(cooldown); Objects.requireNonNull(duration); Objects.requireNonNull(reductionPercent);
+            if (cooldown.isNegative() || cooldown.compareTo(Duration.ofDays(365)) > 0
+                    || duration.isNegative() || duration.isZero() || duration.compareTo(Duration.ofDays(1)) > 0
+                    || reductionPercent.signum() < 0 || reductionPercent.compareTo(BigDecimal.valueOf(100)) > 0)
+                throw new IllegalArgumentException("Invalid Stone Skin settings");
+        }
+        public static Settings defaults() {
+            return new Settings(Duration.ofSeconds(14), Duration.ofSeconds(4), BigDecimal.valueOf(25));
+        }
+    }
+
+    private final class State implements AutoCloseable {
+        final AbilityExecution execution; final Player player; final AutoCloseable grant; boolean closed;
+        State(AbilityExecution execution, Player player, AutoCloseable grant) {
+            this.execution = execution; this.player = player; this.grant = grant;
+        }
+        @Override public void close() {
+            if (closed) return; closed = true; protections.remove(player.getUniqueId(), this);
+            try { grant.close(); } catch (Exception impossible) { throw new IllegalStateException(impossible); }
+        }
+    }
+
+    private volatile Settings settings;
+    private final CombatMitigation mitigation;
+    private final Map<UUID, State> protections = new java.util.HashMap<>();
+    private boolean closed;
+
+    public StoneSkin(Settings settings, CombatMitigation mitigation) {
+        this.settings = Objects.requireNonNull(settings); this.mitigation = Objects.requireNonNull(mitigation);
+    }
+    public void configure(Settings settings) { this.settings = Objects.requireNonNull(settings); }
+
+    public AbilityDefinition definition() {
+        var current = settings;
+        return new AbilityDefinition("stone_skin", "Stone Skin", Material.BRICK,
+            List.of("Reduce entity and projectile combat damage by " + decimal(current.reductionPercent()) + "%.",
+                "Lasts " + decimal(BigDecimal.valueOf(current.duration().toMillis()).movePointLeft(3)) + " seconds without stacking."),
+            "Use to protect yourself; environmental damage is unchanged.", Map.of(Stat.CON, BigInteger.valueOf(14)), BigInteger.ONE,
+            AbilityDefinition.Activation.DELAYED, ControlInput.Gesture.USE, current.cooldown(),
+            Map.of("duration-seconds", BigDecimal.valueOf(current.duration().toNanos()).movePointLeft(9),
+                "damage-reduction-percent", current.reductionPercent()), AbilityDefinition.TargetPolicy.SELF, this);
+    }
+
+    @Override public void activate(AbilityExecution execution) {
+        if (closed || !execution.stillCurrent()) return;
+        var current = from(execution.definition()); var player = execution.input().player();
+        var grant = mitigation.grant(execution, player, current.reductionPercent());
+        var state = new State(execution, player, grant);
+        var previous = protections.put(player.getUniqueId(), state);
+        if (previous != null) previous.execution.finish();
+        execution.own(state); execution.later(current.duration(), execution::finish);
+    }
+
+    private static Settings from(AbilityDefinition definition) {
+        return new Settings(definition.cooldown(),
+            Duration.ofNanos(definition.parameters().get("duration-seconds").movePointRight(9).longValueExact()),
+            definition.parameters().get("damage-reduction-percent"));
+    }
+    private static String decimal(BigDecimal value) { return value.stripTrailingZeros().toPlainString(); }
+
+    @Override public void close() {
+        if (closed) return; closed = true;
+        for (var state : List.copyOf(protections.values())) state.execution.finish();
+        protections.clear();
+    }
+}

src/main/java/games/dmg/fantasystick/ability/TemporaryHealth.java

@@ -0,0 +1,33 @@
+package games.dmg.fantasystick.ability;
+
+import games.dmg.fantasystick.party.PartyRoster;
+import games.dmg.fantasystick.session.EquipmentSessions;
+import java.math.BigDecimal;
+import java.util.*;
+import java.util.function.Consumer;
+import org.bukkit.entity.*;
+import org.bukkit.event.*;
+import org.bukkit.event.entity.*;
+import org.bukkit.projectiles.ProjectileSource;
+
+/** Plugin-owned temporary-health ledger layered over unrelated native absorption. */
+public final class TemporaryHealth implements Listener,AutoCloseable{
+ public record Support(UUID target,UUID supportingCharacter,EquipmentSessions.Active aided,BigDecimal amount){}
+ private final class Grant implements AutoCloseable{final long sequence;final AbilityExecution execution;final Player target;double remaining;boolean closed;
+  Grant(AbilityExecution e,Player t,double amount){sequence=++sequences;execution=e;target=t;remaining=amount;}
+  @Override public void close(){if(closed)return;double before=owned(target.getUniqueId());closed=true;var list=grants.get(target.getUniqueId());if(list!=null){list.remove(this);if(list.isEmpty())grants.remove(target.getUniqueId());}double after=owned(target.getUniqueId());removeNative(target,Math.max(0,before-after));}}
+ private final EquipmentSessions sessions;private final PartyRoster parties;private final Consumer<Runnable> nextTick;private final Consumer<Support> supports;
+ private final Map<UUID,List<Grant>> grants=new HashMap<>();private long sequences;private boolean closed;
+ public TemporaryHealth(EquipmentSessions sessions,PartyRoster parties,Consumer<Runnable> nextTick,Consumer<Support> supports){this.sessions=Objects.requireNonNull(sessions);this.parties=Objects.requireNonNull(parties);this.nextTick=Objects.requireNonNull(nextTick);this.supports=Objects.requireNonNull(supports);}
+ public AutoCloseable grant(AbilityExecution execution,Player target,double amount){Objects.requireNonNull(execution);Objects.requireNonNull(target);if(closed||!Double.isFinite(amount)||amount<=0)throw new IllegalArgumentException("Invalid temporary health grant");double before=owned(target.getUniqueId());var grant=new Grant(execution,target,amount);grants.computeIfAbsent(target.getUniqueId(),ignored->new ArrayList<>()).add(grant);double after=owned(target.getUniqueId());addNative(target,Math.max(0,after-before));return grant;}
+ @EventHandler(priority=EventPriority.MONITOR,ignoreCancelled=true)public void damage(EntityDamageEvent event){if(closed||!(event.getEntity() instanceof Player target))return;var owner=strongest(target.getUniqueId());if(owner==null||!owner.execution.stillCurrent())return;double before=target.getAbsorptionAmount(),owned=owned(target.getUniqueId());if(!Double.isFinite(before)||before<=0||owned<=0)return;Entity attacker=event instanceof EntityDamageByEntityEvent by?attacker(by):null;var aided=sessions.active(target.getUniqueId()).orElse(null);boolean qualifies=aided!=null&&sessions.current(aided)&&!aided.character().equals(owner.execution.input().session().character())&&sameParty(owner.execution.input().player(),target);UUID enemy=attacker==null?null:attacker.getUniqueId();long ownerSequence=owner.sequence;UUID source=owner.execution.input().session().character();
+  try{nextTick.accept(()->consume(target,before,owned,ownerSequence,source,qualifies?aided:null,enemy));}catch(RuntimeException ignored){}}
+ private void consume(Player target,double before,double ownedBefore,long ownerSequence,UUID source,EquipmentSessions.Active aided,UUID enemy){if(closed)return;double after=target.getAbsorptionAmount();double consumed=Math.min(ownedBefore,Math.max(0,before-after));if(!Double.isFinite(consumed)||consumed<=0)return;var list=grants.get(target.getUniqueId());if(list==null)return;for(var grant:List.copyOf(list))grant.remaining=Math.max(0,grant.remaining-consumed);list.removeIf(g->g.closed||g.remaining<=1e-9);if(list.isEmpty())grants.remove(target.getUniqueId());if(aided!=null&&enemy!=null)supports.accept(new Support(enemy,source,aided,BigDecimal.valueOf(consumed).stripTrailingZeros()));}
+ private boolean sameParty(Player source,Player target){var a=parties.partyOf(source.getUniqueId()).orElse(null);var b=parties.partyOf(target.getUniqueId()).orElse(null);return a!=null&&b!=null&&a.id().equals(b.id());}
+ private Grant strongest(UUID target){Grant result=null;var list=grants.get(target);if(list!=null)for(var grant:List.copyOf(list))if(!grant.closed&&grant.remaining>0&&grant.execution.stillCurrent()&&(result==null||grant.remaining>result.remaining||grant.remaining==result.remaining&&grant.sequence>result.sequence))result=grant;return result;}
+ private double owned(UUID target){double result=0;var list=grants.get(target);if(list!=null)for(var grant:List.copyOf(list))if(!grant.closed&&grant.remaining>result)result=grant.remaining;return result;}
+ private static Entity attacker(EntityDamageByEntityEvent event){Entity causing=event.getDamageSource().getCausingEntity();if(causing!=null)return causing;if(event.getDamager() instanceof Projectile p){ProjectileSource shooter=p.getShooter();if(shooter instanceof Entity e)return e;}return event.getDamager();}
+ private static void addNative(Player target,double amount){if(amount<=0)return;double current=target.getAbsorptionAmount(),next=current+amount;if(!Double.isFinite(current)||current<0||!Double.isFinite(next))throw new IllegalStateException("Temporary health exceeds native range");target.setAbsorptionAmount(next);}
+ private static void removeNative(Player target,double amount){if(amount<=0)return;double current=target.getAbsorptionAmount();if(Double.isFinite(current)&&current>=0)target.setAbsorptionAmount(Math.max(0,current-amount));}
+ @Override public void close(){if(closed)return;for(var list:List.copyOf(grants.values()))for(var grant:List.copyOf(list))grant.close();closed=true;grants.clear();}
+}

src/main/java/games/dmg/fantasystick/book/PartyBookControls.java

@@ -69,12 +69,12 @@ public final class PartyBookControls implements AutoCloseable {
             } else {
                 var group = party.orElseThrow();
                 boolean leader = group.leader().equals(owner);
-                summary = summary.append(Component.text(group.members().size() + "/6 members\n\n"))
+                summary = summary.append(Component.text(group.members().size() + "/" + parties.maximumSize() + " members\n\n"))
                     .append(build.button("Leave party", () -> mutate(input, () -> parties.leave(owner, group.id()))));
                 if (leader) {
                     summary = summary.append(Component.newline())
                         .append(build.button("Disband party", () -> mutate(input, () -> parties.disband(owner, group.id()))));
-                    if (group.members().size() < 6) summary = summary.append(Component.newline())
+                    if (group.members().size() < parties.maximumSize()) summary = summary.append(Component.newline())
                         .append(build.button("Invite players", () -> show(input, Menu.PLAYERS, 0)));
                 }
                 build.pages.add(summary);

src/main/java/games/dmg/fantasystick/crafting/RecipeDiscovery.java

@@ -0,0 +1,49 @@
+package games.dmg.fantasystick.crafting;
+
+import java.util.List;
+import java.util.Objects;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+import org.bukkit.NamespacedKey;
+import org.bukkit.entity.Player;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.Listener;
+import org.bukkit.event.player.PlayerJoinEvent;
+
+/** Idempotent recipe-book visibility; recipe registration and crafting remain separate authorities. */
+public final class RecipeDiscovery implements Listener {
+    private final NamespacedKey recipe;
+    private final Logger logger;
+
+    public RecipeDiscovery(NamespacedKey recipe, Logger logger) {
+        this.recipe = Objects.requireNonNull(recipe, "recipe");
+        this.logger = Objects.requireNonNull(logger, "logger");
+    }
+
+    public void discoverAll(Iterable<? extends Player> players) {
+        for (var player : players) discover(player);
+    }
+
+    @EventHandler
+    public void onJoin(PlayerJoinEvent event) {
+        discover(event.getPlayer());
+    }
+
+    public void discover(Player player) {
+        Objects.requireNonNull(player, "player");
+        try {
+            if (player.hasDiscoveredRecipe(recipe)) return;
+            player.discoverRecipes(List.of(recipe));
+            if (!player.hasDiscoveredRecipe(recipe)) {
+                logger.warning("Could not discover character-sheet recipe for " + label(player));
+            }
+        } catch (RuntimeException failure) {
+            logger.log(Level.WARNING, "Could not discover character-sheet recipe for " + label(player), failure);
+        }
+    }
+
+    private static String label(Player player) {
+        try { return player.getName(); }
+        catch (RuntimeException ignored) { return "an unidentified player"; }
+    }
+}

src/main/java/games/dmg/fantasystick/items/CharacterSheets.java

@@ -14,6 +14,7 @@ import org.bukkit.persistence.PersistentDataType;
 /** Sheet presentation/identity only; saved records and session eligibility remain authoritative. */
 public final class CharacterSheets {
     public static final NamespacedKey RECIPE = new NamespacedKey("fantasystick", "character_sheet");
+    public static final NamespacedKey MODEL = new NamespacedKey("fantasystick", "character_sheet");
     private static final NamespacedKey VERSION = new NamespacedKey("fantasystick", "sheet_version");
     private static final NamespacedKey CHARACTER = new NamespacedKey("fantasystick", "character_id");
     private static final List<Component> INSTRUCTION = List.of(Component.text("Character sheet:"),
@@ -26,15 +27,18 @@ public final class CharacterSheets {
         var data = meta.getPersistentDataContainer();
         data.set(VERSION, PersistentDataType.INTEGER, 1);
         data.set(CHARACTER, PersistentDataType.STRING, character.id().toString());
+        meta.setItemModel(MODEL);
         item.setItemMeta(meta);
         return item;
     }
 
     /** Definition only: a future craft-completion adapter must persist and mint each actual result. */
     public ShapelessRecipe recipe() {
-        return new ShapelessRecipe(RECIPE, paper("Character sheet"))
+        var recipe = new ShapelessRecipe(RECIPE, paper("Character sheet"))
             .addIngredient(Material.STICK).addIngredient(Material.PAPER)
             .addIngredient(Material.FEATHER).addIngredient(Material.INK_SAC);
+        recipe.setCategory(org.bukkit.inventory.recipe.CraftingBookCategory.MISC);
+        return recipe;
     }
 
     private static ItemStack paper(String name) {
@@ -46,6 +50,16 @@ public final class CharacterSheets {
         return item;
     }
 
+    /** Adds only the cosmetic model association to an already authentic sheet. */
+    public boolean applyModel(ItemStack item) {
+        if (identify(item).isEmpty()) return false;
+        var meta = item.getItemMeta();
+        if (MODEL.equals(meta.getItemModel())) return true;
+        meta.setItemModel(MODEL);
+        item.setItemMeta(meta);
+        return true;
+    }
+
     /** A reference, not authorization to activate: the caller must load saved state and claim the session. */
     public Optional<UUID> identify(ItemStack item) {
         if (item == null || item.getType() != Material.PAPER || !item.hasItemMeta()) return Optional.empty();

src/main/java/games/dmg/fantasystick/party/CombatExperience.java

@@ -93,9 +93,24 @@ public final class CombatExperience implements Listener, AutoCloseable {
         retryTask = plugin.getServer().getScheduler().runTaskTimer(plugin, this::retryPending, 20, 20);
     }
 
+    /** Records target-specific, effective support; only a direct contributor can activate it at defeat. */
+    public void support(UUID target, UUID supportingCharacter, EquipmentSessions.Active aided, BigDecimal amount) {
+        Objects.requireNonNull(target); Objects.requireNonNull(supportingCharacter); Objects.requireNonNull(aided); Objects.requireNonNull(amount);
+        if (closed || amount.signum() <= 0 || !sessions.current(aided) || supportingCharacter.equals(aided.character())) return;
+        contributions.support(target, aided.character(), supportingCharacter, clock.instant());
+    }
+
+    /** Records effective healing; any directly contributed target can qualify it within ten seconds. */
+    public void support(UUID supportingCharacter, EquipmentSessions.Active aided, BigDecimal amount) {
+        Objects.requireNonNull(supportingCharacter); Objects.requireNonNull(aided); Objects.requireNonNull(amount);
+        if (closed || amount.signum() <= 0 || !sessions.current(aided) || supportingCharacter.equals(aided.character())) return;
+        contributions.support(aided.character(), supportingCharacter, clock.instant());
+    }
+
     @EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = true)
     public void damage(EntityDamageEvent event) {
-        if (closed || event.getFinalDamage() <= 0) return;
+        if (closed || games.dmg.fantasystick.ability.GuardianBond.redirectedDamage()
+                || event.getFinalDamage() <= 0) return;
         var origin = source(event);
         if (origin == null || origin.session() == null || !sources.current(origin)
                 || event.getEntity().getUniqueId().equals(origin.player())) return;
@@ -198,6 +213,7 @@ public final class CombatExperience implements Listener, AutoCloseable {
 
     public void retryPending() {
         if (closed) return;
+        contributions.sweep(clock.instant());
         for (int attempted = 0; attempted < 64; attempted++) {
             UUID id = retries.poll();
             if (id == null) break;

src/main/java/games/dmg/fantasystick/party/PartyCombat.java

@@ -66,6 +66,7 @@ public final class PartyCombat implements Listener, AutoCloseable {
 
     @EventHandler(priority = EventPriority.HIGHEST, ignoreCancelled = true)
     public void damage(EntityDamageEvent event) {
+        if (games.dmg.fantasystick.ability.GuardianBond.redirectedDamage()) return;
         if (event.getEntity() instanceof Player target) {
             var ongoing = OngoingDamage.read(target, event.getCause());
             if (ongoing != null && (!sources.current(ongoing.target()) || blocked(ongoing.source(), target))) {

src/main/java/games/dmg/fantasystick/party/PartyRoster.java

@@ -25,10 +25,19 @@ public final class PartyRoster implements AutoCloseable {
     private boolean closed;
     private final Clock clock;
     private final Predicate<UUID> online;
+    private final java.util.function.IntSupplier maximumSize;
 
-    public PartyRoster(Clock clock, Predicate<UUID> online) {
+    public PartyRoster(Clock clock, Predicate<UUID> online) { this(clock, online, () -> 6); }
+    public PartyRoster(Clock clock, Predicate<UUID> online, java.util.function.IntSupplier maximumSize) {
         this.clock = Objects.requireNonNull(clock);
         this.online = Objects.requireNonNull(online);
+        this.maximumSize = Objects.requireNonNull(maximumSize);
+        maximumSize();
+    }
+    public int maximumSize() {
+        int value = maximumSize.getAsInt();
+        if (value < 1) throw new IllegalStateException("Party maximum must be positive");
+        return value;
     }
     public Optional<Party> create(UUID player) {
         if (closed || !connected(player) || membership.containsKey(player)) return Optional.empty();
@@ -45,7 +54,7 @@ public final class PartyRoster implements AutoCloseable {
     public Optional<Invitation> invite(UUID leader, UUID party, UUID invitee) {
         expire();
         var group = managedBy(leader, party);
-        if (group == null || group.members().size() >= 6 || !connected(invitee) || membership.containsKey(invitee)) return Optional.empty();
+        if (group == null || group.members().size() >= maximumSize() || !connected(invitee) || membership.containsKey(invitee)) return Optional.empty();
         var existing = invitations.values().stream().filter(i -> i.party().equals(party) && i.invitee().equals(invitee)).findFirst();
         if (existing.isPresent()) return existing;
         var invitation = new Invitation(UUID.randomUUID(), party, leader, invitee, clock.instant().plusSeconds(60));
@@ -57,7 +66,7 @@ public final class PartyRoster implements AutoCloseable {
         var offer = invitations.get(invitation);
         if (offer == null || !offer.invitee().equals(player) || !connected(player) || membership.containsKey(player)) return false;
         var group = membership.get(offer.leader());
-        if (group == null || group.members().size() >= 6 || !group.id().equals(offer.party())) return false;
+        if (group == null || group.members().size() >= maximumSize() || !group.id().equals(offer.party())) return false;
         var members = new ArrayList<>(group.members());
         members.add(player);
         var updated = new Party(group.id(), group.leader(), members);

src/main/java/games/dmg/fantasystick/persistence/AdminReviveSettings.java

@@ -0,0 +1,42 @@
+package games.dmg.fantasystick.persistence;
+
+import java.io.IOException;
+import java.nio.ByteBuffer;
+import java.nio.channels.FileChannel;
+import java.nio.channels.OverlappingFileLockException;
+import java.nio.charset.StandardCharsets;
+import java.nio.file.Files;
+import java.nio.file.LinkOption;
+import java.nio.file.Path;
+import java.nio.file.StandardCopyOption;
+import java.nio.file.StandardOpenOption;
+import java.time.Duration;
+import java.util.LinkedHashMap;
+import java.util.Map;
+import java.util.Objects;
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.CompletionStage;
+import java.util.concurrent.Executors;
+import java.util.concurrent.RejectedExecutionException;
+import org.yaml.snakeyaml.LoaderOptions;
+import org.yaml.snakeyaml.Yaml;
+import org.yaml.snakeyaml.constructor.SafeConstructor;
+
+/** Durable save-before-publish policy for later administrator revival selections. */
+public final class AdminReviveSettings implements AutoCloseable {
+    public static final String KEY="admin-revive-selection-timeout-seconds";public static final String DEFAULT="60";
+    private static final int MAX_BYTES=1_048_576;private static final long MAX_SECONDS=365L*24*60*60;
+    @FunctionalInterface interface Replacement{void move(Path from,Path to)throws IOException;}
+    public record Update(String value,Duration timeout,long sequence){}
+    private final Path directory;private final Replacement replacement;private final java.util.concurrent.ExecutorService worker=Executors.newSingleThreadExecutor(task->new Thread(task,"fantasy-admin-revive-configuration"));
+    private volatile Duration effective;private Duration persisted;private long persistedSequence,publishedSequence;private boolean closed;private int pending;private final CompletableFuture<Void> drained=new CompletableFuture<>();
+    public AdminReviveSettings(Path directory,Duration initial){this(directory,initial,(from,to)->Files.move(from,to,StandardCopyOption.ATOMIC_MOVE,StandardCopyOption.REPLACE_EXISTING));}
+    AdminReviveSettings(Path directory,Duration initial,Replacement replacement){this.directory=Objects.requireNonNull(directory).toAbsolutePath();this.replacement=Objects.requireNonNull(replacement);effective=validate(initial);persisted=effective;}
+    public static Duration parse(Object value){if(value==null)return Duration.ofSeconds(60);try{return validate(Duration.ofSeconds(value instanceof Number n?new java.math.BigDecimal(n.toString()).longValueExact():Long.parseLong(value.toString())));}catch(ArithmeticException|NumberFormatException invalid){throw new IllegalArgumentException(KEY+" must be positive whole seconds",invalid);}}
+    private static Duration validate(Duration value){long seconds;try{seconds=value.toSeconds();}catch(ArithmeticException invalid){throw new IllegalArgumentException("Invalid admin revival timeout",invalid);}if(value.isZero()||value.isNegative()||value.getNano()!=0||seconds>MAX_SECONDS)throw new IllegalArgumentException(KEY+" must be positive whole seconds through 365 days");return value;}
+    public Duration timeout(){return effective;}public String value(){return Long.toString(effective.toSeconds());}
+    public CompletionStage<Update> set(String raw){Duration accepted=parse(raw);synchronized(this){if(closed)return CompletableFuture.failedStage(new IOException("Configuration store is closed"));pending++;}try{return CompletableFuture.supplyAsync(()->{try{save(accepted);persisted=accepted;return new Update(Long.toString(accepted.toSeconds()),accepted,++persistedSequence);}catch(IOException|RuntimeException failure){throw new java.util.concurrent.CompletionException(new IOException("Admin revival configuration save refused or failed; effective setting unchanged"));}finally{finished();}},worker).minimalCompletionStage();}catch(RejectedExecutionException rejected){finished();return CompletableFuture.failedStage(new IOException("Configuration store is closed"));}}
+    public synchronized void publish(Update update){if(update.sequence()<=publishedSequence)return;effective=validate(update.timeout());publishedSequence=update.sequence();}
+    private void save(Duration value)throws IOException{Files.createDirectories(directory);if(!Files.isDirectory(directory,LinkOption.NOFOLLOW_LINKS))throw new IOException("Unsafe directory");var file=directory.resolve("config.yml");var lockFile=directory.resolve(".config.lock");if(Files.exists(lockFile,LinkOption.NOFOLLOW_LINKS)&&!Files.isRegularFile(lockFile,LinkOption.NOFOLLOW_LINKS))throw new IOException("Unsafe lock");try(var channel=FileChannel.open(lockFile,StandardOpenOption.CREATE,StandardOpenOption.WRITE,LinkOption.NOFOLLOW_LINKS);var lock=channel.tryLock()){if(lock==null)throw new IOException("Configuration busy");var options=new LoaderOptions();options.setAllowDuplicateKeys(false);options.setMaxAliasesForCollections(20);options.setCodePointLimit(MAX_BYTES);var yaml=new Yaml(new SafeConstructor(options));Map<String,Object> values=new LinkedHashMap<>();if(Files.exists(file,LinkOption.NOFOLLOW_LINKS)){if(!Files.isRegularFile(file,LinkOption.NOFOLLOW_LINKS))throw new IOException("Unsafe configuration");byte[] bytes;try(var input=Files.newInputStream(file,LinkOption.NOFOLLOW_LINKS)){bytes=input.readNBytes(MAX_BYTES+1);}if(bytes.length>MAX_BYTES)throw new IOException("Configuration too large");Object loaded=yaml.load(StandardCharsets.UTF_8.newDecoder().decode(ByteBuffer.wrap(bytes)).toString());if(loaded!=null){if(!(loaded instanceof Map<?,?> map))throw new IOException("Invalid configuration root");for(var entry:map.entrySet()){if(!(entry.getKey() instanceof String key))throw new IOException("Invalid configuration key");values.put(key,entry.getValue());}}}values.put(KEY,Long.toString(value.toSeconds()));byte[] bytes=yaml.dump(values).getBytes(StandardCharsets.UTF_8);if(bytes.length>MAX_BYTES)throw new IOException("Configuration too large");Path temporary=Files.createTempFile(directory,".config-",".tmp");try{try(var output=FileChannel.open(temporary,StandardOpenOption.WRITE,LinkOption.NOFOLLOW_LINKS)){var buffer=ByteBuffer.wrap(bytes);while(buffer.hasRemaining())output.write(buffer);output.force(true);}replacement.move(temporary,file);}finally{Files.deleteIfExists(temporary);}}catch(OverlappingFileLockException busy){throw new IOException("Configuration busy");}}
+    private synchronized void finished(){pending--;if(closed&&pending==0)drained.complete(null);}public CompletionStage<Void> drained(){return drained.minimalCompletionStage();}@Override public synchronized void close(){closed=true;worker.shutdown();if(pending==0)drained.complete(null);}
+}

src/main/java/games/dmg/fantasystick/persistence/ChainLightningSettings.java

@@ -0,0 +1,173 @@
+package games.dmg.fantasystick.persistence;
+
+import games.dmg.fantasystick.ability.ChainLightning;
+import java.io.IOException;
+import java.math.BigDecimal;
+import java.nio.ByteBuffer;
+import java.nio.channels.FileChannel;
+import java.nio.channels.OverlappingFileLockException;
+import java.nio.charset.StandardCharsets;
+import java.nio.file.Files;
+import java.nio.file.LinkOption;
+import java.nio.file.Path;
+import java.nio.file.StandardCopyOption;
+import java.nio.file.StandardOpenOption;
+import java.time.Duration;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Objects;
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.CompletionStage;
+import java.util.concurrent.Executors;
+import java.util.concurrent.RejectedExecutionException;
+import org.yaml.snakeyaml.LoaderOptions;
+import org.yaml.snakeyaml.Yaml;
+import org.yaml.snakeyaml.constructor.SafeConstructor;
+
+/** Serialized durable Chain Lightning settings; publication remains a server-thread caller decision. */
+public final class ChainLightningSettings implements AutoCloseable {
+    private static final int MAX_BYTES = 1_048_576;
+    public static final String BASE = "chain-lightning-base-damage";
+    public static final String COOLDOWN = "chain-lightning-cooldown-seconds";
+    public static final String INITIAL_RANGE = "chain-lightning-initial-range-blocks";
+    public static final String JUMP_RANGE = "chain-lightning-jump-range-blocks";
+    public static final String ADDITIONAL = "chain-lightning-additional-targets";
+    public static final String MULTIPLIER = "chain-lightning-jump-multiplier";
+    private static final List<String> KEYS = List.of(BASE, COOLDOWN, INITIAL_RANGE, JUMP_RANGE, ADDITIONAL, MULTIPLIER);
+    private static final Map<String, String> DEFAULTS = Map.of(
+        BASE, "8", COOLDOWN, "18", INITIAL_RANGE, "16", JUMP_RANGE, "6", ADDITIONAL, "3", MULTIPLIER, "0.75");
+
+    @FunctionalInterface interface Replacement { void move(Path from, Path to) throws IOException; }
+    public record Update(String key, String value, ChainLightning.Settings settings, Map<String, String> values, long sequence) {
+        public Update { values = Map.copyOf(values); }
+    }
+
+    private final Path directory;
+    private final Replacement replacement;
+    private final java.util.concurrent.ExecutorService worker = Executors.newSingleThreadExecutor(
+        task -> new Thread(task, "fantasy-chain-lightning-configuration"));
+    private volatile Map<String, String> effectiveValues;
+    private Map<String, String> persistedValues;
+    private long persistedSequence;
+    private long publishedSequence;
+    private boolean closed;
+    private int pending;
+    private final CompletableFuture<Void> drained = new CompletableFuture<>();
+
+    public ChainLightningSettings(Path directory, Map<String, String> initial) {
+        this(directory, initial, (from, to) -> Files.move(from, to,
+            StandardCopyOption.ATOMIC_MOVE, StandardCopyOption.REPLACE_EXISTING));
+    }
+
+    ChainLightningSettings(Path directory, Map<String, String> initial, Replacement replacement) {
+        this.directory = Objects.requireNonNull(directory).toAbsolutePath(); this.replacement = Objects.requireNonNull(replacement);
+        var copy = new LinkedHashMap<String, String>();
+        for (String key : KEYS) copy.put(key, Objects.requireNonNull(initial.get(key)));
+        parse(copy); effectiveValues = Map.copyOf(copy); persistedValues = Map.copyOf(copy);
+    }
+
+    public static List<String> keys() { return KEYS; }
+    public static String defaultValue(String key) { return DEFAULTS.get(key); }
+    public String value(String key) { return effectiveValues.get(key); }
+    public ChainLightning.Settings settings() { return parse(effectiveValues); }
+
+    public synchronized void publish(Update update) {
+        Objects.requireNonNull(update);
+        if (update.sequence() <= publishedSequence) return;
+        parse(update.values()); effectiveValues = update.values(); publishedSequence = update.sequence();
+    }
+
+    public CompletionStage<Update> set(String key, String value) {
+        Objects.requireNonNull(key); Objects.requireNonNull(value);
+        if (!KEYS.contains(key)) return CompletableFuture.failedStage(new IllegalArgumentException("Unknown setting"));
+        String accepted = canonical(value); var preview = new LinkedHashMap<>(effectiveValues);
+        preview.put(key, accepted); parse(preview);
+        synchronized (this) {
+            if (closed) return CompletableFuture.failedStage(new IOException("Configuration store is closed"));
+            pending++;
+        }
+        try {
+            return CompletableFuture.supplyAsync(() -> {
+                try {
+                    var next = new LinkedHashMap<>(persistedValues); next.put(key, accepted);
+                    var parsed = parse(next); save(key, accepted); persistedValues = Map.copyOf(next);
+                    return new Update(key, accepted, parsed, persistedValues, ++persistedSequence);
+                } catch (IOException | RuntimeException failure) {
+                    throw new java.util.concurrent.CompletionException(failure instanceof IllegalArgumentException
+                        ? failure : new IOException("Chain Lightning configuration save refused or failed; effective settings unchanged"));
+                } finally { finished(); }
+            }, worker).minimalCompletionStage();
+        } catch (RejectedExecutionException rejected) {
+            finished(); return CompletableFuture.failedStage(new IOException("Configuration store is closed"));
+        }
+    }
+
+    private static String canonical(String raw) {
+        try { return new BigDecimal(raw).stripTrailingZeros().toPlainString(); }
+        catch (NumberFormatException invalid) { throw new IllegalArgumentException("Invalid value", invalid); }
+    }
+
+    public static ChainLightning.Settings parse(Map<String, String> values) {
+        try { return new ChainLightning.Settings(new BigDecimal(values.get(BASE)).toBigIntegerExact(),
+            seconds(values.get(COOLDOWN)), finite(values.get(INITIAL_RANGE)), finite(values.get(JUMP_RANGE)),
+            new BigDecimal(values.get(ADDITIONAL)).intValueExact(), new BigDecimal(values.get(MULTIPLIER))); }
+        catch (ArithmeticException | NumberFormatException | NullPointerException invalid) {
+            throw new IllegalArgumentException("Chain Lightning settings must use supported numeric values", invalid);
+        }
+    }
+
+    private static Duration seconds(String value) {
+        var nanos = new BigDecimal(value).movePointRight(9).toBigIntegerExact().longValueExact();
+        return Duration.ofNanos(nanos);
+    }
+
+    private static double finite(String value) {
+        double result = new BigDecimal(value).doubleValue();
+        if (!Double.isFinite(result)) throw new IllegalArgumentException("Setting is not finite");
+        return result;
+    }
+
+    private void save(String key, String value) throws IOException {
+        Files.createDirectories(directory);
+        if (!Files.isDirectory(directory, LinkOption.NOFOLLOW_LINKS)) throw new IOException("Unsafe directory");
+        var file = directory.resolve("config.yml"); var lockFile = directory.resolve(".config.lock");
+        if (Files.exists(lockFile, LinkOption.NOFOLLOW_LINKS) && !Files.isRegularFile(lockFile, LinkOption.NOFOLLOW_LINKS)) {
+            throw new IOException("Unsafe lock");
+        }
+        try (var channel = FileChannel.open(lockFile, StandardOpenOption.CREATE, StandardOpenOption.WRITE,
+                LinkOption.NOFOLLOW_LINKS); var lock = channel.tryLock()) {
+            if (lock == null) throw new IOException("Configuration busy");
+            var options = new LoaderOptions(); options.setAllowDuplicateKeys(false);
+            options.setMaxAliasesForCollections(20); options.setCodePointLimit(MAX_BYTES);
+            var yaml = new Yaml(new SafeConstructor(options)); Map<String, Object> document = new LinkedHashMap<>();
+            if (Files.exists(file, LinkOption.NOFOLLOW_LINKS)) {
+                if (!Files.isRegularFile(file, LinkOption.NOFOLLOW_LINKS)) throw new IOException("Unsafe configuration");
+                byte[] bytes;
+                try (var input = Files.newInputStream(file, LinkOption.NOFOLLOW_LINKS)) { bytes = input.readNBytes(MAX_BYTES + 1); }
+                if (bytes.length > MAX_BYTES) throw new IOException("Configuration too large");
+                Object loaded = yaml.load(StandardCharsets.UTF_8.newDecoder().decode(ByteBuffer.wrap(bytes)).toString());
+                if (loaded != null) {
+                    if (!(loaded instanceof Map<?, ?> map)) throw new IOException("Invalid configuration root");
+                    for (var entry : map.entrySet()) {
+                        if (!(entry.getKey() instanceof String savedKey)) throw new IOException("Invalid configuration key");
+                        document.put(savedKey, entry.getValue());
+                    }
+                }
+            }
+            document.put(key, value); byte[] bytes = yaml.dump(document).getBytes(StandardCharsets.UTF_8);
+            if (bytes.length > MAX_BYTES) throw new IOException("Configuration too large");
+            Path temporary = Files.createTempFile(directory, ".config-", ".tmp");
+            try {
+                try (var output = FileChannel.open(temporary, StandardOpenOption.WRITE, LinkOption.NOFOLLOW_LINKS)) {
+                    var buffer = ByteBuffer.wrap(bytes); while (buffer.hasRemaining()) output.write(buffer); output.force(true);
+                }
+                replacement.move(temporary, file);
+            } finally { Files.deleteIfExists(temporary); }
+        } catch (OverlappingFileLockException busy) { throw new IOException("Configuration busy"); }
+    }
+
+    private synchronized void finished() { pending--; if (closed && pending == 0) drained.complete(null); }
+    public CompletionStage<Void> drained() { return drained.minimalCompletionStage(); }
+    @Override public synchronized void close() { closed = true; worker.shutdown(); if (pending == 0) drained.complete(null); }
+}

src/main/java/games/dmg/fantasystick/persistence/CharacterStorage.java

@@ -441,12 +441,19 @@ public final class CharacterStorage implements AutoCloseable {
     /** Session-owned remaining health; retain all other current fields and reject concurrent revision changes. */
     public CompletableFuture<Optional<CharacterRecord>> saveHealth(UUID characterId, java.math.BigDecimal health,
                                                                   java.math.BigDecimal nativeLimit) {
+        return saveHealth(characterId, null, health, nativeLimit);
+    }
+
+    /** Ability-owned health mutation that refuses a changed character revision rather than healing stale state. */
+    public CompletableFuture<Optional<CharacterRecord>> saveHealth(UUID characterId, BigInteger expectedRevision,
+            java.math.BigDecimal health, java.math.BigDecimal nativeLimit) {
         Objects.requireNonNull(characterId);
         if (health.signum() < 0 || nativeLimit.signum() <= 0) throw new IllegalArgumentException("Invalid health bound");
         return submit(() -> {
             var found = repository.load(characterId);
             if (found.isEmpty() || found.orElseThrow().dead()) return Optional.empty();
             var old = found.orElseThrow();
+            if (expectedRevision != null && !old.revision().equals(expectedRevision)) return Optional.empty();
             var bounded = health.min(old.maximumHealth()).min(nativeLimit);
             if (old.health().compareTo(bounded) == 0) return Optional.of(old);
             var saved = new CharacterRecord(old.id(), old.name(), old.revision().add(BigInteger.ONE), old.stats(), old.level(),
@@ -495,8 +502,18 @@ public final class CharacterStorage implements AutoCloseable {
     /** Native Revive supplies the current plugin-controlled health ceiling captured on the server thread. */
     public CompletableFuture<Optional<CharacterRecord>> restoreDeathRecord(UUID characterId, UUID deathId,
                                                                             java.math.BigDecimal nativeLimit) {
-        Objects.requireNonNull(characterId);
-        Objects.requireNonNull(deathId);
+        return restore(characterId, deathId, nativeLimit, true);
+    }
+
+    /** Administrator revival retains death identity/consume-once checks but deliberately ignores death age. */
+    public CompletableFuture<Optional<CharacterRecord>> restoreDeathRecordAdministratively(
+            UUID characterId, UUID deathId, java.math.BigDecimal nativeLimit) {
+        return restore(characterId, deathId, nativeLimit, false);
+    }
+
+    private CompletableFuture<Optional<CharacterRecord>> restore(UUID characterId, UUID deathId,
+                                                                  java.math.BigDecimal nativeLimit, boolean ageLimited) {
+        Objects.requireNonNull(characterId); Objects.requireNonNull(deathId);
         if (nativeLimit != null && nativeLimit.signum() <= 0) throw new IllegalArgumentException("Invalid revival health limit");
         Instant selectedAt = clock.instant();
         return submit(() -> {
@@ -504,9 +521,8 @@ public final class CharacterStorage implements AutoCloseable {
             if (found.isEmpty() || !found.orElseThrow().dead()) return Optional.empty();
             CharacterRecord old = found.orElseThrow();
             Duration age = Duration.between(old.diedAt(), selectedAt);
-            if (!deathId.equals(old.deathId()) || age.isNegative() || age.compareTo(Duration.ofHours(24)) >= 0) {
-                return Optional.empty();
-            }
+            if (!deathId.equals(old.deathId()) || age.isNegative()
+                    || ageLimited && age.compareTo(Duration.ofHours(24)) >= 0) return Optional.empty();
             var health = nativeLimit == null ? old.maximumHealth() : old.maximumHealth().min(nativeLimit);
             var restored = new CharacterRecord(old.id(), old.name(), old.revision().add(BigInteger.ONE), old.stats(),
                 old.level(), old.experience(), old.unspentPoints(), health, old.learned(), old.loadout(), old.cooldowns(),

src/main/java/games/dmg/fantasystick/persistence/FrostNovaSettings.java

@@ -0,0 +1,172 @@
+package games.dmg.fantasystick.persistence;
+
+import games.dmg.fantasystick.ability.FrostNova;
+import java.io.IOException;
+import java.math.BigDecimal;
+import java.nio.ByteBuffer;
+import java.nio.channels.FileChannel;
+import java.nio.channels.OverlappingFileLockException;
+import java.nio.charset.StandardCharsets;
+import java.nio.file.Files;
+import java.nio.file.LinkOption;
+import java.nio.file.Path;
+import java.nio.file.StandardCopyOption;
+import java.nio.file.StandardOpenOption;
+import java.time.Duration;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Objects;
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.CompletionStage;
+import java.util.concurrent.Executors;
+import java.util.concurrent.RejectedExecutionException;
+import org.yaml.snakeyaml.LoaderOptions;
+import org.yaml.snakeyaml.Yaml;
+import org.yaml.snakeyaml.constructor.SafeConstructor;
+
+/** Serialized durable Frost Nova settings; publication remains a server-thread caller decision. */
+public final class FrostNovaSettings implements AutoCloseable {
+    private static final int MAX_BYTES = 1_048_576;
+    public static final String BASE = "frost-nova-base-damage";
+    public static final String COOLDOWN = "frost-nova-cooldown-seconds";
+    public static final String RADIUS = "frost-nova-radius-blocks";
+    public static final String SLOWNESS = "frost-nova-slowness-amplifier";
+    public static final String DURATION = "frost-nova-slowness-duration-seconds";
+    private static final List<String> KEYS = List.of(BASE, COOLDOWN, RADIUS, SLOWNESS, DURATION);
+    private static final Map<String, String> DEFAULTS = Map.of(
+        BASE, "5", COOLDOWN, "12", RADIUS, "5", SLOWNESS, "1", DURATION, "3");
+
+    @FunctionalInterface interface Replacement { void move(Path from, Path to) throws IOException; }
+    public record Update(String key, String value, FrostNova.Settings settings, Map<String, String> values, long sequence) {
+        public Update { values = Map.copyOf(values); }
+    }
+
+    private final Path directory;
+    private final Replacement replacement;
+    private final java.util.concurrent.ExecutorService worker = Executors.newSingleThreadExecutor(
+        task -> new Thread(task, "fantasy-frost-nova-configuration"));
+    private volatile Map<String, String> effectiveValues;
+    private Map<String, String> persistedValues;
+    private long persistedSequence;
+    private long publishedSequence;
+    private boolean closed;
+    private int pending;
+    private final CompletableFuture<Void> drained = new CompletableFuture<>();
+
+    public FrostNovaSettings(Path directory, Map<String, String> initial) {
+        this(directory, initial, (from, to) -> Files.move(from, to,
+            StandardCopyOption.ATOMIC_MOVE, StandardCopyOption.REPLACE_EXISTING));
+    }
+
+    FrostNovaSettings(Path directory, Map<String, String> initial, Replacement replacement) {
+        this.directory = Objects.requireNonNull(directory).toAbsolutePath(); this.replacement = Objects.requireNonNull(replacement);
+        var copy = new LinkedHashMap<String, String>();
+        for (String key : KEYS) copy.put(key, Objects.requireNonNull(initial.get(key)));
+        parse(copy); effectiveValues = Map.copyOf(copy); persistedValues = Map.copyOf(copy);
+    }
+
+    public static List<String> keys() { return KEYS; }
+    public static String defaultValue(String key) { return DEFAULTS.get(key); }
+    public String value(String key) { return effectiveValues.get(key); }
+    public FrostNova.Settings settings() { return parse(effectiveValues); }
+
+    public synchronized void publish(Update update) {
+        Objects.requireNonNull(update);
+        if (update.sequence() <= publishedSequence) return;
+        parse(update.values()); effectiveValues = update.values(); publishedSequence = update.sequence();
+    }
+
+    public CompletionStage<Update> set(String key, String value) {
+        Objects.requireNonNull(key); Objects.requireNonNull(value);
+        if (!KEYS.contains(key)) return CompletableFuture.failedStage(new IllegalArgumentException("Unknown setting"));
+        String accepted = canonical(value); var preview = new LinkedHashMap<>(effectiveValues);
+        preview.put(key, accepted); parse(preview);
+        synchronized (this) {
+            if (closed) return CompletableFuture.failedStage(new IOException("Configuration store is closed"));
+            pending++;
+        }
+        try {
+            return CompletableFuture.supplyAsync(() -> {
+                try {
+                    var next = new LinkedHashMap<>(persistedValues); next.put(key, accepted);
+                    var parsed = parse(next); save(key, accepted); persistedValues = Map.copyOf(next);
+                    return new Update(key, accepted, parsed, persistedValues, ++persistedSequence);
+                } catch (IOException | RuntimeException failure) {
+                    throw new java.util.concurrent.CompletionException(failure instanceof IllegalArgumentException
+                        ? failure : new IOException("Frost Nova configuration save refused or failed; effective settings unchanged"));
+                } finally { finished(); }
+            }, worker).minimalCompletionStage();
+        } catch (RejectedExecutionException rejected) {
+            finished(); return CompletableFuture.failedStage(new IOException("Configuration store is closed"));
+        }
+    }
+
+    private static String canonical(String raw) {
+        try { return new BigDecimal(raw).stripTrailingZeros().toPlainString(); }
+        catch (NumberFormatException invalid) { throw new IllegalArgumentException("Invalid value", invalid); }
+    }
+
+    public static FrostNova.Settings parse(Map<String, String> values) {
+        try { return new FrostNova.Settings(new BigDecimal(values.get(BASE)).toBigIntegerExact(),
+            seconds(values.get(COOLDOWN)), finite(values.get(RADIUS)),
+            new BigDecimal(values.get(SLOWNESS)).intValueExact(), seconds(values.get(DURATION))); }
+        catch (ArithmeticException | NumberFormatException | NullPointerException invalid) {
+            throw new IllegalArgumentException("Frost Nova settings must use supported numeric values", invalid);
+        }
+    }
+
+    private static Duration seconds(String value) {
+        var nanos = new BigDecimal(value).movePointRight(9).toBigIntegerExact().longValueExact();
+        return Duration.ofNanos(nanos);
+    }
+
+    private static double finite(String value) {
+        double result = new BigDecimal(value).doubleValue();
+        if (!Double.isFinite(result)) throw new IllegalArgumentException("Setting is not finite");
+        return result;
+    }
+
+    private void save(String key, String value) throws IOException {
+        Files.createDirectories(directory);
+        if (!Files.isDirectory(directory, LinkOption.NOFOLLOW_LINKS)) throw new IOException("Unsafe directory");
+        var file = directory.resolve("config.yml"); var lockFile = directory.resolve(".config.lock");
+        if (Files.exists(lockFile, LinkOption.NOFOLLOW_LINKS) && !Files.isRegularFile(lockFile, LinkOption.NOFOLLOW_LINKS)) {
+            throw new IOException("Unsafe lock");
+        }
+        try (var channel = FileChannel.open(lockFile, StandardOpenOption.CREATE, StandardOpenOption.WRITE,
+                LinkOption.NOFOLLOW_LINKS); var lock = channel.tryLock()) {
+            if (lock == null) throw new IOException("Configuration busy");
+            var options = new LoaderOptions(); options.setAllowDuplicateKeys(false);
+            options.setMaxAliasesForCollections(20); options.setCodePointLimit(MAX_BYTES);
+            var yaml = new Yaml(new SafeConstructor(options)); Map<String, Object> document = new LinkedHashMap<>();
+            if (Files.exists(file, LinkOption.NOFOLLOW_LINKS)) {
+                if (!Files.isRegularFile(file, LinkOption.NOFOLLOW_LINKS)) throw new IOException("Unsafe configuration");
+                byte[] bytes;
+                try (var input = Files.newInputStream(file, LinkOption.NOFOLLOW_LINKS)) { bytes = input.readNBytes(MAX_BYTES + 1); }
+                if (bytes.length > MAX_BYTES) throw new IOException("Configuration too large");
+                Object loaded = yaml.load(StandardCharsets.UTF_8.newDecoder().decode(ByteBuffer.wrap(bytes)).toString());
+                if (loaded != null) {
+                    if (!(loaded instanceof Map<?, ?> map)) throw new IOException("Invalid configuration root");
+                    for (var entry : map.entrySet()) {
+                        if (!(entry.getKey() instanceof String savedKey)) throw new IOException("Invalid configuration key");
+                        document.put(savedKey, entry.getValue());
+                    }
+                }
+            }
+            document.put(key, value); byte[] bytes = yaml.dump(document).getBytes(StandardCharsets.UTF_8);
+            if (bytes.length > MAX_BYTES) throw new IOException("Configuration too large");
+            Path temporary = Files.createTempFile(directory, ".config-", ".tmp");
+            try {
+                try (var output = FileChannel.open(temporary, StandardOpenOption.WRITE, LinkOption.NOFOLLOW_LINKS)) {
+                    var buffer = ByteBuffer.wrap(bytes); while (buffer.hasRemaining()) output.write(buffer); output.force(true);
+                }
+                replacement.move(temporary, file);
+            } finally { Files.deleteIfExists(temporary); }
+        } catch (OverlappingFileLockException busy) { throw new IOException("Configuration busy"); }
+    }
+
+    private synchronized void finished() { pending--; if (closed && pending == 0) drained.complete(null); }
+    public CompletionStage<Void> drained() { return drained.minimalCompletionStage(); }
+    @Override public synchronized void close() { closed = true; worker.shutdown(); if (pending == 0) drained.complete(null); }
+}

src/main/java/games/dmg/fantasystick/persistence/GuardianBondSettings.java

@@ -0,0 +1,170 @@
+package games.dmg.fantasystick.persistence;
+
+import games.dmg.fantasystick.ability.GuardianBond;
+import java.io.IOException;
+import java.math.BigDecimal;
+import java.nio.ByteBuffer;
+import java.nio.channels.FileChannel;
+import java.nio.channels.OverlappingFileLockException;
+import java.nio.charset.StandardCharsets;
+import java.nio.file.Files;
+import java.nio.file.LinkOption;
+import java.nio.file.Path;
+import java.nio.file.StandardCopyOption;
+import java.nio.file.StandardOpenOption;
+import java.time.Duration;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Objects;
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.CompletionStage;
+import java.util.concurrent.Executors;
+import java.util.concurrent.RejectedExecutionException;
+import org.yaml.snakeyaml.LoaderOptions;
+import org.yaml.snakeyaml.Yaml;
+import org.yaml.snakeyaml.constructor.SafeConstructor;
+
+/** Serialized durable Guardian Bond settings; publication remains a server-thread caller decision. */
+public final class GuardianBondSettings implements AutoCloseable {
+    private static final int MAX_BYTES = 1_048_576;
+    public static final String COOLDOWN = "guardian-bond-cooldown-seconds";
+    public static final String RANGE = "guardian-bond-range-blocks";
+    public static final String DURATION = "guardian-bond-duration-seconds";
+    public static final String REDIRECT = "guardian-bond-redirect-percent";
+    private static final List<String> KEYS = List.of(COOLDOWN, DURATION, RANGE, REDIRECT);
+    private static final Map<String, String> DEFAULTS = Map.of(
+        COOLDOWN, "20", RANGE, "10", DURATION, "6", REDIRECT, "30");
+
+    @FunctionalInterface interface Replacement { void move(Path from, Path to) throws IOException; }
+    public record Update(String key, String value, GuardianBond.Settings settings, Map<String, String> values, long sequence) {
+        public Update { values = Map.copyOf(values); }
+    }
+
+    private final Path directory;
+    private final Replacement replacement;
+    private final java.util.concurrent.ExecutorService worker = Executors.newSingleThreadExecutor(
+        task -> new Thread(task, "fantasy-guardian-bond-configuration"));
+    private volatile Map<String, String> effectiveValues;
+    private Map<String, String> persistedValues;
+    private long persistedSequence;
+    private long publishedSequence;
+    private boolean closed;
+    private int pending;
+    private final CompletableFuture<Void> drained = new CompletableFuture<>();
+
+    public GuardianBondSettings(Path directory, Map<String, String> initial) {
+        this(directory, initial, (from, to) -> Files.move(from, to,
+            StandardCopyOption.ATOMIC_MOVE, StandardCopyOption.REPLACE_EXISTING));
+    }
+
+    GuardianBondSettings(Path directory, Map<String, String> initial, Replacement replacement) {
+        this.directory = Objects.requireNonNull(directory).toAbsolutePath(); this.replacement = Objects.requireNonNull(replacement);
+        var copy = new LinkedHashMap<String, String>();
+        for (String key : KEYS) copy.put(key, Objects.requireNonNull(initial.get(key)));
+        parse(copy); effectiveValues = Map.copyOf(copy); persistedValues = Map.copyOf(copy);
+    }
+
+    public static List<String> keys() { return KEYS; }
+    public static String defaultValue(String key) { return DEFAULTS.get(key); }
+    public String value(String key) { return effectiveValues.get(key); }
+    public GuardianBond.Settings settings() { return parse(effectiveValues); }
+
+    public synchronized void publish(Update update) {
+        Objects.requireNonNull(update);
+        if (update.sequence() <= publishedSequence) return;
+        parse(update.values()); effectiveValues = update.values(); publishedSequence = update.sequence();
+    }
+
+    public CompletionStage<Update> set(String key, String value) {
+        Objects.requireNonNull(key); Objects.requireNonNull(value);
+        if (!KEYS.contains(key)) return CompletableFuture.failedStage(new IllegalArgumentException("Unknown setting"));
+        String accepted = canonical(value); var preview = new LinkedHashMap<>(effectiveValues);
+        preview.put(key, accepted); parse(preview);
+        synchronized (this) {
+            if (closed) return CompletableFuture.failedStage(new IOException("Configuration store is closed"));
+            pending++;
+        }
+        try {
+            return CompletableFuture.supplyAsync(() -> {
+                try {
+                    var next = new LinkedHashMap<>(persistedValues); next.put(key, accepted);
+                    var parsed = parse(next); save(key, accepted); persistedValues = Map.copyOf(next);
+                    return new Update(key, accepted, parsed, persistedValues, ++persistedSequence);
+                } catch (IOException | RuntimeException failure) {
+                    throw new java.util.concurrent.CompletionException(failure instanceof IllegalArgumentException
+                        ? failure : new IOException("Guardian Bond configuration save refused or failed; effective settings unchanged"));
+                } finally { finished(); }
+            }, worker).minimalCompletionStage();
+        } catch (RejectedExecutionException rejected) {
+            finished(); return CompletableFuture.failedStage(new IOException("Configuration store is closed"));
+        }
+    }
+
+    private static String canonical(String raw) {
+        try { return new BigDecimal(raw).stripTrailingZeros().toPlainString(); }
+        catch (NumberFormatException invalid) { throw new IllegalArgumentException("Invalid value", invalid); }
+    }
+
+    public static GuardianBond.Settings parse(Map<String, String> values) {
+        try { return new GuardianBond.Settings(seconds(values.get(COOLDOWN)), finite(values.get(RANGE)),
+            seconds(values.get(DURATION)), new BigDecimal(values.get(REDIRECT))); }
+        catch (ArithmeticException | NumberFormatException | NullPointerException invalid) {
+            throw new IllegalArgumentException("Guardian Bond settings must use supported numeric values", invalid);
+        }
+    }
+
+    private static Duration seconds(String value) {
+        var nanos = new BigDecimal(value).movePointRight(9).toBigIntegerExact().longValueExact();
+        return Duration.ofNanos(nanos);
+    }
+
+    private static double finite(String value) {
+        double result = new BigDecimal(value).doubleValue();
+        if (!Double.isFinite(result)) throw new IllegalArgumentException("Setting is not finite");
+        return result;
+    }
+
+    private void save(String key, String value) throws IOException {
+        Files.createDirectories(directory);
+        if (!Files.isDirectory(directory, LinkOption.NOFOLLOW_LINKS)) throw new IOException("Unsafe directory");
+        var file = directory.resolve("config.yml"); var lockFile = directory.resolve(".config.lock");
+        if (Files.exists(lockFile, LinkOption.NOFOLLOW_LINKS) && !Files.isRegularFile(lockFile, LinkOption.NOFOLLOW_LINKS)) {
+            throw new IOException("Unsafe lock");
+        }
+        try (var channel = FileChannel.open(lockFile, StandardOpenOption.CREATE, StandardOpenOption.WRITE,
+                LinkOption.NOFOLLOW_LINKS); var lock = channel.tryLock()) {
+            if (lock == null) throw new IOException("Configuration busy");
+            var options = new LoaderOptions(); options.setAllowDuplicateKeys(false);
+            options.setMaxAliasesForCollections(20); options.setCodePointLimit(MAX_BYTES);
+            var yaml = new Yaml(new SafeConstructor(options)); Map<String, Object> document = new LinkedHashMap<>();
+            if (Files.exists(file, LinkOption.NOFOLLOW_LINKS)) {
+                if (!Files.isRegularFile(file, LinkOption.NOFOLLOW_LINKS)) throw new IOException("Unsafe configuration");
+                byte[] bytes;
+                try (var input = Files.newInputStream(file, LinkOption.NOFOLLOW_LINKS)) { bytes = input.readNBytes(MAX_BYTES + 1); }
+                if (bytes.length > MAX_BYTES) throw new IOException("Configuration too large");
+                Object loaded = yaml.load(StandardCharsets.UTF_8.newDecoder().decode(ByteBuffer.wrap(bytes)).toString());
+                if (loaded != null) {
+                    if (!(loaded instanceof Map<?, ?> map)) throw new IOException("Invalid configuration root");
+                    for (var entry : map.entrySet()) {
+                        if (!(entry.getKey() instanceof String savedKey)) throw new IOException("Invalid configuration key");
+                        document.put(savedKey, entry.getValue());
+                    }
+                }
+            }
+            document.put(key, value); byte[] bytes = yaml.dump(document).getBytes(StandardCharsets.UTF_8);
+            if (bytes.length > MAX_BYTES) throw new IOException("Configuration too large");
+            Path temporary = Files.createTempFile(directory, ".config-", ".tmp");
+            try {
+                try (var output = FileChannel.open(temporary, StandardOpenOption.WRITE, LinkOption.NOFOLLOW_LINKS)) {
+                    var buffer = ByteBuffer.wrap(bytes); while (buffer.hasRemaining()) output.write(buffer); output.force(true);
+                }
+                replacement.move(temporary, file);
+            } finally { Files.deleteIfExists(temporary); }
+        } catch (OverlappingFileLockException busy) { throw new IOException("Configuration busy"); }
+    }
+
+    private synchronized void finished() { pending--; if (closed && pending == 0) drained.complete(null); }
+    public CompletionStage<Void> drained() { return drained.minimalCompletionStage(); }
+    @Override public synchronized void close() { closed = true; worker.shutdown(); if (pending == 0) drained.complete(null); }
+}

src/main/java/games/dmg/fantasystick/persistence/HexSettings.java

@@ -0,0 +1,190 @@
+package games.dmg.fantasystick.persistence;
+
+import games.dmg.fantasystick.ability.Hex;
+import java.io.IOException;
+import java.nio.ByteBuffer;
+import java.nio.channels.FileChannel;
+import java.nio.channels.OverlappingFileLockException;
+import java.nio.charset.StandardCharsets;
+import java.nio.file.Files;
+import java.nio.file.LinkOption;
+import java.nio.file.Path;
+import java.nio.file.StandardCopyOption;
+import java.nio.file.StandardOpenOption;
+import java.time.Duration;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Objects;
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.CompletionStage;
+import java.util.concurrent.Executors;
+import java.util.concurrent.RejectedExecutionException;
+import org.yaml.snakeyaml.LoaderOptions;
+import org.yaml.snakeyaml.Yaml;
+import org.yaml.snakeyaml.constructor.SafeConstructor;
+
+/** Serialized durable Hex settings; publication remains a server-thread caller decision. */
+public final class HexSettings implements AutoCloseable {
+    private static final int MAX_BYTES = 1_048_576;
+    public static final String COOLDOWN = "hex-cooldown-seconds";
+    public static final String RANGE = "hex-range-blocks";
+    public static final String DURATION = "hex-duration-seconds";
+    public static final String REDUCTION = "hex-damage-reduction-percent";
+    private static final List<String> KEYS = List.of(COOLDOWN, RANGE, DURATION, REDUCTION);
+    private static final Map<String, String> DEFAULTS = Map.of(COOLDOWN, "10", RANGE, "12", DURATION, "4", REDUCTION, "20");
+
+    @FunctionalInterface interface Replacement { void move(Path from, Path to) throws IOException; }
+    public record Update(String key, String value, Hex.Settings settings,
+                         Map<String, String> values, long sequence) {
+        public Update { values = Map.copyOf(values); }
+    }
+
+    private final Path directory;
+    private final Replacement replacement;
+    private final java.util.concurrent.ExecutorService worker = Executors.newSingleThreadExecutor(
+        task -> new Thread(task, "fantasy-hex-configuration"));
+    private volatile Map<String, String> effectiveValues;
+    private Map<String, String> persistedValues;
+    private long persistedSequence;
+    private long publishedSequence;
+    private boolean closed;
+    private int pending;
+    private final CompletableFuture<Void> drained = new CompletableFuture<>();
+
+    public HexSettings(Path directory, Map<String, String> initial) {
+        this(directory, initial, (from, to) -> Files.move(from, to,
+            StandardCopyOption.ATOMIC_MOVE, StandardCopyOption.REPLACE_EXISTING));
+    }
+
+    HexSettings(Path directory, Map<String, String> initial, Replacement replacement) {
+        this.directory = Objects.requireNonNull(directory).toAbsolutePath();
+        this.replacement = Objects.requireNonNull(replacement);
+        var copy = new LinkedHashMap<String, String>();
+        for (String key : KEYS) copy.put(key, Objects.requireNonNull(initial.get(key)));
+        parse(copy);
+        effectiveValues = Map.copyOf(copy); persistedValues = Map.copyOf(copy);
+    }
+
+    public static List<String> keys() { return KEYS; }
+    public static String defaultValue(String key) { return DEFAULTS.get(key); }
+    public String value(String key) { return effectiveValues.get(key); }
+    public Hex.Settings settings() { return parse(effectiveValues); }
+
+    /** Publish only after the caller returns the durable acknowledgment to the server thread. */
+    public synchronized void publish(Update update) {
+        Objects.requireNonNull(update);
+        if (update.sequence() <= publishedSequence) return;
+        parse(update.values());
+        effectiveValues = update.values(); publishedSequence = update.sequence();
+    }
+
+    public CompletionStage<Update> set(String key, String value) {
+        Objects.requireNonNull(key); Objects.requireNonNull(value);
+        if (!KEYS.contains(key)) return CompletableFuture.failedStage(new IllegalArgumentException("Unknown setting"));
+        String accepted = canonical(key, value);
+        var preview = new LinkedHashMap<>(effectiveValues); preview.put(key, accepted);
+        parse(preview); // Fail malformed/out-of-range command input before queueing accepted persistence.
+        synchronized (this) {
+            if (closed) return CompletableFuture.failedStage(new IOException("Configuration store is closed"));
+            pending++;
+        }
+        try {
+            return CompletableFuture.supplyAsync(() -> {
+                try {
+                    var next = new LinkedHashMap<>(persistedValues);
+                    next.put(key, accepted);
+                    var parsed = parse(next);
+                    save(key, accepted);
+                    persistedValues = Map.copyOf(next);
+                    return new Update(key, accepted, parsed, persistedValues, ++persistedSequence);
+                } catch (IOException | RuntimeException failure) {
+                    throw new java.util.concurrent.CompletionException(failure instanceof IllegalArgumentException
+                        ? failure : new IOException("Hex configuration save refused or failed; effective settings unchanged"));
+                } finally { finished(); }
+            }, worker).minimalCompletionStage();
+        } catch (RejectedExecutionException rejected) {
+            finished();
+            return CompletableFuture.failedStage(new IOException("Configuration store is closed"));
+        }
+    }
+
+    private static String canonical(String key, String raw) {
+        try {
+            return new java.math.BigDecimal(raw).stripTrailingZeros().toPlainString();
+        } catch (NumberFormatException invalid) { throw new IllegalArgumentException("Invalid value", invalid); }
+    }
+
+    public static Hex.Settings parse(Map<String, String> values) {
+        try {
+            var cooldown = seconds(values.get(COOLDOWN));
+            var range = finite(values.get(RANGE));
+            var duration = seconds(values.get(DURATION));
+            var reduction = new java.math.BigDecimal(values.get(REDUCTION));
+            return new Hex.Settings(cooldown, range, duration, reduction);
+        } catch (ArithmeticException | NumberFormatException | NullPointerException invalid) {
+            throw new IllegalArgumentException("Hex settings must use supported numeric values", invalid);
+        }
+    }
+
+    private static Duration seconds(String value) {
+        var nanos = new java.math.BigDecimal(value).movePointRight(9).toBigIntegerExact().longValueExact();
+        return Duration.ofNanos(nanos);
+    }
+
+    private static double finite(String value) {
+        double result = new java.math.BigDecimal(value).doubleValue();
+        if (!Double.isFinite(result)) throw new IllegalArgumentException("Setting is not finite");
+        return result;
+    }
+
+    private void save(String key, String value) throws IOException {
+        Files.createDirectories(directory);
+        if (!Files.isDirectory(directory, LinkOption.NOFOLLOW_LINKS)) throw new IOException("Unsafe directory");
+        var file = directory.resolve("config.yml");
+        var lockFile = directory.resolve(".config.lock");
+        if (Files.exists(lockFile, LinkOption.NOFOLLOW_LINKS)
+                && !Files.isRegularFile(lockFile, LinkOption.NOFOLLOW_LINKS)) throw new IOException("Unsafe lock");
+        try (var channel = FileChannel.open(lockFile, StandardOpenOption.CREATE, StandardOpenOption.WRITE,
+                LinkOption.NOFOLLOW_LINKS); var lock = channel.tryLock()) {
+            if (lock == null) throw new IOException("Configuration busy");
+            var options = new LoaderOptions(); options.setAllowDuplicateKeys(false);
+            options.setMaxAliasesForCollections(20); options.setCodePointLimit(MAX_BYTES);
+            var yaml = new Yaml(new SafeConstructor(options));
+            Map<String, Object> document = new LinkedHashMap<>();
+            if (Files.exists(file, LinkOption.NOFOLLOW_LINKS)) {
+                if (!Files.isRegularFile(file, LinkOption.NOFOLLOW_LINKS)) throw new IOException("Unsafe configuration");
+                byte[] bytes;
+                try (var input = Files.newInputStream(file, LinkOption.NOFOLLOW_LINKS)) { bytes = input.readNBytes(MAX_BYTES + 1); }
+                if (bytes.length > MAX_BYTES) throw new IOException("Configuration too large");
+                Object loaded = yaml.load(StandardCharsets.UTF_8.newDecoder().decode(ByteBuffer.wrap(bytes)).toString());
+                if (loaded != null) {
+                    if (!(loaded instanceof Map<?, ?> map)) throw new IOException("Invalid configuration root");
+                    for (var entry : map.entrySet()) {
+                        if (!(entry.getKey() instanceof String savedKey)) throw new IOException("Invalid configuration key");
+                        document.put(savedKey, entry.getValue());
+                    }
+                }
+            }
+            document.put(key, value);
+            byte[] bytes = yaml.dump(document).getBytes(StandardCharsets.UTF_8);
+            if (bytes.length > MAX_BYTES) throw new IOException("Configuration too large");
+            Path temporary = Files.createTempFile(directory, ".config-", ".tmp");
+            try {
+                try (var output = FileChannel.open(temporary, StandardOpenOption.WRITE, LinkOption.NOFOLLOW_LINKS)) {
+                    var buffer = ByteBuffer.wrap(bytes); while (buffer.hasRemaining()) output.write(buffer); output.force(true);
+                }
+                replacement.move(temporary, file);
+            } finally { Files.deleteIfExists(temporary); }
+        } catch (OverlappingFileLockException busy) { throw new IOException("Configuration busy"); }
+    }
+
+    private synchronized void finished() {
+        pending--;
+        if (closed && pending == 0) drained.complete(null);
+    }
+    public CompletionStage<Void> drained() { return drained.minimalCompletionStage(); }
+    @Override public synchronized void close() {
+        closed = true; worker.shutdown(); if (pending == 0) drained.complete(null);
+    }
+}

src/main/java/games/dmg/fantasystick/persistence/InspireSettings.java

@@ -0,0 +1,191 @@
+package games.dmg.fantasystick.persistence;
+
+import games.dmg.fantasystick.ability.Inspire;
+import java.io.IOException;
+import java.nio.ByteBuffer;
+import java.nio.channels.FileChannel;
+import java.nio.channels.OverlappingFileLockException;
+import java.nio.charset.StandardCharsets;
+import java.nio.file.Files;
+import java.nio.file.LinkOption;
+import java.nio.file.Path;
+import java.nio.file.StandardCopyOption;
+import java.nio.file.StandardOpenOption;
+import java.time.Duration;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Objects;
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.CompletionStage;
+import java.util.concurrent.Executors;
+import java.util.concurrent.RejectedExecutionException;
+import org.yaml.snakeyaml.LoaderOptions;
+import org.yaml.snakeyaml.Yaml;
+import org.yaml.snakeyaml.constructor.SafeConstructor;
+
+/** Serialized durable Inspire settings; publication remains a server-thread caller decision. */
+public final class InspireSettings implements AutoCloseable {
+    private static final int MAX_BYTES = 1_048_576;
+    public static final String BASE = "inspire-base-temporary-health";
+    public static final String COOLDOWN = "inspire-cooldown-seconds";
+    public static final String RANGE = "inspire-range-blocks";
+    public static final String DURATION = "inspire-duration-seconds";
+    private static final List<String> KEYS = List.of(BASE, COOLDOWN, RANGE, DURATION);
+    private static final Map<String, String> DEFAULTS = Map.of(BASE, "4", COOLDOWN, "15", RANGE, "12", DURATION, "6");
+
+    @FunctionalInterface interface Replacement { void move(Path from, Path to) throws IOException; }
+    public record Update(String key, String value, Inspire.Settings settings,
+                         Map<String, String> values, long sequence) {
+        public Update { values = Map.copyOf(values); }
+    }
+
+    private final Path directory;
+    private final Replacement replacement;
+    private final java.util.concurrent.ExecutorService worker = Executors.newSingleThreadExecutor(
+        task -> new Thread(task, "fantasy-inspire-configuration"));
+    private volatile Map<String, String> effectiveValues;
+    private Map<String, String> persistedValues;
+    private long persistedSequence;
+    private long publishedSequence;
+    private boolean closed;
+    private int pending;
+    private final CompletableFuture<Void> drained = new CompletableFuture<>();
+
+    public InspireSettings(Path directory, Map<String, String> initial) {
+        this(directory, initial, (from, to) -> Files.move(from, to,
+            StandardCopyOption.ATOMIC_MOVE, StandardCopyOption.REPLACE_EXISTING));
+    }
+
+    InspireSettings(Path directory, Map<String, String> initial, Replacement replacement) {
+        this.directory = Objects.requireNonNull(directory).toAbsolutePath();
+        this.replacement = Objects.requireNonNull(replacement);
+        var copy = new LinkedHashMap<String, String>();
+        for (String key : KEYS) copy.put(key, Objects.requireNonNull(initial.get(key)));
+        parse(copy);
+        effectiveValues = Map.copyOf(copy); persistedValues = Map.copyOf(copy);
+    }
+
+    public static List<String> keys() { return KEYS; }
+    public static String defaultValue(String key) { return DEFAULTS.get(key); }
+    public String value(String key) { return effectiveValues.get(key); }
+    public Inspire.Settings settings() { return parse(effectiveValues); }
+
+    /** Publish only after the caller returns the durable acknowledgment to the server thread. */
+    public synchronized void publish(Update update) {
+        Objects.requireNonNull(update);
+        if (update.sequence() <= publishedSequence) return;
+        parse(update.values());
+        effectiveValues = update.values(); publishedSequence = update.sequence();
+    }
+
+    public CompletionStage<Update> set(String key, String value) {
+        Objects.requireNonNull(key); Objects.requireNonNull(value);
+        if (!KEYS.contains(key)) return CompletableFuture.failedStage(new IllegalArgumentException("Unknown setting"));
+        String accepted = canonical(key, value);
+        var preview = new LinkedHashMap<>(effectiveValues); preview.put(key, accepted);
+        parse(preview); // Fail malformed/out-of-range command input before queueing accepted persistence.
+        synchronized (this) {
+            if (closed) return CompletableFuture.failedStage(new IOException("Configuration store is closed"));
+            pending++;
+        }
+        try {
+            return CompletableFuture.supplyAsync(() -> {
+                try {
+                    var next = new LinkedHashMap<>(persistedValues);
+                    next.put(key, accepted);
+                    var parsed = parse(next);
+                    save(key, accepted);
+                    persistedValues = Map.copyOf(next);
+                    return new Update(key, accepted, parsed, persistedValues, ++persistedSequence);
+                } catch (IOException | RuntimeException failure) {
+                    throw new java.util.concurrent.CompletionException(failure instanceof IllegalArgumentException
+                        ? failure : new IOException("Inspire configuration save refused or failed; effective settings unchanged"));
+                } finally { finished(); }
+            }, worker).minimalCompletionStage();
+        } catch (RejectedExecutionException rejected) {
+            finished();
+            return CompletableFuture.failedStage(new IOException("Configuration store is closed"));
+        }
+    }
+
+    private static String canonical(String key, String raw) {
+        try {
+            if (key.equals(BASE)) return new java.math.BigInteger(raw).toString();
+            return new java.math.BigDecimal(raw).stripTrailingZeros().toPlainString();
+        } catch (NumberFormatException invalid) { throw new IllegalArgumentException("Invalid value", invalid); }
+    }
+
+    public static Inspire.Settings parse(Map<String, String> values) {
+        try {
+            var base = new java.math.BigInteger(values.get(BASE));
+            var cooldown = seconds(values.get(COOLDOWN));
+            var range = finite(values.get(RANGE));
+            var duration = seconds(values.get(DURATION));
+            return new Inspire.Settings(base, cooldown, range, duration);
+        } catch (ArithmeticException | NumberFormatException | NullPointerException invalid) {
+            throw new IllegalArgumentException("Inspire settings must use supported numeric values", invalid);
+        }
+    }
+
+    private static Duration seconds(String value) {
+        var nanos = new java.math.BigDecimal(value).movePointRight(9).toBigIntegerExact().longValueExact();
+        return Duration.ofNanos(nanos);
+    }
+
+    private static double finite(String value) {
+        double result = new java.math.BigDecimal(value).doubleValue();
+        if (!Double.isFinite(result)) throw new IllegalArgumentException("Setting is not finite");
+        return result;
+    }
+
+    private void save(String key, String value) throws IOException {
+        Files.createDirectories(directory);
+        if (!Files.isDirectory(directory, LinkOption.NOFOLLOW_LINKS)) throw new IOException("Unsafe directory");
+        var file = directory.resolve("config.yml");
+        var lockFile = directory.resolve(".config.lock");
+        if (Files.exists(lockFile, LinkOption.NOFOLLOW_LINKS)
+                && !Files.isRegularFile(lockFile, LinkOption.NOFOLLOW_LINKS)) throw new IOException("Unsafe lock");
+        try (var channel = FileChannel.open(lockFile, StandardOpenOption.CREATE, StandardOpenOption.WRITE,
+                LinkOption.NOFOLLOW_LINKS); var lock = channel.tryLock()) {
+            if (lock == null) throw new IOException("Configuration busy");
+            var options = new LoaderOptions(); options.setAllowDuplicateKeys(false);
+            options.setMaxAliasesForCollections(20); options.setCodePointLimit(MAX_BYTES);
+            var yaml = new Yaml(new SafeConstructor(options));
+            Map<String, Object> document = new LinkedHashMap<>();
+            if (Files.exists(file, LinkOption.NOFOLLOW_LINKS)) {
+                if (!Files.isRegularFile(file, LinkOption.NOFOLLOW_LINKS)) throw new IOException("Unsafe configuration");
+                byte[] bytes;
+                try (var input = Files.newInputStream(file, LinkOption.NOFOLLOW_LINKS)) { bytes = input.readNBytes(MAX_BYTES + 1); }
+                if (bytes.length > MAX_BYTES) throw new IOException("Configuration too large");
+                Object loaded = yaml.load(StandardCharsets.UTF_8.newDecoder().decode(ByteBuffer.wrap(bytes)).toString());
+                if (loaded != null) {
+                    if (!(loaded instanceof Map<?, ?> map)) throw new IOException("Invalid configuration root");
+                    for (var entry : map.entrySet()) {
+                        if (!(entry.getKey() instanceof String savedKey)) throw new IOException("Invalid configuration key");
+                        document.put(savedKey, entry.getValue());
+                    }
+                }
+            }
+            document.put(key, value);
+            byte[] bytes = yaml.dump(document).getBytes(StandardCharsets.UTF_8);
+            if (bytes.length > MAX_BYTES) throw new IOException("Configuration too large");
+            Path temporary = Files.createTempFile(directory, ".config-", ".tmp");
+            try {
+                try (var output = FileChannel.open(temporary, StandardOpenOption.WRITE, LinkOption.NOFOLLOW_LINKS)) {
+                    var buffer = ByteBuffer.wrap(bytes); while (buffer.hasRemaining()) output.write(buffer); output.force(true);
+                }
+                replacement.move(temporary, file);
+            } finally { Files.deleteIfExists(temporary); }
+        } catch (OverlappingFileLockException busy) { throw new IOException("Configuration busy"); }
+    }
+
+    private synchronized void finished() {
+        pending--;
+        if (closed && pending == 0) drained.complete(null);
+    }
+    public CompletionStage<Void> drained() { return drained.minimalCompletionStage(); }
+    @Override public synchronized void close() {
+        closed = true; worker.shutdown(); if (pending == 0) drained.complete(null);
+    }
+}

src/main/java/games/dmg/fantasystick/persistence/MendingLightSettings.java

@@ -0,0 +1,172 @@
+package games.dmg.fantasystick.persistence;
+
+import games.dmg.fantasystick.ability.MendingLight;
+import java.io.IOException;
+import java.nio.ByteBuffer;
+import java.nio.channels.FileChannel;
+import java.nio.channels.OverlappingFileLockException;
+import java.nio.charset.StandardCharsets;
+import java.nio.file.Files;
+import java.nio.file.LinkOption;
+import java.nio.file.Path;
+import java.nio.file.StandardCopyOption;
+import java.nio.file.StandardOpenOption;
+import java.math.BigDecimal;
+import java.time.Duration;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Objects;
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.CompletionStage;
+import java.util.concurrent.Executors;
+import java.util.concurrent.RejectedExecutionException;
+import org.yaml.snakeyaml.LoaderOptions;
+import org.yaml.snakeyaml.Yaml;
+import org.yaml.snakeyaml.constructor.SafeConstructor;
+
+/** Serialized durable Mending Light settings; publication remains a server-thread caller decision. */
+public final class MendingLightSettings implements AutoCloseable {
+    private static final int MAX_BYTES = 1_048_576;
+    public static final String BASE_HEALING = "mending-light-base-healing";
+    public static final String COOLDOWN = "mending-light-cooldown-seconds";
+    public static final String RANGE = "mending-light-range-blocks";
+    private static final List<String> KEYS = List.of(BASE_HEALING, COOLDOWN, RANGE);
+    private static final Map<String, String> DEFAULTS = Map.of(BASE_HEALING, "6", COOLDOWN, "8", RANGE, "12");
+
+    @FunctionalInterface interface Replacement { void move(Path from, Path to) throws IOException; }
+    public record Update(String key, String value, MendingLight.Settings settings,
+                         Map<String, String> values, long sequence) {
+        public Update { values = Map.copyOf(values); }
+    }
+
+    private final Path directory;
+    private final Replacement replacement;
+    private final java.util.concurrent.ExecutorService worker = Executors.newSingleThreadExecutor(
+        task -> new Thread(task, "fantasy-mending-light-configuration"));
+    private volatile Map<String, String> effectiveValues;
+    private Map<String, String> persistedValues;
+    private long persistedSequence;
+    private long publishedSequence;
+    private boolean closed;
+    private int pending;
+    private final CompletableFuture<Void> drained = new CompletableFuture<>();
+
+    public MendingLightSettings(Path directory, Map<String, String> initial) {
+        this(directory, initial, (from, to) -> Files.move(from, to,
+            StandardCopyOption.ATOMIC_MOVE, StandardCopyOption.REPLACE_EXISTING));
+    }
+
+    MendingLightSettings(Path directory, Map<String, String> initial, Replacement replacement) {
+        this.directory = Objects.requireNonNull(directory).toAbsolutePath(); this.replacement = Objects.requireNonNull(replacement);
+        var copy = new LinkedHashMap<String, String>();
+        for (String key : KEYS) copy.put(key, Objects.requireNonNull(initial.get(key)));
+        parse(copy); effectiveValues = Map.copyOf(copy); persistedValues = Map.copyOf(copy);
+    }
+
+    public static List<String> keys() { return KEYS; }
+    public static String defaultValue(String key) { return DEFAULTS.get(key); }
+    public String value(String key) { return effectiveValues.get(key); }
+    public MendingLight.Settings settings() { return parse(effectiveValues); }
+
+    public synchronized void publish(Update update) {
+        Objects.requireNonNull(update);
+        if (update.sequence() <= publishedSequence) return;
+        parse(update.values()); effectiveValues = update.values(); publishedSequence = update.sequence();
+    }
+
+    public CompletionStage<Update> set(String key, String value) {
+        Objects.requireNonNull(key); Objects.requireNonNull(value);
+        if (!KEYS.contains(key)) return CompletableFuture.failedStage(new IllegalArgumentException("Unknown setting"));
+        String accepted = canonical(key, value);
+        var preview = new LinkedHashMap<>(effectiveValues); preview.put(key, accepted); parse(preview);
+        synchronized (this) {
+            if (closed) return CompletableFuture.failedStage(new IOException("Configuration store is closed"));
+            pending++;
+        }
+        try {
+            return CompletableFuture.supplyAsync(() -> {
+                try {
+                    var next = new LinkedHashMap<>(persistedValues); next.put(key, accepted);
+                    var parsed = parse(next); save(key, accepted); persistedValues = Map.copyOf(next);
+                    return new Update(key, accepted, parsed, persistedValues, ++persistedSequence);
+                } catch (IOException | RuntimeException failure) {
+                    throw new java.util.concurrent.CompletionException(failure instanceof IllegalArgumentException
+                        ? failure : new IOException("Mending Light configuration save refused or failed; effective settings unchanged"));
+                } finally { finished(); }
+            }, worker).minimalCompletionStage();
+        } catch (RejectedExecutionException rejected) {
+            finished(); return CompletableFuture.failedStage(new IOException("Configuration store is closed"));
+        }
+    }
+
+    private static String canonical(String key, String raw) {
+        try {
+            if (key.equals(BASE_HEALING)) return new java.math.BigInteger(raw).toString();
+            return new BigDecimal(raw).stripTrailingZeros().toPlainString();
+        } catch (NumberFormatException invalid) { throw new IllegalArgumentException("Invalid value", invalid); }
+    }
+
+    public static MendingLight.Settings parse(Map<String, String> values) {
+        try {
+            return new MendingLight.Settings(new java.math.BigInteger(values.get(BASE_HEALING)),
+                seconds(values.get(COOLDOWN)), finite(values.get(RANGE)));
+        } catch (ArithmeticException | NumberFormatException | NullPointerException invalid) {
+            throw new IllegalArgumentException("Mending Light settings must use supported numeric values", invalid);
+        }
+    }
+
+    private static Duration seconds(String value) {
+        var nanos = new BigDecimal(value).movePointRight(9).toBigIntegerExact().longValueExact();
+        return Duration.ofNanos(nanos);
+    }
+
+    private static double finite(String value) {
+        double result = new BigDecimal(value).doubleValue();
+        if (!Double.isFinite(result)) throw new IllegalArgumentException("Setting is not finite");
+        return result;
+    }
+
+    private void save(String key, String value) throws IOException {
+        Files.createDirectories(directory);
+        if (!Files.isDirectory(directory, LinkOption.NOFOLLOW_LINKS)) throw new IOException("Unsafe directory");
+        var file = directory.resolve("config.yml"); var lockFile = directory.resolve(".config.lock");
+        if (Files.exists(lockFile, LinkOption.NOFOLLOW_LINKS) && !Files.isRegularFile(lockFile, LinkOption.NOFOLLOW_LINKS)) {
+            throw new IOException("Unsafe lock");
+        }
+        try (var channel = FileChannel.open(lockFile, StandardOpenOption.CREATE, StandardOpenOption.WRITE,
+                LinkOption.NOFOLLOW_LINKS); var lock = channel.tryLock()) {
+            if (lock == null) throw new IOException("Configuration busy");
+            var options = new LoaderOptions(); options.setAllowDuplicateKeys(false);
+            options.setMaxAliasesForCollections(20); options.setCodePointLimit(MAX_BYTES);
+            var yaml = new Yaml(new SafeConstructor(options)); Map<String, Object> document = new LinkedHashMap<>();
+            if (Files.exists(file, LinkOption.NOFOLLOW_LINKS)) {
+                if (!Files.isRegularFile(file, LinkOption.NOFOLLOW_LINKS)) throw new IOException("Unsafe configuration");
+                byte[] bytes;
+                try (var input = Files.newInputStream(file, LinkOption.NOFOLLOW_LINKS)) { bytes = input.readNBytes(MAX_BYTES + 1); }
+                if (bytes.length > MAX_BYTES) throw new IOException("Configuration too large");
+                Object loaded = yaml.load(StandardCharsets.UTF_8.newDecoder().decode(ByteBuffer.wrap(bytes)).toString());
+                if (loaded != null) {
+                    if (!(loaded instanceof Map<?, ?> map)) throw new IOException("Invalid configuration root");
+                    for (var entry : map.entrySet()) {
+                        if (!(entry.getKey() instanceof String savedKey)) throw new IOException("Invalid configuration key");
+                        document.put(savedKey, entry.getValue());
+                    }
+                }
+            }
+            document.put(key, value); byte[] bytes = yaml.dump(document).getBytes(StandardCharsets.UTF_8);
+            if (bytes.length > MAX_BYTES) throw new IOException("Configuration too large");
+            Path temporary = Files.createTempFile(directory, ".config-", ".tmp");
+            try {
+                try (var output = FileChannel.open(temporary, StandardOpenOption.WRITE, LinkOption.NOFOLLOW_LINKS)) {
+                    var buffer = ByteBuffer.wrap(bytes); while (buffer.hasRemaining()) output.write(buffer); output.force(true);
+                }
+                replacement.move(temporary, file);
+            } finally { Files.deleteIfExists(temporary); }
+        } catch (OverlappingFileLockException busy) { throw new IOException("Configuration busy"); }
+    }
+
+    private synchronized void finished() { pending--; if (closed && pending == 0) drained.complete(null); }
+    public CompletionStage<Void> drained() { return drained.minimalCompletionStage(); }
+    @Override public synchronized void close() { closed = true; worker.shutdown(); if (pending == 0) drained.complete(null); }
+}

src/main/java/games/dmg/fantasystick/persistence/PartySettings.java

@@ -0,0 +1,43 @@
+package games.dmg.fantasystick.persistence;
+
+import java.io.IOException;
+import java.nio.ByteBuffer;
+import java.nio.channels.FileChannel;
+import java.nio.channels.OverlappingFileLockException;
+import java.nio.charset.StandardCharsets;
+import java.nio.file.Files;
+import java.nio.file.LinkOption;
+import java.nio.file.Path;
+import java.nio.file.StandardCopyOption;
+import java.nio.file.StandardOpenOption;
+import java.time.Duration;
+import java.util.LinkedHashMap;
+import java.util.Map;
+import java.util.Objects;
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.CompletionStage;
+import java.util.concurrent.Executors;
+import java.util.concurrent.RejectedExecutionException;
+import org.yaml.snakeyaml.LoaderOptions;
+import org.yaml.snakeyaml.Yaml;
+import org.yaml.snakeyaml.constructor.SafeConstructor;
+
+/** Durable save-before-publish policy for party capacity checks and book presentation. */
+public final class PartySettings implements AutoCloseable {
+    public static final String KEY="party-max-size";public static final String DEFAULT="6";
+    private static final int MAX_BYTES=1_048_576;
+    @FunctionalInterface interface Replacement{void move(Path from,Path to)throws IOException;}
+    public record Update(String value,int maximum,long sequence){}
+    private final Path directory;private final Replacement replacement;private final java.util.concurrent.ExecutorService worker=Executors.newSingleThreadExecutor(task->new Thread(task,"fantasy-party-configuration"));
+    private volatile int effective;private long persistedSequence,publishedSequence;private boolean closed;private int pending;private final CompletableFuture<Void> drained=new CompletableFuture<>();
+    public PartySettings(Path directory,int initial){this(directory,initial,(from,to)->Files.move(from,to,StandardCopyOption.ATOMIC_MOVE,StandardCopyOption.REPLACE_EXISTING));}
+    PartySettings(Path directory,int initial,Replacement replacement){this.directory=Objects.requireNonNull(directory).toAbsolutePath();this.replacement=Objects.requireNonNull(replacement);effective=validate(initial);}
+    public static int parse(Object value){if(value==null)return 6;if(!(value instanceof Number number))throw new IllegalArgumentException(KEY+" must be a positive whole number");try{return validate(new java.math.BigDecimal(number.toString()).intValueExact());}catch(ArithmeticException|NumberFormatException invalid){throw new IllegalArgumentException(KEY+" must be a representable positive whole number",invalid);}}
+    private static int parseText(String value){if(value==null||!value.matches("[0-9]+"))throw new IllegalArgumentException(KEY+" must be a positive whole number");try{return validate(new java.math.BigInteger(value).intValueExact());}catch(ArithmeticException|NumberFormatException invalid){throw new IllegalArgumentException(KEY+" must be a representable positive whole number",invalid);}}
+    private static int validate(int value){if(value<1)throw new IllegalArgumentException(KEY+" must be a positive whole number");return value;}
+    public int maximum(){return effective;}public String value(){return Integer.toString(effective);}
+    public CompletionStage<Update> set(String raw){int accepted=parseText(raw);synchronized(this){if(closed)return CompletableFuture.failedStage(new IOException("Configuration store is closed"));pending++;}try{return CompletableFuture.supplyAsync(()->{try{save(accepted);return new Update(Integer.toString(accepted),accepted,++persistedSequence);}catch(IOException|RuntimeException failure){throw new java.util.concurrent.CompletionException(new IOException("Party configuration save refused or failed; effective setting unchanged"));}finally{finished();}},worker).minimalCompletionStage();}catch(RejectedExecutionException rejected){finished();return CompletableFuture.failedStage(new IOException("Configuration store is closed"));}}
+    public synchronized boolean publish(Update update){if(update.sequence()<=publishedSequence)return false;effective=validate(update.maximum());publishedSequence=update.sequence();return true;}
+    private void save(int value)throws IOException{Files.createDirectories(directory);if(!Files.isDirectory(directory,LinkOption.NOFOLLOW_LINKS))throw new IOException("Unsafe directory");var file=directory.resolve("config.yml");var lockFile=directory.resolve(".config.lock");if(Files.exists(lockFile,LinkOption.NOFOLLOW_LINKS)&&!Files.isRegularFile(lockFile,LinkOption.NOFOLLOW_LINKS))throw new IOException("Unsafe lock");try(var channel=FileChannel.open(lockFile,StandardOpenOption.CREATE,StandardOpenOption.WRITE,LinkOption.NOFOLLOW_LINKS);var lock=channel.tryLock()){if(lock==null)throw new IOException("Configuration busy");var options=new LoaderOptions();options.setAllowDuplicateKeys(false);options.setMaxAliasesForCollections(20);options.setCodePointLimit(MAX_BYTES);var yaml=new Yaml(new SafeConstructor(options));Map<String,Object> values=new LinkedHashMap<>();if(Files.exists(file,LinkOption.NOFOLLOW_LINKS)){if(!Files.isRegularFile(file,LinkOption.NOFOLLOW_LINKS))throw new IOException("Unsafe configuration");byte[] bytes;try(var input=Files.newInputStream(file,LinkOption.NOFOLLOW_LINKS)){bytes=input.readNBytes(MAX_BYTES+1);}if(bytes.length>MAX_BYTES)throw new IOException("Configuration too large");Object loaded=yaml.load(StandardCharsets.UTF_8.newDecoder().decode(ByteBuffer.wrap(bytes)).toString());if(loaded!=null){if(!(loaded instanceof Map<?,?> map))throw new IOException("Invalid configuration root");for(var entry:map.entrySet()){if(!(entry.getKey() instanceof String key))throw new IOException("Invalid configuration key");values.put(key,entry.getValue());}}}values.put(KEY,value);byte[] bytes=yaml.dump(values).getBytes(StandardCharsets.UTF_8);if(bytes.length>MAX_BYTES)throw new IOException("Configuration too large");Path temporary=Files.createTempFile(directory,".config-",".tmp");try{try(var output=FileChannel.open(temporary,StandardOpenOption.WRITE,LinkOption.NOFOLLOW_LINKS)){var buffer=ByteBuffer.wrap(bytes);while(buffer.hasRemaining())output.write(buffer);output.force(true);}replacement.move(temporary,file);}finally{Files.deleteIfExists(temporary);}}catch(OverlappingFileLockException busy){throw new IOException("Configuration busy");}}
+    private synchronized void finished(){pending--;if(closed&&pending==0)drained.complete(null);}public CompletionStage<Void> drained(){return drained.minimalCompletionStage();}@Override public synchronized void close(){closed=true;worker.shutdown();if(pending==0)drained.complete(null);}
+}

src/main/java/games/dmg/fantasystick/persistence/PurifySettings.java

@@ -0,0 +1,166 @@
+package games.dmg.fantasystick.persistence;
+
+import games.dmg.fantasystick.ability.Purify;
+import java.io.IOException;
+import java.math.BigDecimal;
+import java.nio.ByteBuffer;
+import java.nio.channels.FileChannel;
+import java.nio.channels.OverlappingFileLockException;
+import java.nio.charset.StandardCharsets;
+import java.nio.file.Files;
+import java.nio.file.LinkOption;
+import java.nio.file.Path;
+import java.nio.file.StandardCopyOption;
+import java.nio.file.StandardOpenOption;
+import java.time.Duration;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Objects;
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.CompletionStage;
+import java.util.concurrent.Executors;
+import java.util.concurrent.RejectedExecutionException;
+import org.yaml.snakeyaml.LoaderOptions;
+import org.yaml.snakeyaml.Yaml;
+import org.yaml.snakeyaml.constructor.SafeConstructor;
+
+/** Serialized durable Purify settings; publication remains a server-thread caller decision. */
+public final class PurifySettings implements AutoCloseable {
+    private static final int MAX_BYTES = 1_048_576;
+    public static final String COOLDOWN = "purify-cooldown-seconds";
+    public static final String RANGE = "purify-range-blocks";
+    private static final List<String> KEYS = List.of(COOLDOWN, RANGE);
+    private static final Map<String, String> DEFAULTS = Map.of(COOLDOWN, "15", RANGE, "12");
+
+    @FunctionalInterface interface Replacement { void move(Path from, Path to) throws IOException; }
+    public record Update(String key, String value, Purify.Settings settings, Map<String, String> values, long sequence) {
+        public Update { values = Map.copyOf(values); }
+    }
+
+    private final Path directory;
+    private final Replacement replacement;
+    private final java.util.concurrent.ExecutorService worker = Executors.newSingleThreadExecutor(
+        task -> new Thread(task, "fantasy-purify-configuration"));
+    private volatile Map<String, String> effectiveValues;
+    private Map<String, String> persistedValues;
+    private long persistedSequence;
+    private long publishedSequence;
+    private boolean closed;
+    private int pending;
+    private final CompletableFuture<Void> drained = new CompletableFuture<>();
+
+    public PurifySettings(Path directory, Map<String, String> initial) {
+        this(directory, initial, (from, to) -> Files.move(from, to,
+            StandardCopyOption.ATOMIC_MOVE, StandardCopyOption.REPLACE_EXISTING));
+    }
+
+    PurifySettings(Path directory, Map<String, String> initial, Replacement replacement) {
+        this.directory = Objects.requireNonNull(directory).toAbsolutePath(); this.replacement = Objects.requireNonNull(replacement);
+        var copy = new LinkedHashMap<String, String>();
+        for (String key : KEYS) copy.put(key, Objects.requireNonNull(initial.get(key)));
+        parse(copy); effectiveValues = Map.copyOf(copy); persistedValues = Map.copyOf(copy);
+    }
+
+    public static List<String> keys() { return KEYS; }
+    public static String defaultValue(String key) { return DEFAULTS.get(key); }
+    public String value(String key) { return effectiveValues.get(key); }
+    public Purify.Settings settings() { return parse(effectiveValues); }
+
+    public synchronized void publish(Update update) {
+        Objects.requireNonNull(update);
+        if (update.sequence() <= publishedSequence) return;
+        parse(update.values()); effectiveValues = update.values(); publishedSequence = update.sequence();
+    }
+
+    public CompletionStage<Update> set(String key, String value) {
+        Objects.requireNonNull(key); Objects.requireNonNull(value);
+        if (!KEYS.contains(key)) return CompletableFuture.failedStage(new IllegalArgumentException("Unknown setting"));
+        String accepted = canonical(value); var preview = new LinkedHashMap<>(effectiveValues);
+        preview.put(key, accepted); parse(preview);
+        synchronized (this) {
+            if (closed) return CompletableFuture.failedStage(new IOException("Configuration store is closed"));
+            pending++;
+        }
+        try {
+            return CompletableFuture.supplyAsync(() -> {
+                try {
+                    var next = new LinkedHashMap<>(persistedValues); next.put(key, accepted);
+                    var parsed = parse(next); save(key, accepted); persistedValues = Map.copyOf(next);
+                    return new Update(key, accepted, parsed, persistedValues, ++persistedSequence);
+                } catch (IOException | RuntimeException failure) {
+                    throw new java.util.concurrent.CompletionException(failure instanceof IllegalArgumentException
+                        ? failure : new IOException("Purify configuration save refused or failed; effective settings unchanged"));
+                } finally { finished(); }
+            }, worker).minimalCompletionStage();
+        } catch (RejectedExecutionException rejected) {
+            finished(); return CompletableFuture.failedStage(new IOException("Configuration store is closed"));
+        }
+    }
+
+    private static String canonical(String raw) {
+        try { return new BigDecimal(raw).stripTrailingZeros().toPlainString(); }
+        catch (NumberFormatException invalid) { throw new IllegalArgumentException("Invalid value", invalid); }
+    }
+
+    public static Purify.Settings parse(Map<String, String> values) {
+        try { return new Purify.Settings(seconds(values.get(COOLDOWN)), finite(values.get(RANGE))); }
+        catch (ArithmeticException | NumberFormatException | NullPointerException invalid) {
+            throw new IllegalArgumentException("Purify settings must use supported numeric values", invalid);
+        }
+    }
+
+    private static Duration seconds(String value) {
+        var nanos = new BigDecimal(value).movePointRight(9).toBigIntegerExact().longValueExact();
+        return Duration.ofNanos(nanos);
+    }
+
+    private static double finite(String value) {
+        double result = new BigDecimal(value).doubleValue();
+        if (!Double.isFinite(result)) throw new IllegalArgumentException("Setting is not finite");
+        return result;
+    }
+
+    private void save(String key, String value) throws IOException {
+        Files.createDirectories(directory);
+        if (!Files.isDirectory(directory, LinkOption.NOFOLLOW_LINKS)) throw new IOException("Unsafe directory");
+        var file = directory.resolve("config.yml"); var lockFile = directory.resolve(".config.lock");
+        if (Files.exists(lockFile, LinkOption.NOFOLLOW_LINKS) && !Files.isRegularFile(lockFile, LinkOption.NOFOLLOW_LINKS)) {
+            throw new IOException("Unsafe lock");
+        }
+        try (var channel = FileChannel.open(lockFile, StandardOpenOption.CREATE, StandardOpenOption.WRITE,
+                LinkOption.NOFOLLOW_LINKS); var lock = channel.tryLock()) {
+            if (lock == null) throw new IOException("Configuration busy");
+            var options = new LoaderOptions(); options.setAllowDuplicateKeys(false);
+            options.setMaxAliasesForCollections(20); options.setCodePointLimit(MAX_BYTES);
+            var yaml = new Yaml(new SafeConstructor(options)); Map<String, Object> document = new LinkedHashMap<>();
+            if (Files.exists(file, LinkOption.NOFOLLOW_LINKS)) {
+                if (!Files.isRegularFile(file, LinkOption.NOFOLLOW_LINKS)) throw new IOException("Unsafe configuration");
+                byte[] bytes;
+                try (var input = Files.newInputStream(file, LinkOption.NOFOLLOW_LINKS)) { bytes = input.readNBytes(MAX_BYTES + 1); }
+                if (bytes.length > MAX_BYTES) throw new IOException("Configuration too large");
+                Object loaded = yaml.load(StandardCharsets.UTF_8.newDecoder().decode(ByteBuffer.wrap(bytes)).toString());
+                if (loaded != null) {
+                    if (!(loaded instanceof Map<?, ?> map)) throw new IOException("Invalid configuration root");
+                    for (var entry : map.entrySet()) {
+                        if (!(entry.getKey() instanceof String savedKey)) throw new IOException("Invalid configuration key");
+                        document.put(savedKey, entry.getValue());
+                    }
+                }
+            }
+            document.put(key, value); byte[] bytes = yaml.dump(document).getBytes(StandardCharsets.UTF_8);
+            if (bytes.length > MAX_BYTES) throw new IOException("Configuration too large");
+            Path temporary = Files.createTempFile(directory, ".config-", ".tmp");
+            try {
+                try (var output = FileChannel.open(temporary, StandardOpenOption.WRITE, LinkOption.NOFOLLOW_LINKS)) {
+                    var buffer = ByteBuffer.wrap(bytes); while (buffer.hasRemaining()) output.write(buffer); output.force(true);
+                }
+                replacement.move(temporary, file);
+            } finally { Files.deleteIfExists(temporary); }
+        } catch (OverlappingFileLockException busy) { throw new IOException("Configuration busy"); }
+    }
+
+    private synchronized void finished() { pending--; if (closed && pending == 0) drained.complete(null); }
+    public CompletionStage<Void> drained() { return drained.minimalCompletionStage(); }
+    @Override public synchronized void close() { closed = true; worker.shutdown(); if (pending == 0) drained.complete(null); }
+}

src/main/java/games/dmg/fantasystick/persistence/RallyingCrySettings.java

@@ -0,0 +1,172 @@
+package games.dmg.fantasystick.persistence;
+
+import games.dmg.fantasystick.ability.RallyingCry;
+import java.io.IOException;
+import java.math.BigDecimal;
+import java.nio.ByteBuffer;
+import java.nio.channels.FileChannel;
+import java.nio.channels.OverlappingFileLockException;
+import java.nio.charset.StandardCharsets;
+import java.nio.file.Files;
+import java.nio.file.LinkOption;
+import java.nio.file.Path;
+import java.nio.file.StandardCopyOption;
+import java.nio.file.StandardOpenOption;
+import java.time.Duration;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Objects;
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.CompletionStage;
+import java.util.concurrent.Executors;
+import java.util.concurrent.RejectedExecutionException;
+import org.yaml.snakeyaml.LoaderOptions;
+import org.yaml.snakeyaml.Yaml;
+import org.yaml.snakeyaml.constructor.SafeConstructor;
+
+/** Serialized durable Rallying Cry settings; publication remains a server-thread caller decision. */
+public final class RallyingCrySettings implements AutoCloseable {
+    private static final int MAX_BYTES = 1_048_576;
+    public static final String COOLDOWN = "rallying-cry-cooldown-seconds";
+    public static final String RADIUS = "rallying-cry-radius-blocks";
+    public static final String DURATION = "rallying-cry-duration-seconds";
+    public static final String SPEED = "rallying-cry-speed-amplifier";
+    public static final String BONUS = "rallying-cry-damage-bonus-percent";
+    private static final List<String> KEYS = List.of(COOLDOWN, BONUS, DURATION, RADIUS, SPEED);
+    private static final Map<String, String> DEFAULTS = Map.of(
+        COOLDOWN, "25", RADIUS, "8", DURATION, "6", SPEED, "0", BONUS, "20");
+
+    @FunctionalInterface interface Replacement { void move(Path from, Path to) throws IOException; }
+    public record Update(String key, String value, RallyingCry.Settings settings, Map<String, String> values, long sequence) {
+        public Update { values = Map.copyOf(values); }
+    }
+
+    private final Path directory;
+    private final Replacement replacement;
+    private final java.util.concurrent.ExecutorService worker = Executors.newSingleThreadExecutor(
+        task -> new Thread(task, "fantasy-rallying-cry-configuration"));
+    private volatile Map<String, String> effectiveValues;
+    private Map<String, String> persistedValues;
+    private long persistedSequence;
+    private long publishedSequence;
+    private boolean closed;
+    private int pending;
+    private final CompletableFuture<Void> drained = new CompletableFuture<>();
+
+    public RallyingCrySettings(Path directory, Map<String, String> initial) {
+        this(directory, initial, (from, to) -> Files.move(from, to,
+            StandardCopyOption.ATOMIC_MOVE, StandardCopyOption.REPLACE_EXISTING));
+    }
+
+    RallyingCrySettings(Path directory, Map<String, String> initial, Replacement replacement) {
+        this.directory = Objects.requireNonNull(directory).toAbsolutePath(); this.replacement = Objects.requireNonNull(replacement);
+        var copy = new LinkedHashMap<String, String>();
+        for (String key : KEYS) copy.put(key, Objects.requireNonNull(initial.get(key)));
+        parse(copy); effectiveValues = Map.copyOf(copy); persistedValues = Map.copyOf(copy);
+    }
+
+    public static List<String> keys() { return KEYS; }
+    public static String defaultValue(String key) { return DEFAULTS.get(key); }
+    public String value(String key) { return effectiveValues.get(key); }
+    public RallyingCry.Settings settings() { return parse(effectiveValues); }
+
+    public synchronized void publish(Update update) {
+        Objects.requireNonNull(update);
+        if (update.sequence() <= publishedSequence) return;
+        parse(update.values()); effectiveValues = update.values(); publishedSequence = update.sequence();
+    }
+
+    public CompletionStage<Update> set(String key, String value) {
+        Objects.requireNonNull(key); Objects.requireNonNull(value);
+        if (!KEYS.contains(key)) return CompletableFuture.failedStage(new IllegalArgumentException("Unknown setting"));
+        String accepted = canonical(value); var preview = new LinkedHashMap<>(effectiveValues);
+        preview.put(key, accepted); parse(preview);
+        synchronized (this) {
+            if (closed) return CompletableFuture.failedStage(new IOException("Configuration store is closed"));
+            pending++;
+        }
+        try {
+            return CompletableFuture.supplyAsync(() -> {
+                try {
+                    var next = new LinkedHashMap<>(persistedValues); next.put(key, accepted);
+                    var parsed = parse(next); save(key, accepted); persistedValues = Map.copyOf(next);
+                    return new Update(key, accepted, parsed, persistedValues, ++persistedSequence);
+                } catch (IOException | RuntimeException failure) {
+                    throw new java.util.concurrent.CompletionException(failure instanceof IllegalArgumentException
+                        ? failure : new IOException("Rallying Cry configuration save refused or failed; effective settings unchanged"));
+                } finally { finished(); }
+            }, worker).minimalCompletionStage();
+        } catch (RejectedExecutionException rejected) {
+            finished(); return CompletableFuture.failedStage(new IOException("Configuration store is closed"));
+        }
+    }
+
+    private static String canonical(String raw) {
+        try { return new BigDecimal(raw).stripTrailingZeros().toPlainString(); }
+        catch (NumberFormatException invalid) { throw new IllegalArgumentException("Invalid value", invalid); }
+    }
+
+    public static RallyingCry.Settings parse(Map<String, String> values) {
+        try { return new RallyingCry.Settings(seconds(values.get(COOLDOWN)), finite(values.get(RADIUS)),
+            seconds(values.get(DURATION)), new BigDecimal(values.get(SPEED)).intValueExact(),
+            new BigDecimal(values.get(BONUS))); }
+        catch (ArithmeticException | NumberFormatException | NullPointerException invalid) {
+            throw new IllegalArgumentException("Rallying Cry settings must use supported numeric values", invalid);
+        }
+    }
+
+    private static Duration seconds(String value) {
+        var nanos = new BigDecimal(value).movePointRight(9).toBigIntegerExact().longValueExact();
+        return Duration.ofNanos(nanos);
+    }
+
+    private static double finite(String value) {
+        double result = new BigDecimal(value).doubleValue();
+        if (!Double.isFinite(result)) throw new IllegalArgumentException("Setting is not finite");
+        return result;
+    }
+
+    private void save(String key, String value) throws IOException {
+        Files.createDirectories(directory);
+        if (!Files.isDirectory(directory, LinkOption.NOFOLLOW_LINKS)) throw new IOException("Unsafe directory");
+        var file = directory.resolve("config.yml"); var lockFile = directory.resolve(".config.lock");
+        if (Files.exists(lockFile, LinkOption.NOFOLLOW_LINKS) && !Files.isRegularFile(lockFile, LinkOption.NOFOLLOW_LINKS)) {
+            throw new IOException("Unsafe lock");
+        }
+        try (var channel = FileChannel.open(lockFile, StandardOpenOption.CREATE, StandardOpenOption.WRITE,
+                LinkOption.NOFOLLOW_LINKS); var lock = channel.tryLock()) {
+            if (lock == null) throw new IOException("Configuration busy");
+            var options = new LoaderOptions(); options.setAllowDuplicateKeys(false);
+            options.setMaxAliasesForCollections(20); options.setCodePointLimit(MAX_BYTES);
+            var yaml = new Yaml(new SafeConstructor(options)); Map<String, Object> document = new LinkedHashMap<>();
+            if (Files.exists(file, LinkOption.NOFOLLOW_LINKS)) {
+                if (!Files.isRegularFile(file, LinkOption.NOFOLLOW_LINKS)) throw new IOException("Unsafe configuration");
+                byte[] bytes;
+                try (var input = Files.newInputStream(file, LinkOption.NOFOLLOW_LINKS)) { bytes = input.readNBytes(MAX_BYTES + 1); }
+                if (bytes.length > MAX_BYTES) throw new IOException("Configuration too large");
+                Object loaded = yaml.load(StandardCharsets.UTF_8.newDecoder().decode(ByteBuffer.wrap(bytes)).toString());
+                if (loaded != null) {
+                    if (!(loaded instanceof Map<?, ?> map)) throw new IOException("Invalid configuration root");
+                    for (var entry : map.entrySet()) {
+                        if (!(entry.getKey() instanceof String savedKey)) throw new IOException("Invalid configuration key");
+                        document.put(savedKey, entry.getValue());
+                    }
+                }
+            }
+            document.put(key, value); byte[] bytes = yaml.dump(document).getBytes(StandardCharsets.UTF_8);
+            if (bytes.length > MAX_BYTES) throw new IOException("Configuration too large");
+            Path temporary = Files.createTempFile(directory, ".config-", ".tmp");
+            try {
+                try (var output = FileChannel.open(temporary, StandardOpenOption.WRITE, LinkOption.NOFOLLOW_LINKS)) {
+                    var buffer = ByteBuffer.wrap(bytes); while (buffer.hasRemaining()) output.write(buffer); output.force(true);
+                }
+                replacement.move(temporary, file);
+            } finally { Files.deleteIfExists(temporary); }
+        } catch (OverlappingFileLockException busy) { throw new IOException("Configuration busy"); }
+    }
+
+    private synchronized void finished() { pending--; if (closed && pending == 0) drained.complete(null); }
+    public CompletionStage<Void> drained() { return drained.minimalCompletionStage(); }
+    @Override public synchronized void close() { closed = true; worker.shutdown(); if (pending == 0) drained.complete(null); }
+}

src/main/java/games/dmg/fantasystick/persistence/RevivalStore.java

@@ -29,10 +29,16 @@ import org.yaml.snakeyaml.constructor.SafeConstructor;
 public final class RevivalStore implements AutoCloseable {
     private static final int MAX_FILE_BYTES = 32_768;
     private static final int MAX_FILES = 4096;
-    private static final Set<String> KEYS = Set.of("schema-version", "reservation-id", "caster-character-id",
+    private static final Set<String> KEYS_V1 = Set.of("schema-version", "reservation-id", "caster-character-id",
         "target-player-id", "character-id", "death-id", "created-at", "source-slot", "source-amount", "destination-slot");
+    private static final Set<String> KEYS_V2 = java.util.stream.Stream.concat(KEYS_V1.stream(), java.util.stream.Stream.of("administrative"))
+        .collect(java.util.stream.Collectors.toUnmodifiableSet());
     public record Reservation(UUID id, UUID casterCharacter, UUID targetPlayer, UUID character, UUID death,
-                              Instant createdAt, int sourceSlot, int sourceAmount, int destinationSlot) {
+                              Instant createdAt, int sourceSlot, int sourceAmount, int destinationSlot, boolean administrative) {
+        public Reservation(UUID id, UUID casterCharacter, UUID targetPlayer, UUID character, UUID death,
+                           Instant createdAt, int sourceSlot, int sourceAmount, int destinationSlot) {
+            this(id, casterCharacter, targetPlayer, character, death, createdAt, sourceSlot, sourceAmount, destinationSlot, false);
+        }
         public Reservation {
             Objects.requireNonNull(id); Objects.requireNonNull(casterCharacter); Objects.requireNonNull(targetPlayer);
             Objects.requireNonNull(character); Objects.requireNonNull(death); Objects.requireNonNull(createdAt);
@@ -121,13 +127,13 @@ public final class RevivalStore implements AutoCloseable {
             var options = new LoaderOptions(); options.setAllowDuplicateKeys(false); options.setMaxAliasesForCollections(0);
             decoded = new Yaml(new SafeConstructor(options)).load(Files.readString(file, StandardCharsets.UTF_8));
         } catch (RuntimeException invalid) { throw new IOException("Invalid revival reservation", invalid); }
-        if (!(decoded instanceof Map<?, ?> raw) || !raw.keySet().equals(KEYS)) throw new IOException("Invalid revival reservation keys");
+        if (!(decoded instanceof Map<?, ?> raw) || !(raw.keySet().equals(KEYS_V1) || raw.keySet().equals(KEYS_V2))) throw new IOException("Invalid revival reservation keys");
         try {
-            if (!"1".equals(text(raw, "schema-version"))) throw new IllegalArgumentException("schema");
+            String schema=text(raw,"schema-version");if(!(schema.equals("1")&&raw.keySet().equals(KEYS_V1)||schema.equals("2")&&raw.keySet().equals(KEYS_V2)))throw new IllegalArgumentException("schema");
             var value = new Reservation(uuid(raw, "reservation-id"), uuid(raw, "caster-character-id"),
                 uuid(raw, "target-player-id"), uuid(raw, "character-id"), uuid(raw, "death-id"),
                 Instant.parse(text(raw, "created-at")), integer(raw, "source-slot"), integer(raw, "source-amount"),
-                integer(raw, "destination-slot"));
+                integer(raw, "destination-slot"), schema.equals("2") && bool(raw,"administrative"));
             if (!file.getFileName().toString().equals(value.character() + ".yml")) throw new IllegalArgumentException("identity");
             return Optional.of(value);
         } catch (RuntimeException invalid) { throw new IOException("Invalid revival reservation", invalid); }
@@ -135,11 +141,12 @@ public final class RevivalStore implements AutoCloseable {
 
     private static String encode(Reservation value) {
         var map = new LinkedHashMap<String, Object>();
-        map.put("schema-version", "1"); map.put("reservation-id", value.id().toString());
+        map.put("schema-version", "2"); map.put("reservation-id", value.id().toString());
         map.put("caster-character-id", value.casterCharacter().toString()); map.put("target-player-id", value.targetPlayer().toString());
         map.put("character-id", value.character().toString()); map.put("death-id", value.death().toString());
         map.put("created-at", value.createdAt().toString()); map.put("source-slot", Integer.toString(value.sourceSlot()));
         map.put("source-amount", Integer.toString(value.sourceAmount())); map.put("destination-slot", Integer.toString(value.destinationSlot()));
+        map.put("administrative", Boolean.toString(value.administrative()));
         return new Yaml().dump(map);
     }
 
@@ -148,6 +155,7 @@ public final class RevivalStore implements AutoCloseable {
     }
     private static UUID uuid(Map<?, ?> map, String key) { var value = UUID.fromString(text(map, key)); if (!value.toString().equals(text(map, key))) throw new IllegalArgumentException(key); return value; }
     private static int integer(Map<?, ?> map, String key) { return Integer.parseInt(text(map, key)); }
+    private static boolean bool(Map<?,?> map,String key){String value=text(map,key);if(!value.equals("true")&&!value.equals("false"))throw new IllegalArgumentException(key);return Boolean.parseBoolean(value);}
 
     @FunctionalInterface private interface Work<T> { T run() throws IOException; }
     private <T> CompletableFuture<T> submit(Work<T> work) {

src/main/java/games/dmg/fantasystick/persistence/RoleplaySettings.java

@@ -0,0 +1,152 @@
+package games.dmg.fantasystick.persistence;
+
+import java.io.IOException;
+import java.nio.ByteBuffer;
+import java.nio.channels.FileChannel;
+import java.nio.channels.OverlappingFileLockException;
+import java.nio.charset.StandardCharsets;
+import java.nio.file.Files;
+import java.nio.file.LinkOption;
+import java.nio.file.Path;
+import java.nio.file.StandardCopyOption;
+import java.nio.file.StandardOpenOption;
+import java.util.LinkedHashMap;
+import java.util.Map;
+import java.util.Objects;
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.CompletionStage;
+import java.util.concurrent.Executors;
+import java.util.concurrent.RejectedExecutionException;
+import org.yaml.snakeyaml.LoaderOptions;
+import org.yaml.snakeyaml.Yaml;
+import org.yaml.snakeyaml.constructor.SafeConstructor;
+
+/** Durable save-before-publish policy for roleplay availability and coordinated exits. */
+public final class RoleplaySettings implements AutoCloseable {
+    public static final String KEY = "roleplay-disabled";
+    private static final int MAX_BYTES = 1_048_576;
+    @FunctionalInterface interface Replacement { void move(Path from, Path to) throws IOException; }
+    public record Update(boolean disabled, long sequence) { }
+    private final Path directory;
+    private final Replacement replacement;
+    private final java.util.concurrent.ExecutorService worker = Executors.newSingleThreadExecutor(
+        task -> new Thread(task, "fantasy-roleplay-configuration"));
+    private volatile boolean disabled;
+    private long persistedSequence;
+    private long publishedSequence;
+    private boolean closed;
+    private int pending;
+    private final CompletableFuture<Void> drained = new CompletableFuture<>();
+
+    public RoleplaySettings(Path directory, boolean initial) {
+        this(directory, initial, (from, to) -> Files.move(from, to,
+            StandardCopyOption.ATOMIC_MOVE, StandardCopyOption.REPLACE_EXISTING));
+    }
+
+    RoleplaySettings(Path directory, boolean initial, Replacement replacement) {
+        this.directory = Objects.requireNonNull(directory).toAbsolutePath();
+        this.replacement = Objects.requireNonNull(replacement);
+        disabled = initial;
+    }
+
+    public static boolean parse(Object value) {
+        if (value == null) return false;
+        if (value instanceof Boolean parsed) return parsed;
+        throw new IllegalArgumentException(KEY + " must be true or false");
+    }
+
+    public boolean disabled() { return disabled; }
+    public String value() { return Boolean.toString(disabled); }
+
+    public CompletionStage<Update> set(String raw) {
+        if (!"true".equals(raw) && !"false".equals(raw)) {
+            throw new IllegalArgumentException(KEY + " must be true or false");
+        }
+        boolean accepted = Boolean.parseBoolean(raw);
+        synchronized (this) {
+            if (closed) return CompletableFuture.failedStage(new IOException("Configuration store is closed"));
+            pending++;
+        }
+        try {
+            return CompletableFuture.supplyAsync(() -> {
+                try {
+                    save(accepted);
+                    return new Update(accepted, ++persistedSequence);
+                } catch (IOException | RuntimeException failure) {
+                    throw new java.util.concurrent.CompletionException(new IOException(
+                        "Roleplay configuration save refused or failed; effective setting unchanged"));
+                } finally { finished(); }
+            }, worker).minimalCompletionStage();
+        } catch (RejectedExecutionException rejected) {
+            finished();
+            return CompletableFuture.failedStage(new IOException("Configuration store is closed"));
+        }
+    }
+
+    public synchronized boolean publish(Update update) {
+        if (update.sequence() <= publishedSequence) return false;
+        disabled = update.disabled();
+        publishedSequence = update.sequence();
+        return true;
+    }
+
+    private void save(boolean value) throws IOException {
+        Files.createDirectories(directory);
+        if (!Files.isDirectory(directory, LinkOption.NOFOLLOW_LINKS)) throw new IOException("Unsafe directory");
+        var file = directory.resolve("config.yml");
+        var lockFile = directory.resolve(".config.lock");
+        if (Files.exists(lockFile, LinkOption.NOFOLLOW_LINKS)
+                && !Files.isRegularFile(lockFile, LinkOption.NOFOLLOW_LINKS)) throw new IOException("Unsafe lock");
+        try (var channel = FileChannel.open(lockFile, StandardOpenOption.CREATE, StandardOpenOption.WRITE, LinkOption.NOFOLLOW_LINKS);
+             var lock = channel.tryLock()) {
+            if (lock == null) throw new IOException("Configuration busy");
+            var options = new LoaderOptions();
+            options.setAllowDuplicateKeys(false);
+            options.setMaxAliasesForCollections(20);
+            options.setCodePointLimit(MAX_BYTES);
+            var yaml = new Yaml(new SafeConstructor(options));
+            Map<String, Object> values = new LinkedHashMap<>();
+            if (Files.exists(file, LinkOption.NOFOLLOW_LINKS)) {
+                if (!Files.isRegularFile(file, LinkOption.NOFOLLOW_LINKS)) throw new IOException("Unsafe configuration");
+                byte[] bytes;
+                try (var input = Files.newInputStream(file, LinkOption.NOFOLLOW_LINKS)) {
+                    bytes = input.readNBytes(MAX_BYTES + 1);
+                }
+                if (bytes.length > MAX_BYTES) throw new IOException("Configuration too large");
+                Object loaded = yaml.load(StandardCharsets.UTF_8.newDecoder().decode(ByteBuffer.wrap(bytes)).toString());
+                if (loaded != null) {
+                    if (!(loaded instanceof Map<?, ?> map)) throw new IOException("Invalid configuration root");
+                    for (var entry : map.entrySet()) {
+                        if (!(entry.getKey() instanceof String key)) throw new IOException("Invalid configuration key");
+                        values.put(key, entry.getValue());
+                    }
+                }
+            }
+            values.put(KEY, value);
+            byte[] bytes = yaml.dump(values).getBytes(StandardCharsets.UTF_8);
+            if (bytes.length > MAX_BYTES) throw new IOException("Configuration too large");
+            Path temporary = Files.createTempFile(directory, ".config-", ".tmp");
+            try {
+                try (var output = FileChannel.open(temporary, StandardOpenOption.WRITE, LinkOption.NOFOLLOW_LINKS)) {
+                    var buffer = ByteBuffer.wrap(bytes);
+                    while (buffer.hasRemaining()) output.write(buffer);
+                    output.force(true);
+                }
+                replacement.move(temporary, file);
+            } finally { Files.deleteIfExists(temporary); }
+        } catch (OverlappingFileLockException busy) { throw new IOException("Configuration busy"); }
+    }
+
+    private synchronized void finished() {
+        pending--;
+        if (closed && pending == 0) drained.complete(null);
+    }
+
+    public CompletionStage<Void> drained() { return drained.minimalCompletionStage(); }
+
+    @Override public synchronized void close() {
+        closed = true;
+        worker.shutdown();
+        if (pending == 0) drained.complete(null);
+    }
+}

src/main/java/games/dmg/fantasystick/persistence/SecondWindSettings.java

@@ -0,0 +1,187 @@
+package games.dmg.fantasystick.persistence;
+
+import games.dmg.fantasystick.ability.SecondWind;
+import java.io.IOException;
+import java.nio.ByteBuffer;
+import java.nio.channels.FileChannel;
+import java.nio.channels.OverlappingFileLockException;
+import java.nio.charset.StandardCharsets;
+import java.nio.file.Files;
+import java.nio.file.LinkOption;
+import java.nio.file.Path;
+import java.nio.file.StandardCopyOption;
+import java.nio.file.StandardOpenOption;
+import java.time.Duration;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Objects;
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.CompletionStage;
+import java.util.concurrent.Executors;
+import java.util.concurrent.RejectedExecutionException;
+import org.yaml.snakeyaml.LoaderOptions;
+import org.yaml.snakeyaml.Yaml;
+import org.yaml.snakeyaml.constructor.SafeConstructor;
+
+/** Serialized durable SecondWind settings; publication remains a server-thread caller decision. */
+public final class SecondWindSettings implements AutoCloseable {
+    private static final int MAX_BYTES = 1_048_576;
+    public static final String BASE_HEALING = "second-wind-base-healing";
+    public static final String COOLDOWN = "second-wind-cooldown-seconds";
+    private static final List<String> KEYS = List.of(BASE_HEALING, COOLDOWN);
+    private static final Map<String, String> DEFAULTS = Map.of(BASE_HEALING, "6", COOLDOWN, "15");
+
+    @FunctionalInterface interface Replacement { void move(Path from, Path to) throws IOException; }
+    public record Update(String key, String value, SecondWind.Settings settings,
+                         Map<String, String> values, long sequence) {
+        public Update { values = Map.copyOf(values); }
+    }
+
+    private final Path directory;
+    private final Replacement replacement;
+    private final java.util.concurrent.ExecutorService worker = Executors.newSingleThreadExecutor(
+        task -> new Thread(task, "fantasy-second-wind-configuration"));
+    private volatile Map<String, String> effectiveValues;
+    private Map<String, String> persistedValues;
+    private long persistedSequence;
+    private long publishedSequence;
+    private boolean closed;
+    private int pending;
+    private final CompletableFuture<Void> drained = new CompletableFuture<>();
+
+    public SecondWindSettings(Path directory, Map<String, String> initial) {
+        this(directory, initial, (from, to) -> Files.move(from, to,
+            StandardCopyOption.ATOMIC_MOVE, StandardCopyOption.REPLACE_EXISTING));
+    }
+
+    SecondWindSettings(Path directory, Map<String, String> initial, Replacement replacement) {
+        this.directory = Objects.requireNonNull(directory).toAbsolutePath();
+        this.replacement = Objects.requireNonNull(replacement);
+        var copy = new LinkedHashMap<String, String>();
+        for (String key : KEYS) copy.put(key, Objects.requireNonNull(initial.get(key)));
+        parse(copy);
+        effectiveValues = Map.copyOf(copy); persistedValues = Map.copyOf(copy);
+    }
+
+    public static List<String> keys() { return KEYS; }
+    public static String defaultValue(String key) { return DEFAULTS.get(key); }
+    public String value(String key) { return effectiveValues.get(key); }
+    public SecondWind.Settings settings() { return parse(effectiveValues); }
+
+    /** Publish only after the caller returns the durable acknowledgment to the server thread. */
+    public synchronized void publish(Update update) {
+        Objects.requireNonNull(update);
+        if (update.sequence() <= publishedSequence) return;
+        parse(update.values());
+        effectiveValues = update.values(); publishedSequence = update.sequence();
+    }
+
+    public CompletionStage<Update> set(String key, String value) {
+        Objects.requireNonNull(key); Objects.requireNonNull(value);
+        if (!KEYS.contains(key)) return CompletableFuture.failedStage(new IllegalArgumentException("Unknown setting"));
+        String accepted = canonical(key, value);
+        var preview = new LinkedHashMap<>(effectiveValues); preview.put(key, accepted);
+        parse(preview); // Fail malformed/out-of-range command input before queueing accepted persistence.
+        synchronized (this) {
+            if (closed) return CompletableFuture.failedStage(new IOException("Configuration store is closed"));
+            pending++;
+        }
+        try {
+            return CompletableFuture.supplyAsync(() -> {
+                try {
+                    var next = new LinkedHashMap<>(persistedValues);
+                    next.put(key, accepted);
+                    var parsed = parse(next);
+                    save(key, accepted);
+                    persistedValues = Map.copyOf(next);
+                    return new Update(key, accepted, parsed, persistedValues, ++persistedSequence);
+                } catch (IOException | RuntimeException failure) {
+                    throw new java.util.concurrent.CompletionException(failure instanceof IllegalArgumentException
+                        ? failure : new IOException("SecondWind configuration save refused or failed; effective settings unchanged"));
+                } finally { finished(); }
+            }, worker).minimalCompletionStage();
+        } catch (RejectedExecutionException rejected) {
+            finished();
+            return CompletableFuture.failedStage(new IOException("Configuration store is closed"));
+        }
+    }
+
+    private static String canonical(String key, String raw) {
+        try {
+            if (key.equals(BASE_HEALING)) return new java.math.BigInteger(raw).toString();
+            return new java.math.BigDecimal(raw).stripTrailingZeros().toPlainString();
+        } catch (NumberFormatException invalid) { throw new IllegalArgumentException("Invalid value", invalid); }
+    }
+
+    public static SecondWind.Settings parse(Map<String, String> values) {
+        try {
+            var base = new java.math.BigInteger(values.get(BASE_HEALING));
+            var cooldown = seconds(values.get(COOLDOWN));
+            return new SecondWind.Settings(base, cooldown);
+        } catch (ArithmeticException | NumberFormatException | NullPointerException invalid) {
+            throw new IllegalArgumentException("SecondWind settings must use supported numeric values", invalid);
+        }
+    }
+
+    private static Duration seconds(String value) {
+        var nanos = new java.math.BigDecimal(value).movePointRight(9).toBigIntegerExact().longValueExact();
+        return Duration.ofNanos(nanos);
+    }
+
+    private static double finite(String value) {
+        double result = new java.math.BigDecimal(value).doubleValue();
+        if (!Double.isFinite(result)) throw new IllegalArgumentException("Setting is not finite");
+        return result;
+    }
+
+    private void save(String key, String value) throws IOException {
+        Files.createDirectories(directory);
+        if (!Files.isDirectory(directory, LinkOption.NOFOLLOW_LINKS)) throw new IOException("Unsafe directory");
+        var file = directory.resolve("config.yml");
+        var lockFile = directory.resolve(".config.lock");
+        if (Files.exists(lockFile, LinkOption.NOFOLLOW_LINKS)
+                && !Files.isRegularFile(lockFile, LinkOption.NOFOLLOW_LINKS)) throw new IOException("Unsafe lock");
+        try (var channel = FileChannel.open(lockFile, StandardOpenOption.CREATE, StandardOpenOption.WRITE,
+                LinkOption.NOFOLLOW_LINKS); var lock = channel.tryLock()) {
+            if (lock == null) throw new IOException("Configuration busy");
+            var options = new LoaderOptions(); options.setAllowDuplicateKeys(false);
+            options.setMaxAliasesForCollections(20); options.setCodePointLimit(MAX_BYTES);
+            var yaml = new Yaml(new SafeConstructor(options));
+            Map<String, Object> document = new LinkedHashMap<>();
+            if (Files.exists(file, LinkOption.NOFOLLOW_LINKS)) {
+                if (!Files.isRegularFile(file, LinkOption.NOFOLLOW_LINKS)) throw new IOException("Unsafe configuration");
+                byte[] bytes;
+                try (var input = Files.newInputStream(file, LinkOption.NOFOLLOW_LINKS)) { bytes = input.readNBytes(MAX_BYTES + 1); }
+                if (bytes.length > MAX_BYTES) throw new IOException("Configuration too large");
+                Object loaded = yaml.load(StandardCharsets.UTF_8.newDecoder().decode(ByteBuffer.wrap(bytes)).toString());
+                if (loaded != null) {
+                    if (!(loaded instanceof Map<?, ?> map)) throw new IOException("Invalid configuration root");
+                    for (var entry : map.entrySet()) {
+                        if (!(entry.getKey() instanceof String savedKey)) throw new IOException("Invalid configuration key");
+                        document.put(savedKey, entry.getValue());
+                    }
+                }
+            }
+            document.put(key, value);
+            byte[] bytes = yaml.dump(document).getBytes(StandardCharsets.UTF_8);
+            if (bytes.length > MAX_BYTES) throw new IOException("Configuration too large");
+            Path temporary = Files.createTempFile(directory, ".config-", ".tmp");
+            try {
+                try (var output = FileChannel.open(temporary, StandardOpenOption.WRITE, LinkOption.NOFOLLOW_LINKS)) {
+                    var buffer = ByteBuffer.wrap(bytes); while (buffer.hasRemaining()) output.write(buffer); output.force(true);
+                }
+                replacement.move(temporary, file);
+            } finally { Files.deleteIfExists(temporary); }
+        } catch (OverlappingFileLockException busy) { throw new IOException("Configuration busy"); }
+    }
+
+    private synchronized void finished() {
+        pending--;
+        if (closed && pending == 0) drained.complete(null);
+    }
+    public CompletionStage<Void> drained() { return drained.minimalCompletionStage(); }
+    @Override public synchronized void close() {
+        closed = true; worker.shutdown(); if (pending == 0) drained.complete(null);
+    }
+}

src/main/java/games/dmg/fantasystick/persistence/SheetResourcePackSettings.java

@@ -0,0 +1,209 @@
+package games.dmg.fantasystick.persistence;
+
+import java.io.IOException;
+import java.net.URI;
+import java.nio.ByteBuffer;
+import java.nio.channels.FileChannel;
+import java.nio.channels.OverlappingFileLockException;
+import java.nio.charset.StandardCharsets;
+import java.nio.file.Files;
+import java.nio.file.LinkOption;
+import java.nio.file.Path;
+import java.nio.file.StandardCopyOption;
+import java.nio.file.StandardOpenOption;
+import java.util.LinkedHashMap;
+import java.util.Map;
+import java.util.Objects;
+import java.util.Properties;
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.CompletionStage;
+import java.util.concurrent.Executors;
+import java.util.concurrent.RejectedExecutionException;
+import org.yaml.snakeyaml.LoaderOptions;
+import org.yaml.snakeyaml.Yaml;
+import org.yaml.snakeyaml.constructor.SafeConstructor;
+
+/** Durable paired resource-pack overrides; each publication carries the latest complete saved snapshot. */
+public final class SheetResourcePackSettings implements AutoCloseable {
+    public static final String URL_KEY = "sheet-resource-pack-url";
+    public static final String SHA1_KEY = "sheet-resource-pack-sha1";
+    private static final int MAX_BYTES = 1_048_576;
+    @FunctionalInterface interface Replacement { void move(Path from, Path to) throws IOException; }
+    public record Defaults(String url, String sha1) {
+        public Defaults { url = effectiveUrl(url, new DefaultsMarker()); sha1 = normalizeHash(sha1, false); }
+    }
+    private static final class DefaultsMarker { }
+    public record Snapshot(String configuredUrl, String configuredSha1, String url, String sha1) { }
+    public record Update(Snapshot snapshot, long sequence) { }
+    private final Path directory;
+    private final Defaults defaults;
+    private final Replacement replacement;
+    private final java.util.concurrent.ExecutorService worker;
+    private volatile Snapshot effective;
+    private String persistedUrl;
+    private String persistedSha1;
+    private long persistedSequence;
+    private long publishedSequence;
+    private boolean closed;
+    private int pending;
+    private final CompletableFuture<Void> drained = new CompletableFuture<>();
+
+    public SheetResourcePackSettings(Path directory, Object configuredUrl, Object configuredSha1, Defaults defaults) {
+        this(directory, raw(configuredUrl, URL_KEY), raw(configuredSha1, SHA1_KEY), defaults,
+            (from, to) -> Files.move(from, to, StandardCopyOption.ATOMIC_MOVE, StandardCopyOption.REPLACE_EXISTING));
+    }
+
+    SheetResourcePackSettings(Path directory, String configuredUrl, String configuredSha1, Defaults defaults, Replacement replacement) {
+        this.directory = Objects.requireNonNull(directory).toAbsolutePath();
+        this.defaults = Objects.requireNonNull(defaults);
+        this.replacement = Objects.requireNonNull(replacement);
+        effective = snapshot(configuredUrl, configuredSha1);
+        worker = Executors.newSingleThreadExecutor(task -> new Thread(task, "fantasy-sheet-resource-pack-configuration"));
+        persistedUrl = configuredUrl;
+        persistedSha1 = configuredSha1;
+    }
+
+    public static Defaults packagedDefaults() {
+        try (var input = SheetResourcePackSettings.class.getResourceAsStream("/sheet-resource-pack.properties")) {
+            if (input == null) throw new IOException("Missing packaged sheet resource-pack metadata");
+            var values = new Properties(); values.load(input);
+            return new Defaults(values.getProperty("url"), values.getProperty("sha1"));
+        } catch (IOException | IllegalArgumentException failure) {
+            throw new IllegalStateException("Invalid packaged sheet resource-pack metadata", failure);
+        }
+    }
+
+    private static String raw(Object value, String key) {
+        if (value == null) return "";
+        if (value instanceof String text) return text;
+        throw new IllegalArgumentException(key + " must be a string");
+    }
+
+    public static String effectiveUrl(String configured, Defaults defaults) {
+        Objects.requireNonNull(defaults);
+        return configured == null || configured.isEmpty() ? defaults.url() : validateUrl(configured);
+    }
+
+    private static String effectiveUrl(String value, DefaultsMarker ignored) { return validateUrl(value); }
+
+    private static String validateUrl(String value) {
+        if (value == null || value.length() > 2048 || value.chars().anyMatch(Character::isWhitespace)) {
+            throw new IllegalArgumentException(URL_KEY + " must be a supported HTTPS URL");
+        }
+        try {
+            var uri = URI.create(value);
+            if (!"https".equals(uri.getScheme()) || uri.getHost() == null || uri.getHost().isBlank()
+                    || uri.getRawUserInfo() != null || uri.getRawFragment() != null
+                    || uri.getRawPath() == null || uri.getRawPath().isBlank()) {
+                throw new IllegalArgumentException(URL_KEY + " must be an absolute HTTPS asset URL without credentials or fragment");
+            }
+            return uri.toASCIIString();
+        } catch (IllegalArgumentException invalid) {
+            throw new IllegalArgumentException(URL_KEY + " must be a supported HTTPS URL", invalid);
+        }
+    }
+
+    public static String effectiveSha1(String configured, Defaults defaults) {
+        Objects.requireNonNull(defaults);
+        return configured == null || configured.isEmpty() ? defaults.sha1() : normalizeHash(configured, false);
+    }
+
+    private static String normalizeHash(String value, boolean allowEmpty) {
+        if (allowEmpty && (value == null || value.isEmpty())) return "";
+        if (value == null || !value.matches("[a-fA-F0-9]{40}")) {
+            throw new IllegalArgumentException(SHA1_KEY + " must be exactly 40 hexadecimal characters");
+        }
+        return value.toLowerCase(java.util.Locale.ROOT);
+    }
+
+    private Snapshot snapshot(String configuredUrl, String configuredSha1) {
+        String url = configuredUrl == null ? "" : configuredUrl;
+        String sha1 = configuredSha1 == null ? "" : normalizeHash(configuredSha1, true);
+        return new Snapshot(url, sha1, effectiveUrl(url, defaults), effectiveSha1(sha1, defaults));
+    }
+
+    public String url() { return effective.url(); }
+    public String sha1() { return effective.sha1(); }
+    public String value(String key) {
+        var state = effective;
+        return switch (key) {
+            case URL_KEY -> state.url();
+            case SHA1_KEY -> state.sha1();
+            default -> throw new IllegalArgumentException("Unknown sheet resource-pack key");
+        };
+    }
+
+    public CompletionStage<Update> set(String key, String raw) {
+        if (!URL_KEY.equals(key) && !SHA1_KEY.equals(key)) throw new IllegalArgumentException("Unknown sheet resource-pack key");
+        if (raw == null) throw new IllegalArgumentException(key + " requires a value");
+        if (URL_KEY.equals(key) && !raw.isEmpty()) validateUrl(raw);
+        if (SHA1_KEY.equals(key)) raw = normalizeHash(raw, true);
+        final String accepted = raw;
+        synchronized (this) {
+            if (closed) return CompletableFuture.failedStage(new IOException("Configuration store is closed"));
+            pending++;
+        }
+        try {
+            return CompletableFuture.supplyAsync(() -> {
+                try {
+                    save(key, accepted);
+                    if (URL_KEY.equals(key)) persistedUrl = accepted; else persistedSha1 = accepted;
+                    return new Update(snapshot(persistedUrl, persistedSha1), ++persistedSequence);
+                } catch (IOException | RuntimeException failure) {
+                    throw new java.util.concurrent.CompletionException(new IOException(
+                        "Sheet resource-pack configuration save refused or failed; effective settings unchanged"));
+                } finally { finished(); }
+            }, worker).minimalCompletionStage();
+        } catch (RejectedExecutionException rejected) {
+            finished();
+            return CompletableFuture.failedStage(new IOException("Configuration store is closed"));
+        }
+    }
+
+    public synchronized boolean publish(Update update) {
+        if (update.sequence() <= publishedSequence) return false;
+        effective = update.snapshot();
+        publishedSequence = update.sequence();
+        return true;
+    }
+
+    private void save(String key, String value) throws IOException {
+        Files.createDirectories(directory);
+        if (!Files.isDirectory(directory, LinkOption.NOFOLLOW_LINKS)) throw new IOException("Unsafe directory");
+        var file = directory.resolve("config.yml"); var lockFile = directory.resolve(".config.lock");
+        if (Files.exists(lockFile, LinkOption.NOFOLLOW_LINKS) && !Files.isRegularFile(lockFile, LinkOption.NOFOLLOW_LINKS)) throw new IOException("Unsafe lock");
+        try (var channel = FileChannel.open(lockFile, StandardOpenOption.CREATE, StandardOpenOption.WRITE, LinkOption.NOFOLLOW_LINKS);
+             var lock = channel.tryLock()) {
+            if (lock == null) throw new IOException("Configuration busy");
+            var options = new LoaderOptions(); options.setAllowDuplicateKeys(false); options.setMaxAliasesForCollections(20); options.setCodePointLimit(MAX_BYTES);
+            var yaml = new Yaml(new SafeConstructor(options)); Map<String, Object> values = new LinkedHashMap<>();
+            if (Files.exists(file, LinkOption.NOFOLLOW_LINKS)) {
+                if (!Files.isRegularFile(file, LinkOption.NOFOLLOW_LINKS)) throw new IOException("Unsafe configuration");
+                byte[] bytes; try (var input = Files.newInputStream(file, LinkOption.NOFOLLOW_LINKS)) { bytes = input.readNBytes(MAX_BYTES + 1); }
+                if (bytes.length > MAX_BYTES) throw new IOException("Configuration too large");
+                Object loaded = yaml.load(StandardCharsets.UTF_8.newDecoder().decode(ByteBuffer.wrap(bytes)).toString());
+                if (loaded != null) {
+                    if (!(loaded instanceof Map<?, ?> map)) throw new IOException("Invalid configuration root");
+                    for (var entry : map.entrySet()) {
+                        if (!(entry.getKey() instanceof String name)) throw new IOException("Invalid configuration key");
+                        values.put(name, entry.getValue());
+                    }
+                }
+            }
+            values.put(key, value);
+            byte[] bytes = yaml.dump(values).getBytes(StandardCharsets.UTF_8);
+            if (bytes.length > MAX_BYTES) throw new IOException("Configuration too large");
+            Path temporary = Files.createTempFile(directory, ".config-", ".tmp");
+            try {
+                try (var output = FileChannel.open(temporary, StandardOpenOption.WRITE, LinkOption.NOFOLLOW_LINKS)) {
+                    var buffer = ByteBuffer.wrap(bytes); while (buffer.hasRemaining()) output.write(buffer); output.force(true);
+                }
+                replacement.move(temporary, file);
+            } finally { Files.deleteIfExists(temporary); }
+        } catch (OverlappingFileLockException busy) { throw new IOException("Configuration busy"); }
+    }
+
+    private synchronized void finished() { pending--; if (closed && pending == 0) drained.complete(null); }
+    public CompletionStage<Void> drained() { return drained.minimalCompletionStage(); }
+    @Override public synchronized void close() { closed = true; worker.shutdown(); if (pending == 0) drained.complete(null); }
+}

src/main/java/games/dmg/fantasystick/persistence/ShieldBashSettings.java

@@ -0,0 +1,192 @@
+package games.dmg.fantasystick.persistence;
+
+import games.dmg.fantasystick.ability.ShieldBash;
+import java.io.IOException;
+import java.nio.ByteBuffer;
+import java.nio.channels.FileChannel;
+import java.nio.channels.OverlappingFileLockException;
+import java.nio.charset.StandardCharsets;
+import java.nio.file.Files;
+import java.nio.file.LinkOption;
+import java.nio.file.Path;
+import java.nio.file.StandardCopyOption;
+import java.nio.file.StandardOpenOption;
+import java.time.Duration;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Objects;
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.CompletionStage;
+import java.util.concurrent.Executors;
+import java.util.concurrent.RejectedExecutionException;
+import org.yaml.snakeyaml.LoaderOptions;
+import org.yaml.snakeyaml.Yaml;
+import org.yaml.snakeyaml.constructor.SafeConstructor;
+
+/** Serialized durable Shield Bash settings; publication remains a server-thread caller decision. */
+public final class ShieldBashSettings implements AutoCloseable {
+    private static final int MAX_BYTES = 1_048_576;
+    public static final String BASE_DAMAGE = "shield-bash-base-damage";
+    public static final String COOLDOWN = "shield-bash-cooldown-seconds";
+    public static final String RANGE = "shield-bash-range-blocks";
+    public static final String HORIZONTAL = "shield-bash-horizontal-knockback";
+    public static final String VERTICAL = "shield-bash-minimum-vertical-knockback";
+    private static final List<String> KEYS = List.of(BASE_DAMAGE, COOLDOWN, RANGE, HORIZONTAL, VERTICAL);
+    private static final Map<String, String> DEFAULTS = Map.of(BASE_DAMAGE, "4", COOLDOWN, "6", RANGE, "3",
+        HORIZONTAL, "0.8", VERTICAL, "0.35");
+
+    @FunctionalInterface interface Replacement { void move(Path from, Path to) throws IOException; }
+    public record Update(String key, String value, ShieldBash.Settings settings,
+                         Map<String, String> values, long sequence) {
+        public Update { values = Map.copyOf(values); }
+    }
+
+    private final Path directory;
+    private final Replacement replacement;
+    private final java.util.concurrent.ExecutorService worker = Executors.newSingleThreadExecutor(
+        task -> new Thread(task, "fantasy-shield-bash-configuration"));
+    private volatile Map<String, String> effectiveValues;
+    private Map<String, String> persistedValues;
+    private long persistedSequence;
+    private long publishedSequence;
+    private boolean closed;
+    private int pending;
+    private final CompletableFuture<Void> drained = new CompletableFuture<>();
+
+    public ShieldBashSettings(Path directory, Map<String, String> initial) {
+        this(directory, initial, (from, to) -> Files.move(from, to,
+            StandardCopyOption.ATOMIC_MOVE, StandardCopyOption.REPLACE_EXISTING));
+    }
+
+    ShieldBashSettings(Path directory, Map<String, String> initial, Replacement replacement) {
+        this.directory = Objects.requireNonNull(directory).toAbsolutePath();
+        this.replacement = Objects.requireNonNull(replacement);
+        var copy = new LinkedHashMap<String, String>();
+        for (String key : KEYS) copy.put(key, Objects.requireNonNull(initial.get(key)));
+        parse(copy);
+        effectiveValues = Map.copyOf(copy); persistedValues = Map.copyOf(copy);
+    }
+
+    public static List<String> keys() { return KEYS; }
+    public static String defaultValue(String key) { return DEFAULTS.get(key); }
+    public String value(String key) { return effectiveValues.get(key); }
+    public ShieldBash.Settings settings() { return parse(effectiveValues); }
+
+    /** Publish only after the caller returns the durable acknowledgment to the server thread. */
+    public synchronized void publish(Update update) {
+        Objects.requireNonNull(update);
+        if (update.sequence() <= publishedSequence) return;
+        parse(update.values());
+        effectiveValues = update.values(); publishedSequence = update.sequence();
+    }
+
+    public CompletionStage<Update> set(String key, String value) {
+        Objects.requireNonNull(key); Objects.requireNonNull(value);
+        if (!KEYS.contains(key)) return CompletableFuture.failedStage(new IllegalArgumentException("Unknown setting"));
+        String accepted = canonical(key, value);
+        var preview = new LinkedHashMap<>(effectiveValues); preview.put(key, accepted);
+        parse(preview); // Fail malformed/out-of-range command input before queueing accepted persistence.
+        synchronized (this) {
+            if (closed) return CompletableFuture.failedStage(new IOException("Configuration store is closed"));
+            pending++;
+        }
+        try {
+            return CompletableFuture.supplyAsync(() -> {
+                try {
+                    var next = new LinkedHashMap<>(persistedValues);
+                    next.put(key, accepted);
+                    var parsed = parse(next);
+                    save(key, accepted);
+                    persistedValues = Map.copyOf(next);
+                    return new Update(key, accepted, parsed, persistedValues, ++persistedSequence);
+                } catch (IOException | RuntimeException failure) {
+                    throw new java.util.concurrent.CompletionException(failure instanceof IllegalArgumentException
+                        ? failure : new IOException("Shield Bash configuration save refused or failed; effective settings unchanged"));
+                } finally { finished(); }
+            }, worker).minimalCompletionStage();
+        } catch (RejectedExecutionException rejected) {
+            finished();
+            return CompletableFuture.failedStage(new IOException("Configuration store is closed"));
+        }
+    }
+
+    private static String canonical(String key, String raw) {
+        try {
+            if (key.equals(BASE_DAMAGE)) return new java.math.BigInteger(raw).toString();
+            return new java.math.BigDecimal(raw).stripTrailingZeros().toPlainString();
+        } catch (NumberFormatException invalid) { throw new IllegalArgumentException("Invalid value", invalid); }
+    }
+
+    public static ShieldBash.Settings parse(Map<String, String> values) {
+        try {
+            var base = new java.math.BigInteger(values.get(BASE_DAMAGE));
+            var cooldown = seconds(values.get(COOLDOWN));
+            return new ShieldBash.Settings(base, cooldown, finite(values.get(RANGE)),
+                finite(values.get(HORIZONTAL)), finite(values.get(VERTICAL)));
+        } catch (ArithmeticException | NumberFormatException | NullPointerException invalid) {
+            throw new IllegalArgumentException("Shield Bash settings must use supported numeric values", invalid);
+        }
+    }
+
+    private static Duration seconds(String value) {
+        var nanos = new java.math.BigDecimal(value).movePointRight(9).toBigIntegerExact().longValueExact();
+        return Duration.ofNanos(nanos);
+    }
+
+    private static double finite(String value) {
+        double result = new java.math.BigDecimal(value).doubleValue();
+        if (!Double.isFinite(result)) throw new IllegalArgumentException("Setting is not finite");
+        return result;
+    }
+
+    private void save(String key, String value) throws IOException {
+        Files.createDirectories(directory);
+        if (!Files.isDirectory(directory, LinkOption.NOFOLLOW_LINKS)) throw new IOException("Unsafe directory");
+        var file = directory.resolve("config.yml");
+        var lockFile = directory.resolve(".config.lock");
+        if (Files.exists(lockFile, LinkOption.NOFOLLOW_LINKS)
+                && !Files.isRegularFile(lockFile, LinkOption.NOFOLLOW_LINKS)) throw new IOException("Unsafe lock");
+        try (var channel = FileChannel.open(lockFile, StandardOpenOption.CREATE, StandardOpenOption.WRITE,
+                LinkOption.NOFOLLOW_LINKS); var lock = channel.tryLock()) {
+            if (lock == null) throw new IOException("Configuration busy");
+            var options = new LoaderOptions(); options.setAllowDuplicateKeys(false);
+            options.setMaxAliasesForCollections(20); options.setCodePointLimit(MAX_BYTES);
+            var yaml = new Yaml(new SafeConstructor(options));
+            Map<String, Object> document = new LinkedHashMap<>();
+            if (Files.exists(file, LinkOption.NOFOLLOW_LINKS)) {
+                if (!Files.isRegularFile(file, LinkOption.NOFOLLOW_LINKS)) throw new IOException("Unsafe configuration");
+                byte[] bytes;
+                try (var input = Files.newInputStream(file, LinkOption.NOFOLLOW_LINKS)) { bytes = input.readNBytes(MAX_BYTES + 1); }
+                if (bytes.length > MAX_BYTES) throw new IOException("Configuration too large");
+                Object loaded = yaml.load(StandardCharsets.UTF_8.newDecoder().decode(ByteBuffer.wrap(bytes)).toString());
+                if (loaded != null) {
+                    if (!(loaded instanceof Map<?, ?> map)) throw new IOException("Invalid configuration root");
+                    for (var entry : map.entrySet()) {
+                        if (!(entry.getKey() instanceof String savedKey)) throw new IOException("Invalid configuration key");
+                        document.put(savedKey, entry.getValue());
+                    }
+                }
+            }
+            document.put(key, value);
+            byte[] bytes = yaml.dump(document).getBytes(StandardCharsets.UTF_8);
+            if (bytes.length > MAX_BYTES) throw new IOException("Configuration too large");
+            Path temporary = Files.createTempFile(directory, ".config-", ".tmp");
+            try {
+                try (var output = FileChannel.open(temporary, StandardOpenOption.WRITE, LinkOption.NOFOLLOW_LINKS)) {
+                    var buffer = ByteBuffer.wrap(bytes); while (buffer.hasRemaining()) output.write(buffer); output.force(true);
+                }
+                replacement.move(temporary, file);
+            } finally { Files.deleteIfExists(temporary); }
+        } catch (OverlappingFileLockException busy) { throw new IOException("Configuration busy"); }
+    }
+
+    private synchronized void finished() {
+        pending--;
+        if (closed && pending == 0) drained.complete(null);
+    }
+    public CompletionStage<Void> drained() { return drained.minimalCompletionStage(); }
+    @Override public synchronized void close() {
+        closed = true; worker.shutdown(); if (pending == 0) drained.complete(null);
+    }
+}

src/main/java/games/dmg/fantasystick/persistence/StoneSkinSettings.java

@@ -0,0 +1,188 @@
+package games.dmg.fantasystick.persistence;
+
+import games.dmg.fantasystick.ability.StoneSkin;
+import java.io.IOException;
+import java.nio.ByteBuffer;
+import java.nio.channels.FileChannel;
+import java.nio.channels.OverlappingFileLockException;
+import java.nio.charset.StandardCharsets;
+import java.nio.file.Files;
+import java.nio.file.LinkOption;
+import java.nio.file.Path;
+import java.nio.file.StandardCopyOption;
+import java.nio.file.StandardOpenOption;
+import java.time.Duration;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Objects;
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.CompletionStage;
+import java.util.concurrent.Executors;
+import java.util.concurrent.RejectedExecutionException;
+import org.yaml.snakeyaml.LoaderOptions;
+import org.yaml.snakeyaml.Yaml;
+import org.yaml.snakeyaml.constructor.SafeConstructor;
+
+/** Serialized durable Stone Skin settings; publication remains a server-thread caller decision. */
+public final class StoneSkinSettings implements AutoCloseable {
+    private static final int MAX_BYTES = 1_048_576;
+    public static final String COOLDOWN = "stone-skin-cooldown-seconds";
+    public static final String DURATION = "stone-skin-duration-seconds";
+    public static final String REDUCTION = "stone-skin-damage-reduction-percent";
+    private static final List<String> KEYS = List.of(COOLDOWN, DURATION, REDUCTION);
+    private static final Map<String, String> DEFAULTS = Map.of(COOLDOWN, "14", DURATION, "4", REDUCTION, "25");
+
+    @FunctionalInterface interface Replacement { void move(Path from, Path to) throws IOException; }
+    public record Update(String key, String value, StoneSkin.Settings settings,
+                         Map<String, String> values, long sequence) {
+        public Update { values = Map.copyOf(values); }
+    }
+
+    private final Path directory;
+    private final Replacement replacement;
+    private final java.util.concurrent.ExecutorService worker = Executors.newSingleThreadExecutor(
+        task -> new Thread(task, "fantasy-stone-skin-configuration"));
+    private volatile Map<String, String> effectiveValues;
+    private Map<String, String> persistedValues;
+    private long persistedSequence;
+    private long publishedSequence;
+    private boolean closed;
+    private int pending;
+    private final CompletableFuture<Void> drained = new CompletableFuture<>();
+
+    public StoneSkinSettings(Path directory, Map<String, String> initial) {
+        this(directory, initial, (from, to) -> Files.move(from, to,
+            StandardCopyOption.ATOMIC_MOVE, StandardCopyOption.REPLACE_EXISTING));
+    }
+
+    StoneSkinSettings(Path directory, Map<String, String> initial, Replacement replacement) {
+        this.directory = Objects.requireNonNull(directory).toAbsolutePath();
+        this.replacement = Objects.requireNonNull(replacement);
+        var copy = new LinkedHashMap<String, String>();
+        for (String key : KEYS) copy.put(key, Objects.requireNonNull(initial.get(key)));
+        parse(copy);
+        effectiveValues = Map.copyOf(copy); persistedValues = Map.copyOf(copy);
+    }
+
+    public static List<String> keys() { return KEYS; }
+    public static String defaultValue(String key) { return DEFAULTS.get(key); }
+    public String value(String key) { return effectiveValues.get(key); }
+    public StoneSkin.Settings settings() { return parse(effectiveValues); }
+
+    /** Publish only after the caller returns the durable acknowledgment to the server thread. */
+    public synchronized void publish(Update update) {
+        Objects.requireNonNull(update);
+        if (update.sequence() <= publishedSequence) return;
+        parse(update.values());
+        effectiveValues = update.values(); publishedSequence = update.sequence();
+    }
+
+    public CompletionStage<Update> set(String key, String value) {
+        Objects.requireNonNull(key); Objects.requireNonNull(value);
+        if (!KEYS.contains(key)) return CompletableFuture.failedStage(new IllegalArgumentException("Unknown setting"));
+        String accepted = canonical(key, value);
+        var preview = new LinkedHashMap<>(effectiveValues); preview.put(key, accepted);
+        parse(preview); // Fail malformed/out-of-range command input before queueing accepted persistence.
+        synchronized (this) {
+            if (closed) return CompletableFuture.failedStage(new IOException("Configuration store is closed"));
+            pending++;
+        }
+        try {
+            return CompletableFuture.supplyAsync(() -> {
+                try {
+                    var next = new LinkedHashMap<>(persistedValues);
+                    next.put(key, accepted);
+                    var parsed = parse(next);
+                    save(key, accepted);
+                    persistedValues = Map.copyOf(next);
+                    return new Update(key, accepted, parsed, persistedValues, ++persistedSequence);
+                } catch (IOException | RuntimeException failure) {
+                    throw new java.util.concurrent.CompletionException(failure instanceof IllegalArgumentException
+                        ? failure : new IOException("Stone Skin configuration save refused or failed; effective settings unchanged"));
+                } finally { finished(); }
+            }, worker).minimalCompletionStage();
+        } catch (RejectedExecutionException rejected) {
+            finished();
+            return CompletableFuture.failedStage(new IOException("Configuration store is closed"));
+        }
+    }
+
+    private static String canonical(String key, String raw) {
+        try {
+            return new java.math.BigDecimal(raw).stripTrailingZeros().toPlainString();
+        } catch (NumberFormatException invalid) { throw new IllegalArgumentException("Invalid value", invalid); }
+    }
+
+    public static StoneSkin.Settings parse(Map<String, String> values) {
+        try {
+            var cooldown = seconds(values.get(COOLDOWN));
+            var duration = seconds(values.get(DURATION));
+            var reduction = new java.math.BigDecimal(values.get(REDUCTION));
+            return new StoneSkin.Settings(cooldown, duration, reduction);
+        } catch (ArithmeticException | NumberFormatException | NullPointerException invalid) {
+            throw new IllegalArgumentException("Stone Skin settings must use supported numeric values", invalid);
+        }
+    }
+
+    private static Duration seconds(String value) {
+        var nanos = new java.math.BigDecimal(value).movePointRight(9).toBigIntegerExact().longValueExact();
+        return Duration.ofNanos(nanos);
+    }
+
+    private static double finite(String value) {
+        double result = new java.math.BigDecimal(value).doubleValue();
+        if (!Double.isFinite(result)) throw new IllegalArgumentException("Setting is not finite");
+        return result;
+    }
+
+    private void save(String key, String value) throws IOException {
+        Files.createDirectories(directory);
+        if (!Files.isDirectory(directory, LinkOption.NOFOLLOW_LINKS)) throw new IOException("Unsafe directory");
+        var file = directory.resolve("config.yml");
+        var lockFile = directory.resolve(".config.lock");
+        if (Files.exists(lockFile, LinkOption.NOFOLLOW_LINKS)
+                && !Files.isRegularFile(lockFile, LinkOption.NOFOLLOW_LINKS)) throw new IOException("Unsafe lock");
+        try (var channel = FileChannel.open(lockFile, StandardOpenOption.CREATE, StandardOpenOption.WRITE,
+                LinkOption.NOFOLLOW_LINKS); var lock = channel.tryLock()) {
+            if (lock == null) throw new IOException("Configuration busy");
+            var options = new LoaderOptions(); options.setAllowDuplicateKeys(false);
+            options.setMaxAliasesForCollections(20); options.setCodePointLimit(MAX_BYTES);
+            var yaml = new Yaml(new SafeConstructor(options));
+            Map<String, Object> document = new LinkedHashMap<>();
+            if (Files.exists(file, LinkOption.NOFOLLOW_LINKS)) {
+                if (!Files.isRegularFile(file, LinkOption.NOFOLLOW_LINKS)) throw new IOException("Unsafe configuration");
+                byte[] bytes;
+                try (var input = Files.newInputStream(file, LinkOption.NOFOLLOW_LINKS)) { bytes = input.readNBytes(MAX_BYTES + 1); }
+                if (bytes.length > MAX_BYTES) throw new IOException("Configuration too large");
+                Object loaded = yaml.load(StandardCharsets.UTF_8.newDecoder().decode(ByteBuffer.wrap(bytes)).toString());
+                if (loaded != null) {
+                    if (!(loaded instanceof Map<?, ?> map)) throw new IOException("Invalid configuration root");
+                    for (var entry : map.entrySet()) {
+                        if (!(entry.getKey() instanceof String savedKey)) throw new IOException("Invalid configuration key");
+                        document.put(savedKey, entry.getValue());
+                    }
+                }
+            }
+            document.put(key, value);
+            byte[] bytes = yaml.dump(document).getBytes(StandardCharsets.UTF_8);
+            if (bytes.length > MAX_BYTES) throw new IOException("Configuration too large");
+            Path temporary = Files.createTempFile(directory, ".config-", ".tmp");
+            try {
+                try (var output = FileChannel.open(temporary, StandardOpenOption.WRITE, LinkOption.NOFOLLOW_LINKS)) {
+                    var buffer = ByteBuffer.wrap(bytes); while (buffer.hasRemaining()) output.write(buffer); output.force(true);
+                }
+                replacement.move(temporary, file);
+            } finally { Files.deleteIfExists(temporary); }
+        } catch (OverlappingFileLockException busy) { throw new IOException("Configuration busy"); }
+    }
+
+    private synchronized void finished() {
+        pending--;
+        if (closed && pending == 0) drained.complete(null);
+    }
+    public CompletionStage<Void> drained() { return drained.minimalCompletionStage(); }
+    @Override public synchronized void close() {
+        closed = true; worker.shutdown(); if (pending == 0) drained.complete(null);
+    }
+}

src/main/java/games/dmg/fantasystick/persistence/SwitchDelaySettings.java

@@ -0,0 +1,42 @@
+package games.dmg.fantasystick.persistence;
+
+import java.io.IOException;
+import java.nio.ByteBuffer;
+import java.nio.channels.FileChannel;
+import java.nio.channels.OverlappingFileLockException;
+import java.nio.charset.StandardCharsets;
+import java.nio.file.Files;
+import java.nio.file.LinkOption;
+import java.nio.file.Path;
+import java.nio.file.StandardCopyOption;
+import java.nio.file.StandardOpenOption;
+import java.time.Duration;
+import java.util.LinkedHashMap;
+import java.util.Map;
+import java.util.Objects;
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.CompletionStage;
+import java.util.concurrent.Executors;
+import java.util.concurrent.RejectedExecutionException;
+import org.yaml.snakeyaml.LoaderOptions;
+import org.yaml.snakeyaml.Yaml;
+import org.yaml.snakeyaml.constructor.SafeConstructor;
+
+/** Durable save-before-publish policy for character-switch delay checks and later exits. */
+public final class SwitchDelaySettings implements AutoCloseable {
+    public static final String KEY="character-swap-cooldown-seconds";public static final String DEFAULT="900";
+    private static final int MAX_BYTES=1_048_576;
+    @FunctionalInterface interface Replacement{void move(Path from,Path to)throws IOException;}
+    public record Update(String value,Duration delay,long sequence){}
+    private final Path directory;private final Replacement replacement;private final java.util.concurrent.ExecutorService worker=Executors.newSingleThreadExecutor(task->new Thread(task,"fantasy-switch-delay-configuration"));
+    private volatile Duration effective;private long persistedSequence,publishedSequence;private boolean closed;private int pending;private final CompletableFuture<Void> drained=new CompletableFuture<>();
+    public SwitchDelaySettings(Path directory,Duration initial){this(directory,initial,(from,to)->Files.move(from,to,StandardCopyOption.ATOMIC_MOVE,StandardCopyOption.REPLACE_EXISTING));}
+    SwitchDelaySettings(Path directory,Duration initial,Replacement replacement){this.directory=Objects.requireNonNull(directory).toAbsolutePath();this.replacement=Objects.requireNonNull(replacement);effective=validate(initial);}
+    public static Duration parse(Object value){if(value==null)return Duration.ofSeconds(900);try{return validate(Duration.ofSeconds(value instanceof Number n?new java.math.BigDecimal(n.toString()).longValueExact():Long.parseLong(value.toString())));}catch(ArithmeticException|NumberFormatException invalid){throw new IllegalArgumentException(KEY+" must be nonnegative whole seconds",invalid);}}
+    private static Duration validate(Duration value){if(value.isNegative()||value.getNano()!=0)throw new IllegalArgumentException(KEY+" must be nonnegative whole seconds");try{var deadline=java.time.Instant.now().plus(value);if(deadline.atOffset(java.time.ZoneOffset.UTC).getYear()>9999)throw new IllegalArgumentException(KEY+" exceeds the persisted timestamp range");return value;}catch(java.time.DateTimeException|ArithmeticException invalid){throw new IllegalArgumentException(KEY+" exceeds the persisted timestamp range",invalid);}}
+    public Duration delay(){return effective;}public String value(){return Long.toString(effective.toSeconds());}
+    public CompletionStage<Update> set(String raw){Duration accepted=parse(raw);synchronized(this){if(closed)return CompletableFuture.failedStage(new IOException("Configuration store is closed"));pending++;}try{return CompletableFuture.supplyAsync(()->{try{save(accepted);return new Update(Long.toString(accepted.toSeconds()),accepted,++persistedSequence);}catch(IOException|RuntimeException failure){throw new java.util.concurrent.CompletionException(new IOException("Character switch configuration save refused or failed; effective setting unchanged"));}finally{finished();}},worker).minimalCompletionStage();}catch(RejectedExecutionException rejected){finished();return CompletableFuture.failedStage(new IOException("Configuration store is closed"));}}
+    public synchronized void publish(Update update){if(update.sequence()<=publishedSequence)return;effective=validate(update.delay());publishedSequence=update.sequence();}
+    private void save(Duration value)throws IOException{Files.createDirectories(directory);if(!Files.isDirectory(directory,LinkOption.NOFOLLOW_LINKS))throw new IOException("Unsafe directory");var file=directory.resolve("config.yml");var lockFile=directory.resolve(".config.lock");if(Files.exists(lockFile,LinkOption.NOFOLLOW_LINKS)&&!Files.isRegularFile(lockFile,LinkOption.NOFOLLOW_LINKS))throw new IOException("Unsafe lock");try(var channel=FileChannel.open(lockFile,StandardOpenOption.CREATE,StandardOpenOption.WRITE,LinkOption.NOFOLLOW_LINKS);var lock=channel.tryLock()){if(lock==null)throw new IOException("Configuration busy");var options=new LoaderOptions();options.setAllowDuplicateKeys(false);options.setMaxAliasesForCollections(20);options.setCodePointLimit(MAX_BYTES);var yaml=new Yaml(new SafeConstructor(options));Map<String,Object> values=new LinkedHashMap<>();if(Files.exists(file,LinkOption.NOFOLLOW_LINKS)){if(!Files.isRegularFile(file,LinkOption.NOFOLLOW_LINKS))throw new IOException("Unsafe configuration");byte[] bytes;try(var input=Files.newInputStream(file,LinkOption.NOFOLLOW_LINKS)){bytes=input.readNBytes(MAX_BYTES+1);}if(bytes.length>MAX_BYTES)throw new IOException("Configuration too large");Object loaded=yaml.load(StandardCharsets.UTF_8.newDecoder().decode(ByteBuffer.wrap(bytes)).toString());if(loaded!=null){if(!(loaded instanceof Map<?,?> map))throw new IOException("Invalid configuration root");for(var entry:map.entrySet()){if(!(entry.getKey() instanceof String key))throw new IOException("Invalid configuration key");values.put(key,entry.getValue());}}}values.put(KEY,Long.toString(value.toSeconds()));byte[] bytes=yaml.dump(values).getBytes(StandardCharsets.UTF_8);if(bytes.length>MAX_BYTES)throw new IOException("Configuration too large");Path temporary=Files.createTempFile(directory,".config-",".tmp");try{try(var output=FileChannel.open(temporary,StandardOpenOption.WRITE,LinkOption.NOFOLLOW_LINKS)){var buffer=ByteBuffer.wrap(bytes);while(buffer.hasRemaining())output.write(buffer);output.force(true);}replacement.move(temporary,file);}finally{Files.deleteIfExists(temporary);}}catch(OverlappingFileLockException busy){throw new IOException("Configuration busy");}}
+    private synchronized void finished(){pending--;if(closed&&pending==0)drained.complete(null);}public CompletionStage<Void> drained(){return drained.minimalCompletionStage();}@Override public synchronized void close(){closed=true;worker.shutdown();if(pending==0)drained.complete(null);}
+}

src/main/java/games/dmg/fantasystick/presentation/SheetResourcePack.java

@@ -0,0 +1,59 @@
+package games.dmg.fantasystick.presentation;
+
+import games.dmg.fantasystick.persistence.SheetResourcePackSettings;
+import java.util.Collection;
+import java.util.Objects;
+import java.util.UUID;
+import java.util.function.BiConsumer;
+import org.bukkit.entity.Player;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.Listener;
+import org.bukkit.event.player.PlayerJoinEvent;
+import org.bukkit.event.player.PlayerResourcePackStatusEvent;
+
+/** Optional cosmetic pack delivery. Status never authorizes or cancels gameplay. */
+public final class SheetResourcePack implements Listener, AutoCloseable {
+    public static final UUID ID = UUID.fromString("0d53e627-f13b-5a49-b8d5-882d3f4122bb");
+    private final SheetResourcePackSettings settings;
+    private final BiConsumer<UUID, Throwable> failures;
+    private boolean closed;
+
+    public SheetResourcePack(SheetResourcePackSettings settings, BiConsumer<UUID, Throwable> failures) {
+        this.settings = Objects.requireNonNull(settings);
+        this.failures = Objects.requireNonNull(failures);
+    }
+
+    public void deliverAll(Collection<? extends Player> players) {
+        if (closed) return;
+        for (var player : players) if (player != null && player.isOnline()) deliver(player);
+    }
+
+    public void deliver(Player player) {
+        if (closed || !player.isOnline()) return;
+        try {
+            player.addResourcePack(ID, settings.url(), java.util.HexFormat.of().parseHex(settings.sha1()),
+                "Optional Fantasy Stick first-person sheet presentation", false);
+        } catch (RuntimeException failure) {
+            report(player.getUniqueId(), failure);
+            player.sendMessage("Fantasy Stick cosmetic resource pack could not be offered; gameplay is unchanged.");
+        }
+    }
+
+    @EventHandler public void join(PlayerJoinEvent event) { deliver(event.getPlayer()); }
+
+    @EventHandler public void status(PlayerResourcePackStatusEvent event) {
+        if (closed || !ID.equals(event.getID())) return;
+        switch (event.getStatus()) {
+            case DECLINED, FAILED_DOWNLOAD, INVALID_URL, FAILED_RELOAD, DISCARDED ->
+                event.getPlayer().sendMessage("Fantasy Stick cosmetic resource pack is unavailable; gameplay is unchanged.");
+            default -> { /* Acceptance/loading is cosmetic and needs no gameplay callback. */ }
+        }
+    }
+
+    private void report(UUID player, Throwable failure) {
+        try { failures.accept(player, failure); }
+        catch (RuntimeException ignored) { /* Diagnostics cannot make a cosmetic pack mandatory. */ }
+    }
+
+    @Override public void close() { closed = true; }
+}

src/main/java/games/dmg/fantasystick/progression/CombatContributions.java

@@ -10,8 +10,11 @@ import java.util.UUID;
 
 /** Server-thread bounded contribution ledger keyed by target and originating character. */
 public final class CombatContributions implements AutoCloseable {
+    private static final java.time.Duration SUPPORT_LIFETIME = java.time.Duration.ofSeconds(10);
     private final CombatRewardRules rules;
     private final Map<UUID, Map<UUID, Instant>> targets = new HashMap<>();
+    private final Map<UUID, Map<UUID, Map<UUID, Instant>>> supports = new HashMap<>();
+    private final Map<UUID, Map<UUID, Instant>> effectiveHealing = new HashMap<>();
     private boolean closed;
 
     public CombatContributions(CombatRewardRules rules) { this.rules = Objects.requireNonNull(rules); }
@@ -23,26 +26,68 @@ public final class CombatContributions implements AutoCloseable {
             (previous, next) -> previous.isAfter(next) ? previous : next);
     }
 
+    public void support(UUID target, UUID aidedCharacter, UUID supportingCharacter, Instant acceptedAt) {
+        Objects.requireNonNull(target); Objects.requireNonNull(aidedCharacter);
+        Objects.requireNonNull(supportingCharacter); Objects.requireNonNull(acceptedAt);
+        if (closed) return;
+        supports.computeIfAbsent(target, ignored -> new HashMap<>())
+            .computeIfAbsent(aidedCharacter, ignored -> new HashMap<>())
+            .merge(supportingCharacter, acceptedAt, (previous, next) -> previous.isAfter(next) ? previous : next);
+    }
+
+    /** Records effective healing that may qualify through any target the aided character directly contributes to. */
+    public void support(UUID aidedCharacter, UUID supportingCharacter, Instant acceptedAt) {
+        Objects.requireNonNull(aidedCharacter); Objects.requireNonNull(supportingCharacter); Objects.requireNonNull(acceptedAt);
+        if (closed) return;
+        effectiveHealing.computeIfAbsent(aidedCharacter, ignored -> new HashMap<>())
+            .merge(supportingCharacter, acceptedAt, (previous, next) -> previous.isAfter(next) ? previous : next);
+    }
+
     public Set<UUID> consume(UUID target, Instant deathAt) {
         Objects.requireNonNull(target); Objects.requireNonNull(deathAt);
         if (closed) return Set.of();
         var contributions = targets.remove(target);
+        var assistance = supports.remove(target);
         if (contributions == null) return Set.of();
         var eligible = new LinkedHashSet<UUID>();
         contributions.forEach((character, acceptedAt) -> {
             if (rules.contributes(acceptedAt, deathAt)) eligible.add(character);
         });
+        for (UUID aided : Set.copyOf(eligible)) {
+            var targeted = assistance == null ? null : assistance.get(aided);
+            if (targeted != null) targeted.forEach((supporter, acceptedAt) -> {
+                if (supports(acceptedAt, deathAt)) eligible.add(supporter);
+            });
+            var healing = effectiveHealing.get(aided);
+            if (healing != null) healing.forEach((supporter, acceptedAt) -> {
+                if (supports(acceptedAt, deathAt)) eligible.add(supporter);
+            });
+        }
         return Set.copyOf(eligible);
     }
 
-    public void invalidate(UUID target) { if (!closed) targets.remove(Objects.requireNonNull(target)); }
+    public void invalidate(UUID target) {
+        if (!closed) { target = Objects.requireNonNull(target); targets.remove(target); supports.remove(target); }
+    }
 
     public void sweep(Instant now) {
         Objects.requireNonNull(now);
         if (closed) return;
         targets.values().forEach(contributions -> contributions.entrySet().removeIf(entry -> !rules.contributes(entry.getValue(), now)));
         targets.values().removeIf(Map::isEmpty);
+        supports.values().forEach(byAlly -> {
+            byAlly.values().forEach(bySupporter -> bySupporter.entrySet().removeIf(entry -> !supports(entry.getValue(), now)));
+            byAlly.values().removeIf(Map::isEmpty);
+        });
+        supports.values().removeIf(Map::isEmpty);
+        effectiveHealing.values().forEach(bySupporter ->
+            bySupporter.entrySet().removeIf(entry -> !supports(entry.getValue(), now)));
+        effectiveHealing.values().removeIf(Map::isEmpty);
     }
 
-    @Override public void close() { closed = true; targets.clear(); }
+    private static boolean supports(Instant acceptedAt, Instant defeatAt) {
+        return !acceptedAt.isAfter(defeatAt) && !defeatAt.isAfter(acceptedAt.plus(SUPPORT_LIFETIME));
+    }
+
+    @Override public void close() { closed = true; targets.clear(); supports.clear(); effectiveHealing.clear(); }
 }

src/main/java/games/dmg/fantasystick/session/AdminCharacterIssuer.java

@@ -0,0 +1,121 @@
+package games.dmg.fantasystick.session;
+
+import games.dmg.fantasystick.items.CharacterSheets;
+import games.dmg.fantasystick.persistence.CharacterRecord;
+import games.dmg.fantasystick.persistence.CharacterStorage;
+import java.util.List;
+import java.util.Objects;
+import java.util.UUID;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.function.Consumer;
+import java.util.function.Supplier;
+import org.bukkit.entity.Player;
+
+/** Persists one fresh character before handing its authentic sheet to a still-valid native inventory slot. */
+public final class AdminCharacterIssuer implements AutoCloseable {
+    public enum Outcome { DELIVERED, FULL, BUSY, STALE, SAVE_FAILED, RETAINED }
+    public record Failure(UUID player, UUID character, String operation, Throwable cause) { }
+
+    private final CharacterStorage storage;
+    private final Supplier<CharacterRecord> allocate;
+    private final Consumer<Runnable> nextTick;
+    private final Consumer<Failure> failures;
+    private final ConcurrentHashMap<UUID, Attempt> pending = new ConcurrentHashMap<>();
+    private volatile boolean closed;
+
+    public AdminCharacterIssuer(CharacterStorage storage, Supplier<CharacterRecord> allocate,
+                                Consumer<Runnable> nextTick, Consumer<Failure> failures) {
+        this.storage = Objects.requireNonNull(storage);
+        this.allocate = Objects.requireNonNull(allocate);
+        this.nextTick = Objects.requireNonNull(nextTick);
+        this.failures = Objects.requireNonNull(failures);
+    }
+
+    /** Must be entered on the server thread. Completion is delivered on that thread. */
+    public void issue(Player player, Consumer<Outcome> response) {
+        Objects.requireNonNull(player); Objects.requireNonNull(response);
+        if (closed || !player.isOnline()) { response.accept(Outcome.STALE); return; }
+        int slot = player.getInventory().firstEmpty();
+        if (slot < 0) { response.accept(Outcome.FULL); return; }
+        var attempt = new Attempt(player, slot, response);
+        if (pending.putIfAbsent(attempt.playerId, attempt) != null) { response.accept(Outcome.BUSY); return; }
+        try {
+            attempt.record = allocate.get();
+            attempt.preparation = storage.prepareCraft(List.of(attempt.record));
+            attempt.preparation.ready().whenComplete((batch, failure) -> schedule(attempt, batch, failure));
+        } catch (RuntimeException failure) {
+            pending.remove(attempt.playerId, attempt);
+            abandon(attempt);
+            report(attempt, "prepare", failure);
+            response.accept(Outcome.SAVE_FAILED);
+        }
+    }
+
+    private void schedule(Attempt attempt, CharacterStorage.CraftBatch batch, Throwable failure) {
+        if (closed || pending.get(attempt.playerId) != attempt) { abandon(attempt); return; }
+        try { nextTick.accept(() -> complete(attempt, batch, failure)); }
+        catch (RuntimeException rejected) {
+            pending.remove(attempt.playerId, attempt); abandon(attempt); report(attempt, "schedule", rejected);
+        }
+    }
+
+    private void complete(Attempt attempt, CharacterStorage.CraftBatch batch, Throwable failure) {
+        if (closed || !pending.remove(attempt.playerId, attempt)) { abandon(attempt); return; }
+        if (failure != null) {
+            abandon(attempt); report(attempt, "save", failure); respond(attempt, Outcome.SAVE_FAILED); return;
+        }
+        var occupying = attempt.player.getInventory().getItem(attempt.slot);
+        if (!attempt.player.isOnline() || attempt.slot < 0 || attempt.slot >= 36
+                || occupying != null && !occupying.getType().isAir()) {
+            abandon(attempt); respond(attempt, Outcome.STALE); return;
+        }
+        var claimed = batch.claimForDelivery();
+        if (claimed.isEmpty() || claimed.orElseThrow().size() != 1
+                || !claimed.orElseThrow().getFirst().id().equals(attempt.record.id())) {
+            abandon(attempt); respond(attempt, Outcome.RETAINED); return;
+        }
+        try {
+            var sheet = new CharacterSheets().create(attempt.record);
+            attempt.player.getInventory().setItem(attempt.slot, sheet);
+            attempt.delivered = true;
+        } catch (RuntimeException uncertain) {
+            report(attempt, "delivery", uncertain);
+            respond(attempt, Outcome.RETAINED);
+            return;
+        }
+        try { attempt.player.updateInventory(); }
+        catch (RuntimeException syncFailure) { report(attempt, "sync", syncFailure); }
+        respond(attempt, Outcome.DELIVERED);
+    }
+
+    private void respond(Attempt attempt, Outcome outcome) {
+        try { attempt.response.accept(outcome); }
+        catch (RuntimeException failure) { report(attempt, "response", failure); }
+    }
+
+    private void abandon(Attempt attempt) {
+        if (attempt.preparation == null || attempt.delivered || !attempt.abandoned.compareAndSet(false, true)) return;
+        attempt.preparation.abandon().thenAccept(cleanup -> {
+            if (!cleanup.retained().isEmpty()) report(attempt, "cleanup-retained", null);
+        });
+    }
+
+    private void report(Attempt attempt, String operation, Throwable cause) {
+        try { failures.accept(new Failure(attempt.playerId, attempt.record == null ? null : attempt.record.id(), operation, cause)); }
+        catch (RuntimeException ignored) { }
+    }
+
+    @Override public void close() {
+        closed = true;
+        for (var attempt : List.copyOf(pending.values())) {
+            if (pending.remove(attempt.playerId, attempt)) abandon(attempt);
+        }
+    }
+
+    private static final class Attempt {
+        final Player player; final UUID playerId; final int slot; final Consumer<Outcome> response;
+        final java.util.concurrent.atomic.AtomicBoolean abandoned = new java.util.concurrent.atomic.AtomicBoolean();
+        CharacterRecord record; CharacterStorage.CraftPreparation preparation; volatile boolean delivered;
+        Attempt(Player player, int slot, Consumer<Outcome> response) { this.player=player; this.playerId=player.getUniqueId(); this.slot=slot; this.response=response; }
+    }
+}

src/main/java/games/dmg/fantasystick/session/AdminExperienceGrant.java

@@ -0,0 +1,114 @@
+package games.dmg.fantasystick.session;
+
+import games.dmg.fantasystick.persistence.CharacterRecord;
+import games.dmg.fantasystick.persistence.CharacterStorage;
+import games.dmg.fantasystick.progression.ProgressionRules;
+import java.math.BigInteger;
+import java.util.Objects;
+import java.util.UUID;
+import java.util.function.Consumer;
+import java.util.function.Function;
+import org.bukkit.Color;
+import org.bukkit.Sound;
+import org.bukkit.entity.Player;
+
+/** Acknowledged administrator XP mutation captured against one exact active character/session. */
+public final class AdminExperienceGrant implements AutoCloseable {
+    public enum Status { APPLIED, AT_CAP, STALE, UNAVAILABLE, FAILED }
+    public record Result(Status status, String name, BigInteger requested, BigInteger applied,
+                         int level, int levels) { }
+    public record Failure(UUID character, Throwable cause) { }
+
+    private final CharacterStorage characters;
+    private final ProgressionRules progression;
+    private final EquipmentSessions sessions;
+    private final Consumer<Runnable> nextTick;
+    private final Function<UUID, Player> players;
+    private final Consumer<Failure> failures;
+    private volatile boolean closed;
+
+    public AdminExperienceGrant(CharacterStorage characters, ProgressionRules progression, EquipmentSessions sessions,
+            Consumer<Runnable> nextTick, Function<UUID, Player> players, Consumer<Failure> failures) {
+        this.characters = Objects.requireNonNull(characters);
+        this.progression = Objects.requireNonNull(progression);
+        this.sessions = Objects.requireNonNull(sessions);
+        this.nextTick = Objects.requireNonNull(nextTick);
+        this.players = Objects.requireNonNull(players);
+        this.failures = Objects.requireNonNull(failures);
+    }
+
+    /** Returns false before persistence when the captured active identity is no longer authoritative. */
+    public boolean grant(EquipmentSessions.Active active, CharacterRecord captured, BigInteger amount,
+                         Consumer<Result> completion) {
+        Objects.requireNonNull(active); Objects.requireNonNull(captured);
+        Objects.requireNonNull(amount); Objects.requireNonNull(completion);
+        if (amount.signum() <= 0) throw new IllegalArgumentException("Experience grant must be positive");
+        if (closed || !sessions.current(active)
+                || sessions.currentRecord(active).filter(captured::equals).isEmpty()) return false;
+        characters.awardExperience(captured.id(), captured.revision(), amount, progression)
+            .whenComplete((award, failure) -> schedule(active, captured, amount, completion, award, failure));
+        return true;
+    }
+
+    private void schedule(EquipmentSessions.Active active, CharacterRecord captured, BigInteger amount,
+            Consumer<Result> completion, CharacterStorage.ExperienceAward award, Throwable failure) {
+        if (failure != null) report(captured.id(), failure);
+        if (closed) return;
+        try {
+            nextTick.accept(() -> complete(active, captured, amount, completion, award, failure));
+        } catch (RuntimeException rejected) { report(captured.id(), rejected); }
+    }
+
+    private void complete(EquipmentSessions.Active active, CharacterRecord captured, BigInteger amount,
+            Consumer<Result> completion, CharacterStorage.ExperienceAward award, Throwable failure) {
+        if (closed) return;
+        if (failure != null) {
+            completion.accept(new Result(Status.FAILED, captured.name(), amount, BigInteger.ZERO,
+                captured.level(), 0));
+            return;
+        }
+        var saved = award.record().orElse(captured);
+        Status status = switch (award.status()) {
+            case APPLIED -> Status.APPLIED;
+            case AT_CAP, UNCHANGED -> Status.AT_CAP;
+            case STALE -> Status.STALE;
+            case UNAVAILABLE -> Status.UNAVAILABLE;
+        };
+        BigInteger applied = status == Status.APPLIED
+            ? saved.experience().subtract(captured.experience()) : BigInteger.ZERO;
+        if (status == Status.APPLIED && sessions.current(active)) {
+            boolean synchronizedSession = sessions.acknowledgeProgress(active, captured.revision(), saved);
+            if (!synchronizedSession && sessions.current(active)
+                    && sessions.currentRecord(active).filter(saved::equals).isEmpty()) {
+                report(captured.id(), new IllegalStateException(
+                    "Saved administrator XP could not synchronize with its captured active session"));
+            }
+            if (synchronizedSession && sessions.current(active)) feedback(active, saved, applied, award.levels());
+        }
+        completion.accept(new Result(status, captured.name(), amount, applied, saved.level(), award.levels()));
+    }
+
+    private void feedback(EquipmentSessions.Active active, CharacterRecord saved, BigInteger applied, int levels) {
+        Player player;
+        try { player = players.apply(active.player()); }
+        catch (RuntimeException failure) { report(saved.id(), failure); return; }
+        if (player == null || !player.isOnline() || !sessions.current(active)
+                || sessions.currentRecord(active).filter(saved::equals).isEmpty()) return;
+        try {
+            player.sendMessage("Received " + applied + " fantasy XP from an administrator.");
+            for (int gained = 1; gained <= levels; gained++) {
+                int level = saved.level() - levels + gained;
+                player.sendMessage("Level " + level + "! Gained 1 character point.");
+                SessionVisuals.burst(player, Color.BLUE, 12);
+                player.playSound(player.getLocation(), Sound.ENTITY_PLAYER_LEVELUP, 1, 1);
+            }
+        } catch (RuntimeException failure) { report(saved.id(), failure); }
+    }
+
+    private void report(UUID character, Throwable failure) {
+        try { failures.accept(new Failure(character, failure)); }
+        catch (RuntimeException ignored) { /* Diagnostics do not replay a grant. */ }
+    }
+
+    @Override public void close() { closed = true; }
+}

src/main/java/games/dmg/fantasystick/session/AdminRevival.java

@@ -0,0 +1,68 @@
+package games.dmg.fantasystick.session;
+
+import games.dmg.fantasystick.items.CharacterSheets;
+import games.dmg.fantasystick.items.TailBooks;
+import games.dmg.fantasystick.persistence.CharacterRecord;
+import games.dmg.fantasystick.persistence.CharacterStorage;
+import games.dmg.fantasystick.persistence.RevivalStore;
+import java.time.Clock;
+import java.time.Duration;
+import java.time.Instant;
+import java.time.temporal.ChronoUnit;
+import java.util.ArrayList;
+import java.util.IdentityHashMap;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Objects;
+import java.util.UUID;
+import java.util.concurrent.CompletableFuture;
+import java.util.function.Consumer;
+import net.kyori.adventure.text.Component;
+import org.bukkit.entity.Player;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.EventPriority;
+import org.bukkit.event.Listener;
+import org.bukkit.inventory.Inventory;
+import org.bukkit.inventory.ItemStack;
+
+/** Admin-owned, expiring Tail selection with authoritative consume-once restoration. */
+public final class AdminRevival implements Listener, AutoCloseable {
+    public interface PopupFactory { Inventory create(int size, Component title); }
+    public interface Scheduler { AutoCloseable later(Duration delay, Runnable action); }
+    private record Candidate(int slot, ItemStack item, TailBooks.Identity identity) { }
+    private record Choice(Candidate candidate, CharacterRecord record) { }
+    private final CharacterStorage characters; private final RevivalStore reservations; private final Clock clock;
+    private final Consumer<Runnable> nextTick; private final Scheduler scheduler; private final PopupFactory popups;
+    private final Consumer<Throwable> failures; private final TailBooks tails=new TailBooks();private final CharacterSheets sheets=new CharacterSheets();
+    private final Map<Inventory,View> views=new IdentityHashMap<>();private boolean closed;
+
+    private final class View implements AutoCloseable {
+        final Player admin,target;final Inventory inventory;final Map<Integer,Choice> choices;final Instant deadline;final AutoCloseable expiry;boolean selecting,finished;
+        View(Player admin,Player target,Inventory inventory,Map<Integer,Choice> choices,Instant deadline){this.admin=admin;this.target=target;this.inventory=inventory;this.choices=choices;this.deadline=deadline;this.expiry=scheduler.later(Duration.between(clock.instant(),deadline),this::close);}
+        boolean current(){return !closed&&!finished&&admin.isOnline()&&admin.hasPermission(EquipmentAdminCommand.PERMISSION)&&target.isOnline()&&clock.instant().isBefore(deadline);}
+        @Override public void close(){if(finished)return;finished=true;views.remove(inventory,this);inventory.clear();try{expiry.close();}catch(Exception e){report(e);}try{admin.closeInventory();}catch(RuntimeException e){report(e);}}
+    }
+
+    public AdminRevival(CharacterStorage characters,RevivalStore reservations,Clock clock,Consumer<Runnable> nextTick,Scheduler scheduler,PopupFactory popups,Consumer<Throwable> failures){this.characters=Objects.requireNonNull(characters);this.reservations=Objects.requireNonNull(reservations);this.clock=Objects.requireNonNull(clock);this.nextTick=Objects.requireNonNull(nextTick);this.scheduler=Objects.requireNonNull(scheduler);this.popups=Objects.requireNonNull(popups);this.failures=Objects.requireNonNull(failures);}
+
+    public void open(Player admin,Player target,Duration timeout){Objects.requireNonNull(admin);Objects.requireNonNull(target);if(closed||!admin.isOnline()||!admin.hasPermission(EquipmentAdminCommand.PERMISSION)||!target.isOnline()){admin.sendMessage("Admin revival refused: authorization or target is no longer available.");return;}var candidates=candidates(target);if(candidates.isEmpty()){admin.sendMessage("That player has no authentic direct-inventory Tails.");return;}var loads=candidates.stream().map(c->characters.find(c.identity.characterId())).toList();CompletableFuture.allOf(loads.toArray(CompletableFuture[]::new)).whenComplete((ignored,failure)->schedule(()->{if(failure!=null){report(failure);admin.sendMessage("Admin revival could not inspect those Tails safely.");return;}if(closed||!admin.isOnline()||!admin.hasPermission(EquipmentAdminCommand.PERMISSION)||!target.isOnline())return;var choices=new ArrayList<Choice>();for(int i=0;i<candidates.size();i++){var found=loads.get(i).join();if(found.isPresent()&&eligible(found.orElseThrow(),candidates.get(i).identity)&&unchanged(target,candidates.get(i)))choices.add(new Choice(candidates.get(i),found.orElseThrow()));}if(choices.isEmpty()){admin.sendMessage("That player has no current unconsumed Tail.");return;}show(admin,target,choices,timeout);}));}
+    private List<Candidate> candidates(Player target){var result=new ArrayList<Candidate>();for(int slot=0;slot<=40;slot++){if(slot>35&&slot!=40)continue;var item=target.getInventory().getItem(slot);if(item==null||item.isEmpty())continue;var identity=tails.identify(item);if(identity.isPresent())result.add(new Candidate(slot,item.clone(),identity.orElseThrow()));}return List.copyOf(result);}
+    private boolean eligible(CharacterRecord record,TailBooks.Identity id){return record.dead()&&record.id().equals(id.characterId())&&Objects.equals(record.deathId(),id.deathId())&&!record.diedAt().isAfter(clock.instant());}
+    private static boolean unchanged(Player target,Candidate candidate){var item=target.getInventory().getItem(candidate.slot);return item!=null&&item.equals(candidate.item);}
+    private void show(Player admin,Player target,List<Choice> eligible,Duration timeout){int size=Math.min(54,Math.max(9,((eligible.size()+8)/9)*9));var inventory=popups.create(size,Component.text("Choose a Tail for "+target.getName()));var choices=new LinkedHashMap<Integer,Choice>();for(int i=0;i<eligible.size()&&i<size;i++){var choice=eligible.get(i);var item=choice.candidate.item.clone();item.setAmount(1);var meta=item.getItemMeta();meta.lore(List.of(Component.text("Character: "+choice.record.name()),Component.text("Level "+choice.record.level()+" · target slot "+choice.candidate.slot),Component.text("Click to restore this exact death")));item.setItemMeta(meta);inventory.setItem(i,item);choices.put(i,choice);}var view=new View(admin,target,inventory,Map.copyOf(choices),clock.instant().plus(timeout));views.put(inventory,view);admin.openInventory(inventory);}
+
+    @EventHandler(priority=EventPriority.HIGHEST) public void click(org.bukkit.event.inventory.InventoryClickEvent event){var view=views.get(event.getView().getTopInventory());if(view==null)return;event.setCancelled(true);if(event.getWhoClicked()!=view.admin||event.getRawSlot()<0||event.getRawSlot()>=view.inventory.getSize())return;var choice=view.choices.get(event.getRawSlot());if(choice==null||view.selecting)return;view.selecting=true;views.remove(view.inventory,view);view.inventory.clear();view.admin.closeInventory();confirm(view,choice);}
+    @EventHandler(priority=EventPriority.HIGHEST) public void drag(org.bukkit.event.inventory.InventoryDragEvent event){var view=views.get(event.getView().getTopInventory());if(view!=null&&event.getRawSlots().stream().anyMatch(slot->slot<view.inventory.getSize()))event.setCancelled(true);}
+    @EventHandler(priority=EventPriority.MONITOR) public void close(org.bukkit.event.inventory.InventoryCloseEvent event){var view=views.get(event.getView().getTopInventory());if(view!=null&&!view.selecting)view.close();}
+    @EventHandler(priority=EventPriority.MONITOR) public void quit(org.bukkit.event.player.PlayerQuitEvent event){for(var view:List.copyOf(views.values()))if(view.admin==event.getPlayer()||view.target==event.getPlayer())view.close();}
+
+    private void confirm(View view,Choice choice){if(!view.current()||!unchanged(view.target,choice.candidate)){view.close();return;}characters.find(choice.record.id()).whenComplete((found,failure)->schedule(()->{if(failure!=null){report(failure);view.admin.sendMessage("Admin revival could not recheck that Tail; no item changed.");view.close();return;}if(!view.current()||found.isEmpty()||!eligible(found.orElseThrow(),choice.candidate.identity)||!unchanged(view.target,choice.candidate)){view.admin.sendMessage("That Tail selection is stale; no item changed.");view.close();return;}reserve(view,choice.candidate,found.orElseThrow());}));}
+    private void reserve(View view,Candidate candidate,CharacterRecord dead){var source=view.target.getInventory().getItem(candidate.slot);int destination=source.getAmount()==1?-1:emptySlot(view.target,candidate.slot);if(source.getAmount()>1&&destination<0){view.admin.sendMessage("Admin revival needs one empty direct inventory slot to preserve copied Tails.");view.close();return;}var reservation=new RevivalStore.Reservation(UUID.randomUUID(),view.admin.getUniqueId(),view.target.getUniqueId(),dead.id(),dead.deathId(),clock.instant().truncatedTo(ChronoUnit.SECONDS),candidate.slot,source.getAmount(),destination,true);reservations.reserve(reservation).whenComplete((saved,failure)->schedule(()->{if(failure!=null){report(failure);view.admin.sendMessage("Admin revival reservation failed; no item changed.");view.close();return;}if(saved.isEmpty()||!view.current()||!unchanged(view.target,candidate)){view.admin.sendMessage("Admin revival became stale after reservation; no item changed.");view.close();return;}deliver(view,dead,reservation);}));}
+    private static int emptySlot(Player target,int source){for(int slot=0;slot<=40;slot++){if(slot>35&&slot!=40||slot==source)continue;var item=target.getInventory().getItem(slot);if(item==null||item.isEmpty())return slot;}return-1;}
+    private void deliver(View view,CharacterRecord dead,RevivalStore.Reservation reservation){try{var provisional=new CharacterRecord(dead.id(),dead.name(),dead.revision(),dead.stats(),dead.level(),dead.experience(),dead.unspentPoints(),dead.maximumHealth(),dead.learned(),dead.loadout(),dead.cooldowns(),dead.restrictedKills(),false,dead.deathId(),dead.diedAt());var sheet=sheets.create(provisional);var source=view.target.getInventory().getItem(reservation.sourceSlot());if(reservation.sourceAmount()==1)view.target.getInventory().setItem(reservation.sourceSlot(),sheet);else{view.target.getInventory().setItem(reservation.destinationSlot(),sheet);var remaining=source.clone();remaining.setAmount(reservation.sourceAmount()-1);view.target.getInventory().setItem(reservation.sourceSlot(),remaining);}view.target.updateInventory();}catch(RuntimeException uncertain){report(uncertain);view.admin.sendMessage("Admin revival delivery is uncertain; retained proof requires recovery.");view.close();return;}characters.restoreDeathRecordAdministratively(reservation.character(),reservation.death(),NativeHealthLimit.read()).whenComplete((restored,failure)->schedule(()->{if(failure!=null||restored.isEmpty()){if(failure!=null)report(failure);view.admin.sendMessage("The Tail changed, but restoration is pending proof-based recovery.");view.close();return;}if(installFinal(view.target,restored.orElseThrow())){reservations.clear(reservation.character(),reservation.id()).exceptionally(error->{report(error);return false;});view.admin.sendMessage("Administratively restored "+restored.orElseThrow().name()+" for "+view.target.getName()+".");view.target.sendMessage("An administrator restored character sheet: "+restored.orElseThrow().name()+".");}else view.admin.sendMessage("Character restoration was saved, but sheet custody is ambiguous; retained proof requires recovery.");view.close();}));}
+    private boolean installFinal(Player target,CharacterRecord record){int found=-1;for(int slot=0;slot<=40;slot++){if(slot>35&&slot!=40)continue;if(sheets.identify(target.getInventory().getItem(slot)).filter(record.id()::equals).isEmpty())continue;if(found>=0)return false;found=slot;}if(found<0)return false;target.getInventory().setItem(found,sheets.create(record));target.updateInventory();return true;}
+    private void schedule(Runnable action){try{nextTick.accept(action);}catch(RuntimeException rejected){report(rejected);}}
+    private void report(Throwable failure){try{failures.accept(failure);}catch(RuntimeException ignored){}}
+    @Override public void close(){if(closed)return;closed=true;for(var view:List.copyOf(views.values()))view.close();views.clear();}
+}

src/main/java/games/dmg/fantasystick/session/EquipmentAdminCommand.java

@@ -1,6 +1,7 @@
 package games.dmg.fantasystick.session;
 
 import games.dmg.fantasystick.persistence.EquipmentSessionStore;
+import java.math.BigInteger;
 import java.util.List;
 import java.util.Objects;
 import java.util.UUID;
@@ -28,6 +29,37 @@ public final class EquipmentAdminCommand implements TabExecutor, AutoCloseable {
     private games.dmg.fantasystick.ability.Longbow longbow;
     private games.dmg.fantasystick.persistence.QuickstepSettings quickstepSettings;
     private games.dmg.fantasystick.ability.Quickstep quickstep;
+    private games.dmg.fantasystick.persistence.SecondWindSettings secondWindSettings;
+    private games.dmg.fantasystick.ability.SecondWind secondWind;
+    private games.dmg.fantasystick.persistence.StoneSkinSettings stoneSkinSettings;
+    private games.dmg.fantasystick.ability.StoneSkin stoneSkin;
+    private games.dmg.fantasystick.persistence.ShieldBashSettings shieldBashSettings;
+    private games.dmg.fantasystick.ability.ShieldBash shieldBash;
+    private games.dmg.fantasystick.persistence.HexSettings hexSettings;
+    private games.dmg.fantasystick.ability.Hex hex;
+    private games.dmg.fantasystick.persistence.InspireSettings inspireSettings;
+    private games.dmg.fantasystick.ability.Inspire inspire;
+    private games.dmg.fantasystick.persistence.MendingLightSettings mendingLightSettings;
+    private games.dmg.fantasystick.ability.MendingLight mendingLight;
+    private games.dmg.fantasystick.persistence.PurifySettings purifySettings;
+    private games.dmg.fantasystick.ability.Purify purify;
+    private games.dmg.fantasystick.persistence.GuardianBondSettings guardianBondSettings;
+    private games.dmg.fantasystick.ability.GuardianBond guardianBond;
+    private games.dmg.fantasystick.persistence.RallyingCrySettings rallyingCrySettings;
+    private games.dmg.fantasystick.ability.RallyingCry rallyingCry;
+    private games.dmg.fantasystick.persistence.FrostNovaSettings frostNovaSettings;
+    private games.dmg.fantasystick.ability.FrostNova frostNova;
+    private games.dmg.fantasystick.persistence.ChainLightningSettings chainLightningSettings;
+    private games.dmg.fantasystick.ability.ChainLightning chainLightning;
+    private AdminCharacterIssuer characterIssuer;
+    private AdminRevival adminRevival;
+    private AdminExperienceGrant experienceGrant;
+    private games.dmg.fantasystick.persistence.AdminReviveSettings adminReviveSettings;
+    private games.dmg.fantasystick.persistence.SwitchDelaySettings switchDelaySettings;
+    private games.dmg.fantasystick.persistence.RoleplaySettings roleplaySettings;
+    private games.dmg.fantasystick.persistence.PartySettings partySettings;
+    private games.dmg.fantasystick.persistence.SheetResourcePackSettings sheetResourcePackSettings;
+    private games.dmg.fantasystick.presentation.SheetResourcePack sheetResourcePack;
 
     public EquipmentAdminCommand(EquipmentSessionStore receipts, EquipmentSessions sessions, Server server,
                                  Consumer<Runnable> nextTick, Consumer<Failure> diagnostics) {
@@ -86,6 +118,173 @@ public final class EquipmentAdminCommand implements TabExecutor, AutoCloseable {
         this.quickstep = Objects.requireNonNull(quickstep);
     }
 
+    public EquipmentAdminCommand(EquipmentSessionStore receipts, EquipmentSessions sessions, Server server,
+                                 Consumer<Runnable> nextTick, Consumer<Failure> diagnostics,
+                                 games.dmg.fantasystick.persistence.AdventureSettings settings,
+                                 games.dmg.fantasystick.persistence.FrostShardSettings frostSettings,
+                                 games.dmg.fantasystick.ability.FrostShard frostShard,
+                                 games.dmg.fantasystick.persistence.LongbowSettings longbowSettings,
+                                 games.dmg.fantasystick.ability.Longbow longbow,
+                                 games.dmg.fantasystick.persistence.QuickstepSettings quickstepSettings,
+                                 games.dmg.fantasystick.ability.Quickstep quickstep,
+                                 games.dmg.fantasystick.persistence.SecondWindSettings secondWindSettings,
+                                 games.dmg.fantasystick.ability.SecondWind secondWind,
+                                 games.dmg.fantasystick.ability.AbilityRegistry abilities) {
+        this(receipts, sessions, server, nextTick, diagnostics, settings, frostSettings, frostShard,
+            longbowSettings, longbow, quickstepSettings, quickstep, abilities);
+        this.secondWindSettings = Objects.requireNonNull(secondWindSettings);
+        this.secondWind = Objects.requireNonNull(secondWind);
+    }
+
+    public EquipmentAdminCommand(EquipmentSessionStore receipts, EquipmentSessions sessions, Server server,
+                                 Consumer<Runnable> nextTick, Consumer<Failure> diagnostics,
+                                 games.dmg.fantasystick.persistence.AdventureSettings settings,
+                                 games.dmg.fantasystick.persistence.FrostShardSettings frostSettings,
+                                 games.dmg.fantasystick.ability.FrostShard frostShard,
+                                 games.dmg.fantasystick.persistence.LongbowSettings longbowSettings,
+                                 games.dmg.fantasystick.ability.Longbow longbow,
+                                 games.dmg.fantasystick.persistence.QuickstepSettings quickstepSettings,
+                                 games.dmg.fantasystick.ability.Quickstep quickstep,
+                                 games.dmg.fantasystick.persistence.SecondWindSettings secondWindSettings,
+                                 games.dmg.fantasystick.ability.SecondWind secondWind,
+                                 games.dmg.fantasystick.persistence.StoneSkinSettings stoneSkinSettings,
+                                 games.dmg.fantasystick.ability.StoneSkin stoneSkin,
+                                 games.dmg.fantasystick.ability.AbilityRegistry abilities) {
+        this(receipts, sessions, server, nextTick, diagnostics, settings, frostSettings, frostShard,
+            longbowSettings, longbow, quickstepSettings, quickstep, secondWindSettings, secondWind, abilities);
+        this.stoneSkinSettings = Objects.requireNonNull(stoneSkinSettings);
+        this.stoneSkin = Objects.requireNonNull(stoneSkin);
+    }
+
+    public EquipmentAdminCommand(EquipmentSessionStore receipts, EquipmentSessions sessions, Server server,
+                                 Consumer<Runnable> nextTick, Consumer<Failure> diagnostics,
+                                 games.dmg.fantasystick.persistence.AdventureSettings settings,
+                                 games.dmg.fantasystick.persistence.FrostShardSettings frostSettings,
+                                 games.dmg.fantasystick.ability.FrostShard frostShard,
+                                 games.dmg.fantasystick.persistence.LongbowSettings longbowSettings,
+                                 games.dmg.fantasystick.ability.Longbow longbow,
+                                 games.dmg.fantasystick.persistence.QuickstepSettings quickstepSettings,
+                                 games.dmg.fantasystick.ability.Quickstep quickstep,
+                                 games.dmg.fantasystick.persistence.SecondWindSettings secondWindSettings,
+                                 games.dmg.fantasystick.ability.SecondWind secondWind,
+                                 games.dmg.fantasystick.persistence.StoneSkinSettings stoneSkinSettings,
+                                 games.dmg.fantasystick.ability.StoneSkin stoneSkin,
+                                 games.dmg.fantasystick.persistence.ShieldBashSettings shieldBashSettings,
+                                 games.dmg.fantasystick.ability.ShieldBash shieldBash,
+                                 games.dmg.fantasystick.ability.AbilityRegistry abilities) {
+        this(receipts, sessions, server, nextTick, diagnostics, settings, frostSettings, frostShard,
+            longbowSettings, longbow, quickstepSettings, quickstep, secondWindSettings, secondWind,
+            stoneSkinSettings, stoneSkin, abilities);
+        this.shieldBashSettings = Objects.requireNonNull(shieldBashSettings);
+        this.shieldBash = Objects.requireNonNull(shieldBash);
+    }
+
+    public EquipmentAdminCommand(EquipmentSessionStore receipts, EquipmentSessions sessions, Server server,
+                                 Consumer<Runnable> nextTick, Consumer<Failure> diagnostics,
+                                 games.dmg.fantasystick.persistence.AdventureSettings settings,
+                                 games.dmg.fantasystick.persistence.FrostShardSettings frostSettings,
+                                 games.dmg.fantasystick.ability.FrostShard frostShard,
+                                 games.dmg.fantasystick.persistence.LongbowSettings longbowSettings,
+                                 games.dmg.fantasystick.ability.Longbow longbow,
+                                 games.dmg.fantasystick.persistence.QuickstepSettings quickstepSettings,
+                                 games.dmg.fantasystick.ability.Quickstep quickstep,
+                                 games.dmg.fantasystick.persistence.SecondWindSettings secondWindSettings,
+                                 games.dmg.fantasystick.ability.SecondWind secondWind,
+                                 games.dmg.fantasystick.persistence.StoneSkinSettings stoneSkinSettings,
+                                 games.dmg.fantasystick.ability.StoneSkin stoneSkin,
+                                 games.dmg.fantasystick.persistence.ShieldBashSettings shieldBashSettings,
+                                 games.dmg.fantasystick.ability.ShieldBash shieldBash,
+                                 games.dmg.fantasystick.persistence.HexSettings hexSettings,
+                                 games.dmg.fantasystick.ability.Hex hex,
+                                 games.dmg.fantasystick.ability.AbilityRegistry abilities) {
+        this(receipts, sessions, server, nextTick, diagnostics, settings, frostSettings, frostShard,
+            longbowSettings, longbow, quickstepSettings, quickstep, secondWindSettings, secondWind,
+            stoneSkinSettings, stoneSkin, shieldBashSettings, shieldBash, abilities);
+        this.hexSettings = Objects.requireNonNull(hexSettings); this.hex = Objects.requireNonNull(hex);
+    }
+
+    public EquipmentAdminCommand(EquipmentSessionStore receipts, EquipmentSessions sessions, Server server,
+                                 Consumer<Runnable> nextTick, Consumer<Failure> diagnostics,
+                                 games.dmg.fantasystick.persistence.AdventureSettings settings,
+                                 games.dmg.fantasystick.persistence.FrostShardSettings frostSettings,
+                                 games.dmg.fantasystick.ability.FrostShard frostShard,
+                                 games.dmg.fantasystick.persistence.LongbowSettings longbowSettings,
+                                 games.dmg.fantasystick.ability.Longbow longbow,
+                                 games.dmg.fantasystick.persistence.QuickstepSettings quickstepSettings,
+                                 games.dmg.fantasystick.ability.Quickstep quickstep,
+                                 games.dmg.fantasystick.persistence.SecondWindSettings secondWindSettings,
+                                 games.dmg.fantasystick.ability.SecondWind secondWind,
+                                 games.dmg.fantasystick.persistence.StoneSkinSettings stoneSkinSettings,
+                                 games.dmg.fantasystick.ability.StoneSkin stoneSkin,
+                                 games.dmg.fantasystick.persistence.ShieldBashSettings shieldBashSettings,
+                                 games.dmg.fantasystick.ability.ShieldBash shieldBash,
+                                 games.dmg.fantasystick.persistence.HexSettings hexSettings,
+                                 games.dmg.fantasystick.ability.Hex hex,
+                                 games.dmg.fantasystick.persistence.InspireSettings inspireSettings,
+                                 games.dmg.fantasystick.ability.Inspire inspire,
+                                 games.dmg.fantasystick.ability.AbilityRegistry abilities) {
+        this(receipts, sessions, server, nextTick, diagnostics, settings, frostSettings, frostShard,
+            longbowSettings, longbow, quickstepSettings, quickstep, secondWindSettings, secondWind,
+            stoneSkinSettings, stoneSkin, shieldBashSettings, shieldBash, hexSettings, hex, abilities);
+        this.inspireSettings=Objects.requireNonNull(inspireSettings);this.inspire=Objects.requireNonNull(inspire);
+    }
+
+    public void attachMendingLight(games.dmg.fantasystick.persistence.MendingLightSettings settings,
+                                   games.dmg.fantasystick.ability.MendingLight effect) {
+        if (closed || mendingLightSettings != null) throw new IllegalStateException("Mending Light already attached or command closed");
+        mendingLightSettings = Objects.requireNonNull(settings); mendingLight = Objects.requireNonNull(effect);
+    }
+
+    public void attachPurify(games.dmg.fantasystick.persistence.PurifySettings settings,
+                             games.dmg.fantasystick.ability.Purify effect) {
+        if (closed || purifySettings != null) throw new IllegalStateException("Purify already attached or command closed");
+        purifySettings = Objects.requireNonNull(settings); purify = Objects.requireNonNull(effect);
+    }
+
+    public void attachGuardianBond(games.dmg.fantasystick.persistence.GuardianBondSettings settings,
+                                   games.dmg.fantasystick.ability.GuardianBond effect) {
+        if (closed || guardianBondSettings != null) throw new IllegalStateException("Guardian Bond already attached or command closed");
+        guardianBondSettings = Objects.requireNonNull(settings); guardianBond = Objects.requireNonNull(effect);
+    }
+
+    public void attachRallyingCry(games.dmg.fantasystick.persistence.RallyingCrySettings settings,
+                                  games.dmg.fantasystick.ability.RallyingCry effect) {
+        if (closed || rallyingCrySettings != null) throw new IllegalStateException("Rallying Cry already attached or command closed");
+        rallyingCrySettings = Objects.requireNonNull(settings); rallyingCry = Objects.requireNonNull(effect);
+    }
+
+    public void attachFrostNova(games.dmg.fantasystick.persistence.FrostNovaSettings settings,
+                                games.dmg.fantasystick.ability.FrostNova effect) {
+        if (closed || frostNovaSettings != null) throw new IllegalStateException("Frost Nova already attached or command closed");
+        frostNovaSettings = Objects.requireNonNull(settings); frostNova = Objects.requireNonNull(effect);
+    }
+
+    public void attachChainLightning(games.dmg.fantasystick.persistence.ChainLightningSettings settings,
+                                     games.dmg.fantasystick.ability.ChainLightning effect) {
+        if (closed || chainLightningSettings != null) throw new IllegalStateException("Chain Lightning already attached or command closed");
+        chainLightningSettings = Objects.requireNonNull(settings); chainLightning = Objects.requireNonNull(effect);
+    }
+
+    public void attachSwitchDelay(games.dmg.fantasystick.persistence.SwitchDelaySettings settings){if(closed||switchDelaySettings!=null)throw new IllegalStateException("Switch delay already attached or command closed");switchDelaySettings=Objects.requireNonNull(settings);}
+    public void attachRoleplaySettings(games.dmg.fantasystick.persistence.RoleplaySettings settings){if(closed||roleplaySettings!=null)throw new IllegalStateException("Roleplay settings already attached or command closed");roleplaySettings=Objects.requireNonNull(settings);}
+    public void attachPartySettings(games.dmg.fantasystick.persistence.PartySettings settings){if(closed||partySettings!=null)throw new IllegalStateException("Party settings already attached or command closed");partySettings=Objects.requireNonNull(settings);}
+    public void attachSheetResourcePack(games.dmg.fantasystick.persistence.SheetResourcePackSettings settings,games.dmg.fantasystick.presentation.SheetResourcePack delivery){if(closed||sheetResourcePackSettings!=null)throw new IllegalStateException("Sheet resource pack already attached or command closed");sheetResourcePackSettings=Objects.requireNonNull(settings);sheetResourcePack=Objects.requireNonNull(delivery);}
+
+    public void attachExperienceGrant(AdminExperienceGrant grant) {
+        if (closed || experienceGrant != null) throw new IllegalStateException("Experience grant already attached or command closed");
+        experienceGrant = Objects.requireNonNull(grant);
+    }
+
+    public void attachAdminRevival(AdminRevival revival, games.dmg.fantasystick.persistence.AdminReviveSettings settings) {
+        if (closed || adminRevival != null) throw new IllegalStateException("Admin revival already attached or command closed");
+        adminRevival=Objects.requireNonNull(revival);adminReviveSettings=Objects.requireNonNull(settings);
+    }
+
+    public void attachCharacterIssuer(AdminCharacterIssuer issuer) {
+        if (closed || characterIssuer != null) throw new IllegalStateException("Character issuer already attached or command closed");
+        characterIssuer = Objects.requireNonNull(issuer);
+    }
+
     @Override public boolean onCommand(CommandSender sender, Command command, String label, String[] args) {
         if (closed) return true;
         if (!sender.hasPermission(PERMISSION)) {
@@ -96,6 +295,16 @@ public final class EquipmentAdminCommand implements TabExecutor, AutoCloseable {
             configuration(sender, args);
             return true;
         }
+        if (args.length > 0 && args[0].equals("give")) {
+            give(sender, args);
+            return true;
+        }
+        if (args.length > 0 && args[0].equals("revive")) {
+            adminRevive(sender,args);return true;
+        }
+        if (args.length > 0 && args[0].equals("experience")) {
+            experience(sender, args); return true;
+        }
         UUID owner;
         try {
             if (args.length != 2 || !(args[0].equals("inspect") || args[0].equals("recover"))) {
@@ -156,15 +365,127 @@ public final class EquipmentAdminCommand implements TabExecutor, AutoCloseable {
         return true;
     }
 
+    private void experience(CommandSender sender, String[] args) {
+        if (experienceGrant == null || args.length < 4 || !args[1].equals("give")) {
+            sender.sendMessage("Usage: /fantasystick experience give <active-character-name...> <positive-amount>"); return;
+        }
+        BigInteger amount;
+        try { amount = new BigInteger(args[args.length - 1]); }
+        catch (NumberFormatException invalid) {
+            sender.sendMessage("Experience amount is invalid; enter a positive whole number."); return;
+        }
+        if (amount.signum() <= 0) {
+            sender.sendMessage("Experience amount is invalid; enter a positive whole number."); return;
+        }
+        String name = String.join(" ", java.util.Arrays.copyOfRange(args, 2, args.length - 1));
+        if (name.isBlank()) {
+            sender.sendMessage("Usage: /fantasystick experience give <active-character-name...> <positive-amount>"); return;
+        }
+        var matches = sessions.activeCharacters().stream().filter(active -> active.record().name().equals(name)).toList();
+        if (matches.isEmpty()) {
+            sender.sendMessage("Experience grant refused: character '" + name + "' is not active. No fantasy XP changed."); return;
+        }
+        if (matches.size() != 1) {
+            sender.sendMessage("Experience grant refused: active character name '" + name
+                + "' is ambiguous. No fantasy XP changed."); return;
+        }
+        if (!sender.hasPermission(PERMISSION)
+                || sender instanceof org.bukkit.entity.Player player && !player.isOnline()) {
+            sender.sendMessage("Experience grant refused before persistence. No fantasy XP changed."); return;
+        }
+        var target = matches.getFirst();
+        boolean accepted = experienceGrant.grant(target.session(), target.record(), amount, result -> {
+            if (closed || !sender.hasPermission(PERMISSION)
+                    || sender instanceof org.bukkit.entity.Player player && !player.isOnline()) return;
+            sender.sendMessage(switch (result.status()) {
+                case APPLIED -> "Granted " + result.requested() + " fantasy XP to " + result.name()
+                    + "; applied " + result.applied() + " after cap clamping; resulting level " + result.level() + ".";
+                case AT_CAP -> "Granted 0 of requested " + result.requested() + " fantasy XP to " + result.name()
+                    + "; the character is already capped at level " + result.level() + ".";
+                case STALE -> "Experience grant refused: " + result.name()
+                    + " changed concurrently. No grant success was recorded.";
+                case UNAVAILABLE -> "Experience grant refused: " + result.name()
+                    + " is unavailable or dead. No fantasy XP changed.";
+                case FAILED -> "Experience grant failed before acknowledgment for " + result.name()
+                    + "; no success was reported. See server diagnostics.";
+            });
+        });
+        if (!accepted) sender.sendMessage("Experience grant refused: the captured character session changed before persistence. No fantasy XP changed.");
+    }
+
+    private void adminRevive(CommandSender sender,String[] args){if(args.length!=2||args[1].isBlank()||adminRevival==null||!(sender instanceof org.bukkit.entity.Player admin)){sender.sendMessage("Usage: /fantasystick revive <online-player> (an in-game administrator must select the Tail)");return;}var matches=server.getOnlinePlayers().stream().filter(player->player.isOnline()&&player.getName().equalsIgnoreCase(args[1])).toList();if(matches.size()!=1){sender.sendMessage("Admin revival refused: target must name one online player. No item changed.");return;}adminRevival.open(admin,matches.getFirst(),adminReviveSettings.timeout());}
+
+    private void give(CommandSender sender, String[] args) {
+        if (args.length != 2 || args[1].isBlank() || characterIssuer == null) {
+            sender.sendMessage("Usage: /fantasystick give <online-player>"); return;
+        }
+        var matches = server.getOnlinePlayers().stream().filter(player -> player.isOnline()
+            && player.getName().equalsIgnoreCase(args[1])).toList();
+        if (matches.size() != 1) {
+            sender.sendMessage("Character issue refused: target must name one online player. No character or item was created."); return;
+        }
+        var target = matches.getFirst();
+        characterIssuer.issue(target, outcome -> {
+            if (closed || !sender.hasPermission(PERMISSION)
+                    || sender instanceof org.bukkit.entity.Player player && !player.isOnline()) return;
+            sender.sendMessage(switch (outcome) {
+                case DELIVERED -> "Issued one new character sheet to " + target.getName() + ".";
+                case FULL -> "Character issue refused: " + target.getName() + " has no inventory space. No character was created.";
+                case BUSY -> "Character issue refused: another delivery to " + target.getName() + " is pending.";
+                case STALE -> "Character issue refused: target disconnected or the reserved inventory slot changed. No sheet was delivered.";
+                case SAVE_FAILED -> "Character issue failed before delivery; no sheet was delivered. See server diagnostics.";
+                case RETAINED -> "Character issue has ambiguous retained state; no retry was performed. See server diagnostics.";
+            });
+        });
+    }
+
     private void configuration(CommandSender sender, String[] args) {
         if (args.length < 2 || args.length > 3) { configurationUsage(sender); return; }
         if (args[1].equals("adventure-mode")) { adventureConfiguration(sender, args); return; }
+        if (args[1].equals(games.dmg.fantasystick.persistence.SwitchDelaySettings.KEY)) { switchDelayConfiguration(sender,args); return; }
+        if (args[1].equals(games.dmg.fantasystick.persistence.RoleplaySettings.KEY)) { roleplayConfiguration(sender,args); return; }
+        if (args[1].equals(games.dmg.fantasystick.persistence.PartySettings.KEY)) { partyConfiguration(sender,args); return; }
+        if (args[1].equals(games.dmg.fantasystick.persistence.SheetResourcePackSettings.URL_KEY)||args[1].equals(games.dmg.fantasystick.persistence.SheetResourcePackSettings.SHA1_KEY)) { sheetResourcePackConfiguration(sender,args); return; }
+        if (args[1].equals(games.dmg.fantasystick.persistence.AdminReviveSettings.KEY)) { adminReviveConfiguration(sender,args); return; }
         if (longbowSettings != null && games.dmg.fantasystick.persistence.LongbowSettings.keys().contains(args[1])) {
             longbowConfiguration(sender, args); return;
         }
         if (quickstepSettings != null && games.dmg.fantasystick.persistence.QuickstepSettings.keys().contains(args[1])) {
             quickstepConfiguration(sender, args); return;
         }
+        if (secondWindSettings != null && games.dmg.fantasystick.persistence.SecondWindSettings.keys().contains(args[1])) {
+            secondWindConfiguration(sender, args); return;
+        }
+        if (stoneSkinSettings != null && games.dmg.fantasystick.persistence.StoneSkinSettings.keys().contains(args[1])) {
+            stoneSkinConfiguration(sender, args); return;
+        }
+        if (shieldBashSettings != null && games.dmg.fantasystick.persistence.ShieldBashSettings.keys().contains(args[1])) {
+            shieldBashConfiguration(sender, args); return;
+        }
+        if (hexSettings != null && games.dmg.fantasystick.persistence.HexSettings.keys().contains(args[1])) {
+            hexConfiguration(sender, args); return;
+        }
+        if (inspireSettings != null && games.dmg.fantasystick.persistence.InspireSettings.keys().contains(args[1])) {
+            inspireConfiguration(sender, args); return;
+        }
+        if (mendingLightSettings != null && games.dmg.fantasystick.persistence.MendingLightSettings.keys().contains(args[1])) {
+            mendingLightConfiguration(sender, args); return;
+        }
+        if (purifySettings != null && games.dmg.fantasystick.persistence.PurifySettings.keys().contains(args[1])) {
+            purifyConfiguration(sender, args); return;
+        }
+        if (guardianBondSettings != null && games.dmg.fantasystick.persistence.GuardianBondSettings.keys().contains(args[1])) {
+            guardianBondConfiguration(sender, args); return;
+        }
+        if (rallyingCrySettings != null && games.dmg.fantasystick.persistence.RallyingCrySettings.keys().contains(args[1])) {
+            rallyingCryConfiguration(sender, args); return;
+        }
+        if (frostNovaSettings != null && games.dmg.fantasystick.persistence.FrostNovaSettings.keys().contains(args[1])) {
+            frostNovaConfiguration(sender, args); return;
+        }
+        if (chainLightningSettings != null && games.dmg.fantasystick.persistence.ChainLightningSettings.keys().contains(args[1])) {
+            chainLightningConfiguration(sender, args); return;
+        }
         if (frostSettings == null || !games.dmg.fantasystick.persistence.FrostShardSettings.keys().contains(args[1])) {
             configurationUsage(sender); return;
         }
@@ -262,6 +583,271 @@ public final class EquipmentAdminCommand implements TabExecutor, AutoCloseable {
         });
     }
 
+    private void inspireConfiguration(CommandSender sender,String[] args){String key=args[1];if(args.length==2){sender.sendMessage(key+"="+inspireSettings.value(key)+" (applies to future Inspire casts only)");return;}java.util.concurrent.CompletionStage<games.dmg.fantasystick.persistence.InspireSettings.Update> operation;try{operation=inspireSettings.set(key,args[2]);}catch(IllegalArgumentException invalid){sender.sendMessage("Inspire setting is invalid; the effective value is unchanged.");return;}operation.whenComplete((saved,failure)->{if(failure!=null)report(null,"config-"+key,failure);if(closed)return;try{nextTick.accept(()->{if(closed)return;if(failure==null){inspire.configure(saved.settings());abilities.replace(inspire.definition());inspireSettings.publish(saved);}if(!sender.hasPermission(PERMISSION)||sender instanceof org.bukkit.entity.Player player&&!player.isOnline())return;sender.sendMessage(failure==null?"Saved "+key+"="+saved.value()+" for future Inspire casts; active effects and deadlines are unchanged.":"Inspire configuration save failed; the effective setting is unchanged.");});}catch(RuntimeException rejected){report(null,"config-response",rejected);}});}
+
+    private void mendingLightConfiguration(CommandSender sender, String[] args) {
+        String key = args[1];
+        if (args.length == 2) {
+            sender.sendMessage(key + "=" + mendingLightSettings.value(key) + " (applies to future Mending Light casts only)");
+            return;
+        }
+        java.util.concurrent.CompletionStage<games.dmg.fantasystick.persistence.MendingLightSettings.Update> operation;
+        try { operation = mendingLightSettings.set(key, args[2]); }
+        catch (IllegalArgumentException invalid) {
+            sender.sendMessage("Mending Light setting is invalid; the effective value is unchanged."); return;
+        }
+        operation.whenComplete((saved, failure) -> {
+            if (failure != null) report(null, "config-" + key, failure);
+            if (closed) return;
+            try { nextTick.accept(() -> {
+                if (closed) return;
+                if (failure == null) {
+                    mendingLight.configure(saved.settings()); abilities.replace(mendingLight.definition()); mendingLightSettings.publish(saved);
+                }
+                if (!sender.hasPermission(PERMISSION)
+                        || sender instanceof org.bukkit.entity.Player player && !player.isOnline()) return;
+                sender.sendMessage(failure == null
+                    ? "Saved " + key + "=" + saved.value() + " for future Mending Light casts; active work and deadlines are unchanged."
+                    : "Mending Light configuration save failed; the effective setting is unchanged.");
+            }); } catch (RuntimeException rejected) { report(null, "config-response", rejected); }
+        });
+    }
+
+    private void purifyConfiguration(CommandSender sender, String[] args) {
+        String key = args[1];
+        if (args.length == 2) {
+            sender.sendMessage(key + "=" + purifySettings.value(key) + " (applies to future Purify casts only)"); return;
+        }
+        java.util.concurrent.CompletionStage<games.dmg.fantasystick.persistence.PurifySettings.Update> operation;
+        try { operation = purifySettings.set(key, args[2]); }
+        catch (IllegalArgumentException invalid) {
+            sender.sendMessage("Purify setting is invalid; the effective value is unchanged."); return;
+        }
+        operation.whenComplete((saved, failure) -> {
+            if (failure != null) report(null, "config-" + key, failure);
+            if (closed) return;
+            try { nextTick.accept(() -> {
+                if (closed) return;
+                if (failure == null) {
+                    purify.configure(saved.settings()); abilities.replace(purify.definition()); purifySettings.publish(saved);
+                }
+                if (!sender.hasPermission(PERMISSION)
+                        || sender instanceof org.bukkit.entity.Player player && !player.isOnline()) return;
+                sender.sendMessage(failure == null
+                    ? "Saved " + key + "=" + saved.value() + " for future Purify casts; active work and deadlines are unchanged."
+                    : "Purify configuration save failed; the effective setting is unchanged.");
+            }); } catch (RuntimeException rejected) { report(null, "config-response", rejected); }
+        });
+    }
+
+    private void guardianBondConfiguration(CommandSender sender, String[] args) {
+        String key = args[1];
+        if (args.length == 2) {
+            sender.sendMessage(key + "=" + guardianBondSettings.value(key) + " (applies to future Guardian Bond casts only)"); return;
+        }
+        java.util.concurrent.CompletionStage<games.dmg.fantasystick.persistence.GuardianBondSettings.Update> operation;
+        try { operation = guardianBondSettings.set(key, args[2]); }
+        catch (IllegalArgumentException invalid) {
+            sender.sendMessage("Guardian Bond setting is invalid; the effective value is unchanged."); return;
+        }
+        operation.whenComplete((saved, failure) -> {
+            if (failure != null) report(null, "config-" + key, failure);
+            if (closed) return;
+            try { nextTick.accept(() -> {
+                if (closed) return;
+                if (failure == null) {
+                    guardianBond.configure(saved.settings()); abilities.replace(guardianBond.definition()); guardianBondSettings.publish(saved);
+                }
+                if (!sender.hasPermission(PERMISSION)
+                        || sender instanceof org.bukkit.entity.Player player && !player.isOnline()) return;
+                sender.sendMessage(failure == null
+                    ? "Saved " + key + "=" + saved.value() + " for future Guardian Bond casts; active bonds and deadlines are unchanged."
+                    : "Guardian Bond configuration save failed; the effective setting is unchanged.");
+            }); } catch (RuntimeException rejected) { report(null, "config-response", rejected); }
+        });
+    }
+
+    private void rallyingCryConfiguration(CommandSender sender, String[] args) {
+        String key = args[1];
+        if (args.length == 2) {
+            sender.sendMessage(key + "=" + rallyingCrySettings.value(key) + " (applies to future Rallying Cry casts only)"); return;
+        }
+        java.util.concurrent.CompletionStage<games.dmg.fantasystick.persistence.RallyingCrySettings.Update> operation;
+        try { operation = rallyingCrySettings.set(key, args[2]); }
+        catch (IllegalArgumentException invalid) {
+            sender.sendMessage("Rallying Cry setting is invalid; the effective value is unchanged."); return;
+        }
+        operation.whenComplete((saved, failure) -> {
+            if (failure != null) report(null, "config-" + key, failure);
+            if (closed) return;
+            try { nextTick.accept(() -> {
+                if (closed) return;
+                if (failure == null) {
+                    rallyingCry.configure(saved.settings()); abilities.replace(rallyingCry.definition()); rallyingCrySettings.publish(saved);
+                }
+                if (!sender.hasPermission(PERMISSION)
+                        || sender instanceof org.bukkit.entity.Player player && !player.isOnline()) return;
+                sender.sendMessage(failure == null
+                    ? "Saved " + key + "=" + saved.value() + " for future Rallying Cry casts; active cries and deadlines are unchanged."
+                    : "Rallying Cry configuration save failed; the effective setting is unchanged.");
+            }); } catch (RuntimeException rejected) { report(null, "config-response", rejected); }
+        });
+    }
+
+    private void frostNovaConfiguration(CommandSender sender, String[] args) {
+        String key = args[1];
+        if (args.length == 2) {
+            sender.sendMessage(key + "=" + frostNovaSettings.value(key) + " (applies to future Frost Nova casts only)"); return;
+        }
+        java.util.concurrent.CompletionStage<games.dmg.fantasystick.persistence.FrostNovaSettings.Update> operation;
+        try { operation = frostNovaSettings.set(key, args[2]); }
+        catch (IllegalArgumentException invalid) {
+            sender.sendMessage("Frost Nova setting is invalid; the effective value is unchanged."); return;
+        }
+        operation.whenComplete((saved, failure) -> {
+            if (failure != null) report(null, "config-" + key, failure);
+            if (closed) return;
+            try { nextTick.accept(() -> {
+                if (closed) return;
+                if (failure == null) {
+                    frostNova.configure(saved.settings()); abilities.replace(frostNova.definition()); frostNovaSettings.publish(saved);
+                }
+                if (!sender.hasPermission(PERMISSION)
+                        || sender instanceof org.bukkit.entity.Player player && !player.isOnline()) return;
+                sender.sendMessage(failure == null
+                    ? "Saved " + key + "=" + saved.value() + " for future Frost Nova casts; active slows and deadlines are unchanged."
+                    : "Frost Nova configuration save failed; the effective setting is unchanged.");
+            }); } catch (RuntimeException rejected) { report(null, "config-response", rejected); }
+        });
+    }
+
+    private void chainLightningConfiguration(CommandSender sender, String[] args) {
+        String key = args[1];
+        if (args.length == 2) {
+            sender.sendMessage(key + "=" + chainLightningSettings.value(key) + " (applies to future Chain Lightning casts only)"); return;
+        }
+        java.util.concurrent.CompletionStage<games.dmg.fantasystick.persistence.ChainLightningSettings.Update> operation;
+        try { operation = chainLightningSettings.set(key, args[2]); }
+        catch (IllegalArgumentException invalid) {
+            sender.sendMessage("Chain Lightning setting is invalid; the effective value is unchanged."); return;
+        }
+        operation.whenComplete((saved, failure) -> {
+            if (failure != null) report(null, "config-" + key, failure);
+            if (closed) return;
+            try { nextTick.accept(() -> {
+                if (closed) return;
+                if (failure == null) {
+                    chainLightning.configure(saved.settings()); abilities.replace(chainLightning.definition()); chainLightningSettings.publish(saved);
+                }
+                if (!sender.hasPermission(PERMISSION)
+                        || sender instanceof org.bukkit.entity.Player player && !player.isOnline()) return;
+                sender.sendMessage(failure == null
+                    ? "Saved " + key + "=" + saved.value() + " for future Chain Lightning casts; active chains and deadlines are unchanged."
+                    : "Chain Lightning configuration save failed; the effective setting is unchanged.");
+            }); } catch (RuntimeException rejected) { report(null, "config-response", rejected); }
+        });
+    }
+
+    private void hexConfiguration(CommandSender sender, String[] args) {
+        String key=args[1];if(args.length==2){sender.sendMessage(key+"="+hexSettings.value(key)+" (applies to future Hex casts only)");return;}
+        java.util.concurrent.CompletionStage<games.dmg.fantasystick.persistence.HexSettings.Update> operation;
+        try{operation=hexSettings.set(key,args[2]);}catch(IllegalArgumentException invalid){sender.sendMessage("Hex setting is invalid; the effective value is unchanged.");return;}
+        operation.whenComplete((saved,failure)->{if(failure!=null)report(null,"config-"+key,failure);if(closed)return;
+            try{nextTick.accept(()->{if(closed)return;if(failure==null){hex.configure(saved.settings());abilities.replace(hex.definition());hexSettings.publish(saved);}
+                if(!sender.hasPermission(PERMISSION)||sender instanceof org.bukkit.entity.Player player&&!player.isOnline())return;
+                sender.sendMessage(failure==null?"Saved "+key+"="+saved.value()+" for future Hex casts; active effects and deadlines are unchanged."
+                    :"Hex configuration save failed; the effective setting is unchanged.");});}catch(RuntimeException rejected){report(null,"config-response",rejected);}});
+    }
+
+    private void shieldBashConfiguration(CommandSender sender, String[] args) {
+        String key = args[1];
+        if (args.length == 2) { sender.sendMessage(key + "=" + shieldBashSettings.value(key) + " (applies to future Shield Bash strikes only)"); return; }
+        java.util.concurrent.CompletionStage<games.dmg.fantasystick.persistence.ShieldBashSettings.Update> operation;
+        try { operation = shieldBashSettings.set(key, args[2]); }
+        catch (IllegalArgumentException invalid) { sender.sendMessage("Shield Bash setting is invalid; the effective value is unchanged."); return; }
+        operation.whenComplete((saved, failure) -> {
+            if (failure != null) report(null, "config-" + key, failure);
+            if (closed) return;
+            try { nextTick.accept(() -> {
+                if (closed) return;
+                if (failure == null) {
+                    shieldBash.configure(saved.settings()); abilities.replace(shieldBash.definition()); shieldBashSettings.publish(saved);
+                }
+                if (!sender.hasPermission(PERMISSION)
+                        || sender instanceof org.bukkit.entity.Player player && !player.isOnline()) return;
+                sender.sendMessage(failure == null
+                    ? "Saved " + key + "=" + saved.value() + " for future Shield Bash strikes; active work and deadlines are unchanged."
+                    : "Shield Bash configuration save failed; the effective setting is unchanged.");
+            }); } catch (RuntimeException rejected) { report(null, "config-response", rejected); }
+        });
+    }
+
+    private void stoneSkinConfiguration(CommandSender sender, String[] args) {
+        String key = args[1];
+        if (args.length == 2) {
+            sender.sendMessage(key + "=" + stoneSkinSettings.value(key) + " (applies to future Stone Skin casts only)"); return;
+        }
+        java.util.concurrent.CompletionStage<games.dmg.fantasystick.persistence.StoneSkinSettings.Update> operation;
+        try { operation = stoneSkinSettings.set(key, args[2]); }
+        catch (IllegalArgumentException invalid) { sender.sendMessage("Stone Skin setting is invalid; the effective value is unchanged."); return; }
+        operation.whenComplete((saved, failure) -> {
+            if (failure != null) report(null, "config-" + key, failure);
+            if (closed) return;
+            try { nextTick.accept(() -> {
+                if (closed) return;
+                if (failure == null) {
+                    stoneSkin.configure(saved.settings()); abilities.replace(stoneSkin.definition()); stoneSkinSettings.publish(saved);
+                }
+                if (!sender.hasPermission(PERMISSION)
+                        || sender instanceof org.bukkit.entity.Player player && !player.isOnline()) return;
+                sender.sendMessage(failure == null
+                    ? "Saved " + key + "=" + saved.value() + " for future Stone Skin casts; active effects and deadlines are unchanged."
+                    : "Stone Skin configuration save failed; the effective setting is unchanged.");
+            }); } catch (RuntimeException rejected) { report(null, "config-response", rejected); }
+        });
+    }
+
+    private void secondWindConfiguration(CommandSender sender, String[] args) {
+        String key = args[1];
+        if (args.length == 2) {
+            sender.sendMessage(key + "=" + secondWindSettings.value(key) + " (applies to future Second Wind casts only)");
+            return;
+        }
+        java.util.concurrent.CompletionStage<games.dmg.fantasystick.persistence.SecondWindSettings.Update> operation;
+        try { operation = secondWindSettings.set(key, args[2]); }
+        catch (IllegalArgumentException invalid) {
+            sender.sendMessage("Second Wind setting is invalid; the effective value is unchanged."); return;
+        }
+        operation.whenComplete((saved, failure) -> {
+            if (failure != null) report(null, "config-" + key, failure);
+            if (closed) return;
+            try {
+                nextTick.accept(() -> {
+                    if (closed) return;
+                    if (failure == null) {
+                        secondWind.configure(saved.settings()); abilities.replace(secondWind.definition());
+                        secondWindSettings.publish(saved);
+                    }
+                    if (!sender.hasPermission(PERMISSION)
+                            || sender instanceof org.bukkit.entity.Player player && !player.isOnline()) return;
+                    sender.sendMessage(failure == null
+                        ? "Saved " + key + "=" + saved.value() + " for future Second Wind casts; active work and deadlines are unchanged."
+                        : "Second Wind configuration save failed; the effective setting is unchanged.");
+                });
+            } catch (RuntimeException rejected) { report(null, "config-response", rejected); }
+        });
+    }
+
+    private void sheetResourcePackConfiguration(CommandSender sender,String[] args){if(sheetResourcePackSettings==null){configurationUsage(sender);return;}String key=args[1];if(args.length==2){sender.sendMessage(key+"="+sheetResourcePackSettings.value(key));return;}java.util.concurrent.CompletionStage<games.dmg.fantasystick.persistence.SheetResourcePackSettings.Update> operation;try{operation=sheetResourcePackSettings.set(key,args[2]);}catch(IllegalArgumentException invalid){sender.sendMessage("Sheet resource-pack value is invalid; use an absolute HTTPS URL or 40 hexadecimal SHA-1 characters.");return;}operation.whenComplete((saved,failure)->{if(failure!=null)report(null,"config-sheet-resource-pack",failure);if(closed)return;try{nextTick.accept(()->{if(closed)return;boolean applied=false;if(failure==null){applied=sheetResourcePackSettings.publish(saved);if(applied)sheetResourcePack.deliverAll(server.getOnlinePlayers());}if(!sender.hasPermission(PERMISSION)||sender instanceof org.bukkit.entity.Player player&&!player.isOnline())return;if(failure!=null)sender.sendMessage("Sheet resource-pack configuration save failed; effective values are unchanged.");else if(!applied)sender.sendMessage("Saved request was superseded; effective "+key+"="+sheetResourcePackSettings.value(key)+".");else sender.sendMessage("Saved "+key+"="+sheetResourcePackSettings.value(key)+"; optional delivery was requested for online players.");});}catch(RuntimeException rejected){report(null,"config-response",rejected);}});}
+
+    private void partyConfiguration(CommandSender sender,String[] args){if(partySettings==null){configurationUsage(sender);return;}if(args.length==2){sender.sendMessage(games.dmg.fantasystick.persistence.PartySettings.KEY+"="+partySettings.value()+" (existing parties are retained)");return;}java.util.concurrent.CompletionStage<games.dmg.fantasystick.persistence.PartySettings.Update> operation;try{operation=partySettings.set(args[2]);}catch(IllegalArgumentException invalid){sender.sendMessage("Party maximum is invalid; enter a positive whole number.");return;}operation.whenComplete((saved,failure)->{if(failure!=null)report(null,"config-party",failure);if(closed)return;try{nextTick.accept(()->{if(closed)return;boolean applied=false;if(failure==null)applied=partySettings.publish(saved);if(!sender.hasPermission(PERMISSION)||sender instanceof org.bukkit.entity.Player player&&!player.isOnline())return;if(failure!=null)sender.sendMessage("Party configuration save failed; the effective limit and rosters are unchanged.");else if(!applied)sender.sendMessage("Saved request was superseded; effective "+games.dmg.fantasystick.persistence.PartySettings.KEY+"="+partySettings.value()+".");else sender.sendMessage("Saved "+games.dmg.fantasystick.persistence.PartySettings.KEY+"="+saved.value()+"; existing members are retained.");});}catch(RuntimeException rejected){report(null,"config-response",rejected);}});}
+
+    private void roleplayConfiguration(CommandSender sender,String[] args){if(roleplaySettings==null){configurationUsage(sender);return;}if(args.length==2){sender.sendMessage(games.dmg.fantasystick.persistence.RoleplaySettings.KEY+"="+roleplaySettings.value());return;}java.util.concurrent.CompletionStage<games.dmg.fantasystick.persistence.RoleplaySettings.Update> operation;try{operation=roleplaySettings.set(args[2]);}catch(IllegalArgumentException invalid){sender.sendMessage("Usage: /fantasystick config roleplay-disabled [true|false]");return;}operation.whenComplete((saved,failure)->{if(failure!=null)report(null,"config-roleplay",failure);if(closed)return;try{nextTick.accept(()->{if(closed)return;boolean applied=false;if(failure==null){applied=roleplaySettings.publish(saved);if(applied&&saved.disabled())sessions.disableRoleplay();}if(!sender.hasPermission(PERMISSION)||sender instanceof org.bukkit.entity.Player player&&!player.isOnline())return;if(failure!=null)sender.sendMessage("Roleplay configuration save failed; policy and sessions are unchanged.");else if(!applied)sender.sendMessage("Saved request was superseded; effective "+games.dmg.fantasystick.persistence.RoleplaySettings.KEY+"="+roleplaySettings.value()+".");else sender.sendMessage("Saved "+games.dmg.fantasystick.persistence.RoleplaySettings.KEY+"="+saved.disabled()+(saved.disabled()?"; ordinary exits were requested for active sessions.":"; normal sheet activation is available."));});}catch(RuntimeException rejected){report(null,"config-response",rejected);}});}
+
+    private void switchDelayConfiguration(CommandSender sender,String[] args){if(switchDelaySettings==null){configurationUsage(sender);return;}if(args.length==2){sender.sendMessage(games.dmg.fantasystick.persistence.SwitchDelaySettings.KEY+"="+switchDelaySettings.value()+" (new exits use this delay; existing deadlines are unchanged)");return;}java.util.concurrent.CompletionStage<games.dmg.fantasystick.persistence.SwitchDelaySettings.Update> operation;try{operation=switchDelaySettings.set(args[2]);}catch(IllegalArgumentException invalid){sender.sendMessage("Character switch delay is invalid; the effective value is unchanged.");return;}operation.whenComplete((saved,failure)->{if(failure!=null)report(null,"config-switch-delay",failure);if(closed)return;try{nextTick.accept(()->{if(closed)return;if(failure==null)switchDelaySettings.publish(saved);if(!sender.hasPermission(PERMISSION)||sender instanceof org.bukkit.entity.Player player&&!player.isOnline())return;sender.sendMessage(failure==null?"Saved "+games.dmg.fantasystick.persistence.SwitchDelaySettings.KEY+"="+saved.value()+"; new exits use it and existing deadlines are unchanged.":"Character switch delay save failed; the effective value is unchanged.");});}catch(RuntimeException rejected){report(null,"config-response",rejected);}});}
+
+    private void adminReviveConfiguration(CommandSender sender,String[] args){if(adminReviveSettings==null){configurationUsage(sender);return;}if(args.length==2){sender.sendMessage(games.dmg.fantasystick.persistence.AdminReviveSettings.KEY+"="+adminReviveSettings.value()+" (applies to later admin revival selections only)");return;}java.util.concurrent.CompletionStage<games.dmg.fantasystick.persistence.AdminReviveSettings.Update> operation;try{operation=adminReviveSettings.set(args[2]);}catch(IllegalArgumentException invalid){sender.sendMessage("Admin revival timeout is invalid; the effective value is unchanged.");return;}operation.whenComplete((saved,failure)->{if(failure!=null)report(null,"config-admin-revive",failure);if(closed)return;try{nextTick.accept(()->{if(closed)return;if(failure==null)adminReviveSettings.publish(saved);if(!sender.hasPermission(PERMISSION)||sender instanceof org.bukkit.entity.Player player&&!player.isOnline())return;sender.sendMessage(failure==null?"Saved "+games.dmg.fantasystick.persistence.AdminReviveSettings.KEY+"="+saved.value()+" for later selections; open selections retain their deadline.":"Admin revival configuration save failed; the effective setting is unchanged.");});}catch(RuntimeException rejected){report(null,"config-response",rejected);}});}
+
     private void adventureConfiguration(CommandSender sender, String[] args) {
         if (args.length == 3 && !args[2].equals("true") && !args[2].equals("false")) {
             sender.sendMessage("Usage: /fantasystick config adventure-mode [true|false]"); return;
@@ -294,19 +880,43 @@ public final class EquipmentAdminCommand implements TabExecutor, AutoCloseable {
         catch (RuntimeException ignored) { /* Diagnostics cannot authorize recovery. */ }
     }
 
-    // Never fall back to Bukkit's online-player-name suggestions for a UUID-only admin interface.
+    // Return only explicit implemented routes; never fall back to Bukkit's broad default suggestions.
     @Override public List<String> onTabComplete(CommandSender sender, Command command, String alias, String[] args) {
         if (closed || !sender.hasPermission(PERMISSION)) return List.of();
-        if (args.length == 1) return matching(List.of("config", "inspect", "recover"), args[0]);
+        if (args.length == 1) return matching(sender instanceof org.bukkit.entity.Player
+            ? List.of("config", "experience", "give", "inspect", "recover", "revive") : List.of("config", "experience", "give", "inspect", "recover"), args[0]);
+        if (args.length == 2 && args[0].equals("experience")) return matching(List.of("give"), args[1]);
+        if (args.length >= 3 && args[0].equals("experience") && args[1].equals("give")) return experienceNames(args);
+        if (args.length == 2 && (args[0].equals("inspect") || args[0].equals("recover"))) return matching(
+            server.getOnlinePlayers().stream().filter(org.bukkit.entity.Player::isOnline)
+                .map(player -> player.getUniqueId().toString()).toList(), args[1]);
+        if (args.length == 2 && (args[0].equals("give") || args[0].equals("revive") && sender instanceof org.bukkit.entity.Player)) return matching(server.getOnlinePlayers().stream()
+            .filter(org.bukkit.entity.Player::isOnline).map(org.bukkit.entity.Player::getName).toList(), args[1]);
         if (args.length == 2 && args[0].equals("config")) {
-            var keys = new java.util.ArrayList<String>(); keys.add("adventure-mode");
+            var keys = new java.util.ArrayList<String>(); keys.add("adventure-mode");keys.add(games.dmg.fantasystick.persistence.AdminReviveSettings.KEY);keys.add(games.dmg.fantasystick.persistence.SwitchDelaySettings.KEY);keys.add(games.dmg.fantasystick.persistence.RoleplaySettings.KEY);keys.add(games.dmg.fantasystick.persistence.PartySettings.KEY);keys.add(games.dmg.fantasystick.persistence.SheetResourcePackSettings.URL_KEY);keys.add(games.dmg.fantasystick.persistence.SheetResourcePackSettings.SHA1_KEY);
             keys.addAll(games.dmg.fantasystick.persistence.FrostShardSettings.keys());
             keys.addAll(games.dmg.fantasystick.persistence.LongbowSettings.keys());
             keys.addAll(games.dmg.fantasystick.persistence.QuickstepSettings.keys());
+            keys.addAll(games.dmg.fantasystick.persistence.SecondWindSettings.keys());
+            keys.addAll(games.dmg.fantasystick.persistence.StoneSkinSettings.keys());
+            keys.addAll(games.dmg.fantasystick.persistence.ShieldBashSettings.keys());
+            keys.addAll(games.dmg.fantasystick.persistence.HexSettings.keys());
+            keys.addAll(games.dmg.fantasystick.persistence.InspireSettings.keys());
+            keys.addAll(games.dmg.fantasystick.persistence.MendingLightSettings.keys());
+            keys.addAll(games.dmg.fantasystick.persistence.PurifySettings.keys());
+            keys.addAll(games.dmg.fantasystick.persistence.GuardianBondSettings.keys());
+            keys.addAll(games.dmg.fantasystick.persistence.RallyingCrySettings.keys());
+            keys.addAll(games.dmg.fantasystick.persistence.FrostNovaSettings.keys());
+            keys.addAll(games.dmg.fantasystick.persistence.ChainLightningSettings.keys());
             return matching(keys, args[1]);
         }
         if (args.length == 3 && args[0].equals("config")) {
             if (args[1].equals("adventure-mode")) return matching(List.of("false", "true"), args[2]);
+            if(args[1].equals(games.dmg.fantasystick.persistence.AdminReviveSettings.KEY)&&adminReviveSettings!=null){String current=adminReviveSettings.value();return matching(current.equals(games.dmg.fantasystick.persistence.AdminReviveSettings.DEFAULT)?List.of(current):List.of(current,games.dmg.fantasystick.persistence.AdminReviveSettings.DEFAULT),args[2]);}
+            if(args[1].equals(games.dmg.fantasystick.persistence.SwitchDelaySettings.KEY)&&switchDelaySettings!=null){String current=switchDelaySettings.value();return matching(current.equals(games.dmg.fantasystick.persistence.SwitchDelaySettings.DEFAULT)?List.of(current):List.of(current,games.dmg.fantasystick.persistence.SwitchDelaySettings.DEFAULT),args[2]);}
+            if(args[1].equals(games.dmg.fantasystick.persistence.RoleplaySettings.KEY)&&roleplaySettings!=null)return matching(List.of("false","true"),args[2]);
+            if(args[1].equals(games.dmg.fantasystick.persistence.PartySettings.KEY)&&partySettings!=null){String current=partySettings.value();return matching(current.equals(games.dmg.fantasystick.persistence.PartySettings.DEFAULT)?List.of(current):List.of(current,games.dmg.fantasystick.persistence.PartySettings.DEFAULT),args[2]);}
+            if(sheetResourcePackSettings!=null&&(args[1].equals(games.dmg.fantasystick.persistence.SheetResourcePackSettings.URL_KEY)||args[1].equals(games.dmg.fantasystick.persistence.SheetResourcePackSettings.SHA1_KEY)))return matching(List.of(sheetResourcePackSettings.value(args[1])),args[2]);
             if (frostSettings != null && games.dmg.fantasystick.persistence.FrostShardSettings.keys().contains(args[1])) {
                 String current = frostSettings.value(args[1]);
                 String defaults = games.dmg.fantasystick.persistence.FrostShardSettings.defaultValue(args[1]);
@@ -322,12 +932,76 @@ public final class EquipmentAdminCommand implements TabExecutor, AutoCloseable {
                 String defaults = games.dmg.fantasystick.persistence.QuickstepSettings.defaultValue(args[1]);
                 return matching(current.equals(defaults) ? List.of(current) : List.of(current, defaults), args[2]);
             }
+            if (secondWindSettings != null && games.dmg.fantasystick.persistence.SecondWindSettings.keys().contains(args[1])) {
+                String current = secondWindSettings.value(args[1]);
+                String defaults = games.dmg.fantasystick.persistence.SecondWindSettings.defaultValue(args[1]);
+                return matching(current.equals(defaults) ? List.of(current) : List.of(current, defaults), args[2]);
+            }
+            if (stoneSkinSettings != null && games.dmg.fantasystick.persistence.StoneSkinSettings.keys().contains(args[1])) {
+                String current = stoneSkinSettings.value(args[1]);
+                String defaults = games.dmg.fantasystick.persistence.StoneSkinSettings.defaultValue(args[1]);
+                return matching(current.equals(defaults) ? List.of(current) : List.of(current, defaults), args[2]);
+            }
+            if (shieldBashSettings != null && games.dmg.fantasystick.persistence.ShieldBashSettings.keys().contains(args[1])) {
+                String current = shieldBashSettings.value(args[1]);
+                String defaults = games.dmg.fantasystick.persistence.ShieldBashSettings.defaultValue(args[1]);
+                return matching(current.equals(defaults) ? List.of(current) : List.of(current, defaults), args[2]);
+            }
+            if (hexSettings != null && games.dmg.fantasystick.persistence.HexSettings.keys().contains(args[1])) {
+                String current = hexSettings.value(args[1]); String defaults = games.dmg.fantasystick.persistence.HexSettings.defaultValue(args[1]);
+                return matching(current.equals(defaults) ? List.of(current) : List.of(current, defaults), args[2]);
+            }
+            if(inspireSettings!=null&&games.dmg.fantasystick.persistence.InspireSettings.keys().contains(args[1])){String current=inspireSettings.value(args[1]);String defaults=games.dmg.fantasystick.persistence.InspireSettings.defaultValue(args[1]);return matching(current.equals(defaults)?List.of(current):List.of(current,defaults),args[2]);}
+            if (mendingLightSettings != null && games.dmg.fantasystick.persistence.MendingLightSettings.keys().contains(args[1])) {
+                String current = mendingLightSettings.value(args[1]);
+                String defaults = games.dmg.fantasystick.persistence.MendingLightSettings.defaultValue(args[1]);
+                return matching(current.equals(defaults) ? List.of(current) : List.of(current, defaults), args[2]);
+            }
+            if (purifySettings != null && games.dmg.fantasystick.persistence.PurifySettings.keys().contains(args[1])) {
+                String current = purifySettings.value(args[1]);
+                String defaults = games.dmg.fantasystick.persistence.PurifySettings.defaultValue(args[1]);
+                return matching(current.equals(defaults) ? List.of(current) : List.of(current, defaults), args[2]);
+            }
+            if (guardianBondSettings != null
+                    && games.dmg.fantasystick.persistence.GuardianBondSettings.keys().contains(args[1])) {
+                String current = guardianBondSettings.value(args[1]);
+                String defaults = games.dmg.fantasystick.persistence.GuardianBondSettings.defaultValue(args[1]);
+                return matching(current.equals(defaults) ? List.of(current) : List.of(current, defaults), args[2]);
+            }
+            if (rallyingCrySettings != null
+                    && games.dmg.fantasystick.persistence.RallyingCrySettings.keys().contains(args[1])) {
+                String current = rallyingCrySettings.value(args[1]);
+                String defaults = games.dmg.fantasystick.persistence.RallyingCrySettings.defaultValue(args[1]);
+                return matching(current.equals(defaults) ? List.of(current) : List.of(current, defaults), args[2]);
+            }
+            if (frostNovaSettings != null
+                    && games.dmg.fantasystick.persistence.FrostNovaSettings.keys().contains(args[1])) {
+                String current = frostNovaSettings.value(args[1]);
+                String defaults = games.dmg.fantasystick.persistence.FrostNovaSettings.defaultValue(args[1]);
+                return matching(current.equals(defaults) ? List.of(current) : List.of(current, defaults), args[2]);
+            }
+            if (chainLightningSettings != null
+                    && games.dmg.fantasystick.persistence.ChainLightningSettings.keys().contains(args[1])) {
+                String current = chainLightningSettings.value(args[1]);
+                String defaults = games.dmg.fantasystick.persistence.ChainLightningSettings.defaultValue(args[1]);
+                return matching(current.equals(defaults) ? List.of(current) : List.of(current, defaults), args[2]);
+            }
         }
         return List.of();
     }
 
+    private List<String> experienceNames(String[] args) {
+        int priorTokens = args.length - 3;
+        String prefix = args[args.length - 1];
+        return matching(sessions.activeCharacters().stream().map(active -> active.record().name())
+            .map(name -> name.split(" ")).filter(tokens -> tokens.length > priorTokens)
+            .filter(tokens -> java.util.stream.IntStream.range(0, priorTokens)
+                .allMatch(index -> tokens[index].equals(args[index + 2])))
+            .map(tokens -> tokens[priorTokens]).toList(), prefix);
+    }
+
     private static List<String> matching(java.util.Collection<String> values, String prefix) {
         return values.stream().filter(value -> value.startsWith(prefix)).distinct().sorted().toList();
     }
-    @Override public void close() { closed = true; }
+    @Override public void close() { closed = true; if (characterIssuer != null) characterIssuer.close(); if(adminRevival!=null)adminRevival.close(); if(experienceGrant!=null)experienceGrant.close(); }
 }

src/main/java/games/dmg/fantasystick/session/EquipmentSessionEvents.java

@@ -343,8 +343,16 @@ public final class EquipmentSessionEvents implements Listener, AutoCloseable {
         if (allowed && event.getHand() == EquipmentSlot.HAND && (event.getAction() == org.bukkit.event.block.Action.RIGHT_CLICK_AIR
                 || event.getAction() == org.bukkit.event.block.Action.RIGHT_CLICK_BLOCK)) {
             var selected = sessions.selectedControl(event.getPlayer(), event.getItem()).orElse(null);
-            if (selected != null && useGesture(selected)) emit(event.getPlayer(), event.getItem(), selected,
-                ControlInput.Gesture.USE, null, 0, 0);
+            if (selected != null && useGesture(selected)) {
+                org.bukkit.entity.Entity target = selected.ability().equals("hex")
+                        || selected.ability().equals("mending_light")
+                        || selected.ability().equals("guardian_bond")
+                    ? event.getPlayer().getTargetEntity(64)
+                    : selected.ability().equals("inspire") || selected.ability().equals("purify")
+                        ? event.getPlayer().isSneaking() ? event.getPlayer() : event.getPlayer().getTargetEntity(64)
+                        : null;
+                emit(event.getPlayer(), event.getItem(), selected, ControlInput.Gesture.USE, target, 0, 0);
+            }
             else if (selected != null && selected.ability().equals("longbow")) beginDraw(event.getPlayer(), event.getItem(), selected);
         }
     }
@@ -434,8 +442,11 @@ public final class EquipmentSessionEvents implements Listener, AutoCloseable {
         if (special(item)) event.setCancelled(true);
         if (event.getHand() == EquipmentSlot.HAND) {
             var selected = sessions.selectedControl(player, item).orElse(null);
-            if (selected != null && useGesture(selected)) emit(player, item, selected,
-                ControlInput.Gesture.USE, event.getRightClicked(), 0, 0);
+            if (selected != null && useGesture(selected)) {
+                org.bukkit.entity.Entity target = selected.ability().equals("inspire") && player.isSneaking()
+                    ? player : event.getRightClicked();
+                emit(player, item, selected, ControlInput.Gesture.USE, target, 0, 0);
+            }
         }
     }
 
@@ -449,7 +460,8 @@ public final class EquipmentSessionEvents implements Listener, AutoCloseable {
         if (special(item)) event.setCancelled(true);
         if (willAttack) {
             var selected = sessions.selectedControl(player, item).orElse(null);
-            if (selected != null && (selected.slot() == 1 || selected.ability().equals("great_sword"))) {
+            if (selected != null && (selected.slot() == 1 || selected.ability().equals("great_sword")
+                    || selected.ability().equals("shield_bash"))) {
                 emit(player, item, selected, ControlInput.Gesture.ATTACK, event.getAttacked(), 0, player.getAttackCooldown());
             }
         }

src/main/java/games/dmg/fantasystick/session/EquipmentSessions.java

@@ -12,6 +12,7 @@ import java.time.Duration;
 import java.time.Instant;
 import java.util.Arrays;
 import java.util.HashMap;
+import java.util.List;
 import java.util.Map;
 import java.util.Objects;
 import java.util.Optional;
@@ -34,11 +35,13 @@ public final class EquipmentSessions implements AutoCloseable {
     public record Notice(UUID player, String code, String message) { }
     public record Failure(UUID player, UUID session, Throwable cause) { }
     public record Active(UUID player, UUID session, UUID character) { }
+    public record ActiveCharacter(Active session, CharacterRecord record) { }
     public record SelectedControl(Active session, int slot, String ability) { }
 
     private final CharacterStorage characters;
     private final EquipmentSessionStore receipts;
-    private final Duration switchDelay;
+    private Supplier<Duration> switchDelay;
+    private java.util.function.BooleanSupplier roleplayDisabled = () -> false;
     private final Clock clock;
     private final Consumer<Runnable> nextTick;
     private final Consumer<Notice> notices;
@@ -91,6 +94,7 @@ public final class EquipmentSessions implements AutoCloseable {
         boolean uncertainSave;
         boolean nativeUncertain;
         boolean exitRequested;
+        Duration exitDelay;
         boolean arrival;
         Attempt recoveryOwner;
         org.bukkit.Location entryLocation;
@@ -118,7 +122,8 @@ public final class EquipmentSessions implements AutoCloseable {
                              Consumer<Runnable> nextTick, Consumer<Notice> notices, Consumer<Failure> diagnostics) {
         this.characters = Objects.requireNonNull(characters);
         this.receipts = Objects.requireNonNull(receipts);
-        this.switchDelay = Objects.requireNonNull(switchDelay);
+        var initialSwitchDelay = Objects.requireNonNull(switchDelay);
+        this.switchDelay = () -> initialSwitchDelay;
         this.clock = Objects.requireNonNull(clock);
         if (switchDelay.isNegative()) throw new IllegalArgumentException("Negative switch delay");
         this.nextTick = Objects.requireNonNull(nextTick);
@@ -142,6 +147,19 @@ public final class EquipmentSessions implements AutoCloseable {
         this.gameModes = Objects.requireNonNull(gameModes);
     }
 
+    /** Install before exposing entry so later checks/exits capture the acknowledged live policy. */
+    public synchronized void attachSwitchDelay(Supplier<Duration> policy) {
+        if (!owned.isEmpty()) throw new IllegalStateException("Sessions already started");
+        switchDelay = Objects.requireNonNull(policy);
+        if (switchDelay.get().isNegative()) throw new IllegalArgumentException("Negative switch delay");
+    }
+
+    /** Install before exposing entry so pending and new activation work revalidates availability. */
+    public synchronized void attachRoleplayDisabled(java.util.function.BooleanSupplier policy) {
+        if (!owned.isEmpty()) throw new IllegalStateException("Sessions already started");
+        roleplayDisabled = Objects.requireNonNull(policy);
+    }
+
     /** Install before exposing entry so registered definitions drive delivered control metadata. */
     public synchronized void attachAbilityRegistry(games.dmg.fantasystick.ability.AbilityRegistry registry) {
         if (!owned.isEmpty()) throw new IllegalStateException("Sessions already started");
@@ -208,6 +226,14 @@ public final class EquipmentSessions implements AutoCloseable {
             && sheets.identify(attempt.player.getInventory().getItemInOffHand()).filter(attempt.character::equals).isPresent();
     }
 
+    /** Side-effect-free server-thread snapshots for exact active-character command resolution/autocomplete. */
+    public synchronized List<ActiveCharacter> activeCharacters() {
+        if (closed) return List.of();
+        return active.values().stream().filter(attempt -> attempt.record != null)
+            .map(attempt -> new ActiveCharacter(new Active(attempt.owner, attempt.session, attempt.character), attempt.record))
+            .filter(snapshot -> current(snapshot.session())).toList();
+    }
+
     /** Current active holder for a transferable identity, used only to synchronize acknowledged character writes. */
     public synchronized Optional<Active> activeCharacter(UUID character) {
         Objects.requireNonNull(character);
@@ -267,6 +293,10 @@ public final class EquipmentSessions implements AutoCloseable {
     public synchronized void enter(Player player) {
         UUID owner = player.getUniqueId();
         if (closed) return;
+        if (roleplayDisabled.getAsBoolean()) {
+            notice(owner, "ROLEPLAY_DISABLED", "Fantasy roleplaying is disabled; the character sheet was not activated.");
+            return;
+        }
         if (transitioning.containsKey(owner)) {
             notice(owner, "BUSY", "An equipment transition is still completing; retry afterwards."); return;
         }
@@ -326,6 +356,10 @@ public final class EquipmentSessions implements AutoCloseable {
 
     private synchronized void loaded(Attempt attempt, Loaded loaded, Throwable failure) {
         if (!entryCurrent(attempt) || attempt.claim != null) return;
+        if (roleplayDisabled.getAsBoolean()) {
+            refuse(attempt, "ROLEPLAY_DISABLED", "Fantasy roleplaying was disabled before activation completed.");
+            return;
+        }
         if (failure != null) { fail(attempt, failure); return; }
         var record = loaded.character().orElse(null);
         if (record == null || record.dead() || record.health().signum() <= 0) {
@@ -337,7 +371,7 @@ public final class EquipmentSessions implements AutoCloseable {
                 refuse(attempt, "RECOVERY_REQUIRED", "An unresolved equipment receipt requires validated recovery."); return;
             }
             Instant now = clock.instant();
-            if (!state.canEnter(attempt.character, switchDelay, now)) {
+            if (!state.canEnter(attempt.character, switchDelay.get(), now)) {
                 Duration remaining = Duration.between(now, state.lastExit().deadline());
                 long seconds = remaining.getSeconds() + (remaining.getNano() == 0 ? 0 : 1);
                 refuse(attempt, "COOLDOWN", "Wait " + seconds + " seconds to switch characters (until "
@@ -376,6 +410,10 @@ public final class EquipmentSessions implements AutoCloseable {
 
     private synchronized void complete(Attempt attempt, Optional<CharacterRecord> fresh, Throwable failure) {
         if (!entryCurrent(attempt)) return;
+        if (roleplayDisabled.getAsBoolean()) {
+            refuse(attempt, "ROLEPLAY_DISABLED", "Fantasy roleplaying was disabled before activation completed.");
+            return;
+        }
         if (failure != null) { fail(attempt, failure); return; }
         var record = fresh.orElse(null);
         if (record == null || record.dead() || record.health().signum() <= 0) {
@@ -401,6 +439,8 @@ public final class EquipmentSessions implements AutoCloseable {
                 refuse(attempt, result.name(), "Equipment entry refused: " + result); return;
             }
             packed = true;
+            try { sheets.applyModel(attempt.player.getInventory().getItemInOffHand()); }
+            catch (RuntimeException cosmeticFailure) { diagnostic(attempt, cosmeticFailure); }
             if (interrupted(attempt)) return;
             for (int slot = 0; slot < 9; slot++) {
                 attempt.player.getInventory().setItem(slot, items[slot]);
@@ -454,6 +494,7 @@ public final class EquipmentSessions implements AutoCloseable {
         UUID owner = player.getUniqueId();
         var transition = transitioning.get(owner);
         if (transition != null) {
+            captureExitDelay(transition);
             active.remove(owner, transition);
             withdrawPresentation(transition);
             transition.exitRequested = true;
@@ -463,6 +504,7 @@ public final class EquipmentSessions implements AutoCloseable {
         cancelEntry(owner);
         var attempt = active.remove(owner);
         if (attempt == null) { invalidateCursor(owner); return EquipmentStorage.RestoreResult.NOT_FOUND; }
+        captureExitDelay(attempt);
         return restoreExit(attempt);
     }
 
@@ -607,6 +649,7 @@ public final class EquipmentSessions implements AutoCloseable {
     }
 
     private EquipmentStorage.RestoreResult restoreExit(Attempt attempt) {
+        captureExitDelay(attempt);
         active.remove(attempt.owner, attempt);
         withdrawPresentation(attempt);
         boolean reserved = transitioning.putIfAbsent(attempt.owner, attempt) == null;
@@ -703,19 +746,35 @@ public final class EquipmentSessions implements AutoCloseable {
         return false;
     }
 
+    private void captureExitDelay(Attempt attempt) {
+        if (attempt.exitDelay != null) return;
+        var delay = Objects.requireNonNull(switchDelay.get());
+        if (delay.isNegative()) throw new IllegalStateException("Negative switch delay policy");
+        attempt.exitDelay = delay;
+    }
+
     private void persistExit(Attempt attempt, boolean restored) {
+        captureExitDelay(attempt); // Recovery attempts have no process-local exit request to capture earlier.
         attempt.nativeRestored = restored;
         boolean complete = restored && (attempt.healthAcknowledged || attempt.defeated);
         attempt.saving = true;
         persist(() -> complete
-            ? receipts.completeExit(attempt.owner, attempt.session, switchDelay)
-            : receipts.recordExit(attempt.owner, attempt.session, switchDelay), (state, failure) -> {
+            ? receipts.completeExit(attempt.owner, attempt.session, attempt.exitDelay)
+            : receipts.recordExit(attempt.owner, attempt.session, attempt.exitDelay), (state, failure) -> {
                 attempt.saving = false;
                 if (failure != null) diagnostic(attempt, failure);
                 else if (complete) { attempt.gearAcknowledged = true; release(attempt); }
             });
     }
 
+    /** Cancel pending activation and route every active player through ordinary restoration. */
+    public synchronized void disableRoleplay() {
+        for (var attempt : java.util.List.copyOf(pending.values())) {
+            refuse(attempt, "ROLEPLAY_DISABLED", "Fantasy roleplaying was disabled before activation completed.");
+        }
+        for (var attempt : java.util.List.copyOf(active.values())) exit(attempt.player);
+    }
+
     public synchronized void cancelEntry(UUID player) {
         var attempt = pending.remove(player);
         if (attempt != null) abandon(attempt);

src/main/resources/config.yml

@@ -1,9 +1,14 @@
 # Captured when a new fantasy session starts; changing this does not alter active sessions.
 # Admin command: /fantasystick config adventure-mode [true|false]
 adventure-mode: true
+admin-revive-selection-timeout-seconds: 60
 
 # Real-time delay before this player may enter a different character after exit.
 character-swap-cooldown-seconds: 900
+roleplay-disabled: false
+party-max-size: 6
+sheet-resource-pack-url: ''
+sheet-resource-pack-sha1: ''
 
 # New-character and transferable fantasy progression defaults.
 starting-points: 40
@@ -51,3 +56,79 @@ longbow-full-projectile-speed-blocks-per-tick: 3
 quickstep-cooldown-seconds: 5
 quickstep-distance-blocks: 4
 quickstep-speed-blocks-per-tick: 1
+
+# Second Wind defaults from the reviewed remaining-development packet.
+# Admin command: /fantasystick config <key> [value]
+second-wind-base-healing: 6
+second-wind-cooldown-seconds: 15
+
+# Stone Skin defaults from the reviewed remaining-development packet.
+# Admin command: /fantasystick config <key> [value]
+stone-skin-cooldown-seconds: 14
+stone-skin-duration-seconds: 4
+stone-skin-damage-reduction-percent: 25
+
+# Shield Bash defaults from the reviewed remaining-development packet.
+# Admin command: /fantasystick config <key> [value]
+shield-bash-base-damage: 4
+shield-bash-cooldown-seconds: 6
+shield-bash-range-blocks: 3
+shield-bash-horizontal-knockback: 0.8
+shield-bash-minimum-vertical-knockback: 0.35
+
+# Hex defaults from the reviewed remaining-development packet.
+# Admin command: /fantasystick config <key> [value]
+hex-cooldown-seconds: 10
+hex-range-blocks: 12
+hex-duration-seconds: 4
+hex-damage-reduction-percent: 20
+
+# Inspire defaults from the reviewed remaining-development packet.
+# Admin command: /fantasystick config <key> [value]
+inspire-base-temporary-health: 4
+inspire-cooldown-seconds: 15
+inspire-range-blocks: 12
+inspire-duration-seconds: 6
+
+# Mending Light defaults from the reviewed remaining-development packet.
+# Admin command: /fantasystick config <key> [value]
+mending-light-base-healing: 6
+mending-light-cooldown-seconds: 8
+mending-light-range-blocks: 12
+
+# Purify defaults from the reviewed remaining-development packet.
+# Admin command: /fantasystick config <key> [value]
+purify-cooldown-seconds: 15
+purify-range-blocks: 12
+
+# Guardian Bond defaults from the reviewed remaining-development packet.
+# Admin command: /fantasystick config <key> [value]
+guardian-bond-cooldown-seconds: 20
+guardian-bond-range-blocks: 10
+guardian-bond-duration-seconds: 6
+guardian-bond-redirect-percent: 30
+
+# Rallying Cry defaults from the reviewed remaining-development packet.
+# Admin command: /fantasystick config <key> [value]
+rallying-cry-cooldown-seconds: 25
+rallying-cry-radius-blocks: 8
+rallying-cry-duration-seconds: 6
+rallying-cry-speed-amplifier: 0
+rallying-cry-damage-bonus-percent: 20
+
+# Frost Nova defaults from the reviewed remaining-development packet.
+# Admin command: /fantasystick config <key> [value]
+frost-nova-base-damage: 5
+frost-nova-cooldown-seconds: 12
+frost-nova-radius-blocks: 5
+frost-nova-slowness-amplifier: 1
+frost-nova-slowness-duration-seconds: 3
+
+# Chain Lightning defaults from the reviewed remaining-development packet.
+# Admin command: /fantasystick config <key> [value]
+chain-lightning-base-damage: 8
+chain-lightning-cooldown-seconds: 18
+chain-lightning-initial-range-blocks: 16
+chain-lightning-jump-range-blocks: 6
+chain-lightning-additional-targets: 3
+chain-lightning-jump-multiplier: 0.75

src/main/resources/plugin.yml

@@ -7,10 +7,10 @@ description: Transferable characters, native fantasy health, recoverable equipme
 author: dmg.games
 commands:
   fantasystick:
-    description: Inspect/recover equipment sessions or configure Fantasy Stick.
-    usage: /fantasystick <inspect|recover> <player-uuid> | config <setting> [value]
+    description: Issue or revive sheets, grant fantasy experience, recover sessions or configure Fantasy Stick.
+    usage: /fantasystick <give|revive> <online-player> | experience give <active-character-name...> <amount> | <inspect|recover> <player-uuid> | config <setting> [value]
     permission: fantasystick.admin
 permissions:
   fantasystick.admin:
-    description: Inspect/recover equipment sessions and configure fantasy mode.
+    description: Issue/revive sheets, grant fantasy experience, recover sessions and configure fantasy mode.
     default: op

src/nativeTest/java/games/dmg/fantasystick/AdminExperienceGrantNativeTest.java

@@ -0,0 +1,73 @@
+package games.dmg.fantasystick;
+
+import static org.junit.jupiter.api.Assertions.*;
+import static org.mockito.Mockito.*;
+
+import games.dmg.fantasystick.crafting.CharacterFactory;
+import games.dmg.fantasystick.persistence.CharacterRecord;
+import games.dmg.fantasystick.persistence.CharacterStorage;
+import games.dmg.fantasystick.progression.ProgressionRules;
+import games.dmg.fantasystick.session.AdminExperienceGrant;
+import games.dmg.fantasystick.session.EquipmentSessions;
+import java.math.BigInteger;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Optional;
+import java.util.UUID;
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.atomic.AtomicBoolean;
+import org.junit.jupiter.api.Test;
+
+class AdminExperienceGrantNativeTest {
+    @Test void acceptedPersistenceCannotRedirectFeedbackAfterCharacterSwitch() {
+        var storage = mock(CharacterStorage.class); var sessions = mock(EquipmentSessions.class);
+        var rules = ProgressionRules.defaults(); CharacterRecord captured = new CharacterFactory().create(rules);
+        var active = new EquipmentSessions.Active(UUID.randomUUID(), UUID.randomUUID(), captured.id());
+        var current = new AtomicBoolean(true);
+        when(sessions.current(active)).thenAnswer(call -> current.get());
+        when(sessions.currentRecord(active)).thenReturn(Optional.of(captured));
+        var future = new CompletableFuture<CharacterStorage.ExperienceAward>();
+        when(storage.awardExperience(captured.id(), captured.revision(), BigInteger.TEN, rules)).thenReturn(future);
+        var tasks = new ArrayList<Runnable>(); var results = new ArrayList<AdminExperienceGrant.Result>();
+        var playerLookups = new java.util.concurrent.atomic.AtomicInteger();
+        var grant = new AdminExperienceGrant(storage, rules, sessions, tasks::add,
+            ignored -> { playerLookups.incrementAndGet(); return null; }, failure -> fail(failure.cause()));
+
+        assertTrue(grant.grant(active, captured, BigInteger.TEN, results::add));
+        current.set(false);
+        var saved = new CharacterRecord(captured.id(), captured.name(), BigInteger.ONE, captured.stats(), 1,
+            BigInteger.TEN, captured.unspentPoints(), captured.health(), captured.learned(), captured.loadout(),
+            captured.cooldowns(), captured.restrictedKills(), false, captured.deathId(), captured.diedAt());
+        future.complete(new CharacterStorage.ExperienceAward(CharacterStorage.ExperienceAwardStatus.APPLIED,
+            Optional.of(saved), 0));
+        assertEquals(1, tasks.size()); tasks.getFirst().run();
+
+        assertEquals(AdminExperienceGrant.Status.APPLIED, results.getFirst().status());
+        assertEquals(BigInteger.TEN, results.getFirst().applied());
+        verify(sessions, never()).acknowledgeProgress(any(), any(), any());
+        assertEquals(0, playerLookups.get(), "A replacement holder/session cannot receive captured feedback");
+    }
+
+    @Test void persistenceFailureReportsOnceAndClosedLifetimePublishesNoStaleCallback() {
+        var storage = mock(CharacterStorage.class); var sessions = mock(EquipmentSessions.class);
+        var rules = ProgressionRules.defaults(); CharacterRecord captured = new CharacterFactory().create(rules);
+        var active = new EquipmentSessions.Active(UUID.randomUUID(), UUID.randomUUID(), captured.id());
+        when(sessions.current(active)).thenReturn(true); when(sessions.currentRecord(active)).thenReturn(Optional.of(captured));
+        var failed = new CompletableFuture<CharacterStorage.ExperienceAward>();
+        when(storage.awardExperience(captured.id(), captured.revision(), BigInteger.ONE, rules)).thenReturn(failed);
+        var tasks = new ArrayList<Runnable>(); var results = new ArrayList<AdminExperienceGrant.Result>();
+        var failures = new ArrayList<AdminExperienceGrant.Failure>();
+        var grant = new AdminExperienceGrant(storage, rules, sessions, tasks::add, ignored -> null, failures::add);
+        assertTrue(grant.grant(active, captured, BigInteger.ONE, results::add));
+        failed.completeExceptionally(new java.io.IOException("save failed"));
+        assertEquals(1, failures.size()); assertEquals(1, tasks.size()); tasks.removeFirst().run();
+        assertEquals(List.of(AdminExperienceGrant.Status.FAILED), results.stream().map(AdminExperienceGrant.Result::status).toList());
+
+        var pending = new CompletableFuture<CharacterStorage.ExperienceAward>();
+        when(storage.awardExperience(captured.id(), captured.revision(), BigInteger.TWO, rules)).thenReturn(pending);
+        assertTrue(grant.grant(active, captured, BigInteger.TWO, results::add)); grant.close();
+        pending.complete(new CharacterStorage.ExperienceAward(CharacterStorage.ExperienceAwardStatus.AT_CAP,
+            Optional.of(captured), 0));
+        assertTrue(tasks.isEmpty()); assertEquals(1, results.size());
+    }
+}

src/nativeTest/java/games/dmg/fantasystick/AdminExperienceNativeTest.java

@@ -0,0 +1,212 @@
+package games.dmg.fantasystick;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+import games.dmg.fantasystick.items.CharacterSheets;
+import games.dmg.fantasystick.persistence.CharacterRecord;
+import games.dmg.fantasystick.persistence.CharacterStorage;
+import java.math.BigInteger;
+import java.nio.file.Path;
+import java.util.List;
+import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.io.TempDir;
+
+class AdminExperienceNativeTest {
+    @TempDir Path data;
+    @BeforeAll static void bootstrap() throws Exception { NativeRuntime.bootstrap(); }
+
+    @Test void registeredCommandResolvesExactActiveCharacterPersistsThenSynchronizesFeedbackAndBook() throws Exception {
+        try (var f = new FantasyStickLifecycleNativeTest.Fixture(data)) {
+            f.plugin.setEnabled(true);
+            var target = new FantasyStickLifecycleNativeTest.Actor(data);
+            var storage = storage(f);
+            storage.renameCharacter(target.core.record.id(), "Mira 雪").get();
+            f.players.put(target.core.id, target.player); f.activate(target);
+            var sender = new EquipmentAdminCommandNativeTest.Sender();
+            var before = storage.find(target.core.record.id()).get().orElseThrow();
+
+            assertEquals(List.of("experience"), f.command.tabComplete(sender.port, "fantasystick", new String[]{"exp"}));
+            assertEquals(List.of("give"), f.command.tabComplete(sender.port, "fantasystick", new String[]{"experience", "g"}));
+            assertEquals(List.of("Mira"), f.command.tabComplete(sender.port, "fantasystick", new String[]{"experience", "give", "Mi"}));
+            assertEquals(List.of("雪"), f.command.tabComplete(sender.port, "fantasystick", new String[]{"experience", "give", "Mira", ""}));
+            assertTrue(f.command.tabComplete(sender.port, "fantasystick", new String[]{"experience", "give", "Mira", "雪", ""}).isEmpty());
+            assertTrue(f.command.execute(sender.port, "fantasystick", new String[]{"experience", "give", "Mira", "雪", "250"}));
+            storage.find(target.core.record.id()).get(); f.tick();
+
+            var saved = storage.find(target.core.record.id()).get().orElseThrow();
+            assertEquals(BigInteger.valueOf(250), saved.experience());
+            assertEquals(3, saved.level());
+            assertEquals(before.unspentPoints().add(BigInteger.TWO), saved.unspentPoints());
+            assertEquals(before.stats(), saved.stats()); assertEquals(before.health(), saved.health());
+            assertEquals(before.learned(), saved.learned()); assertEquals(before.loadout(), saved.loadout());
+            assertEquals(before.cooldowns(), saved.cooldowns()); assertEquals(before.restrictedKills(), saved.restrictedKills());
+            assertTrue(sender.messages.getLast().contains("Mira 雪"));
+            assertTrue(sender.messages.getLast().contains("250")); assertTrue(sender.messages.getLast().contains("level 3"));
+            assertTrue(target.messages.stream().anyMatch(message -> message.contains("250 fantasy XP")));
+            assertTrue(target.messages.stream().anyMatch(message -> message.contains("Level 2")));
+            assertTrue(target.messages.stream().anyMatch(message -> message.contains("Level 3")));
+            assertEquals(2, target.sounds.size());
+            assertEquals(2, org.mockito.Mockito.mockingDetails(target.world).getInvocations().stream()
+                .filter(invocation -> invocation.getMethod().getName().equals("spawnParticle")).count());
+            PartyBookNativeTest.open(f, target);
+            String text = bookText(target.books.getLast());
+            assertTrue(text.contains("Level: 3"), text); assertTrue(text.contains("XP: 50/100"), text);
+
+            f.plugin.setEnabled(false); f.plugin.setEnabled(true);
+            assertEquals(BigInteger.valueOf(250), storage(f).find(target.core.record.id()).get().orElseThrow().experience());
+        }
+    }
+
+    @Test void commandValidationAmbiguityExactCaseAndAutocompleteFailClosedWithoutMutation() throws Exception {
+        try (var f = new FantasyStickLifecycleNativeTest.Fixture(data)) {
+            f.plugin.setEnabled(true);
+            var first = active(f, data, "Twin Hero"); var second = active(f, data, "Twin Hero");
+            var unicode = active(f, data, "Árvíztűrő Tükörfúrógép");
+            var inactive = new FantasyStickLifecycleNativeTest.Actor(data);
+            storage(f).renameCharacter(inactive.core.record.id(), "Hidden Hero").get();
+            var sender = new EquipmentAdminCommandNativeTest.Sender();
+            var firstBefore = storage(f).find(first.core.record.id()).get().orElseThrow();
+            var secondBefore = storage(f).find(second.core.record.id()).get().orElseThrow();
+
+            assertEquals(List.of("Twin"), f.command.tabComplete(sender.port, "fantasystick", new String[]{"experience", "give", "Tw"}));
+            assertEquals(List.of("Hero"), f.command.tabComplete(sender.port, "fantasystick", new String[]{"experience", "give", "Twin", "H"}));
+            assertEquals(List.of("Árvíztűrő"), f.command.tabComplete(sender.port, "fantasystick", new String[]{"experience", "give", "Á"}));
+            assertEquals(List.of("Tükörfúrógép"), f.command.tabComplete(sender.port, "fantasystick", new String[]{"experience", "give", "Árvíztűrő", "T"}));
+            assertTrue(f.command.tabComplete(sender.port, "fantasystick", new String[]{"experience", "give", "Hidden", ""}).isEmpty());
+            int queued = f.tasks.size();
+            for (var args : List.of(
+                    new String[]{"experience", "give", "Twin", "Hero", "5"},
+                    new String[]{"experience", "give", "twin", "Hero", "5"},
+                    new String[]{"experience", "give", "Missing", "5"},
+                    new String[]{"experience", "give", "Hidden", "Hero", "5"},
+                    new String[]{"experience", "give", "Account", "5"},
+                    new String[]{"experience", "give", "Árvíztűrő", "Tükörfúrógép", "0"},
+                    new String[]{"experience", "give", "Árvíztűrő", "Tükörfúrógép", "-1"},
+                    new String[]{"experience", "give", "Árvíztűrő", "Tükörfúrógép", "1.5"},
+                    new String[]{"experience", "give", "Árvíztűrő", "Tükörfúrógép", "5", "extra"},
+                    new String[]{"experience", "give", "Árvíztűrő", "Tükörfúrógép"},
+                    new String[]{"experience", "extra", "Árvíztűrő", "Tükörfúrógép", "5"})) {
+                f.command.execute(sender.port, "fantasystick", args);
+            }
+            assertEquals(queued, f.tasks.size());
+            assertEquals(firstBefore, storage(f).find(first.core.record.id()).get().orElseThrow());
+            assertEquals(secondBefore, storage(f).find(second.core.record.id()).get().orElseThrow());
+            assertTrue(sender.messages.stream().anyMatch(message -> message.contains("ambiguous") && message.contains("Twin Hero")));
+            assertTrue(sender.messages.stream().anyMatch(message -> message.contains("not active") && message.contains("Missing")));
+            sender.allowed = false;
+            assertTrue(f.command.tabComplete(sender.port, "fantasystick", new String[]{"exp"}).isEmpty());
+            f.command.execute(sender.port, "fantasystick", new String[]{"experience", "give", "Árvíztűrő", "Tükörfúrógép", "5"});
+            assertTrue(sender.messages.getLast().contains("Permission denied"));
+            assertEquals(BigInteger.ZERO, storage(f).find(unicode.core.record.id()).get().orElseThrow().experience());
+        }
+    }
+
+    @Test void arbitraryPrecisionGrantClampsAtCapPreservesCombatHistoryAndNeverTouchesNativeXp() throws Exception {
+        try (var f = new FantasyStickLifecycleNativeTest.Fixture(data)) {
+            f.plugin.setEnabled(true);
+            var target = new FantasyStickLifecycleNativeTest.Actor(data); var storage = storage(f);
+            var position = new games.dmg.fantasystick.progression.CombatRewardRules.KillPosition(java.util.UUID.randomUUID(),
+                java.math.BigDecimal.ONE, java.math.BigDecimal.TWO, java.math.BigDecimal.TEN);
+            var progressed = storage.awardCombatExperience(target.core.record.id(), target.core.record.revision(), BigInteger.TEN,
+                new games.dmg.fantasystick.progression.ProgressionRules(BigInteger.valueOf(40), BigInteger.valueOf(100), 30),
+                games.dmg.fantasystick.progression.CombatRewardRules.defaults(), position).get().record().orElseThrow();
+            storage.renameCharacter(target.core.record.id(), "Cap Hero").get();
+            f.players.put(target.core.id, target.player); f.activate(target);
+            var sender = new EquipmentAdminCommandNativeTest.Sender(); String huge = "9".repeat(1000);
+
+            f.command.execute(sender.port, "fantasystick", new String[]{"experience", "give", "Cap", "Hero", huge});
+            storage.find(target.core.record.id()).get(); f.tick();
+            var capped = storage.find(target.core.record.id()).get().orElseThrow();
+            assertEquals(30, capped.level()); assertEquals(BigInteger.valueOf(2900), capped.experience());
+            assertEquals(progressed.restrictedKills(), capped.restrictedKills());
+            assertTrue(sender.messages.getLast().contains("applied 2890"));
+            int feedback = target.messages.size(); int sounds = target.sounds.size();
+            f.command.execute(sender.port, "fantasystick", new String[]{"experience", "give", "Cap", "Hero", "1"});
+            storage.find(target.core.record.id()).get(); f.tick();
+            assertTrue(sender.messages.getLast().contains("Granted 0"));
+            assertEquals(feedback, target.messages.size()); assertEquals(sounds, target.sounds.size());
+            assertEquals(capped, storage.find(target.core.record.id()).get().orElseThrow());
+        }
+    }
+
+    @Test void revisionLogoutFailureAndRepeatedGrantRacesNeverRedirectDuplicateOrClaimFalseSuccess() throws Exception {
+        var staleDir = data.resolve("stale");
+        try (var f = new FantasyStickLifecycleNativeTest.Fixture(staleDir)) {
+            f.plugin.setEnabled(true); var target = active(f, staleDir, "Before Rename"); var storage = storage(f);
+            var worker = (java.util.concurrent.ExecutorService) FantasyStickLifecycleNativeTest.Fixture.field(storage, "worker");
+            var entered = new java.util.concurrent.CountDownLatch(1); var release = new java.util.concurrent.CountDownLatch(1);
+            var gate = worker.submit(() -> { entered.countDown(); try { assertTrue(release.await(5, java.util.concurrent.TimeUnit.SECONDS)); }
+                catch (InterruptedException interrupted) { throw new AssertionError(interrupted); } });
+            var sender = new EquipmentAdminCommandNativeTest.Sender(); assertTrue(entered.await(5, java.util.concurrent.TimeUnit.SECONDS));
+            f.command.execute(sender.port, "fantasystick", new String[]{"experience", "give", "Before", "Rename", "75"});
+            var old = new games.dmg.fantasystick.persistence.YamlCharacterRepository(staleDir).load(target.core.record.id()).orElseThrow();
+            var renamed = copy(old, "After Rename", old.revision().add(BigInteger.ONE));
+            new games.dmg.fantasystick.persistence.YamlCharacterRepository(staleDir).replace(renamed, old.revision());
+            release.countDown(); gate.get(); storage.find(old.id()).get(); f.tick();
+            assertTrue(sender.messages.getLast().contains("changed concurrently"));
+            assertEquals(BigInteger.ZERO, storage.find(old.id()).get().orElseThrow().experience());
+            assertTrue(target.messages.stream().noneMatch(message -> message.contains("administrator")));
+        }
+        var logoutDir = data.resolve("logout");
+        try (var f = new FantasyStickLifecycleNativeTest.Fixture(logoutDir)) {
+            f.plugin.setEnabled(true); var target = active(f, logoutDir, "Departing Hero"); var storage = storage(f);
+            var sender = new EquipmentAdminCommandNativeTest.Sender();
+            f.command.execute(sender.port, "fantasystick", new String[]{"experience", "give", "Departing", "Hero", "75"});
+            target.core.online = false;
+            storage.find(target.core.record.id()).get(); f.tick();
+            assertEquals(BigInteger.valueOf(75), storage.find(target.core.record.id()).get().orElseThrow().experience());
+            assertTrue(sender.messages.getLast().contains("applied 75"));
+            assertTrue(target.messages.stream().noneMatch(message -> message.contains("administrator")));
+        }
+        var repeatDir = data.resolve("repeat");
+        try (var f = new FantasyStickLifecycleNativeTest.Fixture(repeatDir)) {
+            f.plugin.setEnabled(true); var target = active(f, repeatDir, "One Award"); var storage = storage(f);
+            var first = new EquipmentAdminCommandNativeTest.Sender(); var second = new EquipmentAdminCommandNativeTest.Sender();
+            f.command.execute(first.port, "fantasystick", new String[]{"experience", "give", "One", "Award", "25"});
+            f.command.execute(second.port, "fantasystick", new String[]{"experience", "give", "One", "Award", "25"});
+            storage.find(target.core.record.id()).get(); f.tick(); f.tick();
+            assertEquals(BigInteger.valueOf(25), storage.find(target.core.record.id()).get().orElseThrow().experience());
+            assertEquals(1, List.of(first.messages.getLast(), second.messages.getLast()).stream()
+                .filter(message -> message.contains("applied 25")).count());
+            assertEquals(1, List.of(first.messages.getLast(), second.messages.getLast()).stream()
+                .filter(message -> message.contains("changed concurrently")).count());
+        }
+    }
+
+    @Test void realFilesystemSaveFailureReportsNoSuccessOrPlayerFeedback() throws Exception {
+        try (var f = new FantasyStickLifecycleNativeTest.Fixture(data)) {
+            f.plugin.setEnabled(true); var target = active(f, data, "Broken Save");
+            var sender = new EquipmentAdminCommandNativeTest.Sender();
+            var path = data.resolve("characters").resolve(target.core.record.id() + ".yml");
+            java.nio.file.Files.delete(path); java.nio.file.Files.createDirectory(path);
+            int feedback = target.messages.size();
+            f.command.execute(sender.port, "fantasystick", new String[]{"experience", "give", "Broken", "Save", "20"});
+            f.tick();
+            assertTrue(sender.messages.getLast().contains("failed before acknowledgment"));
+            assertEquals(feedback, target.messages.size());
+            assertTrue(sender.messages.stream().noneMatch(message -> message.startsWith("Granted 20")));
+        }
+    }
+
+    private static CharacterRecord copy(CharacterRecord old, String name, BigInteger revision) {
+        return new CharacterRecord(old.id(), name, revision, old.stats(), old.level(), old.experience(), old.unspentPoints(),
+            old.health(), old.learned(), old.loadout(), old.cooldowns(), old.restrictedKills(), old.dead(), old.deathId(), old.diedAt());
+    }
+
+    private static FantasyStickLifecycleNativeTest.Actor active(FantasyStickLifecycleNativeTest.Fixture f,
+            Path data, String name) throws Exception {
+        var actor = new FantasyStickLifecycleNativeTest.Actor(data);
+        storage(f).renameCharacter(actor.core.record.id(), name).get();
+        f.players.put(actor.core.id, actor.player); f.activate(actor); return actor;
+    }
+    private static CharacterStorage storage(FantasyStickLifecycleNativeTest.Fixture f) {
+        return (CharacterStorage) FantasyStickLifecycleNativeTest.Fixture.field(f.plugin, "characters");
+    }
+    private static String bookText(org.bukkit.inventory.ItemStack book) {
+        var content = org.bukkit.craftbukkit.inventory.CraftItemStack.asNMSCopy(book)
+            .get(net.minecraft.core.component.DataComponents.WRITTEN_BOOK_CONTENT);
+        assertNotNull(content);
+        return content.pages().stream().map(page -> page.raw().getString()).collect(java.util.stream.Collectors.joining("\n"));
+    }
+}

src/nativeTest/java/games/dmg/fantasystick/AdminRevivalNativeTest.java

@@ -0,0 +1,28 @@
+package games.dmg.fantasystick;
+
+import static org.junit.jupiter.api.Assertions.*;
+import static org.mockito.Mockito.*;
+
+import java.math.BigInteger;
+import java.nio.file.Path;
+import java.time.Instant;
+import java.time.temporal.ChronoUnit;
+import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.io.TempDir;
+
+class AdminRevivalNativeTest {
+ @TempDir Path data;
+ @BeforeAll static void bootstrap()throws Exception{NativeRuntime.bootstrap();}
+ @Test void commandCompletionConfigurationAndValidationArePermissionAwareAndDurable()throws Exception{try(var f=new FantasyStickLifecycleNativeTest.Fixture(data)){f.plugin.setEnabled(true);var admin=new FantasyStickLifecycleNativeTest.Actor(data);var target=new FantasyStickLifecycleNativeTest.Actor(data);doReturn("Admin").when(admin.player).getName();doReturn("Target").when(target.player).getName();doReturn(true).when(admin.player).hasPermission("fantasystick.admin");f.players.put(admin.core.id,admin.player);f.players.put(target.core.id,target.player);assertEquals(java.util.List.of("revive"),f.command.tabComplete(admin.player,"fantasystick",new String[]{"rev"}));assertEquals(java.util.List.of("Target"),f.command.tabComplete(admin.player,"fantasystick",new String[]{"revive","Tar"}));assertTrue(f.command.tabComplete(admin.player,"fantasystick",new String[]{"revive","Target",""}).isEmpty());doReturn(false).when(admin.player).hasPermission("fantasystick.admin");assertTrue(f.command.tabComplete(admin.player,"fantasystick",new String[]{"revive",""}).isEmpty());doReturn(true).when(admin.player).hasPermission("fantasystick.admin");f.command.execute(admin.player,"fantasystick",new String[]{"revive"});assertTrue(admin.messages.getLast().contains("Usage"));f.command.execute(admin.player,"fantasystick",new String[]{"revive","Missing"});assertTrue(admin.messages.getLast().contains("target must name"));var sender=new EquipmentAdminCommandNativeTest.Sender();sender.allowed=false;assertTrue(f.command.tabComplete(sender.port,"fantasystick",new String[]{"config","admin-rev"}).isEmpty());f.command.execute(sender.port,"fantasystick",new String[]{"config","admin-revive-selection-timeout-seconds","90"});assertTrue(sender.messages.getLast().contains("Permission denied"));sender.allowed=true;f.command.execute(sender.port,"fantasystick",new String[]{"config","admin-revive-selection-timeout-seconds","90","extra"});assertTrue(sender.messages.getLast().contains("Usage"));assertEquals(java.util.List.of("admin-revive-selection-timeout-seconds"),f.command.tabComplete(sender.port,"fantasystick",new String[]{"config","admin-rev"}));assertEquals(java.util.List.of("60"),f.command.tabComplete(sender.port,"fantasystick",new String[]{"config","admin-revive-selection-timeout-seconds",""}));f.command.execute(sender.port,"fantasystick",new String[]{"config","admin-revive-selection-timeout-seconds"});assertTrue(sender.messages.getLast().contains("=60"));for(String invalid:java.util.List.of("0","-1","1.5","bad")){f.command.execute(sender.port,"fantasystick",new String[]{"config","admin-revive-selection-timeout-seconds",invalid});assertTrue(sender.messages.getLast().contains("invalid"));}var pendingDead=dead(data,Instant.now().minusSeconds(60).truncatedTo(ChronoUnit.SECONDS));target.core.inventory.setItem(10,new games.dmg.fantasystick.items.TailBooks().create(pendingDead));f.command.execute(admin.player,"fantasystick",new String[]{"revive","Target"});((games.dmg.fantasystick.persistence.CharacterStorage)FantasyStickLifecycleNativeTest.Fixture.field(f.plugin,"characters")).find(pendingDead.id()).get();f.tick();assertEquals(1200L,f.delayedTicks.getLast());int before=sender.messages.size();f.command.execute(sender.port,"fantasystick",new String[]{"config","admin-revive-selection-timeout-seconds","90"});assertEquals(before,sender.messages.size());var response=f.tasks.poll(5,java.util.concurrent.TimeUnit.SECONDS);assertNotNull(response);response.run();assertTrue(sender.messages.getLast().contains("=90"));f.command.execute(admin.player,"fantasystick",new String[]{"revive","Target"});((games.dmg.fantasystick.persistence.CharacterStorage)FantasyStickLifecycleNativeTest.Fixture.field(f.plugin,"characters")).find(pendingDead.id()).get();f.tick();assertEquals(1800L,f.delayedTicks.getLast());assertTrue(f.delayedTicks.contains(1200L));f.plugin.setEnabled(false);f.plugin.setEnabled(true);f.command.execute(sender.port,"fantasystick",new String[]{"config","admin-revive-selection-timeout-seconds"});assertTrue(sender.messages.getLast().contains("=90"));}
+  var failed=data.resolve("failed-write");java.nio.file.Files.createDirectories(failed);try(var f=new FantasyStickLifecycleNativeTest.Fixture(failed)){f.plugin.setEnabled(true);java.nio.file.Files.createDirectory(failed.resolve("config.yml"));var sender=new EquipmentAdminCommandNativeTest.Sender();f.command.execute(sender.port,"fantasystick",new String[]{"config","admin-revive-selection-timeout-seconds","90"});var response=f.tasks.poll(5,java.util.concurrent.TimeUnit.SECONDS);assertNotNull(response);response.run();assertTrue(sender.messages.getLast().contains("save failed"));f.command.execute(sender.port,"fantasystick",new String[]{"config","admin-revive-selection-timeout-seconds"});assertTrue(sender.messages.getLast().contains("=60"));}
+  for(String invalid:java.util.List.of("0","-1","1.5","bad")){var dir=data.resolve(invalid.replace('.','_'));java.nio.file.Files.createDirectories(dir);java.nio.file.Files.writeString(dir.resolve("config.yml"),"admin-revive-selection-timeout-seconds: '"+invalid+"'\n");try(var f=new FantasyStickLifecycleNativeTest.Fixture(dir)){assertThrows(IllegalArgumentException.class,()->f.plugin.setEnabled(true));assertTrue(f.order.isEmpty());}}}
+ @Test void registeredAdminSelectsAnExpiredDirectTailAndRestoresSameCharacterWithoutChangingTargetState()throws Exception{try(var f=new FantasyStickLifecycleNativeTest.Fixture(data)){f.plugin.setEnabled(true);var admin=new FantasyStickLifecycleNativeTest.Actor(data);var target=new FantasyStickLifecycleNativeTest.Actor(data);doReturn("Admin").when(admin.player).getName();doReturn("Target").when(target.player).getName();doReturn(true).when(admin.player).hasPermission("fantasystick.admin");f.players.put(admin.core.id,admin.player);f.players.put(target.core.id,target.player);f.activate(target);var dead=dead(data,Instant.now().minusSeconds(172800).truncatedTo(ChronoUnit.SECONDS));var tail=new games.dmg.fantasystick.items.TailBooks().create(dead);tail.setAmount(2);target.core.inventory.setItem(10,tail);var beforeHealth=target.core.health;var beforeMode=target.core.gameMode;var beforeLocation=target.core.location.clone();
+  assertTrue(f.command.execute(admin.player,"fantasystick",new String[]{"revive","Target"}));var storage=(games.dmg.fantasystick.persistence.CharacterStorage)FantasyStickLifecycleNativeTest.Fixture.field(f.plugin,"characters");storage.find(dead.id()).get();f.tick();assertEquals(1,admin.inventories.size());assertTrue(target.inventories.isEmpty());var popup=admin.inventories.getFirst();assertEquals(1,java.util.stream.IntStream.range(0,popup.getSize()).filter(i->popup.getItem(i)!=null).count());var view=mock(org.bukkit.inventory.InventoryView.class);when(view.getTopInventory()).thenReturn(popup);when(view.getBottomInventory()).thenReturn(admin.core.inventory);when(view.getPlayer()).thenReturn(admin.player);var click=new org.bukkit.event.inventory.InventoryClickEvent(view,org.bukkit.event.inventory.InventoryType.SlotType.CONTAINER,0,org.bukkit.event.inventory.ClickType.LEFT,org.bukkit.event.inventory.InventoryAction.PICKUP_ALL);f.dispatcher.accept(click);assertTrue(click.isCancelled());PartyBookNativeTest.drain(f);((games.dmg.fantasystick.persistence.RevivalStore)FantasyStickLifecycleNativeTest.Fixture.field(f.plugin,"revivals")).find(dead.id()).join();for(int i=0;i<4;i++)PartyBookNativeTest.drain(f);var restored=storage.find(dead.id()).get().orElseThrow();assertFalse(restored.dead());var sheets=new games.dmg.fantasystick.items.CharacterSheets();assertEquals(1,java.util.stream.IntStream.range(0,41).filter(slot->(slot<=35||slot==40)&&sheets.identify(target.core.inventory.getItem(slot)).filter(dead.id()::equals).isPresent()).count());assertEquals(1,target.core.inventory.getItem(10).getAmount());assertEquals(dead.deathId(),new games.dmg.fantasystick.items.TailBooks().identify(target.core.inventory.getItem(10)).orElseThrow().deathId());assertEquals(restored.maximumHealth(),restored.health());assertEquals(dead.stats(),restored.stats());assertEquals(dead.level(),restored.level());assertEquals(dead.experience(),restored.experience());assertEquals(dead.unspentPoints(),restored.unspentPoints());assertEquals(dead.learned(),restored.learned());assertEquals(dead.loadout(),restored.loadout());assertEquals(dead.cooldowns(),restored.cooldowns());f.dispatcher.accept(click);assertEquals(1,java.util.stream.IntStream.range(0,41).filter(slot->(slot<=35||slot==40)&&sheets.identify(target.core.inventory.getItem(slot)).filter(dead.id()::equals).isPresent()).count());assertEquals(1,target.core.inventory.getItem(10).getAmount());assertEquals(beforeHealth,target.core.health);assertEquals(beforeMode,target.core.gameMode);assertEquals(beforeLocation,target.core.location);assertEquals(target.core.record.id(),((games.dmg.fantasystick.session.EquipmentSessions)FantasyStickLifecycleNativeTest.Fixture.field(f.plugin,"sessions")).active(target.core.id).orElseThrow().character());}}
+ @Test void failedCharacterRestoreRetainsOneSheetAndReservationWithoutFalseSuccess()throws Exception{try(var f=new FantasyStickLifecycleNativeTest.Fixture(data)){f.plugin.setEnabled(true);var admin=new FantasyStickLifecycleNativeTest.Actor(data);var target=new FantasyStickLifecycleNativeTest.Actor(data);doReturn("Admin").when(admin.player).getName();doReturn("Target").when(target.player).getName();doReturn(true).when(admin.player).hasPermission("fantasystick.admin");f.players.put(admin.core.id,admin.player);f.players.put(target.core.id,target.player);var dead=dead(data,Instant.now().minusSeconds(172800).truncatedTo(ChronoUnit.SECONDS));target.core.inventory.setItem(10,new games.dmg.fantasystick.items.TailBooks().create(dead));f.command.execute(admin.player,"fantasystick",new String[]{"revive","Target"});PartyBookNativeTest.drain(f);var popup=admin.inventories.getFirst();var corrupted=new java.util.concurrent.atomic.AtomicBoolean();target.core.mutation=()->{if(!corrupted.compareAndSet(false,true))return;try{var path=data.resolve("characters").resolve(dead.id()+".yml");java.nio.file.Files.delete(path);java.nio.file.Files.createDirectory(path);}catch(Exception e){throw new RuntimeException(e);}};var view=mock(org.bukkit.inventory.InventoryView.class);when(view.getTopInventory()).thenReturn(popup);when(view.getBottomInventory()).thenReturn(admin.core.inventory);when(view.getPlayer()).thenReturn(admin.player);f.dispatcher.accept(new org.bukkit.event.inventory.InventoryClickEvent(view,org.bukkit.event.inventory.InventoryType.SlotType.CONTAINER,0,org.bukkit.event.inventory.ClickType.LEFT,org.bukkit.event.inventory.InventoryAction.PICKUP_ALL));PartyBookNativeTest.drain(f);var revival=(games.dmg.fantasystick.persistence.RevivalStore)FantasyStickLifecycleNativeTest.Fixture.field(f.plugin,"revivals");revival.find(dead.id()).join();for(int i=0;i<3;i++)PartyBookNativeTest.drain(f);assertEquals(dead.id(),new games.dmg.fantasystick.items.CharacterSheets().identify(target.core.inventory.getItem(10)).orElseThrow());assertTrue(revival.find(dead.id()).join().isPresent());assertFalse(admin.messages.stream().anyMatch(message->message.startsWith("Administratively restored")));target.core.mutation=()->{};}}
+ @Test void competingAdministratorsCanConsumeOneDeathOnlyOnce()throws Exception{try(var f=new FantasyStickLifecycleNativeTest.Fixture(data)){f.plugin.setEnabled(true);var a=new FantasyStickLifecycleNativeTest.Actor(data);var b=new FantasyStickLifecycleNativeTest.Actor(data);var target=new FantasyStickLifecycleNativeTest.Actor(data);doReturn("AdminA").when(a.player).getName();doReturn("AdminB").when(b.player).getName();doReturn("Target").when(target.player).getName();doReturn(true).when(a.player).hasPermission("fantasystick.admin");doReturn(true).when(b.player).hasPermission("fantasystick.admin");f.players.put(a.core.id,a.player);f.players.put(b.core.id,b.player);f.players.put(target.core.id,target.player);var dead=dead(data,Instant.now().minusSeconds(172800).truncatedTo(ChronoUnit.SECONDS));target.core.inventory.setItem(10,new games.dmg.fantasystick.items.TailBooks().create(dead));f.command.execute(a.player,"fantasystick",new String[]{"revive","Target"});f.command.execute(b.player,"fantasystick",new String[]{"revive","Target"});PartyBookNativeTest.drain(f);assertEquals(1,a.inventories.size());assertEquals(1,b.inventories.size());for(var admin:java.util.List.of(a,b)){var popup=admin.inventories.getFirst();var view=mock(org.bukkit.inventory.InventoryView.class);when(view.getTopInventory()).thenReturn(popup);when(view.getBottomInventory()).thenReturn(admin.core.inventory);when(view.getPlayer()).thenReturn(admin.player);f.dispatcher.accept(new org.bukkit.event.inventory.InventoryClickEvent(view,org.bukkit.event.inventory.InventoryType.SlotType.CONTAINER,0,org.bukkit.event.inventory.ClickType.LEFT,org.bukkit.event.inventory.InventoryAction.PICKUP_ALL));}PartyBookNativeTest.drain(f);var revival=(games.dmg.fantasystick.persistence.RevivalStore)FantasyStickLifecycleNativeTest.Fixture.field(f.plugin,"revivals");revival.find(dead.id()).join();for(int i=0;i<4;i++)PartyBookNativeTest.drain(f);var storage=(games.dmg.fantasystick.persistence.CharacterStorage)FantasyStickLifecycleNativeTest.Fixture.field(f.plugin,"characters");assertFalse(storage.find(dead.id()).get().orElseThrow().dead());var sheets=new games.dmg.fantasystick.items.CharacterSheets();assertEquals(1,java.util.stream.IntStream.range(0,41).filter(slot->(slot<=35||slot==40)&&sheets.identify(target.core.inventory.getItem(slot)).filter(dead.id()::equals).isPresent()).count());}}
+ @Test void counterfeitLivingAndLifecycleCancelledSelectionsNeverChangeItems()throws Exception{try(var f=new FantasyStickLifecycleNativeTest.Fixture(data)){f.plugin.setEnabled(true);var admin=new FantasyStickLifecycleNativeTest.Actor(data);var target=new FantasyStickLifecycleNativeTest.Actor(data);doReturn("Admin").when(admin.player).getName();doReturn("Target").when(target.player).getName();doReturn(true).when(admin.player).hasPermission("fantasystick.admin");f.players.put(admin.core.id,admin.player);f.players.put(target.core.id,target.player);target.core.inventory.setItem(10,new org.bukkit.inventory.ItemStack(org.bukkit.Material.WRITTEN_BOOK));f.command.execute(admin.player,"fantasystick",new String[]{"revive","Target"});assertTrue(admin.messages.getLast().contains("no authentic"));var livingTailRecord=dead(data,Instant.now().minusSeconds(60).truncatedTo(ChronoUnit.SECONDS));var livingTail=new games.dmg.fantasystick.items.TailBooks().create(livingTailRecord);var storage=(games.dmg.fantasystick.persistence.CharacterStorage)FantasyStickLifecycleNativeTest.Fixture.field(f.plugin,"characters");storage.restoreDeathRecordAdministratively(livingTailRecord.id(),livingTailRecord.deathId(),new java.math.BigDecimal("1024")).get();target.core.inventory.setItem(10,livingTail);f.command.execute(admin.player,"fantasystick",new String[]{"revive","Target"});storage.find(livingTailRecord.id()).get();f.tick();assertTrue(admin.messages.getLast().contains("no current"));var dead=dead(data,Instant.now().minusSeconds(60).truncatedTo(ChronoUnit.SECONDS));var tail=new games.dmg.fantasystick.items.TailBooks().create(dead);target.core.inventory.setItem(10,tail);f.command.execute(admin.player,"fantasystick",new String[]{"revive","Target"});storage.find(dead.id()).get();f.tick();var popup=admin.inventories.getFirst();f.plugin.setEnabled(false);assertNull(popup.getItem(0));assertEquals(tail,target.core.inventory.getItem(10));}}
+ @Test void administrativeReservationResumesAfterRestartWithoutWeakeningDeathIdentity()throws Exception{var target=new FantasyStickLifecycleNativeTest.Actor(data);doReturn("Target").when(target.player).getName();var dead=dead(data,Instant.now().minusSeconds(172800).truncatedTo(ChronoUnit.SECONDS));var provisional=new games.dmg.fantasystick.persistence.CharacterRecord(dead.id(),dead.name(),dead.revision(),dead.stats(),dead.level(),dead.experience(),dead.unspentPoints(),dead.maximumHealth(),dead.learned(),dead.loadout(),dead.cooldowns(),dead.restrictedKills(),false,dead.deathId(),dead.diedAt());target.core.inventory.setItem(10,new games.dmg.fantasystick.items.CharacterSheets().create(provisional));var reservation=new games.dmg.fantasystick.persistence.RevivalStore.Reservation(java.util.UUID.randomUUID(),java.util.UUID.randomUUID(),target.core.id,dead.id(),dead.deathId(),Instant.now().truncatedTo(ChronoUnit.SECONDS),10,1,-1,true);try(var store=new games.dmg.fantasystick.persistence.RevivalStore(data)){assertTrue(store.reserve(reservation).join().isPresent());}try(var f=new FantasyStickLifecycleNativeTest.Fixture(data)){f.players.put(target.core.id,target.player);f.plugin.setEnabled(true);var revivals=(games.dmg.fantasystick.persistence.RevivalStore)FantasyStickLifecycleNativeTest.Fixture.field(f.plugin,"revivals");revivals.target(target.core.id).join();for(int i=0;i<4;i++)PartyBookNativeTest.drain(f);var storage=(games.dmg.fantasystick.persistence.CharacterStorage)FantasyStickLifecycleNativeTest.Fixture.field(f.plugin,"characters");assertFalse(storage.find(dead.id()).get().orElseThrow().dead());assertTrue(revivals.find(dead.id()).join().isEmpty());assertEquals(dead.id(),new games.dmg.fantasystick.items.CharacterSheets().identify(target.core.inventory.getItem(10)).orElseThrow());}}
+ @Test void multipleChoicesSelectExactItemWhilePermissionLossMovementAndTimeoutCancelWithoutMutation()throws Exception{for(String route:java.util.List.of("select-recent","select-second","permission","movement","timeout")){var dir=data.resolve(route);try(var f=new FantasyStickLifecycleNativeTest.Fixture(dir)){f.plugin.setEnabled(true);var admin=new FantasyStickLifecycleNativeTest.Actor(dir);var target=new FantasyStickLifecycleNativeTest.Actor(dir);doReturn("Admin").when(admin.player).getName();doReturn("Target").when(target.player).getName();doReturn(true).when(admin.player).hasPermission("fantasystick.admin");f.players.put(admin.core.id,admin.player);f.players.put(target.core.id,target.player);var first=dead(dir,Instant.now().minusSeconds(60).truncatedTo(ChronoUnit.SECONDS));var second=dead(dir,Instant.now().minusSeconds(86400).truncatedTo(ChronoUnit.SECONDS));var firstTail=new games.dmg.fantasystick.items.TailBooks().create(first);var secondTail=new games.dmg.fantasystick.items.TailBooks().create(second);target.core.inventory.setItem(10,firstTail);target.core.inventory.setItem(11,secondTail);var storage=(games.dmg.fantasystick.persistence.CharacterStorage)FantasyStickLifecycleNativeTest.Fixture.field(f.plugin,"characters");f.command.execute(admin.player,"fantasystick",new String[]{"revive","Target"});storage.find(first.id()).get();f.tick();var popup=admin.inventories.getFirst();assertEquals(2,java.util.stream.IntStream.range(0,popup.getSize()).filter(i->popup.getItem(i)!=null).count());assertTrue(f.delayedTicks.contains(1200L));if(route.equals("timeout")){f.delayed.getLast().run();assertEquals(firstTail,target.core.inventory.getItem(10));assertEquals(secondTail,target.core.inventory.getItem(11));continue;}var view=mock(org.bukkit.inventory.InventoryView.class);when(view.getTopInventory()).thenReturn(popup);when(view.getBottomInventory()).thenReturn(admin.core.inventory);when(view.getPlayer()).thenReturn(admin.player);if(route.equals("permission"))doReturn(false).when(admin.player).hasPermission("fantasystick.admin");if(route.equals("movement"))target.core.inventory.setItem(11,new org.bukkit.inventory.ItemStack(org.bukkit.Material.DIAMOND));int selected=route.equals("select-recent")?0:1;f.dispatcher.accept(new org.bukkit.event.inventory.InventoryClickEvent(view,org.bukkit.event.inventory.InventoryType.SlotType.CONTAINER,selected,org.bukkit.event.inventory.ClickType.LEFT,org.bukkit.event.inventory.InventoryAction.PICKUP_ALL));PartyBookNativeTest.drain(f);if(route.startsWith("select-")){var selectedRecord=route.equals("select-recent")?first:second;var revival=(games.dmg.fantasystick.persistence.RevivalStore)FantasyStickLifecycleNativeTest.Fixture.field(f.plugin,"revivals");revival.find(selectedRecord.id()).join();for(int i=0;i<3;i++)PartyBookNativeTest.drain(f);assertEquals(!route.equals("select-recent"),storage.find(first.id()).get().orElseThrow().dead());assertEquals(route.equals("select-recent"),storage.find(second.id()).get().orElseThrow().dead());if(route.equals("select-recent")){assertEquals(first.id(),new games.dmg.fantasystick.items.CharacterSheets().identify(target.core.inventory.getItem(10)).orElseThrow());assertEquals(secondTail,target.core.inventory.getItem(11));}else{assertEquals(firstTail,target.core.inventory.getItem(10));assertEquals(second.id(),new games.dmg.fantasystick.items.CharacterSheets().identify(target.core.inventory.getItem(11)).orElseThrow());}}else{assertTrue(storage.find(first.id()).get().orElseThrow().dead());assertTrue(storage.find(second.id()).get().orElseThrow().dead());assertEquals(firstTail,target.core.inventory.getItem(10));assertEquals(route.equals("movement")?org.bukkit.Material.DIAMOND:org.bukkit.Material.WRITTEN_BOOK,target.core.inventory.getItem(11).getType());}}}}
+ static games.dmg.fantasystick.persistence.CharacterRecord dead(Path data,Instant died)throws Exception{var base=new games.dmg.fantasystick.crafting.CharacterFactory().create(games.dmg.fantasystick.progression.ProgressionRules.defaults());var record=new games.dmg.fantasystick.persistence.CharacterRecord(base.id(),"Ancient Mira",base.revision(),base.stats(),7,BigInteger.valueOf(642),BigInteger.valueOf(11),java.math.BigDecimal.ZERO,java.util.Set.of("fireball"),java.util.List.of("fireball","","","","","",""),java.util.Map.of("fireball",Instant.now().plusSeconds(30)),base.restrictedKills(),true,java.util.UUID.randomUUID(),died);new games.dmg.fantasystick.persistence.YamlCharacterRepository(data).create(record);return record;}
+}

src/nativeTest/java/games/dmg/fantasystick/ChainLightningNativeTest.java

@@ -0,0 +1,240 @@
+package games.dmg.fantasystick;
+
+import static org.junit.jupiter.api.Assertions.*;
+import static org.mockito.ArgumentMatchers.*;
+import static org.mockito.Mockito.*;
+
+import games.dmg.fantasystick.ability.*;
+import games.dmg.fantasystick.party.PartyRoster;
+import games.dmg.fantasystick.persistence.CharacterRecord;
+import games.dmg.fantasystick.persistence.YamlCharacterRepository;
+import games.dmg.fantasystick.progression.Stat;
+import games.dmg.fantasystick.session.ControlInput;
+import games.dmg.fantasystick.session.EquipmentSessions;
+import java.math.BigDecimal;
+import java.math.BigInteger;
+import java.nio.file.Path;
+import java.util.*;
+import java.util.concurrent.TimeUnit;
+import org.bukkit.Location;
+import org.bukkit.damage.DamageSource;
+import org.bukkit.entity.LivingEntity;
+import org.bukkit.entity.Player;
+import org.bukkit.event.entity.EntityDamageEvent;
+import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.io.TempDir;
+
+class ChainLightningNativeTest {
+    @TempDir Path data;
+    @BeforeAll static void nativeRuntime() throws Exception { NativeRuntime.bootstrap(); }
+
+    @Test void characterBookPurchaseAssignmentAndEquippedControlExecuteNativeChain() throws Exception {
+        java.nio.file.Files.writeString(data.resolve("config.yml"), "chain-lightning-cooldown-seconds: 0\n");
+        try (var fixture = new FantasyStickLifecycleNativeTest.Fixture(data)) {
+            fixture.plugin.setEnabled(true); var caster = new FantasyStickLifecycleNativeTest.Actor(data); prepareCaster(data, caster, false);
+            fixture.players.put(caster.core.id, caster.player); fixture.activate(caster);
+            caster.core.inventory.getInventory().setSelectedSlot(0); PartyBookNativeTest.open(fixture, caster);
+            String text = PartyBookNativeTest.text(caster).replaceAll("\\s+", "");
+            assertTrue(text.contains("ChainLightning")); assertTrue(text.contains("INT20")); assertTrue(text.contains("DEX12"));
+            PartyBookNativeTest.click(fixture, caster, button(caster, "[Learn]", "chain_lightning")); drain(fixture, 2);
+            PartyBookNativeTest.click(fixture, caster, button(caster, "[3]", "chain_lightning")); drain(fixture, 2);
+            var first = mock(LivingEntity.class); var second = mock(LivingEntity.class);
+            locate(first, caster.world, UUID.randomUUID(), 10); locate(second, caster.world, UUID.randomUUID(), 14);
+            doReturn(new Location(caster.world, 0, 64, 0)).when(caster.player).getLocation();
+            doReturn(new Location(caster.world, 0, 65, 0)).when(caster.player).getEyeLocation();
+            doReturn(true).when(caster.player).hasLineOfSight(first);
+            doReturn(new org.bukkit.util.RayTraceResult(new org.bukkit.util.Vector(10, 64, 0), first))
+                .when(caster.world).rayTraceEntities(any(Location.class), any(org.bukkit.util.Vector.class), eq(16.0),
+                    org.mockito.ArgumentMatchers.<java.util.function.Predicate<org.bukkit.entity.Entity>>any());
+            doReturn(List.of(second)).when(first).getNearbyEntities(anyDouble(), anyDouble(), anyDouble()); doReturn(true).when(first).hasLineOfSight(second);
+            var damage = new LinkedHashMap<UUID, Double>(); nativeDamage(fixture, first, damage); nativeDamage(fixture, second, damage);
+            use(fixture, caster); drain(fixture, 2);
+            assertFalse(damage.isEmpty(), caster.messages.toString());
+            assertEquals(13, damage.get(first.getUniqueId()), 1.0e-10); assertEquals(9.75, damage.get(second.getUniqueId()), 1.0e-10);
+            var stored = ((games.dmg.fantasystick.persistence.CharacterStorage) FantasyStickLifecycleNativeTest.Fixture.field(fixture.plugin, "characters"))
+                .find(caster.core.record.id()).get().orElseThrow();
+            assertEquals(BigInteger.valueOf(39), stored.unspentPoints()); assertTrue(stored.learned().contains("chain_lightning"));
+            assertEquals("chain_lightning", stored.loadout().getFirst()); assertNotNull(stored.cooldowns().get("chain_lightning"));
+        }
+    }
+
+    @Test void exactChainUsesNearestUuidTiesFourTargetLimitDecayAndCancellationContinuation() {
+        var sessions = mock(EquipmentSessions.class); var parties = mock(PartyRoster.class); var caster = mock(Player.class);
+        var world = mock(org.bukkit.World.class); UUID casterId = UUID.randomUUID(); when(caster.getUniqueId()).thenReturn(casterId);
+        when(caster.getLocation()).thenReturn(new Location(world, 0, 64, 0)); when(caster.getEyeLocation()).thenReturn(new Location(world, 0, 65, 0));
+        var targets = new ArrayList<LivingEntity>();
+        for (int i = 0; i < 5; i++) { var target = mock(LivingEntity.class); when(target.getUniqueId()).thenReturn(new UUID(0, i + 1));
+            when(target.getLocation()).thenReturn(new Location(world, 4 + i * 2, 64, 0)); when(target.hasLineOfSight(any(org.bukkit.entity.Entity.class))).thenReturn(true); targets.add(target); }
+        when(caster.hasLineOfSight(targets.getFirst())).thenReturn(true);
+        when(targets.get(0).getNearbyEntities(6, 6, 6)).thenReturn(List.of(targets.get(2), targets.get(1), targets.get(1)));
+        when(targets.get(1).getNearbyEntities(6, 6, 6)).thenReturn(List.of(targets.get(3), targets.get(2)));
+        when(targets.get(2).getNearbyEntities(6, 6, 6)).thenReturn(List.of(targets.get(4), targets.get(3)));
+        when(targets.get(3).getNearbyEntities(6, 6, 6)).thenReturn(List.of(targets.get(4)));
+        var active = new EquipmentSessions.Active(casterId, UUID.randomUUID(), UUID.randomUUID());
+        var execution = execution(caster, active, targets.getFirst()); var chain = new ChainLightning(ChainLightning.Settings.defaults(), sessions, parties);
+        when(execution.definition()).thenReturn(chain.definition());
+        var attempted = new LinkedHashMap<UUID, Double>();
+        for (int i = 0; i < targets.size(); i++) { final int index = i; var target = targets.get(i);
+            doAnswer(call -> { double amount = call.getArgument(0); attempted.put(target.getUniqueId(), amount);
+                if (index != 1) chain.acceptedDamage(new EntityDamageEvent(target, EntityDamageEvent.DamageCause.LIGHTNING,
+                    (DamageSource) call.getArgument(1), amount)); return null;
+            }).when(target).damage(anyDouble(), any(DamageSource.class)); }
+        chain.activate(execution);
+        assertEquals(List.of(targets.get(0).getUniqueId(), targets.get(1).getUniqueId(), targets.get(2).getUniqueId(), targets.get(3).getUniqueId()),
+            List.copyOf(attempted.keySet()));
+        assertArrayEquals(new double[]{13, 9.75, 7.3125, 5.484375}, attempted.values().stream().mapToDouble(Double::doubleValue).toArray(), 1.0e-10);
+        verify(targets.get(4), never()).damage(anyDouble(), any(DamageSource.class));
+        verify(execution, times(3)).report(eq(AbilityReport.Type.DAMAGE), any(), any());
+    }
+
+    @Test void boundsVisibilityExclusionsAndEligibilityRaceStopInvalidStrikes() {
+        var sessions = mock(EquipmentSessions.class); var parties = mock(PartyRoster.class); var caster = mock(Player.class);
+        var world = mock(org.bukkit.World.class); when(caster.getUniqueId()).thenReturn(UUID.randomUUID());
+        when(caster.getLocation()).thenReturn(new Location(world, 0, 64, 0)); when(caster.getEyeLocation()).thenReturn(new Location(world, 0, 65, 0));
+        var initial = mock(LivingEntity.class); locate(initial, world, UUID.randomUUID(), 16); when(caster.hasLineOfSight(initial)).thenReturn(true);
+        var blocked = mock(LivingEntity.class); locate(blocked, world, UUID.randomUUID(), 18); when(initial.hasLineOfSight(blocked)).thenReturn(false);
+        var outside = mock(LivingEntity.class); locate(outside, world, UUID.randomUUID(), 22.01); when(initial.hasLineOfSight(outside)).thenReturn(true);
+        var ordinary = mock(Player.class); locate(ordinary, world, UUID.randomUUID(), 18); when(initial.hasLineOfSight(ordinary)).thenReturn(true);
+        when(initial.getNearbyEntities(6, 6, 6)).thenReturn(List.of(blocked, outside, ordinary));
+        var active = new EquipmentSessions.Active(caster.getUniqueId(), UUID.randomUUID(), UUID.randomUUID());
+        var execution = execution(caster, active, initial); var chain = new ChainLightning(ChainLightning.Settings.defaults(), sessions, parties);
+        when(execution.definition()).thenReturn(chain.definition()); chain.activate(execution);
+        verify(initial).damage(anyDouble(), any(DamageSource.class)); verify(blocked, never()).damage(anyDouble(), any(DamageSource.class));
+        verify(outside, never()).damage(anyDouble(), any(DamageSource.class)); verify(ordinary, never()).damage(anyDouble(), any(DamageSource.class));
+        when(execution.stillCurrent()).thenReturn(false); chain.activate(execution); verify(initial, times(1)).damage(anyDouble(), any(DamageSource.class));
+    }
+
+    @Test void jumpInspectionStopsAtSharedCandidateCeiling() {
+        var sessions = mock(EquipmentSessions.class); var parties = mock(PartyRoster.class); var caster = mock(Player.class);
+        var world = mock(org.bukkit.World.class); when(caster.getUniqueId()).thenReturn(UUID.randomUUID());
+        when(caster.getLocation()).thenReturn(new Location(world, 0, 64, 0)); when(caster.getEyeLocation()).thenReturn(new Location(world, 0, 65, 0));
+        var initial = mock(LivingEntity.class); locate(initial, world, UUID.randomUUID(), 10); when(caster.hasLineOfSight(initial)).thenReturn(true);
+        when(initial.hasLineOfSight(any(org.bukkit.entity.Entity.class))).thenReturn(true);
+        var candidates = new ArrayList<org.bukkit.entity.Entity>(); LivingEntity beyond = null;
+        for (int index = 0; index < 257; index++) {
+            var target = mock(LivingEntity.class); locate(target, world, new UUID(1, index + 1), index == 256 ? 10.1 : 15);
+            candidates.add(target); if (index == 256) beyond = target;
+        }
+        when(initial.getNearbyEntities(6, 6, 6)).thenReturn(candidates);
+        var active = new EquipmentSessions.Active(caster.getUniqueId(), UUID.randomUUID(), UUID.randomUUID());
+        var execution = execution(caster, active, initial); var chain = new ChainLightning(ChainLightning.Settings.defaults(), sessions, parties);
+        when(execution.definition()).thenReturn(chain.definition()); chain.activate(execution);
+        verify(initial).damage(anyDouble(), any(DamageSource.class)); verify(beyond, never()).damage(anyDouble(), any(DamageSource.class));
+    }
+
+    @Test void definitionFormulaAndArbitraryPrecisionAreExact() {
+        var chain = new ChainLightning(ChainLightning.Settings.defaults(), mock(EquipmentSessions.class), mock(PartyRoster.class));
+        var definition = chain.definition(); assertEquals("chain_lightning", definition.id()); assertEquals(org.bukkit.Material.LIGHTNING_ROD, definition.icon());
+        assertEquals(java.time.Duration.ofSeconds(18), definition.cooldown()); assertEquals(BigInteger.ONE, definition.pointCost());
+        assertEquals(BigInteger.valueOf(20), definition.requirements().get(Stat.INT)); assertEquals(BigInteger.valueOf(12), definition.requirements().get(Stat.DEX));
+        assertEquals(BigInteger.valueOf(13), ChainLightning.initialDamage(BigInteger.valueOf(20)));
+        assertEquals(BigInteger.valueOf(7), ChainLightning.initialDamage(BigInteger.valueOf(9)));
+        var huge = BigInteger.TEN.pow(500); assertEquals(huge.subtract(BigInteger.TEN).divide(BigInteger.TWO).add(BigInteger.valueOf(8)), ChainLightning.initialDamage(huge));
+    }
+
+    @Test void pluginLoadsEverySettingAndAdminPublishesOnlyAfterDurableSave() throws Exception {
+        java.nio.file.Files.writeString(data.resolve("config.yml"), "chain-lightning-base-damage: 9\nchain-lightning-cooldown-seconds: 4\n"
+            + "chain-lightning-initial-range-blocks: 15\nchain-lightning-jump-range-blocks: 5\nchain-lightning-additional-targets: 2\nchain-lightning-jump-multiplier: 0.5\n");
+        try (var fixture = new FantasyStickLifecycleNativeTest.Fixture(data)) {
+            fixture.plugin.setEnabled(true); var registry = (AbilityRegistry) FantasyStickLifecycleNativeTest.Fixture.field(fixture.plugin, "abilityRegistry");
+            var definition = registry.find("chain_lightning").orElseThrow(); assertEquals(new BigDecimal("9"), definition.parameters().get("base-damage"));
+            assertEquals(java.time.Duration.ofSeconds(4), definition.cooldown());
+            assertEquals(0, new BigDecimal("15").compareTo(definition.parameters().get("initial-range")));
+            assertEquals(0, new BigDecimal("5").compareTo(definition.parameters().get("jump-range")));
+            assertEquals(new BigDecimal("2"), definition.parameters().get("additional-targets"));
+            assertEquals(new BigDecimal("0.5"), definition.parameters().get("jump-multiplier"));
+            var sender = new EquipmentAdminCommandNativeTest.Sender(); sender.allowed = false;
+            assertTrue(fixture.command.tabComplete(sender.port, "fantasystick", new String[]{"config", "chain-lightning-"}).isEmpty());
+            fixture.command.execute(sender.port, "fantasystick", new String[]{"config", "chain-lightning-jump-range-blocks", "7"});
+            assertTrue(sender.messages.getLast().contains("Permission denied")); sender.allowed = true;
+            assertEquals(List.of("chain-lightning-additional-targets", "chain-lightning-base-damage", "chain-lightning-cooldown-seconds",
+                "chain-lightning-initial-range-blocks", "chain-lightning-jump-multiplier", "chain-lightning-jump-range-blocks"),
+                fixture.command.tabComplete(sender.port, "fantasystick", new String[]{"config", "chain-lightning-"}));
+            assertEquals(List.of("5", "6"), fixture.command.tabComplete(sender.port, "fantasystick",
+                new String[]{"config", "chain-lightning-jump-range-blocks", ""}));
+            fixture.command.execute(sender.port, "fantasystick", new String[]{"config", "chain-lightning-jump-range-blocks"});
+            assertTrue(sender.messages.getLast().contains("=5"));
+            for (String[] update : List.of(new String[]{"chain-lightning-base-damage", "10"},
+                    new String[]{"chain-lightning-cooldown-seconds", "3"}, new String[]{"chain-lightning-initial-range-blocks", "14"},
+                    new String[]{"chain-lightning-jump-range-blocks", "7"}, new String[]{"chain-lightning-additional-targets", "1"},
+                    new String[]{"chain-lightning-jump-multiplier", "0.25"})) {
+                fixture.command.execute(sender.port, "fantasystick", new String[]{"config", update[0], update[1]});
+                var response = fixture.tasks.poll(5, TimeUnit.SECONDS); assertNotNull(response); response.run();
+            }
+            var configured = registry.find("chain_lightning").orElseThrow(); assertEquals(new BigDecimal("10"), configured.parameters().get("base-damage"));
+            assertEquals(java.time.Duration.ofSeconds(3), configured.cooldown());
+            assertEquals(0, new BigDecimal("14").compareTo(configured.parameters().get("initial-range")));
+            assertEquals(0, new BigDecimal("7").compareTo(configured.parameters().get("jump-range")));
+            assertEquals(new BigDecimal("1"), configured.parameters().get("additional-targets"));
+            assertEquals(new BigDecimal("0.25"), configured.parameters().get("jump-multiplier"));
+            fixture.command.execute(sender.port, "fantasystick", new String[]{"config", "chain-lightning-jump-range-blocks", "0"});
+            assertTrue(sender.messages.getLast().contains("invalid"));
+            fixture.command.execute(sender.port, "fantasystick", new String[]{"config", "chain-lightning-jump-range-blocks", "7", "extra"});
+            assertTrue(sender.messages.getLast().contains("Usage"));
+            fixture.plugin.setEnabled(false); fixture.plugin.setEnabled(true);
+            var reloaded = (AbilityRegistry) FantasyStickLifecycleNativeTest.Fixture.field(fixture.plugin, "abilityRegistry");
+            var saved = reloaded.find("chain_lightning").orElseThrow();
+            assertEquals(0, new BigDecimal("7").compareTo(saved.parameters().get("jump-range")));
+            assertEquals(new BigDecimal("0.25"), saved.parameters().get("jump-multiplier"));
+            assertEquals(java.time.Duration.ofSeconds(3), saved.cooldown());
+        }
+    }
+
+    private static void nativeDamage(FantasyStickLifecycleNativeTest.Fixture fixture, LivingEntity target, Map<UUID, Double> damage) {
+        doAnswer(call -> { double amount = call.getArgument(0); DamageSource source = call.getArgument(1);
+            var event = new org.bukkit.event.entity.EntityDamageByEntityEvent(source.getCausingEntity(), target,
+                EntityDamageEvent.DamageCause.LIGHTNING, source, amount);
+            fixture.dispatcher.accept(event); if (!event.isCancelled()) damage.put(target.getUniqueId(), event.getFinalDamage()); return null;
+        }).when(target).damage(anyDouble(), any(DamageSource.class));
+    }
+    private static void use(FantasyStickLifecycleNativeTest.Fixture fixture, FantasyStickLifecycleNativeTest.Actor actor) {
+        actor.core.inventory.getInventory().setSelectedSlot(2);
+        fixture.dispatcher.accept(new org.bukkit.event.player.PlayerInteractEvent(actor.player,
+            org.bukkit.event.block.Action.RIGHT_CLICK_AIR, actor.core.inventory.getItem(2), null,
+            org.bukkit.block.BlockFace.SELF, org.bukkit.inventory.EquipmentSlot.HAND));
+    }
+    private static void drain(FantasyStickLifecycleNativeTest.Fixture fixture, int count) throws Exception {
+        for (int index = 0; index < count; index++) PartyBookNativeTest.drain(fixture);
+    }
+    private static net.minecraft.network.chat.ClickEvent.Custom button(
+            FantasyStickLifecycleNativeTest.Actor actor, String label, String ability) {
+        var book = org.bukkit.craftbukkit.inventory.CraftItemStack.asNMSCopy(actor.books.getLast())
+            .get(net.minecraft.core.component.DataComponents.WRITTEN_BOOK_CONTENT); assertNotNull(book);
+        for (var page : book.pages()) { var found = button(page.raw(), label, ability); if (found != null) return found; }
+        throw new AssertionError("Missing " + label + " for " + ability);
+    }
+    private static net.minecraft.network.chat.ClickEvent.Custom button(
+            net.minecraft.network.chat.Component component, String label, String ability) {
+        if (component.getString().equals(label)
+                && component.getStyle().getClickEvent() instanceof net.minecraft.network.chat.ClickEvent.Custom custom
+                && custom.payload().orElse(null) instanceof net.minecraft.nbt.StringTag payload
+                && payload.value().contains(":" + ability)) return custom;
+        for (var child : component.getSiblings()) { var found = button(child, label, ability); if (found != null) return found; }
+        return null;
+    }
+    private static void prepareCaster(Path directory, FantasyStickLifecycleNativeTest.Actor actor, boolean learned) throws Exception {
+        java.nio.file.Files.createDirectories(directory); var repository = new YamlCharacterRepository(directory);
+        var old = repository.load(actor.core.record.id()).orElseThrow(); var stats = new EnumMap<>(old.stats());
+        stats.put(Stat.INT, BigInteger.valueOf(20)); stats.put(Stat.DEX, BigInteger.valueOf(12));
+        repository.replace(new CharacterRecord(old.id(), old.name(), old.revision().add(BigInteger.ONE), stats,
+            old.level(), old.experience(), BigInteger.valueOf(learned ? 39 : 40), old.health(),
+            learned ? Set.of("chain_lightning") : old.learned(), learned ? List.of("chain_lightning", "", "", "", "", "", "") : old.loadout(),
+            old.cooldowns(), old.restrictedKills(), false, null, null), old.revision());
+    }
+
+    private static AbilityExecution execution(Player source, EquipmentSessions.Active active, LivingEntity target) {
+        var execution = mock(AbilityExecution.class); var input = mock(ControlInput.class);
+        when(input.player()).thenReturn(source); when(input.session()).thenReturn(active); when(input.target()).thenReturn(target);
+        when(execution.input()).thenReturn(input); when(execution.stillCurrent()).thenReturn(true);
+        var record = new games.dmg.fantasystick.crafting.CharacterFactory().create(games.dmg.fantasystick.progression.ProgressionRules.defaults());
+        var stats = new EnumMap<>(record.stats()); stats.put(Stat.INT, BigInteger.valueOf(20));
+        when(execution.character()).thenReturn(new CharacterRecord(active.character(), record.name(), record.revision(), stats,
+            record.level(), record.experience(), record.unspentPoints(), record.health(), Set.of("chain_lightning"),
+            List.of("chain_lightning", "", "", "", "", "", ""), record.cooldowns(), record.restrictedKills(), false, null, null));
+        return execution;
+    }
+    private static void locate(LivingEntity entity, org.bukkit.World world, UUID id, double x) {
+        when(entity.getUniqueId()).thenReturn(id); when(entity.getLocation()).thenReturn(new Location(world, x, 64, 0));
+    }
+}

src/nativeTest/java/games/dmg/fantasystick/CharacterSheetRecipeBookNativeTest.java

@@ -0,0 +1,154 @@
+package games.dmg.fantasystick;
+
+import static org.junit.jupiter.api.Assertions.*;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.Mockito.*;
+
+import games.dmg.fantasystick.items.CharacterSheets;
+import java.util.ArrayList;
+import java.util.LinkedHashSet;
+import java.util.List;
+import java.util.Optional;
+import java.util.OptionalInt;
+import org.bukkit.Bukkit;
+import org.bukkit.Material;
+import org.bukkit.Server;
+import org.bukkit.craftbukkit.inventory.CraftItemFactory;
+import org.bukkit.craftbukkit.inventory.CraftItemStack;
+import org.bukkit.craftbukkit.inventory.CraftRecipe;
+import org.bukkit.craftbukkit.util.CraftMagicNumbers;
+import org.bukkit.inventory.ItemStack;
+import org.bukkit.plugin.PluginManager;
+import org.junit.jupiter.api.AfterAll;
+import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+
+/** Pinned Purpur recipe-book persistence and placement without starting a listening server/client. */
+class CharacterSheetRecipeBookNativeTest {
+    private static Server previousServer;
+    private static Server server;
+
+    @BeforeAll static void bootstrap() throws Exception {
+        NativeRuntime.bootstrap(); previousServer = Bukkit.getServer(); server = mock(Server.class); setServer(server);
+    }
+    @BeforeEach void configure() {
+        reset(server);
+        when(server.getItemFactory()).thenAnswer(call -> CraftItemFactory.instance());
+        when(server.getUnsafe()).thenReturn(CraftMagicNumbers.INSTANCE);
+        when(server.isPrimaryThread()).thenReturn(true);
+    }
+    @AfterAll static void restore() throws Exception { setServer(previousServer); }
+    private static void setServer(Server value) throws Exception {
+        var field = Bukkit.class.getDeclaredField("server"); field.setAccessible(true); field.set(null, value);
+    }
+
+    @Test void nativeBookAwardsOneMiscHighlightAndPreservesItWithUnrelatedState() {
+        var bukkit = new CharacterSheets().recipe(); var nativeRecipe = nativeRecipe(bukkit); var key = key();
+        var holder = new net.minecraft.world.item.crafting.RecipeHolder<>(key, nativeRecipe);
+        var events = new ArrayList<org.bukkit.event.Event>(); var manager = mock(PluginManager.class);
+        doAnswer(call -> { events.add(call.getArgument(0)); return null; }).when(manager).callEvent(any());
+        when(server.getPluginManager()).thenReturn(manager);
+        var book = new Book((requested, consumer) -> consumer.accept(new net.minecraft.world.item.crafting.display.RecipeDisplayEntry(
+            new net.minecraft.world.item.crafting.display.RecipeDisplayId(7), nativeRecipe.display().getFirst(),
+            OptionalInt.empty(), nativeRecipe.recipeBookCategory(), Optional.of(nativeRecipe.placementInfo().ingredients()))));
+        var player = mock(net.minecraft.server.level.ServerPlayer.class);
+        when(player.getBukkitEntity()).thenReturn(mock(org.bukkit.craftbukkit.entity.CraftPlayer.class));
+        when(player.getAdvancements()).thenReturn(mock(net.minecraft.server.PlayerAdvancements.class));
+
+        assertEquals(1, book.addRecipes(List.of(holder), player));
+        assertEquals(0, book.addRecipes(List.of(holder), player));
+        assertTrue(book.contains(key));
+        assertEquals(List.of(key), book.pack().highlight());
+        assertEquals(net.minecraft.world.item.crafting.CraftingBookCategory.MISC, nativeRecipe.category());
+        assertEquals(1, events.size());
+        var event = assertInstanceOf(org.bukkit.event.player.PlayerRecipeDiscoverEvent.class, events.getFirst());
+        assertTrue(event.shouldShowNotification());
+
+        var unrelated = nativeKey(new org.bukkit.NamespacedKey("minecraft", "stick"));
+        book.add(unrelated); book.highlight(unrelated);
+        book.setBookSetting(net.minecraft.world.inventory.RecipeBookType.CRAFTING, true, true);
+        var tag = net.minecraft.stats.ServerRecipeBook.Packed.CODEC.encodeStart(net.minecraft.nbt.NbtOps.INSTANCE, book.pack()).getOrThrow();
+        var packed = net.minecraft.stats.ServerRecipeBook.Packed.CODEC.parse(net.minecraft.nbt.NbtOps.INSTANCE, tag).getOrThrow();
+        var restored = new Book(); restored.loadUntrusted(packed, ignored -> true);
+        assertTrue(restored.contains(key)); assertTrue(restored.contains(unrelated));
+        assertEquals(new LinkedHashSet<>(packed.highlight()), new LinkedHashSet<>(restored.pack().highlight()));
+        assertTrue(restored.isOpen(net.minecraft.world.inventory.RecipeBookType.CRAFTING));
+        assertTrue(restored.isFiltering(net.minecraft.world.inventory.RecipeBookType.CRAFTING));
+        int known = restored.pack().known().size(); int highlighted = restored.pack().highlight().size();
+        restored.add(key);
+        assertEquals(known, restored.pack().known().size()); assertEquals(highlighted, restored.pack().highlight().size());
+    }
+
+    @Test void nativeAutofillPlacesExactIngredientsAndPreviewCannotMintACharacter() {
+        var sheets = new CharacterSheets(); var bukkit = sheets.recipe(); var nativeRecipe = nativeRecipe(bukkit);
+        var holder = new net.minecraft.world.item.crafting.RecipeHolder<>(key(), nativeRecipe);
+        var player = mock(net.minecraft.world.entity.player.Player.class);
+        when(player.level()).thenReturn(mock(net.minecraft.world.level.Level.class));
+        when(player.getBukkitEntity()).thenReturn(mock(org.bukkit.craftbukkit.entity.CraftPlayer.class));
+        var inventory = new net.minecraft.world.entity.player.Inventory(player, new net.minecraft.world.entity.EntityEquipment());
+        when(player.getInventory()).thenReturn(inventory);
+        var ingredients = List.of(Material.STICK, Material.PAPER, Material.FEATHER, Material.INK_SAC);
+        for (int index = 0; index < ingredients.size(); index++) inventory.setItem(index,
+            CraftItemStack.asNMSCopy(new ItemStack(ingredients.get(index))));
+        var unrelated = new ItemStack(Material.DIAMOND, 7); inventory.setItem(20, CraftItemStack.asNMSCopy(unrelated));
+        var grid = new net.minecraft.world.inventory.TransientCraftingContainer(
+            mock(net.minecraft.world.inventory.AbstractContainerMenu.class), 3, 3, player);
+        grid.setItem(0, CraftItemStack.asNMSCopy(new ItemStack(Material.DIRT, 3)));
+        var slots = java.util.stream.IntStream.range(0, 9)
+            .mapToObj(slot -> new net.minecraft.world.inventory.Slot(grid, slot, 0, 0)).toList();
+        var access = new net.minecraft.recipebook.ServerPlaceRecipe.CraftingMenuAccess<net.minecraft.world.item.crafting.ShapelessRecipe>() {
+            @Override public void fillCraftSlotsStackedContents(net.minecraft.world.entity.player.StackedItemContents contents) {
+                grid.fillStackedContents(contents);
+            }
+            @Override public void clearCraftingContent() { grid.clearContent(); }
+            @Override public boolean recipeMatches(net.minecraft.world.item.crafting.RecipeHolder<net.minecraft.world.item.crafting.ShapelessRecipe> candidate) {
+                return candidate.value().matches(input(grid), mock(net.minecraft.world.level.Level.class));
+            }
+        };
+
+        var action = net.minecraft.recipebook.ServerPlaceRecipe.placeRecipe(
+            access, 3, 3, slots, slots, inventory, holder, false, false);
+
+        assertEquals(net.minecraft.world.inventory.RecipeBookMenu.PostPlaceAction.NOTHING, action);
+        assertTrue(nativeRecipe.matches(input(grid), mock(net.minecraft.world.level.Level.class)));
+        for (var material : ingredients) assertEquals(1, count(grid, material));
+        assertEquals(unrelated, CraftItemStack.asBukkitCopy(inventory.getItem(20)));
+        assertEquals(3, inventory.getNonEquipmentItems().stream().map(CraftItemStack::asBukkitCopy)
+            .filter(item -> item.getType() == Material.DIRT).mapToInt(ItemStack::getAmount).sum());
+        var before = grid.getItems().stream().map(CraftItemStack::asBukkitCopy).toList();
+        var preview = CraftItemStack.asBukkitCopy(nativeRecipe.assemble(input(grid)));
+        assertEquals(Material.PAPER, preview.getType()); assertTrue(sheets.identify(preview).isEmpty());
+        assertTrue(preview.getItemMeta().getPersistentDataContainer().isEmpty());
+        assertEquals(before, grid.getItems().stream().map(CraftItemStack::asBukkitCopy).toList());
+    }
+
+    private static net.minecraft.world.item.crafting.ShapelessRecipe nativeRecipe(org.bukkit.inventory.ShapelessRecipe recipe) {
+        var ingredients = recipe.getChoiceList().stream().map(choice -> CraftRecipe.toIngredient(choice, false)).toList();
+        return new net.minecraft.world.item.crafting.ShapelessRecipe(
+            new net.minecraft.world.item.crafting.Recipe.CommonInfo(true),
+            new net.minecraft.world.item.crafting.CraftingRecipe.CraftingBookInfo(
+                CraftRecipe.getCategory(recipe.getCategory()), recipe.getGroup()),
+            CraftItemStack.asTemplate(recipe.getResult()), ingredients);
+    }
+    private static net.minecraft.resources.ResourceKey<net.minecraft.world.item.crafting.Recipe<?>> key() {
+        return nativeKey(CharacterSheets.RECIPE);
+    }
+    private static net.minecraft.resources.ResourceKey<net.minecraft.world.item.crafting.Recipe<?>> nativeKey(org.bukkit.NamespacedKey key) {
+        return net.minecraft.resources.ResourceKey.create(net.minecraft.core.registries.Registries.RECIPE,
+            net.minecraft.resources.Identifier.fromNamespaceAndPath(key.getNamespace(), key.getKey()));
+    }
+    private static net.minecraft.world.item.crafting.CraftingInput input(net.minecraft.world.Container grid) {
+        return net.minecraft.world.item.crafting.CraftingInput.of(3, 3,
+            java.util.stream.IntStream.range(0, grid.getContainerSize()).mapToObj(grid::getItem).toList());
+    }
+    private static long count(net.minecraft.world.Container grid, Material material) {
+        return java.util.stream.IntStream.range(0, grid.getContainerSize()).mapToObj(grid::getItem)
+            .map(CraftItemStack::asBukkitCopy).filter(item -> item.getType() == material).mapToInt(ItemStack::getAmount).sum();
+    }
+    private static final class Book extends net.minecraft.stats.ServerRecipeBook {
+        Book() { this((key, consumer) -> { }); }
+        Book(DisplayResolver resolver) { super(resolver); }
+        void highlight(net.minecraft.resources.ResourceKey<net.minecraft.world.item.crafting.Recipe<?>> key) { highlight.add(key); }
+    }
+}

src/nativeTest/java/games/dmg/fantasystick/CharacterSheetsNativeTest.java

@@ -46,12 +46,16 @@ class CharacterSheetsNativeTest {
         meta.displayName(Component.text("Different presentation"));
         sheet.setItemMeta(meta);
         assertEquals(record.id(), sheets.identify(sheet).orElseThrow());
+        assertEquals(CharacterSheets.MODEL, sheet.getItemMeta().getItemModel());
+        var legacy = sheet.clone(); var legacyMeta = legacy.getItemMeta(); legacyMeta.setItemModel(null); legacy.setItemMeta(legacyMeta);
+        assertTrue(sheets.applyModel(legacy)); assertEquals(CharacterSheets.MODEL, legacy.getItemMeta().getItemModel());
         var fake = new ItemStack(Material.PAPER);
         var fakeMeta = fake.getItemMeta();
         fakeMeta.displayName(meta.displayName());
         fakeMeta.lore(meta.lore());
         fake.setItemMeta(fakeMeta);
         assertTrue(sheets.identify(fake).isEmpty());
+        assertFalse(sheets.applyModel(fake)); assertFalse(fake.getItemMeta().hasItemModel());
         assertTrue(sheets.identify(new ItemStack(Material.STICK)).isEmpty());
         assertTrue(sheets.identify(null).isEmpty());
         var version = new NamespacedKey("fantasystick", "sheet_version");
@@ -72,6 +76,7 @@ class CharacterSheetsNativeTest {
         var sheets = new CharacterSheets();
         var recipe = sheets.recipe();
         assertEquals(new NamespacedKey("fantasystick", "character_sheet"), recipe.getKey());
+        assertEquals(org.bukkit.inventory.recipe.CraftingBookCategory.MISC, recipe.getCategory());
         assertEquals(4, recipe.getChoiceList().size());
         assertTrue(recipe.getChoiceList().stream().allMatch(choice ->
             choice instanceof RecipeChoice.MaterialChoice materials && materials.getChoices().size() == 1));
@@ -84,6 +89,7 @@ class CharacterSheetsNativeTest {
             assertEquals(1, preview.getAmount());
             assertTrue(sheets.identify(preview).isEmpty());
             assertTrue(preview.getItemMeta().getPersistentDataContainer().isEmpty());
+            assertFalse(preview.getItemMeta().hasItemModel());
             assertEquals(List.of(Component.text("Character sheet:"), Component.text("Place in off hand"),
                 Component.text("to enter fantasy world.")), preview.getItemMeta().lore());
         }

src/nativeTest/java/games/dmg/fantasystick/EquipmentAdminCommandNativeTest.java

@@ -17,6 +17,106 @@ class EquipmentAdminCommandNativeTest {
     @TempDir Path data;
     @BeforeAll static void bootstrap() throws Exception { NativeRuntime.bootstrap(); }
 
+    @Test void registeredGivePersistsOneFreshSheetThenDeliversActivatesAndReloads() throws Exception {
+        try (var f = new FantasyStickLifecycleNativeTest.Fixture(data)) {
+            f.plugin.setEnabled(true);
+            var target = new FantasyStickLifecycleNativeTest.Actor(data); f.players.put(target.core.id, target.player);
+            var before = target.core.snapshot(); var sender = new Sender();
+            assertTrue(f.command.execute(sender.port, "fantasystick", new String[]{"give", "Account"}));
+            assertTrue(sender.messages.isEmpty(), "Queued persistence is not successful delivery");
+            ((games.dmg.fantasystick.persistence.CharacterStorage) FantasyStickLifecycleNativeTest.Fixture.field(f.plugin, "characters"))
+                .find(java.util.UUID.randomUUID()).get(5, java.util.concurrent.TimeUnit.SECONDS);
+            var callback = f.tasks.poll(5, java.util.concurrent.TimeUnit.SECONDS); assertNotNull(callback); callback.run(); callback.run();
+            assertTrue(sender.messages.getLast().contains("Issued one new character sheet"));
+            assertFalse(java.util.Arrays.equals(before, target.core.snapshot()));
+            var sheets = new games.dmg.fantasystick.items.CharacterSheets();
+            var delivered = java.util.stream.IntStream.range(0, 36).mapToObj(target.core.inventory::getItem)
+                .filter(item -> sheets.identify(item).isPresent()).filter(item -> !sheets.identify(item).orElseThrow().equals(target.core.record.id())).toList();
+            assertEquals(1, delivered.size(), "Repeated callback must not duplicate delivery");
+            assertEquals(target.core.record.id(),sheets.identify(target.core.inventory.getItemInOffHand()).orElseThrow());
+            assertTrue(((games.dmg.fantasystick.session.EquipmentSessions) FantasyStickLifecycleNativeTest.Fixture.field(f.plugin,"sessions")).active(target.core.id).isEmpty());
+            var id = sheets.identify(delivered.getFirst()).orElseThrow();
+            var storage = (games.dmg.fantasystick.persistence.CharacterStorage) FantasyStickLifecycleNativeTest.Fixture.field(f.plugin, "characters");
+            var record = storage.find(id).get(5, java.util.concurrent.TimeUnit.SECONDS).orElseThrow();
+            assertEquals(java.math.BigInteger.valueOf(40), record.unspentPoints()); assertEquals(1, record.level());
+            assertEquals(java.math.BigInteger.ZERO, record.experience()); assertFalse(record.dead()); assertTrue(record.learned().isEmpty());
+            assertTrue(record.stats().values().stream().allMatch(java.math.BigInteger.ZERO::equals));assertEquals(new java.math.BigDecimal("10"),record.health());
+            assertEquals(java.util.Collections.nCopies(7,""),record.loadout());assertTrue(record.cooldowns().isEmpty());assertFalse(record.name().isBlank());
+            target.core.inventory.remove(delivered.getFirst()); target.core.inventory.setItemInOffHand(delivered.getFirst());
+            f.activate(target); assertEquals(id, ((games.dmg.fantasystick.session.EquipmentSessions) FantasyStickLifecycleNativeTest.Fixture.field(f.plugin, "sessions")).active(target.core.id).orElseThrow().character());
+            f.plugin.setEnabled(false); f.plugin.setEnabled(true);
+            assertEquals(record, ((games.dmg.fantasystick.persistence.CharacterStorage) FantasyStickLifecycleNativeTest.Fixture.field(f.plugin, "characters")).find(id).get(5, java.util.concurrent.TimeUnit.SECONDS).orElseThrow());
+        }
+    }
+
+    @Test void giveCompletionAndRejectedExecutionArePermissionAwareStrictAndReadOnly() throws Exception {
+        try (var f = new FantasyStickLifecycleNativeTest.Fixture(data)) {
+            f.plugin.setEnabled(true); var target = new FantasyStickLifecycleNativeTest.Actor(data); f.players.put(target.core.id,target.player);
+            var sender=new Sender();
+            assertEquals(List.of("config","experience","give","inspect","recover"),f.command.tabComplete(sender.port,"fantasystick",new String[]{""}));
+            assertEquals(List.of("give"),f.command.tabComplete(sender.port,"fantasystick",new String[]{"g"}));
+            assertEquals(List.of("Account"),f.command.tabComplete(sender.port,"fantasystick",new String[]{"give",""}));
+            assertEquals(List.of("Account"),f.command.tabComplete(sender.port,"fantasystick",new String[]{"give","Acc"}));
+            assertTrue(f.command.tabComplete(sender.port,"fantasystick",new String[]{"give","Account",""}).isEmpty());
+            sender.allowed=false;assertTrue(f.command.tabComplete(sender.port,"fantasystick",new String[]{"give",""}).isEmpty());
+            var original=target.core.snapshot();f.command.getExecutor().onCommand(sender.port,f.command,"fantasystick",new String[]{"give","Account"});
+            sender.allowed=true;for(String[] args:List.of(new String[]{"give"},new String[]{"give","Missing"},new String[]{"give","Account","extra"}))f.command.execute(sender.port,"fantasystick",args);
+            assertArrayEquals(original,target.core.snapshot());assertTrue(f.tasks.isEmpty());
+            assertEquals(1,java.nio.file.Files.list(data.resolve("characters")).filter(path->path.toString().endsWith(".yml")).count());
+            for(int slot=0;slot<36;slot++)target.core.inventory.setItem(slot,new org.bukkit.inventory.ItemStack(org.bukkit.Material.STONE));
+            var full=target.core.snapshot();f.command.execute(sender.port,"fantasystick",new String[]{"give","Account"});assertTrue(sender.messages.getLast().contains("no inventory space"));
+            assertArrayEquals(full,target.core.snapshot());assertTrue(f.tasks.isEmpty());assertEquals(1,java.nio.file.Files.list(data.resolve("characters")).filter(path->path.toString().endsWith(".yml")).count());
+        }
+    }
+
+    @Test void giveSaveFailureDisconnectSlotRaceAndLifecycleInterruptionNeverDuplicateOrOverwrite() throws Exception {
+        for(String route:List.of("save","disconnect","slot","close")){var dir=data.resolve(route);java.nio.file.Files.createDirectories(dir);try(var f=new FantasyStickLifecycleNativeTest.Fixture(dir)){
+            f.plugin.setEnabled(true);var target=new FantasyStickLifecycleNativeTest.Actor(dir);f.players.put(target.core.id,target.player);var sender=new Sender();var original=target.core.snapshot();
+            var storage=(games.dmg.fantasystick.persistence.CharacterStorage)FantasyStickLifecycleNativeTest.Fixture.field(f.plugin,"characters");
+            var worker=(java.util.concurrent.ExecutorService)FantasyStickLifecycleNativeTest.Fixture.field(storage,"worker");var entered=new java.util.concurrent.CountDownLatch(1);var release=new java.util.concurrent.CountDownLatch(1);worker.execute(()->{entered.countDown();try{release.await(5,java.util.concurrent.TimeUnit.SECONDS);}catch(InterruptedException e){Thread.currentThread().interrupt();}});assertTrue(entered.await(5,java.util.concurrent.TimeUnit.SECONDS));
+            f.command.execute(sender.port,"fantasystick",new String[]{"give","Account"});
+            if(route.equals("save")){var issuer=FantasyStickLifecycleNativeTest.Fixture.field(f.command.getExecutor(),"characterIssuer");var pending=(java.util.Map<?,?>)FantasyStickLifecycleNativeTest.Fixture.field(issuer,"pending");var attempt=pending.values().iterator().next();var record=(games.dmg.fantasystick.persistence.CharacterRecord)FantasyStickLifecycleNativeTest.Fixture.field(attempt,"record");java.nio.file.Files.createDirectory(dir.resolve("characters").resolve(record.id()+".yml"));}
+            release.countDown();storage.find(java.util.UUID.randomUUID()).get(5,java.util.concurrent.TimeUnit.SECONDS);var callback=f.tasks.poll(5,java.util.concurrent.TimeUnit.SECONDS);assertNotNull(callback);
+            if(route.equals("disconnect"))target.core.online=false;if(route.equals("slot"))target.core.inventory.setItem(1,new org.bukkit.inventory.ItemStack(org.bukkit.Material.DIAMOND));if(route.equals("close"))f.plugin.setEnabled(false);callback.run();
+            if(!route.equals("close"))storage.find(java.util.UUID.randomUUID()).get(5,java.util.concurrent.TimeUnit.SECONDS);
+            assertFalse(sender.messages.stream().anyMatch(message->message.startsWith("Issued one")));assertEquals(route.equals("slot")?org.bukkit.Material.DIAMOND:original[1]==null?null:original[1].getType(),target.core.inventory.getItem(1)==null?null:target.core.inventory.getItem(1).getType());
+            if(!route.equals("save"))assertEquals(1,java.nio.file.Files.list(dir.resolve("characters")).filter(path->path.toString().endsWith(".yml")).count());
+            release.countDown();}}
+    }
+
+    @Test void recoveryCompletionIsPermissionAwarePrefixFilteredUuidOnlyAndReadOnly() throws Exception {
+        try (var f = new FantasyStickLifecycleNativeTest.Fixture(data)) {
+            f.plugin.setEnabled(true);
+            var first = new FantasyStickLifecycleNativeTest.Actor(data);
+            var second = new FantasyStickLifecycleNativeTest.Actor(data);
+            var offline = new FantasyStickLifecycleNativeTest.Actor(data);
+            offline.core.online = false;
+            f.players.put(first.core.id, first.player); f.players.put(second.core.id, second.player); f.players.put(offline.core.id, offline.player);
+            var sender = new Sender();
+            var expected = java.util.stream.Stream.of(first.core.id.toString(), second.core.id.toString()).sorted().toList();
+            assertEquals(List.of("config", "experience", "give", "inspect", "recover"), f.command.tabComplete(sender.port, "fantasystick", new String[]{""}));
+            assertEquals(List.of("inspect"), f.command.tabComplete(sender.port, "fantasystick", new String[]{"in"}));
+            assertEquals(List.of("recover"), f.command.tabComplete(sender.port, "fantasystick", new String[]{"rec"}));
+            assertEquals(expected, f.command.tabComplete(sender.port, "fantasystick", new String[]{"inspect", ""}));
+            String prefix = expected.getFirst().substring(0, 8);
+            assertEquals(expected.stream().filter(id -> id.startsWith(prefix)).toList(),
+                f.command.tabComplete(sender.port, "fantasystick", new String[]{"recover", prefix}));
+            assertFalse(f.command.tabComplete(sender.port, "fantasystick", new String[]{"inspect", ""}).contains("Account"));
+            assertTrue(f.command.tabComplete(sender.port, "fantasystick", new String[]{"inspect", expected.getFirst(), ""}).isEmpty());
+            assertTrue(f.command.tabComplete(sender.port, "fantasystick", new String[]{"unknown", ""}).isEmpty());
+            assertEquals(List.of("adventure-mode"), f.command.tabComplete(sender.port, "fantasystick", new String[]{"config", "adventure-m"}));
+            assertEquals(List.of("false", "true"), f.command.tabComplete(sender.port, "fantasystick", new String[]{"config", "adventure-mode", ""}));
+            assertEquals(List.of("true"), f.command.tabComplete(sender.port, "fantasystick", new String[]{"config", "adventure-mode", "t"}));
+            assertTrue(f.command.tabComplete(sender.port, "fantasystick", new String[]{"config", "adventure-mode", "true", ""}).isEmpty());
+            sender.allowed = false;
+            for (String[] args : List.of(new String[]{""}, new String[]{"inspect", ""}, new String[]{"config", ""},
+                    new String[]{"config", "adventure-mode", ""})) {
+                assertTrue(f.command.tabComplete(sender.port, "fantasystick", args).isEmpty());
+            }
+            assertTrue(f.tasks.isEmpty()); assertFalse(Files.exists(data.resolve("sessions")));
+        }
+    }
+
     @Test void adventureConfigurationCommandReadsValidatesPersistsAndReopensWithoutTouchingPlayers() throws Exception {
         try (var f = new FantasyStickLifecycleNativeTest.Fixture(data)) {
             f.plugin.setEnabled(true);

src/nativeTest/java/games/dmg/fantasystick/EquipmentSessionEventsNativeTest.java

@@ -1285,10 +1285,10 @@ class EquipmentSessionEventsNativeTest {
 
     @Test void selectedAbilityUseReachesItsHandlerWithoutVanillaThrowDrinkEquipBlockOrPlacement() throws Exception {
         try (var f = new Fixture()) {
-            String[] abilities = {"fireball", "purify", "guardian_bond", "shield_bash", "rallying_cry", "war_banner", "revive"};
+            String[] abilities = {"chain_lightning", "purify", "guardian_bond", "shield_bash", "rallying_cry", "frost_nova", "revive"};
             f.loadout(abilities);
             var a = f.actor; f.core.activate(a);
-            var target = port(org.bukkit.entity.Player.class);
+            var target = port(org.bukkit.entity.Player.class); a.targetEntity = target;
             for (int index = 0; index < abilities.length; index++) {
                 int slot = index + 2; a.inventory.getInventory().setSelectedSlot(slot);
                 var item = a.inventory.getItem(slot);

src/nativeTest/java/games/dmg/fantasystick/EquipmentSessionsNativeTest.java

@@ -1688,6 +1688,8 @@ class EquipmentSessionsNativeTest {
         Runnable beforeHealth = () -> {};
         Runnable healthMutation = () -> {};
         float attackStrength = 1;
+        boolean sneaking;
+        org.bukkit.entity.Entity targetEntity;
         ItemStack activeItem = new ItemStack(Material.AIR);
         int useStarts;
         int useClears;
@@ -1719,10 +1721,14 @@ class EquipmentSessionsNativeTest {
                     }
                     case "getOpenInventory" -> view;
                     case "getLocation" -> location.clone();
+                    case "getBoundingBox" -> new org.bukkit.util.BoundingBox(location.getX() - 0.3, location.getY(),
+                        location.getZ() - 0.3, location.getX() + 0.3, location.getY() + 1.8, location.getZ() + 0.3);
                     case "getGameMode" -> gameMode;
                     case "setGameMode" -> { beforeMode.run(); gameMode = (org.bukkit.GameMode) args[0]; yield null; }
                     case "getHealth" -> health;
                     case "getAttackCooldown" -> attackStrength;
+                    case "isSneaking" -> sneaking;
+                    case "getTargetEntity" -> targetEntity;
                     case "getActiveItem" -> activeItem.clone();
                     case "hasActiveItem" -> !activeItem.isEmpty();
                     case "getActiveItemHand" -> org.bukkit.inventory.EquipmentSlot.HAND;

src/nativeTest/java/games/dmg/fantasystick/FantasyStickLifecycleNativeTest.java

@@ -60,7 +60,8 @@ class FantasyStickLifecycleNativeTest {
             assertTrue(fixture.order.indexOf("CharacterChatNames") >= 0);
             assertTrue(fixture.order.indexOf("CharacterChatNames") < recipe);
             assertNotNull(fixture.packetListener);
-            assertEquals(5, fixture.timers.size(), "Presentation, ability cleanup, provenance, reward retry and session particles");
+            assertEquals(7, fixture.timers.size(),
+                "Presentation, ability/bond/rally cleanup, provenance, reward retry and session particles");
             assertTrue(fixture.order.indexOf("PartyCombat") >= 0);
             assertTrue(fixture.order.indexOf("PartyCombat") < recipe);
             assertTrue(fixture.order.indexOf("CombatExperience") >= 0);
@@ -73,6 +74,8 @@ class FantasyStickLifecycleNativeTest {
             assertTrue(fixture.order.indexOf("BasicAttack") < recipe);
             assertTrue(fixture.order.indexOf("NutritionPolicy") >= 0);
             assertTrue(fixture.order.indexOf("NutritionPolicy") < recipe);
+            assertTrue(fixture.order.indexOf("RecipeDiscovery") > recipe,
+                "Discovery must not become active before successful recipe registration");
             assertNotNull(fixture.command);
             assertEquals("EquipmentAdminCommand", fixture.command.getExecutor().getClass().getSimpleName());
             assertTrue(fixture.tasks.isEmpty());
@@ -138,7 +141,7 @@ class FantasyStickLifecycleNativeTest {
 
     @Test
     void recipeCollisionAndPartialListenerRegistrationFailureRollbackOnlyThisEnableAttempt() throws Exception {
-        for (String stage : List.of("collision", "recipe", "ManualCraftingGuard", "CharacterAnvilNames", "EquipmentSessionEvents", "CharacterChatNames", "ProtocolPresentation", "CombatExperience", "Fireball", "presentation-timer")) {
+        for (String stage : List.of("collision", "recipe", "ManualCraftingGuard", "CharacterAnvilNames", "EquipmentSessionEvents", "CharacterChatNames", "ProtocolPresentation", "CombatExperience", "Fireball", "presentation-timer", "RecipeDiscovery")) {
             boolean collision = stage.equals("collision");
             try (var fixture = new Fixture(data)) {
                 var existing = new org.bukkit.inventory.ShapelessRecipe(CharacterSheets.RECIPE,
@@ -173,6 +176,10 @@ class FantasyStickLifecycleNativeTest {
             try (var fixture = new Fixture(directory)) {
                 fixture.plugin.setEnabled(true);
                 var actor = new ManualCraftingControllerNativeTest.Actor(2, 2);
+                ((games.dmg.fantasystick.crafting.RecipeDiscovery) Fixture.field(fixture.plugin, "recipeDiscovery"))
+                    .discover(actor.player);
+                assertEquals(java.util.Set.of(CharacterSheets.RECIPE), actor.knownRecipes);
+                assertEquals(1, actor.recipeAwards);
                 assertFalse(java.nio.file.Files.exists(directory.resolve("characters")));
                 assertTrue(new CharacterSheets().identify(fixture.recipes.get(CharacterSheets.RECIPE).getResult()).isEmpty());
                 var cancelled = actor.fixture.event(org.bukkit.event.inventory.ClickType.LEFT,
@@ -1304,6 +1311,9 @@ class FantasyStickLifecycleNativeTest {
         int inventoryCloses;
         final List<Integer> particles = new ArrayList<>();
         final List<org.bukkit.Sound> sounds = new ArrayList<>();
+        final List<Object[]> resourcePacks = new ArrayList<>();
+        final java.util.Set<org.bukkit.NamespacedKey> knownRecipes = new java.util.LinkedHashSet<>();
+        final List<List<org.bukkit.NamespacedKey>> recipeAwards = new ArrayList<>();
         final net.minecraft.world.entity.ai.attributes.AttributeMap healthAttributes = new net.minecraft.world.entity.ai.attributes.AttributeMap(
             net.minecraft.world.entity.ai.attributes.AttributeSupplier.builder().add(net.minecraft.world.entity.ai.attributes.Attributes.MAX_HEALTH).build());
         final net.minecraft.world.entity.ai.attributes.AttributeInstance maximumHealth = java.util.Objects.requireNonNull(
@@ -1311,8 +1321,12 @@ class FantasyStickLifecycleNativeTest {
         final net.minecraft.world.food.FoodData food = new net.minecraft.world.food.FoodData();
         boolean healthScaled;
         double healthScale = 20;
+        double absorption;
         Runnable scaleMutation = () -> {};
         Runnable foodMutation = () -> {};
+        java.util.function.BiConsumer<Double, org.bukkit.entity.Entity> damage = (amount, source) -> {
+            throw new AssertionError("Native damage port not supplied");
+        };
         java.util.function.Consumer<org.bukkit.event.player.PlayerGameModeChangeEvent> modeEvents = ignored -> { };
         final org.bukkit.craftbukkit.entity.CraftPlayer player;
         final net.minecraft.server.level.ServerPlayer nativePlayer = mock(net.minecraft.server.level.ServerPlayer.class);
@@ -1345,6 +1359,8 @@ class FantasyStickLifecycleNativeTest {
                         yield new org.bukkit.craftbukkit.attribute.CraftAttributeInstance(maximumHealth, org.bukkit.attribute.Attribute.MAX_HEALTH);
                     }
                     case "getMaxHealth" -> maximumHealth.getValue();
+                    case "getAbsorptionAmount" -> absorption;
+                    case "setAbsorptionAmount" -> { absorption = (Double) args[0]; yield null; }
                     case "getFoodLevel" -> food.getFoodLevel();
                     case "setFoodLevel" -> { food.setFoodLevel((Integer) args[0]); foodMutation.run(); yield null; }
                     case "getSaturation" -> food.getSaturationLevel();
@@ -1356,6 +1372,10 @@ class FantasyStickLifecycleNativeTest {
                     case "setHealthScale" -> { healthScale = (Double) args[0]; healthScaled = true; scaleMutation.run(); yield null; }
                     case "setHealthScaled" -> { healthScaled = (Boolean) args[0]; yield null; }
                     case "getGameMode" -> core.gameMode;
+                    case "damage" -> {
+                        damage.accept((Double) args[0], args.length > 1 ? (org.bukkit.entity.Entity) args[1] : null);
+                        yield null;
+                    }
                     case "setGameMode" -> {
                         var event = new org.bukkit.event.player.PlayerGameModeChangeEvent((org.bukkit.entity.Player) call.getMock(), (org.bukkit.GameMode) args[0]);
                         modeEvents.accept(event);
@@ -1370,6 +1390,15 @@ class FantasyStickLifecycleNativeTest {
                     case "closeInventory" -> { inventoryCloses++; yield null; }
                     case "spawnParticle" -> { particles.add((Integer) args[2]); yield null; }
                     case "playSound" -> { if (args.length > 1 && args[1] instanceof org.bukkit.Sound sound) sounds.add(sound); yield null; }
+                    case "addResourcePack" -> { resourcePacks.add(args.clone()); yield null; }
+                    case "hasDiscoveredRecipe" -> knownRecipes.contains((org.bukkit.NamespacedKey) args[0]);
+                    case "discoverRecipes" -> {
+                        var requested = ((java.util.Collection<?>) args[0]).stream()
+                            .map(org.bukkit.NamespacedKey.class::cast).toList();
+                        recipeAwards.add(requested); int before = knownRecipes.size(); knownRecipes.addAll(requested);
+                        yield knownRecipes.size() - before;
+                    }
+                    case "undiscoverRecipes" -> throw new AssertionError("Recipe discovery must not be revoked");
                     default -> Proxy.getInvocationHandler(core.player).invoke(core.player, method, args);
                 };
             });

src/nativeTest/java/games/dmg/fantasystick/FrostNovaNativeTest.java

@@ -0,0 +1,324 @@
+package games.dmg.fantasystick;
+
+import static org.junit.jupiter.api.Assertions.*;
+import static org.mockito.ArgumentMatchers.*;
+import static org.mockito.Mockito.*;
+
+import games.dmg.fantasystick.ability.AbilityExecution;
+import games.dmg.fantasystick.ability.FrostNova;
+import games.dmg.fantasystick.party.PartyRoster;
+import games.dmg.fantasystick.persistence.CharacterRecord;
+import games.dmg.fantasystick.persistence.CharacterStorage;
+import games.dmg.fantasystick.persistence.YamlCharacterRepository;
+import games.dmg.fantasystick.progression.Stat;
+import games.dmg.fantasystick.session.ControlInput;
+import games.dmg.fantasystick.session.EquipmentSessions;
+import java.math.BigDecimal;
+import java.math.BigInteger;
+import java.nio.file.Path;
+import java.util.ArrayList;
+import java.util.EnumMap;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.UUID;
+import java.util.concurrent.TimeUnit;
+import net.minecraft.network.chat.ClickEvent;
+import org.bukkit.Location;
+import org.bukkit.entity.Entity;
+import org.bukkit.entity.LivingEntity;
+import org.bukkit.entity.Player;
+import org.bukkit.event.entity.EntityDamageByEntityEvent;
+import org.bukkit.event.entity.EntityDamageEvent;
+import org.bukkit.event.player.PlayerInteractEvent;
+import org.bukkit.inventory.EquipmentSlot;
+import org.bukkit.potion.PotionEffect;
+import org.bukkit.potion.PotionEffectType;
+import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.io.TempDir;
+
+class FrostNovaNativeTest {
+    @TempDir Path data;
+    @BeforeAll static void bootstrap() throws Exception { NativeRuntime.bootstrap(); }
+
+    @Test void bookAcquisitionEquippedBurstDamagesSlowsEligibleTargetsOnceAndRetainsCooldown() throws Exception {
+        try (var fixture = new FantasyStickLifecycleNativeTest.Fixture(data)) {
+            fixture.plugin.setEnabled(true);
+            assertTrue(java.util.Arrays.stream(EntityDamageEvent.getHandlerList().getRegisteredListeners())
+                .anyMatch(listener -> listener.getListener() instanceof FrostNova));
+            var caster = new FantasyStickLifecycleNativeTest.Actor(data);
+            var ally = new FantasyStickLifecycleNativeTest.Actor(data); var opponent = new FantasyStickLifecycleNativeTest.Actor(data);
+            prepareCaster(data, caster, false); fixture.players.put(caster.core.id, caster.player);
+            fixture.players.put(ally.core.id, ally.player); fixture.players.put(opponent.core.id, opponent.player);
+            fixture.activate(caster); fixture.activate(ally); fixture.activate(opponent); party(fixture, caster, ally);
+            var enemy = mock(LivingEntity.class); when(enemy.getUniqueId()).thenReturn(UUID.randomUUID());
+            when(enemy.getLocation()).thenReturn(new Location(caster.world, 3, 64, 0)); when(enemy.getType()).thenReturn(org.bukkit.entity.EntityType.ZOMBIE);
+            var vetoed = mock(LivingEntity.class); when(vetoed.getUniqueId()).thenReturn(UUID.randomUUID());
+            when(vetoed.getLocation()).thenReturn(new Location(caster.world, 2.5, 64, 0));
+            doReturn(true).when(caster.player).hasLineOfSight(enemy); doReturn(true).when(caster.player).hasLineOfSight(vetoed);
+            locate(caster, ally.player, 2, true); locate(caster, opponent.player, 4, true);
+            var ordinary = mock(Player.class); when(ordinary.getUniqueId()).thenReturn(UUID.randomUUID()); locate(caster, ordinary, 2, true);
+            doReturn(List.of(enemy, enemy, vetoed, ally.player, ordinary, opponent.player)).when(caster.player)
+                .getNearbyEntities(anyDouble(), anyDouble(), anyDouble());
+            var enemyEffects = effects(enemy); var vetoedEffects = effects(vetoed);
+            var opponentEffects = effects(opponent.player); effects(ally.player); effects(ordinary);
+            var damage = new HashMap<UUID, Double>(); damage(fixture, enemy, damage); damage(fixture, vetoed, damage); damage(fixture, opponent.player, damage);
+            class Veto implements org.bukkit.event.Listener {
+                @org.bukkit.event.EventHandler(priority = org.bukkit.event.EventPriority.LOWEST)
+                public void cancel(EntityDamageEvent event) { if (event.getEntity() == vetoed) event.setCancelled(true); }
+            }
+            fixture.dispatcher.register(new Veto(), fixture.plugin);
+
+            caster.core.inventory.getInventory().setSelectedSlot(0); PartyBookNativeTest.open(fixture, caster);
+            String text = PartyBookNativeTest.text(caster).replaceAll("\\s+", "");
+            assertTrue(text.contains("FrostNova")); assertTrue(text.contains("INT16")); assertTrue(text.contains("DEX10"));
+            assertTrue(text.contains("Cost:1")); assertTrue(text.contains("5")); assertTrue(text.contains("SlownessII"));
+            PartyBookNativeTest.click(fixture, caster, button(caster, "[Learn]", "frost_nova")); drain(fixture, 2);
+            PartyBookNativeTest.click(fixture, caster, button(caster, "[3]", "frost_nova")); drain(fixture, 2);
+            use(fixture, caster); drain(fixture, 2);
+            assertEquals(8, damage.get(enemy.getUniqueId()), 1.0e-9); assertEquals(8, damage.get(opponent.core.id), 1.0e-9);
+            assertEquals(2, damage.size(), "Duplicate, cancelled, party and ordinary targets cannot add accepted hits");
+            assertFalse(vetoedEffects.containsKey(PotionEffectType.SLOWNESS));
+            assertEquals(1, enemyEffects.get(PotionEffectType.SLOWNESS).getAmplifier());
+            assertEquals(1, opponentEffects.get(PotionEffectType.SLOWNESS).getAmplifier());
+            var stored = storage(fixture).find(caster.core.record.id()).get().orElseThrow();
+            assertEquals(BigInteger.valueOf(39), stored.unspentPoints()); assertNotNull(stored.cooldowns().get("frost_nova"));
+            assertEquals(60L, fixture.delayedTicks.getLast()); fixture.delayed.getLast().run();
+            assertFalse(enemyEffects.containsKey(PotionEffectType.SLOWNESS)); assertFalse(opponentEffects.containsKey(PotionEffectType.SLOWNESS));
+        }
+    }
+
+    @Test void spherePathOrderingCandidateAndTargetBoundsAreDeterministic() {
+        var sessions = mock(EquipmentSessions.class); var parties = mock(PartyRoster.class); var source = mock(Player.class);
+        var world = mock(org.bukkit.World.class); when(source.getUniqueId()).thenReturn(UUID.randomUUID());
+        when(source.getEyeLocation()).thenReturn(new Location(world, 0, 64, 0)); when(source.getLocation()).thenReturn(new Location(world, 0, 64, 0));
+        var active = new EquipmentSessions.Active(source.getUniqueId(), UUID.randomUUID(), UUID.randomUUID());
+        when(sessions.active(source.getUniqueId())).thenReturn(java.util.Optional.of(active)); when(sessions.current(active)).thenReturn(true);
+        var candidates = new ArrayList<Entity>(); var hitOrder = new ArrayList<UUID>();
+        for (int index = 0; index < 270; index++) {
+            var target = mock(LivingEntity.class); var id = new UUID(0, 300 - index); when(target.getUniqueId()).thenReturn(id);
+            double distance = index < 70 ? 1 + index / 100.0 : 4;
+            when(target.getLocation()).thenReturn(new Location(world, distance, 64, 0)); when(source.hasLineOfSight(target)).thenReturn(index != 1);
+            doAnswer(call -> { hitOrder.add(id); return null; }).when(target).damage(anyDouble(), any(org.bukkit.damage.DamageSource.class));
+            effects(target); candidates.add(target);
+        }
+        when(source.getNearbyEntities(5, 5, 5)).thenReturn(candidates);
+        var execution = execution(source, active); var nova = new FrostNova(FrostNova.Settings.defaults(), sessions, parties);
+        when(execution.definition()).thenReturn(nova.definition()); nova.activate(execution);
+        assertEquals(64, hitOrder.size()); assertFalse(hitOrder.contains(new UUID(0, 299)), "Obstructed target excluded");
+        var sorted = new ArrayList<>(hitOrder); sorted.sort(UUID::compareTo);
+        assertNotEquals(sorted, hitOrder, "Distance precedes UUID while UUID breaks equal-distance ties");
+        verify((LivingEntity) candidates.getLast(), never()).damage(anyDouble(), any(org.bukkit.damage.DamageSource.class));
+        verify(execution, atMost(64)).report(any(), any(), any());
+    }
+
+    @Test void exactSphereBoundaryIsIncludedWhileOutsideAndObstructedTargetsAreExcluded() {
+        var sessions = mock(EquipmentSessions.class); var parties = mock(PartyRoster.class); var source = mock(Player.class);
+        var world = mock(org.bukkit.World.class); when(source.getUniqueId()).thenReturn(UUID.randomUUID());
+        when(source.getEyeLocation()).thenReturn(new Location(world, 0, 64, 0));
+        var active = new EquipmentSessions.Active(source.getUniqueId(), UUID.randomUUID(), UUID.randomUUID());
+        when(sessions.active(source.getUniqueId())).thenReturn(java.util.Optional.of(active)); when(sessions.current(active)).thenReturn(true);
+        var boundary = mock(LivingEntity.class); var outside = mock(LivingEntity.class); var blocked = mock(LivingEntity.class);
+        for (var target : List.of(boundary, outside, blocked)) when(target.getUniqueId()).thenReturn(UUID.randomUUID());
+        when(boundary.getLocation()).thenReturn(new Location(world, 5, 64, 0));
+        when(outside.getLocation()).thenReturn(new Location(world, 5.01, 64, 0));
+        when(blocked.getLocation()).thenReturn(new Location(world, 4, 64, 0));
+        when(source.hasLineOfSight(boundary)).thenReturn(true); when(source.hasLineOfSight(outside)).thenReturn(true);
+        when(source.hasLineOfSight(blocked)).thenReturn(true); when(source.getNearbyEntities(5, 5, 5)).thenReturn(List.of(boundary, outside, blocked));
+        when(world.rayTraceBlocks(any(Location.class), any(org.bukkit.util.Vector.class), eq(4.0),
+            eq(org.bukkit.FluidCollisionMode.NEVER), eq(true))).thenReturn(mock(org.bukkit.util.RayTraceResult.class));
+        effects(boundary); effects(outside); effects(blocked);
+        var execution = execution(source, active); var nova = new FrostNova(FrostNova.Settings.defaults(), sessions, parties);
+        when(execution.definition()).thenReturn(nova.definition()); nova.activate(execution);
+        verify(boundary).damage(anyDouble(), any(org.bukkit.damage.DamageSource.class));
+        verify(outside, never()).damage(anyDouble(), any(org.bukkit.damage.DamageSource.class));
+        verify(blocked, never()).damage(anyDouble(), any(org.bukkit.damage.DamageSource.class));
+    }
+
+    @Test void cancelledDamageAndPartyOrModeRaceApplyNoSlownessOrCredit() throws Exception {
+        var sessions = mock(EquipmentSessions.class); var parties = mock(PartyRoster.class); var source = mock(Player.class);
+        var target = mock(Player.class); var world = mock(org.bukkit.World.class); UUID sourceId = UUID.randomUUID(), targetId = UUID.randomUUID();
+        when(source.getUniqueId()).thenReturn(sourceId); when(target.getUniqueId()).thenReturn(targetId);
+        when(source.getEyeLocation()).thenReturn(new Location(world, 0, 64, 0)); when(source.getLocation()).thenReturn(new Location(world, 0, 64, 0));
+        when(target.getLocation()).thenReturn(new Location(world, 3, 64, 0)); when(source.hasLineOfSight(target)).thenReturn(true);
+        when(source.getNearbyEntities(5, 5, 5)).thenReturn(List.of(target));
+        var sourceActive = new EquipmentSessions.Active(sourceId, UUID.randomUUID(), UUID.randomUUID());
+        var targetActive = new EquipmentSessions.Active(targetId, UUID.randomUUID(), UUID.randomUUID());
+        when(sessions.active(sourceId)).thenReturn(java.util.Optional.of(sourceActive)); when(sessions.current(sourceActive)).thenReturn(true);
+        when(sessions.active(targetId)).thenReturn(java.util.Optional.of(targetActive)); when(sessions.current(targetActive)).thenReturn(true);
+        var targetEffects = effects(target); var execution = execution(source, sourceActive);
+        var nova = new FrostNova(FrostNova.Settings.defaults(), sessions, parties); when(execution.definition()).thenReturn(nova.definition());
+        doAnswer(call -> { when(parties.partyOf(sourceId)).thenReturn(java.util.Optional.of(
+                new PartyRoster.Party(UUID.randomUUID(), sourceId, List.of(sourceId, targetId)))); return null; })
+            .when(target).damage(anyDouble(), any(org.bukkit.damage.DamageSource.class));
+        nova.activate(execution); assertTrue(targetEffects.isEmpty()); verify(execution, never()).report(any(), any(), any());
+
+        when(parties.partyOf(sourceId)).thenReturn(java.util.Optional.empty()); when(sessions.current(targetActive)).thenReturn(false);
+        nova.activate(execution); verify(target, times(1)).damage(anyDouble(), any(org.bukkit.damage.DamageSource.class));
+    }
+
+    @Test void ownedSlownessRestoresWeakerPriorStateButPreservesNewerStrongerState() throws Exception {
+        var sessions = mock(EquipmentSessions.class); var parties = mock(PartyRoster.class); var source = mock(Player.class);
+        var target = mock(LivingEntity.class); var world = mock(org.bukkit.World.class);
+        when(source.getUniqueId()).thenReturn(UUID.randomUUID()); when(target.getUniqueId()).thenReturn(UUID.randomUUID());
+        when(source.getEyeLocation()).thenReturn(new Location(world, 0, 64, 0)); when(target.getLocation()).thenReturn(new Location(world, 2, 64, 0));
+        when(source.hasLineOfSight(target)).thenReturn(true); when(source.getNearbyEntities(5, 5, 5)).thenReturn(List.of(target));
+        var active = new EquipmentSessions.Active(source.getUniqueId(), UUID.randomUUID(), UUID.randomUUID());
+        when(sessions.active(source.getUniqueId())).thenReturn(java.util.Optional.of(active)); when(sessions.current(active)).thenReturn(true);
+        var targetEffects = effects(target); targetEffects.put(PotionEffectType.SLOWNESS,
+            new PotionEffect(PotionEffectType.SLOWNESS, 200, 0));
+        var execution = execution(source, active); var nova = new FrostNova(FrostNova.Settings.defaults(), sessions, parties);
+        when(execution.definition()).thenReturn(nova.definition());
+        doAnswer(call -> { var damageSource = (org.bukkit.damage.DamageSource) call.getArgument(1);
+            var event = new EntityDamageEvent(target, EntityDamageEvent.DamageCause.FREEZE, damageSource, (Double) call.getArgument(0));
+            nova.acceptedDamage(event); return null; }).when(target).damage(anyDouble(), any(org.bukkit.damage.DamageSource.class));
+        nova.activate(execution); assertEquals(1, targetEffects.get(PotionEffectType.SLOWNESS).getAmplifier());
+        var resource = org.mockito.ArgumentCaptor.forClass(AutoCloseable.class); verify(execution).own(resource.capture());
+        resource.getValue().close(); assertEquals(0, targetEffects.get(PotionEffectType.SLOWNESS).getAmplifier());
+
+        var execution2 = execution(source, active); when(execution2.definition()).thenReturn(nova.definition());
+        nova.activate(execution2); targetEffects.put(PotionEffectType.SLOWNESS, new PotionEffect(PotionEffectType.SLOWNESS, 400, 3));
+        var resource2 = org.mockito.ArgumentCaptor.forClass(AutoCloseable.class); verify(execution2).own(resource2.capture());
+        resource2.getValue().close(); assertEquals(3, targetEffects.get(PotionEffectType.SLOWNESS).getAmplifier());
+    }
+
+    @Test void configuredDefinitionAdminRestartAndFutureCastCoverEverySetting() throws Exception {
+        java.nio.file.Files.writeString(data.resolve("config.yml"),
+            "frost-nova-base-damage: 7\nfrost-nova-cooldown-seconds: 2\nfrost-nova-radius-blocks: 8\n"
+            + "frost-nova-slowness-amplifier: 2\nfrost-nova-slowness-duration-seconds: 5\n");
+        try (var fixture = new FantasyStickLifecycleNativeTest.Fixture(data)) {
+            fixture.plugin.setEnabled(true); var registry = (games.dmg.fantasystick.ability.AbilityRegistry)
+                FantasyStickLifecycleNativeTest.Fixture.field(fixture.plugin, "abilityRegistry");
+            var definition = registry.find("frost_nova").orElseThrow(); assertEquals(java.time.Duration.ofSeconds(2), definition.cooldown());
+            assertEquals(new BigDecimal("7"), definition.parameters().get("base-damage")); assertEquals(new BigDecimal("8"), definition.parameters().get("radius"));
+            assertEquals(new BigDecimal("2"), definition.parameters().get("slowness-amplifier"));
+            assertEquals(0, new BigDecimal("5").compareTo(definition.parameters().get("slowness-duration-seconds")));
+            var sender = new EquipmentAdminCommandNativeTest.Sender(); sender.allowed = false;
+            assertTrue(fixture.command.tabComplete(sender.port, "fantasystick", new String[]{"config", "frost-nova-"}).isEmpty());
+            fixture.command.execute(sender.port, "fantasystick", new String[]{"config", "frost-nova-radius-blocks", "10"});
+            assertTrue(sender.messages.getLast().contains("Permission denied")); sender.allowed = true;
+            assertEquals(List.of("frost-nova-base-damage", "frost-nova-cooldown-seconds", "frost-nova-radius-blocks",
+                "frost-nova-slowness-amplifier", "frost-nova-slowness-duration-seconds"),
+                fixture.command.tabComplete(sender.port, "fantasystick", new String[]{"config", "frost-nova-"}));
+            assertEquals(List.of("5", "8"), fixture.command.tabComplete(sender.port, "fantasystick",
+                new String[]{"config", "frost-nova-radius-blocks", ""}));
+            fixture.command.execute(sender.port, "fantasystick", new String[]{"config", "frost-nova-radius-blocks"});
+            assertTrue(sender.messages.getLast().contains("=8"));
+            for (String[] update : List.of(new String[]{"frost-nova-base-damage", "9"},
+                    new String[]{"frost-nova-cooldown-seconds", "3"}, new String[]{"frost-nova-radius-blocks", "10"},
+                    new String[]{"frost-nova-slowness-amplifier", "3"}, new String[]{"frost-nova-slowness-duration-seconds", "6"})) {
+                fixture.command.execute(sender.port, "fantasystick", new String[]{"config", update[0], update[1]});
+                var response = fixture.tasks.poll(5, TimeUnit.SECONDS); assertNotNull(response); response.run();
+            }
+            var configured = registry.find("frost_nova").orElseThrow(); assertEquals(java.time.Duration.ofSeconds(3), configured.cooldown());
+            assertEquals(new BigDecimal("9"), configured.parameters().get("base-damage"));
+            assertEquals(0, new BigDecimal("10").compareTo(configured.parameters().get("radius")));
+            assertEquals(new BigDecimal("3"), configured.parameters().get("slowness-amplifier"));
+            assertEquals(0, new BigDecimal("6").compareTo(configured.parameters().get("slowness-duration-seconds")));
+
+            var caster = new FantasyStickLifecycleNativeTest.Actor(data); prepareCaster(data, caster, true);
+            fixture.players.put(caster.core.id, caster.player); fixture.activate(caster);
+            var enemy = mock(LivingEntity.class); when(enemy.getUniqueId()).thenReturn(UUID.randomUUID());
+            when(enemy.getLocation()).thenReturn(new Location(caster.world, 9, 64, 0)); doReturn(true).when(caster.player).hasLineOfSight(enemy);
+            doReturn(new Location(caster.world, 0, 64, 0)).when(caster.player).getEyeLocation();
+            doReturn(List.of(enemy)).when(caster.player).getNearbyEntities(anyDouble(), anyDouble(), anyDouble());
+            var enemyEffects = effects(enemy); var applied = new HashMap<UUID, Double>(); damage(fixture, enemy, applied);
+            use(fixture, caster); drain(fixture, 2); assertEquals(12, applied.get(enemy.getUniqueId()), 1.0e-9);
+            assertEquals(3, enemyEffects.get(PotionEffectType.SLOWNESS).getAmplifier()); assertEquals(120L, fixture.delayedTicks.getLast());
+            fixture.command.execute(sender.port, "fantasystick", new String[]{"config", "frost-nova-radius-blocks", "0"});
+            assertTrue(sender.messages.getLast().contains("invalid"));
+            fixture.command.execute(sender.port, "fantasystick", new String[]{"config", "frost-nova-radius-blocks", "10", "extra"});
+            assertTrue(sender.messages.getLast().contains("Usage"));
+            fixture.plugin.setEnabled(false); fixture.plugin.setEnabled(true);
+            var saved = ((games.dmg.fantasystick.ability.AbilityRegistry) FantasyStickLifecycleNativeTest.Fixture.field(fixture.plugin, "abilityRegistry"))
+                .find("frost_nova").orElseThrow(); assertEquals(new BigDecimal("9"), saved.parameters().get("base-damage"));
+            assertEquals(0, new BigDecimal("10").compareTo(saved.parameters().get("radius")));
+            assertEquals(new BigDecimal("3"), saved.parameters().get("slowness-amplifier"));
+            assertEquals(java.time.Duration.ofSeconds(3), saved.cooldown());
+            assertEquals(0, new BigDecimal("6").compareTo(saved.parameters().get("slowness-duration-seconds")));
+        }
+        for (String invalid : List.of("frost-nova-base-damage: -1\n", "frost-nova-cooldown-seconds: -1\n",
+                "frost-nova-radius-blocks: 0\n", "frost-nova-slowness-amplifier: -1\n", "frost-nova-slowness-duration-seconds: 0\n")) {
+            var directory = data.resolve(Integer.toHexString(invalid.hashCode())); java.nio.file.Files.createDirectories(directory);
+            java.nio.file.Files.writeString(directory.resolve("config.yml"), invalid);
+            try (var fixture = new FantasyStickLifecycleNativeTest.Fixture(directory)) {
+                assertThrows(IllegalArgumentException.class, () -> fixture.plugin.setEnabled(true)); assertTrue(fixture.order.isEmpty());
+            }
+        }
+    }
+
+    @Test void arbitraryPrecisionFormulaUsesFloorModifier() {
+        assertEquals(BigInteger.valueOf(8), FrostNova.damage(BigInteger.valueOf(16)));
+        assertEquals(BigInteger.valueOf(4), FrostNova.damage(BigInteger.valueOf(9)));
+        var huge = BigInteger.TEN.pow(500); assertEquals(huge.subtract(BigInteger.TEN).divide(BigInteger.TWO).add(BigInteger.valueOf(5)), FrostNova.damage(huge));
+    }
+
+    private static AbilityExecution execution(Player source, EquipmentSessions.Active active) {
+        var execution = mock(AbilityExecution.class); var input = mock(ControlInput.class);
+        when(input.player()).thenReturn(source); when(input.session()).thenReturn(active);
+        when(execution.input()).thenReturn(input); when(execution.stillCurrent()).thenReturn(true);
+        var record = new games.dmg.fantasystick.crafting.CharacterFactory().create(games.dmg.fantasystick.progression.ProgressionRules.defaults());
+        var stats = new EnumMap<>(record.stats()); stats.put(Stat.INT, BigInteger.valueOf(16));
+        when(execution.character()).thenReturn(new CharacterRecord(active.character(), record.name(), record.revision(), stats,
+            record.level(), record.experience(), record.unspentPoints(), record.health(), Set.of("frost_nova"),
+            List.of("frost_nova", "", "", "", "", "", ""), record.cooldowns(), record.restrictedKills(), false, null, null));
+        return execution;
+    }
+    private static Map<org.bukkit.potion.PotionEffectType, PotionEffect> effects(LivingEntity target) {
+        var effects = new HashMap<org.bukkit.potion.PotionEffectType, PotionEffect>();
+        doAnswer(call -> effects.get(call.getArgument(0))).when(target).getPotionEffect(any());
+        doAnswer(call -> { PotionEffect effect = call.getArgument(0); effects.put(effect.getType(), effect); return true; })
+            .when(target).addPotionEffect(any());
+        doAnswer(call -> { effects.remove(call.getArgument(0)); return null; }).when(target).removePotionEffect(any()); return effects;
+    }
+    private static void damage(FantasyStickLifecycleNativeTest.Fixture fixture, LivingEntity target, Map<UUID, Double> damage) {
+        doAnswer(call -> { double amount = call.getArgument(0); org.bukkit.damage.DamageSource source = call.getArgument(1);
+            var event = new EntityDamageByEntityEvent(source.getCausingEntity(), target, EntityDamageEvent.DamageCause.FREEZE, source, amount);
+            fixture.dispatcher.accept(event); if (!event.isCancelled()) damage.merge(target.getUniqueId(), event.getFinalDamage(), Double::sum); return null;
+        }).when(target).damage(anyDouble(), any(org.bukkit.damage.DamageSource.class));
+    }
+    private static void locate(FantasyStickLifecycleNativeTest.Actor caster, Player target, double distance, boolean visible) {
+        doReturn(new Location(caster.world, 0, 64, 0)).when(caster.player).getEyeLocation();
+        doReturn(new Location(caster.world, 0, 64, 0)).when(caster.player).getLocation();
+        doReturn(new Location(caster.world, distance, 64, 0)).when(target).getLocation(); doReturn(visible).when(caster.player).hasLineOfSight(target);
+    }
+    private static void use(FantasyStickLifecycleNativeTest.Fixture fixture, FantasyStickLifecycleNativeTest.Actor actor) {
+        actor.core.inventory.getInventory().setSelectedSlot(2);
+        fixture.dispatcher.accept(new PlayerInteractEvent(actor.player, org.bukkit.event.block.Action.RIGHT_CLICK_AIR,
+            actor.core.inventory.getItem(2), null, org.bukkit.block.BlockFace.SELF, EquipmentSlot.HAND));
+    }
+    private static void party(FantasyStickLifecycleNativeTest.Fixture fixture,
+                              FantasyStickLifecycleNativeTest.Actor source, FantasyStickLifecycleNativeTest.Actor target) {
+        var parties = PartyLifecycleNativeTest.parties(fixture); var group = parties.create(source.core.id).orElseThrow();
+        assertTrue(parties.accept(target.core.id, parties.invite(source.core.id, group.id(), target.core.id).orElseThrow().id()));
+    }
+    private static void drain(FantasyStickLifecycleNativeTest.Fixture fixture, int count) throws Exception {
+        for (int index = 0; index < count; index++) PartyBookNativeTest.drain(fixture);
+    }
+    private static CharacterStorage storage(FantasyStickLifecycleNativeTest.Fixture fixture) {
+        return (CharacterStorage) FantasyStickLifecycleNativeTest.Fixture.field(fixture.plugin, "characters");
+    }
+    private static ClickEvent.Custom button(FantasyStickLifecycleNativeTest.Actor actor, String label, String ability) {
+        var book = org.bukkit.craftbukkit.inventory.CraftItemStack.asNMSCopy(actor.books.getLast())
+            .get(net.minecraft.core.component.DataComponents.WRITTEN_BOOK_CONTENT); assertNotNull(book);
+        for (var page : book.pages()) { var found = button(page.raw(), label, ability); if (found != null) return found; }
+        throw new AssertionError("Missing " + label + " for " + ability);
+    }
+    private static ClickEvent.Custom button(net.minecraft.network.chat.Component component, String label, String ability) {
+        if (component.getString().equals(label) && component.getStyle().getClickEvent() instanceof ClickEvent.Custom custom
+                && custom.payload().orElse(null) instanceof net.minecraft.nbt.StringTag payload
+                && payload.value().contains(":" + ability)) return custom;
+        for (var child : component.getSiblings()) { var found = button(child, label, ability); if (found != null) return found; } return null;
+    }
+    private static void prepareCaster(Path directory, FantasyStickLifecycleNativeTest.Actor actor, boolean learned) throws Exception {
+        java.nio.file.Files.createDirectories(directory); var repository = new YamlCharacterRepository(directory);
+        var old = repository.load(actor.core.record.id()).orElseThrow(); var stats = new EnumMap<>(old.stats());
+        stats.put(Stat.INT, BigInteger.valueOf(16)); stats.put(Stat.DEX, BigInteger.TEN);
+        repository.replace(new CharacterRecord(old.id(), old.name(), old.revision().add(BigInteger.ONE), stats,
+            old.level(), old.experience(), BigInteger.valueOf(learned ? 39 : 40), old.health(),
+            learned ? Set.of("frost_nova") : old.learned(), learned ? List.of("frost_nova", "", "", "", "", "", "") : old.loadout(),
+            old.cooldowns(), old.restrictedKills(), false, null, null), old.revision());
+    }
+}

src/nativeTest/java/games/dmg/fantasystick/GuardianBondNativeTest.java

@@ -0,0 +1,392 @@
+package games.dmg.fantasystick;
+
+import static org.junit.jupiter.api.Assertions.*;
+import static org.mockito.ArgumentMatchers.*;
+import static org.mockito.Mockito.*;
+
+import games.dmg.fantasystick.ability.AbilityExecution;
+import games.dmg.fantasystick.ability.AbilityReport;
+import games.dmg.fantasystick.ability.GuardianBond;
+import games.dmg.fantasystick.party.PartyRoster;
+import games.dmg.fantasystick.persistence.CharacterRecord;
+import games.dmg.fantasystick.persistence.CharacterStorage;
+import games.dmg.fantasystick.persistence.GuardianBondSettings;
+import games.dmg.fantasystick.persistence.YamlCharacterRepository;
+import games.dmg.fantasystick.progression.Stat;
+import games.dmg.fantasystick.session.ControlInput;
+import games.dmg.fantasystick.session.EquipmentSessions;
+import java.math.BigDecimal;
+import java.math.BigInteger;
+import java.nio.file.Path;
+import java.util.ArrayList;
+import java.util.EnumMap;
+import java.util.List;
+import java.util.Set;
+import java.util.UUID;
+import java.util.concurrent.TimeUnit;
+import net.minecraft.network.chat.ClickEvent;
+import org.bukkit.Location;
+import org.bukkit.entity.Entity;
+import org.bukkit.entity.LivingEntity;
+import org.bukkit.entity.Player;
+import org.bukkit.event.entity.EntityDamageByEntityEvent;
+import org.bukkit.event.entity.EntityDamageEvent;
+import org.bukkit.event.entity.EntityDeathEvent;
+import org.bukkit.event.player.PlayerInteractEvent;
+import org.bukkit.inventory.EquipmentSlot;
+import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.io.TempDir;
+
+class GuardianBondNativeTest {
+    @TempDir Path data;
+    @BeforeAll static void bootstrap() throws Exception { NativeRuntime.bootstrap(); }
+
+    @Test void bookAcquisitionEquippedUseRedirectsNativeDamageAndPersistsCooldown() throws Exception {
+        try (var fixture = new FantasyStickLifecycleNativeTest.Fixture(data)) {
+            fixture.plugin.setEnabled(true);
+            var guardian = new FantasyStickLifecycleNativeTest.Actor(data);
+            var ally = new FantasyStickLifecycleNativeTest.Actor(data);
+            prepareGuardian(data, guardian, false);
+            fixture.players.put(guardian.core.id, guardian.player); fixture.players.put(ally.core.id, ally.player);
+            fixture.activate(guardian); fixture.activate(ally); party(fixture, guardian, ally); aim(guardian, ally, 8, true);
+            nativeDamage(fixture, guardian);
+
+            guardian.core.inventory.getInventory().setSelectedSlot(0); PartyBookNativeTest.open(fixture, guardian);
+            String text = PartyBookNativeTest.text(guardian).replaceAll("\\s+", "");
+            assertTrue(text.contains("GuardianBond")); assertTrue(text.contains("CON16")); assertTrue(text.contains("WIS10"));
+            assertTrue(text.contains("Cost:1")); assertTrue(text.contains("30%")); assertTrue(text.contains("6seconds"));
+            PartyBookNativeTest.click(fixture, guardian, button(guardian, "[Learn]", "guardian_bond")); drain(fixture, 2);
+            PartyBookNativeTest.click(fixture, guardian, button(guardian, "[3]", "guardian_bond")); drain(fixture, 2);
+            use(fixture, guardian); drain(fixture, 2);
+
+            var enemy = mock(org.bukkit.entity.Zombie.class); when(enemy.getUniqueId()).thenReturn(UUID.randomUUID());
+            var hit = hit(enemy, ally.player, 10); fixture.dispatcher.accept(hit);
+            assertEquals(7, hit.getDamage(), 1.0e-9); assertEquals(7, guardian.player.getHealth(), 1.0e-9);
+            var stored = storage(fixture).find(guardian.core.record.id()).get().orElseThrow();
+            assertEquals(BigInteger.valueOf(39), stored.unspentPoints()); assertNotNull(stored.cooldowns().get("guardian_bond"));
+            assertEquals(120L, fixture.delayedTicks.getLast()); fixture.delayed.getLast().run();
+            var expired = hit(enemy, ally.player, 10); fixture.dispatcher.accept(expired);
+            assertEquals(10, expired.getDamage(), 1.0e-9);
+        }
+    }
+
+    @Test void lethalRedirectUsesNormalDefeatAndOnlyRemovesGuardianAvailableHealth() throws Exception {
+        try (var fixture = new FantasyStickLifecycleNativeTest.Fixture(data)) {
+            fixture.plugin.setEnabled(true);
+            var guardian = new FantasyStickLifecycleNativeTest.Actor(data); var ally = new FantasyStickLifecycleNativeTest.Actor(data);
+            prepareGuardian(data, guardian, true);
+            fixture.players.put(guardian.core.id, guardian.player); fixture.players.put(ally.core.id, ally.player);
+            fixture.activate(guardian); fixture.activate(ally); party(fixture, guardian, ally); aim(guardian, ally, 8, true);
+            var defeatOrder = new ArrayList<String>();
+            guardian.damage = (amount, source) -> {
+                var redirected = hit(source, guardian.player, amount); fixture.dispatcher.accept(redirected);
+                if (redirected.isCancelled()) return;
+                guardian.core.health = Math.max(0, guardian.core.health - redirected.getFinalDamage());
+                if (guardian.core.health == 0) {
+                    var deathSource = new org.bukkit.craftbukkit.damage.CraftDamageSource(
+                        new net.minecraft.world.damagesource.DamageSource(
+                            org.bukkit.craftbukkit.damage.CraftDamageType.bukkitToMinecraftHolder(org.bukkit.damage.DamageType.OUT_OF_WORLD)));
+                    var death = new org.bukkit.event.entity.PlayerDeathEvent(guardian.player, deathSource,
+                        new ArrayList<>(), 0, net.kyori.adventure.text.Component.text("redirected defeat"), true);
+                    fixture.dispatcher.accept(death); assertTrue(death.isCancelled()); defeatOrder.add("guardian");
+                }
+            };
+            use(fixture, guardian); drain(fixture, 2); guardian.core.health = 1; ally.core.health = 9;
+            var hit = hit(mock(org.bukkit.entity.Zombie.class), ally.player, 10); fixture.dispatcher.accept(hit);
+            assertEquals(List.of("guardian"), defeatOrder,
+                "Redirected damage reaches normal guardian defeat before original damage resumes");
+            assertEquals(9, hit.getDamage(), 1.0e-9, "Overkill cannot delete damage the guardian could not accept");
+            ally.core.health = Math.max(0, ally.core.health - hit.getFinalDamage());
+            if (ally.core.health == 0) {
+                var deathSource = new org.bukkit.craftbukkit.damage.CraftDamageSource(
+                    new net.minecraft.world.damagesource.DamageSource(
+                        org.bukkit.craftbukkit.damage.CraftDamageType.bukkitToMinecraftHolder(org.bukkit.damage.DamageType.OUT_OF_WORLD)));
+                var death = new org.bukkit.event.entity.PlayerDeathEvent(ally.player, deathSource,
+                    new ArrayList<>(), 0, net.kyori.adventure.text.Component.text("remaining original defeat"), true);
+                fixture.dispatcher.accept(death); assertTrue(death.isCancelled()); defeatOrder.add("ally");
+            }
+            assertEquals(List.of("guardian", "ally"), defeatOrder, "Both characters may be defeated in the approved order");
+        }
+    }
+
+    @Test void actualProtectionCreatesOnePersistedSupportShareForTheAidedDirectContributor() throws Exception {
+        try (var fixture = new FantasyStickLifecycleNativeTest.Fixture(data)) {
+            fixture.plugin.setEnabled(true);
+            var guardian = new FantasyStickLifecycleNativeTest.Actor(data); var ally = new FantasyStickLifecycleNativeTest.Actor(data);
+            prepareGuardian(data, guardian, true);
+            fixture.players.put(guardian.core.id, guardian.player); fixture.players.put(ally.core.id, ally.player);
+            fixture.activate(guardian); fixture.activate(ally); party(fixture, guardian, ally); aim(guardian, ally, 8, true);
+            nativeDamage(fixture, guardian); use(fixture, guardian); drain(fixture, 2);
+            var enemy = mock(LivingEntity.class); when(enemy.getUniqueId()).thenReturn(UUID.randomUUID());
+            when(enemy.getType()).thenReturn(org.bukkit.entity.EntityType.ZOMBIE);
+            when(enemy.getLocation()).thenReturn(new Location(guardian.world, 8, 64, 0));
+            when(guardian.world.getUID()).thenReturn(UUID.randomUUID());
+            fixture.dispatcher.accept(hit(enemy, ally.player, 10));
+            var source = org.bukkit.damage.DamageSource.builder(org.bukkit.damage.DamageType.PLAYER_ATTACK)
+                .withCausingEntity(ally.player).withDirectEntity(ally.player).build();
+            fixture.dispatcher.accept(new EntityDamageByEntityEvent(ally.player, enemy,
+                EntityDamageEvent.DamageCause.ENTITY_ATTACK, source, 3));
+            fixture.dispatcher.accept(new EntityDeathEvent(enemy, source, new ArrayList<>(), 0)); drain(fixture, 4);
+            assertEquals(BigInteger.valueOf(5), storage(fixture).find(guardian.core.record.id()).get().orElseThrow().experience());
+            assertEquals(BigInteger.valueOf(5), storage(fixture).find(ally.core.record.id()).get().orElseThrow().experience());
+        }
+    }
+
+    @Test void conservedRoutingUsesPostRecipientAndPostGuardianMitigationCancellationAndLethalCaps() {
+        var context = new Context(); var requested = new ArrayList<BigDecimal>();
+        var mitigation = new games.dmg.fantasystick.ability.CombatMitigation();
+        var guardianProtection = mock(AbilityExecution.class); when(guardianProtection.stillCurrent()).thenReturn(true);
+        mitigation.grant(guardianProtection, context.guardian, new BigDecimal("25"));
+        var outgoing = new games.dmg.fantasystick.ability.OutgoingDamageMitigation(
+            context.sessions, context.parties, ignored -> {});
+        var enemyPenalty = mock(AbilityExecution.class); when(enemyPenalty.stillCurrent()).thenReturn(true);
+        outgoing.grant(enemyPenalty, context.enemy, new BigDecimal("20"));
+        context.damage = (guardian, attacker, amount) -> {
+            requested.add(amount); var redirected = hit(attacker, guardian, amount.doubleValue());
+            outgoing.reduce(redirected); mitigation.reduce(redirected); return BigDecimal.valueOf(redirected.getDamage());
+        };
+        context.activate();
+        var accepted = hit(context.enemy, context.ally, 10); outgoing.reduce(accepted); context.bond.redirect(accepted);
+        assertEquals(0, new BigDecimal("2.4").compareTo(requested.getFirst()));
+        assertEquals(6.2, accepted.getDamage(), 1.0e-9);
+        assertEquals(new BigDecimal("1.8"), context.supports.getFirst().amount());
+        verify(context.execution).report(AbilityReport.Type.PREVENTION, context.ally, new BigDecimal("1.8"));
+
+        context.damage = (guardian, attacker, amount) -> {
+            var redirected = hit(attacker, guardian, amount.doubleValue()); redirected.setCancelled(true);
+            mitigation.reduce(redirected); return redirected.isCancelled() ? BigDecimal.ZERO : BigDecimal.valueOf(redirected.getDamage());
+        };
+        var cancelled = hit(context.enemy, context.ally, 8); context.bond.redirect(cancelled);
+        assertEquals(8, cancelled.getDamage(), 1.0e-9); assertEquals(1, context.supports.size());
+
+        context.damage = (guardian, attacker, amount) -> BigDecimal.ONE;
+        var lethal = hit(context.enemy, context.ally, 10); context.bond.redirect(lethal);
+        assertEquals(9, lethal.getDamage(), 1.0e-9, "Only the one point accepted by a lethal guardian is removed");
+    }
+
+    @Test void conflictsCyclesAndInvalidatedRangePartyOrSessionCannotStackOrRedirect() {
+        var context = new Context(); var calls = new java.util.concurrent.atomic.AtomicInteger();
+        context.damage = (guardian, attacker, amount) -> {
+            calls.incrementAndGet();
+            var nested = hit(attacker, guardian, amount.doubleValue()); context.bond.redirect(nested);
+            return BigDecimal.valueOf(nested.getDamage());
+        };
+        context.activate();
+        assertFalse(context.bond.accepts(context.input), "The same caster/target cannot stack another bond");
+
+        var reverse = context.reverse(); reverse.activate();
+        var cycle = hit(context.enemy, context.guardian, 10); context.bond.redirect(cycle);
+        assertEquals(1, calls.get(), "Marked redirected damage must not recurse through the opposite bond");
+        assertEquals(7, cycle.getDamage(), 1.0e-9);
+
+        when(context.ally.getLocation()).thenReturn(new Location(context.world, 11, 64, 0)); context.bond.sweep();
+        when(context.ally.getLocation()).thenReturn(new Location(context.world, 8, 64, 0));
+        var separated = hit(context.enemy, context.ally, 10); context.bond.redirect(separated);
+        assertEquals(10, separated.getDamage(), 1.0e-9); verify(context.execution).finish();
+
+        var disbanded = new Context(); disbanded.activate();
+        when(disbanded.parties.partyOf(disbanded.ally.getUniqueId())).thenReturn(java.util.Optional.empty()); disbanded.bond.sweep();
+        when(disbanded.parties.partyOf(disbanded.ally.getUniqueId())).thenReturn(java.util.Optional.of(disbanded.party));
+        var noParty = hit(disbanded.enemy, disbanded.ally, 10); disbanded.bond.redirect(noParty);
+        assertEquals(10, noParty.getDamage(), 1.0e-9); verify(disbanded.execution).finish();
+        var exited = new Context(); exited.activate(); when(exited.sessions.current(exited.allyActive)).thenReturn(false); exited.bond.sweep();
+        when(exited.sessions.current(exited.allyActive)).thenReturn(true);
+        var noSession = hit(exited.enemy, exited.ally, 10); exited.bond.redirect(noSession);
+        assertEquals(10, noSession.getDamage(), 1.0e-9); verify(exited.execution).finish();
+    }
+
+    @Test void selfOrdinaryNonPartyRangeLineOfSightAndConflictRefuseBeforeCooldown() throws Exception {
+        for (int route = 0; route < 6; route++) {
+            var directory = data.resolve("refusal-" + route);
+            if (route == 5) {
+                java.nio.file.Files.createDirectories(directory);
+                java.nio.file.Files.writeString(directory.resolve("config.yml"),
+                    "guardian-bond-cooldown-seconds: 0\nguardian-bond-range-blocks: 10\n"
+                    + "guardian-bond-duration-seconds: 6\nguardian-bond-redirect-percent: 30\n");
+            }
+            try (var fixture = new FantasyStickLifecycleNativeTest.Fixture(directory)) {
+                fixture.plugin.setEnabled(true); var guardian = new FantasyStickLifecycleNativeTest.Actor(directory);
+                prepareGuardian(directory, guardian, true); fixture.players.put(guardian.core.id, guardian.player); fixture.activate(guardian);
+                Player target;
+                if (route == 0) target = guardian.player;
+                else if (route == 1) { target = mock(Player.class); when(target.getUniqueId()).thenReturn(UUID.randomUUID()); }
+                else {
+                    var ally = new FantasyStickLifecycleNativeTest.Actor(directory);
+                    fixture.players.put(ally.core.id, ally.player); fixture.activate(ally); target = ally.player;
+                    if (route != 2) party(fixture, guardian, ally);
+                }
+                aim(guardian, target, route == 3 ? 11 : 8, route != 4);
+                if (route == 5) { use(fixture, guardian); drain(fixture, 2); }
+                use(fixture, guardian); drain(fixture, 2);
+                var cooldowns = storage(fixture).find(guardian.core.record.id()).get().orElseThrow().cooldowns();
+                if (route < 5) assertFalse(cooldowns.containsKey("guardian_bond"), "route " + route);
+                else assertEquals(1, fixture.delayed.size(), "A conflicting zero-cooldown cast must not stack a second bond");
+            }
+        }
+    }
+
+    @Test void configurationAdminRestartAndFutureBondCoverEverySetting() throws Exception {
+        java.nio.file.Files.writeString(data.resolve("config.yml"),
+            "guardian-bond-cooldown-seconds: 2\nguardian-bond-range-blocks: 14\n"
+            + "guardian-bond-duration-seconds: 8\nguardian-bond-redirect-percent: 40\n");
+        try (var fixture = new FantasyStickLifecycleNativeTest.Fixture(data)) {
+            fixture.plugin.setEnabled(true); var registry = (games.dmg.fantasystick.ability.AbilityRegistry)
+                FantasyStickLifecycleNativeTest.Fixture.field(fixture.plugin, "abilityRegistry");
+            var definition = registry.find("guardian_bond").orElseThrow();
+            assertEquals(java.time.Duration.ofSeconds(2), definition.cooldown());
+            assertEquals(new BigDecimal("14"), definition.parameters().get("range"));
+            assertEquals(0, new BigDecimal("8").compareTo(definition.parameters().get("duration-seconds")));
+            assertEquals(new BigDecimal("40"), definition.parameters().get("redirect-percent"));
+            var sender = new EquipmentAdminCommandNativeTest.Sender(); sender.allowed = false;
+            assertTrue(fixture.command.tabComplete(sender.port, "fantasystick", new String[]{"config", "guardian-bond-"}).isEmpty());
+            fixture.command.execute(sender.port, "fantasystick", new String[]{"config", "guardian-bond-range-blocks", "16"});
+            assertTrue(sender.messages.getLast().contains("Permission denied")); sender.allowed = true;
+            assertEquals(List.of("guardian-bond-cooldown-seconds", "guardian-bond-duration-seconds",
+                "guardian-bond-range-blocks", "guardian-bond-redirect-percent"),
+                fixture.command.tabComplete(sender.port, "fantasystick", new String[]{"config", "guardian-bond-"}));
+            assertEquals(List.of("10", "14"), fixture.command.tabComplete(sender.port, "fantasystick",
+                new String[]{"config", "guardian-bond-range-blocks", ""}));
+            fixture.command.execute(sender.port, "fantasystick", new String[]{"config", "guardian-bond-range-blocks"});
+            assertTrue(sender.messages.getLast().contains("=14"));
+            for (String[] update : List.of(
+                    new String[]{"guardian-bond-range-blocks", "16"},
+                    new String[]{"guardian-bond-cooldown-seconds", "3"},
+                    new String[]{"guardian-bond-duration-seconds", "9"},
+                    new String[]{"guardian-bond-redirect-percent", "50"})) {
+                fixture.command.execute(sender.port, "fantasystick", new String[]{"config", update[0], update[1]});
+                var response = fixture.tasks.poll(5, TimeUnit.SECONDS); assertNotNull(response); response.run();
+            }
+            var configured = registry.find("guardian_bond").orElseThrow();
+            assertEquals(new BigDecimal("16"), configured.parameters().get("range"));
+            assertEquals(java.time.Duration.ofSeconds(3), configured.cooldown());
+            assertEquals(0, new BigDecimal("9").compareTo(configured.parameters().get("duration-seconds")));
+            assertEquals(new BigDecimal("50"), configured.parameters().get("redirect-percent"));
+
+            var guardian = new FantasyStickLifecycleNativeTest.Actor(data); var ally = new FantasyStickLifecycleNativeTest.Actor(data);
+            prepareGuardian(data, guardian, true); fixture.players.put(guardian.core.id, guardian.player); fixture.players.put(ally.core.id, ally.player);
+            fixture.activate(guardian); fixture.activate(ally); party(fixture, guardian, ally); aim(guardian, ally, 15, true);
+            nativeDamage(fixture, guardian); use(fixture, guardian); drain(fixture, 2);
+            var future = hit(mock(org.bukkit.entity.Zombie.class), ally.player, 10); fixture.dispatcher.accept(future);
+            assertEquals(5, future.getDamage(), 1.0e-9); assertEquals(180L, fixture.delayedTicks.getLast());
+            fixture.command.execute(sender.port, "fantasystick", new String[]{"config", "guardian-bond-duration-seconds", "0"});
+            assertTrue(sender.messages.getLast().contains("invalid"));
+            fixture.command.execute(sender.port, "fantasystick", new String[]{"config", "guardian-bond-range-blocks", "16", "extra"});
+            assertTrue(sender.messages.getLast().contains("Usage"));
+            fixture.plugin.setEnabled(false); fixture.plugin.setEnabled(true);
+            var reloaded = (games.dmg.fantasystick.ability.AbilityRegistry)
+                FantasyStickLifecycleNativeTest.Fixture.field(fixture.plugin, "abilityRegistry");
+            var afterRestart = reloaded.find("guardian_bond").orElseThrow();
+            assertEquals(new BigDecimal("16"), afterRestart.parameters().get("range"));
+            assertEquals(java.time.Duration.ofSeconds(3), afterRestart.cooldown());
+            assertEquals(0, new BigDecimal("9").compareTo(afterRestart.parameters().get("duration-seconds")));
+            assertEquals(new BigDecimal("50"), afterRestart.parameters().get("redirect-percent"));
+        }
+        for (String invalid : List.of("guardian-bond-cooldown-seconds: -1\n", "guardian-bond-range-blocks: 0\n",
+                "guardian-bond-duration-seconds: 0\n", "guardian-bond-redirect-percent: 101\n")) {
+            var directory = data.resolve(Integer.toHexString(invalid.hashCode())); java.nio.file.Files.createDirectories(directory);
+            java.nio.file.Files.writeString(directory.resolve("config.yml"), invalid);
+            try (var fixture = new FantasyStickLifecycleNativeTest.Fixture(directory)) {
+                assertThrows(IllegalArgumentException.class, () -> fixture.plugin.setEnabled(true)); assertTrue(fixture.order.isEmpty());
+            }
+        }
+    }
+
+    private final class Context {
+        final org.bukkit.World world = mock(org.bukkit.World.class); final Player guardian = mock(Player.class); final Player ally = mock(Player.class);
+        final LivingEntity enemy = mock(LivingEntity.class); final EquipmentSessions sessions = mock(EquipmentSessions.class);
+        final PartyRoster parties = mock(PartyRoster.class); final AbilityExecution execution = mock(AbilityExecution.class);
+        final ControlInput input = mock(ControlInput.class); final List<GuardianBond.Support> supports = new ArrayList<>();
+        GuardianBond.Damage damage = (target, attacker, amount) -> amount; final GuardianBond bond;
+        final EquipmentSessions.Active guardianActive; final EquipmentSessions.Active allyActive;
+        final PartyRoster.Party party;
+        Context() {
+            var guardianId = UUID.randomUUID(); var allyId = UUID.randomUUID();
+            when(guardian.getUniqueId()).thenReturn(guardianId); when(ally.getUniqueId()).thenReturn(allyId);
+            when(enemy.getUniqueId()).thenReturn(UUID.randomUUID());
+            when(guardian.getLocation()).thenReturn(new Location(world, 0, 64, 0));
+            when(ally.getLocation()).thenReturn(new Location(world, 8, 64, 0));
+            when(guardian.hasLineOfSight(ally)).thenReturn(true); when(ally.hasLineOfSight(guardian)).thenReturn(true);
+            guardianActive = new EquipmentSessions.Active(guardianId, UUID.randomUUID(), UUID.randomUUID());
+            allyActive = new EquipmentSessions.Active(allyId, UUID.randomUUID(), UUID.randomUUID());
+            when(sessions.active(allyId)).thenReturn(java.util.Optional.of(allyActive)); when(sessions.active(guardianId)).thenReturn(java.util.Optional.of(guardianActive));
+            when(sessions.current(allyActive)).thenReturn(true); when(sessions.current(guardianActive)).thenReturn(true);
+            party = new PartyRoster.Party(UUID.randomUUID(), guardianId, List.of(guardianId, allyId));
+            when(parties.partyOf(guardianId)).thenReturn(java.util.Optional.of(party)); when(parties.partyOf(allyId)).thenReturn(java.util.Optional.of(party));
+            when(input.player()).thenReturn(guardian); when(input.target()).thenReturn(ally); when(input.session()).thenReturn(guardianActive);
+            when(execution.input()).thenReturn(input); when(execution.stillCurrent()).thenReturn(true);
+            bond = new GuardianBond(GuardianBond.Settings.defaults(), sessions, parties,
+                (target, attacker, amount) -> damage.apply(target, attacker, amount), supports::add);
+            when(execution.definition()).thenReturn(bond.definition());
+        }
+        void activate() { bond.activate(execution); }
+        Context reverse() {
+            var reverse = new Context();
+            when(reverse.input.player()).thenReturn(ally); when(reverse.input.target()).thenReturn(guardian); when(reverse.input.session()).thenReturn(allyActive);
+            when(reverse.execution.input()).thenReturn(reverse.input); when(reverse.execution.definition()).thenReturn(bond.definition());
+            bond.activate(reverse.execution); return reverse;
+        }
+    }
+
+    private static void nativeDamage(FantasyStickLifecycleNativeTest.Fixture fixture, FantasyStickLifecycleNativeTest.Actor actor) {
+        actor.damage = (amount, source) -> {
+            var event = hit(source, actor.player, amount); fixture.dispatcher.accept(event);
+            if (!event.isCancelled()) actor.core.health = Math.max(0, actor.core.health - event.getFinalDamage());
+        };
+    }
+    private static EntityDamageByEntityEvent hit(Entity attacker, Entity target, double amount) {
+        var source = org.bukkit.damage.DamageSource.builder(org.bukkit.damage.DamageType.PLAYER_ATTACK)
+            .withCausingEntity(attacker).withDirectEntity(attacker).build();
+        return new EntityDamageByEntityEvent(attacker, target, EntityDamageEvent.DamageCause.ENTITY_ATTACK, source, amount);
+    }
+    private static void use(FantasyStickLifecycleNativeTest.Fixture fixture, FantasyStickLifecycleNativeTest.Actor actor) {
+        actor.core.inventory.getInventory().setSelectedSlot(2);
+        fixture.dispatcher.accept(new PlayerInteractEvent(actor.player, org.bukkit.event.block.Action.RIGHT_CLICK_AIR,
+            actor.core.inventory.getItem(2), null, org.bukkit.block.BlockFace.SELF, EquipmentSlot.HAND));
+    }
+    private static PartyRoster.Party party(FantasyStickLifecycleNativeTest.Fixture fixture,
+                                            FantasyStickLifecycleNativeTest.Actor source,
+                                            FantasyStickLifecycleNativeTest.Actor target) {
+        var parties = PartyLifecycleNativeTest.parties(fixture); var group = parties.create(source.core.id).orElseThrow();
+        assertTrue(parties.accept(target.core.id, parties.invite(source.core.id, group.id(), target.core.id).orElseThrow().id()));
+        return parties.partyOf(source.core.id).orElseThrow();
+    }
+    private static void aim(FantasyStickLifecycleNativeTest.Actor source,
+                            FantasyStickLifecycleNativeTest.Actor target, double distance, boolean visible) {
+        aim(source, target.player, distance, visible);
+    }
+    private static void aim(FantasyStickLifecycleNativeTest.Actor source, Player target, double distance, boolean visible) {
+        doReturn(new Location(source.world, 0, 64, 0)).when(source.player).getLocation();
+        doReturn(new Location(source.world, distance, 64, 0)).when(target).getLocation();
+        doReturn(visible).when(source.player).hasLineOfSight(target); doReturn(target).when(source.player).getTargetEntity(64);
+    }
+    private static void drain(FantasyStickLifecycleNativeTest.Fixture fixture, int count) throws Exception {
+        for (int index = 0; index < count; index++) PartyBookNativeTest.drain(fixture);
+    }
+    private static CharacterStorage storage(FantasyStickLifecycleNativeTest.Fixture fixture) {
+        return (CharacterStorage) FantasyStickLifecycleNativeTest.Fixture.field(fixture.plugin, "characters");
+    }
+    private static ClickEvent.Custom button(FantasyStickLifecycleNativeTest.Actor actor, String label, String ability) {
+        var book = org.bukkit.craftbukkit.inventory.CraftItemStack.asNMSCopy(actor.books.getLast())
+            .get(net.minecraft.core.component.DataComponents.WRITTEN_BOOK_CONTENT); assertNotNull(book);
+        for (var page : book.pages()) { var found = button(page.raw(), label, ability); if (found != null) return found; }
+        throw new AssertionError("Missing " + label + " for " + ability);
+    }
+    private static ClickEvent.Custom button(net.minecraft.network.chat.Component component, String label, String ability) {
+        if (component.getString().equals(label) && component.getStyle().getClickEvent() instanceof ClickEvent.Custom custom
+                && custom.payload().orElse(null) instanceof net.minecraft.nbt.StringTag payload
+                && payload.value().contains(":" + ability)) return custom;
+        for (var child : component.getSiblings()) { var found = button(child, label, ability); if (found != null) return found; }
+        return null;
+    }
+    private static void prepareGuardian(Path directory, FantasyStickLifecycleNativeTest.Actor actor, boolean learned) throws Exception {
+        java.nio.file.Files.createDirectories(directory); var repository = new YamlCharacterRepository(directory);
+        var old = repository.load(actor.core.record.id()).orElseThrow(); var stats = new EnumMap<>(old.stats());
+        stats.put(Stat.CON, BigInteger.valueOf(16)); stats.put(Stat.WIS, BigInteger.TEN);
+        repository.replace(new CharacterRecord(old.id(), old.name(), old.revision().add(BigInteger.ONE), stats,
+            old.level(), old.experience(), BigInteger.valueOf(learned ? 39 : 40), old.health(),
+            learned ? Set.of("guardian_bond") : old.learned(),
+            learned ? List.of("guardian_bond", "", "", "", "", "", "") : old.loadout(),
+            old.cooldowns(), old.restrictedKills(), false, null, null), old.revision());
+    }
+}

src/nativeTest/java/games/dmg/fantasystick/HexNativeTest.java

@@ -0,0 +1,196 @@
+package games.dmg.fantasystick;
+
+import static org.junit.jupiter.api.Assertions.*;
+import static org.mockito.ArgumentMatchers.*;
+import static org.mockito.Mockito.*;
+
+import games.dmg.fantasystick.persistence.CharacterRecord;
+import games.dmg.fantasystick.persistence.CharacterStorage;
+import games.dmg.fantasystick.progression.Stat;
+import java.math.BigInteger;
+import java.nio.file.Path;
+import java.util.EnumMap;
+import java.util.List;
+import net.minecraft.network.chat.ClickEvent;
+import org.bukkit.Location;
+import org.bukkit.damage.DamageSource;
+import org.bukkit.damage.DamageType;
+import org.bukkit.event.entity.EntityDamageByEntityEvent;
+import org.bukkit.event.entity.EntityDamageEvent;
+import org.bukkit.event.player.PlayerInteractEvent;
+import org.bukkit.inventory.EquipmentSlot;
+import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.io.TempDir;
+
+class HexNativeTest {
+    @TempDir Path data;
+    @BeforeAll static void bootstrap() throws Exception { NativeRuntime.bootstrap(); }
+
+    @Test void bookCastActualPreventionAndQualifyingAllyDamagePersistTwoRewardShares() throws Exception {
+        try (var f = new FantasyStickLifecycleNativeTest.Fixture(data)) {
+            f.plugin.setEnabled(true);
+            var a = new FantasyStickLifecycleNativeTest.Actor(data); var b = new FantasyStickLifecycleNativeTest.Actor(data);
+            withHex(data, a, false); f.players.put(a.core.id, a.player); f.players.put(b.core.id, b.player); f.activate(a); f.activate(b);
+            var parties = PartyLifecycleNativeTest.parties(f); var party = parties.create(a.core.id).orElseThrow();
+            assertTrue(parties.accept(b.core.id, parties.invite(a.core.id, party.id(), b.core.id).orElseThrow().id()));
+            a.core.inventory.getInventory().setSelectedSlot(0); PartyBookNativeTest.open(f, a);
+            String book = PartyBookNativeTest.text(a).replaceAll("\\s+", "");
+            assertTrue(book.contains("Hex")); assertTrue(book.contains("CHR14")); assertTrue(book.contains("WIS12"));
+            assertTrue(book.contains("Cost:1")); assertTrue(book.contains("12")); assertTrue(book.contains("20%")); assertTrue(book.contains("4s"));
+            PartyBookNativeTest.click(f, a, abilityButton(a, "[Learn]", "hex")); PartyBookNativeTest.drain(f); PartyBookNativeTest.drain(f);
+            PartyBookNativeTest.click(f, a, abilityButton(a, "[3]", "hex")); PartyBookNativeTest.drain(f); PartyBookNativeTest.drain(f);
+
+            var enemy = mock(org.bukkit.entity.LivingEntity.class); var enemyId = java.util.UUID.randomUUID();
+            when(enemy.getUniqueId()).thenReturn(enemyId); when(enemy.getType()).thenReturn(org.bukkit.entity.EntityType.ZOMBIE);
+            when(a.world.getUID()).thenReturn(java.util.UUID.randomUUID());
+            doReturn(new Location(a.world, 0, 64, 0)).when(a.player).getLocation();
+            when(enemy.getLocation()).thenReturn(new Location(a.world, 8, 64, 0)); doReturn(true).when(a.player).hasLineOfSight(enemy);
+            doReturn(enemy).when(a.player).getTargetEntity(64);
+            a.core.inventory.getInventory().setSelectedSlot(2);
+            f.dispatcher.accept(new PlayerInteractEvent(a.player, org.bukkit.event.block.Action.RIGHT_CLICK_AIR,
+                a.core.inventory.getItem(2), null, org.bukkit.block.BlockFace.SELF, EquipmentSlot.HAND));
+            PartyBookNativeTest.drain(f); PartyBookNativeTest.drain(f);
+            var storage = (CharacterStorage) FantasyStickLifecycleNativeTest.Fixture.field(f.plugin, "characters");
+            assertNotNull(storage.find(a.core.record.id()).get().orElseThrow().cooldowns().get("hex"));
+
+            var allySource = DamageSource.builder(DamageType.PLAYER_ATTACK).withCausingEntity(b.player).withDirectEntity(b.player).build();
+            f.dispatcher.accept(new EntityDamageByEntityEvent(b.player, enemy, EntityDamageEvent.DamageCause.ENTITY_ATTACK, allySource, 3));
+            var enemySource = DamageSource.builder(DamageType.MOB_ATTACK).withCausingEntity(enemy).withDirectEntity(enemy).build();
+            var protectedHit = new EntityDamageByEntityEvent(enemy, b.player, EntityDamageEvent.DamageCause.ENTITY_ATTACK, enemySource, 10);
+            f.dispatcher.accept(protectedHit); assertEquals(8, protectedHit.getDamage(), 1.0e-9);
+            var sourceSheet=a.core.inventory.getItemInOffHand().clone();a.core.inventory.setItemInOffHand(null);f.changed(a);PartyBookNativeTest.drain(f);f.awaitCharacterAndReceipt(a);
+            var holder=new FantasyStickLifecycleNativeTest.Actor(data);holder.core.inventory.setItemInOffHand(sourceSheet);f.players.put(holder.core.id,holder.player);f.activate(holder);
+            f.dispatcher.accept(new org.bukkit.event.entity.EntityDeathEvent(enemy, allySource, new java.util.ArrayList<>(), 0));
+            for (int i = 0; i < 4; i++) PartyBookNativeTest.drain(f);
+            assertEquals(BigInteger.valueOf(5), storage.find(a.core.record.id()).get().orElseThrow().experience());
+            assertEquals(BigInteger.valueOf(5), storage.find(b.core.record.id()).get().orElseThrow().experience());
+        }
+    }
+
+    @Test void replacementOldExpiryAndSourceExitPreserveOnlyCurrentOwnedPenalty() throws Exception {
+        java.nio.file.Files.writeString(data.resolve("config.yml"),"hex-cooldown-seconds: 0\n");
+        try(var f=new FantasyStickLifecycleNativeTest.Fixture(data)){
+            f.plugin.setEnabled(true);var a=new FantasyStickLifecycleNativeTest.Actor(data);withHex(data,a,true);f.players.put(a.core.id,a.player);f.activate(a);
+            var enemy=mock(org.bukkit.entity.LivingEntity.class);when(enemy.getUniqueId()).thenReturn(java.util.UUID.randomUUID());when(enemy.getType()).thenReturn(org.bukkit.entity.EntityType.ZOMBIE);
+            doReturn(new Location(a.world,0,64,0)).when(a.player).getLocation();when(enemy.getLocation()).thenReturn(new Location(a.world,8,64,0));doReturn(true).when(a.player).hasLineOfSight(enemy);doReturn(enemy).when(a.player).getTargetEntity(64);
+            use(f,a);PartyBookNativeTest.drain(f);PartyBookNativeTest.drain(f);use(f,a);PartyBookNativeTest.drain(f);PartyBookNativeTest.drain(f);
+            assertEquals(2,f.delayed.size());f.delayed.getFirst().run();
+            var hit=new EntityDamageByEntityEvent(enemy,mock(org.bukkit.entity.Zombie.class),EntityDamageEvent.DamageCause.ENTITY_ATTACK,mock(DamageSource.class),10);
+            f.dispatcher.accept(hit);assertEquals(8,hit.getDamage(),1.0e-9);f.delayed.getLast().run();
+            var expired=new EntityDamageByEntityEvent(enemy,mock(org.bukkit.entity.Zombie.class),EntityDamageEvent.DamageCause.ENTITY_ATTACK,mock(DamageSource.class),10);
+            f.dispatcher.accept(expired);assertEquals(10,expired.getDamage(),1.0e-9);
+            use(f,a);PartyBookNativeTest.drain(f);PartyBookNativeTest.drain(f);a.core.inventory.setItemInOffHand(null);f.changed(a);PartyBookNativeTest.drain(f);f.awaitCharacterAndReceipt(a);
+            var exited=new EntityDamageByEntityEvent(enemy,mock(org.bukkit.entity.Zombie.class),EntityDamageEvent.DamageCause.ENTITY_ATTACK,mock(DamageSource.class),10);
+            f.dispatcher.accept(exited);assertEquals(10,exited.getDamage(),1.0e-9);
+        }
+    }
+
+    @Test void latestReplacementOwnsEffectivePreventionSupport() throws Exception {
+        java.nio.file.Files.writeString(data.resolve("config.yml"),"hex-cooldown-seconds: 0\n");try(var f=new FantasyStickLifecycleNativeTest.Fixture(data)){f.plugin.setEnabled(true);var a=new FantasyStickLifecycleNativeTest.Actor(data);var c=new FantasyStickLifecycleNativeTest.Actor(data);var b=new FantasyStickLifecycleNativeTest.Actor(data);withHex(data,a,true);withHex(data,c,true);f.players.put(a.core.id,a.player);f.players.put(c.core.id,c.player);f.players.put(b.core.id,b.player);f.activate(a);f.activate(c);f.activate(b);
+            var parties=PartyLifecycleNativeTest.parties(f);var party=parties.create(a.core.id).orElseThrow();for(var member:List.of(c,b))assertTrue(parties.accept(member.core.id,parties.invite(a.core.id,party.id(),member.core.id).orElseThrow().id()));
+            var enemy=mock(org.bukkit.entity.LivingEntity.class);when(enemy.getUniqueId()).thenReturn(java.util.UUID.randomUUID());when(enemy.getType()).thenReturn(org.bukkit.entity.EntityType.ZOMBIE);when(a.world.getUID()).thenReturn(java.util.UUID.randomUUID());when(enemy.getLocation()).thenReturn(new Location(a.world,8,64,0));
+            for(var caster:List.of(a,c)){doReturn(new Location(a.world,0,64,0)).when(caster.player).getLocation();doReturn(true).when(caster.player).hasLineOfSight(enemy);doReturn(enemy).when(caster.player).getTargetEntity(64);use(f,caster);PartyBookNativeTest.drain(f);PartyBookNativeTest.drain(f);}
+            var allySource=DamageSource.builder(DamageType.PLAYER_ATTACK).withCausingEntity(b.player).withDirectEntity(b.player).build();f.dispatcher.accept(new EntityDamageByEntityEvent(b.player,enemy,EntityDamageEvent.DamageCause.ENTITY_ATTACK,allySource,3));var enemySource=DamageSource.builder(DamageType.MOB_ATTACK).withCausingEntity(enemy).withDirectEntity(enemy).build();var hit=new EntityDamageByEntityEvent(enemy,b.player,EntityDamageEvent.DamageCause.ENTITY_ATTACK,enemySource,10);f.dispatcher.accept(hit);assertEquals(8,hit.getDamage(),1.0e-9);f.dispatcher.accept(new org.bukkit.event.entity.EntityDeathEvent(enemy,allySource,new java.util.ArrayList<>(),0));for(int i=0;i<4;i++)PartyBookNativeTest.drain(f);
+            var storage=(CharacterStorage)FantasyStickLifecycleNativeTest.Fixture.field(f.plugin,"characters");assertEquals(BigInteger.ZERO,storage.find(a.core.record.id()).get().orElseThrow().experience());assertEquals(BigInteger.valueOf(5),storage.find(c.core.record.id()).get().orElseThrow().experience());assertEquals(BigInteger.valueOf(5),storage.find(b.core.record.id()).get().orElseThrow().experience());
+        }}
+
+    @Test void unusedProtectionCannotManufactureSupportShare() throws Exception {
+        try(var f=new FantasyStickLifecycleNativeTest.Fixture(data)){
+            f.plugin.setEnabled(true);var a=new FantasyStickLifecycleNativeTest.Actor(data);var b=new FantasyStickLifecycleNativeTest.Actor(data);withHex(data,a,true);
+            f.players.put(a.core.id,a.player);f.players.put(b.core.id,b.player);f.activate(a);f.activate(b);var parties=PartyLifecycleNativeTest.parties(f);var party=parties.create(a.core.id).orElseThrow();
+            assertTrue(parties.accept(b.core.id,parties.invite(a.core.id,party.id(),b.core.id).orElseThrow().id()));
+            var enemy=mock(org.bukkit.entity.LivingEntity.class);when(enemy.getUniqueId()).thenReturn(java.util.UUID.randomUUID());when(enemy.getType()).thenReturn(org.bukkit.entity.EntityType.ZOMBIE);when(a.world.getUID()).thenReturn(java.util.UUID.randomUUID());
+            doReturn(new Location(a.world,0,64,0)).when(a.player).getLocation();when(enemy.getLocation()).thenReturn(new Location(a.world,8,64,0));doReturn(true).when(a.player).hasLineOfSight(enemy);doReturn(enemy).when(a.player).getTargetEntity(64);use(f,a);PartyBookNativeTest.drain(f);PartyBookNativeTest.drain(f);
+            var allySource=DamageSource.builder(DamageType.PLAYER_ATTACK).withCausingEntity(b.player).withDirectEntity(b.player).build();
+            f.dispatcher.accept(new EntityDamageByEntityEvent(b.player,enemy,EntityDamageEvent.DamageCause.ENTITY_ATTACK,allySource,3));
+            f.dispatcher.accept(new org.bukkit.event.entity.EntityDeathEvent(enemy,allySource,new java.util.ArrayList<>(),0));for(int i=0;i<4;i++)PartyBookNativeTest.drain(f);
+            var storage=(CharacterStorage)FantasyStickLifecycleNativeTest.Fixture.field(f.plugin,"characters");assertEquals(BigInteger.ZERO,storage.find(a.core.record.id()).get().orElseThrow().experience());
+            assertEquals(BigInteger.TEN,storage.find(b.core.record.id()).get().orElseThrow().experience());
+        }
+    }
+
+    @Test void failedCooldownPersistenceAppliesNoHex() {
+        var storage=mock(CharacterStorage.class);var sessions=mock(games.dmg.fantasystick.session.EquipmentSessions.class);var parties=new games.dmg.fantasystick.party.PartyRoster(java.time.Clock.systemUTC(),ignored->true);
+        var mitigation=new games.dmg.fantasystick.ability.OutgoingDamageMitigation(sessions,parties,ignored->{});var hex=new games.dmg.fantasystick.ability.Hex(games.dmg.fantasystick.ability.Hex.Settings.defaults(),mitigation);var registry=new games.dmg.fantasystick.ability.AbilityRegistry();registry.register(hex.definition());
+        var base=new games.dmg.fantasystick.crafting.CharacterFactory().create(games.dmg.fantasystick.progression.ProgressionRules.defaults());var stats=new EnumMap<>(base.stats());stats.put(Stat.CHR,BigInteger.valueOf(14));stats.put(Stat.WIS,BigInteger.valueOf(12));
+        var record=new CharacterRecord(base.id(),base.name(),base.revision(),stats,base.level(),base.experience(),base.unspentPoints(),base.health(),java.util.Set.of("hex"),List.of("hex","","","","","",""),base.cooldowns(),base.restrictedKills(),false,null,null);
+        var active=new games.dmg.fantasystick.session.EquipmentSessions.Active(java.util.UUID.randomUUID(),java.util.UUID.randomUUID(),record.id());var player=mock(org.bukkit.entity.Player.class);when(player.getUniqueId()).thenReturn(active.player());var world=mock(org.bukkit.World.class);doReturn(new Location(world,0,64,0)).when(player).getLocation();
+        var enemy=mock(org.bukkit.entity.LivingEntity.class);when(enemy.getUniqueId()).thenReturn(java.util.UUID.randomUUID());when(enemy.getType()).thenReturn(org.bukkit.entity.EntityType.ZOMBIE);when(enemy.getLocation()).thenReturn(new Location(world,8,64,0));doReturn(true).when(player).hasLineOfSight(enemy);when(sessions.current(active)).thenReturn(true);when(sessions.currentRecord(active)).thenReturn(java.util.Optional.of(record));
+        var failed=new java.util.concurrent.CompletableFuture<CharacterStorage.AbilityMutation>();failed.completeExceptionally(new java.io.IOException("simulated"));when(storage.commitAbilityCooldown(eq(record.id()),eq(record.revision()),eq("hex"),any())).thenReturn(failed);
+        var engine=new games.dmg.fantasystick.ability.AbilityEngine(registry,storage,sessions,parties,java.time.Clock.systemUTC(),Runnable::run,(delay,action)->()->{},ignored->{},ignored->{});engine.accept(new games.dmg.fantasystick.session.ControlInput(player,active,2,"hex",games.dmg.fantasystick.session.ControlInput.Kind.ABILITY,games.dmg.fantasystick.session.ControlInput.Gesture.USE,enemy,0,0,()->true));
+        verify(storage).commitAbilityCooldown(eq(record.id()),eq(record.revision()),eq("hex"),any());var hit=new EntityDamageByEntityEvent(enemy,mock(org.bukkit.entity.Zombie.class),EntityDamageEvent.DamageCause.ENTITY_ATTACK,mock(DamageSource.class),10);mitigation.reduce(hit);assertEquals(10,hit.getDamage(),1.0e-9);engine.close();hex.close();mitigation.close();parties.close();
+    }
+
+    @Test void cancelledDamageCreatesNoReductionOrSupportButRetainsAcknowledgedCooldown() throws Exception {
+        try(var f=new FantasyStickLifecycleNativeTest.Fixture(data)){f.plugin.setEnabled(true);var a=new FantasyStickLifecycleNativeTest.Actor(data);var b=new FantasyStickLifecycleNativeTest.Actor(data);withHex(data,a,true);
+            f.players.put(a.core.id,a.player);f.players.put(b.core.id,b.player);f.activate(a);f.activate(b);var parties=PartyLifecycleNativeTest.parties(f);var party=parties.create(a.core.id).orElseThrow();assertTrue(parties.accept(b.core.id,parties.invite(a.core.id,party.id(),b.core.id).orElseThrow().id()));
+            var enemy=mock(org.bukkit.entity.LivingEntity.class);when(enemy.getUniqueId()).thenReturn(java.util.UUID.randomUUID());when(enemy.getType()).thenReturn(org.bukkit.entity.EntityType.ZOMBIE);doReturn(new Location(a.world,0,64,0)).when(a.player).getLocation();when(enemy.getLocation()).thenReturn(new Location(a.world,8,64,0));doReturn(true).when(a.player).hasLineOfSight(enemy);doReturn(enemy).when(a.player).getTargetEntity(64);use(f,a);PartyBookNativeTest.drain(f);PartyBookNativeTest.drain(f);
+            class Veto implements org.bukkit.event.Listener{@org.bukkit.event.EventHandler(priority=org.bukkit.event.EventPriority.LOWEST)public void damage(EntityDamageByEntityEvent event){if(event.getDamager()==enemy)event.setCancelled(true);}}
+            f.dispatcher.register(new Veto(),f.plugin);var source=DamageSource.builder(DamageType.MOB_ATTACK).withCausingEntity(enemy).withDirectEntity(enemy).build();var hit=new EntityDamageByEntityEvent(enemy,b.player,EntityDamageEvent.DamageCause.ENTITY_ATTACK,source,10);f.dispatcher.accept(hit);assertTrue(hit.isCancelled());assertEquals(10,hit.getDamage(),1.0e-9);
+            var storage=(CharacterStorage)FantasyStickLifecycleNativeTest.Fixture.field(f.plugin,"characters");assertNotNull(storage.find(a.core.record.id()).get().orElseThrow().cooldowns().get("hex"));
+        }
+    }
+
+    @Test void unlearnRelearnAndTransferRetainCooldownAndClearOwnedPenalty() throws Exception {
+        java.nio.file.Files.writeString(data.resolve("config.yml"),"hex-cooldown-seconds: 60\n");try(var f=new FantasyStickLifecycleNativeTest.Fixture(data)){f.plugin.setEnabled(true);var a=new FantasyStickLifecycleNativeTest.Actor(data);withHex(data,a,true);f.players.put(a.core.id,a.player);f.activate(a);
+            var enemy=mock(org.bukkit.entity.LivingEntity.class);when(enemy.getUniqueId()).thenReturn(java.util.UUID.randomUUID());when(enemy.getType()).thenReturn(org.bukkit.entity.EntityType.ZOMBIE);doReturn(new Location(a.world,0,64,0)).when(a.player).getLocation();when(enemy.getLocation()).thenReturn(new Location(a.world,8,64,0));doReturn(true).when(a.player).hasLineOfSight(enemy);doReturn(enemy).when(a.player).getTargetEntity(64);use(f,a);PartyBookNativeTest.drain(f);PartyBookNativeTest.drain(f);
+            var storage=(CharacterStorage)FantasyStickLifecycleNativeTest.Fixture.field(f.plugin,"characters");var deadline=storage.find(a.core.record.id()).get().orElseThrow().cooldowns().get("hex");
+            a.core.inventory.getInventory().setSelectedSlot(0);PartyBookNativeTest.open(f,a);var unlearn=abilityButton(a,"[Unlearn]","hex");PartyBookNativeTest.click(f,a,unlearn);PartyBookNativeTest.click(f,a,unlearn);PartyBookNativeTest.drain(f);PartyBookNativeTest.drain(f);
+            var refunded=storage.find(a.core.record.id()).get().orElseThrow();assertEquals(BigInteger.valueOf(40),refunded.unspentPoints());assertEquals(deadline,refunded.cooldowns().get("hex"));
+            var hit=new EntityDamageByEntityEvent(enemy,mock(org.bukkit.entity.Zombie.class),EntityDamageEvent.DamageCause.ENTITY_ATTACK,mock(DamageSource.class),10);f.dispatcher.accept(hit);assertEquals(10,hit.getDamage(),1.0e-9);
+            learnAndAssign(f,a);use(f,a);assertTrue(a.messages.stream().anyMatch(message->message.contains("ready in")));
+            var sheet=a.core.inventory.getItemInOffHand().clone();a.core.inventory.setItemInOffHand(null);f.changed(a);PartyBookNativeTest.drain(f);f.awaitCharacterAndReceipt(a);var b=new FantasyStickLifecycleNativeTest.Actor(data);b.core.inventory.setItemInOffHand(sheet);f.players.put(b.core.id,b.player);f.activate(b);doReturn(new Location(a.world,0,64,0)).when(b.player).getLocation();doReturn(true).when(b.player).hasLineOfSight(enemy);doReturn(enemy).when(b.player).getTargetEntity(64);use(f,b);assertTrue(b.messages.stream().anyMatch(message->message.contains("ready in")));assertEquals(deadline,storage.find(a.core.record.id()).get().orElseThrow().cooldowns().get("hex"));
+        }}
+
+    @Test void configuredDefinitionAdminRoutesRestartAndStartupValidationCoverEverySetting() throws Exception {
+        java.nio.file.Files.writeString(data.resolve("config.yml"),"hex-cooldown-seconds: 2\nhex-range-blocks: 16\nhex-duration-seconds: 6\nhex-damage-reduction-percent: 30\n");
+        try(var f=new FantasyStickLifecycleNativeTest.Fixture(data)){f.plugin.setEnabled(true);var registry=(games.dmg.fantasystick.ability.AbilityRegistry)FantasyStickLifecycleNativeTest.Fixture.field(f.plugin,"abilityRegistry");var d=registry.find("hex").orElseThrow();
+            assertEquals(java.time.Duration.ofSeconds(2),d.cooldown());assertEquals(0,new java.math.BigDecimal("16").compareTo(d.parameters().get("range")));assertEquals(0,new java.math.BigDecimal("6").compareTo(d.parameters().get("duration-seconds")));assertEquals(0,new java.math.BigDecimal("30").compareTo(d.parameters().get("damage-reduction-percent")));
+            var sender=new EquipmentAdminCommandNativeTest.Sender();sender.allowed=false;assertTrue(f.command.tabComplete(sender.port,"fantasystick",new String[]{"config","hex-"}).isEmpty());
+            f.command.execute(sender.port,"fantasystick",new String[]{"config","hex-range-blocks","18"});assertTrue(sender.messages.getLast().contains("Permission denied"));sender.allowed=true;
+            assertEquals(List.of("hex-cooldown-seconds","hex-damage-reduction-percent","hex-duration-seconds","hex-range-blocks"),f.command.tabComplete(sender.port,"fantasystick",new String[]{"config","hex-"}));
+            assertEquals(List.of("12","16"),f.command.tabComplete(sender.port,"fantasystick",new String[]{"config","hex-range-blocks",""}));
+            f.command.execute(sender.port,"fantasystick",new String[]{"config","hex-range-blocks"});assertTrue(sender.messages.getLast().contains("=16"));
+            f.command.execute(sender.port,"fantasystick",new String[]{"config","hex-range-blocks","18"});var response=f.tasks.poll(5,java.util.concurrent.TimeUnit.SECONDS);assertNotNull(response);response.run();
+            assertEquals(0,new java.math.BigDecimal("18").compareTo(registry.find("hex").orElseThrow().parameters().get("range")));
+            var a=new FantasyStickLifecycleNativeTest.Actor(data);withHex(data,a,true);f.players.put(a.core.id,a.player);f.activate(a);var enemy=mock(org.bukkit.entity.LivingEntity.class);when(enemy.getUniqueId()).thenReturn(java.util.UUID.randomUUID());when(enemy.getType()).thenReturn(org.bukkit.entity.EntityType.ZOMBIE);doReturn(new Location(a.world,0,64,0)).when(a.player).getLocation();when(enemy.getLocation()).thenReturn(new Location(a.world,17,64,0));doReturn(true).when(a.player).hasLineOfSight(enemy);doReturn(enemy).when(a.player).getTargetEntity(64);use(f,a);PartyBookNativeTest.drain(f);PartyBookNativeTest.drain(f);var configured=new EntityDamageByEntityEvent(enemy,mock(org.bukkit.entity.Zombie.class),EntityDamageEvent.DamageCause.ENTITY_ATTACK,mock(DamageSource.class),10);f.dispatcher.accept(configured);assertEquals(7,configured.getDamage(),1.0e-9);
+            f.command.execute(sender.port,"fantasystick",new String[]{"config","hex-range-blocks","0"});assertTrue(sender.messages.getLast().contains("invalid"));
+            f.command.execute(sender.port,"fantasystick",new String[]{"config","hex-range-blocks","18","extra"});assertTrue(sender.messages.getLast().contains("Usage"));
+            f.plugin.setEnabled(false);f.plugin.setEnabled(true);var reloaded=(games.dmg.fantasystick.ability.AbilityRegistry)FantasyStickLifecycleNativeTest.Fixture.field(f.plugin,"abilityRegistry");assertEquals(0,new java.math.BigDecimal("18").compareTo(reloaded.find("hex").orElseThrow().parameters().get("range")));
+        }
+        for(String invalid:List.of("hex-cooldown-seconds: -1\n","hex-range-blocks: 0\n","hex-duration-seconds: 0\n","hex-damage-reduction-percent: 101\n")){var dir=data.resolve(Integer.toHexString(invalid.hashCode()));java.nio.file.Files.createDirectories(dir);java.nio.file.Files.writeString(dir.resolve("config.yml"),invalid);try(var f=new FantasyStickLifecycleNativeTest.Fixture(dir)){assertThrows(IllegalArgumentException.class,()->f.plugin.setEnabled(true));assertTrue(f.order.isEmpty());}}
+    }
+
+    @Test void partyAndMixedModeAimedPlayersRefuseWithoutCooldown() throws Exception {
+        for(int route=0;route<2;route++){var dir=data.resolve("player-refused-"+route);try(var f=new FantasyStickLifecycleNativeTest.Fixture(dir)){f.plugin.setEnabled(true);var a=new FantasyStickLifecycleNativeTest.Actor(dir);withHex(dir,a,true);f.players.put(a.core.id,a.player);f.activate(a);org.bukkit.entity.Player target;
+            if(route==0){var b=new FantasyStickLifecycleNativeTest.Actor(dir);target=b.player;f.players.put(b.core.id,b.player);f.activate(b);var parties=PartyLifecycleNativeTest.parties(f);var party=parties.create(a.core.id).orElseThrow();assertTrue(parties.accept(b.core.id,parties.invite(a.core.id,party.id(),b.core.id).orElseThrow().id()));}else{target=mock(org.bukkit.entity.Player.class);when(target.getUniqueId()).thenReturn(java.util.UUID.randomUUID());}
+            doReturn(new Location(a.world,0,64,0)).when(a.player).getLocation();doReturn(new Location(a.world,8,64,0)).when(target).getLocation();doReturn(true).when(a.player).hasLineOfSight(target);doReturn(target).when(a.player).getTargetEntity(64);use(f,a);PartyBookNativeTest.drain(f);var storage=(CharacterStorage)FantasyStickLifecycleNativeTest.Fixture.field(f.plugin,"characters");assertFalse(storage.find(a.core.record.id()).get().orElseThrow().cooldowns().containsKey("hex"));}}
+    }
+
+    @Test void firstAimedOutOfRangeOrObstructedTargetRefusesWithoutFallbackOrCooldown() throws Exception {
+        for(int route=0;route<2;route++){var dir=data.resolve("refused-"+route);try(var f=new FantasyStickLifecycleNativeTest.Fixture(dir)){f.plugin.setEnabled(true);var a=new FantasyStickLifecycleNativeTest.Actor(dir);withHex(dir,a,true);f.players.put(a.core.id,a.player);f.activate(a);
+            var enemy=mock(org.bukkit.entity.LivingEntity.class);when(enemy.getUniqueId()).thenReturn(java.util.UUID.randomUUID());when(enemy.getType()).thenReturn(org.bukkit.entity.EntityType.ZOMBIE);doReturn(new Location(a.world,0,64,0)).when(a.player).getLocation();when(enemy.getLocation()).thenReturn(new Location(a.world,route==0?13:8,64,0));doReturn(route==0).when(a.player).hasLineOfSight(enemy);doReturn(enemy).when(a.player).getTargetEntity(64);use(f,a);PartyBookNativeTest.drain(f);
+            var storage=(CharacterStorage)FantasyStickLifecycleNativeTest.Fixture.field(f.plugin,"characters");assertFalse(storage.find(a.core.record.id()).get().orElseThrow().cooldowns().containsKey("hex"));}}
+    }
+
+    private static void learnAndAssign(FantasyStickLifecycleNativeTest.Fixture f,FantasyStickLifecycleNativeTest.Actor a)throws Exception{a.core.inventory.getInventory().setSelectedSlot(0);PartyBookNativeTest.open(f,a);PartyBookNativeTest.click(f,a,abilityButton(a,"[Learn]","hex"));PartyBookNativeTest.drain(f);PartyBookNativeTest.drain(f);PartyBookNativeTest.click(f,a,abilityButton(a,"[3]","hex"));PartyBookNativeTest.drain(f);PartyBookNativeTest.drain(f);}
+
+    private static void use(FantasyStickLifecycleNativeTest.Fixture f,FantasyStickLifecycleNativeTest.Actor a){a.core.inventory.getInventory().setSelectedSlot(2);
+        f.dispatcher.accept(new PlayerInteractEvent(a.player,org.bukkit.event.block.Action.RIGHT_CLICK_AIR,a.core.inventory.getItem(2),null,org.bukkit.block.BlockFace.SELF,EquipmentSlot.HAND));}
+
+    private static ClickEvent.Custom abilityButton(FantasyStickLifecycleNativeTest.Actor actor,String label,String ability){
+        var book=org.bukkit.craftbukkit.inventory.CraftItemStack.asNMSCopy(actor.books.getLast()).get(net.minecraft.core.component.DataComponents.WRITTEN_BOOK_CONTENT);assertNotNull(book);
+        for(var page:book.pages()){var found=abilityButton(page.raw(),label,ability);if(found!=null)return found;}throw new AssertionError("Missing action");}
+    private static ClickEvent.Custom abilityButton(net.minecraft.network.chat.Component component,String label,String ability){
+        if(component.getString().equals(label)&&component.getStyle().getClickEvent() instanceof ClickEvent.Custom custom
+            &&custom.payload().orElse(null) instanceof net.minecraft.nbt.StringTag payload&&payload.value().contains(":"+ability))return custom;
+        for(var child:component.getSiblings()){var found=abilityButton(child,label,ability);if(found!=null)return found;}return null;}
+    private static void withHex(Path data,FantasyStickLifecycleNativeTest.Actor actor,boolean learned)throws Exception{
+        java.nio.file.Files.createDirectories(data);var repository=new games.dmg.fantasystick.persistence.YamlCharacterRepository(data);
+        var old=repository.load(actor.core.record.id()).orElseThrow();var stats=new EnumMap<>(old.stats());
+        stats.put(Stat.CHR,BigInteger.valueOf(14));stats.put(Stat.WIS,BigInteger.valueOf(12));
+        repository.replace(new CharacterRecord(old.id(),old.name(),old.revision().add(BigInteger.ONE),stats,old.level(),old.experience(),
+            BigInteger.valueOf(learned?39:40),old.health(),learned?java.util.Set.of("hex"):old.learned(),
+            learned?List.of("hex","","","","","",""):old.loadout(),old.cooldowns(),old.restrictedKills(),false,null,null),old.revision());}
+}

src/nativeTest/java/games/dmg/fantasystick/InspireNativeTest.java

@@ -0,0 +1,27 @@
+package games.dmg.fantasystick;
+import static org.junit.jupiter.api.Assertions.*;import static org.mockito.Mockito.*;
+import games.dmg.fantasystick.persistence.*;import games.dmg.fantasystick.progression.Stat;import java.math.BigInteger;import java.nio.file.Path;import java.util.*;import net.minecraft.network.chat.ClickEvent;import org.bukkit.event.player.PlayerInteractEvent;import org.bukkit.inventory.EquipmentSlot;import org.junit.jupiter.api.*;import org.junit.jupiter.api.io.TempDir;
+class InspireNativeTest{@TempDir Path data;@BeforeAll static void bootstrap()throws Exception{NativeRuntime.bootstrap();}
+ @Test void bookAcquisitionSneakUseAddsOwnedTemporaryHealthAndExpiryPreservesUnrelatedAbsorption()throws Exception{try(var f=new FantasyStickLifecycleNativeTest.Fixture(data)){f.plugin.setEnabled(true);var a=new FantasyStickLifecycleNativeTest.Actor(data);withInspire(data,a,false);f.players.put(a.core.id,a.player);f.activate(a);a.core.inventory.getInventory().setSelectedSlot(0);PartyBookNativeTest.open(f,a);String book=PartyBookNativeTest.text(a).replaceAll("\\s+","");assertTrue(book.contains("Inspire"));assertTrue(book.contains("CHR12"));assertTrue(book.contains("WIS10"));assertTrue(book.contains("Cost:1"));assertTrue(book.contains("12"));assertTrue(book.contains("6s"));PartyBookNativeTest.click(f,a,button(a,"[Learn]","inspire"));PartyBookNativeTest.drain(f);PartyBookNativeTest.drain(f);PartyBookNativeTest.click(f,a,button(a,"[3]","inspire"));PartyBookNativeTest.drain(f);PartyBookNativeTest.drain(f);
+   double maximum=a.maximumHealth.getBaseValue();var absorption=new java.util.concurrent.atomic.AtomicReference<>(2.0);doAnswer(c->absorption.get()).when(a.player).getAbsorptionAmount();doAnswer(c->{absorption.set(c.getArgument(0));return null;}).when(a.player).setAbsorptionAmount(anyDouble());doReturn(true).when(a.player).isSneaking();a.core.inventory.getInventory().setSelectedSlot(2);f.dispatcher.accept(new PlayerInteractEvent(a.player,org.bukkit.event.block.Action.RIGHT_CLICK_AIR,a.core.inventory.getItem(2),null,org.bukkit.block.BlockFace.SELF,EquipmentSlot.HAND));PartyBookNativeTest.drain(f);PartyBookNativeTest.drain(f);assertEquals(7,absorption.get(),1e-9);assertEquals(maximum,a.maximumHealth.getBaseValue(),1e-9);assertEquals(120L,f.delayedTicks.getLast());f.delayed.getLast().run();assertEquals(2,absorption.get(),1e-9);var storage=(CharacterStorage)FantasyStickLifecycleNativeTest.Fixture.field(f.plugin,"characters");assertNotNull(storage.find(a.core.record.id()).get().orElseThrow().cooldowns().get("inspire"));}}
+ @Test void aimedPartyAllyActualAbsorptionCreatesPersistedSupportShare()throws Exception{try(var f=new FantasyStickLifecycleNativeTest.Fixture(data)){f.plugin.setEnabled(true);var a=new FantasyStickLifecycleNativeTest.Actor(data);var b=new FantasyStickLifecycleNativeTest.Actor(data);withInspire(data,a,true);f.players.put(a.core.id,a.player);f.players.put(b.core.id,b.player);f.activate(a);f.activate(b);var parties=PartyLifecycleNativeTest.parties(f);var party=parties.create(a.core.id).orElseThrow();assertTrue(parties.accept(b.core.id,parties.invite(a.core.id,party.id(),b.core.id).orElseThrow().id()));
+  doReturn(false).when(a.player).isSneaking();doReturn(new org.bukkit.Location(a.world,0,64,0)).when(a.player).getLocation();doReturn(new org.bukkit.Location(a.world,8,64,0)).when(b.player).getLocation();doReturn(true).when(a.player).hasLineOfSight(b.player);doReturn(b.player).when(a.player).getTargetEntity(64);var absorption=new java.util.concurrent.atomic.AtomicReference<>(0.0);doAnswer(c->absorption.get()).when(b.player).getAbsorptionAmount();doAnswer(c->{absorption.set(c.getArgument(0));return null;}).when(b.player).setAbsorptionAmount(anyDouble());use(f,a);PartyBookNativeTest.drain(f);PartyBookNativeTest.drain(f);assertEquals(5,absorption.get(),1e-9);
+  var enemy=mock(org.bukkit.entity.LivingEntity.class);when(enemy.getUniqueId()).thenReturn(java.util.UUID.randomUUID());when(enemy.getType()).thenReturn(org.bukkit.entity.EntityType.ZOMBIE);when(a.world.getUID()).thenReturn(java.util.UUID.randomUUID());when(enemy.getLocation()).thenReturn(new org.bukkit.Location(a.world,8,64,0));var enemySource=org.bukkit.damage.DamageSource.builder(org.bukkit.damage.DamageType.MOB_ATTACK).withCausingEntity(enemy).withDirectEntity(enemy).build();f.dispatcher.accept(new org.bukkit.event.entity.EntityDamageByEntityEvent(enemy,b.player,org.bukkit.event.entity.EntityDamageEvent.DamageCause.ENTITY_ATTACK,enemySource,3));absorption.set(2.0);PartyBookNativeTest.drain(f);var sourceSheet=a.core.inventory.getItemInOffHand().clone();a.core.inventory.setItemInOffHand(null);f.changed(a);PartyBookNativeTest.drain(f);f.awaitCharacterAndReceipt(a);var holder=new FantasyStickLifecycleNativeTest.Actor(data);holder.core.inventory.setItemInOffHand(sourceSheet);f.players.put(holder.core.id,holder.player);f.activate(holder);
+  var allySource=org.bukkit.damage.DamageSource.builder(org.bukkit.damage.DamageType.PLAYER_ATTACK).withCausingEntity(b.player).withDirectEntity(b.player).build();f.dispatcher.accept(new org.bukkit.event.entity.EntityDamageByEntityEvent(b.player,enemy,org.bukkit.event.entity.EntityDamageEvent.DamageCause.ENTITY_ATTACK,allySource,3));f.dispatcher.accept(new org.bukkit.event.entity.EntityDeathEvent(enemy,allySource,new java.util.ArrayList<>(),0));for(int i=0;i<4;i++)PartyBookNativeTest.drain(f);var storage=(CharacterStorage)FantasyStickLifecycleNativeTest.Fixture.field(f.plugin,"characters");assertEquals(BigInteger.valueOf(5),storage.find(a.core.record.id()).get().orElseThrow().experience());assertEquals(BigInteger.valueOf(5),storage.find(b.core.record.id()).get().orElseThrow().experience());}}
+ @Test void normalSelfOrdinaryOutOfRangeAndObstructedTargetsRefuseBeforeCooldown()throws Exception{for(int route=0;route<4;route++){var dir=data.resolve("refuse-"+route);try(var f=new FantasyStickLifecycleNativeTest.Fixture(dir)){f.plugin.setEnabled(true);var a=new FantasyStickLifecycleNativeTest.Actor(dir);withInspire(dir,a,true);f.players.put(a.core.id,a.player);f.activate(a);org.bukkit.entity.Player target;if(route==0)target=a.player;else if(route==1){target=mock(org.bukkit.entity.Player.class);when(target.getUniqueId()).thenReturn(java.util.UUID.randomUUID());}else{var b=new FantasyStickLifecycleNativeTest.Actor(dir);target=b.player;f.players.put(b.core.id,b.player);f.activate(b);}doReturn(false).when(a.player).isSneaking();doReturn(new org.bukkit.Location(a.world,0,64,0)).when(a.player).getLocation();doReturn(new org.bukkit.Location(a.world,route==2?13:8,64,0)).when(target).getLocation();doReturn(route!=3).when(a.player).hasLineOfSight(target);doReturn(target).when(a.player).getTargetEntity(64);use(f,a);PartyBookNativeTest.drain(f);var storage=(CharacterStorage)FantasyStickLifecycleNativeTest.Fixture.field(f.plugin,"characters");assertFalse(storage.find(a.core.record.id()).get().orElseThrow().cooldowns().containsKey("inspire"));}}}
+ @Test void nonPartyTargetIsAllowedAndStrongestRemainingCopiesPreserveUnrelatedAbsorption()throws Exception{java.nio.file.Files.writeString(data.resolve("config.yml"),"inspire-cooldown-seconds: 0\n");try(var f=new FantasyStickLifecycleNativeTest.Fixture(data)){f.plugin.setEnabled(true);var a=new FantasyStickLifecycleNativeTest.Actor(data);var c=new FantasyStickLifecycleNativeTest.Actor(data);var b=new FantasyStickLifecycleNativeTest.Actor(data);withInspire(data,a,true);withInspire(data,c,true);f.players.put(a.core.id,a.player);f.players.put(c.core.id,c.player);f.players.put(b.core.id,b.player);f.activate(a);f.activate(c);f.activate(b);var absorption=new java.util.concurrent.atomic.AtomicReference<>(2.0);doAnswer(x->absorption.get()).when(b.player).getAbsorptionAmount();doAnswer(x->{absorption.set(x.getArgument(0));return null;}).when(b.player).setAbsorptionAmount(anyDouble());for(var caster:List.of(a,c)){doReturn(false).when(caster.player).isSneaking();doReturn(new org.bukkit.Location(a.world,0,64,0)).when(caster.player).getLocation();doReturn(true).when(caster.player).hasLineOfSight(b.player);doReturn(b.player).when(caster.player).getTargetEntity(64);}doReturn(new org.bukkit.Location(a.world,8,64,0)).when(b.player).getLocation();use(f,a);PartyBookNativeTest.drain(f);PartyBookNativeTest.drain(f);assertEquals(7,absorption.get(),1e-9);var sender=new EquipmentAdminCommandNativeTest.Sender();f.command.execute(sender.port,"fantasystick",new String[]{"config","inspire-base-temporary-health","6"});var response=f.tasks.poll(5,java.util.concurrent.TimeUnit.SECONDS);assertNotNull(response);response.run();use(f,c);PartyBookNativeTest.drain(f);PartyBookNativeTest.drain(f);assertEquals(9,absorption.get(),1e-9);
+  var enemy=mock(org.bukkit.entity.Zombie.class);when(enemy.getUniqueId()).thenReturn(java.util.UUID.randomUUID());var source=org.bukkit.damage.DamageSource.builder(org.bukkit.damage.DamageType.MOB_ATTACK).withCausingEntity(enemy).withDirectEntity(enemy).build();f.dispatcher.accept(new org.bukkit.event.entity.EntityDamageByEntityEvent(enemy,b.player,org.bukkit.event.entity.EntityDamageEvent.DamageCause.ENTITY_ATTACK,source,3));absorption.set(6.0);PartyBookNativeTest.drain(f);f.delayed.getLast().run();assertEquals(4,absorption.get(),1e-9);f.delayed.getFirst().run();assertEquals(2,absorption.get(),1e-9);}}
+ @Test void cancelledOrSelfOnlyProtectionCannotManufactureSupportShare()throws Exception{for(int route=0;route<2;route++){var dir=data.resolve("no-support-"+route);try(var f=new FantasyStickLifecycleNativeTest.Fixture(dir)){f.plugin.setEnabled(true);var a=new FantasyStickLifecycleNativeTest.Actor(dir);var b=new FantasyStickLifecycleNativeTest.Actor(dir);withInspire(dir,a,true);f.players.put(a.core.id,a.player);f.players.put(b.core.id,b.player);f.activate(a);f.activate(b);var parties=PartyLifecycleNativeTest.parties(f);var party=parties.create(a.core.id).orElseThrow();assertTrue(parties.accept(b.core.id,parties.invite(a.core.id,party.id(),b.core.id).orElseThrow().id()));var target=route==0?b.player:a.player;var absorption=new java.util.concurrent.atomic.AtomicReference<>(0.0);doAnswer(x->absorption.get()).when(target).getAbsorptionAmount();doAnswer(x->{absorption.set(x.getArgument(0));return null;}).when(target).setAbsorptionAmount(anyDouble());doReturn(route==1).when(a.player).isSneaking();doReturn(new org.bukkit.Location(a.world,0,64,0)).when(a.player).getLocation();doReturn(new org.bukkit.Location(a.world,8,64,0)).when(b.player).getLocation();doReturn(true).when(a.player).hasLineOfSight(b.player);doReturn(b.player).when(a.player).getTargetEntity(64);use(f,a);PartyBookNativeTest.drain(f);PartyBookNativeTest.drain(f);var enemy=mock(org.bukkit.entity.LivingEntity.class);when(enemy.getUniqueId()).thenReturn(java.util.UUID.randomUUID());when(enemy.getType()).thenReturn(org.bukkit.entity.EntityType.ZOMBIE);when(enemy.getLocation()).thenReturn(new org.bukkit.Location(a.world,8,64,0));when(a.world.getUID()).thenReturn(java.util.UUID.randomUUID());var enemySource=org.bukkit.damage.DamageSource.builder(org.bukkit.damage.DamageType.MOB_ATTACK).withCausingEntity(enemy).withDirectEntity(enemy).build();var hit=new org.bukkit.event.entity.EntityDamageByEntityEvent(enemy,target,org.bukkit.event.entity.EntityDamageEvent.DamageCause.ENTITY_ATTACK,enemySource,3);if(route==0)hit.setCancelled(true);f.dispatcher.accept(hit);if(route==1){absorption.set(2.0);PartyBookNativeTest.drain(f);}var allySource=org.bukkit.damage.DamageSource.builder(org.bukkit.damage.DamageType.PLAYER_ATTACK).withCausingEntity(b.player).withDirectEntity(b.player).build();f.dispatcher.accept(new org.bukkit.event.entity.EntityDamageByEntityEvent(b.player,enemy,org.bukkit.event.entity.EntityDamageEvent.DamageCause.ENTITY_ATTACK,allySource,3));f.dispatcher.accept(new org.bukkit.event.entity.EntityDeathEvent(enemy,allySource,new java.util.ArrayList<>(),0));for(int i=0;i<4;i++)PartyBookNativeTest.drain(f);var storage=(CharacterStorage)FantasyStickLifecycleNativeTest.Fixture.field(f.plugin,"characters");assertEquals(BigInteger.ZERO,storage.find(a.core.record.id()).get().orElseThrow().experience());assertEquals(BigInteger.TEN,storage.find(b.core.record.id()).get().orElseThrow().experience());}}}
+ @Test void exactFormulaSupportsFiniteUncappedCharisma(){assertEquals(BigInteger.valueOf(5),games.dmg.fantasystick.ability.Inspire.amount(BigInteger.valueOf(12)));assertEquals(BigInteger.valueOf(3),games.dmg.fantasystick.ability.Inspire.amount(BigInteger.valueOf(9)));var huge=BigInteger.TEN.pow(500);assertEquals(huge.subtract(BigInteger.TEN).divide(BigInteger.TWO).add(BigInteger.valueOf(4)),games.dmg.fantasystick.ability.Inspire.amount(huge));}
+ @Test void failedCooldownPersistencePublishesNoTemporaryHealth(){var storage=mock(CharacterStorage.class);var sessions=mock(games.dmg.fantasystick.session.EquipmentSessions.class);var parties=new games.dmg.fantasystick.party.PartyRoster(java.time.Clock.systemUTC(),ignored->true);var temporary=new games.dmg.fantasystick.ability.TemporaryHealth(sessions,parties,Runnable::run,ignored->{});var inspire=new games.dmg.fantasystick.ability.Inspire(games.dmg.fantasystick.ability.Inspire.Settings.defaults(),temporary);var registry=new games.dmg.fantasystick.ability.AbilityRegistry();registry.register(inspire.definition());var base=new games.dmg.fantasystick.crafting.CharacterFactory().create(games.dmg.fantasystick.progression.ProgressionRules.defaults());var stats=new EnumMap<>(base.stats());stats.put(Stat.CHR,BigInteger.valueOf(12));stats.put(Stat.WIS,BigInteger.TEN);var record=new CharacterRecord(base.id(),base.name(),base.revision(),stats,base.level(),base.experience(),base.unspentPoints(),base.health(),Set.of("inspire"),List.of("inspire","","","","","",""),base.cooldowns(),base.restrictedKills(),false,null,null);var active=new games.dmg.fantasystick.session.EquipmentSessions.Active(java.util.UUID.randomUUID(),java.util.UUID.randomUUID(),record.id());var player=mock(org.bukkit.entity.Player.class);when(player.getUniqueId()).thenReturn(active.player());when(player.isSneaking()).thenReturn(true);when(sessions.active(active.player())).thenReturn(java.util.Optional.of(active));when(sessions.current(active)).thenReturn(true);when(sessions.currentRecord(active)).thenReturn(java.util.Optional.of(record));var failed=new java.util.concurrent.CompletableFuture<CharacterStorage.AbilityMutation>();failed.completeExceptionally(new java.io.IOException("simulated"));when(storage.commitAbilityCooldown(eq(record.id()),eq(record.revision()),eq("inspire"),any())).thenReturn(failed);var engine=new games.dmg.fantasystick.ability.AbilityEngine(registry,storage,sessions,parties,java.time.Clock.systemUTC(),Runnable::run,(delay,action)->()->{},ignored->{},ignored->{});engine.accept(new games.dmg.fantasystick.session.ControlInput(player,active,2,"inspire",games.dmg.fantasystick.session.ControlInput.Kind.ABILITY,games.dmg.fantasystick.session.ControlInput.Gesture.USE,player,0,0,()->true));verify(storage).commitAbilityCooldown(eq(record.id()),eq(record.revision()),eq("inspire"),any());verify(player,never()).setAbsorptionAmount(anyDouble());engine.close();inspire.close();temporary.close();parties.close();}
+ @Test void unlearnRelearnAndTransferRetainCooldownAndClearOnlyOwnedTemporaryHealth()throws Exception{java.nio.file.Files.writeString(data.resolve("config.yml"),"inspire-cooldown-seconds: 60\n");try(var f=new FantasyStickLifecycleNativeTest.Fixture(data)){f.plugin.setEnabled(true);var a=new FantasyStickLifecycleNativeTest.Actor(data);withInspire(data,a,true);f.players.put(a.core.id,a.player);f.activate(a);var absorption=new java.util.concurrent.atomic.AtomicReference<>(2.0);doAnswer(x->absorption.get()).when(a.player).getAbsorptionAmount();doAnswer(x->{absorption.set(x.getArgument(0));return null;}).when(a.player).setAbsorptionAmount(anyDouble());doReturn(true).when(a.player).isSneaking();use(f,a);PartyBookNativeTest.drain(f);PartyBookNativeTest.drain(f);assertEquals(7,absorption.get(),1e-9);var storage=(CharacterStorage)FantasyStickLifecycleNativeTest.Fixture.field(f.plugin,"characters");var deadline=storage.find(a.core.record.id()).get().orElseThrow().cooldowns().get("inspire");a.core.inventory.getInventory().setSelectedSlot(0);PartyBookNativeTest.open(f,a);var unlearn=button(a,"[Unlearn]","inspire");PartyBookNativeTest.click(f,a,unlearn);PartyBookNativeTest.click(f,a,unlearn);PartyBookNativeTest.drain(f);PartyBookNativeTest.drain(f);assertEquals(2,absorption.get(),1e-9);var refunded=storage.find(a.core.record.id()).get().orElseThrow();assertEquals(BigInteger.valueOf(40),refunded.unspentPoints());assertEquals(deadline,refunded.cooldowns().get("inspire"));learnAndAssign(f,a);use(f,a);assertTrue(a.messages.stream().anyMatch(m->m.contains("ready in")));var sheet=a.core.inventory.getItemInOffHand().clone();a.core.inventory.setItemInOffHand(null);f.changed(a);PartyBookNativeTest.drain(f);f.awaitCharacterAndReceipt(a);var b=new FantasyStickLifecycleNativeTest.Actor(data);b.core.inventory.setItemInOffHand(sheet);f.players.put(b.core.id,b.player);f.activate(b);doReturn(true).when(b.player).isSneaking();use(f,b);assertTrue(b.messages.stream().anyMatch(m->m.contains("ready in")));assertEquals(deadline,storage.find(a.core.record.id()).get().orElseThrow().cooldowns().get("inspire"));}}
+ @Test void configuredDefinitionAdminRestartFutureCastAndStartupValidationCoverEverySetting()throws Exception{java.nio.file.Files.writeString(data.resolve("config.yml"),"inspire-base-temporary-health: 8\ninspire-cooldown-seconds: 0\ninspire-range-blocks: 16\ninspire-duration-seconds: 8\n");try(var f=new FantasyStickLifecycleNativeTest.Fixture(data)){f.plugin.setEnabled(true);var registry=(games.dmg.fantasystick.ability.AbilityRegistry)FantasyStickLifecycleNativeTest.Fixture.field(f.plugin,"abilityRegistry");var d=registry.find("inspire").orElseThrow();assertEquals(java.time.Duration.ZERO,d.cooldown());assertEquals(new java.math.BigDecimal("8"),d.parameters().get("base-temporary-health"));assertEquals(0,new java.math.BigDecimal("16").compareTo(d.parameters().get("range")));assertEquals(0,new java.math.BigDecimal("8").compareTo(d.parameters().get("duration-seconds")));
+  var sender=new EquipmentAdminCommandNativeTest.Sender();sender.allowed=false;assertTrue(f.command.tabComplete(sender.port,"fantasystick",new String[]{"config","inspire-"}).isEmpty());f.command.execute(sender.port,"fantasystick",new String[]{"config","inspire-base-temporary-health","9"});assertTrue(sender.messages.getLast().contains("Permission denied"));sender.allowed=true;assertEquals(List.of("inspire-base-temporary-health","inspire-cooldown-seconds","inspire-duration-seconds","inspire-range-blocks"),f.command.tabComplete(sender.port,"fantasystick",new String[]{"config","inspire-"}));assertEquals(List.of("4","8"),f.command.tabComplete(sender.port,"fantasystick",new String[]{"config","inspire-base-temporary-health",""}));f.command.execute(sender.port,"fantasystick",new String[]{"config","inspire-base-temporary-health"});assertTrue(sender.messages.getLast().contains("=8"));f.command.execute(sender.port,"fantasystick",new String[]{"config","inspire-base-temporary-health","9"});var response=f.tasks.poll(5,java.util.concurrent.TimeUnit.SECONDS);assertNotNull(response);response.run();assertEquals(new java.math.BigDecimal("9"),registry.find("inspire").orElseThrow().parameters().get("base-temporary-health"));
+  var a=new FantasyStickLifecycleNativeTest.Actor(data);withInspire(data,a,true);f.players.put(a.core.id,a.player);f.activate(a);var absorption=new java.util.concurrent.atomic.AtomicReference<>(0.0);doAnswer(c->absorption.get()).when(a.player).getAbsorptionAmount();doAnswer(c->{absorption.set(c.getArgument(0));return null;}).when(a.player).setAbsorptionAmount(anyDouble());doReturn(true).when(a.player).isSneaking();use(f,a);PartyBookNativeTest.drain(f);PartyBookNativeTest.drain(f);assertEquals(10,absorption.get(),1e-9);assertEquals(160L,f.delayedTicks.getLast());
+  f.command.execute(sender.port,"fantasystick",new String[]{"config","inspire-base-temporary-health","-1"});assertTrue(sender.messages.getLast().contains("invalid"));f.command.execute(sender.port,"fantasystick",new String[]{"config","inspire-base-temporary-health","9","extra"});assertTrue(sender.messages.getLast().contains("Usage"));f.plugin.setEnabled(false);f.plugin.setEnabled(true);var reload=(games.dmg.fantasystick.ability.AbilityRegistry)FantasyStickLifecycleNativeTest.Fixture.field(f.plugin,"abilityRegistry");assertEquals(new java.math.BigDecimal("9"),reload.find("inspire").orElseThrow().parameters().get("base-temporary-health"));}
+  for(String invalid:List.of("inspire-base-temporary-health: -1\n","inspire-cooldown-seconds: -1\n","inspire-range-blocks: 0\n","inspire-duration-seconds: 0\n")){var dir=data.resolve(Integer.toHexString(invalid.hashCode()));java.nio.file.Files.createDirectories(dir);java.nio.file.Files.writeString(dir.resolve("config.yml"),invalid);try(var f=new FantasyStickLifecycleNativeTest.Fixture(dir)){assertThrows(IllegalArgumentException.class,()->f.plugin.setEnabled(true));assertTrue(f.order.isEmpty());}}}
+ private static void learnAndAssign(FantasyStickLifecycleNativeTest.Fixture f,FantasyStickLifecycleNativeTest.Actor a)throws Exception{a.core.inventory.getInventory().setSelectedSlot(0);PartyBookNativeTest.open(f,a);PartyBookNativeTest.click(f,a,button(a,"[Learn]","inspire"));PartyBookNativeTest.drain(f);PartyBookNativeTest.drain(f);PartyBookNativeTest.click(f,a,button(a,"[3]","inspire"));PartyBookNativeTest.drain(f);PartyBookNativeTest.drain(f);}
+ private static void use(FantasyStickLifecycleNativeTest.Fixture f,FantasyStickLifecycleNativeTest.Actor a){a.core.inventory.getInventory().setSelectedSlot(2);f.dispatcher.accept(new PlayerInteractEvent(a.player,org.bukkit.event.block.Action.RIGHT_CLICK_AIR,a.core.inventory.getItem(2),null,org.bukkit.block.BlockFace.SELF,EquipmentSlot.HAND));}
+ private static ClickEvent.Custom button(FantasyStickLifecycleNativeTest.Actor a,String label,String ability){var b=org.bukkit.craftbukkit.inventory.CraftItemStack.asNMSCopy(a.books.getLast()).get(net.minecraft.core.component.DataComponents.WRITTEN_BOOK_CONTENT);assertNotNull(b);for(var p:b.pages()){var x=button(p.raw(),label,ability);if(x!=null)return x;}throw new AssertionError("missing action");}
+ private static ClickEvent.Custom button(net.minecraft.network.chat.Component c,String label,String ability){if(c.getString().equals(label)&&c.getStyle().getClickEvent() instanceof ClickEvent.Custom x&&x.payload().orElse(null) instanceof net.minecraft.nbt.StringTag p&&p.value().contains(":"+ability))return x;for(var k:c.getSiblings()){var x=button(k,label,ability);if(x!=null)return x;}return null;}
+ private static void withInspire(Path d,FantasyStickLifecycleNativeTest.Actor a,boolean learned)throws Exception{java.nio.file.Files.createDirectories(d);var r=new YamlCharacterRepository(d);var o=r.load(a.core.record.id()).orElseThrow();var s=new EnumMap<>(o.stats());s.put(Stat.CHR,BigInteger.valueOf(12));s.put(Stat.WIS,BigInteger.TEN);r.replace(new CharacterRecord(o.id(),o.name(),o.revision().add(BigInteger.ONE),s,o.level(),o.experience(),BigInteger.valueOf(learned?39:40),o.health(),learned?Set.of("inspire"):o.learned(),learned?List.of("inspire","","","","","",""):o.loadout(),o.cooldowns(),o.restrictedKills(),false,null,null),o.revision());}}

src/nativeTest/java/games/dmg/fantasystick/LongbowNativeTest.java

@@ -348,7 +348,7 @@ class LongbowNativeTest {
             assertThrows(AssertionError.class, () -> abilityButton(unavailable, "[Learn]", "longbow"));
 
             var sender = new EquipmentAdminCommandNativeTest.Sender();
-            assertEquals(java.util.List.of("config", "inspect", "recover"),
+            assertEquals(java.util.List.of("config", "experience", "give", "inspect", "recover"),
                 f.command.tabComplete(sender.port, "fantasystick", new String[]{""}));
             assertEquals(java.util.List.of("config"), f.command.tabComplete(sender.port, "fantasystick", new String[]{"c"}));
             assertTrue(f.command.tabComplete(sender.port, "fantasystick", new String[]{"unknown"}).isEmpty());

src/nativeTest/java/games/dmg/fantasystick/ManualCraftingControllerNativeTest.java

@@ -424,6 +424,8 @@ class ManualCraftingControllerNativeTest {
         org.bukkit.Location eyeLocation;
         boolean online = true;
         int syncs;
+        final java.util.Set<org.bukkit.NamespacedKey> knownRecipes = new java.util.LinkedHashSet<>();
+        int recipeAwards;
         Runnable onSync = () -> { };
 
         Actor(int width, int amount) {
@@ -438,6 +440,14 @@ class ManualCraftingControllerNativeTest {
                         case "getEyeLocation" -> java.util.Objects.requireNonNull(eyeLocation).clone();
                         case "isOnline" -> online;
                         case "updateInventory" -> { syncs++; onSync.run(); yield null; }
+                        case "getName" -> "CraftingActor";
+                        case "hasDiscoveredRecipe" -> knownRecipes.contains((org.bukkit.NamespacedKey) args[0]);
+                        case "discoverRecipes" -> {
+                            recipeAwards++; int before = knownRecipes.size();
+                            ((java.util.Collection<?>) args[0]).stream().map(org.bukkit.NamespacedKey.class::cast)
+                                .forEach(knownRecipes::add);
+                            yield knownRecipes.size() - before;
+                        }
                         case "equals" -> object == args[0];
                         case "hashCode" -> System.identityHashCode(object);
                         case "toString" -> "Crafting actor fixture";

src/nativeTest/java/games/dmg/fantasystick/MendingLightNativeTest.java

@@ -0,0 +1,356 @@
+package games.dmg.fantasystick;
+
+import static org.junit.jupiter.api.Assertions.*;
+import static org.mockito.ArgumentMatchers.*;
+import static org.mockito.Mockito.*;
+
+import games.dmg.fantasystick.ability.AbilityExecution;
+import games.dmg.fantasystick.ability.MendingLight;
+import games.dmg.fantasystick.party.PartyRoster;
+import games.dmg.fantasystick.persistence.CharacterRecord;
+import games.dmg.fantasystick.persistence.CharacterStorage;
+import games.dmg.fantasystick.persistence.MendingLightSettings;
+import games.dmg.fantasystick.persistence.YamlCharacterRepository;
+import games.dmg.fantasystick.progression.Stat;
+import games.dmg.fantasystick.session.ControlInput;
+import games.dmg.fantasystick.session.EquipmentSessions;
+import java.math.BigDecimal;
+import java.math.BigInteger;
+import java.nio.file.Path;
+import java.util.ArrayList;
+import java.util.EnumMap;
+import java.util.List;
+import java.util.Set;
+import java.util.UUID;
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.TimeUnit;
+import net.minecraft.network.chat.ClickEvent;
+import org.bukkit.Location;
+import org.bukkit.attribute.Attribute;
+import org.bukkit.attribute.AttributeInstance;
+import org.bukkit.entity.LivingEntity;
+import org.bukkit.entity.Player;
+import org.bukkit.event.entity.EntityDamageByEntityEvent;
+import org.bukkit.event.entity.EntityDeathEvent;
+import org.bukkit.event.entity.EntityRegainHealthEvent;
+import org.bukkit.event.player.PlayerInteractEvent;
+import org.bukkit.inventory.EquipmentSlot;
+import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.io.TempDir;
+
+class MendingLightNativeTest {
+    @TempDir Path data;
+
+    @BeforeAll static void bootstrap() throws Exception { NativeRuntime.bootstrap(); }
+
+    @Test void bookAcquisitionAimedPartyHealPersistsCapsAndKeepsCooldownAcrossReloadAndRelearn() throws Exception {
+        try (var fixture = new FantasyStickLifecycleNativeTest.Fixture(data)) {
+            fixture.plugin.setEnabled(true);
+            var caster = new FantasyStickLifecycleNativeTest.Actor(data);
+            var ally = new FantasyStickLifecycleNativeTest.Actor(data);
+            prepareCaster(data, caster, false);
+            setHealth(data, ally, BigDecimal.valueOf(4));
+            fixture.players.put(caster.core.id, caster.player);
+            fixture.players.put(ally.core.id, ally.player);
+            fixture.activate(caster); fixture.activate(ally); party(fixture, caster, ally); aim(caster, ally, 8, true);
+
+            caster.core.inventory.getInventory().setSelectedSlot(0); PartyBookNativeTest.open(fixture, caster);
+            String text = PartyBookNativeTest.text(caster).replaceAll("\\s+", "");
+            assertTrue(text.contains("MendingLight")); assertTrue(text.contains("WIS12"));
+            assertTrue(text.contains("CHR10")); assertTrue(text.contains("Cost:1"));
+            assertTrue(text.contains("12")); assertTrue(text.contains("8"));
+            PartyBookNativeTest.click(fixture, caster, button(caster, "[Learn]", "mending_light"));
+            drain(fixture, 2);
+            PartyBookNativeTest.click(fixture, caster, button(caster, "[3]", "mending_light"));
+            drain(fixture, 2);
+
+            use(fixture, caster); drain(fixture, 3);
+            var storage = storage(fixture);
+            var healed = storage.find(ally.core.record.id()).get().orElseThrow();
+            assertEquals(0, BigDecimal.TEN.compareTo(healed.health()), "6 + WIS modifier caps at ally maximum");
+            assertEquals(10, ally.player.getHealth());
+            var deadline = storage.find(caster.core.record.id()).get().orElseThrow().cooldowns().get("mending_light");
+            assertNotNull(deadline);
+
+            caster.core.inventory.getInventory().setSelectedSlot(0); PartyBookNativeTest.open(fixture, caster);
+            var unlearn = button(caster, "[Unlearn]", "mending_light");
+            PartyBookNativeTest.click(fixture, caster, unlearn); PartyBookNativeTest.click(fixture, caster, unlearn);
+            drain(fixture, 2);
+            assertEquals(deadline, storage.find(caster.core.record.id()).get().orElseThrow().cooldowns().get("mending_light"));
+            learnAndAssign(fixture, caster); use(fixture, caster);
+            assertTrue(caster.messages.stream().anyMatch(message -> message.contains("ready in")));
+
+            var allySheet = ally.core.inventory.getItemInOffHand().clone();
+            ally.core.inventory.setItemInOffHand(null); fixture.changed(ally); drain(fixture, 1); fixture.awaitCharacterAndReceipt(ally);
+            var resumed = new FantasyStickLifecycleNativeTest.Actor(data);
+            resumed.core.inventory.setItemInOffHand(allySheet); fixture.players.put(resumed.core.id, resumed.player); fixture.activate(resumed);
+            assertEquals(10, resumed.player.getHealth(), "Healed health survives exit, transfer and resume");
+        }
+    }
+
+    @Test void actualHealingCreatesOnePersistedSupportShareForAnAllyDirectContributor() throws Exception {
+        try (var fixture = new FantasyStickLifecycleNativeTest.Fixture(data)) {
+            fixture.plugin.setEnabled(true);
+            var caster = new FantasyStickLifecycleNativeTest.Actor(data);
+            var ally = new FantasyStickLifecycleNativeTest.Actor(data);
+            prepareCaster(data, caster, true); setHealth(data, ally, BigDecimal.valueOf(4));
+            fixture.players.put(caster.core.id, caster.player); fixture.players.put(ally.core.id, ally.player);
+            fixture.activate(caster); fixture.activate(ally); party(fixture, caster, ally); aim(caster, ally, 8, true);
+            use(fixture, caster); drain(fixture, 3);
+            var sourceSheet = caster.core.inventory.getItemInOffHand().clone();
+            caster.core.inventory.setItemInOffHand(null); fixture.changed(caster); drain(fixture, 1); fixture.awaitCharacterAndReceipt(caster);
+            var currentHolder = new FantasyStickLifecycleNativeTest.Actor(data);
+            currentHolder.core.inventory.setItemInOffHand(sourceSheet);
+            fixture.players.put(currentHolder.core.id, currentHolder.player); fixture.activate(currentHolder);
+
+            var enemy = mock(LivingEntity.class);
+            when(enemy.getUniqueId()).thenReturn(UUID.randomUUID());
+            when(enemy.getType()).thenReturn(org.bukkit.entity.EntityType.ZOMBIE);
+            when(caster.world.getUID()).thenReturn(UUID.randomUUID());
+            when(enemy.getLocation()).thenReturn(new Location(caster.world, 8, 64, 0));
+            var source = org.bukkit.damage.DamageSource.builder(org.bukkit.damage.DamageType.PLAYER_ATTACK)
+                .withCausingEntity(ally.player).withDirectEntity(ally.player).build();
+            fixture.dispatcher.accept(new EntityDamageByEntityEvent(ally.player, enemy,
+                org.bukkit.event.entity.EntityDamageEvent.DamageCause.ENTITY_ATTACK, source, 3));
+            fixture.dispatcher.accept(new EntityDeathEvent(enemy, source, new ArrayList<>(), 0));
+            drain(fixture, 4);
+
+            assertEquals(BigInteger.valueOf(5), storage(fixture).find(caster.core.record.id()).get().orElseThrow().experience());
+            assertEquals(BigInteger.valueOf(5), storage(fixture).find(ally.core.record.id()).get().orElseThrow().experience());
+            assertTrue(currentHolder.messages.stream().anyMatch(message -> message.contains("5") && message.contains("XP")),
+                "Effective healing follows the living source character through transfer");
+        }
+    }
+
+    @Test void selfOrdinaryNonPartyFullHealthRangeAndLineOfSightRefuseBeforeCooldown() throws Exception {
+        for (int route = 0; route < 6; route++) {
+            var directory = data.resolve("refusal-" + route);
+            try (var fixture = new FantasyStickLifecycleNativeTest.Fixture(directory)) {
+                fixture.plugin.setEnabled(true);
+                var caster = new FantasyStickLifecycleNativeTest.Actor(directory); prepareCaster(directory, caster, true);
+                fixture.players.put(caster.core.id, caster.player); fixture.activate(caster);
+                Player target;
+                if (route == 0) target = caster.player;
+                else if (route == 1) { target = mock(Player.class); when(target.getUniqueId()).thenReturn(UUID.randomUUID()); }
+                else {
+                    var ally = new FantasyStickLifecycleNativeTest.Actor(directory);
+                    setHealth(directory, ally, route == 3 ? BigDecimal.TEN : BigDecimal.valueOf(4));
+                    fixture.players.put(ally.core.id, ally.player); fixture.activate(ally); target = ally.player;
+                    if (route != 2) party(fixture, caster, ally);
+                }
+                aim(caster, target, route == 4 ? 13 : 8, route != 5);
+                use(fixture, caster); drain(fixture, 2);
+                assertFalse(storage(fixture).find(caster.core.record.id()).get().orElseThrow()
+                    .cooldowns().containsKey("mending_light"), "route " + route + " must refuse before cooldown");
+            }
+        }
+    }
+
+    @Test void cancelledHealingConsumesCooldownButAppliesNoHealthOrSupport() throws Exception {
+        try (var fixture = new FantasyStickLifecycleNativeTest.Fixture(data)) {
+            fixture.plugin.setEnabled(true);
+            var caster = new FantasyStickLifecycleNativeTest.Actor(data);
+            var ally = new FantasyStickLifecycleNativeTest.Actor(data);
+            prepareCaster(data, caster, true); setHealth(data, ally, BigDecimal.valueOf(4));
+            fixture.players.put(caster.core.id, caster.player); fixture.players.put(ally.core.id, ally.player);
+            fixture.activate(caster); fixture.activate(ally); party(fixture, caster, ally); aim(caster, ally, 8, true);
+            class Veto implements org.bukkit.event.Listener {
+                @org.bukkit.event.EventHandler public void heal(EntityRegainHealthEvent event) {
+                    if (event.getEntity() == ally.player) event.setCancelled(true);
+                }
+            }
+            fixture.dispatcher.register(new Veto(), fixture.plugin);
+            use(fixture, caster); drain(fixture, 3);
+            assertEquals(4, ally.player.getHealth());
+            assertNotNull(storage(fixture).find(caster.core.record.id()).get().orElseThrow().cooldowns().get("mending_light"));
+        }
+    }
+
+    @Test void targetSaveFailureOrSessionReplacementPublishesNoNativeHealingOrSupport() {
+        var characters = mock(CharacterStorage.class); var sessions = mock(EquipmentSessions.class);
+        var parties = mock(PartyRoster.class); var source = mock(Player.class); var target = mock(Player.class);
+        var attribute = mock(AttributeInstance.class); when(target.getAttribute(Attribute.MAX_HEALTH)).thenReturn(attribute);
+        when(attribute.getValue()).thenReturn(10.0); when(target.getHealth()).thenReturn(4.0);
+        when(source.getUniqueId()).thenReturn(UUID.randomUUID()); when(target.getUniqueId()).thenReturn(UUID.randomUUID());
+        var world = mock(org.bukkit.World.class);
+        when(source.getLocation()).thenReturn(new Location(world, 0, 64, 0));
+        when(target.getLocation()).thenReturn(new Location(world, 8, 64, 0));
+        when(source.hasLineOfSight(target)).thenReturn(true);
+        var casterRecord = recordWith(UUID.randomUUID(), "mending_light", BigDecimal.TEN);
+        var targetRecord = recordWith(UUID.randomUUID(), null, BigDecimal.valueOf(4));
+        var casterActive = new EquipmentSessions.Active(source.getUniqueId(), UUID.randomUUID(), casterRecord.id());
+        var targetActive = new EquipmentSessions.Active(target.getUniqueId(), UUID.randomUUID(), targetRecord.id());
+        when(sessions.active(target.getUniqueId())).thenReturn(java.util.Optional.of(targetActive));
+        when(sessions.current(targetActive)).thenReturn(true); when(sessions.currentRecord(targetActive)).thenReturn(java.util.Optional.of(targetRecord));
+        var party = new PartyRoster.Party(UUID.randomUUID(), source.getUniqueId(), List.of(source.getUniqueId(), target.getUniqueId()));
+        when(parties.partyOf(source.getUniqueId())).thenReturn(java.util.Optional.of(party));
+        when(parties.partyOf(target.getUniqueId())).thenReturn(java.util.Optional.of(party));
+        var input = mock(ControlInput.class); when(input.player()).thenReturn(source); when(input.target()).thenReturn(target); when(input.session()).thenReturn(casterActive);
+        var execution = mock(AbilityExecution.class); when(execution.stillCurrent()).thenReturn(true);
+        when(execution.input()).thenReturn(input); when(execution.character()).thenReturn(casterRecord);
+        var supports = new ArrayList<MendingLight.Support>();
+        var effect = new MendingLight(MendingLight.Settings.defaults(), characters, sessions, parties, Runnable::run,
+            ignored -> {}, () -> BigDecimal.valueOf(1024), supports::add);
+        when(execution.definition()).thenReturn(effect.definition());
+        var failed = new CompletableFuture<java.util.Optional<CharacterRecord>>();
+        when(characters.saveHealth(eq(targetRecord.id()), eq(targetRecord.revision()), any(), any())).thenReturn(failed);
+        effect.activate(execution); failed.completeExceptionally(new java.io.IOException("simulated"));
+        verify(target, never()).setHealth(anyDouble()); assertTrue(supports.isEmpty()); verify(execution).finish();
+
+        var acknowledged = new CharacterRecord(targetRecord.id(), targetRecord.name(), targetRecord.revision().add(BigInteger.ONE),
+            targetRecord.stats(), targetRecord.level(), targetRecord.experience(), targetRecord.unspentPoints(), BigDecimal.TEN,
+            targetRecord.learned(), targetRecord.loadout(), targetRecord.cooldowns(), targetRecord.restrictedKills(), false, null, null);
+        var delayed = new CompletableFuture<java.util.Optional<CharacterRecord>>();
+        when(characters.saveHealth(eq(targetRecord.id()), eq(targetRecord.revision()), any(), any())).thenReturn(delayed);
+        when(sessions.current(targetActive)).thenReturn(true);
+        effect.activate(execution);
+        when(sessions.current(targetActive)).thenReturn(false);
+        delayed.complete(java.util.Optional.of(acknowledged));
+        verify(target, never()).setHealth(anyDouble()); assertTrue(supports.isEmpty());
+        verify(sessions, never()).acknowledgeProgress(eq(targetActive), any(), any());
+        verify(execution, times(2)).finish();
+    }
+
+    @Test void configuredDefinitionAdminRestartAndFutureCastCoverEverySetting() throws Exception {
+        java.nio.file.Files.writeString(data.resolve("config.yml"),
+            "mending-light-base-healing: 8\nmending-light-cooldown-seconds: 0\nmending-light-range-blocks: 16\n");
+        try (var fixture = new FantasyStickLifecycleNativeTest.Fixture(data)) {
+            fixture.plugin.setEnabled(true);
+            var registry = (games.dmg.fantasystick.ability.AbilityRegistry)
+                FantasyStickLifecycleNativeTest.Fixture.field(fixture.plugin, "abilityRegistry");
+            var definition = registry.find("mending_light").orElseThrow();
+            assertEquals(java.time.Duration.ZERO, definition.cooldown());
+            assertEquals(new BigDecimal("8"), definition.parameters().get("base-healing"));
+            assertEquals(0, new BigDecimal("16").compareTo(definition.parameters().get("range")));
+            var sender = new EquipmentAdminCommandNativeTest.Sender(); sender.allowed = false;
+            assertTrue(fixture.command.tabComplete(sender.port, "fantasystick", new String[]{"config", "mending-light-"}).isEmpty());
+            fixture.command.execute(sender.port, "fantasystick", new String[]{"config", "mending-light-base-healing", "9"});
+            assertTrue(sender.messages.getLast().contains("Permission denied")); sender.allowed = true;
+            assertEquals(List.of("mending-light-base-healing", "mending-light-cooldown-seconds", "mending-light-range-blocks"),
+                fixture.command.tabComplete(sender.port, "fantasystick", new String[]{"config", "mending-light-"}));
+            assertEquals(List.of("6", "8"), fixture.command.tabComplete(sender.port, "fantasystick",
+                new String[]{"config", "mending-light-base-healing", ""}));
+            fixture.command.execute(sender.port, "fantasystick", new String[]{"config", "mending-light-base-healing"});
+            assertTrue(sender.messages.getLast().contains("=8"));
+            fixture.command.execute(sender.port, "fantasystick", new String[]{"config", "mending-light-base-healing", "9"});
+            var response = fixture.tasks.poll(5, TimeUnit.SECONDS); assertNotNull(response); response.run();
+            assertEquals(new BigDecimal("9"), registry.find("mending_light").orElseThrow().parameters().get("base-healing"));
+
+            var caster = new FantasyStickLifecycleNativeTest.Actor(data); var ally = new FantasyStickLifecycleNativeTest.Actor(data);
+            prepareCaster(data, caster, true); setHealth(data, ally, BigDecimal.valueOf(1));
+            fixture.players.put(caster.core.id, caster.player); fixture.players.put(ally.core.id, ally.player);
+            fixture.activate(caster); fixture.activate(ally); party(fixture, caster, ally); aim(caster, ally, 15, true);
+            use(fixture, caster); drain(fixture, 3); assertEquals(10, ally.player.getHealth());
+            fixture.command.execute(sender.port, "fantasystick", new String[]{"config", "mending-light-base-healing", "-1"});
+            assertTrue(sender.messages.getLast().contains("invalid"));
+            fixture.command.execute(sender.port, "fantasystick", new String[]{"config", "mending-light-base-healing", "9", "extra"});
+            assertTrue(sender.messages.getLast().contains("Usage"));
+            fixture.plugin.setEnabled(false); fixture.plugin.setEnabled(true);
+            var reloaded = (games.dmg.fantasystick.ability.AbilityRegistry)
+                FantasyStickLifecycleNativeTest.Fixture.field(fixture.plugin, "abilityRegistry");
+            assertEquals(new BigDecimal("9"), reloaded.find("mending_light").orElseThrow().parameters().get("base-healing"));
+        }
+        for (String invalid : List.of("mending-light-base-healing: -1\n", "mending-light-cooldown-seconds: -1\n",
+                "mending-light-range-blocks: 0\n")) {
+            var directory = data.resolve(Integer.toHexString(invalid.hashCode())); java.nio.file.Files.createDirectories(directory);
+            java.nio.file.Files.writeString(directory.resolve("config.yml"), invalid);
+            try (var fixture = new FantasyStickLifecycleNativeTest.Fixture(directory)) {
+                assertThrows(IllegalArgumentException.class, () -> fixture.plugin.setEnabled(true)); assertTrue(fixture.order.isEmpty());
+            }
+        }
+    }
+
+    @Test void exactFormulaSupportsUncappedWisdomAndFloorDivision() {
+        assertEquals(BigInteger.valueOf(7), MendingLight.healing(BigInteger.valueOf(12)));
+        assertEquals(BigInteger.valueOf(5), MendingLight.healing(BigInteger.valueOf(9)));
+        var huge = BigInteger.TEN.pow(500);
+        assertEquals(huge.subtract(BigInteger.TEN).divide(BigInteger.TWO).add(BigInteger.valueOf(6)), MendingLight.healing(huge));
+    }
+
+    private static void learnAndAssign(FantasyStickLifecycleNativeTest.Fixture fixture,
+                                       FantasyStickLifecycleNativeTest.Actor actor) throws Exception {
+        actor.core.inventory.getInventory().setSelectedSlot(0); PartyBookNativeTest.open(fixture, actor);
+        PartyBookNativeTest.click(fixture, actor, button(actor, "[Learn]", "mending_light")); drain(fixture, 2);
+        PartyBookNativeTest.click(fixture, actor, button(actor, "[3]", "mending_light")); drain(fixture, 2);
+    }
+
+    private static PartyRoster.Party party(FantasyStickLifecycleNativeTest.Fixture fixture,
+                                           FantasyStickLifecycleNativeTest.Actor caster,
+                                           FantasyStickLifecycleNativeTest.Actor ally) {
+        var parties = PartyLifecycleNativeTest.parties(fixture); var group = parties.create(caster.core.id).orElseThrow();
+        assertTrue(parties.accept(ally.core.id, parties.invite(caster.core.id, group.id(), ally.core.id).orElseThrow().id()));
+        return parties.partyOf(caster.core.id).orElseThrow();
+    }
+
+    private static void aim(FantasyStickLifecycleNativeTest.Actor caster,
+                            FantasyStickLifecycleNativeTest.Actor target, double distance, boolean visible) {
+        aim(caster, target.player, distance, visible);
+    }
+
+    private static void aim(FantasyStickLifecycleNativeTest.Actor caster, Player target, double distance, boolean visible) {
+        doReturn(new Location(caster.world, 0, 64, 0)).when(caster.player).getLocation();
+        doReturn(new Location(caster.world, distance, 64, 0)).when(target).getLocation();
+        doReturn(visible).when(caster.player).hasLineOfSight(target);
+        doReturn(target).when(caster.player).getTargetEntity(64);
+    }
+
+    private static void use(FantasyStickLifecycleNativeTest.Fixture fixture,
+                            FantasyStickLifecycleNativeTest.Actor actor) {
+        actor.core.inventory.getInventory().setSelectedSlot(2);
+        fixture.dispatcher.accept(new PlayerInteractEvent(actor.player, org.bukkit.event.block.Action.RIGHT_CLICK_AIR,
+            actor.core.inventory.getItem(2), null, org.bukkit.block.BlockFace.SELF, EquipmentSlot.HAND));
+    }
+
+    private static void drain(FantasyStickLifecycleNativeTest.Fixture fixture, int count) throws Exception {
+        for (int index = 0; index < count; index++) PartyBookNativeTest.drain(fixture);
+    }
+
+    private static CharacterStorage storage(FantasyStickLifecycleNativeTest.Fixture fixture) {
+        return (CharacterStorage) FantasyStickLifecycleNativeTest.Fixture.field(fixture.plugin, "characters");
+    }
+
+    private static ClickEvent.Custom button(FantasyStickLifecycleNativeTest.Actor actor, String label, String ability) {
+        var book = org.bukkit.craftbukkit.inventory.CraftItemStack.asNMSCopy(actor.books.getLast())
+            .get(net.minecraft.core.component.DataComponents.WRITTEN_BOOK_CONTENT);
+        assertNotNull(book);
+        for (var page : book.pages()) { var found = button(page.raw(), label, ability); if (found != null) return found; }
+        throw new AssertionError("Missing " + label + " for " + ability);
+    }
+
+    private static ClickEvent.Custom button(net.minecraft.network.chat.Component component, String label, String ability) {
+        if (component.getString().equals(label) && component.getStyle().getClickEvent() instanceof ClickEvent.Custom custom
+                && custom.payload().orElse(null) instanceof net.minecraft.nbt.StringTag payload
+                && payload.value().contains(":" + ability)) return custom;
+        for (var child : component.getSiblings()) { var found = button(child, label, ability); if (found != null) return found; }
+        return null;
+    }
+
+    private static void prepareCaster(Path directory, FantasyStickLifecycleNativeTest.Actor actor, boolean learned) throws Exception {
+        java.nio.file.Files.createDirectories(directory); var repository = new YamlCharacterRepository(directory);
+        var old = repository.load(actor.core.record.id()).orElseThrow(); var stats = new EnumMap<>(old.stats());
+        stats.put(Stat.WIS, BigInteger.valueOf(12)); stats.put(Stat.CHR, BigInteger.TEN);
+        repository.replace(new CharacterRecord(old.id(), old.name(), old.revision().add(BigInteger.ONE), stats,
+            old.level(), old.experience(), BigInteger.valueOf(learned ? 39 : 40), old.health(),
+            learned ? Set.of("mending_light") : old.learned(),
+            learned ? List.of("mending_light", "", "", "", "", "", "") : old.loadout(),
+            old.cooldowns(), old.restrictedKills(), false, null, null), old.revision());
+    }
+
+    private static void setHealth(Path directory, FantasyStickLifecycleNativeTest.Actor actor, BigDecimal health) throws Exception {
+        java.nio.file.Files.createDirectories(directory); var repository = new YamlCharacterRepository(directory);
+        var old = repository.load(actor.core.record.id()).orElseThrow();
+        repository.replace(new CharacterRecord(old.id(), old.name(), old.revision().add(BigInteger.ONE), old.stats(),
+            old.level(), old.experience(), old.unspentPoints(), health, old.learned(), old.loadout(), old.cooldowns(),
+            old.restrictedKills(), false, null, null), old.revision());
+    }
+
+    private static CharacterRecord recordWith(UUID id, String ability, BigDecimal health) {
+        var base = new games.dmg.fantasystick.crafting.CharacterFactory().create(
+            games.dmg.fantasystick.progression.ProgressionRules.defaults());
+        var stats = new EnumMap<>(base.stats()); stats.put(Stat.WIS, BigInteger.valueOf(12)); stats.put(Stat.CHR, BigInteger.TEN);
+        return new CharacterRecord(id, base.name(), base.revision(), stats, base.level(), base.experience(), base.unspentPoints(),
+            health, ability == null ? Set.of() : Set.of(ability), ability == null ? base.loadout() : List.of(ability, "", "", "", "", "", ""),
+            base.cooldowns(), base.restrictedKills(), false, null, null);
+    }
+}

src/nativeTest/java/games/dmg/fantasystick/OutgoingDamageBonusNativeTest.java

@@ -0,0 +1,85 @@
+package games.dmg.fantasystick;
+
+import static org.junit.jupiter.api.Assertions.*;
+import static org.mockito.Mockito.*;
+
+import games.dmg.fantasystick.ability.AbilityExecution;
+import games.dmg.fantasystick.ability.AbilityReport;
+import games.dmg.fantasystick.ability.OutgoingDamageBonus;
+import games.dmg.fantasystick.party.PartyRoster;
+import games.dmg.fantasystick.session.ControlInput;
+import games.dmg.fantasystick.session.EquipmentSessions;
+import java.math.BigDecimal;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.UUID;
+import org.bukkit.entity.LivingEntity;
+import org.bukkit.entity.Player;
+import org.bukkit.event.entity.EntityDamageByEntityEvent;
+import org.bukkit.event.entity.EntityDamageEvent;
+import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.api.Test;
+
+class OutgoingDamageBonusNativeTest {
+    @BeforeAll static void bootstrap() throws Exception { NativeRuntime.bootstrap(); }
+
+    @Test void strongestDeterministicGrantAppliesOnceAndReportsOnlyAcceptedAllyUse() throws Exception {
+        var sessions = mock(EquipmentSessions.class); var parties = mock(PartyRoster.class);
+        var recipient = mock(Player.class); var enemy = mock(LivingEntity.class);
+        var recipientId = UUID.randomUUID(); when(recipient.getUniqueId()).thenReturn(recipientId);
+        when(enemy.getUniqueId()).thenReturn(UUID.randomUUID());
+        var aided = new EquipmentSessions.Active(recipientId, UUID.randomUUID(), UUID.randomUUID());
+        when(sessions.active(recipientId)).thenReturn(java.util.Optional.of(aided)); when(sessions.current(aided)).thenReturn(true);
+        var sourcePlayer = mock(Player.class); when(sourcePlayer.getUniqueId()).thenReturn(UUID.randomUUID());
+        var party = new PartyRoster.Party(UUID.randomUUID(), sourcePlayer.getUniqueId(), List.of(sourcePlayer.getUniqueId(), recipientId));
+        when(parties.partyOf(sourcePlayer.getUniqueId())).thenReturn(java.util.Optional.of(party));
+        when(parties.partyOf(recipientId)).thenReturn(java.util.Optional.of(party));
+        var supports = new ArrayList<OutgoingDamageBonus.Support>();
+        var bonuses = new OutgoingDamageBonus(sessions, parties, supports::add);
+        var first = execution(sourcePlayer, UUID.randomUUID()); var strongest = execution(sourcePlayer, UUID.randomUUID());
+        var tiedLater = execution(sourcePlayer, UUID.randomUUID());
+        var firstGrant = bonuses.grant(first, recipient, new BigDecimal("20"), () -> true);
+        var strongestGrant = bonuses.grant(strongest, recipient, new BigDecimal("25"), () -> true);
+        var tiedGrant = bonuses.grant(tiedLater, recipient, new BigDecimal("25"), () -> true);
+
+        var hit = hit(recipient, enemy, 10); bonuses.increase(hit); assertEquals(12.5, hit.getDamage(), 1.0e-9);
+        bonuses.accepted(hit);
+        assertEquals(1, supports.size()); assertEquals(0, new BigDecimal("2.50").compareTo(supports.getFirst().amount()));
+        assertEquals(strongest.input().session().character(), supports.getFirst().supportingCharacter());
+        verify(strongest).report(eq(AbilityReport.Type.BOOST_USED), eq(enemy),
+            argThat(amount -> amount.compareTo(new BigDecimal("2.50")) == 0));
+        verify(first, never()).report(any(), any(), any()); verify(tiedLater, never()).report(any(), any(), any());
+
+        var cancelled = hit(recipient, enemy, 10); bonuses.increase(cancelled); cancelled.setCancelled(true); bonuses.accepted(cancelled);
+        assertEquals(1, supports.size());
+        firstGrant.close(); strongestGrant.close(); tiedGrant.close(); bonuses.close();
+    }
+
+    @Test void invalidOrSelfUseAndMarkedGuardianRedirectionCreateNoSupportOrRepeatedBonus() throws Exception {
+        var sessions = mock(EquipmentSessions.class); var parties = mock(PartyRoster.class);
+        var player = mock(Player.class); var enemy = mock(LivingEntity.class); var id = UUID.randomUUID();
+        when(player.getUniqueId()).thenReturn(id); when(enemy.getUniqueId()).thenReturn(UUID.randomUUID());
+        var active = new EquipmentSessions.Active(id, UUID.randomUUID(), UUID.randomUUID());
+        when(sessions.active(id)).thenReturn(java.util.Optional.of(active)); when(sessions.current(active)).thenReturn(true);
+        var supports = new ArrayList<OutgoingDamageBonus.Support>(); var bonuses = new OutgoingDamageBonus(sessions, parties, supports::add);
+        var valid = new java.util.concurrent.atomic.AtomicBoolean(true);
+        var self = execution(player, active.character()); bonuses.grant(self, player, new BigDecimal("20"), valid::get);
+        var hit = hit(player, enemy, 10); bonuses.increase(hit); bonuses.accepted(hit);
+        assertEquals(12, hit.getDamage(), 1.0e-9); assertTrue(supports.isEmpty());
+        when(sessions.current(active)).thenReturn(false); valid.set(false);
+        var stale = hit(player, enemy, 10); bonuses.increase(stale); assertEquals(10, stale.getDamage(), 1.0e-9);
+        bonuses.close();
+    }
+
+    private static AbilityExecution execution(Player source, UUID character) {
+        var execution = mock(AbilityExecution.class); var input = mock(ControlInput.class);
+        var active = new EquipmentSessions.Active(source.getUniqueId(), UUID.randomUUID(), character);
+        when(input.player()).thenReturn(source); when(input.session()).thenReturn(active);
+        when(execution.input()).thenReturn(input); when(execution.stillCurrent()).thenReturn(true); return execution;
+    }
+    private static EntityDamageByEntityEvent hit(Player attacker, LivingEntity target, double amount) {
+        var source = org.bukkit.damage.DamageSource.builder(org.bukkit.damage.DamageType.PLAYER_ATTACK)
+            .withCausingEntity(attacker).withDirectEntity(attacker).build();
+        return new EntityDamageByEntityEvent(attacker, target, EntityDamageEvent.DamageCause.ENTITY_ATTACK, source, amount);
+    }
+}

src/nativeTest/java/games/dmg/fantasystick/PartyCapacityNativeTest.java

@@ -0,0 +1,7 @@
+package games.dmg.fantasystick;
+import static org.junit.jupiter.api.Assertions.*;import java.nio.file.Path;import org.junit.jupiter.api.BeforeAll;import org.junit.jupiter.api.Test;import org.junit.jupiter.api.io.TempDir;
+class PartyCapacityNativeTest{@TempDir Path data;@BeforeAll static void bootstrap()throws Exception{NativeRuntime.bootstrap();}
+ @Test void registeredPolicyDrivesActualBookInvitationsAcceptanceGrandfatheringAndRestart()throws Exception{try(var f=new FantasyStickLifecycleNativeTest.Fixture(data)){f.plugin.setEnabled(true);var sender=new EquipmentAdminCommandNativeTest.Sender();assertEquals(java.util.List.of("party-max-size"),f.command.tabComplete(sender.port,"fantasystick",new String[]{"config","party-m"}));assertEquals(java.util.List.of("6"),f.command.tabComplete(sender.port,"fantasystick",new String[]{"config","party-max-size",""}));f.command.execute(sender.port,"fantasystick",new String[]{"config","party-max-size"});assertTrue(sender.messages.getLast().contains("=6"));for(String bad:java.util.List.of("0","-1","1.5","bad","2147483648")){f.command.execute(sender.port,"fantasystick",new String[]{"config","party-max-size",bad});assertTrue(sender.messages.getLast().contains("invalid"));}sender.allowed=false;assertTrue(f.command.tabComplete(sender.port,"fantasystick",new String[]{"config","party"}).isEmpty());f.command.execute(sender.port,"fantasystick",new String[]{"config","party-max-size","2"});assertTrue(sender.messages.getLast().contains("Permission denied"));sender.allowed=true;f.command.execute(sender.port,"fantasystick",new String[]{"config","party-max-size","2","extra"});assertTrue(sender.messages.getLast().contains("Usage"));save(f,sender,"2");var leader=new FantasyStickLifecycleNativeTest.Actor(data);var member=new FantasyStickLifecycleNativeTest.Actor(data);f.players.put(leader.core.id,leader.player);f.players.put(member.core.id,member.player);f.activate(leader);f.activate(member);PartyBookNativeTest.open(f,leader);PartyBookNativeTest.click(f,leader,PartyBookNativeTest.button(leader,"[Create party]"));PartyBookNativeTest.drain(f);PartyBookNativeTest.click(f,leader,PartyBookNativeTest.button(leader,"[Invite players]"));PartyBookNativeTest.click(f,leader,PartyBookNativeTest.button(leader,"[Invite]"));PartyBookNativeTest.open(f,member);PartyBookNativeTest.click(f,member,PartyBookNativeTest.button(member,"[Invitations]"));PartyBookNativeTest.click(f,member,PartyBookNativeTest.button(member,"[Accept]"));PartyBookNativeTest.drain(f);var parties=PartyLifecycleNativeTest.parties(f);assertEquals(2,parties.partyOf(leader.core.id).orElseThrow().members().size());assertTrue(PartyBookNativeTest.text(member).contains("2/2 members"));PartyBookNativeTest.open(f,leader);assertFalse(PartyBookNativeTest.text(leader).contains("[Invite players]"));save(f,sender,"3");var third=new FantasyStickLifecycleNativeTest.Actor(data);f.players.put(third.core.id,third.player);f.activate(third);PartyBookNativeTest.open(f,leader);assertTrue(PartyBookNativeTest.text(leader).contains("2/3 members"));PartyBookNativeTest.click(f,leader,PartyBookNativeTest.button(leader,"[Invite players]"));PartyBookNativeTest.click(f,leader,PartyBookNativeTest.button(leader,"[Invite]"));assertEquals(1,parties.invitationsFor(third.core.id).size());save(f,sender,"2");PartyBookNativeTest.open(f,third);PartyBookNativeTest.click(f,third,PartyBookNativeTest.button(third,"[Invitations]"));PartyBookNativeTest.click(f,third,PartyBookNativeTest.button(third,"[Accept]"));PartyBookNativeTest.drain(f);assertTrue(parties.partyOf(third.core.id).isEmpty());assertEquals(2,parties.partyOf(leader.core.id).orElseThrow().members().size());save(f,sender,"3");PartyBookNativeTest.open(f,third);PartyBookNativeTest.click(f,third,PartyBookNativeTest.button(third,"[Invitations]"));PartyBookNativeTest.click(f,third,PartyBookNativeTest.button(third,"[Accept]"));PartyBookNativeTest.drain(f);assertEquals(3,parties.partyOf(leader.core.id).orElseThrow().members().size());save(f,sender,"2");assertEquals(3,parties.partyOf(leader.core.id).orElseThrow().members().size());assertTrue(PartyCombatNativeTest.hit(f,leader.player,member.player).isCancelled());PartyBookNativeTest.open(f,leader);assertTrue(PartyBookNativeTest.text(leader).contains("3/2 members"));assertFalse(PartyBookNativeTest.text(leader).contains("[Invite players]"));f.plugin.setEnabled(false);f.plugin.setEnabled(true);f.command.execute(sender.port,"fantasystick",new String[]{"config","party-max-size"});assertTrue(sender.messages.getLast().contains("=2"));assertTrue(PartyLifecycleNativeTest.parties(f).partyOf(leader.core.id).isEmpty());}}
+ @Test void failedRegisteredSaveLeavesCurrentRosterAndLimitUnchanged()throws Exception{try(var f=new FantasyStickLifecycleNativeTest.Fixture(data)){f.plugin.setEnabled(true);var sender=new EquipmentAdminCommandNativeTest.Sender();var leader=new FantasyStickLifecycleNativeTest.Actor(data);f.players.put(leader.core.id,leader.player);var party=PartyLifecycleNativeTest.parties(f).create(leader.core.id).orElseThrow();java.nio.file.Files.createDirectory(data.resolve("config.yml"));f.command.execute(sender.port,"fantasystick",new String[]{"config","party-max-size","2"});var callback=f.tasks.poll(5,java.util.concurrent.TimeUnit.SECONDS);assertNotNull(callback);callback.run();assertTrue(sender.messages.getLast().contains("save failed"));assertEquals(party,PartyLifecycleNativeTest.parties(f).partyOf(leader.core.id).orElseThrow());f.command.execute(sender.port,"fantasystick",new String[]{"config","party-max-size"});assertTrue(sender.messages.getLast().contains("=6"));}}
+ static void save(FantasyStickLifecycleNativeTest.Fixture f,EquipmentAdminCommandNativeTest.Sender sender,String value)throws Exception{int before=sender.messages.size();f.command.execute(sender.port,"fantasystick",new String[]{"config","party-max-size",value});assertEquals(before,sender.messages.size());while(sender.messages.size()==before){var task=f.tasks.poll(5,java.util.concurrent.TimeUnit.SECONDS);assertNotNull(task);task.run();}assertTrue(sender.messages.getLast().contains("="+value));}
+}

src/nativeTest/java/games/dmg/fantasystick/PurifyNativeTest.java

@@ -0,0 +1,306 @@
+package games.dmg.fantasystick;
+
+import static org.junit.jupiter.api.Assertions.*;
+import static org.mockito.Mockito.*;
+
+import games.dmg.fantasystick.persistence.CharacterRecord;
+import games.dmg.fantasystick.persistence.CharacterStorage;
+import games.dmg.fantasystick.persistence.YamlCharacterRepository;
+import games.dmg.fantasystick.progression.Stat;
+import java.math.BigDecimal;
+import java.math.BigInteger;
+import java.nio.file.Path;
+import java.util.ArrayList;
+import java.util.EnumMap;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.UUID;
+import java.util.concurrent.TimeUnit;
+import net.minecraft.network.chat.ClickEvent;
+import net.minecraft.world.effect.MobEffectInstance;
+import org.bukkit.Location;
+import org.bukkit.entity.LivingEntity;
+import org.bukkit.entity.Player;
+import org.bukkit.event.entity.EntityDamageByEntityEvent;
+import org.bukkit.event.entity.EntityDeathEvent;
+import org.bukkit.event.entity.EntityPotionEffectEvent;
+import org.bukkit.event.player.PlayerInteractEvent;
+import org.bukkit.inventory.EquipmentSlot;
+import org.bukkit.potion.PotionEffect;
+import org.bukkit.potion.PotionEffectType;
+import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.io.TempDir;
+
+class PurifyNativeTest {
+    private static List<PotionEffectType> harmful;
+    @TempDir Path data;
+
+    @BeforeAll static void bootstrap() throws Exception {
+        NativeRuntime.bootstrap();
+        harmful = List.of(PotionEffectType.POISON, PotionEffectType.WITHER,
+            PotionEffectType.SLOWNESS, PotionEffectType.WEAKNESS);
+    }
+
+    @Test void bookAcquisitionSneakUseRemovesEveryHarmfulLayerAndPreservesBeneficialEffectsAndCooldown() throws Exception {
+        try (var fixture = new FantasyStickLifecycleNativeTest.Fixture(data)) {
+            fixture.plugin.setEnabled(true);
+            var actor = new FantasyStickLifecycleNativeTest.Actor(data); prepare(data, actor, false);
+            fixture.players.put(actor.core.id, actor.player); fixture.activate(actor);
+            var effects = effects(fixture, actor.player);
+            harmful.forEach(type -> effects.put(type, layered(type)));
+            effects.put(PotionEffectType.REGENERATION, instance(PotionEffectType.REGENERATION, 200, 1));
+
+            actor.core.inventory.getInventory().setSelectedSlot(0); PartyBookNativeTest.open(fixture, actor);
+            String book = PartyBookNativeTest.text(actor).replaceAll("\\s+", "");
+            assertTrue(book.contains("Purify")); assertTrue(book.contains("WIS14")); assertTrue(book.contains("CHR10"));
+            assertTrue(book.contains("Cost:1")); assertTrue(book.contains("15")); assertTrue(book.contains("12"));
+            PartyBookNativeTest.click(fixture, actor, button(actor, "[Learn]", "purify")); drain(fixture, 2);
+            PartyBookNativeTest.click(fixture, actor, button(actor, "[3]", "purify")); drain(fixture, 2);
+            doReturn(true).when(actor.player).isSneaking(); use(fixture, actor); drain(fixture, 2);
+
+            harmful.forEach(type -> assertFalse(effects.containsKey(type), type + " and its hidden chain must be gone"));
+            assertTrue(effects.containsKey(PotionEffectType.REGENERATION));
+            var storage = storage(fixture); var saved = storage.find(actor.core.record.id()).get().orElseThrow();
+            var deadline = saved.cooldowns().get("purify"); assertNotNull(deadline);
+            actor.core.inventory.getInventory().setSelectedSlot(0); PartyBookNativeTest.open(fixture, actor);
+            var unlearn = button(actor, "[Unlearn]", "purify");
+            PartyBookNativeTest.click(fixture, actor, unlearn); PartyBookNativeTest.click(fixture, actor, unlearn); drain(fixture, 2);
+            assertEquals(deadline, storage.find(actor.core.record.id()).get().orElseThrow().cooldowns().get("purify"));
+            learnAndAssign(fixture, actor); use(fixture, actor);
+            assertTrue(actor.messages.stream().anyMatch(message -> message.contains("ready in")));
+        }
+    }
+
+    @Test void aimedAllyActualCleanseCreatesPersistedSupportShareThatFollowsSourceCharacter() throws Exception {
+        try (var fixture = new FantasyStickLifecycleNativeTest.Fixture(data)) {
+            fixture.plugin.setEnabled(true);
+            var caster = new FantasyStickLifecycleNativeTest.Actor(data); var ally = new FantasyStickLifecycleNativeTest.Actor(data);
+            prepare(data, caster, true); fixture.players.put(caster.core.id, caster.player); fixture.players.put(ally.core.id, ally.player);
+            fixture.activate(caster); fixture.activate(ally); party(fixture, caster, ally); aim(caster, ally.player, 8, true);
+            var effects = effects(fixture, ally.player); effects.put(PotionEffectType.POISON, layered(PotionEffectType.POISON));
+            doReturn(false).when(caster.player).isSneaking(); use(fixture, caster); drain(fixture, 2);
+            assertFalse(effects.containsKey(PotionEffectType.POISON));
+
+            var sheet = caster.core.inventory.getItemInOffHand().clone(); caster.core.inventory.setItemInOffHand(null);
+            fixture.changed(caster); drain(fixture, 1); fixture.awaitCharacterAndReceipt(caster);
+            var holder = new FantasyStickLifecycleNativeTest.Actor(data); holder.core.inventory.setItemInOffHand(sheet);
+            fixture.players.put(holder.core.id, holder.player); fixture.activate(holder);
+
+            var enemy = mock(LivingEntity.class); when(enemy.getUniqueId()).thenReturn(UUID.randomUUID());
+            when(enemy.getType()).thenReturn(org.bukkit.entity.EntityType.ZOMBIE);
+            when(caster.world.getUID()).thenReturn(UUID.randomUUID()); when(enemy.getLocation()).thenReturn(new Location(caster.world, 8, 64, 0));
+            var source = org.bukkit.damage.DamageSource.builder(org.bukkit.damage.DamageType.PLAYER_ATTACK)
+                .withCausingEntity(ally.player).withDirectEntity(ally.player).build();
+            fixture.dispatcher.accept(new EntityDamageByEntityEvent(ally.player, enemy,
+                org.bukkit.event.entity.EntityDamageEvent.DamageCause.ENTITY_ATTACK, source, 3));
+            fixture.dispatcher.accept(new EntityDeathEvent(enemy, source, new ArrayList<>(), 0)); drain(fixture, 4);
+            assertEquals(BigInteger.valueOf(5), storage(fixture).find(caster.core.record.id()).get().orElseThrow().experience());
+            assertEquals(BigInteger.valueOf(5), storage(fixture).find(ally.core.record.id()).get().orElseThrow().experience());
+            assertTrue(holder.messages.stream().anyMatch(message -> message.contains("5") && message.contains("XP")));
+        }
+    }
+
+    @Test void normalSelfOrdinaryNonPartyOutOfRangeObstructedAndNoOpTargetsRefuseBeforeCooldown() throws Exception {
+        for (int route = 0; route < 6; route++) {
+            var directory = data.resolve("refusal-" + route);
+            try (var fixture = new FantasyStickLifecycleNativeTest.Fixture(directory)) {
+                fixture.plugin.setEnabled(true);
+                var caster = new FantasyStickLifecycleNativeTest.Actor(directory); prepare(directory, caster, true);
+                fixture.players.put(caster.core.id, caster.player); fixture.activate(caster);
+                Player target;
+                if (route == 0) { target = caster.player; doReturn(false).when(caster.player).isSneaking(); }
+                else if (route == 1) { target = mock(Player.class); when(target.getUniqueId()).thenReturn(UUID.randomUUID()); }
+                else {
+                    var ally = new FantasyStickLifecycleNativeTest.Actor(directory); fixture.players.put(ally.core.id, ally.player);
+                    fixture.activate(ally); target = ally.player; effects(fixture, ally.player);
+                    if (route != 2) party(fixture, caster, ally);
+                }
+                if (route != 5 && route > 1) effectMap(target).put(PotionEffectType.WEAKNESS, instance(PotionEffectType.WEAKNESS, 200, 0));
+                aim(caster, target, route == 3 ? 13 : 8, route != 4); doReturn(false).when(caster.player).isSneaking();
+                use(fixture, caster); drain(fixture, 2);
+                assertFalse(storage(fixture).find(caster.core.record.id()).get().orElseThrow().cooldowns().containsKey("purify"),
+                    "route " + route + " must refuse before cooldown");
+            }
+        }
+    }
+
+    @Test void cancelledRemovalAndSelfCleanseCreateNoSupportWhileAcknowledgedCooldownRemains() throws Exception {
+        try (var fixture = new FantasyStickLifecycleNativeTest.Fixture(data)) {
+            fixture.plugin.setEnabled(true);
+            var caster = new FantasyStickLifecycleNativeTest.Actor(data); var ally = new FantasyStickLifecycleNativeTest.Actor(data);
+            prepare(data, caster, true); fixture.players.put(caster.core.id, caster.player); fixture.players.put(ally.core.id, ally.player);
+            fixture.activate(caster); fixture.activate(ally); party(fixture, caster, ally); aim(caster, ally.player, 8, true);
+            var effects = effects(fixture, ally.player); effects.put(PotionEffectType.POISON, layered(PotionEffectType.POISON));
+            class Veto implements org.bukkit.event.Listener {
+                @org.bukkit.event.EventHandler public void removal(EntityPotionEffectEvent event) {
+                    if (event.getEntity() == ally.player && event.getAction() == EntityPotionEffectEvent.Action.REMOVED) event.setCancelled(true);
+                }
+            }
+            fixture.dispatcher.register(new Veto(), fixture.plugin); doReturn(false).when(caster.player).isSneaking();
+            use(fixture, caster); drain(fixture, 2);
+            assertTrue(effects.containsKey(PotionEffectType.POISON));
+            assertNotNull(storage(fixture).find(caster.core.record.id()).get().orElseThrow().cooldowns().get("purify"));
+        }
+    }
+
+    @Test void selfCleanseNeverEmitsSupportEvidence() {
+        var sessions = mock(games.dmg.fantasystick.session.EquipmentSessions.class);
+        var parties = mock(games.dmg.fantasystick.party.PartyRoster.class); var player = mock(Player.class);
+        var active = new games.dmg.fantasystick.session.EquipmentSessions.Active(UUID.randomUUID(), UUID.randomUUID(), UUID.randomUUID());
+        when(player.getUniqueId()).thenReturn(active.player()); when(player.isSneaking()).thenReturn(true);
+        when(sessions.active(active.player())).thenReturn(java.util.Optional.of(active)); when(sessions.current(active)).thenReturn(true);
+        var poison = new java.util.concurrent.atomic.AtomicBoolean(true);
+        when(player.getPotionEffect(PotionEffectType.POISON)).thenAnswer(ignored -> poison.get()
+            ? new PotionEffect(PotionEffectType.POISON, 200, 0) : null);
+        doAnswer(ignored -> { poison.set(false); return null; }).when(player).removePotionEffect(PotionEffectType.POISON);
+        var input = mock(games.dmg.fantasystick.session.ControlInput.class);
+        when(input.player()).thenReturn(player); when(input.target()).thenReturn(player); when(input.session()).thenReturn(active);
+        var supports = new ArrayList<games.dmg.fantasystick.ability.Purify.Support>();
+        var purify = new games.dmg.fantasystick.ability.Purify(
+            games.dmg.fantasystick.ability.Purify.Settings.defaults(), sessions, parties, supports::add);
+        var execution = mock(games.dmg.fantasystick.ability.AbilityExecution.class);
+        when(execution.stillCurrent()).thenReturn(true); when(execution.input()).thenReturn(input);
+        when(execution.definition()).thenReturn(purify.definition());
+        purify.activate(execution);
+        assertFalse(poison.get()); assertTrue(supports.isEmpty()); verify(player).removePotionEffect(PotionEffectType.POISON);
+    }
+
+    @Test void configuredDefinitionAdminRestartAndFutureCastCoverEverySetting() throws Exception {
+        java.nio.file.Files.writeString(data.resolve("config.yml"), "purify-cooldown-seconds: 0\npurify-range-blocks: 16\n");
+        try (var fixture = new FantasyStickLifecycleNativeTest.Fixture(data)) {
+            fixture.plugin.setEnabled(true);
+            var registry = (games.dmg.fantasystick.ability.AbilityRegistry)
+                FantasyStickLifecycleNativeTest.Fixture.field(fixture.plugin, "abilityRegistry");
+            var definition = registry.find("purify").orElseThrow(); assertEquals(java.time.Duration.ZERO, definition.cooldown());
+            assertEquals(0, new BigDecimal("16").compareTo(definition.parameters().get("range")));
+            var sender = new EquipmentAdminCommandNativeTest.Sender(); sender.allowed = false;
+            assertTrue(fixture.command.tabComplete(sender.port, "fantasystick", new String[]{"config", "purify-"}).isEmpty());
+            fixture.command.execute(sender.port, "fantasystick", new String[]{"config", "purify-range-blocks", "20"});
+            assertTrue(sender.messages.getLast().contains("Permission denied")); sender.allowed = true;
+            assertEquals(List.of("purify-cooldown-seconds", "purify-range-blocks"),
+                fixture.command.tabComplete(sender.port, "fantasystick", new String[]{"config", "purify-"}));
+            assertEquals(List.of("12", "16"), fixture.command.tabComplete(sender.port, "fantasystick",
+                new String[]{"config", "purify-range-blocks", ""}));
+            fixture.command.execute(sender.port, "fantasystick", new String[]{"config", "purify-range-blocks"});
+            assertTrue(sender.messages.getLast().contains("=16"));
+            fixture.command.execute(sender.port, "fantasystick", new String[]{"config", "purify-range-blocks", "20"});
+            var response = fixture.tasks.poll(5, TimeUnit.SECONDS); assertNotNull(response); response.run();
+            assertEquals(0, new BigDecimal("20").compareTo(registry.find("purify").orElseThrow().parameters().get("range")));
+            var caster = new FantasyStickLifecycleNativeTest.Actor(data); var ally = new FantasyStickLifecycleNativeTest.Actor(data);
+            prepare(data, caster, true); fixture.players.put(caster.core.id, caster.player); fixture.players.put(ally.core.id, ally.player);
+            fixture.activate(caster); fixture.activate(ally); party(fixture, caster, ally); aim(caster, ally.player, 19, true);
+            effects(fixture, ally.player).put(PotionEffectType.SLOWNESS, instance(PotionEffectType.SLOWNESS, 200, 0));
+            doReturn(false).when(caster.player).isSneaking(); use(fixture, caster); drain(fixture, 2);
+            assertNull(ally.player.getPotionEffect(PotionEffectType.SLOWNESS));
+            fixture.command.execute(sender.port, "fantasystick", new String[]{"config", "purify-range-blocks", "0"});
+            assertTrue(sender.messages.getLast().contains("invalid"));
+            fixture.command.execute(sender.port, "fantasystick", new String[]{"config", "purify-range-blocks", "20", "extra"});
+            assertTrue(sender.messages.getLast().contains("Usage"));
+            fixture.plugin.setEnabled(false); fixture.plugin.setEnabled(true);
+            var reloaded = (games.dmg.fantasystick.ability.AbilityRegistry)
+                FantasyStickLifecycleNativeTest.Fixture.field(fixture.plugin, "abilityRegistry");
+            assertEquals(0, new BigDecimal("20").compareTo(reloaded.find("purify").orElseThrow().parameters().get("range")));
+        }
+        for (String invalid : List.of("purify-cooldown-seconds: -1\n", "purify-range-blocks: 0\n")) {
+            var directory = data.resolve(Integer.toHexString(invalid.hashCode())); java.nio.file.Files.createDirectories(directory);
+            java.nio.file.Files.writeString(directory.resolve("config.yml"), invalid);
+            try (var fixture = new FantasyStickLifecycleNativeTest.Fixture(directory)) {
+                assertThrows(IllegalArgumentException.class, () -> fixture.plugin.setEnabled(true)); assertTrue(fixture.order.isEmpty());
+            }
+        }
+    }
+
+    private static final Map<Player, Map<PotionEffectType, MobEffectInstance>> EFFECTS = new java.util.WeakHashMap<>();
+
+    private static Map<PotionEffectType, MobEffectInstance> effects(FantasyStickLifecycleNativeTest.Fixture fixture, Player player) {
+        var active = new HashMap<PotionEffectType, MobEffectInstance>(); EFFECTS.put(player, active);
+        doAnswer(call -> {
+            var effect = active.get(call.getArgument(0));
+            return effect == null ? null : new PotionEffect(call.getArgument(0), effect.getDuration(), effect.getAmplifier());
+        }).when(player).getPotionEffect(any());
+        doAnswer(call -> {
+            PotionEffectType type = call.getArgument(0); var current = active.get(type);
+            if (current == null) return null;
+            var old = new PotionEffect(type, current.getDuration(), current.getAmplifier());
+            var event = new EntityPotionEffectEvent(player, old, null, null, EntityPotionEffectEvent.Cause.MILK,
+                EntityPotionEffectEvent.Action.REMOVED, false);
+            fixture.dispatcher.accept(event); if (!event.isCancelled()) active.remove(type); return null;
+        }).when(player).removePotionEffect(any());
+        return active;
+    }
+
+    private static Map<PotionEffectType, MobEffectInstance> effectMap(Player player) {
+        return EFFECTS.computeIfAbsent(player, ignored -> new HashMap<>());
+    }
+
+    private static MobEffectInstance layered(PotionEffectType type) {
+        var current = instance(type, 200, 0); current.update(instance(type, 40, 1));
+        assertNotNull(current.hiddenEffect); return current;
+    }
+
+    private static MobEffectInstance instance(PotionEffectType type, int duration, int amplifier) {
+        return new MobEffectInstance(org.bukkit.craftbukkit.potion.CraftPotionEffectType.bukkitToMinecraftHolder(type), duration, amplifier);
+    }
+
+    private static void learnAndAssign(FantasyStickLifecycleNativeTest.Fixture fixture,
+                                       FantasyStickLifecycleNativeTest.Actor actor) throws Exception {
+        actor.core.inventory.getInventory().setSelectedSlot(0); PartyBookNativeTest.open(fixture, actor);
+        PartyBookNativeTest.click(fixture, actor, button(actor, "[Learn]", "purify")); drain(fixture, 2);
+        PartyBookNativeTest.click(fixture, actor, button(actor, "[3]", "purify")); drain(fixture, 2);
+    }
+
+    private static void party(FantasyStickLifecycleNativeTest.Fixture fixture,
+                              FantasyStickLifecycleNativeTest.Actor caster,
+                              FantasyStickLifecycleNativeTest.Actor ally) {
+        var parties = PartyLifecycleNativeTest.parties(fixture); var group = parties.create(caster.core.id).orElseThrow();
+        assertTrue(parties.accept(ally.core.id, parties.invite(caster.core.id, group.id(), ally.core.id).orElseThrow().id()));
+    }
+
+    private static void aim(FantasyStickLifecycleNativeTest.Actor caster, Player target, double distance, boolean visible) {
+        doReturn(new Location(caster.world, 0, 64, 0)).when(caster.player).getLocation();
+        doReturn(new Location(caster.world, distance, 64, 0)).when(target).getLocation();
+        doReturn(visible).when(caster.player).hasLineOfSight(target); doReturn(target).when(caster.player).getTargetEntity(64);
+    }
+
+    private static void use(FantasyStickLifecycleNativeTest.Fixture fixture, FantasyStickLifecycleNativeTest.Actor actor) {
+        actor.core.inventory.getInventory().setSelectedSlot(2);
+        fixture.dispatcher.accept(new PlayerInteractEvent(actor.player, org.bukkit.event.block.Action.RIGHT_CLICK_AIR,
+            actor.core.inventory.getItem(2), null, org.bukkit.block.BlockFace.SELF, EquipmentSlot.HAND));
+    }
+
+    private static void drain(FantasyStickLifecycleNativeTest.Fixture fixture, int count) throws Exception {
+        for (int index = 0; index < count; index++) PartyBookNativeTest.drain(fixture);
+    }
+
+    private static CharacterStorage storage(FantasyStickLifecycleNativeTest.Fixture fixture) {
+        return (CharacterStorage) FantasyStickLifecycleNativeTest.Fixture.field(fixture.plugin, "characters");
+    }
+
+    private static ClickEvent.Custom button(FantasyStickLifecycleNativeTest.Actor actor, String label, String ability) {
+        var book = org.bukkit.craftbukkit.inventory.CraftItemStack.asNMSCopy(actor.books.getLast())
+            .get(net.minecraft.core.component.DataComponents.WRITTEN_BOOK_CONTENT); assertNotNull(book);
+        for (var page : book.pages()) { var found = button(page.raw(), label, ability); if (found != null) return found; }
+        throw new AssertionError("Missing " + label + " for " + ability);
+    }
+
+    private static ClickEvent.Custom button(net.minecraft.network.chat.Component component, String label, String ability) {
+        if (component.getString().equals(label) && component.getStyle().getClickEvent() instanceof ClickEvent.Custom custom
+                && custom.payload().orElse(null) instanceof net.minecraft.nbt.StringTag payload
+                && payload.value().contains(":" + ability)) return custom;
+        for (var child : component.getSiblings()) { var found = button(child, label, ability); if (found != null) return found; }
+        return null;
+    }
+
+    private static void prepare(Path directory, FantasyStickLifecycleNativeTest.Actor actor, boolean learned) throws Exception {
+        java.nio.file.Files.createDirectories(directory); var repository = new YamlCharacterRepository(directory);
+        var old = repository.load(actor.core.record.id()).orElseThrow(); var stats = new EnumMap<>(old.stats());
+        stats.put(Stat.WIS, BigInteger.valueOf(14)); stats.put(Stat.CHR, BigInteger.TEN);
+        repository.replace(new CharacterRecord(old.id(), old.name(), old.revision().add(BigInteger.ONE), stats,
+            old.level(), old.experience(), BigInteger.valueOf(learned ? 39 : 40), old.health(),
+            learned ? Set.of("purify") : old.learned(), learned ? List.of("purify", "", "", "", "", "", "") : old.loadout(),
+            old.cooldowns(), old.restrictedKills(), false, null, null), old.revision());
+    }
+}

src/nativeTest/java/games/dmg/fantasystick/QuickstepNativeTest.java

@@ -202,7 +202,7 @@ class QuickstepNativeTest {
             assertEquals(0, new java.math.BigDecimal("6").compareTo(definition.parameters().get("distance")));
             assertEquals(0, new java.math.BigDecimal("1.5").compareTo(definition.parameters().get("speed")));
             var sender = new EquipmentAdminCommandNativeTest.Sender();
-            assertEquals(List.of("config", "inspect", "recover"),
+            assertEquals(List.of("config", "experience", "give", "inspect", "recover"),
                 f.command.tabComplete(sender.port, "fantasystick", new String[]{""}));
             assertEquals(List.of("config"), f.command.tabComplete(sender.port, "fantasystick", new String[]{"co"}));
             assertTrue(f.command.tabComplete(sender.port, "fantasystick", new String[]{"unsupported"}).isEmpty());

src/nativeTest/java/games/dmg/fantasystick/RallyingCryNativeTest.java

@@ -0,0 +1,287 @@
+package games.dmg.fantasystick;
+
+import static org.junit.jupiter.api.Assertions.*;
+import static org.mockito.ArgumentMatchers.*;
+import static org.mockito.Mockito.*;
+
+import games.dmg.fantasystick.ability.AbilityExecution;
+import games.dmg.fantasystick.ability.OutgoingDamageBonus;
+import games.dmg.fantasystick.ability.RallyingCry;
+import games.dmg.fantasystick.party.PartyRoster;
+import games.dmg.fantasystick.persistence.CharacterRecord;
+import games.dmg.fantasystick.persistence.CharacterStorage;
+import games.dmg.fantasystick.persistence.YamlCharacterRepository;
+import games.dmg.fantasystick.progression.Stat;
+import games.dmg.fantasystick.session.ControlInput;
+import games.dmg.fantasystick.session.EquipmentSessions;
+import java.math.BigDecimal;
+import java.math.BigInteger;
+import java.nio.file.Path;
+import java.util.ArrayList;
+import java.util.EnumMap;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.UUID;
+import java.util.concurrent.TimeUnit;
+import net.minecraft.network.chat.ClickEvent;
+import org.bukkit.Location;
+import org.bukkit.entity.LivingEntity;
+import org.bukkit.entity.Player;
+import org.bukkit.event.entity.EntityDamageByEntityEvent;
+import org.bukkit.event.entity.EntityDamageEvent;
+import org.bukkit.event.entity.EntityDeathEvent;
+import org.bukkit.event.player.PlayerInteractEvent;
+import org.bukkit.inventory.EquipmentSlot;
+import org.bukkit.potion.PotionEffect;
+import org.bukkit.potion.PotionEffectType;
+import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.io.TempDir;
+
+class RallyingCryNativeTest {
+    @TempDir Path data;
+    @BeforeAll static void bootstrap() throws Exception { NativeRuntime.bootstrap(); }
+
+    @Test void bookAcquisitionEquippedUseBuffsCasterAndNearbyPartyAllyAndRewardsActualUse() throws Exception {
+        try (var fixture = new FantasyStickLifecycleNativeTest.Fixture(data)) {
+            fixture.plugin.setEnabled(true); var caster = new FantasyStickLifecycleNativeTest.Actor(data);
+            var ally = new FantasyStickLifecycleNativeTest.Actor(data); prepareCaster(data, caster, false);
+            fixture.players.put(caster.core.id, caster.player); fixture.players.put(ally.core.id, ally.player);
+            fixture.activate(caster); fixture.activate(ally); party(fixture, caster, ally); nearby(caster, List.of(ally.player));
+            var casterEffects = effects(caster.player); var allyEffects = effects(ally.player);
+
+            caster.core.inventory.getInventory().setSelectedSlot(0); PartyBookNativeTest.open(fixture, caster);
+            String text = PartyBookNativeTest.text(caster).replaceAll("\\s+", "");
+            assertTrue(text.contains("RallyingCry")); assertTrue(text.contains("CHR16")); assertTrue(text.contains("CON12"));
+            assertTrue(text.contains("Cost:1")); assertTrue(text.contains("20%")); assertTrue(text.contains("6seconds"));
+            PartyBookNativeTest.click(fixture, caster, button(caster, "[Learn]", "rallying_cry")); drain(fixture, 2);
+            PartyBookNativeTest.click(fixture, caster, button(caster, "[3]", "rallying_cry")); drain(fixture, 2);
+            use(fixture, caster); drain(fixture, 2);
+            assertEquals(0, casterEffects.get(PotionEffectType.SPEED).getAmplifier());
+            assertEquals(0, allyEffects.get(PotionEffectType.SPEED).getAmplifier());
+            assertNotNull(storage(fixture).find(caster.core.record.id()).get().orElseThrow().cooldowns().get("rallying_cry"));
+
+            var enemy = mock(LivingEntity.class); when(enemy.getUniqueId()).thenReturn(UUID.randomUUID());
+            when(enemy.getType()).thenReturn(org.bukkit.entity.EntityType.ZOMBIE);
+            when(enemy.getLocation()).thenReturn(new Location(caster.world, 4, 64, 0)); when(caster.world.getUID()).thenReturn(UUID.randomUUID());
+            var source = org.bukkit.damage.DamageSource.builder(org.bukkit.damage.DamageType.PLAYER_ATTACK)
+                .withCausingEntity(ally.player).withDirectEntity(ally.player).build();
+            var hit = new EntityDamageByEntityEvent(ally.player, enemy, EntityDamageEvent.DamageCause.ENTITY_ATTACK, source, 10);
+            fixture.dispatcher.accept(hit); assertEquals(12, hit.getDamage(), 1.0e-9);
+            fixture.dispatcher.accept(new EntityDeathEvent(enemy, source, new ArrayList<>(), 0)); drain(fixture, 4);
+            assertEquals(BigInteger.valueOf(5), storage(fixture).find(caster.core.record.id()).get().orElseThrow().experience());
+            assertEquals(BigInteger.valueOf(5), storage(fixture).find(ally.core.record.id()).get().orElseThrow().experience());
+            fixture.delayed.getLast().run();
+            assertFalse(casterEffects.containsKey(PotionEffectType.SPEED)); assertFalse(allyEffects.containsKey(PotionEffectType.SPEED));
+            var expired = new EntityDamageByEntityEvent(ally.player, enemy, EntityDamageEvent.DamageCause.ENTITY_ATTACK, source, 10);
+            fixture.dispatcher.accept(expired); assertEquals(10, expired.getDamage(), 1.0e-9);
+            var deadline = storage(fixture).find(caster.core.record.id()).get().orElseThrow().cooldowns().get("rallying_cry");
+            caster.core.inventory.getInventory().setSelectedSlot(0); PartyBookNativeTest.open(fixture, caster);
+            var unlearn = button(caster, "[Unlearn]", "rallying_cry");
+            PartyBookNativeTest.click(fixture, caster, unlearn); PartyBookNativeTest.click(fixture, caster, unlearn); drain(fixture, 2);
+            assertEquals(deadline, storage(fixture).find(caster.core.record.id()).get().orElseThrow().cooldowns().get("rallying_cry"));
+            PartyBookNativeTest.click(fixture, caster, button(caster, "[Learn]", "rallying_cry")); drain(fixture, 2);
+            PartyBookNativeTest.click(fixture, caster, button(caster, "[3]", "rallying_cry")); drain(fixture, 2);
+            use(fixture, caster); assertTrue(caster.messages.stream().anyMatch(message -> message.contains("ready in")));
+        }
+    }
+
+    @Test void dynamicSphereMembershipSessionAndSourceValidityRecheckOwnedBenefits() throws Exception {
+        var sessions = mock(EquipmentSessions.class); var parties = mock(PartyRoster.class);
+        var bonus = mock(OutgoingDamageBonus.class); var sourceGrant = mock(AutoCloseable.class); var allyGrant = mock(AutoCloseable.class);
+        when(bonus.grant(any(), any(), any(), any())).thenReturn(sourceGrant, allyGrant);
+        var source = mock(Player.class); var ally = mock(Player.class); var outsider = mock(Player.class);
+        var world = mock(org.bukkit.World.class); var sourceId = UUID.randomUUID(); var allyId = UUID.randomUUID(); var outsiderId = UUID.randomUUID();
+        when(source.getUniqueId()).thenReturn(sourceId); when(ally.getUniqueId()).thenReturn(allyId); when(outsider.getUniqueId()).thenReturn(outsiderId);
+        when(source.getLocation()).thenReturn(new Location(world, 0, 64, 0)); when(ally.getLocation()).thenReturn(new Location(world, 7, 64, 0));
+        when(outsider.getLocation()).thenReturn(new Location(world, 2, 64, 0));
+        when(source.getNearbyEntities(8, 8, 8)).thenReturn(List.of(ally, outsider));
+        var sourceEffects = effects(source); var allyEffects = effects(ally); effects(outsider);
+        var sourceActive = new EquipmentSessions.Active(sourceId, UUID.randomUUID(), UUID.randomUUID());
+        var allyActive = new EquipmentSessions.Active(allyId, UUID.randomUUID(), UUID.randomUUID());
+        var outsiderActive = new EquipmentSessions.Active(outsiderId, UUID.randomUUID(), UUID.randomUUID());
+        when(sessions.active(sourceId)).thenReturn(java.util.Optional.of(sourceActive)); when(sessions.current(sourceActive)).thenReturn(true);
+        when(sessions.active(allyId)).thenReturn(java.util.Optional.of(allyActive)); when(sessions.current(allyActive)).thenReturn(true);
+        when(sessions.active(outsiderId)).thenReturn(java.util.Optional.of(outsiderActive)); when(sessions.current(outsiderActive)).thenReturn(true);
+        var party = new PartyRoster.Party(UUID.randomUUID(), sourceId, List.of(sourceId, allyId));
+        when(parties.partyOf(sourceId)).thenReturn(java.util.Optional.of(party)); when(parties.partyOf(allyId)).thenReturn(java.util.Optional.of(party));
+        var execution = mock(AbilityExecution.class); var input = mock(ControlInput.class);
+        when(input.player()).thenReturn(source); when(input.session()).thenReturn(sourceActive);
+        when(execution.input()).thenReturn(input); when(execution.stillCurrent()).thenReturn(true);
+        var rally = new RallyingCry(RallyingCry.Settings.defaults(), sessions, parties, bonus); when(execution.definition()).thenReturn(rally.definition());
+        rally.activate(execution);
+        assertTrue(sourceEffects.containsKey(PotionEffectType.SPEED)); assertTrue(allyEffects.containsKey(PotionEffectType.SPEED));
+        verify(bonus, times(2)).grant(eq(execution), any(), eq(new BigDecimal("20")), any());
+
+        when(ally.getLocation()).thenReturn(new Location(world, 9, 64, 0)); rally.sweep();
+        assertFalse(allyEffects.containsKey(PotionEffectType.SPEED)); verify(allyGrant).close();
+        when(ally.getLocation()).thenReturn(new Location(world, 7, 64, 0)); rally.sweep();
+        assertTrue(allyEffects.containsKey(PotionEffectType.SPEED), "A valid party ally re-entering the active cry is rechecked");
+        when(parties.partyOf(allyId)).thenReturn(java.util.Optional.empty()); rally.sweep();
+        assertFalse(allyEffects.containsKey(PotionEffectType.SPEED));
+        when(parties.partyOf(allyId)).thenReturn(java.util.Optional.of(party)); rally.sweep();
+        assertTrue(allyEffects.containsKey(PotionEffectType.SPEED));
+        when(sessions.current(allyActive)).thenReturn(false); rally.sweep();
+        assertFalse(allyEffects.containsKey(PotionEffectType.SPEED));
+        when(sessions.current(sourceActive)).thenReturn(false); rally.sweep(); verify(execution).finish(); verify(sourceGrant).close();
+    }
+
+    @Test void duplicateRalliesDoNotStackSpeedOrDamageAndPreserveStrongerUnrelatedSpeed() throws Exception {
+        var sessions = mock(EquipmentSessions.class); var parties = mock(PartyRoster.class);
+        var supports = new ArrayList<OutgoingDamageBonus.Support>(); var bonus = new OutgoingDamageBonus(sessions, parties, supports::add);
+        var sourceA = mock(Player.class); var sourceB = mock(Player.class); var ally = mock(Player.class); var enemy = mock(LivingEntity.class);
+        var world = mock(org.bukkit.World.class); UUID a = UUID.randomUUID(), b = UUID.randomUUID(), c = UUID.randomUUID();
+        when(sourceA.getUniqueId()).thenReturn(a); when(sourceB.getUniqueId()).thenReturn(b); when(ally.getUniqueId()).thenReturn(c);
+        when(enemy.getUniqueId()).thenReturn(UUID.randomUUID());
+        for (var player : List.of(sourceA, sourceB, ally)) when(player.getLocation()).thenReturn(new Location(world, 0, 64, 0));
+        when(sourceA.getNearbyEntities(8, 8, 8)).thenReturn(List.of(sourceB, ally));
+        when(sourceB.getNearbyEntities(8, 8, 8)).thenReturn(List.of(sourceA, ally));
+        effects(sourceA); effects(sourceB); var allyEffects = effects(ally);
+        allyEffects.put(PotionEffectType.SPEED, new PotionEffect(PotionEffectType.SPEED, 200, 1));
+        var aa = new EquipmentSessions.Active(a, UUID.randomUUID(), UUID.randomUUID());
+        var ba = new EquipmentSessions.Active(b, UUID.randomUUID(), UUID.randomUUID());
+        var ca = new EquipmentSessions.Active(c, UUID.randomUUID(), UUID.randomUUID());
+        when(sessions.active(a)).thenReturn(java.util.Optional.of(aa)); when(sessions.active(b)).thenReturn(java.util.Optional.of(ba));
+        when(sessions.active(c)).thenReturn(java.util.Optional.of(ca)); when(sessions.current(any())).thenReturn(true);
+        var party = new PartyRoster.Party(UUID.randomUUID(), a, List.of(a, b, c));
+        when(parties.partyOf(a)).thenReturn(java.util.Optional.of(party)); when(parties.partyOf(b)).thenReturn(java.util.Optional.of(party));
+        when(parties.partyOf(c)).thenReturn(java.util.Optional.of(party));
+        var rally = new RallyingCry(RallyingCry.Settings.defaults(), sessions, parties, bonus);
+        var first = execution(sourceA, aa, rally); var second = execution(sourceB, ba, rally); rally.activate(first); rally.activate(second);
+        var hit = hit(ally, enemy, 10); bonus.increase(hit); assertEquals(12, hit.getDamage(), 1.0e-9);
+        assertEquals(1, allyEffects.get(PotionEffectType.SPEED).getAmplifier(), "Stronger unrelated Speed is untouched");
+        rally.close(); bonus.close(); assertEquals(1, allyEffects.get(PotionEffectType.SPEED).getAmplifier());
+    }
+
+    @Test void configuredDefinitionAdminRestartAndFutureCastCoverEverySetting() throws Exception {
+        java.nio.file.Files.writeString(data.resolve("config.yml"),
+            "rallying-cry-cooldown-seconds: 2\nrallying-cry-radius-blocks: 10\nrallying-cry-duration-seconds: 8\n"
+            + "rallying-cry-speed-amplifier: 1\nrallying-cry-damage-bonus-percent: 30\n");
+        try (var fixture = new FantasyStickLifecycleNativeTest.Fixture(data)) {
+            fixture.plugin.setEnabled(true); var registry = (games.dmg.fantasystick.ability.AbilityRegistry)
+                FantasyStickLifecycleNativeTest.Fixture.field(fixture.plugin, "abilityRegistry");
+            var definition = registry.find("rallying_cry").orElseThrow(); assertEquals(java.time.Duration.ofSeconds(2), definition.cooldown());
+            assertEquals(0, new BigDecimal("10").compareTo(definition.parameters().get("radius")));
+            assertEquals(0, new BigDecimal("8").compareTo(definition.parameters().get("duration-seconds")));
+            assertEquals(new BigDecimal("1"), definition.parameters().get("speed-amplifier"));
+            assertEquals(new BigDecimal("30"), definition.parameters().get("damage-bonus-percent"));
+            var sender = new EquipmentAdminCommandNativeTest.Sender(); sender.allowed = false;
+            assertTrue(fixture.command.tabComplete(sender.port, "fantasystick", new String[]{"config", "rallying-cry-"}).isEmpty());
+            fixture.command.execute(sender.port, "fantasystick", new String[]{"config", "rallying-cry-radius-blocks", "12"});
+            assertTrue(sender.messages.getLast().contains("Permission denied")); sender.allowed = true;
+            assertEquals(List.of("rallying-cry-cooldown-seconds", "rallying-cry-damage-bonus-percent",
+                "rallying-cry-duration-seconds", "rallying-cry-radius-blocks", "rallying-cry-speed-amplifier"),
+                fixture.command.tabComplete(sender.port, "fantasystick", new String[]{"config", "rallying-cry-"}));
+            assertEquals(List.of("10", "8"), fixture.command.tabComplete(sender.port, "fantasystick",
+                new String[]{"config", "rallying-cry-radius-blocks", ""}));
+            fixture.command.execute(sender.port, "fantasystick", new String[]{"config", "rallying-cry-radius-blocks"});
+            assertTrue(sender.messages.getLast().contains("=10"));
+            for (String[] update : List.of(new String[]{"rallying-cry-cooldown-seconds", "3"},
+                    new String[]{"rallying-cry-radius-blocks", "12"}, new String[]{"rallying-cry-duration-seconds", "9"},
+                    new String[]{"rallying-cry-speed-amplifier", "2"}, new String[]{"rallying-cry-damage-bonus-percent", "40"})) {
+                fixture.command.execute(sender.port, "fantasystick", new String[]{"config", update[0], update[1]});
+                var response = fixture.tasks.poll(5, TimeUnit.SECONDS); assertNotNull(response); response.run();
+            }
+            var configured = registry.find("rallying_cry").orElseThrow();
+            assertEquals(java.time.Duration.ofSeconds(3), configured.cooldown());
+            assertEquals(0, new BigDecimal("12").compareTo(configured.parameters().get("radius")));
+            assertEquals(0, new BigDecimal("9").compareTo(configured.parameters().get("duration-seconds")));
+            assertEquals(new BigDecimal("2"), configured.parameters().get("speed-amplifier"));
+            assertEquals(new BigDecimal("40"), configured.parameters().get("damage-bonus-percent"));
+
+            var caster = new FantasyStickLifecycleNativeTest.Actor(data); var ally = new FantasyStickLifecycleNativeTest.Actor(data);
+            prepareCaster(data, caster, true); fixture.players.put(caster.core.id, caster.player); fixture.players.put(ally.core.id, ally.player);
+            fixture.activate(caster); fixture.activate(ally); party(fixture, caster, ally); nearby(caster, List.of(ally.player));
+            var casterEffects = effects(caster.player); var allyEffects = effects(ally.player); use(fixture, caster); drain(fixture, 2);
+            assertEquals(2, casterEffects.get(PotionEffectType.SPEED).getAmplifier());
+            assertEquals(2, allyEffects.get(PotionEffectType.SPEED).getAmplifier()); assertEquals(180L, fixture.delayedTicks.getLast());
+            var futureTarget = mock(LivingEntity.class); when(futureTarget.getUniqueId()).thenReturn(UUID.randomUUID());
+            var future = hit(ally.player, futureTarget, 10); fixture.dispatcher.accept(future);
+            assertEquals(14, future.getDamage(), 1.0e-9);
+            fixture.command.execute(sender.port, "fantasystick", new String[]{"config", "rallying-cry-duration-seconds", "0"});
+            assertTrue(sender.messages.getLast().contains("invalid"));
+            fixture.command.execute(sender.port, "fantasystick", new String[]{"config", "rallying-cry-radius-blocks", "12", "extra"});
+            assertTrue(sender.messages.getLast().contains("Usage"));
+            fixture.plugin.setEnabled(false); fixture.plugin.setEnabled(true);
+            var reloaded = (games.dmg.fantasystick.ability.AbilityRegistry)
+                FantasyStickLifecycleNativeTest.Fixture.field(fixture.plugin, "abilityRegistry");
+            var saved = reloaded.find("rallying_cry").orElseThrow(); assertEquals(java.time.Duration.ofSeconds(3), saved.cooldown());
+            assertEquals(new BigDecimal("12"), saved.parameters().get("radius")); assertEquals(new BigDecimal("40"), saved.parameters().get("damage-bonus-percent"));
+            assertEquals(0, new BigDecimal("9").compareTo(saved.parameters().get("duration-seconds")));
+            assertEquals(new BigDecimal("2"), saved.parameters().get("speed-amplifier"));
+        }
+        for (String invalid : List.of("rallying-cry-cooldown-seconds: -1\n", "rallying-cry-radius-blocks: 0\n",
+                "rallying-cry-duration-seconds: 0\n", "rallying-cry-speed-amplifier: -1\n",
+                "rallying-cry-damage-bonus-percent: 101\n")) {
+            var directory = data.resolve(Integer.toHexString(invalid.hashCode())); java.nio.file.Files.createDirectories(directory);
+            java.nio.file.Files.writeString(directory.resolve("config.yml"), invalid);
+            try (var fixture = new FantasyStickLifecycleNativeTest.Fixture(directory)) {
+                assertThrows(IllegalArgumentException.class, () -> fixture.plugin.setEnabled(true)); assertTrue(fixture.order.isEmpty());
+            }
+        }
+    }
+
+    private static AbilityExecution execution(Player player, EquipmentSessions.Active active, RallyingCry rally) {
+        var execution = mock(AbilityExecution.class); var input = mock(ControlInput.class);
+        when(input.player()).thenReturn(player); when(input.session()).thenReturn(active);
+        when(execution.input()).thenReturn(input); when(execution.stillCurrent()).thenReturn(true); when(execution.definition()).thenReturn(rally.definition());
+        return execution;
+    }
+    private static Map<org.bukkit.potion.PotionEffectType, PotionEffect> effects(Player player) {
+        var effects = new HashMap<org.bukkit.potion.PotionEffectType, PotionEffect>();
+        doAnswer(call -> effects.get(call.getArgument(0))).when(player).getPotionEffect(any());
+        doAnswer(call -> { PotionEffect effect = call.getArgument(0); effects.put(effect.getType(), effect); return true; })
+            .when(player).addPotionEffect(any(), eq(true));
+        doAnswer(call -> { effects.remove(call.getArgument(0)); return null; }).when(player).removePotionEffect(any()); return effects;
+    }
+    private static void nearby(FantasyStickLifecycleNativeTest.Actor source, List<? extends org.bukkit.entity.Entity> entities) {
+        doReturn(new Location(source.world, 0, 64, 0)).when(source.player).getLocation();
+        doReturn(new ArrayList<>(entities)).when(source.player).getNearbyEntities(anyDouble(), anyDouble(), anyDouble());
+        for (var entity : entities) if (entity instanceof Player player) doReturn(new Location(source.world, 4, 64, 0)).when(player).getLocation();
+    }
+    private static EntityDamageByEntityEvent hit(Player attacker, LivingEntity target, double amount) {
+        var source = org.bukkit.damage.DamageSource.builder(org.bukkit.damage.DamageType.PLAYER_ATTACK)
+            .withCausingEntity(attacker).withDirectEntity(attacker).build();
+        return new EntityDamageByEntityEvent(attacker, target, EntityDamageEvent.DamageCause.ENTITY_ATTACK, source, amount);
+    }
+    private static void use(FantasyStickLifecycleNativeTest.Fixture fixture, FantasyStickLifecycleNativeTest.Actor actor) {
+        actor.core.inventory.getInventory().setSelectedSlot(2);
+        fixture.dispatcher.accept(new PlayerInteractEvent(actor.player, org.bukkit.event.block.Action.RIGHT_CLICK_AIR,
+            actor.core.inventory.getItem(2), null, org.bukkit.block.BlockFace.SELF, EquipmentSlot.HAND));
+    }
+    private static PartyRoster.Party party(FantasyStickLifecycleNativeTest.Fixture fixture,
+                                            FantasyStickLifecycleNativeTest.Actor source,
+                                            FantasyStickLifecycleNativeTest.Actor target) {
+        var parties = PartyLifecycleNativeTest.parties(fixture); var group = parties.create(source.core.id).orElseThrow();
+        assertTrue(parties.accept(target.core.id, parties.invite(source.core.id, group.id(), target.core.id).orElseThrow().id())); return group;
+    }
+    private static void drain(FantasyStickLifecycleNativeTest.Fixture fixture, int count) throws Exception {
+        for (int index = 0; index < count; index++) PartyBookNativeTest.drain(fixture);
+    }
+    private static CharacterStorage storage(FantasyStickLifecycleNativeTest.Fixture fixture) {
+        return (CharacterStorage) FantasyStickLifecycleNativeTest.Fixture.field(fixture.plugin, "characters");
+    }
+    private static ClickEvent.Custom button(FantasyStickLifecycleNativeTest.Actor actor, String label, String ability) {
+        var book = org.bukkit.craftbukkit.inventory.CraftItemStack.asNMSCopy(actor.books.getLast())
+            .get(net.minecraft.core.component.DataComponents.WRITTEN_BOOK_CONTENT); assertNotNull(book);
+        for (var page : book.pages()) { var found = button(page.raw(), label, ability); if (found != null) return found; }
+        throw new AssertionError("Missing " + label + " for " + ability);
+    }
+    private static ClickEvent.Custom button(net.minecraft.network.chat.Component component, String label, String ability) {
+        if (component.getString().equals(label) && component.getStyle().getClickEvent() instanceof ClickEvent.Custom custom
+                && custom.payload().orElse(null) instanceof net.minecraft.nbt.StringTag payload
+                && payload.value().contains(":" + ability)) return custom;
+        for (var child : component.getSiblings()) { var found = button(child, label, ability); if (found != null) return found; } return null;
+    }
+    private static void prepareCaster(Path directory, FantasyStickLifecycleNativeTest.Actor actor, boolean learned) throws Exception {
+        java.nio.file.Files.createDirectories(directory); var repository = new YamlCharacterRepository(directory);
+        var old = repository.load(actor.core.record.id()).orElseThrow(); var stats = new EnumMap<>(old.stats());
+        stats.put(Stat.CHR, BigInteger.valueOf(16)); stats.put(Stat.CON, BigInteger.valueOf(12));
+        repository.replace(new CharacterRecord(old.id(), old.name(), old.revision().add(BigInteger.ONE), stats,
+            old.level(), old.experience(), BigInteger.valueOf(learned ? 39 : 40), old.health(),
+            learned ? Set.of("rallying_cry") : old.learned(), learned ? List.of("rallying_cry", "", "", "", "", "", "") : old.loadout(),
+            old.cooldowns(), old.restrictedKills(), false, null, null), old.revision());
+    }
+}

src/nativeTest/java/games/dmg/fantasystick/RecipeDiscoveryNativeTest.java

@@ -0,0 +1,100 @@
+package games.dmg.fantasystick;
+
+import static org.junit.jupiter.api.Assertions.*;
+import static org.mockito.ArgumentMatchers.anyCollection;
+import static org.mockito.Mockito.doAnswer;
+
+import games.dmg.fantasystick.items.CharacterSheets;
+import java.nio.file.Path;
+import java.util.List;
+import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.logging.Handler;
+import java.util.logging.LogRecord;
+import org.bukkit.event.player.PlayerJoinEvent;
+import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.io.TempDir;
+
+class RecipeDiscoveryNativeTest {
+    @TempDir Path data;
+    @BeforeAll static void bootstrap() throws Exception { NativeRuntime.bootstrap(); }
+
+    @Test void packagedRegistrationDiscoversOnlineAndJoinPlayersOnceWithoutMintingAndRetainsKnowledge() throws Exception {
+        try (var f = new FantasyStickLifecycleNativeTest.Fixture(data)) {
+            var online = new FantasyStickLifecycleNativeTest.Actor(data);
+            f.players.put(online.core.id, online.player);
+            long records = records(data);
+
+            f.plugin.setEnabled(true);
+
+            var recipe = (org.bukkit.inventory.ShapelessRecipe) f.recipes.get(CharacterSheets.RECIPE);
+            assertNotNull(recipe);
+            assertEquals(org.bukkit.inventory.recipe.CraftingBookCategory.MISC, recipe.getCategory());
+            assertEquals(java.util.Set.of(CharacterSheets.RECIPE), online.knownRecipes);
+            assertEquals(List.of(List.of(CharacterSheets.RECIPE)), online.recipeAwards);
+            assertEquals(records, records(data));
+            assertTrue(new CharacterSheets().identify(recipe.getResult()).isEmpty());
+            var joining = new FantasyStickLifecycleNativeTest.Actor(data);
+            f.players.put(joining.core.id, joining.player);
+            f.dispatcher.accept(new PlayerJoinEvent(joining.player, "joined"));
+            f.dispatcher.accept(new PlayerJoinEvent(joining.player, "joined again"));
+            assertEquals(List.of(List.of(CharacterSheets.RECIPE)), joining.recipeAwards);
+            assertEquals(records + 1, records(data));
+
+            f.plugin.setEnabled(false);
+            f.dispatcher.accept(new PlayerJoinEvent(joining.player, "disabled"));
+            assertEquals(List.of(List.of(CharacterSheets.RECIPE)), joining.recipeAwards);
+            assertEquals(java.util.Set.of(CharacterSheets.RECIPE), joining.knownRecipes);
+            f.plugin.setEnabled(true);
+            assertEquals(List.of(List.of(CharacterSheets.RECIPE)), online.recipeAwards);
+            assertEquals(List.of(List.of(CharacterSheets.RECIPE)), joining.recipeAwards);
+        }
+    }
+
+    @Test void playerFailureIsLoggedIsolatedAndRetryableButRegistrationFailureAwardsNobody() throws Exception {
+        try (var f = new FantasyStickLifecycleNativeTest.Fixture(data.resolve("player-failure"))) {
+            var failing = new FantasyStickLifecycleNativeTest.Actor(data.resolve("player-failure"));
+            var healthy = new FantasyStickLifecycleNativeTest.Actor(data.resolve("player-failure"));
+            var fail = new AtomicBoolean(true);
+            doAnswer(call -> {
+                if (fail.getAndSet(false)) throw new IllegalStateException("simulated discovery failure");
+                var requested = ((java.util.Collection<?>) call.getArgument(0)).stream()
+                    .map(org.bukkit.NamespacedKey.class::cast).toList();
+                failing.recipeAwards.add(requested); failing.knownRecipes.addAll(requested); return requested.size();
+            }).when(failing.player).discoverRecipes(anyCollection());
+            f.players.put(failing.core.id, failing.player); f.players.put(healthy.core.id, healthy.player);
+            var logs = new java.util.ArrayList<LogRecord>();
+            var handler = new Handler() {
+                @Override public void publish(LogRecord record) { logs.add(record); }
+                @Override public void flush() { }
+                @Override public void close() { }
+            };
+            f.plugin.getLogger().addHandler(handler);
+            try {
+                f.plugin.setEnabled(true);
+                assertTrue(f.recipes.containsKey(CharacterSheets.RECIPE));
+                assertTrue(failing.knownRecipes.isEmpty());
+                assertEquals(java.util.Set.of(CharacterSheets.RECIPE), healthy.knownRecipes);
+                assertTrue(logs.stream().anyMatch(log -> log.getMessage().contains("discover character-sheet recipe")));
+                f.dispatcher.accept(new PlayerJoinEvent(failing.player, "retry"));
+                assertEquals(java.util.Set.of(CharacterSheets.RECIPE), failing.knownRecipes);
+            } finally { f.plugin.getLogger().removeHandler(handler); }
+        }
+        try (var f = new FantasyStickLifecycleNativeTest.Fixture(data.resolve("registration-failure"))) {
+            var online = new FantasyStickLifecycleNativeTest.Actor(data.resolve("registration-failure"));
+            f.players.put(online.core.id, online.player); f.failRegistrationAt = "recipe";
+            assertThrows(IllegalStateException.class, () -> f.plugin.setEnabled(true));
+            assertTrue(online.knownRecipes.isEmpty());
+            assertTrue(online.recipeAwards.isEmpty());
+            assertTrue(f.recipes.isEmpty());
+        }
+    }
+
+    private static long records(Path directory) throws Exception {
+        var characters = directory.resolve("characters");
+        if (!java.nio.file.Files.isDirectory(characters)) return 0;
+        try (var files = java.nio.file.Files.list(characters)) {
+            return files.filter(file -> file.getFileName().toString().endsWith(".yml")).count();
+        }
+    }
+}

src/nativeTest/java/games/dmg/fantasystick/ReviveNativeTest.java

@@ -36,9 +36,9 @@ class ReviveNativeTest {
             String text = PartyBookNativeTest.text(actor).replaceAll("\\s+", "");
             assertTrue(text.contains("Revive")); assertTrue(text.contains("WIS30")); assertTrue(text.contains("CHR24"));
             assertTrue(text.contains("CON12")); assertTrue(text.contains("Cooldown:86400s"));
-            PartyBookNativeTest.click(fixture, actor, PartyBookNativeTest.button(actor, "[Learn]"));
+            PartyBookNativeTest.click(fixture, actor, abilityButton(actor, "[Learn]", "revive"));
             PartyBookNativeTest.drain(fixture); PartyBookNativeTest.drain(fixture);
-            PartyBookNativeTest.click(fixture, actor, PartyBookNativeTest.button(actor, "[3]"));
+            PartyBookNativeTest.click(fixture, actor, abilityButton(actor, "[3]", "revive"));
             PartyBookNativeTest.drain(fixture); PartyBookNativeTest.drain(fixture);
             var storage = (games.dmg.fantasystick.persistence.CharacterStorage)
                 FantasyStickLifecycleNativeTest.Fixture.field(fixture.plugin, "characters");
@@ -372,6 +372,29 @@ class ReviveNativeTest {
         }
     }
 
+    private static net.minecraft.network.chat.ClickEvent.Custom abilityButton(
+            FantasyStickLifecycleNativeTest.Actor actor, String label, String ability) {
+        var book = org.bukkit.craftbukkit.inventory.CraftItemStack.asNMSCopy(actor.books.getLast())
+            .get(net.minecraft.core.component.DataComponents.WRITTEN_BOOK_CONTENT);
+        assertNotNull(book);
+        for (var page : book.pages()) {
+            var found = abilityButton(page.raw(), label, ability); if (found != null) return found;
+        }
+        throw new AssertionError("Missing " + label + " for " + ability);
+    }
+
+    private static net.minecraft.network.chat.ClickEvent.Custom abilityButton(
+            net.minecraft.network.chat.Component component, String label, String ability) {
+        if (component.getString().equals(label)
+                && component.getStyle().getClickEvent() instanceof net.minecraft.network.chat.ClickEvent.Custom custom
+                && custom.payload().orElse(null) instanceof net.minecraft.nbt.StringTag payload
+                && payload.value().contains(":" + ability)) return custom;
+        for (var child : component.getSiblings()) {
+            var found = abilityButton(child, label, ability); if (found != null) return found;
+        }
+        return null;
+    }
+
     private static void withRevive(Path data, FantasyStickLifecycleNativeTest.Actor actor) throws Exception {
         var repository = new games.dmg.fantasystick.persistence.YamlCharacterRepository(data);
         var old = repository.load(actor.core.record.id()).orElseThrow();

src/nativeTest/java/games/dmg/fantasystick/RoleplayAvailabilityNativeTest.java

@@ -0,0 +1,11 @@
+package games.dmg.fantasystick;
+import static org.junit.jupiter.api.Assertions.*;import java.nio.file.Path;import org.junit.jupiter.api.BeforeAll;import org.junit.jupiter.api.Test;import org.junit.jupiter.api.io.TempDir;
+class RoleplayAvailabilityNativeTest{@TempDir Path data;@BeforeAll static void bootstrap()throws Exception{NativeRuntime.bootstrap();}
+ @Test void registeredToggleExitsEveryActiveSessionBlocksEntryAndAllowsRecoveryThenLaterEntry()throws Exception{try(var f=new FantasyStickLifecycleNativeTest.Fixture(data)){f.plugin.setEnabled(true);var sender=new EquipmentAdminCommandNativeTest.Sender();assertEquals(java.util.List.of("roleplay-disabled"),f.command.tabComplete(sender.port,"fantasystick",new String[]{"config","rolep"}));assertEquals(java.util.List.of("false","true"),f.command.tabComplete(sender.port,"fantasystick",new String[]{"config","roleplay-disabled",""}));f.command.execute(sender.port,"fantasystick",new String[]{"config","roleplay-disabled"});assertTrue(sender.messages.getLast().contains("=false"));for(String bad:java.util.List.of("TRUE","1","yes","")){f.command.execute(sender.port,"fantasystick",new String[]{"config","roleplay-disabled",bad});assertTrue(sender.messages.getLast().contains("true|false"));}sender.allowed=false;assertTrue(f.command.tabComplete(sender.port,"fantasystick",new String[]{"config","rolep"}).isEmpty());f.command.execute(sender.port,"fantasystick",new String[]{"config","roleplay-disabled","true"});assertTrue(sender.messages.getLast().contains("Permission denied"));sender.allowed=true;f.command.execute(sender.port,"fantasystick",new String[]{"config","roleplay-disabled","true","extra"});assertTrue(sender.messages.getLast().contains("Usage"));assertTrue(f.command.tabComplete(sender.port,"fantasystick",new String[]{"config","roleplay-disabled","true",""}).isEmpty());var a=new FantasyStickLifecycleNativeTest.Actor(data);var b=new FantasyStickLifecycleNativeTest.Actor(data);var ordinary=new FantasyStickLifecycleNativeTest.Actor(data);f.players.put(a.core.id,a.player);f.players.put(b.core.id,b.player);f.players.put(ordinary.core.id,ordinary.player);var aBefore=a.core.snapshot();var bBefore=b.core.snapshot();var ordinaryBefore=ordinary.core.snapshot();assertDoesNotThrow(()->f.activate(a),"initial A activation");assertDoesNotThrow(()->f.activate(b),"initial B activation");a.core.health=4;save(f,sender,"true");f.awaitCharacterAndReceipt(a);f.awaitCharacterAndReceipt(b);var sessions=(games.dmg.fantasystick.session.EquipmentSessions)FantasyStickLifecycleNativeTest.Fixture.field(f.plugin,"sessions");assertTrue(sessions.active(a.core.id).isEmpty());assertTrue(sessions.active(b.core.id).isEmpty());assertArrayEquals(aBefore,a.core.snapshot());assertArrayEquals(bBefore,b.core.snapshot());assertArrayEquals(ordinaryBefore,ordinary.core.snapshot());assertTrue(a.core.online&&b.core.online);var storage=(games.dmg.fantasystick.persistence.CharacterStorage)FantasyStickLifecycleNativeTest.Fixture.field(f.plugin,"characters");assertEquals(0,new java.math.BigDecimal("4").compareTo(storage.find(a.core.record.id()).toCompletableFuture().get().orElseThrow().health()));var c=new FantasyStickLifecycleNativeTest.Actor(data);f.players.put(c.core.id,c.player);var cBefore=c.core.snapshot();f.changed(c);PartyBookNativeTest.drain(f);assertTrue(sessions.active(c.core.id).isEmpty());assertArrayEquals(cBefore,c.core.snapshot());assertTrue(c.messages.stream().anyMatch(message->message.toLowerCase().contains("disabled")));
+  var recovery=new FantasyStickLifecycleNativeTest.Actor(data);f.players.put(recovery.core.id,recovery.player);var recoveryBefore=recovery.core.snapshot();var session=java.util.UUID.randomUUID();f.receipts().prepare(recovery.core.id,session,recovery.core.record.id()).toCompletableFuture().get();assertEquals(games.dmg.fantasystick.items.EquipmentStorage.PackResult.PACKED,new games.dmg.fantasystick.items.EquipmentStorage().pack(recovery.core.inventory,recovery.core.id,session));recovery.core.marker(session,"PACKED");f.command.execute(sender.port,"fantasystick",new String[]{"recover",recovery.core.id.toString()});f.tick();assertArrayEquals(recoveryBefore,recovery.core.snapshot());save(f,sender,"false");var policy=(games.dmg.fantasystick.persistence.RoleplaySettings)FantasyStickLifecycleNativeTest.Fixture.field(f.plugin,"roleplaySettings");assertFalse(policy.disabled());f.reenter(c);assertEquals(c.core.record.id(),sessions.active(c.core.id).orElseThrow().character());f.plugin.setEnabled(false);f.plugin.setEnabled(true);f.command.execute(sender.port,"fantasystick",new String[]{"config","roleplay-disabled"});assertTrue(sender.messages.getLast().contains("=false"));}}
+ @Test void reenableWaitsForAcceptedRoleplayWriteAndOldLifetimeCannotReplayExit()throws Exception{try(var f=new FantasyStickLifecycleNativeTest.Fixture(data)){f.plugin.setEnabled(true);var old=(games.dmg.fantasystick.persistence.RoleplaySettings)FantasyStickLifecycleNativeTest.Fixture.field(f.plugin,"roleplaySettings");var worker=(java.util.concurrent.ExecutorService)FantasyStickLifecycleNativeTest.Fixture.field(old,"worker");var entered=new java.util.concurrent.CountDownLatch(1);var release=new java.util.concurrent.CountDownLatch(1);worker.execute(()->{entered.countDown();try{release.await();}catch(InterruptedException e){Thread.currentThread().interrupt();}});assertTrue(entered.await(5,java.util.concurrent.TimeUnit.SECONDS));var sender=new EquipmentAdminCommandNativeTest.Sender();f.command.execute(sender.port,"fantasystick",new String[]{"config","roleplay-disabled","true"});f.plugin.setEnabled(false);f.plugin.setEnabled(true);assertNull(FantasyStickLifecycleNativeTest.Fixture.field(f.plugin,"sessions"));release.countDown();f.tick();assertNotNull(FantasyStickLifecycleNativeTest.Fixture.field(f.plugin,"sessions"));assertTrue(((games.dmg.fantasystick.persistence.RoleplaySettings)FantasyStickLifecycleNativeTest.Fixture.field(f.plugin,"roleplaySettings")).disabled());var a=new FantasyStickLifecycleNativeTest.Actor(data);f.players.put(a.core.id,a.player);var before=a.core.snapshot();f.changed(a);PartyBookNativeTest.drain(f);assertArrayEquals(before,a.core.snapshot());}}
+ @Test void startupLoadsDisabledPolicyAndInvalidTypedValuesFailBeforeRegistration()throws Exception{var enabled=data.resolve("enabled");java.nio.file.Files.createDirectories(enabled);java.nio.file.Files.writeString(enabled.resolve("config.yml"),"roleplay-disabled: true\n");try(var f=new FantasyStickLifecycleNativeTest.Fixture(enabled)){f.plugin.setEnabled(true);var a=new FantasyStickLifecycleNativeTest.Actor(enabled);f.players.put(a.core.id,a.player);var before=a.core.snapshot();f.changed(a);PartyBookNativeTest.drain(f);var sessions=(games.dmg.fantasystick.session.EquipmentSessions)FantasyStickLifecycleNativeTest.Fixture.field(f.plugin,"sessions");assertTrue(sessions.active(a.core.id).isEmpty());assertArrayEquals(before,a.core.snapshot());var sender=new EquipmentAdminCommandNativeTest.Sender();f.command.execute(sender.port,"fantasystick",new String[]{"config","roleplay-disabled"});assertTrue(sender.messages.getLast().contains("=true"));}var invalid=data.resolve("invalid");java.nio.file.Files.createDirectories(invalid);java.nio.file.Files.writeString(invalid.resolve("config.yml"),"roleplay-disabled: 'true'\n");try(var f=new FantasyStickLifecycleNativeTest.Fixture(invalid)){assertThrows(IllegalArgumentException.class,()->f.plugin.setEnabled(true));assertTrue(f.order.isEmpty());assertTrue(f.tasks.isEmpty());}}
+ @Test void failedRestorationRetainsEvidenceWhileDisabled()throws Exception{try(var f=new FantasyStickLifecycleNativeTest.Fixture(data)){f.plugin.setEnabled(true);var sender=new EquipmentAdminCommandNativeTest.Sender();var a=new FantasyStickLifecycleNativeTest.Actor(data);f.players.put(a.core.id,a.player);f.activate(a);int box=java.util.stream.IntStream.range(9,36).filter(slot->a.core.inventory.getItem(slot)!=null&&a.core.inventory.getItem(slot).getType()==org.bukkit.Material.SHULKER_BOX).findFirst().orElseThrow();a.core.inventory.setItem(box,null);var before=a.core.snapshot();save(f,sender,"true");var sessions=(games.dmg.fantasystick.session.EquipmentSessions)FantasyStickLifecycleNativeTest.Fixture.field(f.plugin,"sessions");assertTrue(sessions.active(a.core.id).isEmpty());assertArrayEquals(before,a.core.snapshot());var state=f.receipts().find(a.core.id).toCompletableFuture().get().orElseThrow();assertNotNull(state.pending());assertNotNull(state.lastExit());assertTrue(((games.dmg.fantasystick.persistence.RoleplaySettings)FantasyStickLifecycleNativeTest.Fixture.field(f.plugin,"roleplaySettings")).disabled());assertTrue(a.core.online);}}
+ @Test void acknowledgedDisableCancelsPendingEntryAndFailedSaveChangesNothing()throws Exception{try(var f=new FantasyStickLifecycleNativeTest.Fixture(data)){f.plugin.setEnabled(true);var sender=new EquipmentAdminCommandNativeTest.Sender();var a=new FantasyStickLifecycleNativeTest.Actor(data);f.players.put(a.core.id,a.player);var before=a.core.snapshot();var characters=(games.dmg.fantasystick.persistence.CharacterStorage)FantasyStickLifecycleNativeTest.Fixture.field(f.plugin,"characters");var worker=(java.util.concurrent.ExecutorService)FantasyStickLifecycleNativeTest.Fixture.field(characters,"worker");var entered=new java.util.concurrent.CountDownLatch(1);var release=new java.util.concurrent.CountDownLatch(1);worker.execute(()->{entered.countDown();try{release.await();}catch(InterruptedException e){Thread.currentThread().interrupt();}});assertTrue(entered.await(5,java.util.concurrent.TimeUnit.SECONDS));f.changed(a);save(f,sender,"true");release.countDown();characters.find(java.util.UUID.randomUUID()).toCompletableFuture().get();PartyBookNativeTest.drain(f);var sessions=(games.dmg.fantasystick.session.EquipmentSessions)FantasyStickLifecycleNativeTest.Fixture.field(f.plugin,"sessions");assertTrue(sessions.active(a.core.id).isEmpty());assertArrayEquals(before,a.core.snapshot());f.plugin.setEnabled(false);}var failed=data.resolve("failed");java.nio.file.Files.createDirectories(failed);try(var f=new FantasyStickLifecycleNativeTest.Fixture(failed)){f.plugin.setEnabled(true);var sender=new EquipmentAdminCommandNativeTest.Sender();var a=new FantasyStickLifecycleNativeTest.Actor(failed);f.players.put(a.core.id,a.player);f.activate(a);java.nio.file.Files.createDirectory(failed.resolve("config.yml"));f.command.execute(sender.port,"fantasystick",new String[]{"config","roleplay-disabled","true"});var callback=f.tasks.poll(5,java.util.concurrent.TimeUnit.SECONDS);assertNotNull(callback);callback.run();assertTrue(sender.messages.getLast().contains("save failed"));var sessions=(games.dmg.fantasystick.session.EquipmentSessions)FantasyStickLifecycleNativeTest.Fixture.field(f.plugin,"sessions");assertTrue(sessions.active(a.core.id).isPresent());}}
+ static void save(FantasyStickLifecycleNativeTest.Fixture f,EquipmentAdminCommandNativeTest.Sender sender,String value)throws Exception{int before=sender.messages.size();f.command.execute(sender.port,"fantasystick",new String[]{"config","roleplay-disabled",value});assertEquals(before,sender.messages.size());while(sender.messages.size()==before){var task=f.tasks.poll(5,java.util.concurrent.TimeUnit.SECONDS);assertNotNull(task);task.run();}assertTrue(sender.messages.getLast().contains("="+value));}
+}

src/nativeTest/java/games/dmg/fantasystick/SecondWindNativeTest.java

@@ -0,0 +1,214 @@
+package games.dmg.fantasystick;
+
+import static org.junit.jupiter.api.Assertions.*;
+import static org.mockito.ArgumentMatchers.*;
+import static org.mockito.Mockito.*;
+
+import games.dmg.fantasystick.persistence.CharacterRecord;
+import games.dmg.fantasystick.persistence.CharacterStorage;
+import games.dmg.fantasystick.progression.Stat;
+import java.math.BigDecimal;
+import java.math.BigInteger;
+import java.nio.file.Path;
+import java.util.EnumMap;
+import java.util.List;
+import net.minecraft.network.chat.ClickEvent;
+import org.bukkit.event.entity.EntityRegainHealthEvent;
+import org.bukkit.event.player.PlayerInteractEvent;
+import org.bukkit.inventory.EquipmentSlot;
+import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.io.TempDir;
+
+class SecondWindNativeTest {
+    @TempDir Path data;
+    @BeforeAll static void bootstrap() throws Exception { NativeRuntime.bootstrap(); }
+
+    @Test void bookAcquisitionActualNativeHealPersistsBeforePublicationAndRetainsCooldown() throws Exception {
+        try (var f = new FantasyStickLifecycleNativeTest.Fixture(data)) {
+            f.plugin.setEnabled(true);
+            var a = new FantasyStickLifecycleNativeTest.Actor(data); withSecondWind(data, a, false, BigDecimal.valueOf(4));
+            f.players.put(a.core.id, a.player); f.activate(a);
+            a.core.inventory.getInventory().setSelectedSlot(0); PartyBookNativeTest.open(f, a);
+            String text = PartyBookNativeTest.text(a).replaceAll("\\s+", "");
+            assertTrue(text.contains("SecondWind")); assertTrue(text.contains("CON12")); assertTrue(text.contains("WIS12"));
+            PartyBookNativeTest.click(f, a, abilityButton(a, "[Learn]", "second_wind"));
+            PartyBookNativeTest.drain(f); PartyBookNativeTest.drain(f);
+            PartyBookNativeTest.click(f, a, abilityButton(a, "[3]", "second_wind"));
+            PartyBookNativeTest.drain(f); PartyBookNativeTest.drain(f);
+            assertEquals(4, a.player.getHealth());
+            use(f, a); PartyBookNativeTest.drain(f); PartyBookNativeTest.drain(f); PartyBookNativeTest.drain(f);
+            var storage = (CharacterStorage) FantasyStickLifecycleNativeTest.Fixture.field(f.plugin, "characters");
+            var saved = storage.find(a.core.record.id()).get().orElseThrow();
+            assertEquals(0, BigDecimal.valueOf(11).compareTo(saved.health())); assertEquals(11, a.player.getHealth());
+            assertNotNull(saved.cooldowns().get("second_wind"));
+            assertFalse(a.messages.stream().anyMatch(message -> message.contains("support")));
+            var sheet = a.core.inventory.getItemInOffHand().clone();
+            a.core.inventory.setItemInOffHand(null); f.changed(a); PartyBookNativeTest.drain(f); f.awaitCharacterAndReceipt(a);
+            a.core.inventory.setItemInOffHand(sheet); f.activate(a);
+            assertEquals(11, a.player.getHealth(), "Persisted healing survives exit and resume");
+            a.core.inventory.getInventory().setSelectedSlot(0); PartyBookNativeTest.open(f, a);
+            var unlearn = abilityButton(a, "[Unlearn]", "second_wind");
+            PartyBookNativeTest.click(f, a, unlearn); PartyBookNativeTest.click(f, a, unlearn);
+            PartyBookNativeTest.drain(f); PartyBookNativeTest.drain(f);
+            var refunded = storage.find(a.core.record.id()).get().orElseThrow();
+            assertEquals(BigInteger.valueOf(40), refunded.unspentPoints());
+            assertEquals(saved.cooldowns().get("second_wind"), refunded.cooldowns().get("second_wind"));
+            learnAndAssign(f, a); use(f, a);
+            assertTrue(a.messages.stream().anyMatch(message -> message.contains("ready in")));
+        }
+    }
+
+    @Test void fullHealthAndCancelledNativeHealingApplyNoHealth() throws Exception {
+        for (boolean full : new boolean[]{true, false}) try (var f = new FantasyStickLifecycleNativeTest.Fixture(data.resolve(Boolean.toString(full)))) {
+            f.plugin.setEnabled(true);
+            var a = new FantasyStickLifecycleNativeTest.Actor(data.resolve(Boolean.toString(full)));
+            withSecondWind(data.resolve(Boolean.toString(full)), a, true, BigDecimal.valueOf(full ? 22 : 4));
+            f.players.put(a.core.id, a.player); f.activate(a);
+            if (!full) {
+                class Veto implements org.bukkit.event.Listener {
+                    @org.bukkit.event.EventHandler public void heal(EntityRegainHealthEvent event) {
+                        if (event.getEntity() == a.player && event.getRegainReason() == EntityRegainHealthEvent.RegainReason.CUSTOM) {
+                            event.setCancelled(true);
+                        }
+                    }
+                }
+                f.dispatcher.register(new Veto(), f.plugin);
+            }
+            double before = a.player.getHealth(); use(f, a); PartyBookNativeTest.drain(f); PartyBookNativeTest.drain(f);
+            assertEquals(before, a.player.getHealth());
+            var storage = (CharacterStorage) FantasyStickLifecycleNativeTest.Fixture.field(f.plugin, "characters");
+            var saved = storage.find(a.core.record.id()).get().orElseThrow();
+            if (full) assertFalse(saved.cooldowns().containsKey("second_wind"));
+            else assertNotNull(saved.cooldowns().get("second_wind"));
+        }
+    }
+
+    @Test void failedHealthPersistencePublishesNoNativeHealing() {
+        var characters = mock(CharacterStorage.class);
+        var sessions = mock(games.dmg.fantasystick.session.EquipmentSessions.class);
+        var player = mock(org.bukkit.entity.Player.class);
+        var attribute = mock(org.bukkit.attribute.AttributeInstance.class);
+        when(player.getAttribute(org.bukkit.attribute.Attribute.MAX_HEALTH)).thenReturn(attribute);
+        when(attribute.getValue()).thenReturn(22.0); when(player.getHealth()).thenReturn(4.0);
+        var stats = new EnumMap<Stat, BigInteger>(Stat.class);
+        for (Stat stat : Stat.values()) stats.put(stat, BigInteger.ZERO);
+        stats.put(Stat.CON, BigInteger.valueOf(12)); stats.put(Stat.WIS, BigInteger.valueOf(12));
+        var base = new games.dmg.fantasystick.crafting.CharacterFactory().create(
+            games.dmg.fantasystick.progression.ProgressionRules.defaults());
+        var record = new CharacterRecord(base.id(), base.name(), BigInteger.ONE, stats, base.level(), base.experience(),
+            base.unspentPoints(), BigDecimal.valueOf(4), java.util.Set.of("second_wind"),
+            List.of("second_wind", "", "", "", "", "", ""), base.cooldowns(), base.restrictedKills(), false, null, null);
+        var input = mock(games.dmg.fantasystick.session.ControlInput.class);
+        var active = new games.dmg.fantasystick.session.EquipmentSessions.Active(java.util.UUID.randomUUID(),
+            java.util.UUID.randomUUID(), record.id());
+        when(input.player()).thenReturn(player); when(input.session()).thenReturn(active);
+        var execution = mock(games.dmg.fantasystick.ability.AbilityExecution.class);
+        var effect = new games.dmg.fantasystick.ability.SecondWind(
+            games.dmg.fantasystick.ability.SecondWind.Settings.defaults(), characters, sessions, Runnable::run,
+            ignored -> {}, () -> BigDecimal.valueOf(1024));
+        when(execution.stillCurrent()).thenReturn(true); when(execution.input()).thenReturn(input);
+        when(execution.character()).thenReturn(record); when(execution.definition()).thenReturn(effect.definition());
+        var failure = new java.util.concurrent.CompletableFuture<java.util.Optional<CharacterRecord>>();
+        when(characters.saveHealth(eq(record.id()), eq(record.revision()), any(), any())).thenReturn(failure);
+        effect.activate(execution); verify(player, never()).setHealth(anyDouble());
+        failure.completeExceptionally(new java.io.IOException("simulated health save failure"));
+        verify(player, never()).setHealth(anyDouble()); verify(execution).finish();
+    }
+
+    @Test void configuredDefinitionFormulaAndAdminRoutesCoverBothSettings() throws Exception {
+        java.nio.file.Files.writeString(data.resolve("config.yml"),
+            "second-wind-base-healing: 8\nsecond-wind-cooldown-seconds: 20\n");
+        try (var f = new FantasyStickLifecycleNativeTest.Fixture(data)) {
+            f.plugin.setEnabled(true);
+            var registry = (games.dmg.fantasystick.ability.AbilityRegistry)
+                FantasyStickLifecycleNativeTest.Fixture.field(f.plugin, "abilityRegistry");
+            var definition = registry.find("second_wind").orElseThrow();
+            assertEquals(java.time.Duration.ofSeconds(20), definition.cooldown());
+            assertEquals(new BigDecimal("8"), definition.parameters().get("base-healing"));
+            assertEquals(BigInteger.valueOf(7), games.dmg.fantasystick.ability.SecondWind.healing(BigInteger.valueOf(12)));
+            assertEquals(BigInteger.TEN.pow(500).subtract(BigInteger.TEN).divide(BigInteger.TWO).add(BigInteger.valueOf(6)),
+                games.dmg.fantasystick.ability.SecondWind.healing(BigInteger.TEN.pow(500)));
+            var sender = new EquipmentAdminCommandNativeTest.Sender();
+            assertEquals(List.of("config", "experience", "give", "inspect", "recover"),
+                f.command.tabComplete(sender.port, "fantasystick", new String[]{""}));
+            sender.allowed = false;
+            assertTrue(f.command.tabComplete(sender.port, "fantasystick", new String[]{"config", "second"}).isEmpty());
+            f.command.execute(sender.port, "fantasystick", new String[]{"config", "second-wind-base-healing", "9"});
+            assertTrue(sender.messages.getLast().contains("Permission denied")); sender.allowed = true;
+            assertEquals(List.of("second-wind-base-healing", "second-wind-cooldown-seconds"),
+                f.command.tabComplete(sender.port, "fantasystick", new String[]{"config", "second-wind-"}));
+            assertEquals(List.of("6", "8"), f.command.tabComplete(sender.port, "fantasystick",
+                new String[]{"config", "second-wind-base-healing", ""}));
+            f.command.execute(sender.port, "fantasystick", new String[]{"config", "second-wind-base-healing"});
+            assertTrue(sender.messages.getLast().contains("=8"));
+            f.command.execute(sender.port, "fantasystick", new String[]{"config", "second-wind-base-healing", "9"});
+            var response = f.tasks.poll(5, java.util.concurrent.TimeUnit.SECONDS); assertNotNull(response); response.run();
+            assertEquals(new BigDecimal("9"), registry.find("second_wind").orElseThrow().parameters().get("base-healing"));
+            var a = new FantasyStickLifecycleNativeTest.Actor(data); withSecondWind(data, a, true, BigDecimal.valueOf(4));
+            f.players.put(a.core.id, a.player); f.activate(a); use(f, a);
+            PartyBookNativeTest.drain(f); PartyBookNativeTest.drain(f); PartyBookNativeTest.drain(f);
+            assertEquals(14, a.player.getHealth(), "Future cast uses acknowledged base healing");
+            f.command.execute(sender.port, "fantasystick", new String[]{"config", "second-wind-base-healing", "-1"});
+            assertTrue(sender.messages.getLast().contains("invalid"));
+            f.command.execute(sender.port, "fantasystick", new String[]{"config", "second-wind-base-healing", "9", "extra"});
+            assertTrue(sender.messages.getLast().contains("Usage"));
+            f.plugin.setEnabled(false); f.plugin.setEnabled(true);
+            var reloaded = (games.dmg.fantasystick.ability.AbilityRegistry)
+                FantasyStickLifecycleNativeTest.Fixture.field(f.plugin, "abilityRegistry");
+            assertEquals(new BigDecimal("9"), reloaded.find("second_wind").orElseThrow().parameters().get("base-healing"));
+        }
+        for (String invalid : List.of("second-wind-base-healing: -1\n", "second-wind-cooldown-seconds: -1\n")) {
+            var directory = data.resolve(Integer.toHexString(invalid.hashCode()));
+            java.nio.file.Files.createDirectories(directory); java.nio.file.Files.writeString(directory.resolve("config.yml"), invalid);
+            try (var f = new FantasyStickLifecycleNativeTest.Fixture(directory)) {
+                assertThrows(IllegalArgumentException.class, () -> f.plugin.setEnabled(true));
+                assertTrue(f.order.isEmpty());
+            }
+        }
+    }
+
+    private static void learnAndAssign(FantasyStickLifecycleNativeTest.Fixture fixture,
+                                       FantasyStickLifecycleNativeTest.Actor actor) throws Exception {
+        actor.core.inventory.getInventory().setSelectedSlot(0); PartyBookNativeTest.open(fixture, actor);
+        PartyBookNativeTest.click(fixture, actor, abilityButton(actor, "[Learn]", "second_wind"));
+        PartyBookNativeTest.drain(fixture); PartyBookNativeTest.drain(fixture);
+        PartyBookNativeTest.click(fixture, actor, abilityButton(actor, "[3]", "second_wind"));
+        PartyBookNativeTest.drain(fixture); PartyBookNativeTest.drain(fixture);
+    }
+
+    private static void use(FantasyStickLifecycleNativeTest.Fixture fixture,
+                            FantasyStickLifecycleNativeTest.Actor actor) {
+        actor.core.inventory.getInventory().setSelectedSlot(2);
+        fixture.dispatcher.accept(new PlayerInteractEvent(actor.player, org.bukkit.event.block.Action.RIGHT_CLICK_AIR,
+            actor.core.inventory.getItem(2), null, org.bukkit.block.BlockFace.SELF, EquipmentSlot.HAND));
+    }
+
+    private static ClickEvent.Custom abilityButton(FantasyStickLifecycleNativeTest.Actor actor, String label, String ability) {
+        var book = org.bukkit.craftbukkit.inventory.CraftItemStack.asNMSCopy(actor.books.getLast())
+            .get(net.minecraft.core.component.DataComponents.WRITTEN_BOOK_CONTENT);
+        assertNotNull(book);
+        for (var page : book.pages()) { var found = abilityButton(page.raw(), label, ability); if (found != null) return found; }
+        throw new AssertionError("Missing " + label + " action for " + ability);
+    }
+    private static ClickEvent.Custom abilityButton(net.minecraft.network.chat.Component component, String label, String ability) {
+        if (component.getString().equals(label) && component.getStyle().getClickEvent() instanceof ClickEvent.Custom custom
+                && custom.payload().orElse(null) instanceof net.minecraft.nbt.StringTag payload
+                && payload.value().contains(":" + ability)) return custom;
+        for (var child : component.getSiblings()) { var found = abilityButton(child, label, ability); if (found != null) return found; }
+        return null;
+    }
+
+    private static void withSecondWind(Path data, FantasyStickLifecycleNativeTest.Actor actor,
+                                       boolean learned, BigDecimal health) throws Exception {
+        java.nio.file.Files.createDirectories(data);
+        var repository = new games.dmg.fantasystick.persistence.YamlCharacterRepository(data);
+        var old = repository.load(actor.core.record.id()).orElseThrow();
+        var stats = new EnumMap<>(old.stats()); stats.put(Stat.CON, BigInteger.valueOf(12)); stats.put(Stat.WIS, BigInteger.valueOf(12));
+        repository.replace(new CharacterRecord(old.id(), old.name(), old.revision().add(BigInteger.ONE), stats,
+            old.level(), old.experience(), BigInteger.valueOf(learned ? 39 : 40), health,
+            learned ? java.util.Set.of("second_wind") : old.learned(),
+            learned ? List.of("second_wind", "", "", "", "", "", "") : old.loadout(),
+            old.cooldowns(), old.restrictedKills(), false, null, null), old.revision());
+    }
+}

src/nativeTest/java/games/dmg/fantasystick/SheetResourcePackNativeTest.java

@@ -0,0 +1,11 @@
+package games.dmg.fantasystick;
+import static org.junit.jupiter.api.Assertions.*;import static org.mockito.ArgumentMatchers.*;import static org.mockito.Mockito.*;import java.nio.file.Path;import java.util.*;import net.kyori.adventure.text.Component;import org.bukkit.event.player.PlayerResourcePackStatusEvent;import org.junit.jupiter.api.BeforeAll;import org.junit.jupiter.api.Test;import org.junit.jupiter.api.io.TempDir;
+class SheetResourcePackNativeTest{@TempDir Path data;@BeforeAll static void bootstrap()throws Exception{NativeRuntime.bootstrap();}
+ record Request(UUID id,String url,byte[] hash,String prompt,boolean required){}
+ @Test void packagedStartupJoinAndStatusesUseOptionalNativeDeliveryWithoutGameplayMutation()throws Exception{try(var f=new FantasyStickLifecycleNativeTest.Fixture(data)){var a=new FantasyStickLifecycleNativeTest.Actor(data);a.core.inventory.setItemInOffHand(null);f.players.put(a.core.id,a.player);var before=a.core.snapshot();f.plugin.setEnabled(true);f.awaitCharacterAndReceipt(a);PartyBookNativeTest.drain(f);assertEquals(1,a.resourcePacks.size());var request=request(a.resourcePacks.getFirst());assertEquals(games.dmg.fantasystick.presentation.SheetResourcePack.ID,request.id());assertEquals(games.dmg.fantasystick.persistence.SheetResourcePackSettings.packagedDefaults().url(),request.url());assertEquals(20,request.hash().length);assertFalse(request.required());assertArrayEquals(before,a.core.snapshot());for(var status:List.of(PlayerResourcePackStatusEvent.Status.DECLINED,PlayerResourcePackStatusEvent.Status.FAILED_DOWNLOAD,PlayerResourcePackStatusEvent.Status.INVALID_URL,PlayerResourcePackStatusEvent.Status.FAILED_RELOAD,PlayerResourcePackStatusEvent.Status.DISCARDED)){f.dispatcher.accept(new PlayerResourcePackStatusEvent(a.player,request.id(),status));assertTrue(a.messages.getLast().toLowerCase().contains("cosmetic"));assertArrayEquals(before,a.core.snapshot());}int messages=a.messages.size();f.dispatcher.accept(new PlayerResourcePackStatusEvent(a.player,request.id(),PlayerResourcePackStatusEvent.Status.ACCEPTED));f.dispatcher.accept(new PlayerResourcePackStatusEvent(a.player,request.id(),PlayerResourcePackStatusEvent.Status.DOWNLOADED));f.dispatcher.accept(new PlayerResourcePackStatusEvent(a.player,request.id(),PlayerResourcePackStatusEvent.Status.SUCCESSFULLY_LOADED));assertEquals(messages,a.messages.size());var active=new FantasyStickLifecycleNativeTest.Actor(data);f.players.put(active.core.id,active.player);var legacyMeta=active.core.inventory.getItemInOffHand().getItemMeta();legacyMeta.setItemModel(null);active.core.inventory.getItemInOffHand().setItemMeta(legacyMeta);var activeBefore=active.core.snapshot();var expectedMeta=activeBefore[40].getItemMeta();expectedMeta.setItemModel(games.dmg.fantasystick.items.CharacterSheets.MODEL);activeBefore[40].setItemMeta(expectedMeta);var sessions=(games.dmg.fantasystick.session.EquipmentSessions)FantasyStickLifecycleNativeTest.Fixture.field(f.plugin,"sessions");sessions.enter(active.player);awaitPacked(f,active);assertEquals(games.dmg.fantasystick.items.CharacterSheets.MODEL,active.core.inventory.getItemInOffHand().getItemMeta().getItemModel());sessions.exit(active.player);f.awaitCharacterAndReceipt(active);assertArrayEquals(activeBefore,active.core.snapshot());var retained=(games.dmg.fantasystick.presentation.SheetResourcePack)FantasyStickLifecycleNativeTest.Fixture.field(f.plugin,"sheetResourcePack");f.plugin.setEnabled(false);retained.status(new PlayerResourcePackStatusEvent(a.player,request.id(),PlayerResourcePackStatusEvent.Status.DECLINED));assertEquals(messages,a.messages.size());f.plugin.setEnabled(true);var late=new FantasyStickLifecycleNativeTest.Actor(data);f.players.put(late.core.id,late.player);f.dispatcher.accept(new org.bukkit.event.player.PlayerJoinEvent(late.player,(Component)null));assertEquals(1,late.resourcePacks.size());}}
+ @Test void invalidStartupAndFailedRegisteredWriteNeverDeliverOrChangeEffectiveDefaults()throws Exception{int route=0;for(String value:List.of("sheet-resource-pack-url: 'http://bad.test/x.zip'\n","sheet-resource-pack-sha1: bad\n")){var dir=data.resolve("invalid-"+route++);java.nio.file.Files.createDirectories(dir);java.nio.file.Files.writeString(dir.resolve("config.yml"),value);try(var f=new FantasyStickLifecycleNativeTest.Fixture(dir)){assertThrows(IllegalArgumentException.class,()->f.plugin.setEnabled(true));assertTrue(f.order.isEmpty(),"native registration order "+f.order);assertTrue(f.tasks.isEmpty(),"queued tasks");}}var failed=data.resolve("failed");java.nio.file.Files.createDirectories(failed);try(var f=new FantasyStickLifecycleNativeTest.Fixture(failed)){f.plugin.setEnabled(true);var a=new FantasyStickLifecycleNativeTest.Actor(failed);f.players.put(a.core.id,a.player);java.nio.file.Files.createDirectory(failed.resolve("config.yml"));var sender=new EquipmentAdminCommandNativeTest.Sender();f.command.execute(sender.port,"fantasystick",new String[]{"config","sheet-resource-pack-url","https://packs.example.test/x.zip"});var callback=f.tasks.poll(5,java.util.concurrent.TimeUnit.SECONDS);assertNotNull(callback);callback.run();assertTrue(sender.messages.getLast().contains("save failed"),sender.messages::toString);assertTrue(a.resourcePacks.isEmpty());f.command.execute(sender.port,"fantasystick",new String[]{"config","sheet-resource-pack-url"});assertTrue(sender.messages.getLast().contains("git.garvis.dev"));}}
+ @Test void registeredConfigurationDurablyPublishesAndRedeliversWhileFailureRetainsPair()throws Exception{try(var f=new FantasyStickLifecycleNativeTest.Fixture(data)){f.plugin.setEnabled(true);var a=new FantasyStickLifecycleNativeTest.Actor(data);f.players.put(a.core.id,a.player);var sender=new EquipmentAdminCommandNativeTest.Sender();assertEquals(List.of("sheet-resource-pack-sha1","sheet-resource-pack-url"),f.command.tabComplete(sender.port,"fantasystick",new String[]{"config","sheet-r"}));assertEquals(1,f.command.tabComplete(sender.port,"fantasystick",new String[]{"config","sheet-resource-pack-url",""}).size());sender.allowed=false;assertTrue(f.command.tabComplete(sender.port,"fantasystick",new String[]{"config","sheet-r"}).isEmpty());f.command.execute(sender.port,"fantasystick",new String[]{"config","sheet-resource-pack-url","https://packs.example.test/sheet.zip"});assertTrue(sender.messages.getLast().contains("Permission denied"));sender.allowed=true;f.command.execute(sender.port,"fantasystick",new String[]{"config","sheet-resource-pack-url","https://packs.example.test/x.zip","extra"});assertTrue(sender.messages.getLast().contains("Usage"));for(var pair:List.of(new String[]{"sheet-resource-pack-url","http://bad.test/x.zip"},new String[]{"sheet-resource-pack-sha1","bad"})){f.command.execute(sender.port,"fantasystick",new String[]{"config",pair[0],pair[1]});assertTrue(sender.messages.getLast().contains("invalid"));}save(f,sender,"sheet-resource-pack-url","https://packs.example.test/sheet.zip");assertEquals(1,a.resourcePacks.size());assertEquals("https://packs.example.test/sheet.zip",request(a.resourcePacks.getLast()).url());save(f,sender,"sheet-resource-pack-sha1","a".repeat(40));assertEquals(2,a.resourcePacks.size());assertArrayEquals(java.util.HexFormat.of().parseHex("a".repeat(40)),request(a.resourcePacks.getLast()).hash());f.plugin.setEnabled(false);f.plugin.setEnabled(true);f.command.execute(sender.port,"fantasystick",new String[]{"config","sheet-resource-pack-url"});assertTrue(sender.messages.getLast().contains("https://packs.example.test/sheet.zip"));}}
+ static void awaitPacked(FantasyStickLifecycleNativeTest.Fixture f,FantasyStickLifecycleNativeTest.Actor actor)throws Exception{long deadline=System.nanoTime()+java.util.concurrent.TimeUnit.SECONDS.toNanos(10);while(System.nanoTime()<deadline){var marker=actor.core.marker();if(marker!=null&&marker.endsWith("|PACKED"))return;var task=f.tasks.poll(100,java.util.concurrent.TimeUnit.MILLISECONDS);if(task!=null)task.run();}fail("Session did not activate; notices="+actor.messages);}
+ static Request request(Object[] args){return new Request((UUID)args[0],(String)args[1],(byte[])args[2],(String)args[3],(Boolean)args[4]);}
+ static void save(FantasyStickLifecycleNativeTest.Fixture f,EquipmentAdminCommandNativeTest.Sender sender,String key,String value)throws Exception{int before=sender.messages.size();f.command.execute(sender.port,"fantasystick",new String[]{"config",key,value});assertEquals(before,sender.messages.size());while(sender.messages.size()==before){var task=f.tasks.poll(5,java.util.concurrent.TimeUnit.SECONDS);assertNotNull(task);task.run();}assertTrue(sender.messages.getLast().contains("Saved "+key));}
+}

src/nativeTest/java/games/dmg/fantasystick/ShieldBashNativeTest.java

@@ -0,0 +1,329 @@
+package games.dmg.fantasystick;
+
+import static org.junit.jupiter.api.Assertions.*;
+import static org.mockito.ArgumentMatchers.*;
+import static org.mockito.Mockito.*;
+
+import games.dmg.fantasystick.persistence.CharacterRecord;
+import games.dmg.fantasystick.persistence.CharacterStorage;
+import games.dmg.fantasystick.progression.Stat;
+import java.math.BigInteger;
+import java.nio.file.Path;
+import java.util.EnumMap;
+import java.util.List;
+import net.minecraft.network.chat.ClickEvent;
+import org.bukkit.Location;
+import org.bukkit.event.entity.EntityDamageByEntityEvent;
+import org.bukkit.event.entity.EntityDamageEvent;
+import org.bukkit.util.Vector;
+import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.io.TempDir;
+
+class ShieldBashNativeTest {
+    @TempDir Path data;
+    @BeforeAll static void bootstrap() throws Exception { NativeRuntime.bootstrap(); }
+
+    @Test void bookAcquisitionAndEquippedAttackReplaceVanillaDamageThenKnockBack() throws Exception {
+        try (var f = new FantasyStickLifecycleNativeTest.Fixture(data)) {
+            f.plugin.setEnabled(true);
+            var a = new FantasyStickLifecycleNativeTest.Actor(data); withShieldBash(data, a, false);
+            f.players.put(a.core.id, a.player); f.activate(a);
+            a.core.inventory.getInventory().setSelectedSlot(0); PartyBookNativeTest.open(f, a);
+            String book = PartyBookNativeTest.text(a).replaceAll("\\s+", "");
+            assertTrue(book.contains("ShieldBash")); assertTrue(book.contains("STR12")); assertTrue(book.contains("CON12"));
+            assertTrue(book.contains("Cost:1")); assertTrue(book.contains("3")); assertTrue(book.contains("6s"));
+            PartyBookNativeTest.click(f, a, abilityButton(a, "[Learn]", "shield_bash"));
+            PartyBookNativeTest.drain(f); PartyBookNativeTest.drain(f);
+            PartyBookNativeTest.click(f, a, abilityButton(a, "[3]", "shield_bash"));
+            PartyBookNativeTest.drain(f); PartyBookNativeTest.drain(f);
+            var storage = (CharacterStorage) FantasyStickLifecycleNativeTest.Fixture.field(f.plugin, "characters");
+            assertEquals(BigInteger.valueOf(39), storage.find(a.core.record.id()).get().orElseThrow().unspentPoints());
+            assertEquals(org.bukkit.Material.SHIELD, a.core.inventory.getItem(2).getType());
+            a.core.inventory.getInventory().setSelectedSlot(2);
+            var block = new org.bukkit.event.player.PlayerInteractEvent(a.player,
+                org.bukkit.event.block.Action.RIGHT_CLICK_AIR, a.core.inventory.getItem(2), null,
+                org.bukkit.block.BlockFace.SELF, org.bukkit.inventory.EquipmentSlot.HAND);
+            f.dispatcher.accept(block); assertTrue(block.isCancelled(), "Contained shield cannot start ordinary blocking");
+            assertFalse(storage.find(a.core.record.id()).get().orElseThrow().cooldowns().containsKey("shield_bash"));
+
+            var target = mock(org.bukkit.entity.LivingEntity.class);
+            when(target.getUniqueId()).thenReturn(java.util.UUID.randomUUID()); when(target.getType()).thenReturn(org.bukkit.entity.EntityType.ZOMBIE);
+            when(a.world.getUID()).thenReturn(java.util.UUID.randomUUID());
+            var origin = new Location(a.world, 0, 64, 0); var destination = new Location(a.world, 2, 64, 0);
+            doReturn(origin).when(a.player).getLocation(); when(target.getLocation()).thenReturn(destination);
+            doReturn(true).when(a.player).hasLineOfSight(target); when(target.getVelocity()).thenReturn(new Vector(0.1, 0.2, 0));
+            var applied = new java.util.concurrent.atomic.AtomicReference<Vector>();
+            doAnswer(call -> { applied.set(call.getArgument(0)); return null; }).when(target).setVelocity(any(Vector.class));
+            var damages = new java.util.ArrayList<EntityDamageByEntityEvent>();
+            doAnswer(call -> {
+                var source = (org.bukkit.damage.DamageSource) call.getArgument(1);
+                var event = new EntityDamageByEntityEvent(a.player, target, EntityDamageEvent.DamageCause.ENTITY_ATTACK,
+                    source, (Double) call.getArgument(0)); damages.add(event); f.dispatcher.accept(event); return null;
+            }).when(target).damage(anyDouble(), any(org.bukkit.damage.DamageSource.class));
+            a.core.inventory.getInventory().setSelectedSlot(2);
+            var attack = new io.papermc.paper.event.player.PrePlayerAttackEntityEvent(a.player, target, true);
+            f.dispatcher.accept(attack); PartyBookNativeTest.drain(f); PartyBookNativeTest.drain(f);
+            assertTrue(attack.isCancelled(), "Contained shield cannot continue into vanilla damage/blocking");
+            assertEquals(1, damages.size()); assertEquals(5, damages.getFirst().getDamage(), 1.0e-9);
+            assertEquals(new Vector(0.9, 0.35, 0), applied.get());
+            assertNotNull(storage.find(a.core.record.id()).get().orElseThrow().cooldowns().get("shield_bash"));
+            f.dispatcher.accept(new org.bukkit.event.entity.EntityDeathEvent(target, damages.getFirst().getDamageSource(),
+                new java.util.ArrayList<>(), 0)); PartyBookNativeTest.drain(f); PartyBookNativeTest.drain(f);
+            assertEquals(BigInteger.TEN, storage.find(a.core.record.id()).get().orElseThrow().experience());
+            f.dispatcher.accept(new io.papermc.paper.event.player.PrePlayerAttackEntityEvent(a.player, target, true));
+            PartyBookNativeTest.drain(f); assertEquals(1, damages.size());
+            assertTrue(a.messages.stream().anyMatch(message -> message.contains("ready in")));
+        }
+    }
+
+    @Test void outOfRangeOrObstructedTargetRefusesBeforeCooldownWhileStillContainingShield() throws Exception {
+        for (int route = 0; route < 2; route++) {
+            var directory = data.resolve("refused-" + route);
+            try (var f = new FantasyStickLifecycleNativeTest.Fixture(directory)) {
+                f.plugin.setEnabled(true); var a = new FantasyStickLifecycleNativeTest.Actor(directory);
+                withShieldBash(directory, a, true); f.players.put(a.core.id, a.player); f.activate(a);
+                var target = mock(org.bukkit.entity.LivingEntity.class);
+                when(target.getUniqueId()).thenReturn(java.util.UUID.randomUUID()); when(target.getType()).thenReturn(org.bukkit.entity.EntityType.ZOMBIE);
+                doReturn(new Location(a.world, 0, 64, 0)).when(a.player).getLocation();
+                when(target.getLocation()).thenReturn(new Location(a.world, route == 0 ? 4 : 2, 64, 0));
+                doReturn(route == 0).when(a.player).hasLineOfSight(target);
+                a.core.inventory.getInventory().setSelectedSlot(2);
+                var attack = new io.papermc.paper.event.player.PrePlayerAttackEntityEvent(a.player, target, true);
+                f.dispatcher.accept(attack); assertTrue(attack.isCancelled());
+                verify(target, never()).damage(anyDouble(), any(org.bukkit.damage.DamageSource.class));
+                var storage = (CharacterStorage) FantasyStickLifecycleNativeTest.Fixture.field(f.plugin, "characters");
+                assertFalse(storage.find(a.core.record.id()).get().orElseThrow().cooldowns().containsKey("shield_bash"));
+            }
+        }
+    }
+
+    @Test void partyAndMixedModePlayerTargetsAreRefusedWithoutFreeVanillaHits() throws Exception {
+        try(var f=new FantasyStickLifecycleNativeTest.Fixture(data)){
+            f.plugin.setEnabled(true);var a=new FantasyStickLifecycleNativeTest.Actor(data);var b=new FantasyStickLifecycleNativeTest.Actor(data);
+            withShieldBash(data,a,true);f.players.put(a.core.id,a.player);f.players.put(b.core.id,b.player);f.activate(a);f.activate(b);
+            var parties=PartyLifecycleNativeTest.parties(f);var party=parties.create(a.core.id).orElseThrow();
+            assertTrue(parties.accept(b.core.id,parties.invite(a.core.id,party.id(),b.core.id).orElseThrow().id()));
+            a.core.inventory.getInventory().setSelectedSlot(2);
+            var friendly=new io.papermc.paper.event.player.PrePlayerAttackEntityEvent(a.player,b.player,true);f.dispatcher.accept(friendly);
+            assertTrue(friendly.isCancelled());verify(b.player,never()).damage(anyDouble(),any(org.bukkit.damage.DamageSource.class));
+            var ordinary=mock(org.bukkit.entity.Player.class);when(ordinary.getUniqueId()).thenReturn(java.util.UUID.randomUUID());
+            var mixed=new io.papermc.paper.event.player.PrePlayerAttackEntityEvent(a.player,ordinary,true);f.dispatcher.accept(mixed);
+            assertTrue(mixed.isCancelled());verify(ordinary,never()).damage(anyDouble(),any(org.bukkit.damage.DamageSource.class));
+            var storage=(CharacterStorage)FantasyStickLifecycleNativeTest.Fixture.field(f.plugin,"characters");
+            assertFalse(storage.find(a.core.record.id()).get().orElseThrow().cooldowns().containsKey("shield_bash"));
+        }
+    }
+
+    @Test void cancelledDamageAppliesNoKnockbackAndNeverRefundsAcknowledgedCooldown() throws Exception {
+        try (var f = new FantasyStickLifecycleNativeTest.Fixture(data)) {
+            f.plugin.setEnabled(true); var a = new FantasyStickLifecycleNativeTest.Actor(data);
+            withShieldBash(data, a, true); f.players.put(a.core.id, a.player); f.activate(a);
+            var target = mock(org.bukkit.entity.LivingEntity.class); when(target.getUniqueId()).thenReturn(java.util.UUID.randomUUID());
+            when(target.getType()).thenReturn(org.bukkit.entity.EntityType.ZOMBIE);
+            doReturn(new Location(a.world, 0, 64, 0)).when(a.player).getLocation();
+            when(target.getLocation()).thenReturn(new Location(a.world, 2, 64, 0)); doReturn(true).when(a.player).hasLineOfSight(target);
+            doAnswer(call -> {
+                var source = (org.bukkit.damage.DamageSource) call.getArgument(1);
+                var event = new EntityDamageByEntityEvent(a.player, target, EntityDamageEvent.DamageCause.ENTITY_ATTACK,
+                    source, (Double) call.getArgument(0)); event.setCancelled(true); f.dispatcher.accept(event); return null;
+            }).when(target).damage(anyDouble(), any(org.bukkit.damage.DamageSource.class));
+            a.core.inventory.getInventory().setSelectedSlot(2);
+            f.dispatcher.accept(new io.papermc.paper.event.player.PrePlayerAttackEntityEvent(a.player, target, true));
+            PartyBookNativeTest.drain(f); PartyBookNativeTest.drain(f); verify(target, never()).setVelocity(any(Vector.class));
+            var storage = (CharacterStorage) FantasyStickLifecycleNativeTest.Fixture.field(f.plugin, "characters");
+            assertNotNull(storage.find(a.core.record.id()).get().orElseThrow().cooldowns().get("shield_bash"));
+        }
+    }
+
+    @Test void cancelledPlayerVelocityPreservesMovementAfterAcceptedDamage() throws Exception {
+        try (var f = new FantasyStickLifecycleNativeTest.Fixture(data)) {
+            f.plugin.setEnabled(true); var a = new FantasyStickLifecycleNativeTest.Actor(data);
+            var b = new FantasyStickLifecycleNativeTest.Actor(data); withShieldBash(data, a, true);
+            f.players.put(a.core.id, a.player); f.players.put(b.core.id, b.player); f.activate(a); f.activate(b);
+            doReturn(new Location(a.world, 0, 64, 0)).when(a.player).getLocation();
+            doReturn(new Location(a.world, 2, 64, 0)).when(b.player).getLocation();
+            doReturn(true).when(a.player).hasLineOfSight(b.player); doReturn(new Vector(0.1, 0.2, 0)).when(b.player).getVelocity();
+            class Veto implements org.bukkit.event.Listener {
+                @org.bukkit.event.EventHandler public void velocity(org.bukkit.event.player.PlayerVelocityEvent event) {
+                    if (event.getPlayer() == b.player) event.setCancelled(true);
+                }
+            }
+            f.dispatcher.register(new Veto(), f.plugin);
+            doAnswer(call -> {
+                var source = (org.bukkit.damage.DamageSource) call.getArgument(1);
+                f.dispatcher.accept(new EntityDamageByEntityEvent(a.player, b.player, EntityDamageEvent.DamageCause.ENTITY_ATTACK,
+                    source, (Double) call.getArgument(0))); return null;
+            }).when(b.player).damage(anyDouble(), any(org.bukkit.damage.DamageSource.class));
+            a.core.inventory.getInventory().setSelectedSlot(2);
+            f.dispatcher.accept(new io.papermc.paper.event.player.PrePlayerAttackEntityEvent(a.player, b.player, true));
+            PartyBookNativeTest.drain(f); PartyBookNativeTest.drain(f); verify(b.player, never()).setVelocity(any(Vector.class));
+        }
+    }
+
+    @Test void unlearnRelearnAndCharacterTransferRetainCooldown() throws Exception {
+        java.nio.file.Files.writeString(data.resolve("config.yml"), "shield-bash-cooldown-seconds: 60\n");
+        try (var f = new FantasyStickLifecycleNativeTest.Fixture(data)) {
+            f.plugin.setEnabled(true); var a = new FantasyStickLifecycleNativeTest.Actor(data);
+            withShieldBash(data, a, true); f.players.put(a.core.id, a.player); f.activate(a);
+            var target = mock(org.bukkit.entity.LivingEntity.class); when(target.getUniqueId()).thenReturn(java.util.UUID.randomUUID());
+            when(target.getType()).thenReturn(org.bukkit.entity.EntityType.ZOMBIE);
+            doReturn(new Location(a.world, 0, 64, 0)).when(a.player).getLocation();
+            when(target.getLocation()).thenReturn(new Location(a.world, 2, 64, 0)); doReturn(true).when(a.player).hasLineOfSight(target);
+            when(target.getVelocity()).thenReturn(new Vector()); var hits = new java.util.concurrent.atomic.AtomicInteger();
+            doAnswer(call -> { hits.incrementAndGet(); var source = (org.bukkit.damage.DamageSource) call.getArgument(1);
+                f.dispatcher.accept(new EntityDamageByEntityEvent(a.player, target, EntityDamageEvent.DamageCause.ENTITY_ATTACK,
+                    source, (Double) call.getArgument(0))); return null; }).when(target).damage(anyDouble(), any(org.bukkit.damage.DamageSource.class));
+            a.core.inventory.getInventory().setSelectedSlot(2);
+            f.dispatcher.accept(new io.papermc.paper.event.player.PrePlayerAttackEntityEvent(a.player, target, true));
+            PartyBookNativeTest.drain(f); PartyBookNativeTest.drain(f); assertEquals(1, hits.get());
+            var storage = (CharacterStorage) FantasyStickLifecycleNativeTest.Fixture.field(f.plugin, "characters");
+            var deadline = storage.find(a.core.record.id()).get().orElseThrow().cooldowns().get("shield_bash");
+            a.core.inventory.getInventory().setSelectedSlot(0); PartyBookNativeTest.open(f, a);
+            var unlearn = abilityButton(a, "[Unlearn]", "shield_bash");
+            PartyBookNativeTest.click(f, a, unlearn); PartyBookNativeTest.click(f, a, unlearn);
+            PartyBookNativeTest.drain(f); PartyBookNativeTest.drain(f);
+            var refunded = storage.find(a.core.record.id()).get().orElseThrow();
+            assertEquals(BigInteger.valueOf(40), refunded.unspentPoints()); assertEquals(deadline, refunded.cooldowns().get("shield_bash"));
+            learnAndAssign(f, a); a.core.inventory.getInventory().setSelectedSlot(2);
+            f.dispatcher.accept(new io.papermc.paper.event.player.PrePlayerAttackEntityEvent(a.player, target, true));
+            PartyBookNativeTest.drain(f); assertEquals(1, hits.get());
+            var sheet = a.core.inventory.getItemInOffHand().clone();
+            a.core.inventory.setItemInOffHand(null); f.changed(a); PartyBookNativeTest.drain(f); f.awaitCharacterAndReceipt(a);
+            var b = new FantasyStickLifecycleNativeTest.Actor(data); b.core.inventory.setItemInOffHand(sheet);
+            f.players.put(b.core.id, b.player); f.activate(b); b.core.inventory.getInventory().setSelectedSlot(2);
+            doReturn(new Location(a.world, 0, 64, 0)).when(b.player).getLocation(); doReturn(true).when(b.player).hasLineOfSight(target);
+            f.dispatcher.accept(new io.papermc.paper.event.player.PrePlayerAttackEntityEvent(b.player, target, true));
+            PartyBookNativeTest.drain(f); assertEquals(1, hits.get()); assertEquals(deadline,
+                storage.find(a.core.record.id()).get().orElseThrow().cooldowns().get("shield_bash"));
+        }
+    }
+
+    @Test void exactDamageFormulaSupportsFiniteUncappedStats() {
+        assertEquals(BigInteger.valueOf(5), games.dmg.fantasystick.ability.ShieldBash.damage(BigInteger.valueOf(12)));
+        assertEquals(BigInteger.valueOf(3), games.dmg.fantasystick.ability.ShieldBash.damage(BigInteger.valueOf(9)));
+        var huge = BigInteger.TEN.pow(500);
+        assertEquals(huge.subtract(BigInteger.TEN).divide(BigInteger.TWO).add(BigInteger.valueOf(4)),
+            games.dmg.fantasystick.ability.ShieldBash.damage(huge));
+    }
+
+    @Test void failedCooldownPersistenceDealsNoDamageOrKnockback() {
+        var storage=mock(CharacterStorage.class);var sessions=mock(games.dmg.fantasystick.session.EquipmentSessions.class);
+        var parties=new games.dmg.fantasystick.party.PartyRoster(java.time.Clock.systemUTC(),ignored->true);
+        var registry=new games.dmg.fantasystick.ability.AbilityRegistry();var bash=new games.dmg.fantasystick.ability.ShieldBash(
+            games.dmg.fantasystick.ability.ShieldBash.Settings.defaults(),ignored->{});registry.register(bash.definition());
+        var base=new games.dmg.fantasystick.crafting.CharacterFactory().create(games.dmg.fantasystick.progression.ProgressionRules.defaults());
+        var stats=new EnumMap<>(base.stats());stats.put(Stat.STR,BigInteger.valueOf(12));stats.put(Stat.CON,BigInteger.valueOf(12));
+        var record=new CharacterRecord(base.id(),base.name(),base.revision(),stats,base.level(),base.experience(),base.unspentPoints(),base.health(),
+            java.util.Set.of("shield_bash"),List.of("shield_bash","","","","","",""),base.cooldowns(),base.restrictedKills(),false,null,null);
+        var active=new games.dmg.fantasystick.session.EquipmentSessions.Active(java.util.UUID.randomUUID(),java.util.UUID.randomUUID(),record.id());
+        var player=mock(org.bukkit.entity.Player.class);when(player.getUniqueId()).thenReturn(active.player());
+        var world=mock(org.bukkit.World.class);doReturn(new Location(world,0,64,0)).when(player).getLocation();
+        var target=mock(org.bukkit.entity.LivingEntity.class);when(target.getUniqueId()).thenReturn(java.util.UUID.randomUUID());
+        when(target.getType()).thenReturn(org.bukkit.entity.EntityType.ZOMBIE);when(target.getLocation()).thenReturn(new Location(world,2,64,0));
+        doReturn(true).when(player).hasLineOfSight(target);when(sessions.current(active)).thenReturn(true);
+        when(sessions.currentRecord(active)).thenReturn(java.util.Optional.of(record));
+        var failed=new java.util.concurrent.CompletableFuture<CharacterStorage.AbilityMutation>();
+        failed.completeExceptionally(new java.io.IOException("simulated cooldown failure"));
+        when(storage.commitAbilityCooldown(eq(record.id()),eq(record.revision()),eq("shield_bash"),any())).thenReturn(failed);
+        var engine=new games.dmg.fantasystick.ability.AbilityEngine(registry,storage,sessions,parties,java.time.Clock.systemUTC(),Runnable::run,
+            (delay,action)->()->{},ignored->{},ignored->{});
+        engine.accept(new games.dmg.fantasystick.session.ControlInput(player,active,2,"shield_bash",
+            games.dmg.fantasystick.session.ControlInput.Kind.ABILITY,games.dmg.fantasystick.session.ControlInput.Gesture.ATTACK,
+            target,0,1,()->true));
+        verify(storage).commitAbilityCooldown(eq(record.id()),eq(record.revision()),eq("shield_bash"),any());
+        verify(target,never()).damage(anyDouble(),any(org.bukkit.damage.DamageSource.class));verify(target,never()).setVelocity(any(Vector.class));
+        engine.close();bash.close();parties.close();
+    }
+
+    @Test void configuredDefinitionAdminRoutesRestartAndFutureStrikeCoverEverySetting() throws Exception {
+        java.nio.file.Files.writeString(data.resolve("config.yml"),
+            "shield-bash-base-damage: 8\nshield-bash-cooldown-seconds: 0\nshield-bash-range-blocks: 5\n" +
+            "shield-bash-horizontal-knockback: 1.2\nshield-bash-minimum-vertical-knockback: 0.5\n");
+        try (var f = new FantasyStickLifecycleNativeTest.Fixture(data)) {
+            f.plugin.setEnabled(true); var registry = (games.dmg.fantasystick.ability.AbilityRegistry)
+                FantasyStickLifecycleNativeTest.Fixture.field(f.plugin, "abilityRegistry");
+            var definition = registry.find("shield_bash").orElseThrow(); assertEquals(java.time.Duration.ZERO, definition.cooldown());
+            assertEquals(0, new java.math.BigDecimal("8").compareTo(definition.parameters().get("base-damage")));
+            assertEquals(0, new java.math.BigDecimal("5").compareTo(definition.parameters().get("range")));
+            assertEquals(0, new java.math.BigDecimal("1.2").compareTo(definition.parameters().get("horizontal-knockback")));
+            assertEquals(0, new java.math.BigDecimal("0.5").compareTo(definition.parameters().get("minimum-vertical-knockback")));
+            var sender = new EquipmentAdminCommandNativeTest.Sender(); sender.allowed=false;
+            assertTrue(f.command.tabComplete(sender.port,"fantasystick",new String[]{"config","shield-bash"}).isEmpty());
+            f.command.execute(sender.port,"fantasystick",new String[]{"config","shield-bash-base-damage","9"});
+            assertTrue(sender.messages.getLast().contains("Permission denied")); sender.allowed=true;
+            assertEquals(List.of("shield-bash-base-damage","shield-bash-cooldown-seconds","shield-bash-horizontal-knockback",
+                "shield-bash-minimum-vertical-knockback","shield-bash-range-blocks"),
+                f.command.tabComplete(sender.port,"fantasystick",new String[]{"config","shield-bash-"}));
+            assertEquals(List.of("4","8"),f.command.tabComplete(sender.port,"fantasystick",
+                new String[]{"config","shield-bash-base-damage",""}));
+            f.command.execute(sender.port,"fantasystick",new String[]{"config","shield-bash-base-damage"});
+            assertTrue(sender.messages.getLast().contains("=8"));
+            f.command.execute(sender.port,"fantasystick",new String[]{"config","shield-bash-base-damage","9"});
+            var response=f.tasks.poll(5,java.util.concurrent.TimeUnit.SECONDS);assertNotNull(response);response.run();
+            assertEquals(0,new java.math.BigDecimal("9").compareTo(registry.find("shield_bash").orElseThrow().parameters().get("base-damage")));
+            var a=new FantasyStickLifecycleNativeTest.Actor(data);withShieldBash(data,a,true);f.players.put(a.core.id,a.player);f.activate(a);
+            var target=mock(org.bukkit.entity.LivingEntity.class);when(target.getUniqueId()).thenReturn(java.util.UUID.randomUUID());
+            when(target.getType()).thenReturn(org.bukkit.entity.EntityType.ZOMBIE);
+            doReturn(new Location(a.world,0,64,0)).when(a.player).getLocation();when(target.getLocation()).thenReturn(new Location(a.world,4,64,0));
+            doReturn(true).when(a.player).hasLineOfSight(target);when(target.getVelocity()).thenReturn(new Vector());
+            var amount=new java.util.concurrent.atomic.AtomicReference<Double>();var movement=new java.util.concurrent.atomic.AtomicReference<Vector>();
+            doAnswer(call->{amount.set(call.getArgument(0));var source=(org.bukkit.damage.DamageSource)call.getArgument(1);
+                f.dispatcher.accept(new EntityDamageByEntityEvent(a.player,target,EntityDamageEvent.DamageCause.ENTITY_ATTACK,source,(Double)call.getArgument(0)));return null;
+            }).when(target).damage(anyDouble(),any(org.bukkit.damage.DamageSource.class));
+            doAnswer(call->{movement.set(call.getArgument(0));return null;}).when(target).setVelocity(any(Vector.class));
+            a.core.inventory.getInventory().setSelectedSlot(2);f.dispatcher.accept(new io.papermc.paper.event.player.PrePlayerAttackEntityEvent(a.player,target,true));
+            PartyBookNativeTest.drain(f);PartyBookNativeTest.drain(f);assertEquals(10,amount.get(),1.0e-9);assertEquals(new Vector(1.2,0.5,0),movement.get());
+            f.command.execute(sender.port,"fantasystick",new String[]{"config","shield-bash-base-damage","-1"});
+            assertTrue(sender.messages.getLast().contains("invalid"));
+            f.command.execute(sender.port,"fantasystick",new String[]{"config","shield-bash-base-damage","9","extra"});
+            assertTrue(sender.messages.getLast().contains("Usage"));
+            f.plugin.setEnabled(false);f.plugin.setEnabled(true);var reloaded=(games.dmg.fantasystick.ability.AbilityRegistry)
+                FantasyStickLifecycleNativeTest.Fixture.field(f.plugin,"abilityRegistry");
+            assertEquals(0,new java.math.BigDecimal("9").compareTo(reloaded.find("shield_bash").orElseThrow().parameters().get("base-damage")));
+        }
+        for(String invalid:List.of("shield-bash-base-damage: -1\n","shield-bash-cooldown-seconds: -1\n",
+                "shield-bash-range-blocks: 0\n","shield-bash-horizontal-knockback: 9\n",
+                "shield-bash-minimum-vertical-knockback: 9\n")){
+            var directory=data.resolve(Integer.toHexString(invalid.hashCode()));java.nio.file.Files.createDirectories(directory);
+            java.nio.file.Files.writeString(directory.resolve("config.yml"),invalid);
+            try(var f=new FantasyStickLifecycleNativeTest.Fixture(directory)){
+                assertThrows(IllegalArgumentException.class,()->f.plugin.setEnabled(true));assertTrue(f.order.isEmpty());
+            }
+        }
+    }
+
+    private static void learnAndAssign(FantasyStickLifecycleNativeTest.Fixture fixture,
+                                       FantasyStickLifecycleNativeTest.Actor actor) throws Exception {
+        actor.core.inventory.getInventory().setSelectedSlot(0); PartyBookNativeTest.open(fixture, actor);
+        PartyBookNativeTest.click(fixture, actor, abilityButton(actor, "[Learn]", "shield_bash"));
+        PartyBookNativeTest.drain(fixture); PartyBookNativeTest.drain(fixture);
+        PartyBookNativeTest.click(fixture, actor, abilityButton(actor, "[3]", "shield_bash"));
+        PartyBookNativeTest.drain(fixture); PartyBookNativeTest.drain(fixture);
+    }
+
+    private static ClickEvent.Custom abilityButton(FantasyStickLifecycleNativeTest.Actor actor, String label, String ability) {
+        var book = org.bukkit.craftbukkit.inventory.CraftItemStack.asNMSCopy(actor.books.getLast())
+            .get(net.minecraft.core.component.DataComponents.WRITTEN_BOOK_CONTENT); assertNotNull(book);
+        for (var page : book.pages()) { var found = abilityButton(page.raw(), label, ability); if (found != null) return found; }
+        throw new AssertionError("Missing " + label + " for " + ability);
+    }
+    private static ClickEvent.Custom abilityButton(net.minecraft.network.chat.Component component, String label, String ability) {
+        if (component.getString().equals(label) && component.getStyle().getClickEvent() instanceof ClickEvent.Custom custom
+                && custom.payload().orElse(null) instanceof net.minecraft.nbt.StringTag payload
+                && payload.value().contains(":" + ability)) return custom;
+        for (var child : component.getSiblings()) { var found = abilityButton(child, label, ability); if (found != null) return found; }
+        return null;
+    }
+    private static void withShieldBash(Path data, FantasyStickLifecycleNativeTest.Actor actor, boolean learned) throws Exception {
+        java.nio.file.Files.createDirectories(data);
+        var repository = new games.dmg.fantasystick.persistence.YamlCharacterRepository(data);
+        var old = repository.load(actor.core.record.id()).orElseThrow(); var stats = new EnumMap<>(old.stats());
+        stats.put(Stat.STR, BigInteger.valueOf(12)); stats.put(Stat.CON, BigInteger.valueOf(12));
+        repository.replace(new CharacterRecord(old.id(), old.name(), old.revision().add(BigInteger.ONE), stats,
+            old.level(), old.experience(), BigInteger.valueOf(learned ? 39 : 40), old.health(),
+            learned ? java.util.Set.of("shield_bash") : old.learned(),
+            learned ? List.of("shield_bash", "", "", "", "", "", "") : old.loadout(),
+            old.cooldowns(), old.restrictedKills(), false, null, null), old.revision());
+    }
+}

src/nativeTest/java/games/dmg/fantasystick/StoneSkinNativeTest.java

@@ -0,0 +1,294 @@
+package games.dmg.fantasystick;
+
+import static org.junit.jupiter.api.Assertions.*;
+import static org.mockito.Mockito.*;
+
+import games.dmg.fantasystick.persistence.CharacterRecord;
+import games.dmg.fantasystick.persistence.CharacterStorage;
+import games.dmg.fantasystick.progression.Stat;
+import java.math.BigInteger;
+import java.nio.file.Path;
+import java.util.EnumMap;
+import java.util.List;
+import net.minecraft.network.chat.ClickEvent;
+import org.bukkit.event.entity.EntityDamageByEntityEvent;
+import org.bukkit.event.entity.EntityDamageEvent;
+import org.bukkit.event.player.PlayerInteractEvent;
+import org.bukkit.inventory.EquipmentSlot;
+import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.io.TempDir;
+
+class StoneSkinNativeTest {
+    @TempDir Path data;
+    @BeforeAll static void bootstrap() throws Exception { NativeRuntime.bootstrap(); }
+
+    @Test void bookAcquisitionEquippedUseReducesNativeEntityDamageForFourSeconds() throws Exception {
+        try (var f = new FantasyStickLifecycleNativeTest.Fixture(data)) {
+            f.plugin.setEnabled(true);
+            var a = new FantasyStickLifecycleNativeTest.Actor(data); withStoneSkin(data, a, false);
+            f.players.put(a.core.id, a.player); f.activate(a);
+            a.core.inventory.getInventory().setSelectedSlot(0); PartyBookNativeTest.open(f, a);
+            String text = PartyBookNativeTest.text(a).replaceAll("\\s+", "");
+            assertTrue(text.contains("StoneSkin")); assertTrue(text.contains("CON14"));
+            assertTrue(text.contains("Cost:1")); assertTrue(text.contains("25%")); assertTrue(text.contains("4s"));
+            PartyBookNativeTest.click(f, a, abilityButton(a, "[Learn]", "stone_skin"));
+            PartyBookNativeTest.drain(f); PartyBookNativeTest.drain(f);
+            PartyBookNativeTest.click(f, a, abilityButton(a, "[3]", "stone_skin"));
+            PartyBookNativeTest.drain(f); PartyBookNativeTest.drain(f);
+            var storage = (CharacterStorage) FantasyStickLifecycleNativeTest.Fixture.field(f.plugin, "characters");
+            assertEquals(BigInteger.valueOf(39), storage.find(a.core.record.id()).get().orElseThrow().unspentPoints());
+            use(f, a); PartyBookNativeTest.drain(f); PartyBookNativeTest.drain(f);
+            assertNotNull(storage.find(a.core.record.id()).get().orElseThrow().cooldowns().get("stone_skin"));
+            var attacker = mock(org.bukkit.entity.Zombie.class);
+            var hit = new EntityDamageByEntityEvent(attacker, a.player,
+                EntityDamageEvent.DamageCause.ENTITY_ATTACK, mock(org.bukkit.damage.DamageSource.class), 8);
+            f.dispatcher.accept(hit); assertEquals(6, hit.getDamage(), 1.0e-9);
+            assertEquals(80L, f.delayedTicks.getLast());
+            f.delayed.getLast().run();
+            var expired = new EntityDamageByEntityEvent(attacker, a.player,
+                EntityDamageEvent.DamageCause.ENTITY_ATTACK, mock(org.bukkit.damage.DamageSource.class), 8);
+            f.dispatcher.accept(expired); assertEquals(8, expired.getDamage(), 1.0e-9);
+            var deadline = storage.find(a.core.record.id()).get().orElseThrow().cooldowns().get("stone_skin");
+            a.core.inventory.getInventory().setSelectedSlot(0); PartyBookNativeTest.open(f, a);
+            var unlearn = abilityButton(a, "[Unlearn]", "stone_skin");
+            PartyBookNativeTest.click(f, a, unlearn); PartyBookNativeTest.click(f, a, unlearn);
+            PartyBookNativeTest.drain(f); PartyBookNativeTest.drain(f);
+            var refunded = storage.find(a.core.record.id()).get().orElseThrow();
+            assertEquals(BigInteger.valueOf(40), refunded.unspentPoints()); assertEquals(deadline, refunded.cooldowns().get("stone_skin"));
+            a.core.inventory.getInventory().setSelectedSlot(0); PartyBookNativeTest.open(f, a);
+            PartyBookNativeTest.click(f, a, abilityButton(a, "[Learn]", "stone_skin"));
+            PartyBookNativeTest.drain(f); PartyBookNativeTest.drain(f);
+            PartyBookNativeTest.click(f, a, abilityButton(a, "[3]", "stone_skin"));
+            PartyBookNativeTest.drain(f); PartyBookNativeTest.drain(f); use(f, a);
+            assertTrue(a.messages.stream().anyMatch(message -> message.contains("ready in")));
+        }
+    }
+
+    @Test void environmentalAndCancelledDamageRemainUntouchedWhileProjectileCombatIsReduced() throws Exception {
+        try (var f = new FantasyStickLifecycleNativeTest.Fixture(data)) {
+            f.plugin.setEnabled(true);
+            var a = new FantasyStickLifecycleNativeTest.Actor(data); withStoneSkin(data, a, true);
+            f.players.put(a.core.id, a.player); f.activate(a); use(f, a);
+            PartyBookNativeTest.drain(f); PartyBookNativeTest.drain(f);
+            var fall = new EntityDamageEvent(a.player, EntityDamageEvent.DamageCause.FALL,
+                mock(org.bukkit.damage.DamageSource.class), 8);
+            f.dispatcher.accept(fall); assertEquals(8, fall.getDamage(), 1.0e-9);
+            var arrow = mock(org.bukkit.entity.Arrow.class);
+            var projectile = new EntityDamageByEntityEvent(arrow, a.player,
+                EntityDamageEvent.DamageCause.PROJECTILE, mock(org.bukkit.damage.DamageSource.class), 8);
+            f.dispatcher.accept(projectile); assertEquals(6, projectile.getDamage(), 1.0e-9);
+            class Veto implements org.bukkit.event.Listener {
+                @org.bukkit.event.EventHandler(priority = org.bukkit.event.EventPriority.LOWEST)
+                public void veto(EntityDamageByEntityEvent event) { event.setCancelled(true); }
+            }
+            f.dispatcher.register(new Veto(), f.plugin);
+            var cancelled = new EntityDamageByEntityEvent(mock(org.bukkit.entity.Zombie.class), a.player,
+                EntityDamageEvent.DamageCause.ENTITY_ATTACK, mock(org.bukkit.damage.DamageSource.class), 8);
+            f.dispatcher.accept(cancelled); assertTrue(cancelled.isCancelled()); assertEquals(8, cancelled.getDamage(), 1.0e-9);
+        }
+    }
+
+    @Test void replacementExpirySessionExitAndTransferRemoveOnlyOwnedReductionAndRetainDeadline() throws Exception {
+        java.nio.file.Files.writeString(data.resolve("config.yml"),
+            "stone-skin-cooldown-seconds: 0\nstone-skin-duration-seconds: 4\nstone-skin-damage-reduction-percent: 25\n");
+        try (var f = new FantasyStickLifecycleNativeTest.Fixture(data)) {
+            f.plugin.setEnabled(true);
+            var a = new FantasyStickLifecycleNativeTest.Actor(data); withStoneSkin(data, a, true);
+            f.players.put(a.core.id, a.player); f.activate(a); use(f, a); PartyBookNativeTest.drain(f); PartyBookNativeTest.drain(f);
+            use(f, a); PartyBookNativeTest.drain(f); PartyBookNativeTest.drain(f);
+            assertEquals(2, f.delayed.size());
+            f.delayed.getFirst().run();
+            assertEquals(6, hit(f, a, 8).getDamage(), 1.0e-9, "Old expiry cannot remove replacement protection");
+            f.delayed.getLast().run();
+            assertEquals(8, hit(f, a, 8).getDamage(), 1.0e-9);
+            use(f, a); PartyBookNativeTest.drain(f); PartyBookNativeTest.drain(f);
+            var storage = (CharacterStorage) FantasyStickLifecycleNativeTest.Fixture.field(f.plugin, "characters");
+            var deadline = storage.find(a.core.record.id()).get().orElseThrow().cooldowns().get("stone_skin");
+            var sheet = a.core.inventory.getItemInOffHand().clone();
+            a.core.inventory.setItemInOffHand(null); f.changed(a); PartyBookNativeTest.drain(f); f.awaitCharacterAndReceipt(a);
+            assertEquals(8, hit(f, a, 8).getDamage(), 1.0e-9, "Exit clears owned reduction");
+            assertEquals(deadline, storage.find(a.core.record.id()).get().orElseThrow().cooldowns().get("stone_skin"));
+            var b = new FantasyStickLifecycleNativeTest.Actor(data); b.core.inventory.setItemInOffHand(sheet);
+            f.players.put(b.core.id, b.player); f.activate(b);
+            assertEquals(deadline, storage.find(a.core.record.id()).get().orElseThrow().cooldowns().get("stone_skin"));
+        }
+    }
+
+    @Test void acknowledgedConfigurationAffectsFutureCastsWhileActiveProtectionKeepsSnapshot() throws Exception {
+        java.nio.file.Files.writeString(data.resolve("config.yml"),
+            "stone-skin-cooldown-seconds: 0\nstone-skin-duration-seconds: 4\nstone-skin-damage-reduction-percent: 25\n");
+        try (var f = new FantasyStickLifecycleNativeTest.Fixture(data)) {
+            f.plugin.setEnabled(true);
+            var a = new FantasyStickLifecycleNativeTest.Actor(data); withStoneSkin(data, a, true);
+            f.players.put(a.core.id, a.player); f.activate(a); use(f, a); PartyBookNativeTest.drain(f); PartyBookNativeTest.drain(f);
+            var sender = new EquipmentAdminCommandNativeTest.Sender();
+            f.command.execute(sender.port, "fantasystick", new String[]{"config", "stone-skin-duration-seconds", "6"});
+            f.command.execute(sender.port, "fantasystick", new String[]{"config", "stone-skin-damage-reduction-percent", "50"});
+            for (int i = 0; i < 2; i++) { var response = f.tasks.poll(5, java.util.concurrent.TimeUnit.SECONDS); assertNotNull(response); response.run(); }
+            assertEquals(6, hit(f, a, 8).getDamage(), 1.0e-9, "Active cast retains captured 25 percent");
+            assertEquals(80L, f.delayedTicks.getFirst());
+            var b = new FantasyStickLifecycleNativeTest.Actor(data); withStoneSkin(data, b, true);
+            f.players.put(b.core.id, b.player); f.activate(b); use(f, b); PartyBookNativeTest.drain(f); PartyBookNativeTest.drain(f);
+            assertEquals(4, hit(f, b, 8).getDamage(), 1.0e-9); assertEquals(120L, f.delayedTicks.getLast());
+        }
+    }
+
+    @Test void acceptedDamageReportsExactPreventionWhileCancelledDamageReportsNothing() {
+        var mitigation = new games.dmg.fantasystick.ability.CombatMitigation();
+        var stone = new games.dmg.fantasystick.ability.StoneSkin(
+            games.dmg.fantasystick.ability.StoneSkin.Settings.defaults(), mitigation);
+        var execution = mock(games.dmg.fantasystick.ability.AbilityExecution.class);
+        var input = mock(games.dmg.fantasystick.session.ControlInput.class);
+        var player = mock(org.bukkit.entity.Player.class); var id = java.util.UUID.randomUUID();
+        when(player.getUniqueId()).thenReturn(id); when(input.player()).thenReturn(player);
+        when(execution.input()).thenReturn(input); when(execution.definition()).thenReturn(stone.definition());
+        when(execution.stillCurrent()).thenReturn(true);
+        stone.activate(execution);
+        var weaker = mock(games.dmg.fantasystick.ability.AbilityExecution.class);
+        when(weaker.stillCurrent()).thenReturn(true);
+        var unrelated = mitigation.grant(weaker, player, new java.math.BigDecimal("20"));
+        var accepted = new EntityDamageByEntityEvent(mock(org.bukkit.entity.Zombie.class), player,
+            EntityDamageEvent.DamageCause.ENTITY_ATTACK, mock(org.bukkit.damage.DamageSource.class), 8);
+        mitigation.reduce(accepted); mitigation.accepted(accepted);
+        verify(execution).report(games.dmg.fantasystick.ability.AbilityReport.Type.PREVENTION,
+            player, new java.math.BigDecimal("2.0"));
+        var cancelled = new EntityDamageByEntityEvent(mock(org.bukkit.entity.Zombie.class), player,
+            EntityDamageEvent.DamageCause.ENTITY_ATTACK, mock(org.bukkit.damage.DamageSource.class), 8);
+        mitigation.reduce(cancelled); cancelled.setCancelled(true); mitigation.accepted(cancelled);
+        verify(execution, times(1)).report(any(), any(), any());
+        verify(weaker, never()).report(any(), any(), any());
+        try { unrelated.close(); } catch (Exception failure) { fail(failure); }
+        stone.close(); mitigation.close();
+    }
+
+    @Test void failedCooldownPersistenceCreatesNoReduction() {
+        var storage = mock(CharacterStorage.class);
+        var sessions = mock(games.dmg.fantasystick.session.EquipmentSessions.class);
+        var parties = new games.dmg.fantasystick.party.PartyRoster(java.time.Clock.systemUTC(), ignored -> true);
+        var registry = new games.dmg.fantasystick.ability.AbilityRegistry();
+        var mitigation = new games.dmg.fantasystick.ability.CombatMitigation();
+        var stone = new games.dmg.fantasystick.ability.StoneSkin(
+            games.dmg.fantasystick.ability.StoneSkin.Settings.defaults(), mitigation); registry.register(stone.definition());
+        var base = new games.dmg.fantasystick.crafting.CharacterFactory().create(
+            games.dmg.fantasystick.progression.ProgressionRules.defaults());
+        var stats = new EnumMap<>(base.stats()); stats.put(Stat.CON, BigInteger.valueOf(14));
+        var record = new CharacterRecord(base.id(), base.name(), base.revision(), stats, base.level(), base.experience(),
+            base.unspentPoints(), base.health(), java.util.Set.of("stone_skin"),
+            List.of("stone_skin", "", "", "", "", "", ""), base.cooldowns(), base.restrictedKills(), false, null, null);
+        var active = new games.dmg.fantasystick.session.EquipmentSessions.Active(java.util.UUID.randomUUID(),
+            java.util.UUID.randomUUID(), record.id());
+        var player = mock(org.bukkit.entity.Player.class); when(player.getUniqueId()).thenReturn(active.player());
+        when(sessions.current(active)).thenReturn(true); when(sessions.currentRecord(active)).thenReturn(java.util.Optional.of(record));
+        var failed = new java.util.concurrent.CompletableFuture<CharacterStorage.AbilityMutation>();
+        failed.completeExceptionally(new java.io.IOException("simulated cooldown save failure"));
+        when(storage.commitAbilityCooldown(eq(record.id()), eq(record.revision()), eq("stone_skin"), any())).thenReturn(failed);
+        var failures = new java.util.ArrayList<games.dmg.fantasystick.ability.AbilityEngine.Failure>();
+        var engine = new games.dmg.fantasystick.ability.AbilityEngine(registry, storage, sessions, parties,
+            java.time.Clock.systemUTC(), Runnable::run, (delay, action) -> () -> {}, ignored -> {}, failures::add);
+        engine.accept(new games.dmg.fantasystick.session.ControlInput(player, active, 2, "stone_skin",
+            games.dmg.fantasystick.session.ControlInput.Kind.ABILITY,
+            games.dmg.fantasystick.session.ControlInput.Gesture.USE, null, 0, 0, () -> true));
+        var hit = new EntityDamageByEntityEvent(mock(org.bukkit.entity.Zombie.class), player,
+            EntityDamageEvent.DamageCause.ENTITY_ATTACK, mock(org.bukkit.damage.DamageSource.class), 8);
+        mitigation.reduce(hit); assertEquals(8, hit.getDamage(), 1.0e-9);
+        verify(storage).commitAbilityCooldown(eq(record.id()), eq(record.revision()), eq("stone_skin"), any());
+        engine.close(); stone.close(); mitigation.close(); parties.close();
+    }
+
+    @Test void configuredDefinitionAdminRoutesAndStartupValidationCoverEverySetting() throws Exception {
+        java.nio.file.Files.writeString(data.resolve("config.yml"),
+            "stone-skin-cooldown-seconds: 2\nstone-skin-duration-seconds: 6\nstone-skin-damage-reduction-percent: 40\n");
+        try (var f = new FantasyStickLifecycleNativeTest.Fixture(data)) {
+            f.plugin.setEnabled(true);
+            var registry = (games.dmg.fantasystick.ability.AbilityRegistry)
+                FantasyStickLifecycleNativeTest.Fixture.field(f.plugin, "abilityRegistry");
+            var definition = registry.find("stone_skin").orElseThrow();
+            assertEquals(java.time.Duration.ofSeconds(2), definition.cooldown());
+            assertEquals(0, new java.math.BigDecimal("6").compareTo(definition.parameters().get("duration-seconds")));
+            assertEquals(0, new java.math.BigDecimal("40").compareTo(definition.parameters().get("damage-reduction-percent")));
+            var sender = new EquipmentAdminCommandNativeTest.Sender(); sender.allowed = false;
+            assertTrue(f.command.tabComplete(sender.port, "fantasystick", new String[]{"config", "stone-skin"}).isEmpty());
+            f.command.execute(sender.port, "fantasystick", new String[]{"config", "stone-skin-duration-seconds", "7"});
+            assertTrue(sender.messages.getLast().contains("Permission denied")); sender.allowed = true;
+            assertEquals(List.of("stone-skin-cooldown-seconds", "stone-skin-damage-reduction-percent", "stone-skin-duration-seconds"),
+                f.command.tabComplete(sender.port, "fantasystick", new String[]{"config", "stone-skin-"}));
+            assertEquals(List.of("4", "6"), f.command.tabComplete(sender.port, "fantasystick",
+                new String[]{"config", "stone-skin-duration-seconds", ""}));
+            f.command.execute(sender.port, "fantasystick", new String[]{"config", "stone-skin-duration-seconds"});
+            assertTrue(sender.messages.getLast().contains("=6"));
+            f.command.execute(sender.port, "fantasystick", new String[]{"config", "stone-skin-duration-seconds", "7"});
+            var response = f.tasks.poll(5, java.util.concurrent.TimeUnit.SECONDS); assertNotNull(response); response.run();
+            assertEquals(0, new java.math.BigDecimal("7").compareTo(
+                registry.find("stone_skin").orElseThrow().parameters().get("duration-seconds")));
+            f.command.execute(sender.port, "fantasystick", new String[]{"config", "stone-skin-duration-seconds", "-1"});
+            assertTrue(sender.messages.getLast().contains("invalid"));
+            f.command.execute(sender.port, "fantasystick", new String[]{"config", "stone-skin-duration-seconds", "7", "extra"});
+            assertTrue(sender.messages.getLast().contains("Usage"));
+            f.plugin.setEnabled(false); f.plugin.setEnabled(true);
+            var reloaded = (games.dmg.fantasystick.ability.AbilityRegistry)
+                FantasyStickLifecycleNativeTest.Fixture.field(f.plugin, "abilityRegistry");
+            assertEquals(0, new java.math.BigDecimal("7").compareTo(
+                reloaded.find("stone_skin").orElseThrow().parameters().get("duration-seconds")));
+        }
+        for (String invalid : List.of("stone-skin-cooldown-seconds: -1\n",
+                "stone-skin-duration-seconds: 0\n", "stone-skin-damage-reduction-percent: 101\n")) {
+            var directory = data.resolve(Integer.toHexString(invalid.hashCode())); java.nio.file.Files.createDirectories(directory);
+            java.nio.file.Files.writeString(directory.resolve("config.yml"), invalid);
+            try (var f = new FantasyStickLifecycleNativeTest.Fixture(directory)) {
+                assertThrows(IllegalArgumentException.class, () -> f.plugin.setEnabled(true)); assertTrue(f.order.isEmpty());
+            }
+        }
+    }
+
+    private static EntityDamageByEntityEvent hit(FantasyStickLifecycleNativeTest.Fixture fixture,
+                                                  FantasyStickLifecycleNativeTest.Actor target, double amount) {
+        var event = new EntityDamageByEntityEvent(mock(org.bukkit.entity.Zombie.class), target.player,
+            EntityDamageEvent.DamageCause.ENTITY_ATTACK, mock(org.bukkit.damage.DamageSource.class), amount);
+        fixture.dispatcher.accept(event); return event;
+    }
+
+    private static void use(FantasyStickLifecycleNativeTest.Fixture fixture,
+                            FantasyStickLifecycleNativeTest.Actor actor) {
+        actor.core.inventory.getInventory().setSelectedSlot(2);
+        fixture.dispatcher.accept(new PlayerInteractEvent(actor.player,
+            org.bukkit.event.block.Action.RIGHT_CLICK_AIR, actor.core.inventory.getItem(2), null,
+            org.bukkit.block.BlockFace.SELF, EquipmentSlot.HAND));
+    }
+
+    private static ClickEvent.Custom abilityButton(FantasyStickLifecycleNativeTest.Actor actor,
+                                                    String label, String ability) {
+        var book = org.bukkit.craftbukkit.inventory.CraftItemStack.asNMSCopy(actor.books.getLast())
+            .get(net.minecraft.core.component.DataComponents.WRITTEN_BOOK_CONTENT);
+        assertNotNull(book);
+        for (var page : book.pages()) {
+            var found = abilityButton(page.raw(), label, ability);
+            if (found != null) return found;
+        }
+        fail("Missing " + label + " for " + ability); return null;
+    }
+    private static ClickEvent.Custom abilityButton(net.minecraft.network.chat.Component component,
+                                                    String label, String ability) {
+        if (component.getString().equals(label)
+                && component.getStyle().getClickEvent() instanceof ClickEvent.Custom custom
+                && custom.payload().orElse(null) instanceof net.minecraft.nbt.StringTag payload
+                && payload.value().contains(":" + ability)) return custom;
+        for (var child : component.getSiblings()) {
+            var found = abilityButton(child, label, ability); if (found != null) return found;
+        }
+        return null;
+    }
+
+    private static void withStoneSkin(Path data, FantasyStickLifecycleNativeTest.Actor actor,
+                                      boolean learned) throws Exception {
+        java.nio.file.Files.createDirectories(data);
+        var repository = new games.dmg.fantasystick.persistence.YamlCharacterRepository(data);
+        var old = repository.load(actor.core.record.id()).orElseThrow();
+        var stats = new EnumMap<>(old.stats()); stats.put(Stat.CON, BigInteger.valueOf(14));
+        repository.replace(new CharacterRecord(old.id(), old.name(), old.revision().add(BigInteger.ONE), stats,
+            old.level(), old.experience(), BigInteger.valueOf(learned ? 39 : 40), old.health(),
+            learned ? java.util.Set.of("stone_skin") : old.learned(),
+            learned ? List.of("stone_skin", "", "", "", "", "", "") : old.loadout(),
+            old.cooldowns(), old.restrictedKills(), false, null, null), old.revision());
+    }
+}

src/nativeTest/java/games/dmg/fantasystick/SwitchDelayAdminNativeTest.java

@@ -0,0 +1,9 @@
+package games.dmg.fantasystick;
+import static org.junit.jupiter.api.Assertions.*;import java.nio.file.Path;import java.time.Duration;import org.junit.jupiter.api.BeforeAll;import org.junit.jupiter.api.Test;import org.junit.jupiter.api.io.TempDir;
+class SwitchDelayAdminNativeTest{@TempDir Path data;@BeforeAll static void bootstrap()throws Exception{NativeRuntime.bootstrap();}
+ @Test void registeredCommandDurablyChangesActualExitAndEntryPolicyWithoutRewritingDeadlines()throws Exception{try(var f=new FantasyStickLifecycleNativeTest.Fixture(data)){f.plugin.setEnabled(true);var sender=new EquipmentAdminCommandNativeTest.Sender();assertEquals(java.util.List.of("character-swap-cooldown-seconds"),f.command.tabComplete(sender.port,"fantasystick",new String[]{"config","character-s"}));assertEquals(java.util.List.of("900"),f.command.tabComplete(sender.port,"fantasystick",new String[]{"config","character-swap-cooldown-seconds",""}));f.command.execute(sender.port,"fantasystick",new String[]{"config","character-swap-cooldown-seconds"});assertTrue(sender.messages.getLast().contains("=900"));sender.allowed=false;assertTrue(f.command.tabComplete(sender.port,"fantasystick",new String[]{"config","character"}).isEmpty());f.command.execute(sender.port,"fantasystick",new String[]{"config","character-swap-cooldown-seconds","37"});assertTrue(sender.messages.getLast().contains("Permission denied"));sender.allowed=true;for(String bad:java.util.List.of("-1","1.5","bad","9223372036854775807")){f.command.execute(sender.port,"fantasystick",new String[]{"config","character-swap-cooldown-seconds",bad});assertTrue(sender.messages.getLast().contains("invalid"),bad+" -> "+sender.messages);}f.command.execute(sender.port,"fantasystick",new String[]{"config","character-swap-cooldown-seconds","37","extra"});assertTrue(sender.messages.getLast().contains("Usage"));save(f,sender,"37");
+  var sessions=(games.dmg.fantasystick.session.EquipmentSessions)FantasyStickLifecycleNativeTest.Fixture.field(f.plugin,"sessions");var a=new FantasyStickLifecycleNativeTest.Actor(data);var b=new FantasyStickLifecycleNativeTest.Actor(data);f.players.put(a.core.id,a.player);f.players.put(b.core.id,b.player);f.activate(a);f.activate(b);sessions.exit(a.player);sessions.exit(b.player);f.awaitCharacterAndReceipt(a);f.awaitCharacterAndReceipt(b);var aExit=f.receipts().find(a.core.id).toCompletableFuture().get().orElseThrow().lastExit();var bExit=f.receipts().find(b.core.id).toCompletableFuture().get().orElseThrow().lastExit();assertEquals(Duration.ofSeconds(37),Duration.between(aExit.exitedAt(),aExit.deadline()));assertEquals(Duration.ofSeconds(37),Duration.between(bExit.exitedAt(),bExit.deadline()));var otherA=new FantasyStickLifecycleNativeTest.Actor(data);var otherB=new FantasyStickLifecycleNativeTest.Actor(data);a.core.inventory.setItemInOffHand(otherA.core.inventory.getItemInOffHand().clone());b.core.inventory.setItemInOffHand(otherB.core.inventory.getItemInOffHand().clone());save(f,sender,"0");f.activate(a);assertEquals(otherA.core.record.id(),sessions.active(a.core.id).orElseThrow().character());assertEquals(aExit,f.receipts().find(a.core.id).toCompletableFuture().get().orElseThrow().lastExit());save(f,sender,"900");var policy=(games.dmg.fantasystick.persistence.SwitchDelaySettings)FantasyStickLifecycleNativeTest.Fixture.field(f.plugin,"switchDelaySettings");assertEquals(Duration.ofSeconds(900),policy.delay());assertFalse(f.receipts().find(b.core.id).toCompletableFuture().get().orElseThrow().canEnter(otherB.core.record.id(),policy.delay(),java.time.Instant.now()));assertTrue(sessions.active(b.core.id).isEmpty(),"B remained active after exit");f.changed(b);f.receipts().find(b.core.id).toCompletableFuture().get();PartyBookNativeTest.drain(f);assertTrue(sessions.active(b.core.id).isEmpty(),b.messages::toString);assertEquals(bExit,f.receipts().find(b.core.id).toCompletableFuture().get().orElseThrow().lastExit());sessions.exit(a.player);f.awaitCharacterAndReceipt(a);var newExit=f.receipts().find(a.core.id).toCompletableFuture().get().orElseThrow().lastExit();assertEquals(Duration.ofSeconds(900),Duration.between(newExit.exitedAt(),newExit.deadline()));f.plugin.setEnabled(false);f.plugin.setEnabled(true);f.command.execute(sender.port,"fantasystick",new String[]{"config","character-swap-cooldown-seconds"});assertTrue(sender.messages.getLast().contains("=900"));}}
+ @Test void exitRetainsPolicyCapturedWhenItsNativeTransitionStarts()throws Exception{try(var f=new FantasyStickLifecycleNativeTest.Fixture(data)){f.plugin.setEnabled(true);var sender=new EquipmentAdminCommandNativeTest.Sender();save(f,sender,"37");var a=new FantasyStickLifecycleNativeTest.Actor(data);f.players.put(a.core.id,a.player);f.activate(a);var characters=(games.dmg.fantasystick.persistence.CharacterStorage)FantasyStickLifecycleNativeTest.Fixture.field(f.plugin,"characters");var worker=(java.util.concurrent.ExecutorService)FantasyStickLifecycleNativeTest.Fixture.field(characters,"worker");var entered=new java.util.concurrent.CountDownLatch(1);var release=new java.util.concurrent.CountDownLatch(1);worker.execute(()->{entered.countDown();try{release.await();}catch(InterruptedException interrupted){Thread.currentThread().interrupt();}});assertTrue(entered.await(5,java.util.concurrent.TimeUnit.SECONDS));var sessions=(games.dmg.fantasystick.session.EquipmentSessions)FantasyStickLifecycleNativeTest.Fixture.field(f.plugin,"sessions");sessions.exit(a.player);save(f,sender,"0");release.countDown();f.awaitCharacterAndReceipt(a);var exit=f.receipts().find(a.core.id).toCompletableFuture().get().orElseThrow().lastExit();assertEquals(Duration.ofSeconds(37),Duration.between(exit.exitedAt(),exit.deadline()));}}
+ @Test void failedRegisteredWriteLeavesEffectivePolicyAndUnrelatedStateUntouched()throws Exception{try(var f=new FantasyStickLifecycleNativeTest.Fixture(data)){f.plugin.setEnabled(true);java.nio.file.Files.createDirectory(data.resolve("config.yml"));var sender=new EquipmentAdminCommandNativeTest.Sender();f.command.execute(sender.port,"fantasystick",new String[]{"config","character-swap-cooldown-seconds","0"});var task=f.tasks.poll(5,java.util.concurrent.TimeUnit.SECONDS);assertNotNull(task);task.run();assertTrue(sender.messages.getLast().contains("save failed"));f.command.execute(sender.port,"fantasystick",new String[]{"config","character-swap-cooldown-seconds"});assertTrue(sender.messages.getLast().contains("=900"));}}
+ static void save(FantasyStickLifecycleNativeTest.Fixture f,EquipmentAdminCommandNativeTest.Sender sender,String value)throws Exception{int before=sender.messages.size();f.command.execute(sender.port,"fantasystick",new String[]{"config","character-swap-cooldown-seconds",value});assertEquals(before,sender.messages.size());var task=f.tasks.poll(5,java.util.concurrent.TimeUnit.SECONDS);assertNotNull(task);task.run();assertTrue(sender.messages.getLast().contains("="+value));}
+}

src/resourcePack/assets/fantasystick/items/character_sheet.json

@@ -0,0 +1,21 @@
+{
+  "model": {
+    "type": "minecraft:select",
+    "property": "minecraft:display_context",
+    "cases": [
+      {
+        "when": [
+          "firstperson_lefthand",
+          "firstperson_righthand"
+        ],
+        "model": {
+          "type": "minecraft:empty"
+        }
+      }
+    ],
+    "fallback": {
+      "type": "minecraft:model",
+      "model": "minecraft:item/paper"
+    }
+  }
+}

src/resourcePack/pack.mcmeta

@@ -0,0 +1,7 @@
+{
+  "pack": {
+    "description": "Fantasy Stick ${version} sheet presentation",
+    "min_format": [88, 0],
+    "max_format": [88, 0]
+  }
+}

src/test/java/games/dmg/fantasystick/DistributionTest.java

@@ -5,6 +5,7 @@ import static org.junit.jupiter.api.Assertions.*;
 import java.io.DataInputStream;
 import java.nio.file.Path;
 import java.util.jar.JarFile;
+import java.util.zip.ZipFile;
 import org.bukkit.plugin.PluginDescriptionFile;
 import org.bukkit.plugin.java.JavaPlugin;
 import org.junit.jupiter.api.Test;
@@ -30,6 +31,7 @@ class DistributionTest {
             assertEquals(java.util.List.of("ProtocolLib"), metadata.getDepend());
             assertEquals(java.util.Set.of("fantasystick"), metadata.getCommands().keySet());
             assertEquals("fantasystick.admin", metadata.getCommands().get("fantasystick").get("permission"));
+            assertTrue(metadata.getCommands().get("fantasystick").get("usage").toString().contains("experience give"));
             assertEquals(1, metadata.getPermissions().size());
             assertEquals("fantasystick.admin", metadata.getPermissions().getFirst().getName());
             assertEquals(org.bukkit.permissions.PermissionDefault.OP, metadata.getPermissions().getFirst().getDefault());
@@ -60,6 +62,30 @@ class DistributionTest {
                     "quickstep-distance-blocks: 4", "quickstep-speed-blocks-per-tick: 1")) {
                 assertTrue(defaults.contains(setting), "Missing packaged Quickstep default: " + setting);
             }
+            for (String setting : java.util.List.of("second-wind-base-healing: 6",
+                    "second-wind-cooldown-seconds: 15")) {
+                assertTrue(defaults.contains(setting), "Missing packaged Second Wind default: " + setting);
+            }
+            for (String setting : java.util.List.of("stone-skin-cooldown-seconds: 14",
+                    "stone-skin-duration-seconds: 4", "stone-skin-damage-reduction-percent: 25")) {
+                assertTrue(defaults.contains(setting), "Missing packaged Stone Skin default: " + setting);
+            }
+            for (String setting : java.util.List.of("shield-bash-base-damage: 4", "shield-bash-cooldown-seconds: 6",
+                    "shield-bash-range-blocks: 3", "shield-bash-horizontal-knockback: 0.8",
+                    "shield-bash-minimum-vertical-knockback: 0.35")) {
+                assertTrue(defaults.contains(setting), "Missing packaged Shield Bash default: " + setting);
+            }
+            for (String setting : java.util.List.of("hex-cooldown-seconds: 10", "hex-range-blocks: 12",
+                    "hex-duration-seconds: 4", "hex-damage-reduction-percent: 20")) {
+                assertTrue(defaults.contains(setting), "Missing packaged Hex default: " + setting);
+            }
+            for (String setting : java.util.List.of("inspire-base-temporary-health: 4",
+                    "inspire-cooldown-seconds: 15", "inspire-range-blocks: 12", "inspire-duration-seconds: 6")) {
+                assertTrue(defaults.contains(setting), "Missing packaged Inspire default: " + setting);
+            }
+            assertTrue(defaults.contains("admin-revive-selection-timeout-seconds: 60"));
+            assertTrue(defaults.contains("sheet-resource-pack-url: ''"));
+            assertTrue(defaults.contains("sheet-resource-pack-sha1: ''"));
             assertTrue(JavaPlugin.class.isAssignableFrom(FantasyStickPlugin.class));
             var entrypoint = jar.getJarEntry(metadata.getMain().replace('.', '/') + ".class");
             assertNotNull(entrypoint);
@@ -73,4 +99,38 @@ class DistributionTest {
                 "Server API and test dependencies must not ship in the plugin");
         }
     }
+
+    @Test void packagesVersionedContextSensitiveSheetResourcePackAndMatchingRuntimeMetadata() throws Exception {
+        Path artifact = Path.of(System.getProperty("distribution.jar"));
+        Path pack = Path.of(System.getProperty("resource.pack.zip"));
+        String version = System.getProperty("distribution.version");
+        assertEquals("purpur-fantasy-stick-" + version + "-resource-pack.zip", pack.getFileName().toString());
+        byte[] bytes = java.nio.file.Files.readAllBytes(pack);
+        String sha1 = java.util.HexFormat.of().formatHex(java.security.MessageDigest.getInstance("SHA-1").digest(bytes));
+        try (var zip = new ZipFile(pack.toFile())) {
+            var manifest = zip.getEntry("pack.mcmeta"); assertNotNull(manifest);
+            String manifestJson; try (var input = zip.getInputStream(manifest)) { manifestJson = new String(input.readAllBytes(), java.nio.charset.StandardCharsets.UTF_8); }
+            assertTrue(manifestJson.contains("\"min_format\": [88, 0]"));
+            assertTrue(manifestJson.contains("\"max_format\": [88, 0]"));
+            assertTrue(manifestJson.contains(version));
+            var model = zip.getEntry("assets/fantasystick/items/character_sheet.json");
+            assertNotNull(model);
+            String json;
+            try (var input = zip.getInputStream(model)) { json = new String(input.readAllBytes(), java.nio.charset.StandardCharsets.UTF_8); }
+            assertTrue(json.contains("minecraft:select"));
+            assertTrue(json.contains("minecraft:display_context"));
+            assertTrue(json.contains("firstperson_lefthand"));
+            assertTrue(json.contains("firstperson_righthand"));
+            assertTrue(json.contains("minecraft:empty"));
+            assertTrue(json.contains("minecraft:item/paper"), "Inventory and other contexts retain Paper presentation");
+        }
+        try (var jar = new JarFile(artifact.toFile())) {
+            var metadata = jar.getJarEntry("sheet-resource-pack.properties"); assertNotNull(metadata);
+            var values = new java.util.Properties();
+            try (var input = jar.getInputStream(metadata)) { values.load(input); }
+            assertEquals(sha1, values.getProperty("sha1"));
+            assertEquals("https://git.garvis.dev/dmg/purpur-fantasy-stick/releases/download/v" + version
+                + "/purpur-fantasy-stick-" + version + "-resource-pack.zip", values.getProperty("url"));
+        }
+    }
 }

src/test/java/games/dmg/fantasystick/crafting/RecipeDiscoveryTest.java

@@ -0,0 +1,103 @@
+package games.dmg.fantasystick.crafting;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+import games.dmg.fantasystick.items.CharacterSheets;
+import java.lang.reflect.Proxy;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.LinkedHashSet;
+import java.util.List;
+import java.util.Set;
+import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.logging.Handler;
+import java.util.logging.LogRecord;
+import java.util.logging.Logger;
+import org.bukkit.NamespacedKey;
+import org.bukkit.entity.Player;
+import org.bukkit.event.player.PlayerJoinEvent;
+import org.junit.jupiter.api.Test;
+
+class RecipeDiscoveryTest {
+    @Test void onlineJoinRepeatedFailureAndRetryAreIsolatedAndIdempotent() {
+        var warnings = new ArrayList<LogRecord>();
+        var logger = Logger.getAnonymousLogger(); logger.setUseParentHandlers(false);
+        logger.addHandler(new Handler() {
+            @Override public void publish(LogRecord record) { warnings.add(record); }
+            @Override public void flush() { }
+            @Override public void close() { }
+        });
+        var firstKnown = new LinkedHashSet<NamespacedKey>(); var firstAwards = new ArrayList<List<NamespacedKey>>();
+        var secondKnown = new LinkedHashSet<NamespacedKey>(); var secondAwards = new ArrayList<List<NamespacedKey>>();
+        var fail = new AtomicBoolean(true);
+        var first = player("First", firstKnown, firstAwards, fail);
+        var second = player("Second", secondKnown, secondAwards, new AtomicBoolean(false));
+        var discovery = new RecipeDiscovery(CharacterSheets.RECIPE, logger);
+
+        discovery.discoverAll(List.of(first, second));
+        discovery.onJoin(new PlayerJoinEvent(first, "joined"));
+        discovery.onJoin(new PlayerJoinEvent(first, "joined again"));
+        discovery.discover(second);
+
+        assertEquals(Set.of(CharacterSheets.RECIPE), firstKnown);
+        assertEquals(Set.of(CharacterSheets.RECIPE), secondKnown);
+        assertEquals(List.of(List.of(CharacterSheets.RECIPE)), firstAwards);
+        assertEquals(List.of(List.of(CharacterSheets.RECIPE)), secondAwards);
+        assertEquals(1, warnings.size());
+        assertTrue(warnings.getFirst().getMessage().contains("First"));
+    }
+
+    @Test void missingNativePostconditionIsLoggedAndRetried() {
+        var warnings = new ArrayList<LogRecord>();
+        var logger = Logger.getAnonymousLogger(); logger.setUseParentHandlers(false);
+        logger.addHandler(new Handler() {
+            @Override public void publish(LogRecord record) { warnings.add(record); }
+            @Override public void flush() { }
+            @Override public void close() { }
+        });
+        var known = new LinkedHashSet<NamespacedKey>(); var awards = new ArrayList<List<NamespacedKey>>();
+        var omit = new AtomicBoolean(true);
+        var player = proxy("Ada", known, awards, omit);
+        var discovery = new RecipeDiscovery(CharacterSheets.RECIPE, logger);
+
+        discovery.discover(player);
+        discovery.discover(player);
+
+        assertEquals(Set.of(CharacterSheets.RECIPE), known);
+        assertEquals(List.of(List.of(CharacterSheets.RECIPE), List.of(CharacterSheets.RECIPE)), awards);
+        assertEquals(1, warnings.size());
+    }
+
+    private static Player player(String name, Set<NamespacedKey> known, List<List<NamespacedKey>> awards,
+            AtomicBoolean fail) {
+        return (Player) Proxy.newProxyInstance(Player.class.getClassLoader(), new Class<?>[]{Player.class}, (proxy, method, args) -> {
+            if (method.getName().equals("getName")) return name;
+            if (method.getName().equals("hasDiscoveredRecipe")) return known.contains(args[0]);
+            if (method.getName().equals("discoverRecipes")) {
+                if (fail.getAndSet(false)) throw new IllegalStateException("simulated discovery failure");
+                var requested = ((Collection<?>) args[0]).stream().map(NamespacedKey.class::cast).toList();
+                awards.add(requested); known.addAll(requested); return requested.size();
+            }
+            if (method.getName().equals("toString")) return name;
+            if (method.getName().equals("hashCode")) return System.identityHashCode(proxy);
+            if (method.getName().equals("equals")) return proxy == args[0];
+            throw new UnsupportedOperationException(method.getName());
+        });
+    }
+
+    private static Player proxy(String name, Set<NamespacedKey> known, List<List<NamespacedKey>> awards,
+            AtomicBoolean omitFirst) {
+        return (Player) Proxy.newProxyInstance(Player.class.getClassLoader(), new Class<?>[]{Player.class}, (proxy, method, args) -> {
+            if (method.getName().equals("getName")) return name;
+            if (method.getName().equals("hasDiscoveredRecipe")) return known.contains(args[0]);
+            if (method.getName().equals("discoverRecipes")) {
+                var requested = ((Collection<?>) args[0]).stream().map(NamespacedKey.class::cast).toList();
+                awards.add(requested); if (!omitFirst.getAndSet(false)) known.addAll(requested); return requested.size();
+            }
+            if (method.getName().equals("toString")) return name;
+            if (method.getName().equals("hashCode")) return System.identityHashCode(proxy);
+            if (method.getName().equals("equals")) return proxy == args[0];
+            throw new UnsupportedOperationException(method.getName());
+        });
+    }
+}

src/test/java/games/dmg/fantasystick/party/PartyRosterTest.java

@@ -108,6 +108,28 @@ class PartyRosterTest {
         assertEquals(6, parties.partyOf(leader).orElseThrow().members().size());
     }
 
+    @Test void liveCapacityGrandfathersExistingMembersAndRechecksPendingInvitations() {
+        var limit = new java.util.concurrent.atomic.AtomicInteger(3);
+        try (var dynamic = new PartyRoster(clock, online::contains, limit::get)) {
+            UUID leader = player(), first = player(), second = player(), pending = player(), later = player();
+            var party = dynamic.create(leader).orElseThrow();
+            assertTrue(dynamic.accept(first, dynamic.invite(leader, party.id(), first).orElseThrow().id()));
+            var pendingOffer = dynamic.invite(leader, party.id(), pending).orElseThrow();
+            assertTrue(dynamic.accept(second, dynamic.invite(leader, party.id(), second).orElseThrow().id()));
+            limit.set(2);
+            assertEquals(3, dynamic.partyOf(leader).orElseThrow().members().size());
+            assertFalse(dynamic.accept(pending, pendingOffer.id()));
+            assertTrue(dynamic.invite(leader, party.id(), later).isEmpty());
+            assertTrue(dynamic.leave(first, party.id()));
+            assertTrue(dynamic.invite(leader, party.id(), later).isEmpty(), "At the limit cannot grow");
+            assertTrue(dynamic.leave(second, party.id()));
+            assertTrue(dynamic.accept(later, dynamic.invite(leader, party.id(), later).orElseThrow().id()));
+            limit.set(4);
+            assertEquals(4, dynamic.maximumSize());
+            assertTrue(dynamic.invite(leader, party.id(), pending).isPresent());
+        }
+    }
+
     @Test void onlyTheCurrentOnlineLeaderCanKickOrDisbandTheMatchingParty() {
         UUID leader = player(), member = player(), stranger = player();
         var party = parties.create(leader).orElseThrow();

src/test/java/games/dmg/fantasystick/persistence/AdminReviveSettingsTest.java

@@ -0,0 +1,7 @@
+package games.dmg.fantasystick.persistence;
+import static org.junit.jupiter.api.Assertions.*;
+import java.nio.file.*;import java.time.Duration;import org.junit.jupiter.api.Test;import org.junit.jupiter.api.io.TempDir;
+class AdminReviveSettingsTest{@TempDir Path data;
+ @Test void validatesPersistsPreservesUnrelatedAndPublishesOnlyAcknowledgedUpdates()throws Exception{assertEquals(Duration.ofSeconds(60),AdminReviveSettings.parse(null));for(Object bad:new Object[]{0,-1,"1.5","no",31536001L})assertThrows(IllegalArgumentException.class,()->AdminReviveSettings.parse(bad));Files.writeString(data.resolve("config.yml"),"unrelated: keep\nadmin-revive-selection-timeout-seconds: 60\n");try(var settings=new AdminReviveSettings(data,Duration.ofSeconds(60))){var update=settings.set("90").toCompletableFuture().get();assertEquals("60",settings.value());assertTrue(Files.readString(data.resolve("config.yml")).contains("unrelated: keep"));settings.publish(update);assertEquals("90",settings.value());assertEquals(Duration.ofSeconds(90),settings.timeout());settings.publish(update);assertEquals("90",settings.value());}}
+ @Test void failedWriteRetainsEffectiveValue()throws Exception{try(var settings=new AdminReviveSettings(data,Duration.ofSeconds(60))){Files.createDirectory(data.resolve("config.yml"));assertThrows(Exception.class,()->settings.set("90").toCompletableFuture().get());assertEquals("60",settings.value());}}
+}

src/test/java/games/dmg/fantasystick/persistence/ChainLightningSettingsTest.java

@@ -0,0 +1,82 @@
+package games.dmg.fantasystick.persistence;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.StandardCopyOption;
+import java.util.LinkedHashMap;
+import java.util.Map;
+import java.util.concurrent.TimeUnit;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.io.TempDir;
+
+class ChainLightningSettingsTest {
+    @TempDir Path data;
+
+    @Test void defaultsAndParsingRetainExactDecay() {
+        var settings = ChainLightningSettings.parse(defaults());
+        assertEquals(java.math.BigInteger.valueOf(8), settings.baseDamage());
+        assertEquals(java.time.Duration.ofSeconds(18), settings.cooldown());
+        assertEquals(16, settings.initialRange(), 0); assertEquals(6, settings.jumpRange(), 0);
+        assertEquals(3, settings.additionalTargets());
+        assertEquals(new java.math.BigDecimal("0.75"), settings.jumpMultiplier());
+    }
+
+    @Test void serializesPreservesUnrelatedKeysAndPublishesAcknowledgedSnapshotsInOrder() throws Exception {
+        Files.writeString(data.resolve("config.yml"), "unrelated: retained\n");
+        try (var settings = new ChainLightningSettings(data, defaults())) {
+            var range = settings.set(ChainLightningSettings.JUMP_RANGE, "7").toCompletableFuture();
+            var cooldown = settings.set(ChainLightningSettings.COOLDOWN, "24").toCompletableFuture();
+            var savedRange = range.get(5, TimeUnit.SECONDS); var savedCooldown = cooldown.get(5, TimeUnit.SECONDS);
+            assertEquals(6, settings.settings().jumpRange(), 0);
+            settings.publish(savedCooldown); settings.publish(savedRange);
+            assertEquals(7, settings.settings().jumpRange(), 0);
+            assertEquals(java.time.Duration.ofSeconds(24), settings.settings().cooldown());
+            var yaml = (Map<?, ?>) new org.yaml.snakeyaml.Yaml().load(Files.readString(data.resolve("config.yml")));
+            assertEquals("retained", yaml.get("unrelated"));
+            assertEquals("7", String.valueOf(yaml.get(ChainLightningSettings.JUMP_RANGE)));
+        }
+    }
+
+    @Test void invalidFailedUnsafeAndClosedWritesRetainEffectiveState() throws Exception {
+        try (var settings = new ChainLightningSettings(data, defaults())) {
+            for (var entry : Map.of(
+                    ChainLightningSettings.COOLDOWN, "-1", ChainLightningSettings.INITIAL_RANGE, "0",
+                    ChainLightningSettings.JUMP_RANGE, "0", ChainLightningSettings.ADDITIONAL, "-1",
+                    ChainLightningSettings.BASE, "-1", ChainLightningSettings.MULTIPLIER, "0").entrySet()) {
+                assertThrows(IllegalArgumentException.class, () -> settings.set(entry.getKey(), entry.getValue()));
+            }
+            assertThrows(IllegalArgumentException.class, () -> settings.set(ChainLightningSettings.COOLDOWN, "0.0000000001"));
+        }
+        var fail = new java.util.concurrent.atomic.AtomicBoolean(true);
+        try (var settings = new ChainLightningSettings(data, defaults(), (from, to) -> {
+            if (fail.getAndSet(false)) throw new java.io.IOException("simulated");
+            Files.move(from, to, StandardCopyOption.REPLACE_EXISTING);
+        })) {
+            assertThrows(java.util.concurrent.ExecutionException.class,
+                () -> settings.set(ChainLightningSettings.JUMP_RANGE, "7").toCompletableFuture().get(5, TimeUnit.SECONDS));
+            assertEquals("6", settings.value(ChainLightningSettings.JUMP_RANGE));
+        }
+        if (!System.getProperty("os.name", "").toLowerCase().contains("win")) {
+            var unsafe = data.resolve("unsafe"); Files.createDirectories(unsafe);
+            var outside = data.resolve("outside.yml"); Files.writeString(outside, "safe\n");
+            Files.createSymbolicLink(unsafe.resolve("config.yml"), outside);
+            try (var settings = new ChainLightningSettings(unsafe, defaults())) {
+                assertThrows(java.util.concurrent.ExecutionException.class,
+                    () -> settings.set(ChainLightningSettings.MULTIPLIER, "0.5").toCompletableFuture().get(5, TimeUnit.SECONDS));
+                assertEquals("safe\n", Files.readString(outside));
+            }
+        }
+        var closed = new ChainLightningSettings(data.resolve("closed"), defaults()); closed.close();
+        assertThrows(java.util.concurrent.ExecutionException.class,
+            () -> closed.set(ChainLightningSettings.BASE, "9").toCompletableFuture().get(5, TimeUnit.SECONDS));
+        closed.drained().toCompletableFuture().get(5, TimeUnit.SECONDS);
+    }
+
+    private static Map<String, String> defaults() {
+        var values = new LinkedHashMap<String, String>();
+        for (String key : ChainLightningSettings.keys()) values.put(key, ChainLightningSettings.defaultValue(key));
+        return values;
+    }
+}

src/test/java/games/dmg/fantasystick/persistence/FrostNovaSettingsTest.java

@@ -0,0 +1,75 @@
+package games.dmg.fantasystick.persistence;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.StandardCopyOption;
+import java.util.LinkedHashMap;
+import java.util.Map;
+import java.util.concurrent.TimeUnit;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.io.TempDir;
+
+class FrostNovaSettingsTest {
+    @TempDir Path data;
+
+    @Test void serializesPreservesUnrelatedKeysAndPublishesAcknowledgedSnapshotsInOrder() throws Exception {
+        Files.writeString(data.resolve("config.yml"), "unrelated: retained\n");
+        try (var settings = new FrostNovaSettings(data, defaults())) {
+            var range = settings.set(FrostNovaSettings.RADIUS, "7").toCompletableFuture();
+            var cooldown = settings.set(FrostNovaSettings.COOLDOWN, "24").toCompletableFuture();
+            var savedRange = range.get(5, TimeUnit.SECONDS); var savedCooldown = cooldown.get(5, TimeUnit.SECONDS);
+            assertEquals(5, settings.settings().radius(), 0);
+            settings.publish(savedCooldown); settings.publish(savedRange);
+            assertEquals(7, settings.settings().radius(), 0);
+            assertEquals(java.time.Duration.ofSeconds(24), settings.settings().cooldown());
+            var yaml = (Map<?, ?>) new org.yaml.snakeyaml.Yaml().load(Files.readString(data.resolve("config.yml")));
+            assertEquals("retained", yaml.get("unrelated"));
+            assertEquals("7", String.valueOf(yaml.get(FrostNovaSettings.RADIUS)));
+        }
+    }
+
+    @Test void invalidFailedUnsafeAndClosedWritesRetainEffectiveState() throws Exception {
+        try (var settings = new FrostNovaSettings(data, defaults())) {
+            for (var entry : Map.of(
+                    FrostNovaSettings.COOLDOWN, "-1",
+                    FrostNovaSettings.RADIUS, "0",
+                    FrostNovaSettings.DURATION, "0",
+                    FrostNovaSettings.BASE, "-1",
+                    FrostNovaSettings.SLOWNESS, "-1").entrySet()) {
+                assertThrows(IllegalArgumentException.class, () -> settings.set(entry.getKey(), entry.getValue()));
+            }
+            assertThrows(IllegalArgumentException.class, () -> settings.set(FrostNovaSettings.COOLDOWN, "0.0000000001"));
+        }
+        var fail = new java.util.concurrent.atomic.AtomicBoolean(true);
+        try (var settings = new FrostNovaSettings(data, defaults(), (from, to) -> {
+            if (fail.getAndSet(false)) throw new java.io.IOException("simulated");
+            Files.move(from, to, StandardCopyOption.REPLACE_EXISTING);
+        })) {
+            assertThrows(java.util.concurrent.ExecutionException.class,
+                () -> settings.set(FrostNovaSettings.RADIUS, "7").toCompletableFuture().get(5, TimeUnit.SECONDS));
+            assertEquals("5", settings.value(FrostNovaSettings.RADIUS));
+        }
+        if (!System.getProperty("os.name", "").toLowerCase().contains("win")) {
+            var unsafe = data.resolve("unsafe"); Files.createDirectories(unsafe);
+            var outside = data.resolve("outside.yml"); Files.writeString(outside, "safe\n");
+            Files.createSymbolicLink(unsafe.resolve("config.yml"), outside);
+            try (var settings = new FrostNovaSettings(unsafe, defaults())) {
+                assertThrows(java.util.concurrent.ExecutionException.class,
+                    () -> settings.set(FrostNovaSettings.DURATION, "8").toCompletableFuture().get(5, TimeUnit.SECONDS));
+                assertEquals("safe\n", Files.readString(outside));
+            }
+        }
+        var closed = new FrostNovaSettings(data.resolve("closed"), defaults()); closed.close();
+        assertThrows(java.util.concurrent.ExecutionException.class,
+            () -> closed.set(FrostNovaSettings.BASE, "8").toCompletableFuture().get(5, TimeUnit.SECONDS));
+        closed.drained().toCompletableFuture().get(5, TimeUnit.SECONDS);
+    }
+
+    private static Map<String, String> defaults() {
+        var values = new LinkedHashMap<String, String>();
+        for (String key : FrostNovaSettings.keys()) values.put(key, FrostNovaSettings.defaultValue(key));
+        return values;
+    }
+}

src/test/java/games/dmg/fantasystick/persistence/GuardianBondSettingsTest.java

@@ -0,0 +1,74 @@
+package games.dmg.fantasystick.persistence;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.StandardCopyOption;
+import java.util.LinkedHashMap;
+import java.util.Map;
+import java.util.concurrent.TimeUnit;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.io.TempDir;
+
+class GuardianBondSettingsTest {
+    @TempDir Path data;
+
+    @Test void serializesPreservesUnrelatedKeysAndPublishesAcknowledgedSnapshotsInOrder() throws Exception {
+        Files.writeString(data.resolve("config.yml"), "unrelated: retained\n");
+        try (var settings = new GuardianBondSettings(data, defaults())) {
+            var range = settings.set(GuardianBondSettings.RANGE, "16").toCompletableFuture();
+            var cooldown = settings.set(GuardianBondSettings.COOLDOWN, "24").toCompletableFuture();
+            var savedRange = range.get(5, TimeUnit.SECONDS); var savedCooldown = cooldown.get(5, TimeUnit.SECONDS);
+            assertEquals(10, settings.settings().range(), 0);
+            settings.publish(savedCooldown); settings.publish(savedRange);
+            assertEquals(16, settings.settings().range(), 0);
+            assertEquals(java.time.Duration.ofSeconds(24), settings.settings().cooldown());
+            var yaml = (Map<?, ?>) new org.yaml.snakeyaml.Yaml().load(Files.readString(data.resolve("config.yml")));
+            assertEquals("retained", yaml.get("unrelated"));
+            assertEquals("16", String.valueOf(yaml.get(GuardianBondSettings.RANGE)));
+        }
+    }
+
+    @Test void invalidFailedUnsafeAndClosedWritesRetainEffectiveState() throws Exception {
+        try (var settings = new GuardianBondSettings(data, defaults())) {
+            for (var entry : Map.of(
+                    GuardianBondSettings.COOLDOWN, "-1",
+                    GuardianBondSettings.RANGE, "0",
+                    GuardianBondSettings.DURATION, "0",
+                    GuardianBondSettings.REDIRECT, "101").entrySet()) {
+                assertThrows(IllegalArgumentException.class, () -> settings.set(entry.getKey(), entry.getValue()));
+            }
+            assertThrows(IllegalArgumentException.class, () -> settings.set(GuardianBondSettings.COOLDOWN, "0.0000000001"));
+        }
+        var fail = new java.util.concurrent.atomic.AtomicBoolean(true);
+        try (var settings = new GuardianBondSettings(data, defaults(), (from, to) -> {
+            if (fail.getAndSet(false)) throw new java.io.IOException("simulated");
+            Files.move(from, to, StandardCopyOption.REPLACE_EXISTING);
+        })) {
+            assertThrows(java.util.concurrent.ExecutionException.class,
+                () -> settings.set(GuardianBondSettings.RANGE, "16").toCompletableFuture().get(5, TimeUnit.SECONDS));
+            assertEquals("10", settings.value(GuardianBondSettings.RANGE));
+        }
+        if (!System.getProperty("os.name", "").toLowerCase().contains("win")) {
+            var unsafe = data.resolve("unsafe"); Files.createDirectories(unsafe);
+            var outside = data.resolve("outside.yml"); Files.writeString(outside, "safe\n");
+            Files.createSymbolicLink(unsafe.resolve("config.yml"), outside);
+            try (var settings = new GuardianBondSettings(unsafe, defaults())) {
+                assertThrows(java.util.concurrent.ExecutionException.class,
+                    () -> settings.set(GuardianBondSettings.DURATION, "8").toCompletableFuture().get(5, TimeUnit.SECONDS));
+                assertEquals("safe\n", Files.readString(outside));
+            }
+        }
+        var closed = new GuardianBondSettings(data.resolve("closed"), defaults()); closed.close();
+        assertThrows(java.util.concurrent.ExecutionException.class,
+            () -> closed.set(GuardianBondSettings.REDIRECT, "40").toCompletableFuture().get(5, TimeUnit.SECONDS));
+        closed.drained().toCompletableFuture().get(5, TimeUnit.SECONDS);
+    }
+
+    private static Map<String, String> defaults() {
+        var values = new LinkedHashMap<String, String>();
+        for (String key : GuardianBondSettings.keys()) values.put(key, GuardianBondSettings.defaultValue(key));
+        return values;
+    }
+}

src/test/java/games/dmg/fantasystick/persistence/HexSettingsTest.java

@@ -0,0 +1,13 @@
+package games.dmg.fantasystick.persistence;
+import static org.junit.jupiter.api.Assertions.*;
+import java.nio.file.*;import java.util.*;import java.util.concurrent.TimeUnit;import org.junit.jupiter.api.Test;import org.junit.jupiter.api.io.TempDir;
+class HexSettingsTest{@TempDir Path data;
+ @Test void serializesPreservesAndPublishesAcknowledgedSnapshots()throws Exception{Files.writeString(data.resolve("config.yml"),"unrelated: retained\n");try(var s=new HexSettings(data,defaults())){
+  var r=s.set(HexSettings.RANGE,"16").toCompletableFuture();var p=s.set(HexSettings.REDUCTION,"30").toCompletableFuture();var rr=r.get(5,TimeUnit.SECONDS);var pp=p.get(5,TimeUnit.SECONDS);
+  assertEquals(12,s.settings().range(),0);s.publish(pp);s.publish(rr);assertEquals(16,s.settings().range(),0);assertEquals(0,new java.math.BigDecimal("30").compareTo(s.settings().reductionPercent()));
+  var y=(Map<?,?>)new org.yaml.snakeyaml.Yaml().load(Files.readString(data.resolve("config.yml")));assertEquals("retained",y.get("unrelated"));assertEquals("16",String.valueOf(y.get(HexSettings.RANGE)));}}
+ @Test void invalidAndFailedWritesRetainState()throws Exception{try(var s=new HexSettings(data,defaults())){for(var e:Map.of(HexSettings.COOLDOWN,"-1",HexSettings.RANGE,"0",HexSettings.DURATION,"0",HexSettings.REDUCTION,"101").entrySet())assertThrows(IllegalArgumentException.class,()->s.set(e.getKey(),e.getValue()));assertThrows(IllegalArgumentException.class,()->s.set(HexSettings.COOLDOWN,"0.0000000001"));}
+  var fail=new java.util.concurrent.atomic.AtomicBoolean(true);try(var s=new HexSettings(data,defaults(),(a,b)->{if(fail.getAndSet(false))throw new java.io.IOException("simulated");Files.move(a,b,StandardCopyOption.REPLACE_EXISTING);})){assertThrows(java.util.concurrent.ExecutionException.class,()->s.set(HexSettings.RANGE,"16").toCompletableFuture().get(5,TimeUnit.SECONDS));assertEquals("12",s.value(HexSettings.RANGE));}}
+ @Test void unsafeAndClosedStoresFailSafely()throws Exception{if(!System.getProperty("os.name","").toLowerCase().contains("win")){var out=data.resolveSibling(data.getFileName()+"-outside");Files.writeString(out,"safe\n");Files.createSymbolicLink(data.resolve("config.yml"),out);try(var s=new HexSettings(data,defaults())){assertThrows(java.util.concurrent.ExecutionException.class,()->s.set(HexSettings.RANGE,"16").toCompletableFuture().get(5,TimeUnit.SECONDS));assertEquals("safe\n",Files.readString(out));}}
+  var s=new HexSettings(data.resolve("closed"),defaults());s.close();assertThrows(java.util.concurrent.ExecutionException.class,()->s.set(HexSettings.RANGE,"16").toCompletableFuture().get(5,TimeUnit.SECONDS));s.drained().toCompletableFuture().get(5,TimeUnit.SECONDS);}
+ private static Map<String,String>defaults(){var m=new LinkedHashMap<String,String>();for(String k:HexSettings.keys())m.put(k,HexSettings.defaultValue(k));return m;}}

src/test/java/games/dmg/fantasystick/persistence/InspireSettingsTest.java

@@ -0,0 +1,13 @@
+package games.dmg.fantasystick.persistence;
+import static org.junit.jupiter.api.Assertions.*;
+import java.nio.file.*;import java.util.*;import java.util.concurrent.TimeUnit;import org.junit.jupiter.api.Test;import org.junit.jupiter.api.io.TempDir;
+class InspireSettingsTest{@TempDir Path data;
+ @Test void serializesPreservesAndPublishesAcknowledgedSnapshots()throws Exception{Files.writeString(data.resolve("config.yml"),"unrelated: retained\n");try(var s=new InspireSettings(data,defaults())){
+  var r=s.set(InspireSettings.RANGE,"16").toCompletableFuture();var p=s.set(InspireSettings.BASE,"8").toCompletableFuture();var rr=r.get(5,TimeUnit.SECONDS);var pp=p.get(5,TimeUnit.SECONDS);
+  assertEquals(12,s.settings().range(),0);s.publish(pp);s.publish(rr);assertEquals(16,s.settings().range(),0);assertEquals(new java.math.BigInteger("8"),s.settings().baseTemporaryHealth());
+  var y=(Map<?,?>)new org.yaml.snakeyaml.Yaml().load(Files.readString(data.resolve("config.yml")));assertEquals("retained",y.get("unrelated"));assertEquals("16",String.valueOf(y.get(InspireSettings.RANGE)));}}
+ @Test void invalidAndFailedWritesRetainState()throws Exception{try(var s=new InspireSettings(data,defaults())){for(var e:Map.of(InspireSettings.COOLDOWN,"-1",InspireSettings.RANGE,"0",InspireSettings.DURATION,"0",InspireSettings.BASE,"-1").entrySet())assertThrows(IllegalArgumentException.class,()->s.set(e.getKey(),e.getValue()));assertThrows(IllegalArgumentException.class,()->s.set(InspireSettings.COOLDOWN,"0.0000000001"));assertThrows(IllegalArgumentException.class,()->s.set(InspireSettings.BASE,"1.5"));}
+  var fail=new java.util.concurrent.atomic.AtomicBoolean(true);try(var s=new InspireSettings(data,defaults(),(a,b)->{if(fail.getAndSet(false))throw new java.io.IOException("simulated");Files.move(a,b,StandardCopyOption.REPLACE_EXISTING);})){assertThrows(java.util.concurrent.ExecutionException.class,()->s.set(InspireSettings.RANGE,"16").toCompletableFuture().get(5,TimeUnit.SECONDS));assertEquals("12",s.value(InspireSettings.RANGE));}}
+ @Test void unsafeAndClosedStoresFailSafely()throws Exception{if(!System.getProperty("os.name","").toLowerCase().contains("win")){var out=data.resolveSibling(data.getFileName()+"-outside");Files.writeString(out,"safe\n");Files.createSymbolicLink(data.resolve("config.yml"),out);try(var s=new InspireSettings(data,defaults())){assertThrows(java.util.concurrent.ExecutionException.class,()->s.set(InspireSettings.RANGE,"16").toCompletableFuture().get(5,TimeUnit.SECONDS));assertEquals("safe\n",Files.readString(out));}}
+  var s=new InspireSettings(data.resolve("closed"),defaults());s.close();assertThrows(java.util.concurrent.ExecutionException.class,()->s.set(InspireSettings.RANGE,"16").toCompletableFuture().get(5,TimeUnit.SECONDS));s.drained().toCompletableFuture().get(5,TimeUnit.SECONDS);}
+ private static Map<String,String>defaults(){var m=new LinkedHashMap<String,String>();for(String k:InspireSettings.keys())m.put(k,InspireSettings.defaultValue(k));return m;}}

src/test/java/games/dmg/fantasystick/persistence/MendingLightSettingsTest.java

@@ -0,0 +1,71 @@
+package games.dmg.fantasystick.persistence;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.StandardCopyOption;
+import java.util.LinkedHashMap;
+import java.util.Map;
+import java.util.concurrent.TimeUnit;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.io.TempDir;
+
+class MendingLightSettingsTest {
+    @TempDir Path data;
+
+    @Test void serializesPreservesUnrelatedKeysAndPublishesAcknowledgedSnapshotsInOrder() throws Exception {
+        Files.writeString(data.resolve("config.yml"), "unrelated: retained\n");
+        try (var settings = new MendingLightSettings(data, defaults())) {
+            var range = settings.set(MendingLightSettings.RANGE, "16").toCompletableFuture();
+            var base = settings.set(MendingLightSettings.BASE_HEALING, "8").toCompletableFuture();
+            var savedRange = range.get(5, TimeUnit.SECONDS); var savedBase = base.get(5, TimeUnit.SECONDS);
+            assertEquals(12, settings.settings().range(), 0);
+            settings.publish(savedBase); settings.publish(savedRange);
+            assertEquals(16, settings.settings().range(), 0);
+            assertEquals(new java.math.BigInteger("8"), settings.settings().baseHealing());
+            var yaml = (Map<?, ?>) new org.yaml.snakeyaml.Yaml().load(Files.readString(data.resolve("config.yml")));
+            assertEquals("retained", yaml.get("unrelated")); assertEquals("16", String.valueOf(yaml.get(MendingLightSettings.RANGE)));
+        }
+    }
+
+    @Test void invalidFailedUnsafeAndClosedWritesRetainEffectiveState() throws Exception {
+        try (var settings = new MendingLightSettings(data, defaults())) {
+            for (var entry : Map.of(MendingLightSettings.COOLDOWN, "-1", MendingLightSettings.RANGE, "0",
+                    MendingLightSettings.BASE_HEALING, "-1").entrySet()) {
+                assertThrows(IllegalArgumentException.class, () -> settings.set(entry.getKey(), entry.getValue()));
+            }
+            assertThrows(IllegalArgumentException.class, () -> settings.set(MendingLightSettings.COOLDOWN, "0.0000000001"));
+            assertThrows(IllegalArgumentException.class, () -> settings.set(MendingLightSettings.BASE_HEALING, "1.5"));
+        }
+        var fail = new java.util.concurrent.atomic.AtomicBoolean(true);
+        try (var settings = new MendingLightSettings(data, defaults(), (from, to) -> {
+            if (fail.getAndSet(false)) throw new java.io.IOException("simulated");
+            Files.move(from, to, StandardCopyOption.REPLACE_EXISTING);
+        })) {
+            assertThrows(java.util.concurrent.ExecutionException.class,
+                () -> settings.set(MendingLightSettings.RANGE, "16").toCompletableFuture().get(5, TimeUnit.SECONDS));
+            assertEquals("12", settings.value(MendingLightSettings.RANGE));
+        }
+        if (!System.getProperty("os.name", "").toLowerCase().contains("win")) {
+            var unsafe = data.resolve("unsafe"); Files.createDirectories(unsafe);
+            var outside = data.resolve("outside.yml"); Files.writeString(outside, "safe\n");
+            Files.createSymbolicLink(unsafe.resolve("config.yml"), outside);
+            try (var settings = new MendingLightSettings(unsafe, defaults())) {
+                assertThrows(java.util.concurrent.ExecutionException.class,
+                    () -> settings.set(MendingLightSettings.RANGE, "16").toCompletableFuture().get(5, TimeUnit.SECONDS));
+                assertEquals("safe\n", Files.readString(outside));
+            }
+        }
+        var closed = new MendingLightSettings(data.resolve("closed"), defaults()); closed.close();
+        assertThrows(java.util.concurrent.ExecutionException.class,
+            () -> closed.set(MendingLightSettings.RANGE, "16").toCompletableFuture().get(5, TimeUnit.SECONDS));
+        closed.drained().toCompletableFuture().get(5, TimeUnit.SECONDS);
+    }
+
+    private static Map<String, String> defaults() {
+        var values = new LinkedHashMap<String, String>();
+        for (String key : MendingLightSettings.keys()) values.put(key, MendingLightSettings.defaultValue(key));
+        return values;
+    }
+}

src/test/java/games/dmg/fantasystick/persistence/PartySettingsTest.java

@@ -0,0 +1,6 @@
+package games.dmg.fantasystick.persistence;
+import static org.junit.jupiter.api.Assertions.*;import java.nio.file.*;import org.junit.jupiter.api.Test;import org.junit.jupiter.api.io.TempDir;
+class PartySettingsTest{@TempDir Path data;
+ @Test void validatesPersistsPreservesUnrelatedAndRejectsStalePublication()throws Exception{assertEquals(6,PartySettings.parse(null));assertEquals(1,PartySettings.parse(1));assertEquals(Integer.MAX_VALUE,PartySettings.parse(Integer.MAX_VALUE));for(Object bad:new Object[]{0,-1,"1",1.5,"2147483648"})assertThrows(IllegalArgumentException.class,()->PartySettings.parse(bad));Files.writeString(data.resolve("config.yml"),"unrelated: keep\nparty-max-size: 6\n");try(var settings=new PartySettings(data,6)){var one=settings.set("2").toCompletableFuture().get();var two=settings.set("3").toCompletableFuture().get();assertEquals(6,settings.maximum());settings.publish(two);settings.publish(one);assertEquals(3,settings.maximum());assertTrue(Files.readString(data.resolve("config.yml")).contains("unrelated: keep"));}}
+ @Test void failedWriteRetainsEffectiveValue()throws Exception{try(var settings=new PartySettings(data,6)){Files.createDirectory(data.resolve("config.yml"));assertThrows(Exception.class,()->settings.set("2").toCompletableFuture().get());assertEquals(6,settings.maximum());}}
+}

src/test/java/games/dmg/fantasystick/persistence/PurifySettingsTest.java

@@ -0,0 +1,69 @@
+package games.dmg.fantasystick.persistence;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.StandardCopyOption;
+import java.util.LinkedHashMap;
+import java.util.Map;
+import java.util.concurrent.TimeUnit;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.io.TempDir;
+
+class PurifySettingsTest {
+    @TempDir Path data;
+
+    @Test void serializesPreservesUnrelatedKeysAndPublishesAcknowledgedSnapshotsInOrder() throws Exception {
+        Files.writeString(data.resolve("config.yml"), "unrelated: retained\n");
+        try (var settings = new PurifySettings(data, defaults())) {
+            var range = settings.set(PurifySettings.RANGE, "16").toCompletableFuture();
+            var cooldown = settings.set(PurifySettings.COOLDOWN, "20").toCompletableFuture();
+            var savedRange = range.get(5, TimeUnit.SECONDS); var savedCooldown = cooldown.get(5, TimeUnit.SECONDS);
+            assertEquals(12, settings.settings().range(), 0);
+            settings.publish(savedCooldown); settings.publish(savedRange);
+            assertEquals(16, settings.settings().range(), 0);
+            assertEquals(java.time.Duration.ofSeconds(20), settings.settings().cooldown());
+            var yaml = (Map<?, ?>) new org.yaml.snakeyaml.Yaml().load(Files.readString(data.resolve("config.yml")));
+            assertEquals("retained", yaml.get("unrelated")); assertEquals("16", String.valueOf(yaml.get(PurifySettings.RANGE)));
+        }
+    }
+
+    @Test void invalidFailedUnsafeAndClosedWritesRetainEffectiveState() throws Exception {
+        try (var settings = new PurifySettings(data, defaults())) {
+            for (var entry : Map.of(PurifySettings.COOLDOWN, "-1", PurifySettings.RANGE, "0").entrySet()) {
+                assertThrows(IllegalArgumentException.class, () -> settings.set(entry.getKey(), entry.getValue()));
+            }
+            assertThrows(IllegalArgumentException.class, () -> settings.set(PurifySettings.COOLDOWN, "0.0000000001"));
+        }
+        var fail = new java.util.concurrent.atomic.AtomicBoolean(true);
+        try (var settings = new PurifySettings(data, defaults(), (from, to) -> {
+            if (fail.getAndSet(false)) throw new java.io.IOException("simulated");
+            Files.move(from, to, StandardCopyOption.REPLACE_EXISTING);
+        })) {
+            assertThrows(java.util.concurrent.ExecutionException.class,
+                () -> settings.set(PurifySettings.RANGE, "16").toCompletableFuture().get(5, TimeUnit.SECONDS));
+            assertEquals("12", settings.value(PurifySettings.RANGE));
+        }
+        if (!System.getProperty("os.name", "").toLowerCase().contains("win")) {
+            var unsafe = data.resolve("unsafe"); Files.createDirectories(unsafe);
+            var outside = data.resolve("outside.yml"); Files.writeString(outside, "safe\n");
+            Files.createSymbolicLink(unsafe.resolve("config.yml"), outside);
+            try (var settings = new PurifySettings(unsafe, defaults())) {
+                assertThrows(java.util.concurrent.ExecutionException.class,
+                    () -> settings.set(PurifySettings.RANGE, "16").toCompletableFuture().get(5, TimeUnit.SECONDS));
+                assertEquals("safe\n", Files.readString(outside));
+            }
+        }
+        var closed = new PurifySettings(data.resolve("closed"), defaults()); closed.close();
+        assertThrows(java.util.concurrent.ExecutionException.class,
+            () -> closed.set(PurifySettings.RANGE, "16").toCompletableFuture().get(5, TimeUnit.SECONDS));
+        closed.drained().toCompletableFuture().get(5, TimeUnit.SECONDS);
+    }
+
+    private static Map<String, String> defaults() {
+        var values = new LinkedHashMap<String, String>();
+        for (String key : PurifySettings.keys()) values.put(key, PurifySettings.defaultValue(key));
+        return values;
+    }
+}