feat(feedback): render routine outcomes in gray

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

@@ -39,11 +39,23 @@ public final class FantasyStickPlugin extends JavaPlugin {
     private games.dmg.fantasystick.party.CharacterPartyDirectory characterParties;
     private games.dmg.fantasystick.party.PartyRegistrarDirectory partyRegistrars;
     private games.dmg.fantasystick.party.PartyRegistrarController partyRegistrarController;
+    private games.dmg.fantasystick.training.TrainingDummyDirectory trainingDummies;
+    private games.dmg.fantasystick.training.TrainingDummyController trainingDummyController;
     private games.dmg.fantasystick.party.PartyManagement partyManagement;
     private games.dmg.fantasystick.party.PartyRegistrarMenus partyRegistrarMenus;
     private games.dmg.fantasystick.party.PartyEvents partyEvents;
+    private games.dmg.fantasystick.shop.FantasyArmorerDirectory armorers;
+    private games.dmg.fantasystick.shop.FantasyArmorerController armorerController;
+    private games.dmg.fantasystick.shop.ArmorMarket armorMarket;
+    private games.dmg.fantasystick.shop.ArmorShop armorShop;
+    private games.dmg.fantasystick.shop.ArmorShopMenus armorShopMenus;
+    private org.bukkit.scheduler.BukkitTask armorMarketPulse;
+    private org.bukkit.scheduler.BukkitTask armorMenuPulse;
     private games.dmg.fantasystick.party.PartyCombat partyCombat;
     private EquipmentAdminCommand admin;
+    private games.dmg.fantasystick.persistence.PlayerFeedbackPreferences feedbackPreferences;
+    private games.dmg.fantasystick.session.FantasyFeedbackCommand feedbackCommand;
+    private games.dmg.fantasystick.presentation.CombatFeedback combatFeedback;
     private volatile Object lifetime;
     private CharacterPresentation presentation;
     private ProtocolPresentation protocolPresentation;
@@ -57,6 +69,7 @@ public final class FantasyStickPlugin extends JavaPlugin {
     private games.dmg.fantasystick.ability.AbilityRegistry abilityRegistry;
     private games.dmg.fantasystick.ability.AbilityEngine abilityEngine;
     private games.dmg.fantasystick.ability.Fireball fireball;
+    private games.dmg.fantasystick.persistence.FireballSettings fireballSettings;
     private games.dmg.fantasystick.ability.FrostShard frostShard;
     private games.dmg.fantasystick.persistence.FrostShardSettings frostShardSettings;
     private games.dmg.fantasystick.ability.Longbow longbow;
@@ -104,7 +117,13 @@ public final class FantasyStickPlugin extends JavaPlugin {
     private games.dmg.fantasystick.persistence.RoleplaySettings roleplaySettings;
     private games.dmg.fantasystick.persistence.PartySettings partySettings;
     private games.dmg.fantasystick.persistence.PartyEconomySettings partyEconomySettings;
+    private games.dmg.fantasystick.persistence.GearSettings gearSettings;
     private games.dmg.fantasystick.persistence.CoinSettings coinSettings;
+    private games.dmg.fantasystick.persistence.HardMobXpSettings hardMobXpSettings;
+    private games.dmg.fantasystick.persistence.AdventureQuestSettings adventureQuestSettings;
+    private games.dmg.fantasystick.adventure.AdventureQuestDirectory adventureQuests;
+    private games.dmg.fantasystick.adventure.AdventureQuestController adventureQuestController;
+    private games.dmg.fantasystick.adventure.AdventureQuestCommands adventureQuestCommands;
     private games.dmg.fantasystick.persistence.SheetResourcePackSettings sheetResourcePackSettings;
     private games.dmg.fantasystick.presentation.SheetResourcePack sheetResourcePack;
     private games.dmg.fantasystick.session.NutritionPolicy nutritionPolicy;
@@ -149,15 +168,19 @@ public final class FantasyStickPlugin extends JavaPlugin {
             var partyMaximum = games.dmg.fantasystick.persistence.PartySettings.parse(
                 getConfig().get(games.dmg.fantasystick.persistence.PartySettings.KEY));
             var partyEconomyConfiguration = new java.util.LinkedHashMap<String, String>();
-            for (String key : games.dmg.fantasystick.persistence.PartyEconomySettings.keys()) {
-                partyEconomyConfiguration.put(key, getConfig().getString(key,
-                    games.dmg.fantasystick.persistence.PartyEconomySettings.defaultValue(key)));
-            }
+            for (String key : games.dmg.fantasystick.persistence.PartyEconomySettings.keys()) partyEconomyConfiguration.put(key, getConfig().getString(key,games.dmg.fantasystick.persistence.PartyEconomySettings.defaultValue(key)));
+            var gearConfiguration=new java.util.LinkedHashMap<String,String>();for(String key:games.dmg.fantasystick.persistence.GearSettings.keys())gearConfiguration.put(key,getConfig().getString(key,games.dmg.fantasystick.persistence.GearSettings.defaultValue(key)));
             var coinConfiguration = new java.util.LinkedHashMap<String, String>();
             for (String key : games.dmg.fantasystick.persistence.CoinSettings.keys()) {
                 coinConfiguration.put(key, getConfig().getString(key,
                     games.dmg.fantasystick.persistence.CoinSettings.defaultValue(key)));
             }
+            var adventureQuestConfiguration = new java.util.LinkedHashMap<String, String>();
+            for (String key : games.dmg.fantasystick.persistence.AdventureQuestSettings.keys()) {
+                adventureQuestConfiguration.put(key, getConfig().getString(key,
+                    games.dmg.fantasystick.persistence.AdventureQuestSettings.defaultValue(key)));
+            }
+            games.dmg.fantasystick.persistence.AdventureQuestSettings.parse(adventureQuestConfiguration);
             var recoveryConfiguration = outOfCombatRecoveryConfiguration();
             var recoveryInitial = games.dmg.fantasystick.persistence.OutOfCombatRecoverySettings.parse(recoveryConfiguration);
             var quickerRegenerationInitial = games.dmg.fantasystick.persistence.QuickerRegenerationSettings.parse(
@@ -174,8 +197,13 @@ public final class FantasyStickPlugin extends JavaPlugin {
                 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();
+            var hardMobXpConfiguration = getConfig().getString(
+                games.dmg.fantasystick.persistence.HardMobXpSettings.KEY,
+                games.dmg.fantasystick.persistence.HardMobXpSettings.DEFAULT);
+            var hardMobXp = games.dmg.fantasystick.persistence.HardMobXpSettings.parse(hardMobXpConfiguration);
+            var rewardRules = combatRewardRules(hardMobXp);
+            var fireballConfiguration = fireballConfiguration();
+            var fireballInitial = games.dmg.fantasystick.persistence.FireballSettings.parse(fireballConfiguration);
             var greatSwordSettings = greatSwordSettings();
             var frostShardConfiguration = frostShardConfiguration();
             var frostShardInitial = games.dmg.fantasystick.persistence.FrostShardSettings.parse(frostShardConfiguration);
@@ -215,16 +243,34 @@ public final class FantasyStickPlugin extends JavaPlugin {
                 getConfig().get(games.dmg.fantasystick.persistence.AdminReviveSettings.KEY));
             partyEconomySettings = new games.dmg.fantasystick.persistence.PartyEconomySettings(
                 getDataFolder().toPath(), partyEconomyConfiguration);
+            gearSettings=new games.dmg.fantasystick.persistence.GearSettings(getDataFolder().toPath(),gearConfiguration);
             coinSettings = new games.dmg.fantasystick.persistence.CoinSettings(getDataFolder().toPath(), coinConfiguration);
+            hardMobXpSettings = new games.dmg.fantasystick.persistence.HardMobXpSettings(
+                getDataFolder().toPath(), hardMobXp.toString());
+            adventureQuestSettings = new games.dmg.fantasystick.persistence.AdventureQuestSettings(
+                getDataFolder().toPath(), adventureQuestConfiguration);
             var factory = new CharacterFactory(coinSettings::rules);
             characters = new CharacterStorage(new YamlCharacterRepository(getDataFolder().toPath()), Clock.systemUTC(),
                 coinSettings::rules, java.util.random.RandomGenerator.getDefault());
+            var armorRandom=java.util.random.RandomGenerator.getDefault();
+            armorMarket=new games.dmg.fantasystick.shop.ArmorMarket(
+                new games.dmg.fantasystick.persistence.YamlArmorCatalogRepository(getDataFolder().toPath()),
+                new games.dmg.fantasystick.persistence.ArmorPurchaseOperationStore(getDataFolder().toPath()),
+                characters,gearSettings::rules,Clock.systemUTC(),
+                (minimum,maximum)->(int)armorRandom.nextLong(minimum,(long)maximum+1));
             crafting = new ManualCraftingController(characters, () -> factory.create(rules),
                 task -> getServer().getScheduler().runTask(this, task),
                 player -> new PlayerSheetDrops(player, event -> getServer().getPluginManager().callEvent(event)),
                 problem -> getLogger().log(Level.WARNING, "Character craft " + problem.operation() + " for player "
                     + problem.player() + "; character records " + problem.characters(), problem.cause()));
             java.util.function.Consumer<Runnable> nextTick = task -> getServer().getScheduler().runTask(this, task);
+            try {
+                feedbackPreferences = new games.dmg.fantasystick.persistence.PlayerFeedbackPreferences(getDataFolder().toPath());
+            } catch (java.io.IOException invalidPreferences) {
+                throw new java.io.UncheckedIOException("Player feedback preferences could not be loaded", invalidPreferences);
+            }
+            feedbackCommand = new games.dmg.fantasystick.session.FantasyFeedbackCommand(feedbackPreferences, nextTick,
+                failure -> getLogger().log(Level.WARNING, "Player feedback preference failed", failure));
             java.util.function.Consumer<Throwable> presentationFailures = problem ->
                 getLogger().log(Level.WARNING, "Character presentation failed", problem);
             // This supplier belongs to one enable, never the mutable plugin field after re-enable.
@@ -261,8 +307,14 @@ public final class FantasyStickPlugin extends JavaPlugin {
                     new games.dmg.fantasystick.persistence.YamlPartyRepository(getDataFolder().toPath()), partySettings::maximum);
                 partyRegistrars = new games.dmg.fantasystick.party.PartyRegistrarDirectory(
                     new games.dmg.fantasystick.persistence.YamlPartyRegistrarRepository(getDataFolder().toPath()));
-            } catch (java.io.IOException invalidPartyState) {
-                throw new java.io.UncheckedIOException("Persistent party state could not be loaded", invalidPartyState);
+                trainingDummies = new games.dmg.fantasystick.training.TrainingDummyDirectory(
+                    new games.dmg.fantasystick.persistence.YamlTrainingDummyRepository(getDataFolder().toPath()));
+                adventureQuests = new games.dmg.fantasystick.adventure.AdventureQuestDirectory(
+                    new games.dmg.fantasystick.persistence.YamlAdventureQuestRepository(getDataFolder().toPath()),
+                    Clock.systemUTC(), adventureQuestSettings::rules, java.util.random.RandomGenerator.getDefault());
+                armorers=new games.dmg.fantasystick.shop.FantasyArmorerDirectory(new games.dmg.fantasystick.persistence.YamlFantasyArmorerRepository(getDataFolder().toPath()));
+            } catch (java.io.IOException invalidManagedState) {
+                throw new java.io.UncheckedIOException("Persistent party, shop, training or adventure state could not be loaded", invalidManagedState);
             }
             characterParties.suspend();
             sheetResourcePack = new games.dmg.fantasystick.presentation.SheetResourcePack(sheetResourcePackSettings,
@@ -271,6 +323,8 @@ public final class FantasyStickPlugin extends JavaPlugin {
                 notice -> notifyPlayer(generation, notice), diagnostics, presentation, adventureSettings::enabled, gameModes);
             sessions.attachSwitchDelay(switchDelaySettings::delay);
             sessions.attachRoleplayDisabled(roleplaySettings::disabled);
+            combatFeedback = new games.dmg.fantasystick.presentation.CombatFeedback(feedbackPreferences, sessions);
+            trainingDummyController = new games.dmg.fantasystick.training.TrainingDummyController(this, trainingDummies);
             parties = new games.dmg.fantasystick.party.PartyRoster(characterParties, sessions, partySettings::maximum);
             characterParties.attachEnded(former -> nextTick.accept(() -> {
                 String message = "Party ended: " + former.displayName();
@@ -299,7 +353,9 @@ public final class FantasyStickPlugin extends JavaPlugin {
                 problem -> getLogger().log(Level.WARNING, "Combat reward failed for character " + problem.character(), problem.cause()));
             sessions.attachPvpDefeat(combatExperience::consumePvpDefeat);
             abilityRegistry = new games.dmg.fantasystick.ability.AbilityRegistry();
-            fireball = new games.dmg.fantasystick.ability.Fireball(fireballSettings);
+            fireballSettings = new games.dmg.fantasystick.persistence.FireballSettings(
+                getDataFolder().toPath(), fireballConfiguration);
+            fireball = new games.dmg.fantasystick.ability.Fireball(fireballInitial);
             frostShardSettings = new games.dmg.fantasystick.persistence.FrostShardSettings(
                 getDataFolder().toPath(), frostShardConfiguration);
             frostShard = new games.dmg.fantasystick.ability.FrostShard(frostShardInitial);
@@ -393,6 +449,7 @@ public final class FantasyStickPlugin extends JavaPlugin {
             abilityRegistry.register(greatSword.definition());
             abilityRegistry.register(revive.definition());
             sessions.attachAbilityRegistry(abilityRegistry);
+            var gearItems=new games.dmg.fantasystick.items.GearItems(this);sessions.attachGear(gearItems);
             vitals = new games.dmg.fantasystick.session.SessionVitals();
             sessions.attachVitals(vitals);
             nutritionPolicy = new games.dmg.fantasystick.session.NutritionPolicy(sessions);
@@ -402,7 +459,7 @@ public final class FantasyStickPlugin extends JavaPlugin {
                 Clock.systemUTC(), nextTick, event -> getServer().getPluginManager().callEvent(event),
                 games.dmg.fantasystick.session.NativeHealthLimit::read,
                 problem -> getLogger().log(Level.WARNING,
-                    "Out-of-combat recovery failed for character " + problem.character(), problem.cause()));
+                    "Out-of-combat recovery failed for character " + problem.character(), problem.cause()), combatFeedback);
             quickerRegenerationSettings = new games.dmg.fantasystick.persistence.QuickerRegenerationSettings(
                 getDataFolder().toPath(), quickerRegenerationInitial.bonus().toString());
             quickerRegeneration = new games.dmg.fantasystick.passive.QuickerRegenerationI(quickerRegenerationInitial);
@@ -413,7 +470,8 @@ public final class FantasyStickPlugin extends JavaPlugin {
                 getDataFolder().toPath(), healthStealInitial.healing().toString());
             healthSteal = new games.dmg.fantasystick.passive.HealthSteal(healthStealInitial, characters, sessions, nextTick,
                 event -> getServer().getPluginManager().callEvent(event), games.dmg.fantasystick.session.NativeHealthLimit::read,
-                problem -> getLogger().log(Level.WARNING, "Health Steal failed for character " + problem.character(), problem.cause()));
+                problem -> getLogger().log(Level.WARNING, "Health Steal failed for character " + problem.character(), problem.cause()),
+                combatFeedback);
             speedI = new games.dmg.fantasystick.passive.SpeedI(sessions);
             lowLightVision = new games.dmg.fantasystick.passive.LowLightVision(sessions);
             passiveRegistry = new games.dmg.fantasystick.passive.PassiveRegistry();
@@ -422,6 +480,7 @@ public final class FantasyStickPlugin extends JavaPlugin {
             passiveRegistry.register(healthSteal.definition());
             passiveRegistry.register(speedI.definition());
             passiveRegistry.register(lowLightVision.definition());
+            passiveRegistry.register(new games.dmg.fantasystick.passive.StickKnockback().definition());
             passiveEngine = new games.dmg.fantasystick.passive.PassiveEngine(passiveRegistry, characters, sessions, nextTick,
                 problem -> getLogger().log(Level.WARNING, "Passive change failed for character " + problem.character()
                     + "; passive " + problem.passive(), problem.cause()));
@@ -443,7 +502,7 @@ public final class FantasyStickPlugin extends JavaPlugin {
                 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 -> { },
+                Clock.systemUTC(), nextTick, abilityScheduler, report -> { }, combatFeedback, trainingDummyController,
                 problem -> getLogger().log(Level.WARNING, "Ability engine failed for character " + problem.character()
                     + "; ability " + problem.ability(), problem.cause()));
             abilityEngine.install(this);
@@ -454,7 +513,8 @@ public final class FantasyStickPlugin extends JavaPlugin {
                     var player = getServer().getPlayer(id);
                     return net.kyori.adventure.text.Component.text(name != null ? name : player == null ? id.toString() : player.getName());
                 }, abilityRegistry, abilityEngine, passiveRegistry, passiveEngine);
-            var localBasicAttack = new games.dmg.fantasystick.combat.BasicAttack(sessions);
+            var localBasicAttack = new games.dmg.fantasystick.combat.BasicAttack(
+                sessions, Clock.systemUTC(), combatFeedback, trainingDummyController);
             basicAttack = localBasicAttack;
             sessionEvents = new EquipmentSessionEvents(sessions, nextTick, diagnostics, input -> {
                 books.accept(input);
@@ -462,6 +522,7 @@ public final class FantasyStickPlugin extends JavaPlugin {
                 abilityEngine.accept(input);
             });
             sessionEvents.attachAbilityRegistry(abilityRegistry);
+            sessionEvents.attachGear(gearItems);
             partyManagement = new games.dmg.fantasystick.party.PartyManagement(characterParties, partyRegistrars,
                 characters, sessions, partyEconomySettings,
                 new games.dmg.fantasystick.persistence.PartyOperationStore(getDataFolder().toPath()), nextTick,
@@ -469,6 +530,22 @@ public final class FantasyStickPlugin extends JavaPlugin {
             partyRegistrarMenus = new games.dmg.fantasystick.party.PartyRegistrarMenus(this, partyManagement);
             partyRegistrarController = new games.dmg.fantasystick.party.PartyRegistrarController(this, partyRegistrars,
                 partyRegistrarMenus::open);
+            armorShop=new games.dmg.fantasystick.shop.ArmorShop(armorers,sessions,armorMarket,nextTick,
+                failure->getLogger().log(Level.WARNING,"Fantasy Armorer purchase failed",failure));
+            armorShopMenus=new games.dmg.fantasystick.shop.ArmorShopMenus(this,armorShop);
+            var localArmorMenus=armorShopMenus;
+            armorMarket.attachListener(catalog->{if(lifetime!=generation)return;try{nextTick.accept(()->{
+                if(lifetime==generation)localArmorMenus.refreshOpen();});}
+                catch(RuntimeException failure){if(lifetime==generation)getLogger().log(Level.WARNING,"Fantasy Armorer menu refresh failed",failure);}});
+            armorerController=new games.dmg.fantasystick.shop.FantasyArmorerController(this,armorers,armorShopMenus::open);
+            adventureQuestController = new games.dmg.fantasystick.adventure.AdventureQuestController(this,
+                adventureQuests, adventureQuestSettings, sessions, parties, characters, rules, nextTick,
+                Clock.systemUTC(), java.util.random.RandomGenerator.getDefault());
+            adventureQuestCommands = new games.dmg.fantasystick.adventure.AdventureQuestCommands(
+                this, adventureQuests, adventureQuestController, nextTick);
+            combatExperience.attachExcluded(adventureQuestController::managed);
+            sessionEvents.attachManagedInteractionTarget(entity -> partyRegistrarController.tagged(entity)
+                || armorerController.tagged(entity) || adventureQuestController.giver(entity));
             admin = new EquipmentAdminCommand(receipts, sessions, getServer(), nextTick,
                 problem -> getLogger().log(Level.WARNING, "Equipment admin " + problem.operation()
                     + " for player " + problem.player(), problem.cause()), adventureSettings,
@@ -476,6 +553,7 @@ public final class FantasyStickPlugin extends JavaPlugin {
                 quickstepSettings, quickstep, secondWindSettings, secondWind,
                 stoneSkinSettings, stoneSkin, shieldBashSettings, shieldBash, hexSettings, hex,
                 inspireSettings, inspire, abilityRegistry);
+            admin.attachFireball(fireballSettings, fireball);
             admin.attachMendingLight(mendingLightSettings, mendingLight);
             admin.attachPurify(purifySettings, purify);
             admin.attachGuardianBond(guardianBondSettings, guardianBond);
@@ -495,7 +573,13 @@ public final class FantasyStickPlugin extends JavaPlugin {
             admin.attachPartySettings(partySettings);
             admin.attachPartyEconomySettings(partyEconomySettings);
             admin.attachPartyRegistrars(partyRegistrars, partyRegistrarController);
+            admin.attachTrainingDummies(trainingDummies, trainingDummyController);
+            admin.attachGearSettings(gearSettings);
+            admin.attachArmorers(armorers,armorerController);
+            admin.attachArmorMarket(armorMarket);
             admin.attachCoinSettings(coinSettings);
+            admin.attachHardMobXpSettings(hardMobXpSettings, combatExperience);
+            admin.attachAdventureQuests(adventureQuestCommands, adventureQuestSettings);
             admin.attachSheetResourcePack(sheetResourcePackSettings, sheetResourcePack);
             admin.attachOutOfCombatRecovery(outOfCombatRecoverySettings, outOfCombatRecovery);
             admin.attachQuickerRegeneration(quickerRegenerationSettings, quickerRegeneration, passiveRegistry);
@@ -508,6 +592,10 @@ public final class FantasyStickPlugin extends JavaPlugin {
             var command = java.util.Objects.requireNonNull(getCommand("fantasystick"), "Missing packaged fantasystick command");
             command.setExecutor(admin);
             command.setTabCompleter(admin);
+            var playerFeedbackCommand = java.util.Objects.requireNonNull(getCommand("fantasyfeedback"),
+                "Missing packaged fantasyfeedback command");
+            playerFeedbackCommand.setExecutor(feedbackCommand);
+            playerFeedbackCommand.setTabCompleter(feedbackCommand);
             getServer().getPluginManager().registerEvents(crafting, this);
             getServer().getPluginManager().registerEvents(guard, this);
             getServer().getPluginManager().registerEvents(anvilNames, this);
@@ -516,8 +604,20 @@ public final class FantasyStickPlugin extends JavaPlugin {
             getServer().getPluginManager().registerEvents(partyEvents, this);
             getServer().getPluginManager().registerEvents(partyCombat, this);
             getServer().getPluginManager().registerEvents(partyRegistrarController, this);
+            getServer().getPluginManager().registerEvents(trainingDummyController, this);
             getServer().getPluginManager().registerEvents(partyRegistrarMenus, this);
+            getServer().getPluginManager().registerEvents(armorerController,this);
+            getServer().getPluginManager().registerEvents(armorShopMenus,this);
+            getServer().getPluginManager().registerEvents(adventureQuestController,this);
             partyRegistrarController.install();
+            trainingDummyController.install();
+            armorerController.install();
+            adventureQuestController.install();
+            var localArmorMarket=armorMarket;
+            armorMarketPulse=getServer().getScheduler().runTaskTimer(this,()->{if(lifetime!=generation)return;
+                localArmorMarket.current().whenComplete((catalog,failure)->{
+                    if(failure!=null&&lifetime==generation)getLogger().log(Level.WARNING,"Scheduled Fantasy Armorer restock check failed",failure);});},20L,20L);
+            armorMenuPulse=getServer().getScheduler().runTaskTimer(this,localArmorMenus::refreshOpen,1200L,1200L);
             partyCombat.install(this);
             getServer().getPluginManager().registerEvents(healthSteal, this);
             getServer().getPluginManager().registerEvents(combatExperience, this);
@@ -575,6 +675,9 @@ public final class FantasyStickPlugin extends JavaPlugin {
         var closingProtocol = protocolPresentation; protocolPresentation = null;
         var closingChat = chatNames; chatNames = null;
         var closingAdmin = admin; admin = null;
+        var closingFeedbackCommand = feedbackCommand; feedbackCommand = null;
+        var closingFeedbackPreferences = feedbackPreferences; feedbackPreferences = null;
+        combatFeedback = null;
         var closingEvents = sessionEvents; sessionEvents = null;
         var closingBooks = books; books = null;
         var closingPartyEvents = partyEvents; partyEvents = null;
@@ -583,8 +686,17 @@ public final class FantasyStickPlugin extends JavaPlugin {
         var closingCharacterParties = characterParties; characterParties = null;
         var closingPartyRegistrars = partyRegistrars; partyRegistrars = null;
         var closingPartyRegistrarController = partyRegistrarController; partyRegistrarController = null;
+        var closingTrainingDummies = trainingDummies; trainingDummies = null;
+        var closingTrainingDummyController = trainingDummyController; trainingDummyController = null;
+        var closingAdventureQuests = adventureQuests; adventureQuests = null;
+        var closingAdventureQuestController = adventureQuestController; adventureQuestController = null;
+        adventureQuestCommands = null;
         var closingPartyRegistrarMenus = partyRegistrarMenus; partyRegistrarMenus = null;
         var closingPartyManagement = partyManagement; partyManagement = null;
+        var closingArmorers=armorers;armorers=null;var closingArmorerController=armorerController;armorerController=null;
+        var closingArmorShopMenus=armorShopMenus;armorShopMenus=null;armorShop=null;
+        var closingArmorMarket=armorMarket;armorMarket=null;var closingArmorMarketPulse=armorMarketPulse;armorMarketPulse=null;
+        var closingArmorMenuPulse=armorMenuPulse;armorMenuPulse=null;
         var closingCrafting = crafting; crafting = null;
         var closingGuard = guard; guard = null;
         var closingAnvil = anvilNames; anvilNames = null;
@@ -600,6 +712,7 @@ public final class FantasyStickPlugin extends JavaPlugin {
         var closingCombatExperience = combatExperience; combatExperience = null;
         var closingAbilityEngine = abilityEngine; abilityEngine = null;
         var closingFireball = fireball; fireball = null;
+        var closingFireballSettings = fireballSettings; fireballSettings = null;
         var closingFrostShard = frostShard; frostShard = null;
         var closingFrostSettings = frostShardSettings; frostShardSettings = null;
         var closingLongbow = longbow; longbow = null;
@@ -637,7 +750,10 @@ public final class FantasyStickPlugin extends JavaPlugin {
         var closingRoleplaySettings = roleplaySettings; roleplaySettings = null;
         var closingPartySettings = partySettings; partySettings = null;
         var closingPartyEconomySettings = partyEconomySettings; partyEconomySettings = null;
+        var closingGearSettings=gearSettings;gearSettings=null;
         var closingCoinSettings = coinSettings; coinSettings = null;
+        var closingHardMobXpSettings = hardMobXpSettings; hardMobXpSettings = null;
+        var closingAdventureQuestSettings = adventureQuestSettings; adventureQuestSettings = null;
         var closingSheetResourcePackSettings = sheetResourcePackSettings; sheetResourcePackSettings = null;
         var closingSheetResourcePack = sheetResourcePack; sheetResourcePack = null;
         var closingTemporaryHealth = temporaryHealth; temporaryHealth = null;
@@ -666,7 +782,10 @@ public final class FantasyStickPlugin extends JavaPlugin {
         if (closingPresentation != null) cleanup("presentation", closingPresentation::close);
         if (closingProtocol != null) cleanup("protocol presentation", closingProtocol::close);
         if (closingAdmin != null) cleanup("admin command", closingAdmin::close);
+        if (closingFeedbackCommand != null) cleanup("feedback command", closingFeedbackCommand::close);
+        if (closingFeedbackPreferences != null) cleanup("feedback preferences", closingFeedbackPreferences::close);
         if (closingSettings != null) cleanup("configuration", closingSettings::close);
+        if (closingFireballSettings != null) cleanup("Fireball configuration", closingFireballSettings::close);
         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);
@@ -697,7 +816,12 @@ public final class FantasyStickPlugin extends JavaPlugin {
         if (closingRoleplaySettings != null) cleanup("roleplay configuration", closingRoleplaySettings::close);
         if (closingPartySettings != null) cleanup("party configuration", closingPartySettings::close);
         if (closingPartyEconomySettings != null) cleanup("party economy configuration", closingPartyEconomySettings::close);
+        if(closingGearSettings!=null)cleanup("gear configuration",closingGearSettings::close);
         if (closingCoinSettings != null) cleanup("coin configuration", closingCoinSettings::close);
+        if (closingHardMobXpSettings != null) cleanup("hard-mob XP configuration", closingHardMobXpSettings::close);
+        if (closingAdventureQuestSettings != null) cleanup("adventure quest configuration", closingAdventureQuestSettings::close);
+        if (closingAdventureQuests != null) cleanup("adventure quest persistence", closingAdventureQuests::close);
+        if (closingAdventureQuestController != null) cleanup("adventure quests", closingAdventureQuestController::close);
         if (closingSheetResourcePackSettings != null) cleanup("sheet resource-pack configuration", closingSheetResourcePackSettings::close);
         if (closingSheetResourcePack != null) cleanup("sheet resource-pack", closingSheetResourcePack::close);
         if (closingOutOfCombatRecoverySettings != null) cleanup("out-of-combat recovery configuration", closingOutOfCombatRecoverySettings::close);
@@ -705,16 +829,31 @@ public final class FantasyStickPlugin extends JavaPlugin {
         if (closingQuickerRegenerationIISettings != null) cleanup("Quicker Regeneration II configuration", closingQuickerRegenerationIISettings::close);
         if (closingHealthStealSettings != null) cleanup("Health Steal configuration", closingHealthStealSettings::close);
         configurationDrain = java.util.concurrent.CompletableFuture.allOf(
+            closingFeedbackPreferences == null ? java.util.concurrent.CompletableFuture.completedFuture(null)
+                : closingFeedbackPreferences.drained().toCompletableFuture(),
             closingCharacterParties == null ? java.util.concurrent.CompletableFuture.completedFuture(null)
                 : closingCharacterParties.drained().toCompletableFuture(),
             closingPartyRegistrars == null ? java.util.concurrent.CompletableFuture.completedFuture(null)
                 : closingPartyRegistrars.drained().toCompletableFuture(),
+            closingTrainingDummies == null ? java.util.concurrent.CompletableFuture.completedFuture(null)
+                : closingTrainingDummies.drained().toCompletableFuture(),
             closingPartyManagement == null ? java.util.concurrent.CompletableFuture.completedFuture(null)
                 : closingPartyManagement.drained().toCompletableFuture(),
+            closingArmorers==null?java.util.concurrent.CompletableFuture.completedFuture(null):closingArmorers.drained().toCompletableFuture(),
+            closingArmorMarket==null?java.util.concurrent.CompletableFuture.completedFuture(null):closingArmorMarket.drained().toCompletableFuture(),
+            closingGearSettings==null?java.util.concurrent.CompletableFuture.completedFuture(null):closingGearSettings.drained().toCompletableFuture(),
             closingPartyEconomySettings == null ? java.util.concurrent.CompletableFuture.completedFuture(null)
                 : closingPartyEconomySettings.drained().toCompletableFuture(),
+            closingHardMobXpSettings == null ? java.util.concurrent.CompletableFuture.completedFuture(null)
+                : closingHardMobXpSettings.drained().toCompletableFuture(),
+            closingAdventureQuestSettings == null ? java.util.concurrent.CompletableFuture.completedFuture(null)
+                : closingAdventureQuestSettings.drained().toCompletableFuture(),
+            closingAdventureQuests == null ? java.util.concurrent.CompletableFuture.completedFuture(null)
+                : closingAdventureQuests.drained().toCompletableFuture(),
             closingSettings == null ? java.util.concurrent.CompletableFuture.completedFuture(null)
                 : closingSettings.drained().toCompletableFuture(),
+            closingFireballSettings == null ? java.util.concurrent.CompletableFuture.completedFuture(null)
+                : closingFireballSettings.drained().toCompletableFuture(),
             closingFrostSettings == null ? java.util.concurrent.CompletableFuture.completedFuture(null)
                 : closingFrostSettings.drained().toCompletableFuture(),
             closingLongbowSettings == null ? java.util.concurrent.CompletableFuture.completedFuture(null)
@@ -798,6 +937,14 @@ public final class FantasyStickPlugin extends JavaPlugin {
         if (closingPartyManagement != null) cleanup("party management", closingPartyManagement::close);
         if (closingPartyRegistrarController != null) cleanup("party registrar entities", closingPartyRegistrarController::close);
         if (closingPartyRegistrars != null) cleanup("party registrars", closingPartyRegistrars::close);
+        if (closingTrainingDummyController != null) cleanup("training dummy entities", closingTrainingDummyController::close);
+        if (closingTrainingDummies != null) cleanup("training dummies", closingTrainingDummies::close);
+        if(closingArmorMarketPulse!=null)cleanup("armor market schedule",closingArmorMarketPulse::cancel);
+        if(closingArmorMenuPulse!=null)cleanup("armor menu schedule",closingArmorMenuPulse::cancel);
+        if(closingArmorShopMenus!=null)cleanup("armor shop menus",closingArmorShopMenus::close);
+        if(closingArmorerController!=null)cleanup("armorer entities",closingArmorerController::close);
+        if(closingArmorMarket!=null)cleanup("armor market",closingArmorMarket::close);
+        if(closingArmorers!=null)cleanup("armorers",closingArmorers::close);
         if (closingPartyCombat != null) cleanup("party combat", closingPartyCombat::close);
         if (closingEvents != null) cleanup("session events", closingEvents::close);
         if (closingCrafting != null) cleanup("craft attempts", closingCrafting::close);
@@ -808,7 +955,10 @@ public final class FantasyStickPlugin extends JavaPlugin {
         unregister(closingPartyEvents);
         unregister(closingPartyCombat);
         unregister(closingPartyRegistrarController);
+        unregister(closingTrainingDummyController);
         unregister(closingPartyRegistrarMenus);
+        unregister(closingArmorerController);unregister(closingArmorShopMenus);
+        unregister(closingAdventureQuestController);
         unregister(closingCombatExperience);
         unregister(closingHealthSteal);
         unregister(closingFireball);
@@ -868,30 +1018,26 @@ public final class FantasyStickPlugin extends JavaPlugin {
         }
     }
 
-    private games.dmg.fantasystick.progression.CombatRewardRules combatRewardRules() {
+    private games.dmg.fantasystick.progression.CombatRewardRules combatRewardRules(java.math.BigInteger hard) {
         try {
             var passive = new java.math.BigInteger(getConfig().getString("passive-xp", "1"));
             var ordinary = new java.math.BigInteger(getConfig().getString("ordinary-xp", "10"));
             var boss = new java.math.BigInteger(getConfig().getString("boss-xp", "100"));
             var spacing = new java.math.BigDecimal(getConfig().getString("restricted-kill-spacing-blocks", "3"));
-            return new games.dmg.fantasystick.progression.CombatRewardRules(passive, ordinary, boss, spacing);
+            return new games.dmg.fantasystick.progression.CombatRewardRules(passive, ordinary, hard, boss, spacing);
         } catch (NumberFormatException invalid) {
             throw new IllegalArgumentException("Combat reward settings must be decimal numbers", invalid);
         }
     }
 
-    private games.dmg.fantasystick.ability.Fireball.Settings fireballSettings() {
-        try {
-            var base = new java.math.BigInteger(getConfig().getString("fireball-base-damage", "6"));
-            var cooldown = java.time.Duration.ofSeconds(new java.math.BigInteger(
-                getConfig().getString("fireball-cooldown-seconds", "4")).longValueExact());
-            double range = new java.math.BigDecimal(getConfig().getString("fireball-range-blocks", "32")).doubleValue();
-            var lifetime = java.time.Duration.ofSeconds(new java.math.BigInteger(
-                getConfig().getString("fireball-lifetime-seconds", "5")).longValueExact());
-            return new games.dmg.fantasystick.ability.Fireball.Settings(base, cooldown, range, lifetime);
-        } catch (ArithmeticException | NumberFormatException invalid) {
-            throw new IllegalArgumentException("Fireball settings must use supported nonnegative numeric values", invalid);
+    private java.util.Map<String, String> fireballConfiguration() {
+        var values = new java.util.LinkedHashMap<String, String>();
+        for (String key : games.dmg.fantasystick.persistence.FireballSettings.keys()) {
+            values.put(key, getConfig().getString(key,
+                games.dmg.fantasystick.persistence.FireballSettings.defaultValue(key)));
         }
+        games.dmg.fantasystick.persistence.FireballSettings.parse(values);
+        return java.util.Map.copyOf(values);
     }
 
     private java.util.Map<String, String> outOfCombatRecoveryConfiguration() {
@@ -1074,7 +1220,7 @@ public final class FantasyStickPlugin extends JavaPlugin {
     private games.dmg.fantasystick.ability.GreatSword.Settings greatSwordSettings() {
         try {
             var base = new java.math.BigInteger(getConfig().getString("great-sword-base-damage", "7"));
-            var seconds = new java.math.BigDecimal(getConfig().getString("great-sword-recovery-seconds", "1.2"));
+            var seconds = new java.math.BigDecimal(getConfig().getString("great-sword-recovery-seconds", "0.75"));
             var recovery = java.time.Duration.ofNanos(seconds.movePointRight(9).toBigIntegerExact().longValueExact());
             return new games.dmg.fantasystick.ability.GreatSword.Settings(base, recovery);
         } catch (ArithmeticException | NumberFormatException invalid) {

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

@@ -13,9 +13,10 @@ import org.bukkit.Material;
 
 /** Immutable internal ability metadata and focused effect boundary; not an external add-on API. */
 public record AbilityDefinition(String id, String name, Material icon, List<String> lore, String instructions,
-        Map<Stat, BigInteger> requirements, BigInteger pointCost, Activation activation,
+        Map<Stat, BigInteger> requirements, BigInteger pointCost, Category category, Activation activation,
         ControlInput.Gesture gesture, Duration cooldown, Map<String, BigDecimal> parameters,
         TargetPolicy targetPolicy, AbilityEffect effect) {
+    public enum Category { ATK, BUF, HEAL }
     public enum Activation { IMMEDIATE, DELAYED, PROJECTILE, AREA, SELECTION }
     public enum TargetPolicy { SELF, HOSTILE, PROJECTILE_HOSTILE, ALLY, PARTY, AREA, SELECTION, EXCEPTIONAL_NONCOMBAT,
         EXCEPTIONAL_NONCOMBAT_SELECTION }
@@ -25,7 +26,7 @@ public record AbilityDefinition(String id, String name, Material icon, List<Stri
     public AbilityDefinition {
         Objects.requireNonNull(id); Objects.requireNonNull(name); Objects.requireNonNull(icon);
         Objects.requireNonNull(lore); Objects.requireNonNull(instructions); Objects.requireNonNull(requirements);
-        Objects.requireNonNull(pointCost); Objects.requireNonNull(activation); Objects.requireNonNull(gesture);
+        Objects.requireNonNull(pointCost); Objects.requireNonNull(category); Objects.requireNonNull(activation); Objects.requireNonNull(gesture);
         Objects.requireNonNull(cooldown); Objects.requireNonNull(parameters); Objects.requireNonNull(targetPolicy);
         Objects.requireNonNull(effect);
         lore = List.copyOf(lore); requirements = Map.copyOf(requirements); parameters = Map.copyOf(parameters);

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

@@ -39,6 +39,8 @@ public final class AbilityEngine implements Consumer<ControlInput>, AutoCloseabl
     private final Consumer<Runnable> nextTick;
     private final AbilityScheduler scheduler;
     private final Consumer<AbilityReport> reports;
+    private final AbilityFeedback feedback;
+    private final games.dmg.fantasystick.training.TrainingDamage trainingDamage;
     private final Consumer<Failure> failures;
     private final Map<Key, Object> pending = new HashMap<>();
     private final Map<Key, Long> generations = new HashMap<>();
@@ -49,10 +51,27 @@ public final class AbilityEngine implements Consumer<ControlInput>, AutoCloseabl
     public AbilityEngine(AbilityRegistry registry, CharacterStorage characters, EquipmentSessions sessions,
             PartyRoster parties, Clock clock, Consumer<Runnable> nextTick, AbilityScheduler scheduler,
             Consumer<AbilityReport> reports, Consumer<Failure> failures) {
+        this(registry, characters, sessions, parties, clock, nextTick, scheduler, reports,
+            (definition, input, type, target, amount) -> { },
+            games.dmg.fantasystick.training.TrainingDamage.passthrough(), failures);
+    }
+
+    public AbilityEngine(AbilityRegistry registry, CharacterStorage characters, EquipmentSessions sessions,
+            PartyRoster parties, Clock clock, Consumer<Runnable> nextTick, AbilityScheduler scheduler,
+            Consumer<AbilityReport> reports, AbilityFeedback feedback, Consumer<Failure> failures) {
+        this(registry, characters, sessions, parties, clock, nextTick, scheduler, reports, feedback,
+            games.dmg.fantasystick.training.TrainingDamage.passthrough(), failures);
+    }
+
+    public AbilityEngine(AbilityRegistry registry, CharacterStorage characters, EquipmentSessions sessions,
+            PartyRoster parties, Clock clock, Consumer<Runnable> nextTick, AbilityScheduler scheduler,
+            Consumer<AbilityReport> reports, AbilityFeedback feedback,
+            games.dmg.fantasystick.training.TrainingDamage trainingDamage, Consumer<Failure> failures) {
         this.registry = Objects.requireNonNull(registry); this.characters = Objects.requireNonNull(characters);
         this.sessions = Objects.requireNonNull(sessions); this.parties = Objects.requireNonNull(parties);
         this.clock = Objects.requireNonNull(clock); this.nextTick = Objects.requireNonNull(nextTick);
         this.scheduler = Objects.requireNonNull(scheduler); this.reports = Objects.requireNonNull(reports);
+        this.feedback = Objects.requireNonNull(feedback); this.trainingDamage = Objects.requireNonNull(trainingDamage);
         this.failures = Objects.requireNonNull(failures);
     }
 
@@ -326,11 +345,21 @@ public final class AbilityEngine implements Consumer<ControlInput>, AutoCloseabl
             }
             owned.add(resource);
         }
+        @Override public boolean trainingDummy(Entity target) { return trainingDamage.target(Objects.requireNonNull(target)); }
+        @Override public void damage(org.bukkit.entity.LivingEntity target, double amount,
+                                     org.bukkit.damage.DamageSource source) {
+            Objects.requireNonNull(target); Objects.requireNonNull(source);
+            var measured = trainingDamage.apply(input.player(), target, () -> target.damage(amount, source));
+            measured.ifPresent(value -> report(AbilityReport.Type.DAMAGE, target, value));
+        }
         @Override public void report(AbilityReport.Type type, Entity target, java.math.BigDecimal amount) {
             if (!stillCurrent() || definition.targetPolicy() == AbilityDefinition.TargetPolicy.EXCEPTIONAL_NONCOMBAT
                     || definition.targetPolicy() == AbilityDefinition.TargetPolicy.EXCEPTIONAL_NONCOMBAT_SELECTION
                     || target == null || !AbilityEngine.this.eligible(definition.targetPolicy(), input, target)) return;
-            reports.accept(new AbilityReport(type, key.character(), input.session().session(), target.getUniqueId(), amount, clock.instant()));
+            var report = new AbilityReport(type, key.character(), input.session().session(), target.getUniqueId(), amount, clock.instant());
+            reports.accept(report);
+            try { feedback.report(definition, input, type, target, report.amount()); }
+            catch (RuntimeException failure) { AbilityEngine.this.report(key.character(), key.ability(), failure); }
         }
         @Override public void finish() { close(); }
         @Override public void close() {

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

@@ -5,7 +5,9 @@ import java.math.BigDecimal;
 import java.time.Duration;
 import java.util.Collection;
 import java.util.List;
+import org.bukkit.damage.DamageSource;
 import org.bukkit.entity.Entity;
+import org.bukkit.entity.LivingEntity;
 
 /** Bounded owned runtime supplied by the shared engine after durable cast authorization. */
 public interface AbilityExecution extends AutoCloseable {
@@ -16,6 +18,8 @@ public interface AbilityExecution extends AutoCloseable {
     List<Entity> eligible(Collection<? extends Entity> candidates, int maximum);
     AbilityScheduler.Task later(Duration delay, Runnable action);
     void own(AutoCloseable resource);
+    boolean trainingDummy(Entity target);
+    void damage(LivingEntity target, double amount, DamageSource source);
     void report(AbilityReport.Type type, Entity target, BigDecimal amount);
     void finish();
     @Override void close();

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

@@ -0,0 +1,11 @@
+package games.dmg.fantasystick.ability;
+
+import games.dmg.fantasystick.session.ControlInput;
+import java.math.BigDecimal;
+import org.bukkit.entity.Entity;
+
+/** Presentation sink for an authoritative applied ability outcome. */
+@FunctionalInterface
+public interface AbilityFeedback {
+    void report(AbilityDefinition definition, ControlInput input, AbilityReport.Type type, Entity target, BigDecimal amount);
+}

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

@@ -72,7 +72,7 @@ public final class ChainLightning implements AbilityEffect, Listener, AutoClosea
                 "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,
+            Map.of(Stat.INT, BigInteger.valueOf(20), Stat.DEX, BigInteger.valueOf(12)), BigInteger.ONE, AbilityDefinition.Category.ATK,
             AbilityDefinition.Activation.IMMEDIATE, ControlInput.Gesture.USE, current.cooldown(),
             Map.of("base-damage", new BigDecimal(current.baseDamage()),
                 "initial-range", BigDecimal.valueOf(current.initialRange()).stripTrailingZeros(),
@@ -117,7 +117,7 @@ public final class ChainLightning implements AbilityEffect, Listener, AutoClosea
         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); }
+        try { execution.damage(target, amount, source); }
         finally { if (damaging == attempt) damaging = null; }
     }
 

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

@@ -15,47 +15,50 @@ import org.bukkit.Material;
 import org.bukkit.Particle;
 import org.bukkit.damage.DamageSource;
 import org.bukkit.damage.DamageType;
+import org.bukkit.entity.AbstractArrow;
+import org.bukkit.entity.Arrow;
 import org.bukkit.entity.LivingEntity;
-import org.bukkit.entity.Snowball;
 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.event.entity.ProjectileHitEvent;
 import org.bukkit.util.Vector;
 
-/** Fireball's owned snowball projectile, direct custom damage and bounded cleanup adapter. */
+/** Fireball's owned arrow flight, direct custom damage and bounded cleanup adapter. */
 public final class Fireball implements AbilityEffect, Listener, AutoCloseable {
-    private static final double SPEED_PER_TICK = 1.0;
-
-    public record Settings(BigInteger baseDamage, Duration cooldown, double range, Duration lifetime) {
+    public record Settings(BigInteger baseDamage, Duration cooldown, double range, Duration lifetime, double speedPerTick) {
         public Settings {
             Objects.requireNonNull(baseDamage); Objects.requireNonNull(cooldown); Objects.requireNonNull(lifetime);
             if (baseDamage.signum() < 0 || cooldown.isNegative() || cooldown.compareTo(Duration.ofDays(365)) > 0
                     || !Double.isFinite(range) || range <= 0 || range > 1024
-                    || lifetime.isZero() || lifetime.isNegative() || lifetime.compareTo(Duration.ofSeconds(60)) > 0) {
+                    || lifetime.isZero() || lifetime.isNegative() || lifetime.compareTo(Duration.ofSeconds(60)) > 0
+                    || !Double.isFinite(speedPerTick) || speedPerTick < 0.01 || speedPerTick > 64) {
                 throw new IllegalArgumentException("Invalid Fireball settings");
             }
         }
         public static Settings defaults() {
-            return new Settings(BigInteger.valueOf(6), Duration.ofSeconds(4), 32, Duration.ofSeconds(5));
+            return new Settings(BigInteger.valueOf(6), Duration.ofMillis(1200), 32, Duration.ofSeconds(5), 3);
         }
     }
 
-    private final Settings settings;
+    private volatile Settings settings;
     private final Map<UUID, State> projectiles = new HashMap<>();
     private State damaging;
     private boolean closed;
 
     private final class State implements AutoCloseable {
-        final Snowball projectile;
+        final Arrow projectile;
         final AbilityExecution execution;
         final Location origin;
         final BigInteger intelligence;
+        final Settings settings;
         LivingEntity target;
         boolean finished;
-        State(Snowball projectile, AbilityExecution execution, Location origin, BigInteger intelligence) {
-            this.projectile = projectile; this.execution = execution; this.origin = origin; this.intelligence = intelligence;
+        State(Arrow projectile, AbilityExecution execution, Location origin, BigInteger intelligence, Settings settings) {
+            this.projectile = projectile; this.execution = execution; this.origin = origin;
+            this.intelligence = intelligence; this.settings = settings;
         }
         @Override public void close() {
             if (finished) return;
@@ -66,16 +69,19 @@ public final class Fireball implements AbilityEffect, Listener, AutoCloseable {
     }
 
     public Fireball(Settings settings) { this.settings = Objects.requireNonNull(settings); }
+    public void configure(Settings settings) { this.settings = Objects.requireNonNull(settings); }
 
     public AbilityDefinition definition() {
+        var current = settings;
         return new AbilityDefinition("fireball", "Fireball", Material.SNOWBALL,
-            List.of("Launch a bounded fiery snowball.", "Deals " + settings.baseDamage() + " + INT modifier damage."),
+            List.of("Launch a bounded fiery arrow flight.", "Deals " + current.baseDamage() + " + INT modifier damage."),
             "Use the equipped snowball; a miss still spends the cooldown.",
-            Map.of(Stat.INT, BigInteger.valueOf(12)), BigInteger.ONE,
-            AbilityDefinition.Activation.PROJECTILE, ControlInput.Gesture.USE, settings.cooldown(),
-            Map.of("base-damage", new BigDecimal(settings.baseDamage()),
-                "range", BigDecimal.valueOf(settings.range()).stripTrailingZeros(),
-                "lifetime", BigDecimal.valueOf(settings.lifetime().toMillis(), 3).stripTrailingZeros()),
+            Map.of(Stat.INT, BigInteger.valueOf(12)), BigInteger.ONE, AbilityDefinition.Category.ATK,
+            AbilityDefinition.Activation.PROJECTILE, ControlInput.Gesture.USE, current.cooldown(),
+            Map.of("base-damage", new BigDecimal(current.baseDamage()),
+                "range", BigDecimal.valueOf(current.range()).stripTrailingZeros(),
+                "lifetime", seconds(current.lifetime()),
+                "projectile-speed", BigDecimal.valueOf(current.speedPerTick()).stripTrailingZeros()),
             AbilityDefinition.TargetPolicy.PROJECTILE_HOSTILE, this);
     }
 
@@ -95,21 +101,24 @@ public final class Fireball implements AbilityEffect, Listener, AutoCloseable {
 
     @Override public void activate(AbilityExecution execution) {
         if (closed || !execution.stillCurrent()) return;
+        var current = settings;
         var player = execution.input().player();
         Location origin = player.getEyeLocation().clone();
         Vector direction = origin.getDirection();
         if (!Double.isFinite(direction.getX()) || !Double.isFinite(direction.getY()) || !Double.isFinite(direction.getZ())
                 || direction.lengthSquared() == 0) throw new IllegalStateException("Fireball direction is unavailable");
-        var projectile = player.launchProjectile(Snowball.class, direction.normalize().multiply(SPEED_PER_TICK));
+        var projectile = player.launchProjectile(Arrow.class, direction.normalize().multiply(current.speedPerTick()));
+        projectile.setPickupStatus(AbstractArrow.PickupStatus.DISALLOWED);
+        projectile.setDamage(0); projectile.setKnockbackStrength(0); projectile.setPierceLevel(0); projectile.setCritical(false);
         projectile.setVisualFire(true);
-        var state = new State(projectile, execution, origin, execution.character().stats().get(Stat.INT));
+        var state = new State(projectile, execution, origin, execution.character().stats().get(Stat.INT), current);
         if (projectiles.putIfAbsent(projectile.getUniqueId(), state) != null) {
             projectile.remove(); throw new IllegalStateException("Duplicate Fireball projectile identity");
         }
         execution.own(state);
-        long rangeTicks = Math.max(1, (long) Math.ceil(settings.range() / SPEED_PER_TICK));
+        long rangeTicks = Math.max(1, (long) Math.ceil(current.range() / current.speedPerTick()));
         execution.later(Duration.ofMillis(Math.multiplyExact(rangeTicks, 50)), execution::finish);
-        execution.later(settings.lifetime(), execution::finish);
+        execution.later(current.lifetime(), execution::finish);
         player.getWorld().spawnParticle(Particle.FLAME, origin, 8, 0.15, 0.15, 0.15, 0.01);
     }
 
@@ -121,13 +130,13 @@ public final class Fireball implements AbilityEffect, Listener, AutoCloseable {
             if (closed || event.isCancelled() || !state.execution.stillCurrent()
                     || !(event.getHitEntity() instanceof LivingEntity target) || !inRange(state, event.getEntity().getLocation())
                     || state.execution.eligible(List.of(target), 1).isEmpty()) return;
-            BigInteger amount = damage(settings.baseDamage(), state.intelligence);
+            BigInteger amount = damage(state.settings.baseDamage(), state.intelligence);
             double nativeDamage = amount.bitLength() > 1023 ? Double.MAX_VALUE : amount.doubleValue();
             var source = DamageSource.builder(DamageType.FIREBALL).withCausingEntity(state.execution.input().player())
                 .withDirectEntity(state.projectile).withDamageLocation(state.projectile.getLocation()).build();
             state.target = target;
             damaging = state;
-            try { target.damage(nativeDamage, source); }
+            try { state.execution.damage(target, nativeDamage, source); }
             finally { if (damaging == state) damaging = null; }
         } finally {
             state.execution.finish();
@@ -137,7 +146,14 @@ public final class Fireball implements AbilityEffect, Listener, AutoCloseable {
     private boolean inRange(State state, Location current) {
         return current.getWorld() != null && state.origin.getWorld() != null
             && current.getWorld().equals(state.origin.getWorld())
-            && current.distanceSquared(state.origin) <= settings.range() * settings.range();
+            && current.distanceSquared(state.origin) <= state.settings.range() * state.settings.range();
+    }
+
+    @EventHandler(priority = EventPriority.HIGHEST)
+    public void containNativeDamage(EntityDamageByEntityEvent event) {
+        if (!(event.getDamager() instanceof Arrow arrow)) return;
+        var state = projectiles.get(arrow.getUniqueId());
+        if (state != null && damaging != state) event.setCancelled(true);
     }
 
     @EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = true)
@@ -153,6 +169,10 @@ public final class Fireball implements AbilityEffect, Listener, AutoCloseable {
         state.execution.report(AbilityReport.Type.DAMAGE, event.getEntity(), BigDecimal.valueOf(event.getFinalDamage()));
     }
 
+    private static BigDecimal seconds(Duration duration) {
+        return BigDecimal.valueOf(duration.getSeconds()).add(BigDecimal.valueOf(duration.getNano(), 9)).stripTrailingZeros();
+    }
+
     @Override public void close() {
         if (closed) return;
         closed = true;

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

@@ -102,7 +102,7 @@ public final class FrostNova implements AbilityEffect, Listener, AutoCloseable {
                     + 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,
+            Map.of(Stat.INT, BigInteger.valueOf(16), Stat.DEX, BigInteger.TEN), BigInteger.ONE, AbilityDefinition.Category.ATK,
             AbilityDefinition.Activation.DELAYED, ControlInput.Gesture.USE, current.cooldown(),
             Map.of("base-damage", new BigDecimal(current.baseDamage()),
                 "radius", BigDecimal.valueOf(current.radius()).stripTrailingZeros(),
@@ -135,7 +135,7 @@ public final class FrostNova implements AbilityEffect, Listener, AutoCloseable {
             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); }
+            try { execution.damage(target, amount, sourceDamage); }
             finally { if (damaging == attempt) damaging = null; }
             affected++;
             if (!attempt.accepted || !execution.stillCurrent() || !eligible(execution, target, origin, captured.radius())) continue;

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

@@ -15,11 +15,13 @@ import org.bukkit.Material;
 import org.bukkit.Particle;
 import org.bukkit.damage.DamageSource;
 import org.bukkit.damage.DamageType;
+import org.bukkit.entity.AbstractArrow;
+import org.bukkit.entity.Arrow;
 import org.bukkit.entity.LivingEntity;
-import org.bukkit.entity.Snowball;
 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.event.entity.ProjectileHitEvent;
 import org.bukkit.potion.PotionEffect;
@@ -45,12 +47,12 @@ public final class FrostShard implements AbilityEffect, Listener, AutoCloseable
         }
         public static Settings defaults() {
             return new Settings(BigInteger.valueOf(4), Duration.ofSeconds(5), 32, Duration.ofSeconds(5),
-                1, 0, Duration.ofSeconds(2));
+                3, 0, Duration.ofSeconds(2));
         }
     }
 
     private final class State implements AutoCloseable {
-        final Snowball projectile;
+        final Arrow projectile;
         final AbilityExecution execution;
         final Location origin;
         final BigInteger intelligence;
@@ -58,7 +60,7 @@ public final class FrostShard implements AbilityEffect, Listener, AutoCloseable
         LivingEntity target;
         boolean accepted;
         boolean finished;
-        State(Snowball projectile, AbilityExecution execution, Location origin, BigInteger intelligence, Settings settings) {
+        State(Arrow projectile, AbilityExecution execution, Location origin, BigInteger intelligence, Settings settings) {
             this.projectile = projectile; this.execution = execution; this.origin = origin;
             this.intelligence = intelligence; this.settings = settings;
         }
@@ -112,7 +114,7 @@ public final class FrostShard implements AbilityEffect, Listener, AutoCloseable
                 "Deals " + current.baseDamage() + " + INT modifier damage and Slowness "
                     + level(current.slownessAmplifier()) + " for " + seconds(current.slownessDuration()) + "s."),
             "Use the equipped shard; a miss still spends the cooldown.",
-            Map.of(Stat.INT, BigInteger.valueOf(12), Stat.WIS, BigInteger.TEN), BigInteger.ONE,
+            Map.of(Stat.INT, BigInteger.valueOf(12), Stat.WIS, BigInteger.TEN), BigInteger.ONE, AbilityDefinition.Category.ATK,
             AbilityDefinition.Activation.PROJECTILE, ControlInput.Gesture.USE, current.cooldown(),
             Map.of("base-damage", new BigDecimal(current.baseDamage()),
                 "range", BigDecimal.valueOf(current.range()).stripTrailingZeros(),
@@ -144,7 +146,9 @@ public final class FrostShard implements AbilityEffect, Listener, AutoCloseable
         Vector direction = origin.getDirection();
         if (!Double.isFinite(direction.getX()) || !Double.isFinite(direction.getY()) || !Double.isFinite(direction.getZ())
                 || direction.lengthSquared() == 0) throw new IllegalStateException("Frost Shard direction is unavailable");
-        var projectile = player.launchProjectile(Snowball.class, direction.normalize().multiply(current.speedPerTick()));
+        var projectile = player.launchProjectile(Arrow.class, direction.normalize().multiply(current.speedPerTick()));
+        projectile.setPickupStatus(AbstractArrow.PickupStatus.DISALLOWED);
+        projectile.setDamage(0); projectile.setKnockbackStrength(0); projectile.setPierceLevel(0); projectile.setCritical(false);
         var state = new State(projectile, execution, origin, execution.character().stats().get(Stat.INT), current);
         if (projectiles.putIfAbsent(projectile.getUniqueId(), state) != null) {
             projectile.remove(); throw new IllegalStateException("Duplicate Frost Shard projectile identity");
@@ -160,6 +164,13 @@ public final class FrostShard implements AbilityEffect, Listener, AutoCloseable
         player.getWorld().spawnParticle(Particle.SNOWFLAKE, origin, 8, 0.15, 0.15, 0.15, 0.01);
     }
 
+    @EventHandler(priority = EventPriority.HIGHEST)
+    public void containNativeDamage(EntityDamageByEntityEvent event) {
+        if (!(event.getDamager() instanceof Arrow arrow)) return;
+        var state = projectiles.get(arrow.getUniqueId());
+        if (state != null && damaging != state) event.setCancelled(true);
+    }
+
     @EventHandler(priority = EventPriority.MONITOR)
     public void hit(ProjectileHitEvent event) {
         var state = projectiles.remove(event.getEntity().getUniqueId());
@@ -175,7 +186,7 @@ public final class FrostShard implements AbilityEffect, Listener, AutoCloseable
             var source = DamageSource.builder(DamageType.FREEZE).withCausingEntity(state.execution.input().player())
                 .withDirectEntity(state.projectile).withDamageLocation(state.projectile.getLocation()).build();
             state.target = target; damaging = state;
-            try { target.damage(nativeDamage, source); }
+            try { state.execution.damage(target, nativeDamage, source); }
             finally { if (damaging == state) damaging = null; }
             if (state.accepted && state.execution.stillCurrent()) {
                 int ticks = Math.toIntExact(Math.max(1,

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

@@ -27,7 +27,7 @@ public final class GreatSword implements AbilityEffect, Listener, AutoCloseable
                 throw new IllegalArgumentException("Invalid Great Sword settings");
             }
         }
-        public static Settings defaults() { return new Settings(BigInteger.valueOf(7), Duration.ofMillis(1200)); }
+        public static Settings defaults() { return new Settings(BigInteger.valueOf(7), Duration.ofMillis(750)); }
     }
 
     private static final class Attempt {
@@ -50,7 +50,7 @@ public final class GreatSword implements AbilityEffect, Listener, AutoCloseable
             List.of("Charge a contained melee strike.",
                 "Fully charged: " + settings.baseDamage() + " + STR modifier damage."),
             "Attack with the equipped sword; partial charge follows the native attack curve.",
-            Map.of(Stat.STR, BigInteger.valueOf(12)), BigInteger.ONE,
+            Map.of(Stat.STR, BigInteger.valueOf(12)), BigInteger.ONE, AbilityDefinition.Category.ATK,
             AbilityDefinition.Activation.IMMEDIATE, ControlInput.Gesture.ATTACK, settings.recovery(),
             Map.of("base-damage", new BigDecimal(settings.baseDamage())),
             AbilityDefinition.TargetPolicy.HOSTILE, this);
@@ -93,7 +93,7 @@ public final class GreatSword implements AbilityEffect, Listener, AutoCloseable
             .withDirectEntity(player).build();
         var attempt = new Attempt(execution, target);
         damaging = attempt;
-        try { target.damage(nativeDamage, source); }
+        try { execution.damage(target, nativeDamage, source); }
         finally { if (damaging == attempt) damaging = null; }
     }
 

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

@@ -130,7 +130,7 @@ public final class GuardianBond implements AbilityEffect, Listener, AutoCloseabl
             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,
+            Map.of(Stat.CON, BigInteger.valueOf(16), Stat.WIS, BigInteger.TEN), BigInteger.ONE, AbilityDefinition.Category.BUF,
             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),

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

@@ -30,13 +30,13 @@ public final class Hex implements AbilityEffect,AutoCloseable{
     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,
+        "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.Category.ATK,
         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 current=from(execution.definition());if(!inRange(execution.input(),target,current.range())||execution.trainingDummy(target)){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();

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

@@ -5,7 +5,7 @@ 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);}
+ 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.Category.BUF,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);}

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

@@ -83,7 +83,7 @@ public final class Longbow implements AbilityEffect, Listener, AutoCloseable {
             List.of("Draw and release an ammunition-free owned arrow.",
                 "A full draw deals " + current.baseDamage() + " + DEX modifier damage."),
             "Draw by holding use; release after at least " + current.minimumDrawTicks() + " ticks.",
-            Map.of(Stat.DEX, BigInteger.valueOf(14)), BigInteger.ONE,
+            Map.of(Stat.DEX, BigInteger.valueOf(14)), BigInteger.ONE, AbilityDefinition.Category.ATK,
             AbilityDefinition.Activation.PROJECTILE, ControlInput.Gesture.DRAW_RELEASE, current.recovery(),
             Map.of("base-damage", new BigDecimal(current.baseDamage()),
                 "minimum-draw-ticks", BigDecimal.valueOf(current.minimumDrawTicks()),
@@ -171,7 +171,7 @@ public final class Longbow implements AbilityEffect, Listener, AutoCloseable {
             var source = DamageSource.builder(DamageType.ARROW).withCausingEntity(state.execution.input().player())
                 .withDirectEntity(state.arrow).withDamageLocation(state.arrow.getLocation()).build();
             state.target = target; damaging = state;
-            try { target.damage(nativeDamage, source); }
+            try { state.execution.damage(target, nativeDamage, source); }
             finally { if (damaging == state) damaging = null; }
         } finally {
             state.close(); state.execution.finish();

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

@@ -70,7 +70,7 @@ public final class MendingLight implements AbilityEffect {
             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,
+            Map.of(Stat.WIS, BigInteger.valueOf(12), Stat.CHR, BigInteger.TEN), BigInteger.ONE, AbilityDefinition.Category.HEAL,
             AbilityDefinition.Activation.DELAYED, ControlInput.Gesture.USE, current.cooldown(),
             Map.of("base-healing", new BigDecimal(current.baseHealing()),
                 "range", BigDecimal.valueOf(current.range()).stripTrailingZeros()),
@@ -142,8 +142,7 @@ public final class MendingLight implements AbilityEffect {
             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.");
+            execution.report(AbilityReport.Type.HEALING, target.player(), amount);
         } finally { execution.finish(); }
     }
 

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

@@ -46,7 +46,7 @@ public final class Meteor implements AbilityEffect, Listener, AutoCloseable {
         Warning(AbilityExecution execution,Ground ground,Settings captured){this.execution=execution;source=execution.input().player();this.ground=ground;this.captured=captured;intelligence=execution.character().stats().get(Stat.INT);maximumTicks=(int)Math.max(1,(captured.warning().toNanos()+49_999_999L)/50_000_000L);}
         void start(){warnings.put(execution,this);execution.own(this);warningVisual();execution.later(Duration.ofMillis(50),this::step);}
         void step(){if(closed||impacted)return;if(!execution.stillCurrent()){execution.finish();return;}elapsed++;if(elapsed>=maximumTicks){impact();execution.finish();return;}warningVisual();execution.later(Duration.ofMillis(50),this::step);}
-        void impact(){if(closed||impacted)return;impacted=true;if(!groundCurrent()||!execution.stillCurrent())return;impactVisual();double amount=finite(damage(captured.baseDamage(),intelligence));int affected=0;for(var target:candidates(ground.origin(),captured.radius(),captured.verticalRange())){if(affected==64||!execution.stillCurrent())break;if(!eligible(execution,target,ground.origin(),captured.radius(),captured.verticalRange()))continue;var sourceDamage=DamageSource.builder(DamageType.MAGIC).withCausingEntity(source).withDirectEntity(source).withDamageLocation(ground.origin()).build();var attempt=new Attempt(execution,target);damaging=attempt;try{target.damage(amount,sourceDamage);}finally{if(damaging==attempt)damaging=null;}affected++;}}
+        void impact(){if(closed||impacted)return;impacted=true;if(!groundCurrent()||!execution.stillCurrent())return;impactVisual();double amount=finite(damage(captured.baseDamage(),intelligence));int affected=0;for(var target:candidates(ground.origin(),captured.radius(),captured.verticalRange())){if(affected==64||!execution.stillCurrent())break;if(!eligible(execution,target,ground.origin(),captured.radius(),captured.verticalRange()))continue;var sourceDamage=DamageSource.builder(DamageType.MAGIC).withCausingEntity(source).withDirectEntity(source).withDamageLocation(ground.origin()).build();var attempt=new Attempt(execution,target);damaging=attempt;try{execution.damage(target,amount,sourceDamage);}finally{if(damaging==attempt)damaging=null;}affected++;}}
         boolean groundCurrent(){try{return ground.origin().getWorld()!=null&&ground.block().getWorld()==ground.origin().getWorld()&&ground.block().getType().isSolid();}catch(RuntimeException invalid){return false;}}
         void warningVisual(){try{var dust=new Particle.DustOptions(Color.fromRGB(255,90,20),1.6f);ground.origin().getWorld().spawnParticle(Particle.DUST,ground.origin().clone().add(0,.15,0),24,captured.radius()/2,.05,captured.radius()/2,0,dust);}catch(RuntimeException ignored){}}
         void impactVisual(){try{var world=ground.origin().getWorld();world.spawnParticle(Particle.EXPLOSION_EMITTER,ground.origin(),2,0,0,0,0);world.spawnParticle(Particle.FLAME,ground.origin(),48,captured.radius()/2,1,captured.radius()/2,.04);world.playSound(ground.origin(),Sound.ENTITY_GENERIC_EXPLODE,1f,.7f);}catch(RuntimeException ignored){}}
@@ -59,7 +59,7 @@ public final class Meteor implements AbilityEffect, Listener, AutoCloseable {
     public void configure(Settings settings){this.settings=Objects.requireNonNull(settings);}
     public AbilityDefinition definition(){var current=settings;return new AbilityDefinition("meteor","Meteor",Material.FIRE_CHARGE,
         List.of("Mark visible ground within "+decimal(current.targetRange())+" blocks for a "+seconds(current.warning())+"-second warning.","Impact exposed enemies in a "+decimal(current.radius())+"-block area for "+current.baseDamage()+" + INT modifier damage."),
-        "Use while looking at a solid top surface; the warning is visible and the impact never changes terrain.",Map.of(Stat.INT,BigInteger.valueOf(26),Stat.WIS,BigInteger.valueOf(20),Stat.CON,BigInteger.valueOf(12)),BigInteger.ONE,
+        "Use while looking at a solid top surface; the warning is visible and the impact never changes terrain.",Map.of(Stat.INT,BigInteger.valueOf(26),Stat.WIS,BigInteger.valueOf(20),Stat.CON,BigInteger.valueOf(12)),BigInteger.ONE,AbilityDefinition.Category.ATK,
         AbilityDefinition.Activation.DELAYED,ControlInput.Gesture.USE,current.cooldown(),Map.of("base-damage",new BigDecimal(current.baseDamage()),"target-range",BigDecimal.valueOf(current.targetRange()).stripTrailingZeros(),"warning-seconds",nanos(current.warning()),"radius",BigDecimal.valueOf(current.radius()).stripTrailingZeros(),"vertical-range",BigDecimal.valueOf(current.verticalRange()).stripTrailingZeros()),AbilityDefinition.TargetPolicy.AREA,this);}
     public static BigInteger damage(BigInteger intelligence){return damage(BigInteger.valueOf(14),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 Meteor 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);}

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

@@ -58,7 +58,7 @@ public final class Purify implements AbilityEffect {
             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,
+            Map.of(Stat.WIS, BigInteger.valueOf(14), Stat.CHR, BigInteger.TEN), BigInteger.ONE, AbilityDefinition.Category.BUF,
             AbilityDefinition.Activation.IMMEDIATE, ControlInput.Gesture.USE, current.cooldown(),
             Map.of("range", BigDecimal.valueOf(current.range()).stripTrailingZeros()),
             AbilityDefinition.TargetPolicy.PARTY, this);
@@ -81,12 +81,11 @@ public final class Purify implements AbilityEffect {
             if (target.player().getPotionEffect(type) == null) removed++;
         }
         if (removed == 0) return;
-        execution.input().player().sendMessage("Purify removed " + removed + " harmful effect" + (removed == 1 ? "." : "s."));
+        var amount = BigDecimal.valueOf(removed);
+        execution.report(AbilityReport.Type.CLEANSING, target.player(), amount);
         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."));
         }
     }
 

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

@@ -80,7 +80,7 @@ public final class Quickstep implements AbilityEffect, Listener, AutoCloseable {
             List.of("Dash forward with native horizontal movement.",
                 "Travel up to " + decimal(current.distance()) + " blocks while obstacles remain authoritative."),
             "Use while grounded, on foot, and not flying or gliding.",
-            Map.of(Stat.DEX, BigInteger.valueOf(12)), BigInteger.ONE,
+            Map.of(Stat.DEX, BigInteger.valueOf(12)), BigInteger.ONE, AbilityDefinition.Category.BUF,
             AbilityDefinition.Activation.DELAYED, ControlInput.Gesture.USE, current.cooldown(),
             Map.of("distance", BigDecimal.valueOf(current.distance()).stripTrailingZeros(),
                 "speed", BigDecimal.valueOf(current.speedPerTick()).stripTrailingZeros()),

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

@@ -175,7 +175,7 @@ public final class RallyingCry implements AbilityEffect, AutoCloseable {
                     + " 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,
+            Map.of(Stat.CHR, BigInteger.valueOf(16), Stat.CON, BigInteger.valueOf(12)), BigInteger.ONE, AbilityDefinition.Category.BUF,
             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),

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

@@ -85,7 +85,7 @@ public final class Revive implements AbilityEffect, Listener, AutoCloseable {
             List.of("Let another player continue one fallen character.", "A valid cast spends the daily opportunity."),
             "Use the equipped shard while aiming at another player within 12 blocks.",
             Map.of(Stat.WIS, BigInteger.valueOf(30), Stat.CHR, BigInteger.valueOf(24), Stat.CON, BigInteger.valueOf(12)),
-            BigInteger.ONE, AbilityDefinition.Activation.SELECTION, ControlInput.Gesture.USE, Duration.ofHours(24),
+            BigInteger.ONE, AbilityDefinition.Category.HEAL, AbilityDefinition.Activation.SELECTION, ControlInput.Gesture.USE, Duration.ofHours(24),
             Map.of("range", BigDecimal.valueOf(12), "selection-time", BigDecimal.valueOf(300),
                 "death-age", BigDecimal.valueOf(86400)),
             AbilityDefinition.TargetPolicy.EXCEPTIONAL_NONCOMBAT_SELECTION, this);

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

@@ -174,7 +174,7 @@ public final class Sanctuary implements AbilityEffect, AutoCloseable {
                 "Party members inside heal " + decimal(current.healingPerPulse()) + " each second and take "
                     + decimal(current.damageReductionPercent()) + "% less combat damage."),
             "Use to hold exposed ground; healing starts after one second and the area does not follow you.",
-            Map.of(Stat.WIS, BigInteger.valueOf(24), Stat.CHR, BigInteger.valueOf(20), Stat.CON, BigInteger.TEN), BigInteger.ONE,
+            Map.of(Stat.WIS, BigInteger.valueOf(24), Stat.CHR, BigInteger.valueOf(20), Stat.CON, BigInteger.TEN), BigInteger.ONE, AbilityDefinition.Category.HEAL,
             AbilityDefinition.Activation.DELAYED, ControlInput.Gesture.USE, current.cooldown(),
             Map.of("radius", BigDecimal.valueOf(current.radius()).stripTrailingZeros(),
                 "vertical-range", BigDecimal.valueOf(current.verticalRange()).stripTrailingZeros(),
@@ -199,6 +199,8 @@ public final class Sanctuary implements AbilityEffect, AutoCloseable {
             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));
+            state.execution.report(AbilityReport.Type.HEALING, target.player(),
+                BigDecimal.valueOf(restored).stripTrailingZeros());
             if (target.player() != state.source) supports.accept(new MendingLight.Support(
                 state.execution.input().session().character(), target.active(), BigDecimal.valueOf(restored).stripTrailingZeros()));
         } finally { completePending(state); }

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

@@ -51,7 +51,7 @@ public final class SecondWind implements AbilityEffect {
             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,
+            Map.of(Stat.CON, BigInteger.valueOf(12), Stat.WIS, BigInteger.valueOf(12)), BigInteger.ONE, AbilityDefinition.Category.HEAL,
             AbilityDefinition.Activation.DELAYED, ControlInput.Gesture.USE, current.cooldown(),
             Map.of("base-healing", new BigDecimal(current.baseHealing())),
             AbilityDefinition.TargetPolicy.SELF, this);
@@ -105,8 +105,12 @@ public final class SecondWind implements AbilityEffect {
                         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()));
+                        double nativeBefore = player.getHealth();
+                        double publish = Math.min(attribute.getValue(), Math.max(nativeBefore, persisted.health().doubleValue()));
                         player.setHealth(publish);
+                        double restored = publish - nativeBefore;
+                        if (Double.isFinite(restored) && restored > 0) execution.report(AbilityReport.Type.HEALING,
+                            player, BigDecimal.valueOf(restored).stripTrailingZeros());
                     } finally { execution.finish(); }
                 });
             } catch (RuntimeException rejected) { execution.finish(); }

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

@@ -35,7 +35,7 @@ public final class ShieldBash implements AbilityEffect, Listener, AutoCloseable
                     || 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);
+            return new Settings(BigInteger.valueOf(4), Duration.ofSeconds(3), 3, 0.8, 0.35);
         }
     }
     private static final class Attempt {
@@ -61,7 +61,7 @@ public final class ShieldBash implements AbilityEffect, Listener, AutoCloseable
             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(),
+            BigInteger.ONE, AbilityDefinition.Category.ATK, 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())),
@@ -91,7 +91,7 @@ public final class ShieldBash implements AbilityEffect, Listener, AutoCloseable
         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); }
+        try { execution.damage(target, amount, source); }
         finally { if (damaging == attempt) damaging = null; execution.finish(); }
     }
 

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

@@ -53,7 +53,7 @@ public final class StoneSkin implements AbilityEffect, AutoCloseable {
         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,
+            "Use to protect yourself; environmental damage is unchanged.", Map.of(Stat.CON, BigInteger.valueOf(14)), BigInteger.ONE, AbilityDefinition.Category.BUF,
             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);

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

@@ -20,9 +20,9 @@ public final class TemporaryHealth implements Listener,AutoCloseable{
  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()));}
+ @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();
+  try{nextTick.accept(()->consume(target,before,owned,owner,qualifies?aided:null,enemy));}catch(RuntimeException ignored){}}
+ private void consume(Player target,double before,double ownedBefore,Grant owner,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;var amount=BigDecimal.valueOf(consumed).stripTrailingZeros();owner.execution.report(AbilityReport.Type.PREVENTION,target,amount);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,owner.execution.input().session().character(),aided,amount));}
  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;}

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

@@ -181,7 +181,7 @@ public final class WarBanner implements AbilityEffect, AutoCloseable {
                 "Party members in its " + decimal(current.radius()) + "-block area gain " + decimal(current.damageBonusPercent())
                     + "% combat damage and " + decimal(current.knockbackResistancePercent()) + "% knockback resistance."),
             "Use while looking at the solid top surface where the fixed banner should stand; copies do not stack.",
-            Map.of(Stat.STR, BigInteger.valueOf(22), Stat.CHR, BigInteger.valueOf(22), Stat.CON, BigInteger.valueOf(12)), BigInteger.ONE,
+            Map.of(Stat.STR, BigInteger.valueOf(22), Stat.CHR, BigInteger.valueOf(22), Stat.CON, BigInteger.valueOf(12)), BigInteger.ONE, AbilityDefinition.Category.BUF,
             AbilityDefinition.Activation.DELAYED, ControlInput.Gesture.USE, current.cooldown(),
             Map.of("placement-range", BigDecimal.valueOf(current.placementRange()).stripTrailingZeros(),
                 "radius", BigDecimal.valueOf(current.radius()).stripTrailingZeros(),

src/main/java/games/dmg/fantasystick/adventure/AdventureQuestCommands.java

@@ -0,0 +1,26 @@
+package games.dmg.fantasystick.adventure;
+
+import java.util.*;
+import java.util.function.Consumer;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+import org.bukkit.plugin.Plugin;
+
+/** Registered command adapter for player inspection and acknowledged adventure administration. */
+public final class AdventureQuestCommands {
+    private static final String PERMISSION="fantasystick.admin";
+    private final Plugin plugin;private final AdventureQuestDirectory directory;private final AdventureQuestController controller;private final Consumer<Runnable> nextTick;
+    public AdventureQuestCommands(Plugin plugin,AdventureQuestDirectory directory,AdventureQuestController controller,Consumer<Runnable> nextTick){this.plugin=Objects.requireNonNull(plugin);this.directory=Objects.requireNonNull(directory);this.controller=Objects.requireNonNull(controller);this.nextTick=Objects.requireNonNull(nextTick);}
+    public void adventure(CommandSender sender,String[] args){if(args.length==1){if(sender instanceof Player player)controller.inspect(player);else sender.sendMessage("Usage: /fantasystick adventure");return;}if(args.length==2&&args[1].equals("reroll")){if(!authorized(sender))return;sender.sendMessage("Reroll replaces today's offers only when no quest or encounter is active. Run /fantasystick adventure reroll confirm to continue.");return;}if(args.length!=3||!args[1].equals("reroll")||!args[2].equals("confirm")){sender.sendMessage("Usage: /fantasystick adventure [reroll confirm]");return;}if(!authorized(sender))return;if(controller.hasActiveEncounter()){sender.sendMessage("Adventure reroll refused: an encounter is active.");return;}var current=directory.snapshot().catalog();UUID expected=current==null?null:current.revision();directory.rerollToday(expected).whenComplete((result,failure)->respond(sender,()->{if(failure!=null){sender.sendMessage("Adventure reroll failed; the current catalog is unchanged.");return;}switch(result.status()){case ACTIVE->sender.sendMessage("Adventure reroll refused: an accepted quest is active.");case STALE->sender.sendMessage("Adventure reroll refused: the catalog changed; inspect it and try again.");case APPLIED->{controller.catalogRerolled();var catalog=result.catalog().orElseThrow();sender.sendMessage("Rerolled daily adventures: revision="+catalog.revision()+", offers="+catalog.sites().size()+", expires="+catalog.expiresAt()+".");}}}));}
+    public void site(CommandSender sender,String[] args){if(!authorized(sender))return;if(args.length<2){sender.sendMessage("Usage: /fantasystick adventure-site <place <camp|champion> [name...]|remove <site-uuid>|list>");return;}switch(args[1]){case"list"->{if(args.length!=2){usageSite(sender);return;}if(directory.snapshot().sites().isEmpty())sender.sendMessage("No adventure sites registered.");else directory.snapshot().sites().stream().sorted(Comparator.comparing(v->v.id().toString())).forEach(v->sender.sendMessage(v.id()+" "+v.type().name().toLowerCase(Locale.ROOT)+" "+v.displayName()+" world="+v.world()+" x="+v.x()+" y="+v.y()+" z="+v.z()));}case"place"->{if(args.length<3||!(args[2].equals("camp")||args[2].equals("champion"))||!(sender instanceof Player player)){usageSite(sender);return;}String name=join(args,3);var location=player.getLocation();var type=args[2].equals("camp")?AdventureQuestState.SiteType.CAMP:AdventureQuestState.SiteType.CHAMPION;directory.placeSite(type,name,Objects.requireNonNull(location.getWorld()).getUID(),location.getX(),location.getY(),location.getZ()).whenComplete((value,failure)->respond(sender,()->sender.sendMessage(failure==null?"Placed "+value.type().name().toLowerCase(Locale.ROOT)+" "+value.id()+" ("+value.displayName()+").":"Adventure site save failed; desired state is unchanged.")));}case"remove"->{if(args.length!=3){usageSite(sender);return;}UUID id=parse(args[2]);if(id==null){usageSite(sender);return;}directory.removeSite(id).whenComplete((removed,failure)->respond(sender,()->{if(failure!=null)sender.sendMessage("Adventure site removal failed; desired state is unchanged.");else if(removed.isEmpty())sender.sendMessage("Adventure site not found.");else{controller.removeSiteLoaded(id);sender.sendMessage("Removed adventure site "+id+"; its quests expired.");}}));}default->usageSite(sender);}}
+    public void giver(CommandSender sender,String[] args){if(!authorized(sender))return;if(args.length<2){usageGiver(sender);return;}switch(args[1]){case"list"->{if(args.length!=2){usageGiver(sender);return;}if(directory.snapshot().givers().isEmpty())sender.sendMessage("No Quest Givers registered.");else directory.snapshot().givers().stream().sorted(Comparator.comparing(v->v.id().toString())).forEach(v->sender.sendMessage(v.id()+" "+v.displayName()+" world="+v.world()+" x="+v.x()+" y="+v.y()+" z="+v.z()));}case"place"->{if(!(sender instanceof Player player)){usageGiver(sender);return;}String name=join(args,2);var location=player.getLocation();directory.placeGiver(name,Objects.requireNonNull(location.getWorld()).getUID(),location.getX(),location.getY(),location.getZ(),location.getYaw(),location.getPitch()).whenComplete((value,failure)->respond(sender,()->{if(failure!=null){sender.sendMessage("Quest Giver save failed; desired state is unchanged.");return;}var world=plugin.getServer().getWorld(value.world());if(world!=null&&world.isChunkLoaded(section(value.x()),section(value.z())))controller.reconcile(world.getChunkAt(section(value.x()),section(value.z())));sender.sendMessage("Placed Quest Giver "+value.id()+" ("+value.displayName()+").");}));}case"remove"->{if(args.length!=3){usageGiver(sender);return;}UUID id=parse(args[2]);if(id==null){usageGiver(sender);return;}directory.removeGiver(id).whenComplete((removed,failure)->respond(sender,()->{if(failure!=null)sender.sendMessage("Quest Giver removal failed; desired state is unchanged.");else if(removed.isEmpty())sender.sendMessage("Quest Giver not found.");else{controller.removeGiverLoaded(id);sender.sendMessage("Removed Quest Giver "+id+".");}}));}default->usageGiver(sender);}}
+    public List<String> complete(CommandSender sender,String[] args){if(args.length==1){var values=new ArrayList<String>();values.add("adventure");if(sender.hasPermission(PERMISSION)){values.add("adventure-site");values.add("quest-giver");}return matching(values,args[0]);}if(!sender.hasPermission(PERMISSION))return List.of();if(args.length==2&&args[0].equals("adventure"))return matching(List.of("reroll"),args[1]);if(args.length==3&&args[0].equals("adventure")&&args[1].equals("reroll"))return matching(List.of("confirm"),args[2]);if(args.length==2&&args[0].equals("adventure-site"))return matching(sender instanceof Player?List.of("list","place","remove"):List.of("list","remove"),args[1]);if(args.length==3&&args[0].equals("adventure-site")&&args[1].equals("place"))return matching(List.of("camp","champion"),args[2]);if(args.length==3&&args[0].equals("adventure-site")&&args[1].equals("remove"))return matching(directory.snapshot().sites().stream().map(v->v.id().toString()).toList(),args[2]);if(args.length==2&&args[0].equals("quest-giver"))return matching(sender instanceof Player?List.of("list","place","remove"):List.of("list","remove"),args[1]);if(args.length==3&&args[0].equals("quest-giver")&&args[1].equals("remove"))return matching(directory.snapshot().givers().stream().map(v->v.id().toString()).toList(),args[2]);return List.of();}
+    private boolean authorized(CommandSender sender){if(sender.hasPermission(PERMISSION))return true;sender.sendMessage("Permission denied: you need fantasystick.admin to administer Fantasy Stick.");return false;}
+    private void respond(CommandSender sender,Runnable response){try{nextTick.accept(()->{if(sender.hasPermission(PERMISSION)&&(!(sender instanceof Player player)||player.isOnline()))response.run();});}catch(RuntimeException ignored){}}
+    private static String join(String[] args,int start){return start>=args.length?"":String.join(" ",Arrays.copyOfRange(args,start,args.length));}
+    private static UUID parse(String value){try{var id=UUID.fromString(value);return id.toString().equals(value)?id:null;}catch(IllegalArgumentException invalid){return null;}}
+    private static int section(double coordinate){return((int)Math.floor(coordinate))>>4;}
+    private static List<String> matching(Collection<String> values,String prefix){return values.stream().filter(v->v.startsWith(prefix)).distinct().sorted().toList();}
+    private static void usageSite(CommandSender sender){sender.sendMessage("Usage: /fantasystick adventure-site <place <camp|champion> [name...]|remove <site-uuid>|list>");}
+    private static void usageGiver(CommandSender sender){sender.sendMessage("Usage: /fantasystick quest-giver <place [name...]|remove <giver-uuid>|list>");}
+}

src/main/java/games/dmg/fantasystick/adventure/AdventureQuestController.java

@@ -0,0 +1,104 @@
+package games.dmg.fantasystick.adventure;
+
+import games.dmg.fantasystick.party.PartyRoster;
+import games.dmg.fantasystick.persistence.AdventureQuestSettings;
+import games.dmg.fantasystick.persistence.CharacterStorage;
+import games.dmg.fantasystick.progression.ProgressionRules;
+import games.dmg.fantasystick.progression.RewardAllocator;
+import games.dmg.fantasystick.session.EquipmentSessions;
+import java.math.BigInteger;
+import java.time.Clock;
+import java.time.Instant;
+import java.util.*;
+import java.util.concurrent.CompletableFuture;
+import java.util.function.Consumer;
+import org.bukkit.*;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.*;
+import org.bukkit.attribute.Attribute;
+import org.bukkit.boss.*;
+import org.bukkit.event.*;
+import org.bukkit.event.entity.*;
+import org.bukkit.event.inventory.InventoryClickEvent;
+import org.bukkit.event.player.PlayerInteractEntityEvent;
+import org.bukkit.event.entity.PlayerLeashEntityEvent;
+import org.bukkit.inventory.*;
+import org.bukkit.persistence.PersistentDataType;
+import org.bukkit.plugin.Plugin;
+
+/** Native Quest Givers, shared camp/champion attempts, eligibility containment and idempotent completion rewards. */
+public final class AdventureQuestController implements Listener,AutoCloseable {
+    private static final String GIVER="quest_giver",ENEMY="adventure_enemy",PROJECTILE="adventure_projectile";
+    private final Plugin plugin;private final AdventureQuestDirectory directory;private final AdventureQuestSettings settings;
+    private final EquipmentSessions sessions;private final PartyRoster parties;private final CharacterStorage characters;private final ProgressionRules progression;
+    private final Consumer<Runnable> nextTick;private final Clock clock;private final java.util.random.RandomGenerator random;
+    private final NamespacedKey typeKey,idKey,siteKey,catalogKey,menuSiteKey,menuCatalogKey;
+    private final Set<Entity> relocating=Collections.newSetFromMap(new IdentityHashMap<>());
+    private final Map<UUID,Attempt> attempts=new HashMap<>();private final Map<UUID,Instant> readyAt=new HashMap<>();private final Set<UUID> starting=new HashSet<>();
+    private org.bukkit.scheduler.BukkitTask pulseTask;private boolean closed;
+    private static final class MenuHolder implements InventoryHolder {final UUID catalog;MenuHolder(UUID catalog){this.catalog=catalog;}@Override public Inventory getInventory(){return null;}}
+    private static final class Attempt {final UUID id=UUID.randomUUID(),site,catalog;final AdventureQuestState.SiteType type;final Set<UUID> entities=new HashSet<>(),represented=new HashSet<>();final int radius,resetSeconds;BossBar bossBar;LivingEntity champion;Instant absentSince;Attempt(UUID site,UUID catalog,AdventureQuestState.SiteType type,int radius,int resetSeconds){this.site=site;this.catalog=catalog;this.type=type;this.radius=radius;this.resetSeconds=resetSeconds;}}
+    public AdventureQuestController(Plugin plugin,AdventureQuestDirectory directory,AdventureQuestSettings settings,EquipmentSessions sessions,PartyRoster parties,CharacterStorage characters,ProgressionRules progression,Consumer<Runnable> nextTick,Clock clock,java.util.random.RandomGenerator random){this.plugin=Objects.requireNonNull(plugin);this.directory=Objects.requireNonNull(directory);this.settings=Objects.requireNonNull(settings);this.sessions=Objects.requireNonNull(sessions);this.parties=Objects.requireNonNull(parties);this.characters=Objects.requireNonNull(characters);this.progression=Objects.requireNonNull(progression);this.nextTick=Objects.requireNonNull(nextTick);this.clock=Objects.requireNonNull(clock);this.random=Objects.requireNonNull(random);typeKey=new NamespacedKey(plugin,"managed_npc_type");idKey=new NamespacedKey(plugin,"quest_giver_id");siteKey=new NamespacedKey(plugin,"adventure_site_id");catalogKey=new NamespacedKey(plugin,"adventure_catalog_id");menuSiteKey=new NamespacedKey(plugin,"quest_offer_site");menuCatalogKey=new NamespacedKey(plugin,"quest_offer_catalog");}
+    public void install(){for(var world:plugin.getServer().getWorlds()){var chunks=world.getLoadedChunks();if(chunks!=null)for(var chunk:chunks)reconcile(chunk);}pulseTask=plugin.getServer().getScheduler().runTaskTimer(plugin,this::pulse,20,20);}
+    public boolean giver(Entity entity){var data=entity.getPersistentDataContainer();return data!=null&&GIVER.equals(data.get(typeKey,PersistentDataType.STRING));}
+    public boolean enemy(Entity entity){var data=entity.getPersistentDataContainer();return data!=null&&ENEMY.equals(data.get(typeKey,PersistentDataType.STRING));}
+    public boolean managed(Entity entity){var data=entity.getPersistentDataContainer();return enemy(entity)||data!=null&&PROJECTILE.equals(data.get(typeKey,PersistentDataType.STRING));}
+    public void reconcile(Chunk chunk){if(closed)return;var desired=new HashMap<UUID,AdventureQuestState.Giver>();for(var giver:directory.snapshot().givers())if(giver.world().equals(chunk.getWorld().getUID())&&section(giver.x())==chunk.getX()&&section(giver.z())==chunk.getZ())desired.put(giver.id(),giver);var retained=new HashSet<UUID>();for(var entity:chunk.getEntities()){if(managed(entity)){entity.remove();continue;}if(!giver(entity))continue;UUID id=id(entity,idKey);var value=id==null?null:desired.get(id);if(!(entity instanceof Villager villager)||value==null||!retained.add(id)){entity.remove();continue;}configure(villager,value);var expected=location(value);var current=villager.getLocation();if(current.distanceSquared(expected)>0.000001||Math.abs(current.getYaw()-expected.getYaw())>0.001||Math.abs(current.getPitch()-expected.getPitch())>0.001){relocating.add(villager);boolean moved;try{moved=villager.teleport(expected);}finally{relocating.remove(villager);}if(!moved){villager.remove();spawnGiver(value);}}}for(var value:desired.values())if(!retained.contains(value.id()))spawnGiver(value);}
+    public void removeGiverLoaded(UUID id){for(var world:plugin.getServer().getWorlds())for(var entity:safe(world.getEntities()))if(giver(entity)&&id.equals(id(entity,idKey)))entity.remove();}
+    public void removeSiteLoaded(UUID id){var attempt=attempts.remove(id);if(attempt!=null)cleanup(attempt);readyAt.remove(id);}
+    public boolean hasActiveEncounter(){return !attempts.isEmpty()||!starting.isEmpty();}
+    public void catalogRerolled(){if(hasActiveEncounter())throw new IllegalStateException("Active adventure encounter");readyAt.clear();}
+    private void spawnGiver(AdventureQuestState.Giver value){var world=plugin.getServer().getWorld(value.world());if(world==null||!world.isChunkLoaded(section(value.x()),section(value.z())))return;world.spawn(location(value),Villager.class,villager->configure(villager,value));}
+    private void configure(Villager villager,AdventureQuestState.Giver value){var data=villager.getPersistentDataContainer();data.set(typeKey,PersistentDataType.STRING,GIVER);data.set(idKey,PersistentDataType.STRING,value.id().toString());villager.setAI(false);villager.setGravity(false);villager.setSilent(true);villager.setInvulnerable(true);villager.setCollidable(false);villager.setCanPickupItems(false);villager.setLeashHolder(null);villager.setRemoveWhenFarAway(false);villager.setAdult();villager.setAgeLock(true);villager.customName(net.kyori.adventure.text.Component.text(value.displayName()));villager.setCustomNameVisible(true);}
+    public void open(Player player){var context=context(player);if(context==null){player.sendMessage("Quest Giver refused: actively play a living fantasy character first.");return;}directory.ensureToday().whenComplete((catalog,failure)->schedule(()->{if(failure!=null||context(player)==null){player.sendMessage("Daily quests are unavailable.");return;}var inventory=plugin.getServer().createInventory(new MenuHolder(catalog.revision()),Math.max(9,Math.min(54,((catalog.sites().size()+8)/9)*9)),net.kyori.adventure.text.Component.text("Daily Adventure Quests"));int slot=0;for(UUID siteId:catalog.sites()){var site=directory.findSite(siteId).orElse(null);var item=new ItemStack(site==null?Material.BARRIER:site.type()==AdventureQuestState.SiteType.CAMP?Material.CAMPFIRE:Material.NETHERITE_SWORD);var meta=item.getItemMeta();String name=site==null?"Unavailable site":site.displayName();meta.displayName(net.kyori.adventure.text.Component.text(name));var active=directory.activeFor(context.character,context.partyId).orElse(null);String state=site==null?"Unavailable":active!=null&&active.site().equals(siteId)?"Active — click to abandon":active!=null?"Another quest is active":directory.claimed(catalog.revision(),siteId,context.character,context.partyId)?"Completed / already claimed":"Available — click to accept";var rules=settings.rules();String kind=site!=null&&site.type()==AdventureQuestState.SiteType.CHAMPION?"Champion":"Monster camp";var rewardXp=active!=null&&active.site().equals(siteId)?active.rewardXp():site!=null&&site.type()==AdventureQuestState.SiteType.CHAMPION?rules.championRewardXp():rules.campRewardXp();var rewardCoins=active!=null&&active.site().equals(siteId)?active.rewardCoins():site!=null&&site.type()==AdventureQuestState.SiteType.CHAMPION?rules.championRewardCoins():rules.campRewardCoins();meta.lore(List.of(net.kyori.adventure.text.Component.text(kind),net.kyori.adventure.text.Component.text("Reward: "+rewardXp+" XP, "+rewardCoins+" coins"),net.kyori.adventure.text.Component.text("Expires: "+catalog.expiresAt()),net.kyori.adventure.text.Component.text(state)));meta.getPersistentDataContainer().set(menuSiteKey,PersistentDataType.STRING,siteId.toString());meta.getPersistentDataContainer().set(menuCatalogKey,PersistentDataType.STRING,catalog.revision().toString());item.setItemMeta(meta);inventory.setItem(slot++,item);}player.openInventory(inventory);}));}
+    private record Context(EquipmentSessions.Active active,UUID character,UUID partyId,boolean leader,Set<UUID> members){}
+    private Context context(Player player){var active=sessions.active(player.getUniqueId()).filter(sessions::current).orElse(null);if(active==null)return null;var record=sessions.currentRecord(active).orElse(null);if(record==null||record.dead())return null;var party=parties.partyOf(player.getUniqueId()).orElse(null);if(party==null)return new Context(active,record.id(),null,true,Set.of(record.id()));return new Context(active,record.id(),party.id(),party.leaderCharacter().equals(record.id()),Set.copyOf(party.characters()));}
+    @EventHandler(priority=EventPriority.HIGHEST,ignoreCancelled=true)public void interact(PlayerInteractEntityEvent event){if(!giver(event.getRightClicked()))return;event.setCancelled(true);if(event.getHand()!=EquipmentSlot.HAND)return;UUID id=id(event.getRightClicked(),idKey);if(id!=null&&directory.findGiver(id).isPresent())open(event.getPlayer());}
+    @EventHandler(priority=EventPriority.HIGHEST)public void click(InventoryClickEvent event){if(!(event.getInventory().getHolder() instanceof MenuHolder holder))return;event.setCancelled(true);if(!(event.getWhoClicked() instanceof Player player)||event.getCurrentItem()==null)return;var data=event.getCurrentItem().getPersistentDataContainer();UUID site=parse(data.get(menuSiteKey,PersistentDataType.STRING)),catalog=parse(data.get(menuCatalogKey,PersistentDataType.STRING));if(site==null||catalog==null||!holder.catalog.equals(catalog))return;var context=context(player);if(context==null){player.sendMessage("Quest action refused: stale fantasy session.");return;}var active=directory.activeFor(context.character,context.partyId).orElse(null);if(active!=null){if(!active.site().equals(site)){player.sendMessage("Quest action refused: another quest is active.");return;}directory.abandon(active.id(),active.unit()).whenComplete((changed,failure)->schedule(()->{player.sendMessage(failure==null&&changed?"Adventure quest abandoned.":"Quest abandonment failed; retained state is unchanged.");open(player);}));return;}if(context.partyId!=null&&!context.leader){player.sendMessage("Only the active party leader may accept a party quest.");return;}var type=context.partyId==null?AdventureQuestState.UnitType.SOLO:AdventureQuestState.UnitType.PARTY;var unit=context.partyId==null?context.character:context.partyId;directory.accept(catalog,site,type,unit,context.members).whenComplete((result,failure)->schedule(()->{if(failure!=null){player.sendMessage("Quest acceptance failed; retained state is unchanged.");return;}if(result.status()!=AdventureQuestDirectory.Acceptance.APPLIED){player.sendMessage("Quest acceptance refused: "+result.status().name().toLowerCase(Locale.ROOT)+".");return;}var location=directory.findSite(site).orElseThrow();player.sendMessage("Accepted "+location.displayName()+" at "+location.world()+" "+location.x()+", "+location.y()+", "+location.z()+"; expires "+result.quest().orElseThrow().expiresAt()+".");}));}
+    public void inspect(Player player){var context=context(player);if(context==null){player.sendMessage("No active fantasy character.");return;}var quest=directory.activeFor(context.character,context.partyId).orElse(null);if(quest==null){player.sendMessage("No active adventure quest.");return;}var site=directory.findSite(quest.site()).orElse(null);if(site==null){player.sendMessage("Active quest site is unavailable.");return;}player.sendMessage(site.displayName()+" at "+site.world()+" "+site.x()+", "+site.y()+", "+site.z()+"; state="+(attempts.containsKey(site.id())?"active":"waiting")+"; expires "+quest.expiresAt()+".");}
+    private void pulse(){if(closed)return;directory.ensureToday();directory.expireParties(parties::exists);for(var attempt:new ArrayList<>(attempts.values())){var catalog=directory.snapshot().catalog();if(catalog==null||!catalog.revision().equals(attempt.catalog)||!clock.instant().isBefore(catalog.expiresAt())){cleanup(attempt);attempts.remove(attempt.site);readyAt.remove(attempt.site);continue;}contain(attempt);syncBossBar(attempt);boolean present=eligibleInside(attempt.site,attempt.radius).findAny().isPresent();if(present)attempt.absentSince=null;else if(attempt.absentSince==null)attempt.absentSince=clock.instant();else if(!clock.instant().isBefore(attempt.absentSince.plusSeconds(attempt.resetSeconds))){cleanup(attempt);attempts.remove(attempt.site);readyAt.put(attempt.site,clock.instant());}}for(var quest:directory.active()){if(attempts.containsKey(quest.site())||starting.contains(quest.site()))continue;var ready=readyAt.get(quest.site());if(ready!=null&&clock.instant().isBefore(ready))continue;if(eligibleInside(quest.site()).findAny().isPresent())start(quest.site(),quest.catalog());}}
+    private void contain(Attempt attempt){var site=directory.findSite(attempt.site).orElse(null);if(site==null)return;var world=plugin.getServer().getWorld(site.world());if(world==null)return;for(var entity:safe(world.getEntities()))if(enemy(entity)&&attempt.site.equals(site(entity))&&!inside(entity.getLocation(),site,attempt.radius)){relocating.add(entity);try{entity.teleport(new Location(world,site.x(),site.y(),site.z()));if(entity instanceof LivingEntity living)living.setVelocity(new org.bukkit.util.Vector());}finally{relocating.remove(entity);}}}
+    private java.util.stream.Stream<Player> eligibleInside(UUID site){return eligibleInside(site,settings.rules().radius());}
+    private java.util.stream.Stream<Player> eligibleInside(UUID site,int radius){var value=directory.findSite(site).orElse(null);if(value==null)return java.util.stream.Stream.empty();return plugin.getServer().getOnlinePlayers().stream().map(Player.class::cast).filter(player->eligible(player,site)!=null).filter(player->inside(player.getLocation(),value,radius));}
+    private AdventureQuestState.Quest eligible(Player player,UUID site){var context=context(player);if(context==null)return null;var quest=directory.activeFor(context.character,context.partyId).orElse(null);return quest!=null&&quest.site().equals(site)&&quest.snapshot().contains(context.character)?quest:null;}
+    private void start(UUID site,UUID catalog){var value=directory.findSite(site).orElse(null);if(value==null)return;if(value.type()==AdventureQuestState.SiteType.CHAMPION){startChampion(value,catalog);return;}starting.add(site);directory.roster(site).whenComplete((roster,failure)->schedule(()->{starting.remove(site);if(failure!=null||closed||attempts.containsKey(site))return;var current=directory.findSite(site).orElse(null);if(current==null)return;var world=plugin.getServer().getWorld(current.world());if(world==null||!world.isChunkLoaded(section(current.x()),section(current.z())))return;var rules=settings.rules();var attempt=new Attempt(site,catalog,current.type(),rules.radius(),rules.resetSeconds());attempts.put(site,attempt);for(int index=0;index<roster.size();index++)spawnEnemy(world,current,roster.get(index),attempt,index);}));}
+    private void startChampion(AdventureQuestState.Site site,UUID catalog){if(closed||attempts.containsKey(site.id())||starting.contains(site.id()))return;var world=plugin.getServer().getWorld(site.world());if(world==null||!world.isChunkLoaded(section(site.x()),section(site.z())))return;starting.add(site.id());try{var rules=settings.rules();var attempt=new Attempt(site.id(),catalog,site.type(),rules.radius(),rules.resetSeconds());attempt.bossBar=plugin.getServer().createBossBar("Daybreak Champion",BarColor.RED,BarStyle.SOLID);attempts.put(site.id(),attempt);world.spawn(new Location(world,site.x(),site.y(),site.z()),Vindicator.class,champion->{configureEnemy(champion,attempt);var maximum=Objects.requireNonNull(champion.getAttribute(Attribute.MAX_HEALTH));maximum.setBaseValue(rules.championHealth());champion.setHealth(rules.championHealth());Objects.requireNonNull(champion.getAttribute(Attribute.ATTACK_DAMAGE)).setBaseValue(rules.championDamage());champion.customName(net.kyori.adventure.text.Component.text("Daybreak Champion"));champion.setCustomNameVisible(true);attempt.champion=champion;});syncBossBar(attempt);}catch(RuntimeException failure){var attempt=attempts.remove(site.id());if(attempt!=null)cleanup(attempt);plugin.getLogger().log(java.util.logging.Level.WARNING,"Champion attempt could not start at site "+site.id(),failure);}finally{starting.remove(site.id());}}
+    private void spawnEnemy(World world,AdventureQuestState.Site site,org.bukkit.entity.EntityType type,Attempt attempt,int index){var location=new Location(world,site.x()+(index%3)-1,site.y(),site.z()+(index/3));switch(type){case HUSK->world.spawn(location,Husk.class,mob->configureEnemy(mob,attempt));case PILLAGER->world.spawn(location,Pillager.class,mob->configureEnemy(mob,attempt));case VINDICATOR->world.spawn(location,Vindicator.class,mob->configureEnemy(mob,attempt));case WITCH->world.spawn(location,Witch.class,mob->configureEnemy(mob,attempt));default->throw new IllegalArgumentException("Unsupported camp entity");}}
+    private void configureEnemy(Mob mob,Attempt attempt){mob.getPersistentDataContainer().set(typeKey,PersistentDataType.STRING,ENEMY);mob.getPersistentDataContainer().set(siteKey,PersistentDataType.STRING,attempt.site.toString());mob.getPersistentDataContainer().set(catalogKey,PersistentDataType.STRING,attempt.catalog.toString());mob.setCanPickupItems(false);mob.setRemoveWhenFarAway(false);mob.setPersistent(true);mob.setFireTicks(0);if(mob instanceof Husk husk){husk.setShouldBurnInDay(false);husk.setCanBreakDoors(false);}if(mob instanceof Raider raider){raider.setPatrolLeader(false);raider.setCanJoinRaid(false);}attempt.entities.add(mob.getUniqueId());}
+    @EventHandler(priority=EventPriority.HIGHEST,ignoreCancelled=true)public void damage(EntityDamageEvent event){if(enemy(event.getEntity())){if(!(event instanceof EntityDamageByEntityEvent by)||source(by)==null||eligible(source(by),site(event.getEntity()))==null)event.setCancelled(true);return;}if(event instanceof EntityDamageByEntityEvent by&&managed(by.getDamager())){UUID site=site(by.getDamager());if(!(event.getEntity() instanceof Player player)||site==null||eligible(player,site)==null)event.setCancelled(true);}}
+    @EventHandler(priority=EventPriority.MONITOR,ignoreCancelled=true)public void accepted(EntityDamageByEntityEvent event){if(!enemy(event.getEntity())||event.getFinalDamage()<=0||!Double.isFinite(event.getFinalDamage()))return;var player=source(event);if(player==null)return;var quest=eligible(player,site(event.getEntity()));if(quest!=null){var attempt=attempts.get(quest.site());if(attempt!=null){attempt.represented.add(quest.id());if(attempt.champion==event.getEntity()&&attempt.bossBar!=null){double maximum=Objects.requireNonNull(attempt.champion.getAttribute(Attribute.MAX_HEALTH)).getValue();attempt.bossBar.setProgress(Math.max(0,Math.min(1,(attempt.champion.getHealth()-event.getFinalDamage())/maximum)));}}}}
+    @EventHandler(priority=EventPriority.HIGHEST)public void death(EntityDeathEvent event){if(!enemy(event.getEntity()))return;event.getDrops().clear();event.setDroppedExp(0);UUID site=site(event.getEntity());var attempt=site==null?null:attempts.get(site);if(attempt==null)return;attempt.entities.remove(event.getEntity().getUniqueId());if(attempt.entities.isEmpty())clear(attempt);}
+    private void clear(Attempt attempt){attempts.remove(attempt.site);if(attempt.bossBar!=null)attempt.bossBar.removeAll();readyAt.put(attempt.site,clock.instant().plusSeconds(attempt.resetSeconds));for(UUID questId:Set.copyOf(attempt.represented)){var quest=directory.findQuest(questId).orElse(null);if(quest==null)continue;var recipients=recipients(quest,attempt.site,attempt.radius);if(!recipients.isEmpty())award(quest,recipients);} }
+    private List<UUID> recipients(AdventureQuestState.Quest quest,UUID site){return recipients(quest,site,settings.rules().radius());}
+    private List<UUID> recipients(AdventureQuestState.Quest quest,UUID site,int radius){var value=directory.findSite(site).orElse(null);if(value==null)return List.of();var result=new ArrayList<UUID>();for(UUID character:quest.snapshot()){if(directory.characterClaimed(quest.catalog(),quest.site(),character))continue;var active=sessions.activeCharacter(character).filter(sessions::current).orElse(null);if(active==null)continue;var player=plugin.getServer().getPlayer(active.player());if(player==null||!inside(player.getLocation(),value,radius))continue;if(quest.unitType()==AdventureQuestState.UnitType.PARTY){var party=parties.partyOf(player.getUniqueId()).orElse(null);if(party==null||!party.id().equals(quest.unit())||!party.characters().contains(character))continue;}result.add(character);}return result.stream().distinct().sorted().toList();}
+    private void award(AdventureQuestState.Quest quest,List<UUID> recipients){var unit=new RewardAllocator.Unit<UUID>(quest.unit(),recipients);var xp=RewardAllocator.allocate(quest.rewardXp(),List.of(unit),random);var coins=RewardAllocator.allocate(quest.rewardCoins(),List.of(unit),random);var work=recipients.stream().map(character->awardOne(quest,character,xp.get(character),coins.get(character))).toArray(CompletableFuture[]::new);CompletableFuture.allOf(work).whenComplete((ignored,failure)->{if(failure==null)directory.complete(quest.id(),Set.copyOf(recipients));else plugin.getLogger().log(java.util.logging.Level.WARNING,"Adventure completion reward failed for quest "+quest.id(),failure);});}
+    private java.util.concurrent.CompletableFuture<Void> awardOne(AdventureQuestState.Quest quest,UUID character,BigInteger xp,BigInteger coins){var result=new java.util.concurrent.CompletableFuture<Void>();characters.find(character).whenComplete((found,failure)->{if(failure!=null||found.isEmpty()){result.completeExceptionally(failure==null?new IllegalStateException("Character unavailable"):failure);return;}attemptAward(quest,found.orElseThrow(),xp,coins,result);});return result;}
+    private void attemptAward(AdventureQuestState.Quest quest,games.dmg.fantasystick.persistence.CharacterRecord record,BigInteger xp,BigInteger coins,java.util.concurrent.CompletableFuture<Void> result){UUID receipt=UUID.nameUUIDFromBytes((quest.catalog()+":"+quest.site()+":"+quest.unit()+":"+record.id()).getBytes(java.nio.charset.StandardCharsets.UTF_8));characters.awardCombatReward(record.id(),record.revision(),receipt,xp,coins,progression,games.dmg.fantasystick.progression.CombatRewardRules.defaults(),null).whenComplete((award,failure)->{if(failure!=null){result.completeExceptionally(failure);return;}if(award.status()==CharacterStorage.CombatAwardStatus.STALE&&award.record().isPresent()){attemptAward(quest,award.record().orElseThrow(),xp,coins,result);return;}if(award.record().isEmpty()){result.completeExceptionally(new IllegalStateException("Reward unavailable"));return;}var saved=award.record().orElseThrow();schedule(()->{var active=sessions.activeCharacter(saved.id()).filter(sessions::current).orElse(null);if(active!=null)sessions.acknowledgeProgress(active,saved.revision().subtract(BigInteger.ONE),saved);var player=active==null?null:plugin.getServer().getPlayer(active.player());if(player!=null&&award.status()!=CharacterStorage.CombatAwardStatus.DUPLICATE)player.sendMessage("Adventure complete: earned "+xp+" fantasy XP and "+coins+" character coins.");result.complete(null);});});}
+    @EventHandler(priority=EventPriority.HIGHEST,ignoreCancelled=true)public void splash(org.bukkit.event.entity.PotionSplashEvent event){if(!managed(event.getPotion()))return;UUID site=site(event.getPotion());for(var affected:List.copyOf(event.getAffectedEntities()))if(!(affected instanceof Player player)||site==null||eligible(player,site)==null)event.setIntensity(affected,0);}
+    @EventHandler(priority=EventPriority.HIGHEST,ignoreCancelled=true)public void target(EntityTargetLivingEntityEvent event){if(enemy(event.getEntity())&&event.getTarget()!=null){UUID site=site(event.getEntity());if(!(event.getTarget() instanceof Player player)||site==null||eligible(player,site)==null)event.setCancelled(true);}}
+    @EventHandler(priority=EventPriority.MONITOR,ignoreCancelled=true)public void projectile(org.bukkit.event.entity.ProjectileLaunchEvent event){if(event.getEntity().getShooter() instanceof Entity shooter&&enemy(shooter)){event.getEntity().getPersistentDataContainer().set(typeKey,PersistentDataType.STRING,PROJECTILE);event.getEntity().getPersistentDataContainer().set(siteKey,PersistentDataType.STRING,Objects.requireNonNull(site(shooter)).toString());}}
+    @EventHandler(priority=EventPriority.HIGHEST,ignoreCancelled=true)public void combust(EntityCombustEvent event){if(managed(event.getEntity())||giver(event.getEntity()))event.setCancelled(true);}
+    @EventHandler(priority=EventPriority.HIGHEST,ignoreCancelled=true)public void transform(EntityTransformEvent event){if(managed(event.getEntity())||giver(event.getEntity()))event.setCancelled(true);}
+    @EventHandler(priority=EventPriority.HIGHEST,ignoreCancelled=true)public void portal(EntityPortalEvent event){if(managed(event.getEntity())||giver(event.getEntity()))event.setCancelled(true);}
+    @EventHandler(priority=EventPriority.HIGHEST,ignoreCancelled=true)public void pickup(EntityPickupItemEvent event){if(managed(event.getEntity())||giver(event.getEntity()))event.setCancelled(true);}
+    @EventHandler(priority=EventPriority.HIGHEST,ignoreCancelled=true)public void block(EntityChangeBlockEvent event){if(managed(event.getEntity()))event.setCancelled(true);}
+    @EventHandler(priority=EventPriority.HIGHEST,ignoreCancelled=true)public void breed(EntityBreedEvent event){if(giver(event.getMother())||giver(event.getFather()))event.setCancelled(true);}
+    @EventHandler(priority=EventPriority.HIGHEST,ignoreCancelled=true)public void vehicle(org.bukkit.event.vehicle.VehicleEnterEvent event){if(giver(event.getEntered())||managed(event.getEntered()))event.setCancelled(true);}
+    @EventHandler(priority=EventPriority.HIGHEST,ignoreCancelled=true)public void leash(PlayerLeashEntityEvent event){if(giver(event.getEntity())||managed(event.getEntity()))event.setCancelled(true);}
+    @EventHandler(priority=EventPriority.HIGHEST,ignoreCancelled=true)public void teleport(EntityTeleportEvent event){if((giver(event.getEntity())||managed(event.getEntity()))&&!relocating.contains(event.getEntity()))event.setCancelled(true);}
+    @EventHandler(priority=EventPriority.MONITOR)public void chunkLoad(org.bukkit.event.world.ChunkLoadEvent event){reconcile(event.getChunk());}
+    @EventHandler(priority=EventPriority.MONITOR)public void chunkUnload(org.bukkit.event.world.ChunkUnloadEvent event){for(var entity:event.getChunk().getEntities())if(enemy(entity)){UUID site=site(entity);var attempt=site==null?null:attempts.remove(site);if(attempt!=null){cleanup(attempt);readyAt.put(site,clock.instant());}}}
+    @EventHandler(priority=EventPriority.HIGHEST,ignoreCancelled=true)public void giverDamage(EntityDamageEvent event){if(giver(event.getEntity()))event.setCancelled(true);}
+    private Player source(EntityDamageByEntityEvent event){if(event.getDamager() instanceof Player player)return player;if(event.getDamager() instanceof org.bukkit.entity.Projectile projectile&&projectile.getShooter() instanceof Player player)return player;return null;}
+    private UUID site(Entity entity){return parse(entity.getPersistentDataContainer().get(siteKey,PersistentDataType.STRING));}
+    private void syncBossBar(Attempt attempt){if(attempt.bossBar==null||attempt.champion==null)return;var viewers=eligibleInside(attempt.site,attempt.radius).collect(java.util.stream.Collectors.toSet());for(var player:plugin.getServer().getOnlinePlayers())if(viewers.contains(player))attempt.bossBar.addPlayer(player);else attempt.bossBar.removePlayer(player);double maximum=Objects.requireNonNull(attempt.champion.getAttribute(Attribute.MAX_HEALTH)).getValue();attempt.bossBar.setProgress(Math.max(0,Math.min(1,attempt.champion.getHealth()/maximum)));}
+    private void cleanup(Attempt attempt){if(attempt.bossBar!=null)attempt.bossBar.removeAll();for(var world:plugin.getServer().getWorlds())for(var entity:safe(world.getEntities()))if(enemy(entity)&&attempt.site.equals(site(entity)))entity.remove();attempt.entities.clear();}
+    private void schedule(Runnable task){if(closed)return;try{nextTick.accept(()->{if(!closed)task.run();});}catch(RuntimeException ignored){}}
+    private static boolean inside(Location location,AdventureQuestState.Site site,int radius){return location.getWorld()!=null&&location.getWorld().getUID().equals(site.world())&&location.distanceSquared(new Location(location.getWorld(),site.x(),site.y(),site.z()))<=radius*(double)radius;}
+    private Location location(AdventureQuestState.Giver value){return new Location(plugin.getServer().getWorld(value.world()),value.x(),value.y(),value.z(),value.yaw(),value.pitch());}
+    private static int section(double coordinate){return((int)Math.floor(coordinate))>>4;}
+    private static UUID parse(String value){try{return value==null?null:UUID.fromString(value);}catch(IllegalArgumentException invalid){return null;}}
+    private static UUID id(Entity entity,NamespacedKey key){return parse(entity.getPersistentDataContainer().get(key,PersistentDataType.STRING));}
+    private static <T>List<T> safe(Collection<T> values){return values==null?List.of():List.copyOf(values);}
+    @Override public void close(){closed=true;if(pulseTask!=null)pulseTask.cancel();for(var attempt:new ArrayList<>(attempts.values()))cleanup(attempt);attempts.clear();for(var world:plugin.getServer().getWorlds())for(var entity:safe(world.getEntities()))if(giver(entity)||enemy(entity))entity.remove();}
+}

src/main/java/games/dmg/fantasystick/adventure/AdventureQuestDirectory.java

@@ -0,0 +1,54 @@
+package games.dmg.fantasystick.adventure;
+
+import games.dmg.fantasystick.persistence.AdventureQuestSettings;
+import games.dmg.fantasystick.persistence.YamlAdventureQuestRepository;
+import java.io.IOException;
+import java.time.*;
+import java.util.*;
+import java.util.concurrent.*;
+import java.util.function.Supplier;
+import org.bukkit.entity.EntityType;
+
+/** Serialized durable daily catalog, acceptance, roster and completion authority. */
+public final class AdventureQuestDirectory implements AutoCloseable {
+    public enum Acceptance { APPLIED, STALE, UNAVAILABLE, CONFLICT, CLAIMED }
+    public enum RerollStatus { APPLIED, ACTIVE, STALE }
+    public record AcceptResult(Acceptance status,Optional<AdventureQuestState.Quest> quest) { }
+    public record RerollResult(RerollStatus status,Optional<AdventureQuestState.Catalog> catalog) { }
+    private final YamlAdventureQuestRepository repository;private final Clock clock;private final Supplier<AdventureQuestSettings.Rules> settings;private final java.util.random.RandomGenerator random;
+    private final ExecutorService worker=Executors.newSingleThreadExecutor(r->new Thread(r,"fantasy-adventure-persistence"));
+    private volatile AdventureQuestState snapshot;private boolean closed;private int pending;private final CompletableFuture<Void> drained=new CompletableFuture<>();
+    public AdventureQuestDirectory(YamlAdventureQuestRepository repository,Clock clock,Supplier<AdventureQuestSettings.Rules> settings,java.util.random.RandomGenerator random)throws IOException{this.repository=Objects.requireNonNull(repository);this.clock=Objects.requireNonNull(clock);this.settings=Objects.requireNonNull(settings);this.random=Objects.requireNonNull(random);snapshot=repository.load();}
+    public AdventureQuestState snapshot(){return snapshot;}
+    public Optional<AdventureQuestState.Site> findSite(UUID id){return snapshot.sites().stream().filter(v->v.id().equals(id)).findFirst();}
+    public Optional<AdventureQuestState.Giver> findGiver(UUID id){return snapshot.givers().stream().filter(v->v.id().equals(id)).findFirst();}
+    public Optional<AdventureQuestState.Quest> findQuest(UUID id){return snapshot.quests().stream().filter(v->v.id().equals(id)).findFirst();}
+    public CompletableFuture<AdventureQuestState.Site> placeSite(AdventureQuestState.SiteType type,String name,UUID world,double x,double y,double z){var value=new AdventureQuestState.Site(UUID.randomUUID(),type,name,world,x,y,z);return mutate(state->{var sites=new ArrayList<>(state.sites());sites.add(value);return result(copy(state,List.copyOf(sites),state.givers(),state.catalog(),state.quests(),state.unitClaims(),state.characterClaims(),state.rosters()),value);});}
+    public CompletableFuture<Optional<AdventureQuestState.Site>> removeSite(UUID id){return mutate(state->{var found=state.sites().stream().filter(v->v.id().equals(id)).findFirst();if(found.isEmpty())return result(state,Optional.empty());var sites=state.sites().stream().filter(v->!v.id().equals(id)).toList();var quests=state.quests().stream().filter(v->!v.site().equals(id)).toList();var rosters=new HashMap<>(state.rosters());rosters.remove(id);return result(copy(state,sites,state.givers(),state.catalog(),quests,state.unitClaims(),state.characterClaims(),rosters),found);});}
+    public CompletableFuture<AdventureQuestState.Giver> placeGiver(String name,UUID world,double x,double y,double z,float yaw,float pitch){var value=new AdventureQuestState.Giver(UUID.randomUUID(),name,world,x,y,z,yaw,pitch);return mutate(state->{var values=new ArrayList<>(state.givers());values.add(value);return result(copy(state,state.sites(),List.copyOf(values),state.catalog(),state.quests(),state.unitClaims(),state.characterClaims(),state.rosters()),value);});}
+    public CompletableFuture<Optional<AdventureQuestState.Giver>> removeGiver(UUID id){return mutate(state->{var found=state.givers().stream().filter(v->v.id().equals(id)).findFirst();if(found.isEmpty())return result(state,Optional.empty());return result(copy(state,state.sites(),state.givers().stream().filter(v->!v.id().equals(id)).toList(),state.catalog(),state.quests(),state.unitClaims(),state.characterClaims(),state.rosters()),found);});}
+    public CompletableFuture<AdventureQuestState.Catalog> ensureToday(){return mutate(state->{var today=LocalDate.now(clock.withZone(ZoneOffset.UTC));if(state.catalog()!=null&&state.catalog().day().equals(today))return result(expire(state),state.catalog());var catalog=roll(state,today,state.catalog()==null?Set.of():Set.copyOf(state.catalog().sites()));var next=copy(state,state.sites(),state.givers(),catalog,List.of(),Set.of(),Set.of(),Map.of());return result(next,catalog);});}
+    public CompletableFuture<RerollResult> rerollToday(){var current=snapshot.catalog();return rerollToday(current==null?null:current.revision());}
+    public CompletableFuture<RerollResult> rerollToday(UUID expectedRevision){return mutate(original->{var state=expire(original);var current=state.catalog();UUID actual=current==null?null:current.revision();if(!Objects.equals(expectedRevision,actual))return result(state,new RerollResult(RerollStatus.STALE,Optional.ofNullable(current)));if(!state.quests().isEmpty())return result(state,new RerollResult(RerollStatus.ACTIVE,Optional.ofNullable(current)));var today=LocalDate.now(clock.withZone(ZoneOffset.UTC));boolean sameDay=current!=null&&current.day().equals(today);var catalog=roll(state,today,sameDay?Set.copyOf(current.sites()):Set.of());var next=copy(state,state.sites(),state.givers(),catalog,List.of(),sameDay?state.unitClaims():Set.of(),sameDay?state.characterClaims():Set.of(),Map.of());return result(next,new RerollResult(RerollStatus.APPLIED,Optional.of(catalog)));});}
+    public CompletableFuture<AcceptResult> accept(UUID catalog,UUID site,AdventureQuestState.UnitType type,UUID unit,Set<UUID> members){return mutate(original->{var state=expire(original);var current=state.catalog();if(current==null||!current.day().equals(LocalDate.now(clock.withZone(ZoneOffset.UTC)))||!current.revision().equals(catalog))return result(state,new AcceptResult(Acceptance.STALE,Optional.empty()));if(!current.sites().contains(site)||find(state.sites(),site).isEmpty())return result(state,new AcceptResult(Acceptance.UNAVAILABLE,Optional.empty()));boolean unitClaimed=state.unitClaims().stream().anyMatch(claim->claim.site().equals(site)&&claim.type()==type&&claim.unit().equals(unit));boolean characterClaimed=members.stream().anyMatch(member->state.characterClaims().stream().anyMatch(claim->claim.site().equals(site)&&claim.character().equals(member)));if(unitClaimed||characterClaimed)return result(state,new AcceptResult(Acceptance.CLAIMED,Optional.empty()));boolean conflict=state.quests().stream().anyMatch(q->q.unit().equals(unit)||type==AdventureQuestState.UnitType.PARTY&&q.unitType()==AdventureQuestState.UnitType.SOLO&&members.contains(q.unit()));if(conflict)return result(state,new AcceptResult(Acceptance.CONFLICT,Optional.empty()));var rules=settings.get();var siteType=find(state.sites(),site).orElseThrow().type();var quest=new AdventureQuestState.Quest(UUID.randomUUID(),catalog,site,type,unit,members,current.expiresAt(),siteType==AdventureQuestState.SiteType.CAMP?rules.campRewardXp():rules.championRewardXp(),siteType==AdventureQuestState.SiteType.CAMP?rules.campRewardCoins():rules.championRewardCoins());var quests=new ArrayList<>(state.quests());quests.add(quest);return result(copy(state,state.sites(),state.givers(),current,List.copyOf(quests),state.unitClaims(),state.characterClaims(),state.rosters()),new AcceptResult(Acceptance.APPLIED,Optional.of(quest)));});}
+    public CompletableFuture<Boolean> abandon(UUID quest,UUID unit){return mutate(state->{var found=state.quests().stream().filter(q->q.id().equals(quest)&&q.unit().equals(unit)).findFirst();if(found.isEmpty())return result(state,false);return result(copy(state,state.sites(),state.givers(),state.catalog(),state.quests().stream().filter(q->!q.id().equals(quest)).toList(),state.unitClaims(),state.characterClaims(),state.rosters()),true);});}
+    public CompletableFuture<List<EntityType>> roster(UUID site){return mutate(state->{state=expire(state);if(state.catalog()==null||!state.catalog().day().equals(LocalDate.now(clock.withZone(ZoneOffset.UTC)))||!state.catalog().sites().contains(site)||find(state.sites(),site).filter(v->v.type()==AdventureQuestState.SiteType.CAMP).isEmpty())throw new IllegalArgumentException("Unavailable camp");var existing=state.rosters().get(site);if(existing!=null)return result(state,existing);var rolled=CampRoster.roll(settings.get().campEnemies(),random);var rosters=new HashMap<>(state.rosters());rosters.put(site,rolled);return result(copy(state,state.sites(),state.givers(),state.catalog(),state.quests(),state.unitClaims(),state.characterClaims(),rosters),rolled);});}
+    public CompletableFuture<Boolean> complete(UUID questId,Set<UUID> recipients){return mutate(state->{var quest=state.quests().stream().filter(q->q.id().equals(questId)).findFirst().orElse(null);if(quest==null)return result(state,false);var units=new HashSet<>(state.unitClaims());units.add(new AdventureQuestState.UnitClaim(quest.catalog(),quest.site(),quest.unitType(),quest.unit()));var characters=new HashSet<>(state.characterClaims());for(UUID recipient:recipients)characters.add(new AdventureQuestState.CharacterClaim(quest.catalog(),quest.site(),recipient));return result(copy(state,state.sites(),state.givers(),state.catalog(),state.quests().stream().filter(q->!q.id().equals(questId)).toList(),units,characters,state.rosters()),true);});}
+    public List<AdventureQuestState.Quest> active(){return expireView(snapshot).quests();}
+    public boolean characterClaimed(UUID catalog,UUID site,UUID character){return snapshot.characterClaims().stream().anyMatch(claim->claim.site().equals(site)&&claim.character().equals(character));}
+    public boolean claimed(UUID catalog,UUID site,UUID character,UUID party){var state=snapshot;return state.characterClaims().stream().anyMatch(claim->claim.site().equals(site)&&claim.character().equals(character))||(party!=null&&state.unitClaims().stream().anyMatch(claim->claim.site().equals(site)&&claim.type()==AdventureQuestState.UnitType.PARTY&&claim.unit().equals(party)));}
+    public Optional<AdventureQuestState.Quest> activeFor(UUID character,UUID party){return active().stream().filter(q->q.unitType()==AdventureQuestState.UnitType.SOLO?q.unit().equals(character):party!=null&&q.unit().equals(party)&&q.snapshot().contains(character)).findFirst();}
+    public CompletableFuture<Integer> expireParties(java.util.function.Predicate<UUID> exists){return mutate(state->{var quests=state.quests().stream().filter(q->q.unitType()!=AdventureQuestState.UnitType.PARTY||exists.test(q.unit())).toList();int removed=state.quests().size()-quests.size();return removed==0?result(state,0):result(copy(state,state.sites(),state.givers(),state.catalog(),quests,state.unitClaims(),state.characterClaims(),state.rosters()),removed);});}
+    private AdventureQuestState expire(AdventureQuestState state){var view=expireView(state);return view.equals(state)?state:view;}
+    private AdventureQuestState expireView(AdventureQuestState state){if(state.catalog()==null||clock.instant().isBefore(state.catalog().expiresAt()))return state;return copy(state,state.sites(),state.givers(),state.catalog(),List.of(),state.unitClaims(),state.characterClaims(),state.rosters());}
+    private AdventureQuestState.Catalog roll(AdventureQuestState state,LocalDate day,Set<UUID> previous){var alternatives=state.sites().stream().map(AdventureQuestState.Site::id).filter(id->!previous.contains(id)).collect(java.util.stream.Collectors.toCollection(ArrayList::new));var old=state.sites().stream().map(AdventureQuestState.Site::id).filter(previous::contains).collect(java.util.stream.Collectors.toCollection(ArrayList::new));shuffle(alternatives);shuffle(old);int count=Math.min(settings.get().dailySiteCount(),state.sites().size());var selected=new ArrayList<UUID>();selected.addAll(alternatives.subList(0,Math.min(count,alternatives.size())));if(selected.size()<count)selected.addAll(old.subList(0,count-selected.size()));return new AdventureQuestState.Catalog(day,UUID.randomUUID(),clock.instant(),selected);}
+    private void shuffle(List<UUID> values){for(int i=values.size()-1;i>0;i--){int j=random.nextInt(i+1);var v=values.get(i);values.set(i,values.get(j));values.set(j,v);}}
+    private static Optional<AdventureQuestState.Site> find(List<AdventureQuestState.Site> sites,UUID id){return sites.stream().filter(v->v.id().equals(id)).findFirst();}
+    private static AdventureQuestState copy(AdventureQuestState ignored,List<AdventureQuestState.Site> sites,List<AdventureQuestState.Giver> givers,AdventureQuestState.Catalog catalog,List<AdventureQuestState.Quest> quests,Set<AdventureQuestState.UnitClaim> unitClaims,Set<AdventureQuestState.CharacterClaim> characterClaims,Map<UUID,List<EntityType>> rosters){return new AdventureQuestState(sites,givers,catalog,quests,unitClaims,characterClaims,rosters);}
+    private record Result<T>(AdventureQuestState state,T value){}
+    private static <T>Result<T> result(AdventureQuestState state,T value){return new Result<>(state,value);}
+    private <T>CompletableFuture<T> mutate(java.util.function.Function<AdventureQuestState,Result<T>> operation){var future=new CompletableFuture<T>();synchronized(this){if(closed){future.completeExceptionally(new IOException("Adventure directory closed"));return future;}pending++;}worker.execute(()->{try{var result=operation.apply(snapshot);if(result.state()!=snapshot){repository.save(result.state());snapshot=result.state();}future.complete(result.value());}catch(Throwable failure){future.completeExceptionally(failure);}finally{finished();}});return future;}
+    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/adventure/AdventureQuestState.java

@@ -0,0 +1,46 @@
+package games.dmg.fantasystick.adventure;
+
+import java.math.BigInteger;
+import java.time.Instant;
+import java.time.LocalDate;
+import java.util.*;
+import org.bukkit.entity.EntityType;
+
+/** Immutable durable authority for registered daily-adventure locations, offers, quests and claims. */
+public record AdventureQuestState(List<Site> sites,List<Giver> givers,Catalog catalog,List<Quest> quests,
+                                  Set<UnitClaim> unitClaims,Set<CharacterClaim> characterClaims,
+                                  Map<UUID,List<EntityType>> rosters) {
+    public enum SiteType { CAMP, CHAMPION }
+    public enum UnitType { SOLO, PARTY }
+    public record Site(UUID id,SiteType type,String name,UUID world,double x,double y,double z) {
+        public Site { Objects.requireNonNull(id);Objects.requireNonNull(type);name=validName(name);Objects.requireNonNull(world);finite(x,y,z); }
+        public String displayName(){return name.isBlank()?type==SiteType.CAMP?"Monster Camp":"Champion Site":name;}
+    }
+    public record Giver(UUID id,String name,UUID world,double x,double y,double z,float yaw,float pitch) {
+        public Giver { Objects.requireNonNull(id);name=validName(name);Objects.requireNonNull(world);finite(x,y,z);if(!Float.isFinite(yaw)||!Float.isFinite(pitch))throw new IllegalArgumentException("Invalid facing"); }
+        public String displayName(){return name.isBlank()?"Quest Giver":name;}
+    }
+    public record Catalog(LocalDate day,UUID revision,Instant createdAt,List<UUID> sites) {
+        public Catalog { Objects.requireNonNull(day);Objects.requireNonNull(revision);Objects.requireNonNull(createdAt);sites=List.copyOf(sites);if(new HashSet<>(sites).size()!=sites.size())throw new IllegalArgumentException("Duplicate offer"); }
+        public Instant expiresAt(){return day.plusDays(1).atStartOfDay(java.time.ZoneOffset.UTC).toInstant();}
+    }
+    public record Quest(UUID id,UUID catalog,UUID site,UnitType unitType,UUID unit,Set<UUID> snapshot,
+                        Instant expiresAt,BigInteger rewardXp,BigInteger rewardCoins) {
+        public Quest { Objects.requireNonNull(id);Objects.requireNonNull(catalog);Objects.requireNonNull(site);Objects.requireNonNull(unitType);Objects.requireNonNull(unit);snapshot=Set.copyOf(snapshot);Objects.requireNonNull(expiresAt);Objects.requireNonNull(rewardXp);Objects.requireNonNull(rewardCoins);if(snapshot.isEmpty()||rewardXp.signum()<0||rewardCoins.signum()<0||unitType==UnitType.SOLO&&(!snapshot.equals(Set.of(unit))))throw new IllegalArgumentException("Invalid quest"); }
+    }
+    public record UnitClaim(UUID catalog,UUID site,UnitType type,UUID unit) {
+        public UnitClaim {Objects.requireNonNull(catalog);Objects.requireNonNull(site);Objects.requireNonNull(type);Objects.requireNonNull(unit);}
+    }
+    public record CharacterClaim(UUID catalog,UUID site,UUID character) {
+        public CharacterClaim {Objects.requireNonNull(catalog);Objects.requireNonNull(site);Objects.requireNonNull(character);}
+    }
+    public AdventureQuestState {
+        sites=List.copyOf(sites);givers=List.copyOf(givers);quests=List.copyOf(quests);unitClaims=Set.copyOf(unitClaims);characterClaims=Set.copyOf(characterClaims);
+        var copied=new LinkedHashMap<UUID,List<EntityType>>();rosters.forEach((key,value)->copied.put(key,List.copyOf(value)));rosters=Map.copyOf(copied);
+        unique(sites.stream().map(Site::id).toList());unique(givers.stream().map(Giver::id).toList());unique(quests.stream().map(Quest::id).toList());
+    }
+    public static AdventureQuestState empty(){return new AdventureQuestState(List.of(),List.of(),null,List.of(),Set.of(),Set.of(),Map.of());}
+    private static String validName(String name){Objects.requireNonNull(name);name=name.strip();if(name.codePointCount(0,name.length())>64||name.codePoints().anyMatch(c->{int t=Character.getType(c);return t==Character.CONTROL||t==Character.FORMAT||t==Character.SURROGATE;}))throw new IllegalArgumentException("Invalid name");return name;}
+    private static void finite(double... values){for(double value:values)if(!Double.isFinite(value))throw new IllegalArgumentException("Invalid position");}
+    private static void unique(List<UUID> values){if(new HashSet<>(values).size()!=values.size())throw new IllegalArgumentException("Duplicate identity");}
+}

src/main/java/games/dmg/fantasystick/adventure/CampRoster.java

@@ -0,0 +1,46 @@
+package games.dmg.fantasystick.adventure;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Objects;
+import java.util.function.IntSupplier;
+import java.util.function.IntUnaryOperator;
+import org.bukkit.entity.EntityType;
+
+/** Fixed weighted monster-camp roster generation with reviewed guarantees and caps. */
+public final class CampRoster {
+    private CampRoster() { }
+
+    public static List<EntityType> roll(int count, java.util.random.RandomGenerator random) {
+        Objects.requireNonNull(random);
+        return roll(count, () -> random.nextInt(100), random::nextInt);
+    }
+
+    static List<EntityType> roll(int count, IntSupplier percent, IntUnaryOperator shuffleIndex) {
+        Objects.requireNonNull(percent); Objects.requireNonNull(shuffleIndex);
+        if (count < 4 || count > 64) throw new IllegalArgumentException("Camp enemy count must be 4 through 64");
+        int guaranteed = (count + 1) / 2;
+        int pillagerCap = count / 2;
+        int vindicatorCap = Math.max(1, count / 4);
+        int pillagers = 0, vindicators = 0, witches = 0;
+        var result = new ArrayList<EntityType>(count);
+        for (int index = 0; index < guaranteed; index++) result.add(EntityType.HUSK);
+        while (result.size() < count) {
+            int roll = percent.getAsInt();
+            if (roll < 0 || roll >= 100) throw new IllegalArgumentException("Camp roll must be 0 through 99");
+            EntityType selected;
+            if (roll < 40) selected = EntityType.HUSK;
+            else if (roll < 75 && pillagers < pillagerCap) { selected = EntityType.PILLAGER; pillagers++; }
+            else if (roll < 95 && roll >= 75 && vindicators < vindicatorCap) { selected = EntityType.VINDICATOR; vindicators++; }
+            else if (roll >= 95 && witches < 1) { selected = EntityType.WITCH; witches++; }
+            else selected = EntityType.HUSK;
+            result.add(selected);
+        }
+        for (int index = result.size() - 1; index > 0; index--) {
+            int other = shuffleIndex.applyAsInt(index + 1);
+            if (other < 0 || other > index) throw new IllegalArgumentException("Invalid shuffle index");
+            var value = result.get(index); result.set(index, result.get(other)); result.set(other, value);
+        }
+        return List.copyOf(result);
+    }
+}

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

@@ -138,10 +138,12 @@ public final class CharacterBookController implements Consumer<ControlInput>, Au
         int start = Math.min(offset, (allOverview.size() - 1) / VOLUME_SIZE * VOLUME_SIZE);
         int end = Math.min(start + VOLUME_SIZE, allOverview.size());
         var pages = new java.util.ArrayList<Component>(allOverview.subList(start, end));
+        if(end==allOverview.size())pages.add(gearPage(record));
         if (record.unspentPoints().signum() > 0 && start == 0) statViews.put(input.session().player(), statView);
 
         var definitions = abilities.definitions().stream()
-            .sorted(java.util.Comparator.comparing(games.dmg.fantasystick.ability.AbilityDefinition::name)
+            .sorted(java.util.Comparator.comparing(games.dmg.fantasystick.ability.AbilityDefinition::category)
+                .thenComparing(games.dmg.fantasystick.ability.AbilityDefinition::name)
                 .thenComparing(games.dmg.fantasystick.ability.AbilityDefinition::id))
             .toList();
         var passiveDefinitions = passives.definitions().stream()
@@ -157,35 +159,51 @@ public final class CharacterBookController implements Consumer<ControlInput>, Au
                 passiveDefinitions.stream().map(games.dmg.fantasystick.passive.PassiveDefinition::id)
                     .collect(java.util.stream.Collectors.toUnmodifiableSet()));
             if (!passiveDefinitions.isEmpty()) passiveViews.put(input.session().player(), passiveView);
-            var details = definitions.stream().map(definition -> abilityPages(record, definition, abilityView)).toList();
             var passiveNames = passiveDefinitions.stream().collect(java.util.stream.Collectors.toMap(
                 games.dmg.fantasystick.passive.PassiveDefinition::id,
                 games.dmg.fantasystick.passive.PassiveDefinition::name));
-            var passiveDetails = passiveDefinitions.stream()
-                .map(definition -> passiveDetailPages(record, definition, passiveNames, passiveView)).toList();
+            var placeholderPassiveDetails = passiveDefinitions.stream()
+                .map(definition -> passiveDetailPages(record, definition, passiveNames, passiveView, 1)).toList();
             var placeholderTargets = definitions.stream().collect(java.util.stream.Collectors.toMap(
                 games.dmg.fantasystick.ability.AbilityDefinition::id, ignored -> 1));
             var passivePlaceholderTargets = passiveDefinitions.stream().collect(java.util.stream.Collectors.toMap(
                 games.dmg.fantasystick.passive.PassiveDefinition::id, ignored -> 1));
+            var placeholderDetails = definitions.stream()
+                .map(definition -> abilityPages(record, definition, abilityView, 1)).toList();
             int activeCount = activePages(record, definitions, placeholderTargets).size();
             int passiveCount = passiveSlotPages(record, passiveDefinitions, passivePlaceholderTargets).size();
-            int indexCount = indexPages(definitions, placeholderTargets).size();
-            int passiveIndexCount = passiveIndexPages(passiveDefinitions, passivePlaceholderTargets).size();
+            var placeholderIndex = indexPages(definitions, placeholderTargets);
+            int indexCount = placeholderIndex.pages().size();
+            var placeholderPassiveIndex = passiveIndexPages(passiveDefinitions, passivePlaceholderTargets);
+            int passiveIndexCount = placeholderPassiveIndex.pages().size();
+            int indexStart = pages.size() + activeCount + passiveCount;
+            var indexTargets = new java.util.HashMap<String, Integer>();
+            placeholderIndex.relativePageByAbility().forEach((id, page) -> indexTargets.put(id, indexStart + page + 1));
+            int passiveIndexStart = indexStart + indexCount;
+            var passiveIndexTargets = new java.util.HashMap<String, Integer>();
+            placeholderPassiveIndex.relativePageByPassive().forEach((id, page) ->
+                passiveIndexTargets.put(id, passiveIndexStart + page + 1));
             var targets = new java.util.HashMap<String, Integer>();
             int target = pages.size() + activeCount + passiveCount + indexCount + passiveIndexCount + 1;
             for (int index = 0; index < definitions.size(); index++) {
                 targets.put(definitions.get(index).id(), target);
-                target += details.get(index).size();
+                target += placeholderDetails.get(index).size();
             }
             var passiveTargets = new java.util.HashMap<String, Integer>();
             for (int index = 0; index < passiveDefinitions.size(); index++) {
                 passiveTargets.put(passiveDefinitions.get(index).id(), target);
-                target += passiveDetails.get(index).size();
+                target += placeholderPassiveDetails.get(index).size();
             }
+            var index = indexPages(definitions, targets);
+            var details = definitions.stream()
+                .map(definition -> abilityPages(record, definition, abilityView, indexTargets.get(definition.id()))).toList();
+            var passiveIndex = passiveIndexPages(passiveDefinitions, passiveTargets);
+            var passiveDetails = passiveDefinitions.stream().map(definition -> passiveDetailPages(record, definition,
+                passiveNames, passiveView, passiveIndexTargets.get(definition.id()))).toList();
             pages.addAll(activePages(record, definitions, targets));
             pages.addAll(passiveSlotPages(record, passiveDefinitions, passiveTargets));
-            pages.addAll(indexPages(definitions, targets));
-            pages.addAll(passiveIndexPages(passiveDefinitions, passiveTargets));
+            pages.addAll(index.pages());
+            pages.addAll(passiveIndex.pages());
             details.forEach(pages::addAll);
             passiveDetails.forEach(pages::addAll);
         }
@@ -204,6 +222,9 @@ public final class CharacterBookController implements Consumer<ControlInput>, Au
         return item;
     }
 
+    private Component gearPage(CharacterRecord record){return Component.text("Gear\n\nHead: Cosmetic\nChestplate: "+tier(record.gear().chestplate())+"\nLeggings: "+tier(record.gear().leggings())+"\nBoots: "+tier(record.gear().boots()));}
+    private static String tier(games.dmg.fantasystick.persistence.GearTier tier){String value=tier.name().toLowerCase(java.util.Locale.ROOT);return Character.toUpperCase(value.charAt(0))+value.substring(1);}
+
     private java.util.List<Component> overviewPages(CharacterRecord record, ControlInput input, StatView view) {
         var builder = new PageBuilder();
         builder.text(record.name());
@@ -270,34 +291,61 @@ public final class CharacterBookController implements Consumer<ControlInput>, Au
         return builder.pages();
     }
 
-    private static java.util.List<Component> indexPages(
-            java.util.List<games.dmg.fantasystick.ability.AbilityDefinition> definitions, Map<String, Integer> targets) {
-        var pages = new java.util.ArrayList<Component>();
-        for (int start = 0; start < definitions.size(); start += 11) {
-            var builder = new PageBuilder(); builder.text("Ability index"); builder.blank();
-            for (var definition : definitions.subList(start, Math.min(start + 11, definitions.size()))) {
-                builder.link("", definition.name(), targets.get(definition.id()));
-            }
-            pages.addAll(builder.pages());
-        }
-        return java.util.List.copyOf(pages);
+    private record AbilityIndex(java.util.List<Component> pages, Map<String, Integer> relativePageByAbility) {
+        private AbilityIndex { pages = java.util.List.copyOf(pages); relativePageByAbility = Map.copyOf(relativePageByAbility); }
     }
 
-    private static java.util.List<Component> passiveIndexPages(
-            java.util.List<games.dmg.fantasystick.passive.PassiveDefinition> definitions, Map<String, Integer> targets) {
+    private static AbilityIndex indexPages(
+            java.util.List<games.dmg.fantasystick.ability.AbilityDefinition> definitions, Map<String, Integer> targets) {
         var pages = new java.util.ArrayList<Component>();
-        for (int start = 0; start < definitions.size(); start += 11) {
+        var relativePages = new java.util.HashMap<String, Integer>();
+        for (var category : games.dmg.fantasystick.ability.AbilityDefinition.Category.values()) {
+            var grouped = definitions.stream().filter(definition -> definition.category() == category).toList();
+            int cursor = 0;
+            while (cursor < grouped.size()) {
+                var builder = new PageBuilder(); builder.text("Ability index"); builder.text(category.name());
+                int usedLines = 0;
+                while (cursor < grouped.size()) {
+                    var definition = grouped.get(cursor);
+                    int linkLines = BookPagination.lines(definition.name()).size();
+                    if (usedLines > 0 && usedLines + linkLines > 11) break;
+                    relativePages.put(definition.id(), pages.size());
+                    builder.link("", definition.name(), targets.get(definition.id()));
+                    usedLines += linkLines; cursor++;
+                }
+                pages.addAll(builder.pages());
+            }
+        }
+        return new AbilityIndex(pages, relativePages);
+    }
+
+    private record PassiveIndex(java.util.List<Component> pages, Map<String, Integer> relativePageByPassive) {
+        private PassiveIndex { pages = java.util.List.copyOf(pages); relativePageByPassive = Map.copyOf(relativePageByPassive); }
+    }
+
+    private static PassiveIndex passiveIndexPages(
+            java.util.List<games.dmg.fantasystick.passive.PassiveDefinition> definitions, Map<String, Integer> targets) {
+        var pages = new java.util.ArrayList<Component>(); var relativePages = new java.util.HashMap<String, Integer>();
+        int cursor = 0;
+        while (cursor < definitions.size()) {
             var builder = new PageBuilder(); builder.text("Passive index"); builder.blank();
-            for (var definition : definitions.subList(start, Math.min(start + 11, definitions.size()))) {
+            int usedLines = 0;
+            while (cursor < definitions.size()) {
+                var definition = definitions.get(cursor);
+                int linkLines = BookPagination.lines(definition.name()).size();
+                if (usedLines > 0 && usedLines + linkLines > 11) break;
+                relativePages.put(definition.id(), pages.size());
                 builder.link("", definition.name(), targets.get(definition.id()));
+                usedLines += linkLines; cursor++;
             }
             pages.addAll(builder.pages());
         }
-        return java.util.List.copyOf(pages);
+        return new PassiveIndex(pages, relativePages);
     }
 
     private static java.util.List<Component> passiveDetailPages(CharacterRecord record,
-            games.dmg.fantasystick.passive.PassiveDefinition definition, Map<String, String> names, PassiveView view) {
+            games.dmg.fantasystick.passive.PassiveDefinition definition, Map<String, String> names, PassiveView view,
+            int indexPage) {
         String requirements = definition.requirements().entrySet().stream().sorted(Map.Entry.comparingByKey())
             .map(entry -> entry.getKey() + " " + entry.getValue()).collect(java.util.stream.Collectors.joining(", "));
         if (!definition.prerequisites().isEmpty()) {
@@ -318,11 +366,13 @@ public final class CharacterBookController implements Consumer<ControlInput>, Au
         else if (prerequisites && stats && points && slot) builder.component(passiveButton("Learn", PASSIVE_UNLOCK, view, definition.id()));
         else builder.text(state);
         builder.blank(); definition.description().forEach(builder::text); builder.blank(); builder.text(state);
+        builder.component(Component.text("[Back to index]", net.kyori.adventure.text.format.NamedTextColor.DARK_BLUE)
+            .clickEvent(net.kyori.adventure.text.event.ClickEvent.changePage(indexPage)));
         return builder.pages();
     }
 
     private static java.util.List<Component> abilityPages(CharacterRecord record,
-            games.dmg.fantasystick.ability.AbilityDefinition definition, AbilityView view) {
+            games.dmg.fantasystick.ability.AbilityDefinition definition, AbilityView view, int indexPage) {
         String requirements = definition.requirements().isEmpty() ? "none" : definition.requirements().entrySet().stream()
             .sorted(Map.Entry.comparingByKey()).map(entry -> entry.getKey() + " " + entry.getValue())
             .collect(java.util.stream.Collectors.joining(", "));
@@ -335,6 +385,7 @@ public final class CharacterBookController implements Consumer<ControlInput>, Au
             : !points ? "Unavailable: points" : !slot ? "Unavailable: slots" : "Available";
         var builder = new PageBuilder();
         builder.text(definition.name());
+        builder.text(definition.category().name());
         builder.text(requirements);
         if (learned) builder.component(abilityButton("Unlearn", ABILITY_UNLEARN, view, definition.id()));
         else if (stats && points && slot) builder.component(abilityButton("Learn", ABILITY_UNLOCK, view, definition.id()));
@@ -347,6 +398,8 @@ public final class CharacterBookController implements Consumer<ControlInput>, Au
             .sorted(Map.Entry.comparingByKey()).map(entry -> entry.getKey() + "=" + entry.getValue())
             .collect(java.util.stream.Collectors.joining(", ")));
         builder.text(state);
+        builder.component(Component.text("[Back to index]", net.kyori.adventure.text.format.NamedTextColor.DARK_BLUE)
+            .clickEvent(net.kyori.adventure.text.event.ClickEvent.changePage(indexPage)));
         return builder.pages();
     }
 

src/main/java/games/dmg/fantasystick/combat/BasicAttack.java

@@ -1,5 +1,7 @@
 package games.dmg.fantasystick.combat;
 
+import games.dmg.fantasystick.ability.AbilityReport;
+import games.dmg.fantasystick.presentation.CombatFeedback;
 import games.dmg.fantasystick.progression.Stat;
 import games.dmg.fantasystick.session.ControlInput;
 import games.dmg.fantasystick.session.EquipmentSessions;
@@ -23,6 +25,8 @@ public final class BasicAttack implements Consumer<ControlInput>, Listener, Auto
     private static final Duration CADENCE = Duration.ofSeconds(1);
     private final EquipmentSessions sessions;
     private final Clock clock;
+    private final CombatFeedback feedback;
+    private final games.dmg.fantasystick.training.TrainingDamage trainingDamage;
     private final Map<UUID, Instant> readyAt = new HashMap<>();
     private Pending pending;
     private boolean closed;
@@ -31,19 +35,31 @@ public final class BasicAttack implements Consumer<ControlInput>, Listener, Auto
         final ControlInput input;
         final LivingEntity target;
         final Instant attackedAt;
+        final boolean knockback;
         boolean accepted;
-        Pending(ControlInput input, LivingEntity target, Instant attackedAt) {
-            this.input = input; this.target = target; this.attackedAt = attackedAt;
+        Pending(ControlInput input, LivingEntity target, Instant attackedAt, boolean knockback) {
+            this.input = input; this.target = target; this.attackedAt = attackedAt; this.knockback = knockback;
         }
     }
 
     public BasicAttack(EquipmentSessions sessions) {
-        this(sessions, Clock.systemUTC());
+        this(sessions, Clock.systemUTC(), null);
     }
 
     public BasicAttack(EquipmentSessions sessions, Clock clock) {
+        this(sessions, clock, null);
+    }
+
+    public BasicAttack(EquipmentSessions sessions, Clock clock, CombatFeedback feedback) {
+        this(sessions, clock, feedback, games.dmg.fantasystick.training.TrainingDamage.passthrough());
+    }
+
+    public BasicAttack(EquipmentSessions sessions, Clock clock, CombatFeedback feedback,
+                       games.dmg.fantasystick.training.TrainingDamage trainingDamage) {
         this.sessions = Objects.requireNonNull(sessions);
         this.clock = Objects.requireNonNull(clock);
+        this.feedback = feedback;
+        this.trainingDamage = Objects.requireNonNull(trainingDamage);
     }
 
     @Override public void accept(ControlInput input) {
@@ -57,30 +73,43 @@ public final class BasicAttack implements Consumer<ControlInput>, Listener, Auto
         if (ready != null && now.isBefore(ready)) return;
         BigInteger damage = damage(record.stats().get(Stat.STR));
         double nativeDamage = damage.bitLength() > 1023 ? Double.MAX_VALUE : damage.doubleValue();
-        var attempt = new Pending(input, target, now);
+        var attempt = new Pending(input, target, now,
+            record.passives().contains(games.dmg.fantasystick.passive.StickKnockback.ID));
         pending = attempt;
         try {
-            target.damage(nativeDamage, input.player());
+            var measured = trainingDamage.apply(input.player(), target, () -> target.damage(nativeDamage, input.player()));
+            measured.ifPresent(amount -> {
+                attempt.accepted = true;
+                if (feedback != null) feedback.report("Basic Attack", input.player(), AbilityReport.Type.DAMAGE, target, amount);
+            });
         } finally {
             if (pending == attempt) pending = null;
-            if (attempt.accepted) readyAt.put(input.session().character(), attempt.attackedAt.plus(CADENCE));
+            if (attempt.accepted) {
+                readyAt.put(input.session().character(), attempt.attackedAt.plus(CADENCE));
+                if (attempt.knockback && !trainingDamage.target(target) && input.stillCurrent()
+                        && sessions.current(input.session())) {
+                    games.dmg.fantasystick.passive.StickKnockback.apply(input.player(), target);
+                }
+            }
         }
     }
 
     static BigInteger damage(BigInteger strength) {
         Objects.requireNonNull(strength);
         if (strength.signum() < 0) throw new IllegalArgumentException("Strength must not be negative");
-        return strength.subtract(BigInteger.TEN).divide(BigInteger.TWO).max(BigInteger.ONE);
+        return strength.subtract(BigInteger.TEN).divide(BigInteger.TWO).add(BigInteger.ONE).max(BigInteger.ONE);
     }
 
     /** MONITOR observes the synchronous native result; cancelled/zero damage never spends cadence. */
     @EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = true)
     public void acceptedDamage(EntityDamageByEntityEvent event) {
         var attempt = pending;
-        if (closed || attempt == null || event.isCancelled() || event.getFinalDamage() <= 0
-                || event.getDamager() != attempt.input.player() || event.getEntity() != attempt.target
+        if (closed || attempt == null || attempt.accepted || event.isCancelled() || event.getFinalDamage() <= 0
+                || !Double.isFinite(event.getFinalDamage()) || event.getDamager() != attempt.input.player() || event.getEntity() != attempt.target
                 || !attempt.input.stillCurrent() || !sessions.current(attempt.input.session())) return;
         attempt.accepted = true;
+        if (feedback != null) feedback.report("Basic Attack", attempt.input.player(), AbilityReport.Type.DAMAGE,
+            event.getEntity(), java.math.BigDecimal.valueOf(event.getFinalDamage()).stripTrailingZeros());
     }
 
     @Override public void close() {

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

@@ -131,7 +131,7 @@ public final class EquipmentStorage {
         for (int slot : EQUIPMENT_SLOTS) {
             if (slot == 39) continue;
             var current = inventory.getItem(slot);
-            if (!empty(current) && !(slot < 9 && ownedControl.test(current.clone()))) return RestoreResult.OCCUPIED_SLOT;
+            if (!empty(current) && !ownedControl.test(current.clone())) return RestoreResult.OCCUPIED_SLOT;
         }
         var currentHead = inventory.getItem(39);
         var displacedHead = empty(currentHead) ? null : currentHead.clone();

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

@@ -0,0 +1,14 @@
+package games.dmg.fantasystick.items;
+
+import games.dmg.fantasystick.persistence.*;import java.util.*;import net.kyori.adventure.text.Component;import org.bukkit.*;import org.bukkit.inventory.*;import org.bukkit.persistence.PersistentDataType;import org.bukkit.plugin.Plugin;
+/** Native unbreakable session-bound projection of permanent character armor. */
+public final class GearItems{
+ private final NamespacedKey typeKey,ownerKey,sessionKey,slotKey,tierKey;
+ public GearItems(Plugin plugin){typeKey=new NamespacedKey(plugin,"character_gear");ownerKey=new NamespacedKey(plugin,"character_gear_owner");sessionKey=new NamespacedKey(plugin,"character_gear_session");slotKey=new NamespacedKey(plugin,"character_gear_slot");tierKey=new NamespacedKey(plugin,"character_gear_tier");}
+ public ItemStack create(GearSlot slot,GearTier tier,UUID owner,UUID session){if(tier==GearTier.NONE)return null;var item=new ItemStack(material(slot,tier));var meta=item.getItemMeta();meta.setUnbreakable(true);meta.setMaxStackSize(1);meta.displayName(Component.text("Fantasy "+title(tier)+" "+title(slot)));var data=meta.getPersistentDataContainer();data.set(typeKey,PersistentDataType.INTEGER,1);data.set(ownerKey,PersistentDataType.STRING,owner.toString());data.set(sessionKey,PersistentDataType.STRING,session.toString());data.set(slotKey,PersistentDataType.STRING,slot.name());data.set(tierKey,PersistentDataType.STRING,tier.name());item.setItemMeta(meta);return item;}
+ public boolean gear(ItemStack item){return item!=null&&!item.isEmpty()&&Integer.valueOf(1).equals(item.getItemMeta().getPersistentDataContainer().get(typeKey,PersistentDataType.INTEGER));}
+ public boolean owned(ItemStack item,UUID owner,UUID session){if(!gear(item))return false;var data=item.getItemMeta().getPersistentDataContainer();return owner.toString().equals(data.get(ownerKey,PersistentDataType.STRING))&&session.toString().equals(data.get(sessionKey,PersistentDataType.STRING));}
+ public void install(PlayerInventory inventory,CharacterRecord record,UUID owner,UUID session){inventory.setChestplate(create(GearSlot.CHESTPLATE,record.gear().chestplate(),owner,session));inventory.setLeggings(create(GearSlot.LEGGINGS,record.gear().leggings(),owner,session));inventory.setBoots(create(GearSlot.BOOTS,record.gear().boots(),owner,session));}
+ private static String title(Enum<?> value){String text=value.name().toLowerCase(Locale.ROOT).replace('_',' ');return Character.toUpperCase(text.charAt(0))+text.substring(1);}
+ private static Material material(GearSlot slot,GearTier tier){return Material.valueOf((tier==GearTier.GOLD?"GOLDEN":tier.name())+"_"+switch(slot){case CHESTPLATE->"CHESTPLATE";case LEGGINGS->"LEGGINGS";case BOOTS->"BOOTS";});}
+}

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

@@ -93,6 +93,9 @@ public final class SessionControls {
             var meta = item.getItemMeta();
             meta.displayName(Component.text(icon.name()));
             meta.setMaxStackSize(1);
+            if (slot == 1 && character.passives().contains(games.dmg.fantasystick.passive.StickKnockback.ID)) {
+                meta.addEnchant(org.bukkit.enchantments.Enchantment.KNOCKBACK, 1, true);
+            }
             if (cooling) meta.setItemModel(COOLDOWN_MODEL);
             var data = meta.getPersistentDataContainer();
             data.set(VERSION, PersistentDataType.INTEGER, 1);

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

@@ -41,6 +41,7 @@ public final class TailBooks {
             .append("\nCoins: ").append(character.coins());
         for (Stat stat : Stat.values()) summary.append('\n').append(stat).append(": ").append(character.stats().get(stat));
         pages.addAll(BookPagination.pages(summary.toString()));
+        pages.addAll(BookPagination.pages("Gear\nHead: Cosmetic\nChestplate: "+tier(character.gear().chestplate())+"\nLeggings: "+tier(character.gear().leggings())+"\nBoots: "+tier(character.gear().boots())));
         if (character.learned().isEmpty()) pages.addAll(BookPagination.pages("Abilities: None"));
         character.learned().stream().sorted().forEach(ability -> {
             var slots = new ArrayList<String>();
@@ -74,6 +75,11 @@ public final class TailBooks {
         return item;
     }
 
+    private static String tier(games.dmg.fantasystick.persistence.GearTier tier) {
+        String value = tier.name().toLowerCase(java.util.Locale.ROOT);
+        return Character.toUpperCase(value.charAt(0)) + value.substring(1);
+    }
+
     public Optional<Identity> identify(ItemStack item) {
         if (item == null || item.getType() != Material.WRITTEN_BOOK || !item.hasItemMeta()) return Optional.empty();
         var data = item.getItemMeta().getPersistentDataContainer();

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

@@ -57,7 +57,7 @@ public final class CombatExperience implements Listener, AutoCloseable {
 
     private final CharacterStorage characters;
     private final ProgressionRules progression;
-    private final CombatRewardRules rewards;
+    private volatile CombatRewardRules rewards;
     private final EquipmentSessions sessions;
     private final Clock clock;
     private final Consumer<Runnable> nextTick;
@@ -73,6 +73,7 @@ public final class CombatExperience implements Listener, AutoCloseable {
     private final Map<UUID, PendingAward> pending = new ConcurrentHashMap<>();
     private final java.util.concurrent.ConcurrentLinkedQueue<UUID> retries = new java.util.concurrent.ConcurrentLinkedQueue<>();
     private org.bukkit.scheduler.BukkitTask retryTask;
+    private java.util.function.Predicate<org.bukkit.entity.Entity> excluded = ignored -> false;
     private boolean closed;
 
     private final class PendingAward {
@@ -81,12 +82,13 @@ public final class CombatExperience implements Listener, AutoCloseable {
         final BigInteger experience;
         final BigInteger coins;
         final CombatRewardRules.KillPosition restricted;
+        final CombatRewardRules rewardRules;
         BigInteger expectedRevision;
         boolean running;
         PendingAward(UUID id, UUID character, BigInteger experience, BigInteger coins,
-                     CombatRewardRules.KillPosition restricted) {
+                     CombatRewardRules.KillPosition restricted, CombatRewardRules rewardRules) {
             this.id = id; this.character = character; this.experience = experience;
-            this.coins = coins; this.restricted = restricted;
+            this.coins = coins; this.restricted = restricted; this.rewardRules = rewardRules;
         }
     }
 
@@ -113,6 +115,11 @@ public final class CombatExperience implements Listener, AutoCloseable {
         sources = new CombatSources(sessions); contributions = new CombatContributions(rewards);
     }
 
+    public void attachExcluded(java.util.function.Predicate<org.bukkit.entity.Entity> predicate) {
+        if (closed) throw new IllegalStateException("Combat experience is closed");
+        excluded = Objects.requireNonNull(predicate);
+    }
+
     public void install(org.bukkit.plugin.Plugin plugin) {
         if (closed || retryTask != null) throw new IllegalStateException("Combat experience is already installed or closed");
         retryTask = plugin.getServer().getScheduler().runTaskTimer(plugin, this::retryPending, 20, 20);
@@ -134,7 +141,7 @@ public final class CombatExperience implements Listener, AutoCloseable {
 
     @EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = true)
     public void damage(EntityDamageEvent event) {
-        if (closed || games.dmg.fantasystick.ability.GuardianBond.redirectedDamage()
+        if (closed || excluded.test(event.getEntity()) || games.dmg.fantasystick.ability.GuardianBond.redirectedDamage()
                 || event.getFinalDamage() <= 0) return;
         var origin = sources.source(event);
         if (origin == null || origin.session() == null || !sources.current(origin)
@@ -172,7 +179,7 @@ public final class CombatExperience implements Listener, AutoCloseable {
 
     @EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = true)
     public void mobDeath(EntityDeathEvent event) {
-        if (closed || event instanceof PlayerDeathEvent) return;
+        if (closed || event instanceof PlayerDeathEvent || excluded.test(event.getEntity())) return;
         award(event.getEntity(), classify(event.getEntity()), 0, null, BigInteger.ZERO);
     }
 
@@ -193,14 +200,16 @@ public final class CombatExperience implements Listener, AutoCloseable {
         BigInteger coinPool = defeatedCharacter == null
             ? coinRules.get().mob(coinTarget(target), random) : defeatedCoins;
         if (units.isEmpty()) return; // The defeat transition has already persisted any PvP balance loss.
-        var xp = games.dmg.fantasystick.progression.RewardAllocator.allocate(rewards.pool(kind, level), units, random);
+        var capturedRewards = rewards;
+        var xp = games.dmg.fantasystick.progression.RewardAllocator.allocate(capturedRewards.pool(kind, level), units, random);
         var coins = games.dmg.fantasystick.progression.RewardAllocator.allocate(coinPool, units, random);
         CombatRewardRules.KillPosition restricted = kind == CombatRewardRules.Target.PASSIVE
             || kind == CombatRewardRules.Target.FANTASY_CHARACTER ? null : position(target.getLocation());
         UUID targetReward = defeatedCharacter == null ? target.getUniqueId() : defeatedCharacter;
         for (UUID character : xp.keySet()) {
             UUID receipt = UUID.nameUUIDFromBytes((targetReward + ":" + character + ":" + now).getBytes(java.nio.charset.StandardCharsets.UTF_8));
-            var operation = new PendingAward(receipt, character, xp.get(character), coins.get(character), restricted);
+            var operation = new PendingAward(receipt, character, xp.get(character), coins.get(character), restricted,
+                capturedRewards);
             pending.put(operation.id, operation);
             attempt(operation);
         }
@@ -259,7 +268,7 @@ public final class CombatExperience implements Listener, AutoCloseable {
             return;
         }
         characters.awardCombatReward(operation.character, operation.expectedRevision, operation.id,
-            operation.experience, operation.coins, progression, rewards, operation.restricted).whenComplete((award, failure) -> {
+            operation.experience, operation.coins, progression, operation.rewardRules, operation.restricted).whenComplete((award, failure) -> {
                 synchronized (operation) { operation.running = false; }
                 if (failure != null) { fail(operation, failure); return; }
                 if (award.status() == CharacterStorage.CombatAwardStatus.STALE && award.record().isPresent()) {
@@ -319,9 +328,17 @@ public final class CombatExperience implements Listener, AutoCloseable {
         }
     }
 
+    public void configure(CombatRewardRules updated) {
+        if (closed) throw new IllegalStateException("Combat rewards are closed");
+        rewards = Objects.requireNonNull(updated);
+    }
+
+    public CombatRewardRules rules() { return rewards; }
+
     public static CombatRewardRules.Target classify(LivingEntity entity) {
         EntityType type = entity.getType();
         if (type == EntityType.WARDEN || type == EntityType.ENDER_DRAGON) return CombatRewardRules.Target.BOSS;
+        if (type == EntityType.WITCH) return CombatRewardRules.Target.HARD;
         return PASSIVE.contains(type) ? CombatRewardRules.Target.PASSIVE : CombatRewardRules.Target.ORDINARY;
     }
 

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

@@ -26,6 +26,7 @@ public final class PartyManagement implements AutoCloseable {
     private void mutate(Player player,UUID id,java.util.function.Function<Context,java.util.concurrent.CompletableFuture<CharacterPartyDirectory.Result>> action,Consumer<Outcome> result){var context=context(player,id);if(context.isEmpty()){result.accept(new Outcome(Status.INVALID_SESSION,Optional.empty()));return;}try{action.apply(context.orElseThrow()).whenComplete((value,failure)->complete(value,failure,result));}catch(RuntimeException failure){fail(failure,result);}}
     private void mutateParty(Player player,UUID id,java.util.function.BiFunction<Context,CharacterParty,java.util.concurrent.CompletableFuture<CharacterPartyDirectory.Result>> action,Consumer<Outcome> result){var context=context(player,id);if(context.isEmpty()){result.accept(new Outcome(Status.INVALID_SESSION,Optional.empty()));return;}var party=parties.partyOf(context.orElseThrow().record().id()).orElse(null);if(party==null){result.accept(new Outcome(Status.FAILED,Optional.empty()));return;}try{action.apply(context.orElseThrow(),party).whenComplete((value,failure)->complete(value,failure,result));}catch(RuntimeException failure){fail(failure,result);}}
     private void complete(CharacterPartyDirectory.Result value,Throwable failure,Consumer<Outcome> result){if(failure!=null){fail(failure,result);return;}publish(()->result.accept(new Outcome(value.status()==CharacterPartyDirectory.Status.APPLIED?Status.APPLIED:map(value.status()),value.party())));}
+    public int registrationPrice(){return prices.registrationPrice();}public int leaderChangePrice(){return prices.leaderChangePrice();}
     public Optional<CharacterRecord> active(Player player,UUID registrar){return context(player,registrar).map(Context::record);}public Optional<UUID> activeSession(Player player,UUID registrar){return context(player,registrar).map(value->value.active().session());}public boolean eligibleInvitationTarget(UUID character){return parties.partyOf(character).isEmpty()&&sessions.activeCharacter(character).filter(sessions::current).flatMap(sessions::currentRecord).filter(value->!value.dead()).isPresent();}public Optional<CharacterRecord> activeCharacter(Player player){var active=sessions.active(player.getUniqueId()).filter(sessions::current).orElse(null);return active==null?Optional.empty():sessions.currentRecord(active).filter(value->!value.dead());}
     private Optional<Context> context(Player player,UUID registrarId){if(!parties.ready()||!recovered)return Optional.empty();var registrar=registrars.find(registrarId).orElse(null);var active=sessions.active(player.getUniqueId()).filter(sessions::current).orElse(null);var record=active==null?null:sessions.currentRecord(active).filter(value->!value.dead()).orElse(null);if(registrar==null||record==null)return Optional.empty();var location=player.getLocation();if(location.getWorld()==null||!location.getWorld().getUID().equals(registrar.world()))return Optional.empty();double dx=location.getX()-registrar.x(),dy=location.getY()-registrar.y(),dz=location.getZ()-registrar.z();if(dx*dx+dy*dy+dz*dz>36)return Optional.empty();return Optional.of(new Context(active,record,registrar));}
     private void fail(Throwable failure,Consumer<Outcome> result){report(failure);publish(()->result.accept(new Outcome(Status.FAILED,Optional.empty())));}private void report(Throwable failure){try{failures.accept(failure);}catch(RuntimeException ignored){}}private void publish(Runnable action){if(closed)return;try{nextTick.accept(action);}catch(RuntimeException rejected){report(rejected);}}

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

@@ -33,7 +33,7 @@ public final class PartyRegistrarController implements Listener, AutoCloseable {
     private Location location(PartyRegistrar value){var world=plugin.getServer().getWorld(value.world());return new Location(world,value.x(),value.y(),value.z(),value.yaw(),value.pitch());}
     private UUID id(Entity entity){String value=entity.getPersistentDataContainer().get(idKey,PersistentDataType.STRING);try{return value==null?null:UUID.fromString(value);}catch(IllegalArgumentException invalid){return null;}}
     private static int chunk(double coordinate){return ((int)Math.floor(coordinate))>>4;}
-    @EventHandler(priority=EventPriority.HIGHEST,ignoreCancelled=true)public void interact(org.bukkit.event.player.PlayerInteractEntityEvent event){if(!tagged(event.getRightClicked()))return;event.setCancelled(true);UUID id=id(event.getRightClicked());if(id!=null&&directory.find(id).isPresent())interactions.accept(event.getPlayer(),id);}
+    @EventHandler(priority=EventPriority.HIGHEST,ignoreCancelled=true)public void interact(org.bukkit.event.player.PlayerInteractEntityEvent event){if(!tagged(event.getRightClicked()))return;event.setCancelled(true);if(event.getHand()!=org.bukkit.inventory.EquipmentSlot.HAND)return;UUID id=id(event.getRightClicked());if(id!=null&&directory.find(id).isPresent())interactions.accept(event.getPlayer(),id);}
     @EventHandler(priority=EventPriority.HIGHEST,ignoreCancelled=true)public void damage(org.bukkit.event.entity.EntityDamageEvent event){if(tagged(event.getEntity()))event.setCancelled(true);}
     @EventHandler(priority=EventPriority.HIGHEST,ignoreCancelled=true)public void combust(org.bukkit.event.entity.EntityCombustEvent event){if(tagged(event.getEntity()))event.setCancelled(true);}
     @EventHandler(priority=EventPriority.HIGHEST,ignoreCancelled=true)public void transform(org.bukkit.event.entity.EntityTransformEvent event){if(tagged(event.getEntity()))event.setCancelled(true);}

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

@@ -22,10 +22,11 @@ public final class PartyRegistrarMenus implements Listener,AutoCloseable {
     private final Server server;private final PartyManagement management;private final NamespacedKey actionKey,targetKey;private boolean closed;
     public PartyRegistrarMenus(Plugin plugin,PartyManagement management){server=plugin.getServer();this.management=Objects.requireNonNull(management);actionKey=new NamespacedKey(plugin,"party_registrar_action");targetKey=new NamespacedKey(plugin,"party_registrar_target");}
     public void open(Player player,UUID registrar){open(player,registrar,Screen.ROOT,0);}
-    private void open(Player player,UUID registrar,Screen screen,int page){if(closed)return;var record=management.active(player,registrar);if(record.isEmpty()){player.sendMessage("You must be actively playing a living fantasy character beside this Party Registrar.");return;}if(screen==Screen.NAME){openName(player,registrar,record.orElseThrow().id(),management.activeSession(player,registrar).orElseThrow());return;}var inventory=server.createInventory(new Holder(registrar,record.orElseThrow().id(),management.activeSession(player,registrar).orElseThrow(),screen,page),screen==Screen.ROOT?27:54,net.kyori.adventure.text.Component.text("Party Registrar"));var party=management.party(player,registrar);if(screen==Screen.ROOT){if(party.isEmpty()){inventory.setItem(11,item(Material.WRITABLE_BOOK,"Register a party","register",null));inventory.setItem(15,item(Material.MAP,"Invitations","invitations",null));}else{var group=party.orElseThrow();inventory.setItem(4,item(Material.PAPER,"Party: "+group.displayName(),"info",null));if(group.leader().equals(record.orElseThrow().id())){inventory.setItem(10,item(Material.EMERALD,"Invite active characters","invite",null));inventory.setItem(13,item(Material.PLAYER_HEAD,"Manage members","members",null));inventory.setItem(16,item(Material.BARRIER,"Disband party","disband",null));inventory.setItem(22,item(Material.MAP,"Pending invitations","outgoing",null));}else inventory.setItem(13,item(Material.BARRIER,"Leave party","leave",null));}}else if(screen==Screen.INVITATIONS){var values=management.invitations(player,registrar);fill(inventory,page,values,value->item(Material.MAP,"Invitation (left accept, right decline)","invitation",value.id()));}else if(screen==Screen.OUTGOING){var values=management.outgoingInvitations(player,registrar);fill(inventory,page,values,value->item(Material.MAP,"Cancel invitation for "+value.character(),"cancel-invitation",value.id()));}else if(screen==Screen.INVITE){var values=server.getOnlinePlayers().stream().filter(Player::isOnline).map(target->management.activeCharacter(target).orElse(null)).filter(Objects::nonNull).filter(target->management.eligibleInvitationTarget(target.id())).map(value->value.id()).distinct().sorted().toList();fill(inventory,page,values,value->item(Material.PLAYER_HEAD,"Invite "+value,"invite-target",value));}else{var values=party.map(value->value.members().stream().filter(member->!member.equals(value.leader())).sorted().toList()).orElse(List.of());fill(inventory,page,values,value->item(Material.PLAYER_HEAD,"Member "+value+" (left kick, right transfer)","member",value));}player.openInventory(inventory);}
+    private void open(Player player,UUID registrar,Screen screen,int page){if(closed)return;var record=management.active(player,registrar);if(record.isEmpty()){player.sendMessage("You must be actively playing a living fantasy character beside this Party Registrar.");return;}if(screen==Screen.NAME){openName(player,registrar,record.orElseThrow().id(),management.activeSession(player,registrar).orElseThrow());return;}var inventory=server.createInventory(new Holder(registrar,record.orElseThrow().id(),management.activeSession(player,registrar).orElseThrow(),screen,page),screen==Screen.ROOT?27:54,net.kyori.adventure.text.Component.text("Party Registrar"));var party=management.party(player,registrar);if(screen==Screen.ROOT){if(party.isEmpty()){inventory.setItem(11,item(Material.WRITABLE_BOOK,"Register a party — "+management.registrationPrice()+" coins","register",null));inventory.setItem(15,item(Material.MAP,"Invitations","invitations",null));}else{var group=party.orElseThrow();inventory.setItem(4,item(Material.PAPER,"Party: "+group.displayName(),"info",null));if(group.leader().equals(record.orElseThrow().id())){inventory.setItem(10,item(Material.EMERALD,"Invite active characters","invite",null));inventory.setItem(13,item(Material.PLAYER_HEAD,"Manage members","members",null));inventory.setItem(16,item(Material.BARRIER,"Disband party","disband",null));inventory.setItem(22,item(Material.MAP,"Pending invitations","outgoing",null));}else inventory.setItem(13,item(Material.BARRIER,"Leave party","leave",null));}}else if(screen==Screen.INVITATIONS){var values=management.invitations(player,registrar);fill(inventory,page,values,value->item(Material.MAP,"Invitation (left accept, right decline)","invitation",value.id()));}else if(screen==Screen.OUTGOING){var values=management.outgoingInvitations(player,registrar);fill(inventory,page,values,value->item(Material.MAP,"Cancel invitation for "+value.character(),"cancel-invitation",value.id()));}else if(screen==Screen.INVITE){var values=server.getOnlinePlayers().stream().filter(Player::isOnline).map(target->management.activeCharacter(target).orElse(null)).filter(Objects::nonNull).filter(target->management.eligibleInvitationTarget(target.id())).map(value->value.id()).distinct().sorted().toList();fill(inventory,page,values,value->item(Material.PLAYER_HEAD,"Invite "+value,"invite-target",value));}else{var values=party.map(value->value.members().stream().filter(member->!member.equals(value.leader())).sorted().toList()).orElse(List.of());fill(inventory,page,values,value->item(Material.PLAYER_HEAD,"Member "+value,"member",value,List.of(net.kyori.adventure.text.Component.text("Left click: Kick (free)"),net.kyori.adventure.text.Component.text("Right click: Transfer leadership — "+management.leaderChangePrice()+" coins"))));}player.openInventory(inventory);}
     private <T> void fill(Inventory inventory,int page,List<T> values,java.util.function.Function<T,ItemStack> item){int start=Math.max(0,page)*45;for(int index=start;index<Math.min(values.size(),start+45);index++)inventory.setItem(index-start,item.apply(values.get(index)));if(page>0)inventory.setItem(45,item(Material.ARROW,"Previous","previous",null));if(start+45<values.size())inventory.setItem(53,item(Material.ARROW,"Next","next",null));}
     private void openName(Player player,UUID registrar,UUID character,UUID session){var inventory=server.createInventory(new Holder(registrar,character,session,Screen.NAME,0),org.bukkit.event.inventory.InventoryType.ANVIL,net.kyori.adventure.text.Component.text("Choose party name"));inventory.setItem(0,item(Material.PAPER,"Party name","name",null));player.openInventory(inventory);}
-    private ItemStack item(Material material,String name,String action,UUID target){var item=new ItemStack(material);var meta=item.getItemMeta();meta.customName(net.kyori.adventure.text.Component.text(name));meta.getPersistentDataContainer().set(actionKey,PersistentDataType.STRING,action);if(target!=null)meta.getPersistentDataContainer().set(targetKey,PersistentDataType.STRING,target.toString());item.setItemMeta(meta);return item;}
+    private ItemStack item(Material material,String name,String action,UUID target){return item(material,name,action,target,List.of());}
+    private ItemStack item(Material material,String name,String action,UUID target,List<net.kyori.adventure.text.Component> lore){var item=new ItemStack(material);var meta=item.getItemMeta();meta.customName(net.kyori.adventure.text.Component.text(name));if(!lore.isEmpty())meta.lore(lore);meta.getPersistentDataContainer().set(actionKey,PersistentDataType.STRING,action);if(target!=null)meta.getPersistentDataContainer().set(targetKey,PersistentDataType.STRING,target.toString());item.setItemMeta(meta);return item;}
     @EventHandler(priority=EventPriority.HIGHEST,ignoreCancelled=true)public void click(InventoryClickEvent event){if(!(event.getInventory().getHolder() instanceof Holder holder)||!(event.getWhoClicked() instanceof Player player))return;event.setCancelled(true);if(closed)return;if(!management.active(player,holder.registrar()).map(value->value.id().equals(holder.character())).orElse(false)||!management.activeSession(player,holder.registrar()).map(holder.session()::equals).orElse(false)){player.sendMessage("Party action refused: the character or session changed.");return;}if(holder.screen()==Screen.NAME&&event.getRawSlot()==2){String name=event.getView() instanceof org.bukkit.inventory.view.AnvilView anvil?anvil.getRenameText():null;if(name!=null)management.register(player,holder.registrar(),name,outcome->respond(player,holder.registrar(),outcome,"Registered party."));return;}var clicked=event.getCurrentItem();if(clicked==null)return;var data=clicked.getItemMeta().getPersistentDataContainer();String action=data.get(actionKey,PersistentDataType.STRING);UUID target=uuid(data.get(targetKey,PersistentDataType.STRING));if("register".equals(action)){open(player,holder.registrar(),Screen.NAME,0);return;}if("invitations".equals(action)){open(player,holder.registrar(),Screen.INVITATIONS,0);return;}if("invite".equals(action)){open(player,holder.registrar(),Screen.INVITE,0);return;}if("outgoing".equals(action)){open(player,holder.registrar(),Screen.OUTGOING,0);return;}if("members".equals(action)){open(player,holder.registrar(),Screen.MEMBERS,0);return;}if("previous".equals(action)){open(player,holder.registrar(),holder.screen(),holder.page()-1);return;}if("next".equals(action)){open(player,holder.registrar(),holder.screen(),holder.page()+1);return;}if("leave".equals(action)){management.leave(player,holder.registrar(),outcome->respond(player,holder.registrar(),outcome,"Left party."));return;}if("disband".equals(action)){management.disband(player,holder.registrar(),outcome->respond(player,holder.registrar(),outcome,"Party ended."));return;}if(target==null)return;if("invite-target".equals(action)){management.invite(player,holder.registrar(),target,outcome->respond(player,holder.registrar(),outcome,"Invitation saved."));return;}if("cancel-invitation".equals(action)){management.cancel(player,holder.registrar(),target,outcome->respond(player,holder.registrar(),outcome,"Invitation cancelled."));return;}if("invitation".equals(action)){if(event.isRightClick())management.decline(player,holder.registrar(),target,outcome->respond(player,holder.registrar(),outcome,"Invitation declined."));else management.accept(player,holder.registrar(),target,outcome->respond(player,holder.registrar(),outcome,"Joined party."));return;}if("member".equals(action)){if(event.isRightClick())management.transfer(player,holder.registrar(),target,outcome->respond(player,holder.registrar(),outcome,"Leadership transferred."));else management.kick(player,holder.registrar(),target,outcome->respond(player,holder.registrar(),outcome,"Member removed."));}}
     @EventHandler(priority=EventPriority.HIGHEST,ignoreCancelled=true)public void drag(org.bukkit.event.inventory.InventoryDragEvent event){if(event.getInventory().getHolder() instanceof Holder)event.setCancelled(true);}
     private void respond(Player player,UUID registrar,PartyManagement.Outcome outcome,String success){if(!player.isOnline())return;if(outcome.status()==PartyManagement.Status.APPLIED){player.sendMessage(success);open(player,registrar);}else player.sendMessage("Party action refused: "+outcome.status().name().toLowerCase(Locale.ROOT).replace('_',' ')+".");}

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

@@ -30,6 +30,7 @@ public final class PartyRoster implements AutoCloseable {
     private UUID character(UUID player){return sessions.active(player).filter(sessions::current).map(EquipmentSessions.Active::character).orElse(null);}
     private List<UUID> activePlayers(CharacterParty party){return party.members().stream().map(sessions::activeCharacter).flatMap(Optional::stream).filter(sessions::current).map(EquipmentSessions.Active::player).sorted().toList();}
     public Optional<UUID> activePlayer(UUID character){if(durable==null)return Optional.of(character);return sessions.activeCharacter(character).filter(sessions::current).map(EquipmentSessions.Active::player);}
+    public boolean exists(UUID party){if(durable!=null)return durable.ready()&&durable.all().stream().anyMatch(value->value.id().equals(party));return membership.values().stream().anyMatch(value->value.id().equals(party));}
     private Optional<Party> project(CharacterParty party){var members=activePlayers(party);UUID leader=sessions.activeCharacter(party.leader()).filter(sessions::current).map(EquipmentSessions.Active::player).orElse(party.leader());return Optional.of(new Party(party.id(),leader,members,party.leader(),party.members().stream().sorted().toList()));}
     private Party managedBy(UUID leader,UUID party){var group=membership.get(leader);return group!=null&&group.id().equals(party)&&group.leader().equals(leader)&&connected(leader)?group:null;}
     private void removeMember(Party group,UUID player){var remaining=group.members().stream().filter(member->!member.equals(player)).toList();if(remaining.stream().noneMatch(this::connected)){remove(group);return;}membership.remove(player);departed.remove(player);var updated=new Party(group.id(),group.leader(),remaining);for(var member:remaining)membership.put(member,updated);}

src/main/java/games/dmg/fantasystick/passive/HealthSteal.java

@@ -1,6 +1,8 @@
 package games.dmg.fantasystick.passive;
 
+import games.dmg.fantasystick.ability.AbilityReport;
 import games.dmg.fantasystick.party.CombatSources;
+import games.dmg.fantasystick.presentation.CombatFeedback;
 import games.dmg.fantasystick.persistence.CharacterRecord;
 import games.dmg.fantasystick.persistence.CharacterStorage;
 import games.dmg.fantasystick.progression.Stat;
@@ -53,6 +55,7 @@ public final class HealthSteal implements Listener, AutoCloseable {
     private final Consumer<EntityRegainHealthEvent> healingEvents;
     private final Supplier<BigDecimal> nativeLimit;
     private final Consumer<Failure> failures;
+    private final CombatFeedback feedback;
     private final CombatSources sources;
     private final Map<UUID, Candidate> lethal = new java.util.HashMap<>();
     private final Set<PlayerDeathEvent> fantasyDefeats = Collections.newSetFromMap(new IdentityHashMap<>());
@@ -65,10 +68,16 @@ public final class HealthSteal implements Listener, AutoCloseable {
     public HealthSteal(Settings settings, CharacterStorage characters, EquipmentSessions sessions,
                        Consumer<Runnable> nextTick, Consumer<EntityRegainHealthEvent> healingEvents,
                        Supplier<BigDecimal> nativeLimit, Consumer<Failure> failures) {
+        this(settings, characters, sessions, nextTick, healingEvents, nativeLimit, failures, null);
+    }
+
+    public HealthSteal(Settings settings, CharacterStorage characters, EquipmentSessions sessions,
+                       Consumer<Runnable> nextTick, Consumer<EntityRegainHealthEvent> healingEvents,
+                       Supplier<BigDecimal> nativeLimit, Consumer<Failure> failures, CombatFeedback feedback) {
         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);
-        this.failures = Objects.requireNonNull(failures); sources = new CombatSources(sessions);
+        this.failures = Objects.requireNonNull(failures); this.feedback = feedback; sources = new CombatSources(sessions);
     }
 
     public void configure(Settings value) { settings = Objects.requireNonNull(value); }
@@ -187,7 +196,11 @@ public final class HealthSteal implements Listener, AutoCloseable {
             if (attribute == null) return;
             double maximum = Math.min(attribute.getValue(), record.maximumHealth().doubleValue());
             double publish = Math.min(maximum, record.health().doubleValue());
-            if (Double.isFinite(maximum) && Double.isFinite(publish) && publish > nativeBefore) player.setHealth(publish);
+            if (Double.isFinite(maximum) && Double.isFinite(publish) && publish > nativeBefore) {
+                player.setHealth(publish);
+                if (feedback != null) feedback.report("Health Steal", player, AbilityReport.Type.HEALING, player,
+                    BigDecimal.valueOf(publish - nativeBefore).stripTrailingZeros());
+            }
         } finally { finish(character); }
     }
 

src/main/java/games/dmg/fantasystick/passive/StickKnockback.java

@@ -0,0 +1,28 @@
+package games.dmg.fantasystick.passive;
+
+import games.dmg.fantasystick.progression.Stat;
+import java.math.BigInteger;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+
+/** Fixed reviewed metadata and native level-I behavior for the basic-stick Knockback passive. */
+public final class StickKnockback {
+    public static final String ID = "stick_knockback";
+
+    public PassiveDefinition definition() {
+        return new PassiveDefinition(ID, "Knockback", Map.of(Stat.STR, BigInteger.valueOf(12)), Set.of(),
+            BigInteger.ONE, List.of("Your bound basic attack stick carries native Knockback I.",
+                "Only positive accepted basic-stick damage can knock the target back."));
+    }
+
+    public static void apply(org.bukkit.entity.Player source, org.bukkit.entity.LivingEntity target) {
+        double radians = Math.toRadians(source.getLocation().getYaw());
+        double directionX = Math.sin(radians);
+        double directionZ = -Math.cos(radians);
+        if (!Double.isFinite(directionX) || !Double.isFinite(directionZ)) return;
+        boolean sprinting = source.isSprinting();
+        target.knockback(sprinting ? 2 : 1, directionX, directionZ);
+        if (sprinting) source.setSprinting(false);
+    }
+}

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

@@ -0,0 +1,80 @@
+package games.dmg.fantasystick.persistence;
+
+import java.io.IOException;
+import java.math.BigInteger;
+import java.nio.ByteBuffer;
+import java.nio.channels.FileChannel;
+import java.nio.channels.OverlappingFileLockException;
+import java.nio.charset.StandardCharsets;
+import java.nio.file.*;
+import java.util.*;
+import java.util.concurrent.*;
+import org.yaml.snakeyaml.LoaderOptions;
+import org.yaml.snakeyaml.Yaml;
+import org.yaml.snakeyaml.constructor.SafeConstructor;
+
+/** Durable save-before-publication settings for later daily catalogs, camp and champion attempts. */
+public final class AdventureQuestSettings implements AutoCloseable {
+    public static final String DAILY_COUNT="adventure-daily-site-count", RADIUS="adventure-site-radius",
+        RESET_SECONDS="adventure-site-reset-seconds", CAMP_ENEMIES="adventure-camp-enemies",
+        CAMP_REWARD_XP="adventure-camp-reward-xp", CAMP_REWARD_COINS="adventure-camp-reward-coins",
+        CHAMPION_HEALTH="adventure-champion-health", CHAMPION_DAMAGE="adventure-champion-damage",
+        CHAMPION_REWARD_XP="adventure-champion-reward-xp", CHAMPION_REWARD_COINS="adventure-champion-reward-coins";
+    private static final Map<String,String> DEFAULTS=Map.ofEntries(
+        Map.entry(DAILY_COUNT,"3"),Map.entry(RADIUS,"16"),Map.entry(RESET_SECONDS,"30"),Map.entry(CAMP_ENEMIES,"8"),
+        Map.entry(CAMP_REWARD_XP,"100"),Map.entry(CAMP_REWARD_COINS,"20"),Map.entry(CHAMPION_HEALTH,"100"),
+        Map.entry(CHAMPION_DAMAGE,"8"),Map.entry(CHAMPION_REWARD_XP,"150"),Map.entry(CHAMPION_REWARD_COINS,"40"));
+    private static final List<String> KEYS=DEFAULTS.keySet().stream().sorted().toList();
+    public record Rules(int dailySiteCount,int radius,int resetSeconds,int campEnemies,
+                        BigInteger campRewardXp,BigInteger campRewardCoins,int championHealth,int championDamage,
+                        BigInteger championRewardXp,BigInteger championRewardCoins) { }
+    public record Update(String key,String value,Map<String,String> values,long sequence) {
+        public Update { values=Map.copyOf(values); }
+    }
+    private final Path directory;
+    private final ExecutorService worker=Executors.newSingleThreadExecutor(r->new Thread(r,"fantasy-adventure-configuration"));
+    private volatile Map<String,String> effective;
+    private Map<String,String> persisted;
+    private long savedSequence,publishedSequence;
+    private boolean closed; private int pending;
+    private final CompletableFuture<Void> drained=new CompletableFuture<>();
+
+    public AdventureQuestSettings(Path directory,Map<String,String> initial) {
+        this.directory=Objects.requireNonNull(directory).toAbsolutePath();
+        var values=new LinkedHashMap<String,String>();
+        for(String key:KEYS)values.put(key,Objects.requireNonNull(initial.getOrDefault(key,DEFAULTS.get(key))));
+        parse(values);effective=Map.copyOf(values);persisted=effective;
+    }
+    public static List<String> keys(){return KEYS;}
+    public static String defaultValue(String key){return DEFAULTS.get(key);}
+    public String value(String key){return effective.get(key);}
+    public Rules rules(){return parse(effective);}
+    public static Rules parse(Map<String,String> values){
+        try{return new Rules(bounded(values.get(DAILY_COUNT),0,20),bounded(values.get(RADIUS),4,64),
+            bounded(values.get(RESET_SECONDS),0,600),bounded(values.get(CAMP_ENEMIES),4,64),
+            whole(values.get(CAMP_REWARD_XP)),whole(values.get(CAMP_REWARD_COINS)),
+            bounded(values.get(CHAMPION_HEALTH),1,2048),bounded(values.get(CHAMPION_DAMAGE),1,2048),
+            whole(values.get(CHAMPION_REWARD_XP)),whole(values.get(CHAMPION_REWARD_COINS)));}
+        catch(RuntimeException invalid){throw new IllegalArgumentException("Invalid adventure quest settings",invalid);}
+    }
+    private static int bounded(String raw,int minimum,int maximum){var value=new BigInteger(raw);if(value.compareTo(BigInteger.valueOf(minimum))<0||value.compareTo(BigInteger.valueOf(maximum))>0)throw new IllegalArgumentException();return value.intValueExact();}
+    private static BigInteger whole(String raw){var value=new BigInteger(raw);if(value.signum()<0||value.compareTo(BigInteger.valueOf(Integer.MAX_VALUE))>0)throw new IllegalArgumentException();return value;}
+    public CompletionStage<Update> set(String key,String raw){
+        if(!KEYS.contains(key))throw new IllegalArgumentException("Unknown adventure setting");
+        var preview=new LinkedHashMap<>(effective);preview.put(key,new BigInteger(raw).toString());var accepted=preview.get(key);parse(preview);
+        synchronized(this){if(closed)return CompletableFuture.failedStage(new IOException("Configuration closed"));pending++;}
+        return CompletableFuture.supplyAsync(()->{try{var next=new LinkedHashMap<>(persisted);next.put(key,accepted);parse(next);save(key,accepted);persisted=Map.copyOf(next);return new Update(key,accepted,persisted,++savedSequence);}catch(IOException failure){throw new CompletionException(failure);}finally{finished();}},worker).minimalCompletionStage();
+    }
+    public synchronized boolean publish(Update update){if(update.sequence()<=publishedSequence)return false;parse(update.values());effective=update.values();publishedSequence=update.sequence();return true;}
+    private void save(String key,String value)throws IOException{
+        Files.createDirectories(directory);var file=directory.resolve("config.yml");var lockFile=directory.resolve(".config.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(1_048_576);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(1_048_577);}if(bytes.length>1_048_576)throw new IOException("Configuration too large");Object loaded=yaml.load(StandardCharsets.UTF_8.newDecoder().decode(ByteBuffer.wrap(bytes)).toString());if(loaded instanceof Map<?,?> map)for(var entry:map.entrySet()){if(!(entry.getKey() instanceof String savedKey))throw new IOException("Invalid key");document.put(savedKey,entry.getValue());}}
+            document.put(key,Integer.parseInt(value));byte[] bytes=yaml.dump(document).getBytes(StandardCharsets.UTF_8);Path temporary=Files.createTempFile(directory,".config-",".tmp");try{Files.write(temporary,bytes,StandardOpenOption.TRUNCATE_EXISTING);try(var output=FileChannel.open(temporary,StandardOpenOption.WRITE)){output.force(true);}Files.move(temporary,file,StandardCopyOption.ATOMIC_MOVE,StandardCopyOption.REPLACE_EXISTING);DurableFiles.forceDirectory(directory);}finally{Files.deleteIfExists(temporary);}
+        }catch(OverlappingFileLockException busy){throw new IOException("Configuration busy",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/ArmorCatalogRepository.java

@@ -0,0 +1,11 @@
+package games.dmg.fantasystick.persistence;
+
+import games.dmg.fantasystick.shop.ArmorCatalog;
+import java.io.IOException;
+import java.util.Optional;
+
+/** Durable adapter boundary for the one shared armor catalog. */
+public interface ArmorCatalogRepository {
+    Optional<ArmorCatalog> load() throws IOException;
+    void save(ArmorCatalog catalog) throws IOException;
+}

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

@@ -0,0 +1,84 @@
+package games.dmg.fantasystick.persistence;
+
+import games.dmg.fantasystick.shop.ArmorProduct;
+import java.io.IOException;
+import java.math.BigInteger;
+import java.nio.ByteBuffer;
+import java.nio.channels.FileChannel;
+import java.nio.charset.StandardCharsets;
+import java.nio.file.*;
+import java.util.*;
+import java.util.concurrent.*;
+import org.yaml.snakeyaml.LoaderOptions;
+import org.yaml.snakeyaml.Yaml;
+import org.yaml.snakeyaml.constructor.SafeConstructor;
+
+/** Durable recovery plans spanning one catalog reservation and character gear purchase. */
+public final class ArmorPurchaseOperationStore implements AutoCloseable {
+    public record Plan(UUID id, UUID character, BigInteger expectedCharacterRevision, UUID catalogRevision,
+                       ArmorProduct product, BigInteger price) {
+        public Plan {
+            Objects.requireNonNull(id); Objects.requireNonNull(character); Objects.requireNonNull(expectedCharacterRevision);
+            Objects.requireNonNull(catalogRevision); Objects.requireNonNull(product); Objects.requireNonNull(price);
+            if(expectedCharacterRevision.signum()<0||price.signum()<=0)throw new IllegalArgumentException("Invalid armor purchase plan");
+        }
+    }
+
+    private final Path directory;
+    private final ExecutorService worker=Executors.newSingleThreadExecutor(r->new Thread(r,"fantasy-armor-operation-persistence"));
+    private boolean closed;
+    private int pending;
+    private final CompletableFuture<Void> drained=new CompletableFuture<>();
+
+    public ArmorPurchaseOperationStore(Path data){directory=data.toAbsolutePath().resolve("armor-purchase-operations");}
+
+    public CompletionStage<Plan> prepare(Plan plan){return submit(()->{
+        Files.createDirectories(directory);Path target=file(plan.id());
+        if(Files.exists(target)) {
+            var existing=decode(Files.readString(target,StandardCharsets.UTF_8));
+            if(!existing.equals(plan))throw new IOException("Armor operation identity collision");
+            return existing;
+        }
+        write(target,encode(plan));return plan;
+    });}
+    public CompletionStage<Void> complete(UUID id){return submit(()->{if(Files.deleteIfExists(file(id)))DurableFiles.forceDirectory(directory);return null;});}
+    public CompletionStage<List<Plan>> load(){return submit(this::loadBlocking);}
+
+    private List<Plan> loadBlocking()throws IOException {
+        if(Files.notExists(directory))return List.of();
+        var result=new ArrayList<Plan>();
+        try(var files=Files.list(directory)) {
+            for(var path:files.filter(value->value.getFileName().toString().endsWith(".yml")).sorted().toList()) {
+                if(Files.size(path)>65_536)throw new IOException("Armor operation too large");
+                result.add(decode(Files.readString(path,StandardCharsets.UTF_8)));
+            }
+        }
+        return List.copyOf(result);
+    }
+    private Path file(UUID id){return directory.resolve(id+".yml");}
+    private static String encode(Plan plan){Map<String,Object> row=new LinkedHashMap<>();row.put("schema-version",1);
+        row.put("operation-id",plan.id().toString());row.put("character",plan.character().toString());
+        row.put("expected-character-revision",plan.expectedCharacterRevision().toString());
+        row.put("catalog-revision",plan.catalogRevision().toString());row.put("slot",plan.product().slot().name());
+        row.put("tier",plan.product().tier().name());row.put("price",plan.price().toString());return yaml().dump(row);}
+    private static Plan decode(String input){Object decoded=yaml().load(input);if(!(decoded instanceof Map<?,?> row)||
+        !"1".equals(String.valueOf(row.get("schema-version"))))throw new IllegalArgumentException("Invalid armor operation schema");
+        return new Plan(UUID.fromString(text(row,"operation-id")),UUID.fromString(text(row,"character")),
+            new BigInteger(text(row,"expected-character-revision")),UUID.fromString(text(row,"catalog-revision")),
+            new ArmorProduct(GearSlot.valueOf(text(row,"slot")),GearTier.valueOf(text(row,"tier"))),new BigInteger(text(row,"price")));}
+    private static void write(Path target,String content)throws IOException {Path temporary=Files.createTempFile(target.getParent(),"armor-operation-",".tmp");
+        try{byte[] bytes=content.getBytes(StandardCharsets.UTF_8);try(var output=FileChannel.open(temporary,StandardOpenOption.WRITE)){
+            var buffer=ByteBuffer.wrap(bytes);while(buffer.hasRemaining())output.write(buffer);output.force(true);}
+            try{Files.move(temporary,target,StandardCopyOption.ATOMIC_MOVE);}catch(AtomicMoveNotSupportedException unsupported){
+                throw new IOException("Atomic armor-operation persistence unavailable",unsupported);}DurableFiles.forceDirectory(target.getParent());}
+        finally{Files.deleteIfExists(temporary);}}
+    private static Yaml yaml(){var options=new LoaderOptions();options.setAllowDuplicateKeys(false);options.setMaxAliasesForCollections(0);
+        options.setCodePointLimit(65_536);return new Yaml(new SafeConstructor(options));}
+    private static String text(Map<?,?> row,String key){Object value=row.get(key);if(value instanceof String text)return text;throw new IllegalArgumentException("Invalid "+key);}
+    private <T>CompletionStage<T> submit(Callable<T> action){synchronized(this){if(closed)return CompletableFuture.failedStage(
+        new IOException("Armor operation store closed"));pending++;}return CompletableFuture.supplyAsync(()->{try{return action.call();}
+        catch(Exception failure){throw new CompletionException(failure);}finally{finished();}},worker).minimalCompletionStage();}
+    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/CharacterGear.java

@@ -0,0 +1,11 @@
+package games.dmg.fantasystick.persistence;
+
+import java.util.Objects;
+
+/** Permanent helmet-free character armor state. */
+public record CharacterGear(GearTier chestplate,GearTier leggings,GearTier boots) {
+    public CharacterGear{if(chestplate==null||leggings==null||boots==null)throw new IllegalArgumentException("Missing gear tier");}
+    public static CharacterGear none(){return new CharacterGear(GearTier.NONE,GearTier.NONE,GearTier.NONE);}
+    public GearTier tier(GearSlot slot){return switch(slot){case CHESTPLATE->chestplate;case LEGGINGS->leggings;case BOOTS->boots;};}
+    public CharacterGear with(GearSlot slot,GearTier tier){Objects.requireNonNull(slot);Objects.requireNonNull(tier);return switch(slot){case CHESTPLATE->new CharacterGear(tier,leggings,boots);case LEGGINGS->new CharacterGear(chestplate,tier,boots);case BOOTS->new CharacterGear(chestplate,leggings,tier);};}
+}

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

@@ -19,7 +19,8 @@ public record CharacterRecord(
         Set<String> learned, List<String> loadout, List<String> passives, Map<String, Instant> cooldowns,
         Map<UUID, CombatRewardRules.KillPosition> restrictedKills,
         boolean dead, UUID deathId, Instant diedAt,
-        BigInteger coins, boolean coinsInitialized, Set<UUID> rewardReceipts, BigInteger pvpCoinEscrow) {
+        BigInteger coins, boolean coinsInitialized, Set<UUID> rewardReceipts, BigInteger pvpCoinEscrow,CharacterGear gear) {
+    public CharacterRecord(UUID id,String name,BigInteger revision,Map<Stat,BigInteger> stats,int level,BigInteger experience,BigInteger unspentPoints,BigDecimal health,Set<String> learned,List<String> loadout,List<String> passives,Map<String,Instant> cooldowns,Map<UUID,CombatRewardRules.KillPosition> restrictedKills,boolean dead,UUID deathId,Instant diedAt,BigInteger coins,boolean coinsInitialized,Set<UUID> rewardReceipts,BigInteger pvpCoinEscrow){this(id,name,revision,stats,level,experience,unspentPoints,health,learned,loadout,passives,cooldowns,restrictedKills,dead,deathId,diedAt,coins,coinsInitialized,rewardReceipts,pvpCoinEscrow,CharacterGear.none());}
     public CharacterRecord(UUID id, String name, BigInteger revision, Map<Stat, BigInteger> stats,
                            int level, BigInteger experience, BigInteger unspentPoints, BigDecimal health,
                            Set<String> learned, List<String> loadout, List<String> passives, Map<String, Instant> cooldowns,
@@ -63,6 +64,7 @@ public record CharacterRecord(
         Objects.requireNonNull(health);
         Objects.requireNonNull(coins);
         Objects.requireNonNull(pvpCoinEscrow);
+        Objects.requireNonNull(gear);
         stats = Map.copyOf(stats);
         learned = Set.copyOf(learned);
         loadout = List.copyOf(loadout);

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

@@ -65,7 +65,7 @@ public final class CharacterStorage implements AutoCloseable {
                     || record.experience().signum() != 0 || record.stats().values().stream().anyMatch(value -> value.signum() != 0)
                     || record.health().compareTo(java.math.BigDecimal.TEN) != 0
                     || !record.learned().isEmpty() || record.passives().stream().anyMatch(id -> !id.isEmpty())
-                    || !record.cooldowns().isEmpty() || !record.coinsInitialized() || !record.rewardReceipts().isEmpty()
+                    || !record.cooldowns().isEmpty() || !record.coinsInitialized() || !record.rewardReceipts().isEmpty() || !record.gear().equals(CharacterGear.none())
                     || record.loadout().stream().anyMatch(ability -> !ability.isEmpty())) {
                 throw new IllegalArgumentException("Craft batch requires distinct new characters");
             }
@@ -215,7 +215,7 @@ public final class CharacterStorage implements AutoCloseable {
         var migrated = new CharacterRecord(old.id(), old.name(), old.revision().add(BigInteger.ONE), old.stats(),
             old.level(), old.experience(), old.unspentPoints(), old.health(), old.learned(), old.loadout(), old.passives(),
             old.cooldowns(), old.restrictedKills(), old.dead(), old.deathId(), old.diedAt(),
-            coinRules.get().starting(coinRandom), true, old.rewardReceipts());
+            coinRules.get().starting(coinRandom), true, old.rewardReceipts(),old.pvpCoinEscrow(),old.gear());
         repository.replace(migrated, old.revision());
         return Optional.of(migrated);
     }
@@ -231,7 +231,7 @@ public final class CharacterStorage implements AutoCloseable {
             if (old.name().equals(name)) return Optional.of(old);
             var renamed = new CharacterRecord(old.id(), name, old.revision().add(BigInteger.ONE), old.stats(), old.level(),
                 old.experience(), old.unspentPoints(), old.health(), old.learned(), old.loadout(), old.passives(), old.cooldowns(),
-                old.restrictedKills(), false, old.deathId(), old.diedAt(), old.coins(), old.coinsInitialized(), old.rewardReceipts());
+                old.restrictedKills(), false, old.deathId(), old.diedAt(), old.coins(), old.coinsInitialized(), old.rewardReceipts(),old.pvpCoinEscrow(),old.gear());
             repository.replace(renamed, old.revision());
             return Optional.of(renamed);
         });
@@ -271,7 +271,7 @@ public final class CharacterStorage implements AutoCloseable {
             int gained = Math.max(0, level - old.level());
             var saved = new CharacterRecord(old.id(), old.name(), old.revision().add(BigInteger.ONE), old.stats(),
                 level, experience, old.unspentPoints().add(BigInteger.valueOf(gained)), old.health(), old.learned(),
-                old.loadout(), old.passives(), old.cooldowns(), old.restrictedKills(), false, old.deathId(), old.diedAt(), old.coins(), old.coinsInitialized(), old.rewardReceipts());
+                old.loadout(), old.passives(), old.cooldowns(), old.restrictedKills(), false, old.deathId(), old.diedAt(), old.coins(), old.coinsInitialized(), old.rewardReceipts(),old.pvpCoinEscrow(),old.gear());
             repository.replace(saved, old.revision());
             return new ExperienceAward(ExperienceAwardStatus.APPLIED, Optional.of(saved), gained);
         });
@@ -307,7 +307,7 @@ public final class CharacterStorage implements AutoCloseable {
             var saved = new CharacterRecord(old.id(), old.name(), old.revision().add(BigInteger.ONE), old.stats(),
                 old.level(), old.experience(), old.unspentPoints(), old.health(), old.learned(), old.loadout(),
                 old.passives(), old.cooldowns(), old.restrictedKills(), false, old.deathId(), old.diedAt(),
-                old.coins().subtract(amount), true, receipts);
+                old.coins().subtract(amount), true, receipts,old.pvpCoinEscrow(),old.gear());
             repository.replace(saved, old.revision());
             return new CoinSpend(CoinSpendStatus.APPLIED, Optional.of(saved));
         });
@@ -316,7 +316,12 @@ public final class CharacterStorage implements AutoCloseable {
     public enum CoinRefundStatus { APPLIED, DUPLICATE, UNAVAILABLE }
     public record CoinRefund(CoinRefundStatus status,Optional<CharacterRecord> record){}
     /** Compensate a persisted debit exactly once while retaining both audit receipts. */
-    public CompletableFuture<CoinRefund> refundCoins(UUID characterId,UUID debitId,UUID refundId,BigInteger amount){Objects.requireNonNull(characterId);Objects.requireNonNull(debitId);Objects.requireNonNull(refundId);Objects.requireNonNull(amount);if(amount.signum()<0)throw new IllegalArgumentException("Coin refund must not be negative");return submit(()->{var found=repository.load(characterId);if(found.isEmpty())return new CoinRefund(CoinRefundStatus.UNAVAILABLE,Optional.empty());var old=found.orElseThrow();if(old.rewardReceipts().contains(refundId))return new CoinRefund(CoinRefundStatus.DUPLICATE,Optional.of(old));if(!old.rewardReceipts().contains(debitId))return new CoinRefund(CoinRefundStatus.UNAVAILABLE,Optional.of(old));var receipts=new java.util.HashSet<>(old.rewardReceipts());if(receipts.size()>=4096)receipts.remove(receipts.stream().filter(id->!id.equals(debitId)).min(UUID::compareTo).orElseThrow());receipts.add(refundId);var saved=new CharacterRecord(old.id(),old.name(),old.revision().add(BigInteger.ONE),old.stats(),old.level(),old.experience(),old.unspentPoints(),old.health(),old.learned(),old.loadout(),old.passives(),old.cooldowns(),old.restrictedKills(),old.dead(),old.deathId(),old.diedAt(),old.coins().add(amount),old.coinsInitialized(),receipts,old.pvpCoinEscrow());repository.replace(saved,old.revision());return new CoinRefund(CoinRefundStatus.APPLIED,Optional.of(saved));});}
+    public CompletableFuture<CoinRefund> refundCoins(UUID characterId,UUID debitId,UUID refundId,BigInteger amount){Objects.requireNonNull(characterId);Objects.requireNonNull(debitId);Objects.requireNonNull(refundId);Objects.requireNonNull(amount);if(amount.signum()<0)throw new IllegalArgumentException("Coin refund must not be negative");return submit(()->{var found=repository.load(characterId);if(found.isEmpty())return new CoinRefund(CoinRefundStatus.UNAVAILABLE,Optional.empty());var old=found.orElseThrow();if(old.rewardReceipts().contains(refundId))return new CoinRefund(CoinRefundStatus.DUPLICATE,Optional.of(old));if(!old.rewardReceipts().contains(debitId))return new CoinRefund(CoinRefundStatus.UNAVAILABLE,Optional.of(old));var receipts=new java.util.HashSet<>(old.rewardReceipts());if(receipts.size()>=4096)receipts.remove(receipts.stream().filter(id->!id.equals(debitId)).min(UUID::compareTo).orElseThrow());receipts.add(refundId);var saved=new CharacterRecord(old.id(),old.name(),old.revision().add(BigInteger.ONE),old.stats(),old.level(),old.experience(),old.unspentPoints(),old.health(),old.learned(),old.loadout(),old.passives(),old.cooldowns(),old.restrictedKills(),old.dead(),old.deathId(),old.diedAt(),old.coins().add(amount),old.coinsInitialized(),receipts,old.pvpCoinEscrow(),old.gear());repository.replace(saved,old.revision());return new CoinRefund(CoinRefundStatus.APPLIED,Optional.of(saved));});}
+
+    public enum GearPurchaseStatus { APPLIED,DUPLICATE,INSUFFICIENT,NOT_UPGRADE,STALE,UNAVAILABLE }
+    public record GearPurchase(GearPurchaseStatus status,Optional<CharacterRecord> record){}
+    /** One character-file transaction owns both the exact coin debit and strict gear replacement. */
+    public CompletableFuture<GearPurchase> purchaseGear(UUID characterId,BigInteger expectedRevision,UUID operationId,GearSlot slot,GearTier target,BigInteger price){Objects.requireNonNull(characterId);Objects.requireNonNull(expectedRevision);Objects.requireNonNull(operationId);Objects.requireNonNull(slot);Objects.requireNonNull(target);Objects.requireNonNull(price);if(target==GearTier.NONE||price.signum()<0)throw new IllegalArgumentException("Invalid gear purchase");return submit(()->{var found=repository.load(characterId);if(found.isEmpty()||found.orElseThrow().dead())return new GearPurchase(GearPurchaseStatus.UNAVAILABLE,Optional.empty());var old=found.orElseThrow();if(old.rewardReceipts().contains(operationId))return new GearPurchase(GearPurchaseStatus.DUPLICATE,Optional.of(old));if(!old.revision().equals(expectedRevision))return new GearPurchase(GearPurchaseStatus.STALE,Optional.of(old));if(!target.higherThan(old.gear().tier(slot)))return new GearPurchase(GearPurchaseStatus.NOT_UPGRADE,Optional.of(old));if(old.coins().compareTo(price)<0)return new GearPurchase(GearPurchaseStatus.INSUFFICIENT,Optional.of(old));var receipts=new java.util.HashSet<>(old.rewardReceipts());if(receipts.size()>=4096)receipts.remove(receipts.stream().min(UUID::compareTo).orElseThrow());receipts.add(operationId);var saved=new CharacterRecord(old.id(),old.name(),old.revision().add(BigInteger.ONE),old.stats(),old.level(),old.experience(),old.unspentPoints(),old.health(),old.learned(),old.loadout(),old.passives(),old.cooldowns(),old.restrictedKills(),false,old.deathId(),old.diedAt(),old.coins().subtract(price),true,receipts,old.pvpCoinEscrow(),old.gear().with(slot,target));repository.replace(saved,old.revision());return new GearPurchase(GearPurchaseStatus.APPLIED,Optional.of(saved));});}
 
     public enum CombatAwardStatus { APPLIED, SPACING_BLOCKED, AT_CAP, UNCHANGED, DUPLICATE, STALE, UNAVAILABLE }
     public record CombatAward(CombatAwardStatus status, Optional<CharacterRecord> record, int levels) { }
@@ -371,7 +376,7 @@ public final class CharacterStorage implements AutoCloseable {
             var saved = new CharacterRecord(old.id(), old.name(), old.revision().add(BigInteger.ONE), old.stats(),
                 level, experience, old.unspentPoints().add(BigInteger.valueOf(gained)), old.health(), old.learned(),
                 old.loadout(), old.passives(), old.cooldowns(), history, false, old.deathId(), old.diedAt(),
-                old.coins().add(coinReward), true, receipts);
+                old.coins().add(coinReward), true, receipts,old.pvpCoinEscrow(),old.gear());
             repository.replace(saved, old.revision());
             return new CombatAward(status, Optional.of(saved), gained);
         });
@@ -411,7 +416,7 @@ public final class CharacterStorage implements AutoCloseable {
             var passives = new java.util.ArrayList<>(old.passives()); passives.set(slot, passive);
             var saved = new CharacterRecord(old.id(), old.name(), old.revision().add(BigInteger.ONE), old.stats(), old.level(),
                 old.experience(), old.unspentPoints().subtract(cost), old.health(), old.learned(), old.loadout(), passives,
-                old.cooldowns(), old.restrictedKills(), false, old.deathId(), old.diedAt(), old.coins(), old.coinsInitialized(), old.rewardReceipts());
+                old.cooldowns(), old.restrictedKills(), false, old.deathId(), old.diedAt(), old.coins(), old.coinsInitialized(), old.rewardReceipts(),old.pvpCoinEscrow(),old.gear());
             repository.replace(saved, old.revision());
             return new PassiveMutation(PassiveMutationStatus.APPLIED, Optional.of(saved));
         });
@@ -439,7 +444,7 @@ public final class CharacterStorage implements AutoCloseable {
             var passives = old.passives().stream().map(id -> id.equals(passive) ? "" : id).toList();
             var saved = new CharacterRecord(old.id(), old.name(), old.revision().add(BigInteger.ONE), old.stats(), old.level(),
                 old.experience(), old.unspentPoints().add(BigInteger.ONE), old.health(), old.learned(), old.loadout(), passives,
-                old.cooldowns(), old.restrictedKills(), false, old.deathId(), old.diedAt(), old.coins(), old.coinsInitialized(), old.rewardReceipts());
+                old.cooldowns(), old.restrictedKills(), false, old.deathId(), old.diedAt(), old.coins(), old.coinsInitialized(), old.rewardReceipts(),old.pvpCoinEscrow(),old.gear());
             repository.replace(saved, old.revision());
             return new PassiveMutation(PassiveMutationStatus.APPLIED, Optional.of(saved));
         });
@@ -474,7 +479,7 @@ public final class CharacterStorage implements AutoCloseable {
             var loadout = new java.util.ArrayList<>(old.loadout()); loadout.set(slot, ability);
             var saved = new CharacterRecord(old.id(), old.name(), old.revision().add(BigInteger.ONE), old.stats(), old.level(),
                 old.experience(), old.unspentPoints().subtract(cost), old.health(), learned, loadout, old.passives(), old.cooldowns(),
-                old.restrictedKills(), false, old.deathId(), old.diedAt(), old.coins(), old.coinsInitialized(), old.rewardReceipts());
+                old.restrictedKills(), false, old.deathId(), old.diedAt(), old.coins(), old.coinsInitialized(), old.rewardReceipts(),old.pvpCoinEscrow(),old.gear());
             repository.replace(saved, old.revision());
             return new AbilityMutation(AbilityMutationStatus.APPLIED, Optional.of(saved));
         });
@@ -494,7 +499,7 @@ public final class CharacterStorage implements AutoCloseable {
             var loadout = old.loadout().stream().map(assigned -> assigned.equals(ability) ? "" : assigned).toList();
             var saved = new CharacterRecord(old.id(), old.name(), old.revision().add(BigInteger.ONE), old.stats(), old.level(),
                 old.experience(), old.unspentPoints().add(BigInteger.ONE), old.health(), learned, loadout, old.passives(), old.cooldowns(),
-                old.restrictedKills(), false, old.deathId(), old.diedAt(), old.coins(), old.coinsInitialized(), old.rewardReceipts());
+                old.restrictedKills(), false, old.deathId(), old.diedAt(), old.coins(), old.coinsInitialized(), old.rewardReceipts(),old.pvpCoinEscrow(),old.gear());
             repository.replace(saved, old.revision());
             return new AbilityMutation(AbilityMutationStatus.APPLIED, Optional.of(saved));
         });
@@ -517,7 +522,7 @@ public final class CharacterStorage implements AutoCloseable {
             if (loadout.equals(old.loadout())) return new AbilityMutation(AbilityMutationStatus.UNCHANGED, Optional.of(old));
             var saved = new CharacterRecord(old.id(), old.name(), old.revision().add(BigInteger.ONE), old.stats(), old.level(),
                 old.experience(), old.unspentPoints(), old.health(), old.learned(), loadout, old.passives(), old.cooldowns(),
-                old.restrictedKills(), false, old.deathId(), old.diedAt(), old.coins(), old.coinsInitialized(), old.rewardReceipts());
+                old.restrictedKills(), false, old.deathId(), old.diedAt(), old.coins(), old.coinsInitialized(), old.rewardReceipts(),old.pvpCoinEscrow(),old.gear());
             repository.replace(saved, old.revision());
             return new AbilityMutation(AbilityMutationStatus.APPLIED, Optional.of(saved));
         });
@@ -541,7 +546,7 @@ public final class CharacterStorage implements AutoCloseable {
             var cooldowns = new java.util.HashMap<>(old.cooldowns()); cooldowns.put(ability, readyAt);
             var saved = new CharacterRecord(old.id(), old.name(), old.revision().add(BigInteger.ONE), old.stats(), old.level(),
                 old.experience(), old.unspentPoints(), old.health(), old.learned(), old.loadout(), old.passives(), cooldowns,
-                old.restrictedKills(), false, old.deathId(), old.diedAt(), old.coins(), old.coinsInitialized(), old.rewardReceipts());
+                old.restrictedKills(), false, old.deathId(), old.diedAt(), old.coins(), old.coinsInitialized(), old.rewardReceipts(),old.pvpCoinEscrow(),old.gear());
             repository.replace(saved, old.revision());
             return new AbilityMutation(AbilityMutationStatus.APPLIED, Optional.of(saved));
         });
@@ -586,7 +591,7 @@ public final class CharacterStorage implements AutoCloseable {
             var saved = new CharacterRecord(old.id(), old.name(), old.revision().add(BigInteger.ONE), stats,
                 old.level(), old.experience(), old.unspentPoints().subtract(BigInteger.ONE),
                 currentHealth.add(gain), old.learned(), old.loadout(), old.passives(), old.cooldowns(), old.restrictedKills(), false,
-                old.deathId(), old.diedAt(), old.coins(), old.coinsInitialized(), old.rewardReceipts());
+                old.deathId(), old.diedAt(), old.coins(), old.coinsInitialized(), old.rewardReceipts(),old.pvpCoinEscrow(),old.gear());
             repository.replace(saved, old.revision());
             return new StatPurchase(StatPurchaseStatus.APPLIED, Optional.of(saved));
         });
@@ -612,7 +617,7 @@ public final class CharacterStorage implements AutoCloseable {
             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(),
                 old.experience(), old.unspentPoints(), bounded, old.learned(), old.loadout(), old.passives(), old.cooldowns(),
-                old.restrictedKills(), false, old.deathId(), old.diedAt(), old.coins(), old.coinsInitialized(), old.rewardReceipts());
+                old.restrictedKills(), false, old.deathId(), old.diedAt(), old.coins(), old.coinsInitialized(), old.rewardReceipts(),old.pvpCoinEscrow(),old.gear());
             repository.replace(saved, old.revision());
             return Optional.of(saved);
         });
@@ -649,7 +654,7 @@ public final class CharacterStorage implements AutoCloseable {
                 old.level(), old.experience(), old.unspentPoints(), java.math.BigDecimal.ZERO, old.learned(),
                 old.loadout(), old.passives(), old.cooldowns(), old.restrictedKills(), true, deathId, diedAt,
                 loseCoins ? BigInteger.ZERO : old.coins(), old.coinsInitialized(), old.rewardReceipts(),
-                loseCoins ? old.coins() : BigInteger.ZERO);
+                loseCoins ? old.coins() : BigInteger.ZERO,old.gear());
             repository.replace(dead, old.revision());
             return Optional.of(dead);
         });
@@ -686,7 +691,7 @@ public final class CharacterStorage implements AutoCloseable {
             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.passives(), old.cooldowns(),
-                old.restrictedKills(), false, old.deathId(), old.diedAt(), old.coins(), old.coinsInitialized(), old.rewardReceipts());
+                old.restrictedKills(), false, old.deathId(), old.diedAt(), old.coins(), old.coinsInitialized(), old.rewardReceipts(),BigInteger.ZERO,old.gear());
             repository.replace(restored, old.revision());
             return Optional.of(restored);
         });

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

@@ -58,6 +58,7 @@ final class CharacterYaml {
         root.put("coins", record.coins().toString());
         root.put("reward-receipts", new ArrayList<>(record.rewardReceipts().stream().sorted().map(UUID::toString).toList()));
         root.put("pvp-coin-escrow", record.pvpCoinEscrow().toString());
+        root.put("gear",Map.of("chestplate",record.gear().chestplate().name(),"leggings",record.gear().leggings().name(),"boots",record.gear().boots().name()));
         root.put("dead", record.dead());
         if (record.deathId() != null) {
             root.put("death-id", record.deathId().toString());
@@ -106,9 +107,12 @@ final class CharacterYaml {
             root.containsKey("coins-initialized") && bool(root.get("coins-initialized")),
             root.containsKey("reward-receipts") ? strings(root.get("reward-receipts")).stream()
                 .map(UUID::fromString).collect(java.util.stream.Collectors.toUnmodifiableSet()) : java.util.Set.of(),
-            root.containsKey("pvp-coin-escrow") ? number(root.get("pvp-coin-escrow")) : BigInteger.ZERO);
+            root.containsKey("pvp-coin-escrow") ? number(root.get("pvp-coin-escrow")) : BigInteger.ZERO,
+            root.containsKey("gear")?gear(root.get("gear")):CharacterGear.none());
     }
 
+    private static CharacterGear gear(Object value){var gear=object(value);return new CharacterGear(GearTier.valueOf(text(gear.get("chestplate"))),GearTier.valueOf(text(gear.get("leggings"))),GearTier.valueOf(text(gear.get("boots"))));}
+
     private static Map<?, ?> object(Object value) {
         if (value instanceof Map<?, ?> map) return map;
         throw new IllegalArgumentException("Expected YAML mapping");

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

@@ -0,0 +1,171 @@
+package games.dmg.fantasystick.persistence;
+
+import games.dmg.fantasystick.ability.Fireball;
+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 Fireball settings; publication remains a server-thread caller decision. */
+public final class FireballSettings implements AutoCloseable {
+    private static final int MAX_BYTES = 1_048_576;
+    public static final String BASE_DAMAGE = "fireball-base-damage";
+    public static final String COOLDOWN = "fireball-cooldown-seconds";
+    public static final String RANGE = "fireball-range-blocks";
+    public static final String LIFETIME = "fireball-lifetime-seconds";
+    public static final String SPEED = "fireball-projectile-speed-blocks-per-tick";
+    private static final List<String> KEYS = List.of(BASE_DAMAGE, COOLDOWN, LIFETIME, SPEED, RANGE);
+    private static final Map<String, String> DEFAULTS = Map.of(BASE_DAMAGE, "6", COOLDOWN, "1.2", RANGE, "32",
+        LIFETIME, "5", SPEED, "3");
+
+    @FunctionalInterface interface Replacement { void move(Path from, Path to) throws IOException; }
+    public record Update(String key, String value, Fireball.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-fireball-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 FireballSettings(Path directory, Map<String, String> initial) {
+        this(directory, initial, (from, to) -> Files.move(from, to,
+            StandardCopyOption.ATOMIC_MOVE, StandardCopyOption.REPLACE_EXISTING));
+    }
+
+    FireballSettings(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 Fireball.Settings settings() { return parse(effectiveValues); }
+
+    public synchronized boolean publish(Update update) {
+        Objects.requireNonNull(update);
+        if (update.sequence() <= publishedSequence) return false;
+        parse(update.values()); effectiveValues = update.values(); publishedSequence = update.sequence(); return true;
+    }
+
+    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("Fireball 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 Fireball.Settings parse(Map<String, String> values) {
+        try {
+            return new Fireball.Settings(new java.math.BigInteger(values.get(BASE_DAMAGE)), seconds(values.get(COOLDOWN)),
+                finite(values.get(RANGE)), seconds(values.get(LIFETIME)), finite(values.get(SPEED)));
+        } catch (ArithmeticException | NumberFormatException | NullPointerException invalid) {
+            throw new IllegalArgumentException("Fireball settings must use supported numeric values", invalid);
+        }
+    }
+
+    private static Duration seconds(String value) {
+        return Duration.ofNanos(new java.math.BigDecimal(value).movePointRight(9).toBigIntegerExact().longValueExact());
+    }
+    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/FrostShardSettings.java

@@ -36,7 +36,7 @@ public final class FrostShardSettings implements AutoCloseable {
     public static final String SLOWNESS = "frost-shard-slowness-duration-seconds";
     private static final List<String> KEYS = List.of(BASE_DAMAGE, COOLDOWN, LIFETIME, SPEED, RANGE, AMPLIFIER, SLOWNESS);
     private static final Map<String, String> DEFAULTS = Map.of(BASE_DAMAGE, "4", COOLDOWN, "5", RANGE, "32",
-        LIFETIME, "5", SPEED, "1", AMPLIFIER, "0", SLOWNESS, "2");
+        LIFETIME, "5", SPEED, "3", AMPLIFIER, "0", SLOWNESS, "2");
 
     @FunctionalInterface interface Replacement { void move(Path from, Path to) throws IOException; }
     public record Update(String key, String value, FrostShard.Settings settings,

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

@@ -0,0 +1,186 @@
+package games.dmg.fantasystick.persistence;
+
+import games.dmg.fantasystick.shop.ArmorMarketRules;
+import java.io.IOException;
+import java.math.BigInteger;
+import java.nio.ByteBuffer;
+import java.nio.channels.FileChannel;
+import java.nio.channels.OverlappingFileLockException;
+import java.nio.charset.StandardCharsets;
+import java.nio.file.*;
+import java.util.*;
+import java.util.concurrent.*;
+import org.yaml.snakeyaml.LoaderOptions;
+import org.yaml.snakeyaml.Yaml;
+import org.yaml.snakeyaml.constructor.SafeConstructor;
+
+/** Durable save-before-publication bases, variance and tier stock bounds for future catalogs. */
+public final class GearSettings implements AutoCloseable {
+    public static final String LEATHER="gear-price-leather", COPPER="gear-price-copper",
+        GOLD="gear-price-gold", IRON="gear-price-iron", DIAMOND="gear-price-diamond",
+        NETHERITE="gear-price-netherite", VARIANCE="gear-price-variance-percent";
+    private static final Map<GearTier,String> PRICE_KEYS=Map.of(
+        GearTier.LEATHER,LEATHER, GearTier.COPPER,COPPER, GearTier.GOLD,GOLD,
+        GearTier.IRON,IRON, GearTier.DIAMOND,DIAMOND, GearTier.NETHERITE,NETHERITE);
+    private static final Map<GearTier,String> TIER_NAMES=Map.of(
+        GearTier.LEATHER,"leather", GearTier.COPPER,"copper", GearTier.GOLD,"gold",
+        GearTier.IRON,"iron", GearTier.DIAMOND,"diamond", GearTier.NETHERITE,"netherite");
+    private static final Map<String,String> DEFAULTS=defaults();
+    private static final List<String> KEYS=DEFAULTS.keySet().stream().sorted().toList();
+
+    public record Update(String key,String value,Map<String,String> values,long sequence) {
+        public Update { values=Map.copyOf(values); }
+    }
+
+    private final Path directory;
+    private final ExecutorService worker=Executors.newSingleThreadExecutor(r->new Thread(r,"fantasy-gear-configuration"));
+    private volatile Map<String,String> effective;
+    private Map<String,String> persisted;
+    private long savedSequence,publishedSequence;
+    private boolean closed;
+    private int pending;
+    private final CompletableFuture<Void> drained=new CompletableFuture<>();
+
+    public GearSettings(Path directory,Map<String,String> initial) {
+        this.directory=Objects.requireNonNull(directory).toAbsolutePath();
+        var values=new LinkedHashMap<String,String>();
+        for(String key:KEYS) values.put(key,Objects.requireNonNull(initial.getOrDefault(key,DEFAULTS.get(key))));
+        validate(values);
+        effective=Map.copyOf(values);
+        persisted=effective;
+    }
+
+    public static List<String> keys(){return KEYS;}
+    public static String defaultValue(String key){return DEFAULTS.get(key);}
+    public String value(String key){return effective.get(key);}
+    public int price(GearTier tier){return wholeNonnegative(effective.get(priceKey(tier)));}
+
+    public ArmorMarketRules rules() {
+        var values=effective;
+        var prices=new EnumMap<GearTier,BigInteger>(GearTier.class);
+        var stock=new EnumMap<GearTier,ArmorMarketRules.StockRange>(GearTier.class);
+        for(var tier:PRICE_KEYS.keySet()) {
+            prices.put(tier,new BigInteger(values.get(priceKey(tier))));
+            stock.put(tier,new ArmorMarketRules.StockRange(
+                wholePositive(values.get(stockKey(tier,true))), wholePositive(values.get(stockKey(tier,false)))));
+        }
+        return new ArmorMarketRules(prices,wholeVariance(values.get(VARIANCE)),stock);
+    }
+
+    public CompletionStage<Update> set(String key,String raw) {
+        if(!KEYS.contains(key)) throw new IllegalArgumentException("Unknown gear market setting");
+        String accepted;
+        try { accepted=Integer.toString(parseForKey(key,raw)); }
+        catch(RuntimeException invalid) { throw new IllegalArgumentException("Invalid gear market setting",invalid); }
+        var preview=new LinkedHashMap<>(effective);
+        preview.put(key,accepted);
+        validate(preview);
+        synchronized(this){if(closed)return CompletableFuture.failedStage(new IOException("Configuration closed"));pending++;}
+        return CompletableFuture.supplyAsync(()->{
+            try {
+                var next=new LinkedHashMap<>(persisted);
+                next.put(key,accepted);
+                validate(next);
+                save(key,accepted);
+                persisted=Map.copyOf(next);
+                return new Update(key,accepted,persisted,++savedSequence);
+            } catch(IOException failure) { throw new CompletionException(failure); }
+            finally { finished(); }
+        },worker).minimalCompletionStage();
+    }
+
+    public synchronized boolean publish(Update update) {
+        if(update.sequence()<=publishedSequence)return false;
+        validate(update.values());
+        effective=update.values();
+        publishedSequence=update.sequence();
+        return true;
+    }
+
+    private static Map<String,String> defaults() {
+        var values=new LinkedHashMap<String,String>();
+        values.put(LEATHER,"2"); values.put(COPPER,"10"); values.put(GOLD,"25");
+        values.put(IRON,"75"); values.put(DIAMOND,"150"); values.put(NETHERITE,"500");
+        values.put(VARIANCE,"10");
+        int[][] ranges={{25,50},{20,40},{15,30},{10,20},{5,10},{1,3}};
+        GearTier[] tiers={GearTier.LEATHER,GearTier.COPPER,GearTier.GOLD,GearTier.IRON,GearTier.DIAMOND,GearTier.NETHERITE};
+        for(int i=0;i<tiers.length;i++) {
+            values.put(stockKey(tiers[i],true),Integer.toString(ranges[i][0]));
+            values.put(stockKey(tiers[i],false),Integer.toString(ranges[i][1]));
+        }
+        return Map.copyOf(values);
+    }
+
+    private static void validate(Map<String,String> values) {
+        for(var tier:PRICE_KEYS.keySet()) {
+            wholeNonnegative(values.get(priceKey(tier)));
+            int minimum=wholePositive(values.get(stockKey(tier,true)));
+            int maximum=wholePositive(values.get(stockKey(tier,false)));
+            if(minimum>maximum)throw new IllegalArgumentException("Stock minimum exceeds maximum");
+        }
+        wholeVariance(values.get(VARIANCE));
+    }
+
+    private static int parseForKey(String key,String value) {
+        if(key.equals(VARIANCE))return wholeVariance(value);
+        if(key.startsWith("gear-stock-"))return wholePositive(value);
+        return wholeNonnegative(value);
+    }
+    private static int wholeNonnegative(String value){return bounded(value,0,Integer.MAX_VALUE);}
+    private static int wholePositive(String value){return bounded(value,1,Integer.MAX_VALUE);}
+    private static int wholeVariance(String value){return bounded(value,0,100);}
+    private static int bounded(String value,int minimum,int maximum) {
+        var number=new BigInteger(Objects.requireNonNull(value));
+        if(number.compareTo(BigInteger.valueOf(minimum))<0||number.compareTo(BigInteger.valueOf(maximum))>0)
+            throw new IllegalArgumentException();
+        return number.intValueExact();
+    }
+    private static String priceKey(GearTier tier) {
+        var key=PRICE_KEYS.get(tier);
+        if(key==null)throw new IllegalArgumentException("None is not purchasable");
+        return key;
+    }
+    public static String stockKey(GearTier tier,boolean minimum) {
+        var name=TIER_NAMES.get(tier);
+        if(name==null)throw new IllegalArgumentException("None is not purchasable");
+        return "gear-stock-"+name+(minimum?"-min":"-max");
+    }
+
+    private void save(String key,String value)throws IOException {
+        Files.createDirectories(directory);
+        var file=directory.resolve("config.yml");
+        var lockFile=directory.resolve(".config.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(1_048_576);
+            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(1_048_577);}
+                if(bytes.length>1_048_576)throw new IOException("Configuration too large");
+                Object loaded=yaml.load(StandardCharsets.UTF_8.newDecoder().decode(ByteBuffer.wrap(bytes)).toString());
+                if(loaded instanceof Map<?,?> map)for(var entry:map.entrySet()) {
+                    if(!(entry.getKey() instanceof String savedKey))throw new IOException("Invalid key");
+                    document.put(savedKey,entry.getValue());
+                }
+            }
+            document.put(key,Integer.parseInt(value));
+            byte[] bytes=yaml.dump(document).getBytes(StandardCharsets.UTF_8);
+            Path temporary=Files.createTempFile(directory,".config-",".tmp");
+            try {
+                Files.write(temporary,bytes,StandardOpenOption.TRUNCATE_EXISTING);
+                try(var output=FileChannel.open(temporary,StandardOpenOption.WRITE)){output.force(true);}
+                Files.move(temporary,file,StandardCopyOption.ATOMIC_MOVE,StandardCopyOption.REPLACE_EXISTING);
+                DurableFiles.forceDirectory(directory);
+            } finally { Files.deleteIfExists(temporary); }
+        } catch(OverlappingFileLockException busy) { throw new IOException("Configuration busy",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/GearSlot.java

@@ -0,0 +1,4 @@
+package games.dmg.fantasystick.persistence;
+
+/** Purchasable character armor slots; head is intentionally absent and remains cosmetic-only. */
+public enum GearSlot { CHESTPLATE, LEGGINGS, BOOTS }

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

@@ -0,0 +1,7 @@
+package games.dmg.fantasystick.persistence;
+
+/** Strict reviewed armor progression; enum order is authoritative for upgrade comparisons. */
+public enum GearTier {
+    NONE, LEATHER, COPPER, GOLD, IRON, DIAMOND, NETHERITE;
+    public boolean higherThan(GearTier current){return ordinal()>current.ordinal();}
+}

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

@@ -0,0 +1,132 @@
+package games.dmg.fantasystick.persistence;
+
+import java.io.IOException;
+import java.math.BigInteger;
+import java.nio.ByteBuffer;
+import java.nio.channels.FileChannel;
+import java.nio.channels.OverlappingFileLockException;
+import java.nio.charset.StandardCharsets;
+import java.nio.file.*;
+import java.util.LinkedHashMap;
+import java.util.Map;
+import java.util.Objects;
+import java.util.concurrent.*;
+import org.yaml.snakeyaml.LoaderOptions;
+import org.yaml.snakeyaml.Yaml;
+import org.yaml.snakeyaml.constructor.SafeConstructor;
+
+/** Durable save-before-publication Witch hard-mob XP pool. */
+public final class HardMobXpSettings implements AutoCloseable {
+    public static final String KEY = "hard-mob-xp";
+    public static final String DEFAULT = "20";
+    private static final BigInteger MAXIMUM = BigInteger.valueOf(Integer.MAX_VALUE);
+    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, BigInteger pool, long sequence) { }
+
+    private final Path directory;
+    private final Replacement replacement;
+    private final ExecutorService worker = Executors.newSingleThreadExecutor(
+        task -> new Thread(task, "fantasy-hard-mob-xp-configuration"));
+    private volatile String effective;
+    private String persisted;
+    private long persistedSequence;
+    private long publishedSequence;
+    private boolean closed;
+    private int pending;
+    private final CompletableFuture<Void> drained = new CompletableFuture<>();
+
+    public HardMobXpSettings(Path directory, String initial) {
+        this(directory, initial, (from, to) -> Files.move(from, to,
+            StandardCopyOption.ATOMIC_MOVE, StandardCopyOption.REPLACE_EXISTING));
+    }
+
+    HardMobXpSettings(Path directory, String initial, Replacement replacement) {
+        this.directory = Objects.requireNonNull(directory).toAbsolutePath();
+        this.replacement = Objects.requireNonNull(replacement);
+        effective = canonical(initial); persisted = effective;
+    }
+
+    public static BigInteger parse(String raw) {
+        try {
+            var value = new BigInteger(raw);
+            if (value.signum() < 0 || value.compareTo(MAXIMUM) > 0) throw new IllegalArgumentException();
+            return value;
+        } catch (RuntimeException invalid) {
+            throw new IllegalArgumentException("Hard-mob XP must be a whole number from 0 through 2147483647", invalid);
+        }
+    }
+
+    private static String canonical(String raw) { return parse(raw).toString(); }
+    public String value() { return effective; }
+    public BigInteger pool() { return parse(effective); }
+
+    public CompletionStage<Update> set(String raw) {
+        String accepted = canonical(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(accepted, parse(accepted), ++persistedSequence);
+                } catch (IOException | RuntimeException failure) {
+                    throw new CompletionException(failure instanceof IllegalArgumentException ? failure
+                        : new IOException("Hard-mob XP save failed; effective value unchanged", failure));
+                } finally { finished(); }
+            }, worker).minimalCompletionStage();
+        } catch (RejectedExecutionException rejected) {
+            finished(); return CompletableFuture.failedStage(new IOException("Configuration store is closed", rejected));
+        }
+    }
+
+    public synchronized boolean publish(Update update) {
+        Objects.requireNonNull(update);
+        if (update.sequence() <= publishedSequence) return false;
+        effective = canonical(update.value()); publishedSequence = update.sequence(); return true;
+    }
+
+    private void save(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 key)) throw new IOException("Invalid configuration key");
+                        document.put(key, entry.getValue());
+                    }
+                }
+            }
+            document.put(KEY, value); byte[] bytes = yaml.dump(document).getBytes(StandardCharsets.UTF_8);
+            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", 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/OutOfCombatRecoverySettings.java

@@ -30,7 +30,7 @@ public final class OutOfCombatRecoverySettings implements AutoCloseable {
     public static final String INTERVAL = "out-of-combat-healing-interval-seconds";
     public static final String AMOUNT = "out-of-combat-healing-amount";
     private static final List<String> KEYS = List.of(DELAY, INTERVAL, AMOUNT);
-    private static final Map<String, String> DEFAULTS = Map.of(DELAY, "30", INTERVAL, "10", AMOUNT, "1");
+    private static final Map<String, String> DEFAULTS = Map.of(DELAY, "10", INTERVAL, "10", AMOUNT, "1");
     private static final int MAX_BYTES = 1_048_576;
     private static final long MAX_SECONDS = 31_536_000L;
 

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

@@ -0,0 +1,186 @@
+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.UUID;
+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 account-owned routine combat/effect feedback preference. */
+public final class PlayerFeedbackPreferences implements AutoCloseable {
+    private static final String FILE = "player-preferences.yml";
+    private static final String PLAYERS = "players";
+    private static final String KEY = "combat-feedback";
+    private static final int MAX_BYTES = 1_048_576;
+
+    public record Update(UUID account, boolean enabled, long sequence) {
+        public Update { Objects.requireNonNull(account); }
+    }
+
+    private final Path directory;
+    private final java.util.concurrent.ExecutorService worker = Executors.newSingleThreadExecutor(
+        task -> new Thread(task, "fantasy-player-feedback-preferences"));
+    private final Map<UUID, Boolean> effective = new java.util.HashMap<>();
+    private final Map<UUID, Long> published = new java.util.HashMap<>();
+    private long persistedSequence;
+    private boolean closed;
+    private int pending;
+    private final CompletableFuture<Void> drained = new CompletableFuture<>();
+
+    public PlayerFeedbackPreferences(Path directory) throws IOException {
+        this.directory = Objects.requireNonNull(directory).toAbsolutePath();
+        effective.putAll(loadEnabled());
+    }
+
+    public synchronized boolean enabled(UUID account) {
+        Objects.requireNonNull(account);
+        return effective.getOrDefault(account, true);
+    }
+
+    public CompletionStage<Update> set(UUID account, boolean enabled) {
+        Objects.requireNonNull(account);
+        synchronized (this) {
+            if (closed) return CompletableFuture.failedStage(new IOException("Player preference store is closed"));
+            pending++;
+        }
+        try {
+            return CompletableFuture.supplyAsync(() -> {
+                try {
+                    save(account, enabled);
+                    return new Update(account, enabled, ++persistedSequence);
+                } catch (IOException | RuntimeException failure) {
+                    throw new java.util.concurrent.CompletionException(new IOException(
+                        "Combat feedback preference save refused or failed; effective setting unchanged", failure));
+                } finally { finished(); }
+            }, worker).minimalCompletionStage();
+        } catch (RejectedExecutionException rejected) {
+            finished();
+            return CompletableFuture.failedStage(new IOException("Player preference store is closed"));
+        }
+    }
+
+    public synchronized boolean publish(Update update) {
+        Objects.requireNonNull(update);
+        if (closed) return false;
+        long previous = published.getOrDefault(update.account(), 0L);
+        if (update.sequence() <= previous) return false;
+        effective.put(update.account(), update.enabled());
+        published.put(update.account(), update.sequence());
+        return true;
+    }
+
+    private Map<UUID, Boolean> loadEnabled() throws IOException {
+        Map<String, Object> root = readRoot();
+        Object rawPlayers = root.get(PLAYERS);
+        if (rawPlayers == null) return Map.of();
+        if (!(rawPlayers instanceof Map<?, ?> players)) throw new IOException("Invalid player preferences");
+        var result = new LinkedHashMap<UUID, Boolean>();
+        for (var entry : players.entrySet()) {
+            if (!(entry.getKey() instanceof String rawId)) throw new IOException("Invalid player preference identity");
+            UUID account;
+            try { account = UUID.fromString(rawId); }
+            catch (IllegalArgumentException invalid) { throw new IOException("Invalid player preference identity", invalid); }
+            if (!(entry.getValue() instanceof Map<?, ?> values)) throw new IOException("Invalid player preference entry");
+            Object raw = values.get(KEY);
+            if (raw == null) continue;
+            if (!(raw instanceof Boolean value)) throw new IOException("Invalid combat feedback preference");
+            result.put(account, value);
+        }
+        return result;
+    }
+
+    private void save(UUID account, boolean enabled) throws IOException {
+        Files.createDirectories(directory);
+        if (!Files.isDirectory(directory, LinkOption.NOFOLLOW_LINKS)) throw new IOException("Unsafe data directory");
+        Path lockFile = directory.resolve(".player-preferences.lock");
+        if (Files.exists(lockFile, LinkOption.NOFOLLOW_LINKS)
+                && !Files.isRegularFile(lockFile, LinkOption.NOFOLLOW_LINKS)) throw new IOException("Unsafe preference lock");
+        try (var channel = FileChannel.open(lockFile, StandardOpenOption.CREATE, StandardOpenOption.WRITE,
+                    LinkOption.NOFOLLOW_LINKS);
+             var ignored = channel.tryLock()) {
+            if (ignored == null) throw new IOException("Player preferences busy");
+            Map<String, Object> root = readRoot();
+            Map<String, Object> players = stringMap(root.get(PLAYERS), "player preferences");
+            Map<String, Object> values = stringMap(players.get(account.toString()), "player preference entry");
+            values.put(KEY, enabled);
+            players.put(account.toString(), values);
+            root.put(PLAYERS, players);
+            byte[] bytes = yaml().dump(root).getBytes(StandardCharsets.UTF_8);
+            if (bytes.length > MAX_BYTES) throw new IOException("Player preferences too large");
+            Path temporary = Files.createTempFile(directory, ".player-preferences-", ".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);
+                }
+                Files.move(temporary, directory.resolve(FILE), StandardCopyOption.ATOMIC_MOVE,
+                    StandardCopyOption.REPLACE_EXISTING);
+                DurableFiles.forceDirectory(directory);
+            } finally { Files.deleteIfExists(temporary); }
+        } catch (OverlappingFileLockException busy) {
+            throw new IOException("Player preferences busy", busy);
+        }
+    }
+
+    private Map<String, Object> readRoot() throws IOException {
+        Path file = directory.resolve(FILE);
+        if (!Files.exists(file, LinkOption.NOFOLLOW_LINKS)) return new LinkedHashMap<>();
+        if (!Files.isRegularFile(file, LinkOption.NOFOLLOW_LINKS)) throw new IOException("Unsafe player preferences");
+        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("Player preferences too large");
+        Object loaded = yaml().load(StandardCharsets.UTF_8.newDecoder().decode(ByteBuffer.wrap(bytes)).toString());
+        return stringMap(loaded, "player preference root");
+    }
+
+    private static Map<String, Object> stringMap(Object raw, String label) throws IOException {
+        var result = new LinkedHashMap<String, Object>();
+        if (raw == null) return result;
+        if (!(raw instanceof Map<?, ?> map)) throw new IOException("Invalid " + label);
+        for (var entry : map.entrySet()) {
+            if (!(entry.getKey() instanceof String key)) throw new IOException("Invalid " + label + " key");
+            result.put(key, entry.getValue());
+        }
+        return result;
+    }
+
+    private static Yaml yaml() {
+        var options = new LoaderOptions();
+        options.setAllowDuplicateKeys(false);
+        options.setMaxAliasesForCollections(20);
+        options.setCodePointLimit(MAX_BYTES);
+        return new Yaml(new SafeConstructor(options));
+    }
+
+    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

@@ -33,7 +33,7 @@ public final class ShieldBashSettings implements AutoCloseable {
     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",
+    private static final Map<String, String> DEFAULTS = Map.of(BASE_DAMAGE, "4", COOLDOWN, "3", RANGE, "3",
         HORIZONTAL, "0.8", VERTICAL, "0.35");
 
     @FunctionalInterface interface Replacement { void move(Path from, Path to) throws IOException; }

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

@@ -0,0 +1,54 @@
+package games.dmg.fantasystick.persistence;
+
+import games.dmg.fantasystick.adventure.AdventureQuestState;
+import java.io.IOException;
+import java.math.BigInteger;
+import java.nio.charset.StandardCharsets;
+import java.nio.file.*;
+import java.time.Instant;
+import java.time.LocalDate;
+import java.util.*;
+import org.bukkit.entity.EntityType;
+import org.yaml.snakeyaml.LoaderOptions;
+import org.yaml.snakeyaml.Yaml;
+import org.yaml.snakeyaml.constructor.SafeConstructor;
+
+/** Atomic single-file durable authority for daily adventure quests. */
+public final class YamlAdventureQuestRepository {
+    private final Path file;
+    public YamlAdventureQuestRepository(Path data){file=data.toAbsolutePath().resolve("adventure-quests.yml");}
+    public AdventureQuestState load()throws IOException{
+        if(Files.notExists(file))return AdventureQuestState.empty();
+        try{
+            Object decoded=yaml().load(Files.readString(file,StandardCharsets.UTF_8));var root=map(decoded);if(number(root.get("schema-version"))!=1)throw new IllegalArgumentException();
+            var sites=new ArrayList<AdventureQuestState.Site>();for(Object item:list(root.get("sites"))){var r=map(item);sites.add(new AdventureQuestState.Site(uuid(r,"id"),AdventureQuestState.SiteType.valueOf(text(r.get("type"))),text(r.get("name")),uuid(r,"world"),decimal(r,"x"),decimal(r,"y"),decimal(r,"z")));}
+            var givers=new ArrayList<AdventureQuestState.Giver>();for(Object item:list(root.get("givers"))){var r=map(item);givers.add(new AdventureQuestState.Giver(uuid(r,"id"),text(r.get("name")),uuid(r,"world"),decimal(r,"x"),decimal(r,"y"),decimal(r,"z"),(float)decimal(r,"yaw"),(float)decimal(r,"pitch")));}
+            AdventureQuestState.Catalog catalog=null;if(root.get("catalog")!=null){var r=map(root.get("catalog"));catalog=new AdventureQuestState.Catalog(LocalDate.parse(text(r.get("day"))),uuid(r,"revision"),Instant.parse(text(r.get("created-at"))),list(r.get("sites")).stream().map(value->UUID.fromString(text(value))).toList());}
+            var quests=new ArrayList<AdventureQuestState.Quest>();for(Object item:list(root.get("quests"))){var r=map(item);quests.add(new AdventureQuestState.Quest(uuid(r,"id"),uuid(r,"catalog"),uuid(r,"site"),AdventureQuestState.UnitType.valueOf(text(r.get("unit-type"))),uuid(r,"unit"),list(r.get("snapshot")).stream().map(value->UUID.fromString(text(value))).collect(java.util.stream.Collectors.toSet()),Instant.parse(text(r.get("expires-at"))),new BigInteger(text(r.get("reward-xp"))),new BigInteger(text(r.get("reward-coins")))));}
+            var unitClaims=new HashSet<AdventureQuestState.UnitClaim>();for(Object item:list(root.get("unit-claims"))){var r=map(item);unitClaims.add(new AdventureQuestState.UnitClaim(uuid(r,"catalog"),uuid(r,"site"),AdventureQuestState.UnitType.valueOf(text(r.get("unit-type"))),uuid(r,"unit")));}
+            var characterClaims=new HashSet<AdventureQuestState.CharacterClaim>();for(Object item:list(root.get("character-claims"))){var r=map(item);characterClaims.add(new AdventureQuestState.CharacterClaim(uuid(r,"catalog"),uuid(r,"site"),uuid(r,"character")));}
+            var rosters=new LinkedHashMap<UUID,List<EntityType>>();for(Object item:list(root.get("rosters"))){var r=map(item);rosters.put(uuid(r,"site"),list(r.get("entities")).stream().map(value->EntityType.valueOf(text(value))).toList());}
+            return new AdventureQuestState(sites,givers,catalog,quests,unitClaims,characterClaims,rosters);
+        }catch(RuntimeException invalid){throw new IOException("Invalid adventure quest file",invalid);}
+    }
+    public void save(AdventureQuestState state)throws IOException{
+        Objects.requireNonNull(state);var root=new LinkedHashMap<String,Object>();root.put("schema-version",1);
+        root.put("sites",state.sites().stream().sorted(Comparator.comparing(AdventureQuestState.Site::id)).map(v->row("id",v.id(),"type",v.type(),"name",v.name(),"world",v.world(),"x",v.x(),"y",v.y(),"z",v.z())).toList());
+        root.put("givers",state.givers().stream().sorted(Comparator.comparing(AdventureQuestState.Giver::id)).map(v->row("id",v.id(),"name",v.name(),"world",v.world(),"x",v.x(),"y",v.y(),"z",v.z(),"yaw",v.yaw(),"pitch",v.pitch())).toList());
+        if(state.catalog()!=null)root.put("catalog",row("day",state.catalog().day(),"revision",state.catalog().revision(),"created-at",state.catalog().createdAt(),"sites",state.catalog().sites()));else root.put("catalog",null);
+        root.put("quests",state.quests().stream().sorted(Comparator.comparing(AdventureQuestState.Quest::id)).map(v->row("id",v.id(),"catalog",v.catalog(),"site",v.site(),"unit-type",v.unitType(),"unit",v.unit(),"snapshot",v.snapshot().stream().sorted().toList(),"expires-at",v.expiresAt(),"reward-xp",v.rewardXp(),"reward-coins",v.rewardCoins())).toList());
+        root.put("unit-claims",state.unitClaims().stream().sorted(Comparator.comparing(v->v.catalog().toString()+v.site()+v.unit())).map(v->row("catalog",v.catalog(),"site",v.site(),"unit-type",v.type(),"unit",v.unit())).toList());
+        root.put("character-claims",state.characterClaims().stream().sorted(Comparator.comparing(v->v.catalog().toString()+v.site()+v.character())).map(v->row("catalog",v.catalog(),"site",v.site(),"character",v.character())).toList());
+        root.put("rosters",state.rosters().entrySet().stream().sorted(Map.Entry.comparingByKey()).map(e->row("site",e.getKey(),"entities",e.getValue())).toList());
+        Files.createDirectories(file.getParent());Path temporary=Files.createTempFile(file.getParent(),"adventure-quests-",".tmp");try{byte[] bytes=yaml().dump(root).getBytes(StandardCharsets.UTF_8);try(var output=java.nio.channels.FileChannel.open(temporary,StandardOpenOption.WRITE)){var buffer=java.nio.ByteBuffer.wrap(bytes);while(buffer.hasRemaining())output.write(buffer);output.force(true);}try{Files.move(temporary,file,StandardCopyOption.ATOMIC_MOVE,StandardCopyOption.REPLACE_EXISTING);}catch(AtomicMoveNotSupportedException unsupported){throw new IOException("Atomic adventure persistence unavailable",unsupported);}DurableFiles.forceDirectory(file.getParent());}finally{Files.deleteIfExists(temporary);}
+    }
+    private static Map<String,Object> row(Object...pairs){var row=new LinkedHashMap<String,Object>();for(int i=0;i<pairs.length;i+=2)row.put((String)pairs[i],encode(pairs[i+1]));return row;}
+    private static Object encode(Object value){if(value instanceof UUID||value instanceof Enum<?>||value instanceof Instant||value instanceof LocalDate||value instanceof BigInteger||value instanceof Double||value instanceof Float)return value.toString();if(value instanceof Collection<?> values)return values.stream().map(YamlAdventureQuestRepository::encode).toList();return value;}
+    private static Yaml yaml(){var options=new LoaderOptions();options.setAllowDuplicateKeys(false);options.setMaxAliasesForCollections(64);options.setCodePointLimit(4_194_304);return new Yaml(new SafeConstructor(options));}
+    private static Map<?,?> map(Object value){if(value instanceof Map<?,?> result)return result;throw new IllegalArgumentException();}
+    private static List<?> list(Object value){if(value instanceof List<?> result)return result;throw new IllegalArgumentException();}
+    private static String text(Object value){if(value instanceof String result)return result;throw new IllegalArgumentException();}
+    private static UUID uuid(Map<?,?> row,String key){return UUID.fromString(text(row.get(key)));}
+    private static double decimal(Map<?,?> row,String key){return Double.parseDouble(text(row.get(key)));}
+    private static int number(Object value){return Integer.parseInt(value.toString());}
+}

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

@@ -0,0 +1,91 @@
+package games.dmg.fantasystick.persistence;
+
+import games.dmg.fantasystick.shop.ArmorCatalog;
+import games.dmg.fantasystick.shop.ArmorProduct;
+import java.io.IOException;
+import java.math.BigInteger;
+import java.nio.ByteBuffer;
+import java.nio.channels.FileChannel;
+import java.nio.charset.StandardCharsets;
+import java.nio.file.*;
+import java.time.Instant;
+import java.time.LocalDate;
+import java.util.*;
+import org.yaml.snakeyaml.LoaderOptions;
+import org.yaml.snakeyaml.Yaml;
+import org.yaml.snakeyaml.constructor.SafeConstructor;
+
+/** Forced atomic persistence for the one shared armor catalog. */
+public final class YamlArmorCatalogRepository implements ArmorCatalogRepository {
+    private final Path file;
+    public YamlArmorCatalogRepository(Path data){file=data.toAbsolutePath().resolve("armor-catalog.yml");}
+
+    @Override public Optional<ArmorCatalog> load() throws IOException {
+        if(Files.notExists(file))return Optional.empty();
+        try {
+            if(Files.size(file)>1_048_576)throw new IllegalArgumentException("Catalog too large");
+            Object decoded=yaml().load(Files.readString(file,StandardCharsets.UTF_8));
+            if(!(decoded instanceof Map<?,?> root)||Integer.parseInt(String.valueOf(root.get("schema-version")))!=1)
+                throw new IllegalArgumentException("Invalid schema");
+            var products=new LinkedHashMap<ArmorProduct,ArmorCatalog.Offer>();
+            for(Object value:list(root.get("products"))) {
+                var row=map(value);
+                var product=parseProduct(text(row,"product"));
+                if(products.put(product,new ArmorCatalog.Offer(new BigInteger(text(row,"price")),
+                    Integer.parseInt(text(row,"remaining"))))!=null)throw new IllegalArgumentException("Duplicate product");
+            }
+            var transactions=new LinkedHashMap<UUID,ArmorCatalog.Transaction>();
+            Object savedTransactions=root.get("transactions");
+            if(savedTransactions!=null)for(Object value:list(savedTransactions)) {
+                var row=map(value);var id=UUID.fromString(text(row,"operation-id"));
+                var transaction=new ArmorCatalog.Transaction(parseProduct(text(row,"product")),
+                    ArmorCatalog.TransactionState.valueOf(text(row,"state")));
+                if(transactions.put(id,transaction)!=null)throw new IllegalArgumentException("Duplicate operation");
+            }
+            return Optional.of(new ArmorCatalog(LocalDate.parse(text(root,"catalog-day")),
+                UUID.fromString(text(root,"revision")),Instant.parse(text(root,"refreshed-at")),
+                ArmorCatalog.RefreshReason.valueOf(text(root,"refresh-reason")),products,transactions));
+        } catch(RuntimeException invalid) { throw new IOException("Invalid armor catalog",invalid); }
+    }
+
+    @Override public void save(ArmorCatalog catalog) throws IOException {
+        Objects.requireNonNull(catalog);
+        Map<String,Object> root=new LinkedHashMap<>();
+        root.put("schema-version",1);
+        root.put("catalog-day",catalog.day().toString());
+        root.put("revision",catalog.revision().toString());
+        root.put("refreshed-at",catalog.refreshedAt().toString());
+        root.put("refresh-reason",catalog.reason().name());
+        root.put("products",catalog.products().entrySet().stream().sorted(Map.Entry.comparingByKey(
+            Comparator.comparing((ArmorProduct value)->value.slot().name()).thenComparing(value->value.tier().name())))
+            .map(entry->{Map<String,Object> row=new LinkedHashMap<>();row.put("product",product(entry.getKey()));
+                row.put("price",entry.getValue().price().toString());row.put("remaining",Integer.toString(entry.getValue().remaining()));return row;}).toList());
+        root.put("transactions",catalog.transactions().entrySet().stream().sorted(Map.Entry.comparingByKey()).map(entry->{
+            Map<String,Object> row=new LinkedHashMap<>();row.put("operation-id",entry.getKey().toString());
+            row.put("product",product(entry.getValue().product()));row.put("state",entry.getValue().state().name());return row;}).toList());
+        write(yaml().dump(root));
+    }
+
+    private void write(String content)throws IOException {
+        Files.createDirectories(file.getParent());
+        Path temporary=Files.createTempFile(file.getParent(),"armor-catalog-",".tmp");
+        try {
+            byte[] bytes=content.getBytes(StandardCharsets.UTF_8);
+            try(var output=FileChannel.open(temporary,StandardOpenOption.WRITE)){
+                var buffer=ByteBuffer.wrap(bytes);while(buffer.hasRemaining())output.write(buffer);output.force(true);
+            }
+            try{Files.move(temporary,file,StandardCopyOption.ATOMIC_MOVE,StandardCopyOption.REPLACE_EXISTING);}
+            catch(AtomicMoveNotSupportedException unsupported){throw new IOException("Atomic armor catalog persistence unavailable",unsupported);}
+            DurableFiles.forceDirectory(file.getParent());
+        } finally { Files.deleteIfExists(temporary); }
+    }
+
+    private static String product(ArmorProduct product){return product.slot().name()+"-"+product.tier().name();}
+    private static ArmorProduct parseProduct(String value){int split=value.indexOf('-');if(split<1)throw new IllegalArgumentException();return new ArmorProduct(
+        GearSlot.valueOf(value.substring(0,split)),GearTier.valueOf(value.substring(split+1)));}
+    private static Yaml yaml(){var options=new LoaderOptions();options.setAllowDuplicateKeys(false);options.setMaxAliasesForCollections(0);
+        options.setCodePointLimit(1_048_576);return new Yaml(new SafeConstructor(options));}
+    private static List<?> list(Object value){if(value instanceof List<?> result)return result;throw new IllegalArgumentException();}
+    private static Map<?,?> map(Object value){if(value instanceof Map<?,?> result)return result;throw new IllegalArgumentException();}
+    private static String text(Map<?,?> map,String key){Object value=map.get(key);if(value instanceof String text)return text;throw new IllegalArgumentException("Invalid "+key);}
+}

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

@@ -0,0 +1,9 @@
+package games.dmg.fantasystick.persistence;
+import games.dmg.fantasystick.shop.FantasyArmorer;import java.io.*;import java.nio.charset.StandardCharsets;import java.nio.file.*;import java.util.*;import org.yaml.snakeyaml.*;import org.yaml.snakeyaml.constructor.SafeConstructor;
+/** Forced atomic desired-state adapter for Fantasy Armorer registrations. */
+public final class YamlFantasyArmorerRepository{
+ private final Path file;public YamlFantasyArmorerRepository(Path data){file=data.toAbsolutePath().resolve("fantasy-armorers.yml");}
+ public List<FantasyArmorer> load()throws IOException{if(Files.notExists(file))return List.of();try{Object decoded=yaml().load(Files.readString(file,StandardCharsets.UTF_8));if(!(decoded instanceof Map<?,?> root)||Integer.parseInt(root.get("schema-version").toString())!=1)throw new IllegalArgumentException();var result=new ArrayList<FantasyArmorer>();for(Object value:list(root.get("shops"))){var row=map(value);result.add(new FantasyArmorer(UUID.fromString(text(row,"shop-id")),text(row,"name"),UUID.fromString(text(row,"world")),Double.parseDouble(text(row,"x")),Double.parseDouble(text(row,"y")),Double.parseDouble(text(row,"z")),Float.parseFloat(text(row,"yaw")),Float.parseFloat(text(row,"pitch"))));}validate(result);return List.copyOf(result);}catch(RuntimeException invalid){throw new IOException("Invalid Fantasy Armorer file",invalid);}}
+ public void save(List<FantasyArmorer> values)throws IOException{validate(values);Map<String,Object> root=new LinkedHashMap<>();root.put("schema-version",1);root.put("shops",values.stream().sorted(Comparator.comparing(FantasyArmorer::id)).map(value->{Map<String,Object> row=new LinkedHashMap<>();row.put("shop-id",value.id().toString());row.put("name",value.name());row.put("world",value.world().toString());row.put("x",Double.toString(value.x()));row.put("y",Double.toString(value.y()));row.put("z",Double.toString(value.z()));row.put("yaw",Float.toString(value.yaw()));row.put("pitch",Float.toString(value.pitch()));return row;}).toList());Files.createDirectories(file.getParent());Path temporary=Files.createTempFile(file.getParent(),"armorers-",".tmp");try{byte[] bytes=yaml().dump(root).getBytes(StandardCharsets.UTF_8);try(var output=java.nio.channels.FileChannel.open(temporary,StandardOpenOption.WRITE)){var buffer=java.nio.ByteBuffer.wrap(bytes);while(buffer.hasRemaining())output.write(buffer);output.force(true);}try{Files.move(temporary,file,StandardCopyOption.ATOMIC_MOVE,StandardCopyOption.REPLACE_EXISTING);}catch(AtomicMoveNotSupportedException unsupported){throw new IOException("Atomic Armorer persistence unavailable",unsupported);}DurableFiles.forceDirectory(file.getParent());}finally{Files.deleteIfExists(temporary);}}
+ private static void validate(List<FantasyArmorer> values){var ids=new HashSet<UUID>();if(values.stream().anyMatch(value->!ids.add(value.id())))throw new IllegalArgumentException("Duplicate Armorer identity");}private static Yaml yaml(){var options=new LoaderOptions();options.setAllowDuplicateKeys(false);options.setMaxAliasesForCollections(0);options.setCodePointLimit(1_048_576);return new Yaml(new SafeConstructor(options));}private static List<?> list(Object value){if(value instanceof List<?> result)return result;throw new IllegalArgumentException();}private static Map<?,?> map(Object value){if(value instanceof Map<?,?> result)return result;throw new IllegalArgumentException();}private static String text(Map<?,?> map,String key){Object value=map.get(key);if(value instanceof String text)return text;throw new IllegalArgumentException();}
+}

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

@@ -0,0 +1,89 @@
+package games.dmg.fantasystick.persistence;
+
+import games.dmg.fantasystick.training.TrainingDummy;
+import java.io.IOException;
+import java.nio.charset.StandardCharsets;
+import java.nio.file.AtomicMoveNotSupportedException;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.StandardCopyOption;
+import java.nio.file.StandardOpenOption;
+import java.util.ArrayList;
+import java.util.Comparator;
+import java.util.HashSet;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.UUID;
+import org.yaml.snakeyaml.LoaderOptions;
+import org.yaml.snakeyaml.Yaml;
+import org.yaml.snakeyaml.constructor.SafeConstructor;
+
+/** Atomic desired-state adapter for administrator-managed training dummies. */
+public final class YamlTrainingDummyRepository {
+    private final Path file;
+
+    public YamlTrainingDummyRepository(Path data) {
+        file = data.toAbsolutePath().resolve("training-dummies.yml");
+    }
+
+    public List<TrainingDummy> load() throws IOException {
+        if (Files.notExists(file)) return List.of();
+        try {
+            Object decoded = yaml().load(Files.readString(file, StandardCharsets.UTF_8));
+            if (!(decoded instanceof Map<?, ?> root) || number(root.get("schema-version")) != 1) {
+                throw new IllegalArgumentException();
+            }
+            var result = new ArrayList<TrainingDummy>();
+            for (Object value : list(root.get("dummies"))) {
+                var row = map(value);
+                result.add(new TrainingDummy(UUID.fromString(text(row.get("dummy-id"))), text(row.get("name")),
+                    UUID.fromString(text(row.get("world"))), decimal(row.get("x")), decimal(row.get("y")),
+                    decimal(row.get("z")), (float) decimal(row.get("yaw")), (float) decimal(row.get("pitch"))));
+            }
+            validate(result); return List.copyOf(result);
+        } catch (RuntimeException invalid) {
+            throw new IOException("Invalid training dummy file", invalid);
+        }
+    }
+
+    public void save(List<TrainingDummy> dummies) throws IOException {
+        validate(dummies);
+        Map<String, Object> root = new LinkedHashMap<>(); root.put("schema-version", 1);
+        root.put("dummies", dummies.stream().sorted(Comparator.comparing(TrainingDummy::id)).map(value -> {
+            Map<String, Object> row = new LinkedHashMap<>();
+            row.put("dummy-id", value.id().toString()); row.put("name", value.name());
+            row.put("world", value.world().toString()); row.put("x", Double.toString(value.x()));
+            row.put("y", Double.toString(value.y())); row.put("z", Double.toString(value.z()));
+            row.put("yaw", Float.toString(value.yaw())); row.put("pitch", Float.toString(value.pitch())); return row;
+        }).toList());
+        Files.createDirectories(file.getParent());
+        Path temporary = Files.createTempFile(file.getParent(), "training-dummies-", ".tmp");
+        try {
+            byte[] bytes = yaml().dump(root).getBytes(StandardCharsets.UTF_8);
+            try (var output = java.nio.channels.FileChannel.open(temporary, StandardOpenOption.WRITE)) {
+                var buffer = java.nio.ByteBuffer.wrap(bytes); while (buffer.hasRemaining()) output.write(buffer); output.force(true);
+            }
+            try { Files.move(temporary, file, StandardCopyOption.ATOMIC_MOVE, StandardCopyOption.REPLACE_EXISTING); }
+            catch (AtomicMoveNotSupportedException unsupported) {
+                throw new IOException("Atomic training dummy persistence is unavailable", unsupported);
+            }
+            DurableFiles.forceDirectory(file.getParent());
+        } finally { Files.deleteIfExists(temporary); }
+    }
+
+    private static void validate(List<TrainingDummy> values) {
+        var ids = new HashSet<UUID>();
+        if (values.stream().anyMatch(value -> !ids.add(value.id()))) {
+            throw new IllegalArgumentException("Duplicate training dummy identity");
+        }
+    }
+    private static Yaml yaml() { var options = new LoaderOptions(); options.setAllowDuplicateKeys(false);
+        options.setMaxAliasesForCollections(0); options.setCodePointLimit(1_048_576);
+        return new Yaml(new SafeConstructor(options)); }
+    private static Map<?, ?> map(Object value) { if (value instanceof Map<?, ?> result) return result; throw new IllegalArgumentException(); }
+    private static List<?> list(Object value) { if (value instanceof List<?> result) return result; throw new IllegalArgumentException(); }
+    private static String text(Object value) { if (value instanceof String result) return result; throw new IllegalArgumentException(); }
+    private static int number(Object value) { return Integer.parseInt(value.toString()); }
+    private static double decimal(Object value) { return Double.parseDouble(text(value)); }
+}

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

@@ -0,0 +1,87 @@
+package games.dmg.fantasystick.presentation;
+
+import games.dmg.fantasystick.ability.AbilityDefinition;
+import games.dmg.fantasystick.ability.AbilityFeedback;
+import games.dmg.fantasystick.ability.AbilityReport;
+import games.dmg.fantasystick.persistence.PlayerFeedbackPreferences;
+import games.dmg.fantasystick.session.ControlInput;
+import games.dmg.fantasystick.session.EquipmentSessions;
+import java.math.BigDecimal;
+import java.math.RoundingMode;
+import java.util.Locale;
+import java.util.Objects;
+import net.kyori.adventure.text.Component;
+import net.kyori.adventure.text.format.NamedTextColor;
+import org.bukkit.entity.Entity;
+import org.bukkit.entity.Player;
+
+/** Account-filtered chat presentation for authoritative Fantasy Stick effect outcomes. */
+public final class CombatFeedback implements AbilityFeedback {
+    private final PlayerFeedbackPreferences preferences;
+    private final EquipmentSessions sessions;
+
+    public CombatFeedback(PlayerFeedbackPreferences preferences, EquipmentSessions sessions) {
+        this.preferences = Objects.requireNonNull(preferences);
+        this.sessions = Objects.requireNonNull(sessions);
+    }
+
+    @Override public void report(AbilityDefinition definition, ControlInput input, AbilityReport.Type type,
+                                 Entity target, BigDecimal amount) {
+        Objects.requireNonNull(definition); Objects.requireNonNull(input);
+        report(definition.name(), input.player(), type, target, amount);
+    }
+
+    public void report(String effect, Player source, AbilityReport.Type type, Entity target, BigDecimal amount) {
+        Objects.requireNonNull(effect); Objects.requireNonNull(source); Objects.requireNonNull(type);
+        Objects.requireNonNull(target); Objects.requireNonNull(amount);
+        if (amount.signum() <= 0 || !Double.isFinite(amount.doubleValue())) return;
+        String message = message(effect, type, name(target), amount);
+        if (preferences.enabled(source.getUniqueId())) send(source, message);
+        if (target instanceof Player recipient && recipient != source && recipientEffect(type)
+                && preferences.enabled(recipient.getUniqueId())) send(recipient, message);
+    }
+
+    private String name(Entity entity) {
+        if (entity instanceof Player player) {
+            var active = sessions.active(player.getUniqueId()).filter(sessions::current).orElse(null);
+            if (active != null) {
+                var record = sessions.currentRecord(active).orElse(null);
+                if (record != null && !record.name().isBlank()) return record.name();
+            }
+        }
+        String nativeName = entity.getName();
+        if (nativeName != null && !nativeName.isBlank()) return nativeName;
+        var entityType = entity.getType();
+        if (entityType == null) return "Target";
+        String value = entityType.name().toLowerCase(Locale.ROOT).replace('_', ' ');
+        var words = value.split(" ");
+        var result = new StringBuilder();
+        for (String word : words) {
+            if (!result.isEmpty()) result.append(' ');
+            if (!word.isEmpty()) result.append(Character.toUpperCase(word.charAt(0))).append(word.substring(1));
+        }
+        return result.toString();
+    }
+
+    private static String message(String effect, AbilityReport.Type type, String target, BigDecimal amount) {
+        String value = amount.setScale(2, RoundingMode.HALF_UP).stripTrailingZeros().toPlainString();
+        return switch (type) {
+            case DAMAGE -> effect + " did " + value + " damage to " + target + ".";
+            case HEALING -> effect + " healed " + target + " for " + value + " health.";
+            case CLEANSING -> effect + " removed " + value + " harmful "
+                + (amount.compareTo(BigDecimal.ONE) == 0 ? "effect" : "effects") + " from " + target + ".";
+            case PREVENTION -> effect + " prevented " + value + " damage to " + target + ".";
+            case BOOST_USED -> effect + " added " + value + " damage against " + target + ".";
+        };
+    }
+
+    private static void send(Player player, String message) {
+        try { player.sendMessage(Component.text(message, NamedTextColor.GRAY)); }
+        catch (RuntimeException ignored) { }
+    }
+
+    private static boolean recipientEffect(AbilityReport.Type type) {
+        return type == AbilityReport.Type.HEALING || type == AbilityReport.Type.CLEANSING
+            || type == AbilityReport.Type.PREVENTION;
+    }
+}

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

@@ -8,9 +8,9 @@ import java.util.Objects;
 import java.util.UUID;
 
 /** Validated combat reward arithmetic and location policy; native classification lives at the adapter. */
-public record CombatRewardRules(BigInteger passivePool, BigInteger ordinaryPool, BigInteger bossPool,
-                                BigDecimal restrictedSpacing) {
-    public enum Target { PASSIVE, ORDINARY, BOSS, FANTASY_CHARACTER }
+public record CombatRewardRules(BigInteger passivePool, BigInteger ordinaryPool, BigInteger hardPool,
+                                BigInteger bossPool, BigDecimal restrictedSpacing) {
+    public enum Target { PASSIVE, ORDINARY, HARD, BOSS, FANTASY_CHARACTER }
     public static final Duration CONTRIBUTION_LIFETIME = Duration.ofMinutes(5);
 
     public record KillPosition(UUID world, BigDecimal x, BigDecimal y, BigDecimal z) {
@@ -26,16 +26,26 @@ public record CombatRewardRules(BigInteger passivePool, BigInteger ordinaryPool,
     }
 
     public CombatRewardRules {
-        Objects.requireNonNull(passivePool); Objects.requireNonNull(ordinaryPool);
+        Objects.requireNonNull(passivePool); Objects.requireNonNull(ordinaryPool); Objects.requireNonNull(hardPool);
         Objects.requireNonNull(bossPool); Objects.requireNonNull(restrictedSpacing);
-        if (passivePool.signum() < 0 || ordinaryPool.signum() < 0 || bossPool.signum() < 0
+        if (passivePool.signum() < 0 || ordinaryPool.signum() < 0 || hardPool.signum() < 0 || bossPool.signum() < 0
                 || restrictedSpacing.signum() < 0 || !Double.isFinite(restrictedSpacing.doubleValue())) {
             throw new IllegalArgumentException("Combat reward values must be finite and nonnegative");
         }
     }
 
+    public CombatRewardRules(BigInteger passivePool, BigInteger ordinaryPool, BigInteger bossPool,
+                             BigDecimal restrictedSpacing) {
+        this(passivePool, ordinaryPool, BigInteger.valueOf(20), bossPool, restrictedSpacing);
+    }
+
     public static CombatRewardRules defaults() {
-        return new CombatRewardRules(BigInteger.ONE, BigInteger.TEN, BigInteger.valueOf(100), BigDecimal.valueOf(3));
+        return new CombatRewardRules(BigInteger.ONE, BigInteger.TEN, BigInteger.valueOf(20),
+            BigInteger.valueOf(100), BigDecimal.valueOf(3));
+    }
+
+    public CombatRewardRules withHardPool(BigInteger pool) {
+        return new CombatRewardRules(passivePool, ordinaryPool, pool, bossPool, restrictedSpacing);
     }
 
     public BigInteger pool(Target target, int defeatedLevel) {
@@ -47,6 +57,7 @@ public record CombatRewardRules(BigInteger passivePool, BigInteger ordinaryPool,
         return switch (target) {
             case PASSIVE -> passivePool;
             case ORDINARY -> ordinaryPool;
+            case HARD -> hardPool;
             case BOSS -> bossPool;
             case FANTASY_CHARACTER -> throw new IllegalStateException("Handled fantasy character");
         };

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

@@ -22,6 +22,8 @@ public final class EquipmentAdminCommand implements TabExecutor, AutoCloseable {
     private final Consumer<Failure> diagnostics;
     private volatile boolean closed;
     private games.dmg.fantasystick.persistence.AdventureSettings settings;
+    private games.dmg.fantasystick.persistence.FireballSettings fireballSettings;
+    private games.dmg.fantasystick.ability.Fireball fireball;
     private games.dmg.fantasystick.persistence.FrostShardSettings frostSettings;
     private games.dmg.fantasystick.ability.FrostShard frostShard;
     private games.dmg.fantasystick.ability.AbilityRegistry abilities;
@@ -65,7 +67,12 @@ public final class EquipmentAdminCommand implements TabExecutor, AutoCloseable {
     private games.dmg.fantasystick.persistence.RoleplaySettings roleplaySettings;
     private games.dmg.fantasystick.persistence.PartySettings partySettings;
     private games.dmg.fantasystick.persistence.PartyEconomySettings partyEconomySettings;
+    private games.dmg.fantasystick.persistence.GearSettings gearSettings;
     private games.dmg.fantasystick.persistence.CoinSettings coinSettings;
+    private games.dmg.fantasystick.persistence.HardMobXpSettings hardMobXpSettings;
+    private games.dmg.fantasystick.persistence.AdventureQuestSettings adventureQuestSettings;
+    private games.dmg.fantasystick.adventure.AdventureQuestCommands adventureQuestCommands;
+    private games.dmg.fantasystick.party.CombatExperience combatExperience;
     private games.dmg.fantasystick.persistence.SheetResourcePackSettings sheetResourcePackSettings;
     private games.dmg.fantasystick.presentation.SheetResourcePack sheetResourcePack;
     private games.dmg.fantasystick.persistence.OutOfCombatRecoverySettings outOfCombatRecoverySettings;
@@ -79,6 +86,11 @@ public final class EquipmentAdminCommand implements TabExecutor, AutoCloseable {
     private games.dmg.fantasystick.passive.PassiveRegistry passiveRegistry;
     private games.dmg.fantasystick.party.PartyRegistrarDirectory partyRegistrars;
     private games.dmg.fantasystick.party.PartyRegistrarController partyRegistrarController;
+    private games.dmg.fantasystick.training.TrainingDummyDirectory trainingDummies;
+    private games.dmg.fantasystick.training.TrainingDummyController trainingDummyController;
+    private games.dmg.fantasystick.shop.FantasyArmorerDirectory armorers;
+    private games.dmg.fantasystick.shop.FantasyArmorerController armorerController;
+    private games.dmg.fantasystick.shop.ArmorMarket armorMarket;
 
     public EquipmentAdminCommand(EquipmentSessionStore receipts, EquipmentSessions sessions, Server server,
                                  Consumer<Runnable> nextTick, Consumer<Failure> diagnostics) {
@@ -306,7 +318,18 @@ public final class EquipmentAdminCommand implements TabExecutor, AutoCloseable {
     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 attachPartyEconomySettings(games.dmg.fantasystick.persistence.PartyEconomySettings settings){if(closed||partyEconomySettings!=null)throw new IllegalStateException("Party economy settings already attached or command closed");partyEconomySettings=Objects.requireNonNull(settings);}
+    public void attachGearSettings(games.dmg.fantasystick.persistence.GearSettings settings){if(closed||gearSettings!=null)throw new IllegalStateException("Gear settings already attached or command closed");gearSettings=Objects.requireNonNull(settings);}
     public void attachCoinSettings(games.dmg.fantasystick.persistence.CoinSettings settings){if(closed||coinSettings!=null)throw new IllegalStateException("Coin settings already attached or command closed");coinSettings=Objects.requireNonNull(settings);}
+    public void attachHardMobXpSettings(games.dmg.fantasystick.persistence.HardMobXpSettings settings,
+                                         games.dmg.fantasystick.party.CombatExperience experience) {
+        if (closed || hardMobXpSettings != null) throw new IllegalStateException("Hard-mob XP settings already attached or command closed");
+        hardMobXpSettings = Objects.requireNonNull(settings); combatExperience = Objects.requireNonNull(experience);
+    }
+    public void attachAdventureQuests(games.dmg.fantasystick.adventure.AdventureQuestCommands commands,
+                                      games.dmg.fantasystick.persistence.AdventureQuestSettings settings) {
+        if (closed || adventureQuestCommands != null) throw new IllegalStateException("Adventure quests already attached or command closed");
+        adventureQuestCommands = Objects.requireNonNull(commands); adventureQuestSettings = 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 attachOutOfCombatRecovery(games.dmg.fantasystick.persistence.OutOfCombatRecoverySettings settings,
                                            OutOfCombatRecovery recovery) {
@@ -360,12 +383,40 @@ public final class EquipmentAdminCommand implements TabExecutor, AutoCloseable {
         partyRegistrars=Objects.requireNonNull(directory); partyRegistrarController=Objects.requireNonNull(controller);
     }
 
+    public void attachFireball(games.dmg.fantasystick.persistence.FireballSettings settings,
+            games.dmg.fantasystick.ability.Fireball effect) {
+        if (closed || fireballSettings != null) throw new IllegalStateException("Fireball already attached or command closed");
+        fireballSettings = Objects.requireNonNull(settings); fireball = Objects.requireNonNull(effect);
+    }
+
+    public void attachTrainingDummies(games.dmg.fantasystick.training.TrainingDummyDirectory directory,
+            games.dmg.fantasystick.training.TrainingDummyController controller) {
+        if (closed || trainingDummies != null) throw new IllegalStateException("Training dummies already attached or command closed");
+        trainingDummies = Objects.requireNonNull(directory); trainingDummyController = Objects.requireNonNull(controller);
+    }
+
+    public void attachArmorers(games.dmg.fantasystick.shop.FantasyArmorerDirectory directory,games.dmg.fantasystick.shop.FantasyArmorerController controller){if(closed||armorers!=null)throw new IllegalStateException("Armorers already attached or command closed");armorers=Objects.requireNonNull(directory);armorerController=Objects.requireNonNull(controller);}
+    public void attachArmorMarket(games.dmg.fantasystick.shop.ArmorMarket market){if(closed||armorMarket!=null)throw new IllegalStateException("Armor market already attached or command closed");armorMarket=Objects.requireNonNull(market);}
+
     @Override public boolean onCommand(CommandSender sender, Command command, String label, String[] args) {
         if (closed) return true;
+        if (adventureQuestCommands != null && args.length > 0 && args[0].equals("adventure")) {
+            adventureQuestCommands.adventure(sender, args); return true;
+        }
         if (!sender.hasPermission(PERMISSION)) {
-            sender.sendMessage("You need fantasystick.admin to administer Fantasy Stick.");
+            sender.sendMessage("Permission denied: you need fantasystick.admin to administer Fantasy Stick.");
             return true;
         }
+        if (adventureQuestCommands != null && args.length > 0 && args[0].equals("adventure-site")) {
+            adventureQuestCommands.site(sender, args); return true;
+        }
+        if (adventureQuestCommands != null && args.length > 0 && args[0].equals("quest-giver")) {
+            adventureQuestCommands.giver(sender, args); return true;
+        }
+        if(args.length>0&&args[0].equals("shop")){shop(sender,args);return true;}
+        if (args.length > 0 && args[0].equals("training-dummy")) {
+            trainingDummy(sender, args); return true;
+        }
         if (args.length > 0 && args[0].equals("party-registrar")) {
             partyRegistrar(sender,args); return true;
         }
@@ -493,6 +544,133 @@ public final class EquipmentAdminCommand implements TabExecutor, AutoCloseable {
 
     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 shop(CommandSender sender,String[] args){
+        if(armorers==null||armorerController==null||args.length<2){shopUsage(sender);return;}
+        if(args[1].equals("restock")&&args.length==2&&armorMarket!=null){armorMarket.restock().whenComplete((catalog,failure)->{
+            if(failure!=null)report(null,"shop-restock",failure);if(closed)return;try{nextTick.accept(()->{
+                if(closed||!sender.hasPermission(PERMISSION)||sender instanceof org.bukkit.entity.Player player&&!player.isOnline())return;
+                if(failure!=null)sender.sendMessage("Fantasy Armorer restock failed; the prior catalog is unchanged.");
+                else sender.sendMessage("Restocked all Fantasy Armorers with catalog "+catalog.revision()+"; the next automatic restock remains 00:00 UTC.");
+            });}catch(RuntimeException rejected){report(null,"shop-restock-response",rejected);}});return;}
+        if(args[1].equals("list")&&args.length==2){var values=armorers.all();if(values.isEmpty())sender.sendMessage("No Fantasy Armorers are registered.");else for(var value:values)sender.sendMessage(value.id()+" "+(value.name().isBlank()?"Fantasy Armorer":value.name())+" @ "+value.world()+" "+value.x()+" "+value.y()+" "+value.z());return;}
+        if(args[1].equals("place")&&sender instanceof org.bukkit.entity.Player player){String name=args.length<3?"":String.join(" ",java.util.Arrays.copyOfRange(args,2,args.length));var location=player.getLocation().clone();java.util.concurrent.CompletableFuture<games.dmg.fantasystick.shop.FantasyArmorer> operation;try{operation=armorers.place(name,location.getWorld().getUID(),location.getX(),location.getY(),location.getZ(),location.getYaw(),location.getPitch());}catch(IllegalArgumentException invalid){sender.sendMessage("Fantasy Armorer name is invalid.");return;}operation.whenComplete((saved,failure)->placeShopResponse(player,location,saved,failure));return;}
+        if(args[1].equals("remove")&&args.length==3){UUID id;try{id=UUID.fromString(args[2]);}catch(IllegalArgumentException invalid){sender.sendMessage("Fantasy Armorer UUID is invalid.");return;}armorers.remove(id).whenComplete((removed,failure)->removeShopResponse(sender,id,removed,failure));return;}
+        shopUsage(sender);
+    }
+    private static void shopUsage(CommandSender sender){sender.sendMessage("Usage: /fantasystick shop <place [name...]|remove <shop-uuid>|list|restock>");}
+    private void placeShopResponse(org.bukkit.entity.Player player,org.bukkit.Location location,games.dmg.fantasystick.shop.FantasyArmorer saved,Throwable failure){if(failure!=null)report(player.getUniqueId(),"shop-place",failure);if(closed)return;nextTick.accept(()->{if(closed)return;if(failure!=null){if(player.isOnline())player.sendMessage("Fantasy Armorer placement failed; no registration or entity changed.");return;}try{int x=location.getBlockX()>>4,z=location.getBlockZ()>>4;if(location.getWorld().isChunkLoaded(x,z))armorerController.reconcile(location.getWorld().getChunkAt(x,z));if(player.isOnline())player.sendMessage("Placed Fantasy Armorer "+saved.id()+".");}catch(RuntimeException entityFailure){report(player.getUniqueId(),"shop-entity",entityFailure);armorers.remove(saved.id()).whenComplete((ignored,rollback)->nextTick.accept(()->{armorerController.removeLoaded(saved.id());if(player.isOnline())player.sendMessage("Fantasy Armorer placement failed; no registration or entity changed.");}));}});}
+    private void removeShopResponse(CommandSender sender,UUID id,java.util.Optional<games.dmg.fantasystick.shop.FantasyArmorer> removed,Throwable failure){if(failure!=null)report(null,"shop-remove",failure);if(closed)return;nextTick.accept(()->{if(failure!=null)sender.sendMessage("Fantasy Armorer removal failed; registration and entity are unchanged.");else if(removed.isEmpty())sender.sendMessage("Fantasy Armorer not found.");else try{armorerController.removeLoaded(id);sender.sendMessage("Removed Fantasy Armorer "+id+".");}catch(RuntimeException entityFailure){var value=removed.orElseThrow();report(null,"shop-entity-remove",entityFailure);armorers.restore(value).whenComplete((restored,rollback)->{if(rollback!=null)report(null,"shop-remove-rollback",rollback);if(closed)return;nextTick.accept(()->{if(rollback==null){var world=server.getWorld(value.world());if(world!=null&&world.isChunkLoaded(((int)Math.floor(value.x()))>>4,((int)Math.floor(value.z()))>>4))armorerController.reconcile(world.getChunkAt(((int)Math.floor(value.x()))>>4,((int)Math.floor(value.z()))>>4));sender.sendMessage("Fantasy Armorer removal failed; registration and entity are unchanged.");}else sender.sendMessage("Fantasy Armorer removal rollback failed; inspect diagnostics.");});});}});}
+
+    private void trainingDummy(CommandSender sender, String[] args) {
+        if (trainingDummies == null || trainingDummyController == null || args.length < 2) {
+            trainingDummyUsage(sender); return;
+        }
+        if (args[1].equals("list") && args.length == 2) {
+            var values = trainingDummies.all();
+            if (values.isEmpty()) sender.sendMessage("No training dummies are registered.");
+            else for (var value : values) sender.sendMessage(value.id() + " " + value.displayName() + " @ "
+                + value.world() + " " + value.x() + " " + value.y() + " " + value.z());
+            return;
+        }
+        if (args[1].equals("place") && sender instanceof org.bukkit.entity.Player player) {
+            String name = args.length < 3 ? "" : String.join(" ", java.util.Arrays.copyOfRange(args, 2, args.length));
+            var location = player.getLocation().clone();
+            try {
+                trainingDummies.place(name, location.getWorld().getUID(), location.getX(), location.getY(),
+                    location.getZ(), location.getYaw(), location.getPitch())
+                    .whenComplete((saved, failure) -> placeDummyResponse(player, location, saved, failure));
+            } catch (IllegalArgumentException invalid) { sender.sendMessage("Training dummy name is invalid."); }
+            return;
+        }
+        if (args[1].equals("remove") && args.length == 3) {
+            UUID id;
+            try { id = UUID.fromString(args[2]); }
+            catch (IllegalArgumentException invalid) { sender.sendMessage("Training dummy UUID is invalid."); return; }
+            trainingDummies.remove(id).whenComplete((removed, failure) -> removeDummyResponse(sender, id, removed, failure));
+            return;
+        }
+        trainingDummyUsage(sender);
+    }
+
+    private static void trainingDummyUsage(CommandSender sender) {
+        sender.sendMessage("Usage: /fantasystick training-dummy <place [name...]|remove <dummy-uuid>|list>");
+    }
+
+    private void placeDummyResponse(org.bukkit.entity.Player player, org.bukkit.Location location,
+            games.dmg.fantasystick.training.TrainingDummy saved, Throwable failure) {
+        if (failure != null) report(player.getUniqueId(), "training-dummy-place", failure);
+        if (closed) return;
+        try { nextTick.accept(() -> {
+            if (closed) return;
+            if (failure != null) {
+                if (player.isOnline()) player.sendMessage("Training dummy placement failed; no record or entity changed.");
+                return;
+            }
+            if (!player.isOnline() || !player.hasPermission(PERMISSION)) {
+                trainingDummies.remove(saved.id()).whenComplete((ignored, rollbackFailure) -> {
+                    if (rollbackFailure != null) report(player.getUniqueId(), "training-dummy-permission-rollback", rollbackFailure);
+                    if (!closed) nextTick.accept(() -> {
+                        trainingDummyController.removeLoaded(saved.id());
+                        if (player.isOnline()) player.sendMessage("Training dummy placement was cancelled because permission changed.");
+                    });
+                });
+                return;
+            }
+            try {
+                int chunkX = location.getBlockX() >> 4, chunkZ = location.getBlockZ() >> 4;
+                if (location.getWorld().isChunkLoaded(chunkX, chunkZ)) {
+                    trainingDummyController.reconcile(location.getWorld().getChunkAt(chunkX, chunkZ));
+                }
+                player.sendMessage("Placed training dummy " + saved.id() + ".");
+            } catch (RuntimeException entityFailure) {
+                report(player.getUniqueId(), "training-dummy-entity", entityFailure);
+                trainingDummies.remove(saved.id()).whenComplete((ignored, rollbackFailure) -> {
+                    if (rollbackFailure != null) report(player.getUniqueId(), "training-dummy-rollback", rollbackFailure);
+                    if (!closed) nextTick.accept(() -> {
+                        trainingDummyController.removeLoaded(saved.id());
+                        if (player.isOnline()) player.sendMessage("Training dummy placement failed; no record or entity changed.");
+                    });
+                });
+            }
+        }); } catch (RuntimeException rejected) { report(player.getUniqueId(), "training-dummy-response", rejected); }
+    }
+
+    private void removeDummyResponse(CommandSender sender, UUID id,
+            java.util.Optional<games.dmg.fantasystick.training.TrainingDummy> removed, Throwable failure) {
+        if (failure != null) report(null, "training-dummy-remove", failure);
+        if (closed) return;
+        try { nextTick.accept(() -> {
+            if (closed) return;
+            if (failure != null) { sender.sendMessage("Training dummy removal failed; record and entity are unchanged."); return; }
+            if (removed.isEmpty()) { sender.sendMessage("Training dummy not found."); return; }
+            if (!sender.hasPermission(PERMISSION)
+                    || sender instanceof org.bukkit.entity.Player player && !player.isOnline()) {
+                restoreDummy(sender, removed.orElseThrow(), "Training dummy removal was cancelled because permission changed.");
+                return;
+            }
+            try { trainingDummyController.removeLoaded(id); sender.sendMessage("Removed training dummy " + id + "."); }
+            catch (RuntimeException entityFailure) {
+                report(null, "training-dummy-entity", entityFailure);
+                restoreDummy(sender, removed.orElseThrow(), "Training dummy removal failed; record and entity are unchanged.");
+            }
+        }); } catch (RuntimeException rejected) { report(null, "training-dummy-response", rejected); }
+    }
+
+    private void restoreDummy(CommandSender sender, games.dmg.fantasystick.training.TrainingDummy removed, String message) {
+        trainingDummies.restore(removed).whenComplete((restored, rollbackFailure) -> {
+            if (rollbackFailure != null) report(null, "training-dummy-rollback", rollbackFailure);
+            if (closed) return;
+            nextTick.accept(() -> {
+                if (rollbackFailure == null) {
+                    var world = server.getWorld(restored.world());
+                    int chunkX = ((int) Math.floor(restored.x())) >> 4, chunkZ = ((int) Math.floor(restored.z())) >> 4;
+                    if (world != null && world.isChunkLoaded(chunkX, chunkZ)) trainingDummyController.reconcile(world.getChunkAt(chunkX, chunkZ));
+                }
+                sender.sendMessage(message);
+            });
+        });
+    }
+
     private void placeRegistrarResponse(org.bukkit.entity.Player player,org.bukkit.Location location,games.dmg.fantasystick.party.PartyRegistrar saved,Throwable failure){if(failure!=null)report(player.getUniqueId(),"party-registrar-place",failure);if(closed)return;try{nextTick.accept(()->{if(closed)return;if(failure!=null){if(player.isOnline())player.sendMessage("Party Registrar placement failed; no registration or entity changed.");return;}try{int chunkX=location.getBlockX()>>4,chunkZ=location.getBlockZ()>>4;if(location.getWorld().isChunkLoaded(chunkX,chunkZ))partyRegistrarController.reconcile(location.getWorld().getChunkAt(chunkX,chunkZ));if(player.isOnline())player.sendMessage("Placed Party Registrar "+saved.id()+".");}catch(RuntimeException entityFailure){report(player.getUniqueId(),"party-registrar-entity",entityFailure);partyRegistrars.remove(saved.id()).whenComplete((ignored,rollbackFailure)->{if(rollbackFailure!=null)report(player.getUniqueId(),"party-registrar-rollback",rollbackFailure);if(closed)return;nextTick.accept(()->{partyRegistrarController.removeLoaded(saved.id());if(player.isOnline())player.sendMessage("Party Registrar placement failed; no registration or entity changed.");});});}});}catch(RuntimeException rejected){report(player.getUniqueId(),"party-registrar-response",rejected);}}
     private void removeRegistrarResponse(CommandSender sender,UUID id,java.util.Optional<games.dmg.fantasystick.party.PartyRegistrar> removed,Throwable failure){if(failure!=null)report(null,"party-registrar-remove",failure);if(closed)return;try{nextTick.accept(()->{if(closed)return;if(failure!=null)sender.sendMessage("Party Registrar removal failed; registration and entity are unchanged.");else if(removed.isEmpty())sender.sendMessage("Party Registrar not found.");else try{partyRegistrarController.removeLoaded(id);sender.sendMessage("Removed Party Registrar "+id+".");}catch(RuntimeException entityFailure){report(null,"party-registrar-entity",entityFailure);partyRegistrars.restore(removed.orElseThrow()).whenComplete((restored,rollbackFailure)->{if(rollbackFailure!=null)report(null,"party-registrar-rollback",rollbackFailure);if(closed)return;nextTick.accept(()->{if(rollbackFailure==null){var world=server.getWorld(restored.world());int chunkX=((int)Math.floor(restored.x()))>>4,chunkZ=((int)Math.floor(restored.z()))>>4;if(world!=null&&world.isChunkLoaded(chunkX,chunkZ))partyRegistrarController.reconcile(world.getChunkAt(chunkX,chunkZ));}sender.sendMessage("Party Registrar removal failed; registration and entity are unchanged.");});});}});}catch(RuntimeException rejected){report(null,"party-registrar-response",rejected);}}
     private void partyRegistrar(CommandSender sender,String[] args){
@@ -534,7 +712,14 @@ public final class EquipmentAdminCommand implements TabExecutor, AutoCloseable {
         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 (partyEconomySettings != null && games.dmg.fantasystick.persistence.PartyEconomySettings.keys().contains(args[1])) { partyEconomyConfiguration(sender,args); return; }
+        if(gearSettings!=null&&games.dmg.fantasystick.persistence.GearSettings.keys().contains(args[1])){gearConfiguration(sender,args);return;}
         if (coinSettings != null && games.dmg.fantasystick.persistence.CoinSettings.keys().contains(args[1])) { coinConfiguration(sender,args); return; }
+        if (hardMobXpSettings != null && args[1].equals(games.dmg.fantasystick.persistence.HardMobXpSettings.KEY)) {
+            hardMobXpConfiguration(sender, args); return;
+        }
+        if (adventureQuestSettings != null && games.dmg.fantasystick.persistence.AdventureQuestSettings.keys().contains(args[1])) {
+            adventureQuestConfiguration(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 (outOfCombatRecoverySettings != null
@@ -600,6 +785,9 @@ public final class EquipmentAdminCommand implements TabExecutor, AutoCloseable {
         if (meteorSettings != null && games.dmg.fantasystick.persistence.MeteorSettings.keys().contains(args[1])) {
             meteorConfiguration(sender, args); return;
         }
+        if (fireballSettings != null && games.dmg.fantasystick.persistence.FireballSettings.keys().contains(args[1])) {
+            fireballConfiguration(sender, args); return;
+        }
         if (frostSettings == null || !games.dmg.fantasystick.persistence.FrostShardSettings.keys().contains(args[1])) {
             configurationUsage(sender); return;
         }
@@ -634,6 +822,33 @@ public final class EquipmentAdminCommand implements TabExecutor, AutoCloseable {
         });
     }
 
+    private void fireballConfiguration(CommandSender sender, String[] args) {
+        String key = args[1];
+        if (args.length == 2) {
+            sender.sendMessage(key + "=" + fireballSettings.value(key) + " (applies to future Fireball casts only)"); return;
+        }
+        java.util.concurrent.CompletionStage<games.dmg.fantasystick.persistence.FireballSettings.Update> operation;
+        try { operation = fireballSettings.set(key, args[2]); }
+        catch (IllegalArgumentException invalid) {
+            sender.sendMessage("Fireball 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 && fireballSettings.publish(saved)) {
+                    fireball.configure(fireballSettings.settings()); abilities.replace(fireball.definition());
+                }
+                if (!sender.hasPermission(PERMISSION)
+                        || sender instanceof org.bukkit.entity.Player player && !player.isOnline()) return;
+                sender.sendMessage(failure == null
+                    ? "Saved " + key + "=" + saved.value() + " for future Fireball casts; active projectiles and deadlines are unchanged."
+                    : "Fireball configuration save failed; the effective setting is unchanged.");
+            }); } catch (RuntimeException rejected) { report(null, "config-response", rejected); }
+        });
+    }
+
     private void outOfCombatRecoveryConfiguration(CommandSender sender, String[] args) {
         String key = args[1];
         if (args.length == 2) {
@@ -1129,8 +1344,44 @@ public final class EquipmentAdminCommand implements TabExecutor, AutoCloseable {
 
     private void partyEconomyConfiguration(CommandSender sender,String[] args){String key=args[1];if(args.length==2){sender.sendMessage(key+"="+partyEconomySettings.value(key)+" (applies to future party transactions only)");return;}java.util.concurrent.CompletionStage<games.dmg.fantasystick.persistence.PartyEconomySettings.Update> operation;try{operation=partyEconomySettings.set(key,args[2]);}catch(IllegalArgumentException invalid){sender.sendMessage("Party price is invalid; enter a whole number from 0 through 2147483647.");return;}operation.whenComplete((saved,failure)->{if(failure!=null)report(null,"config-"+key,failure);if(closed)return;try{nextTick.accept(()->{if(closed)return;boolean applied=failure==null&&partyEconomySettings.publish(saved);if(!sender.hasPermission(PERMISSION)||sender instanceof org.bukkit.entity.Player player&&!player.isOnline())return;if(failure!=null)sender.sendMessage("Party price save failed; the effective price is unchanged.");else if(!applied)sender.sendMessage("Saved request was superseded; effective "+key+"="+partyEconomySettings.value(key)+".");else sender.sendMessage("Saved "+key+"="+saved.value()+" for future party transactions.");});}catch(RuntimeException rejected){report(null,"config-response",rejected);}});}
 
+    private void gearConfiguration(CommandSender sender,String[] args){String key=args[1];if(args.length==2){sender.sendMessage(key+"="+gearSettings.value(key)+" (applies to the next armor restock only)");return;}java.util.concurrent.CompletionStage<games.dmg.fantasystick.persistence.GearSettings.Update> operation;try{operation=gearSettings.set(key,args[2]);}catch(IllegalArgumentException invalid){sender.sendMessage("Armor market setting is invalid; variance is 0–100, prices are nonnegative, and positive stock minima cannot exceed maxima.");return;}operation.whenComplete((saved,failure)->{if(failure!=null)report(null,"config-"+key,failure);if(closed)return;nextTick.accept(()->{boolean applied=failure==null&&gearSettings.publish(saved);if(!sender.hasPermission(PERMISSION)||sender instanceof org.bukkit.entity.Player player&&!player.isOnline())return;if(failure!=null)sender.sendMessage("Armor market setting save failed; effective settings and the current catalog are unchanged.");else if(!applied)sender.sendMessage("Saved request was superseded; effective "+key+"="+gearSettings.value(key)+".");else sender.sendMessage("Saved "+key+"="+saved.value()+" for the next automatic or administrative restock; the current catalog is unchanged.");});});}
+
     private void coinConfiguration(CommandSender sender,String[] args){String key=args[1];if(args.length==2){sender.sendMessage(key+"="+coinSettings.value(key)+" (applies to future creation or defeats only)");return;}java.util.concurrent.CompletionStage<games.dmg.fantasystick.persistence.CoinSettings.Update> operation;try{operation=coinSettings.set(key,args[2]);}catch(IllegalArgumentException invalid){sender.sendMessage("Coin setting is invalid; ranges must be ordered whole numbers from 0 through 2147483647.");return;}operation.whenComplete((saved,failure)->{if(failure!=null)report(null,"config-"+key,failure);if(closed)return;try{nextTick.accept(()->{if(closed)return;boolean applied=failure==null&&coinSettings.publish(saved);if(!sender.hasPermission(PERMISSION)||sender instanceof org.bukkit.entity.Player player&&!player.isOnline())return;if(failure!=null)sender.sendMessage("Coin configuration save failed; effective ranges are unchanged.");else if(!applied)sender.sendMessage("Saved request was superseded; effective "+key+"="+coinSettings.value(key)+".");else sender.sendMessage("Saved "+key+"="+saved.value()+" for future creation or defeats; existing balances and captured rewards are unchanged.");});}catch(RuntimeException rejected){report(null,"config-response",rejected);}});}
 
+    private void hardMobXpConfiguration(CommandSender sender, String[] args) {
+        String key = games.dmg.fantasystick.persistence.HardMobXpSettings.KEY;
+        if (args.length == 2) { sender.sendMessage(key + "=" + hardMobXpSettings.value()
+            + " (applies to future uncaptured Witch defeats only)"); return; }
+        java.util.concurrent.CompletionStage<games.dmg.fantasystick.persistence.HardMobXpSettings.Update> operation;
+        try { operation = hardMobXpSettings.set(args[2]); }
+        catch (IllegalArgumentException invalid) {
+            sender.sendMessage("Hard-mob XP is invalid; enter a whole number from 0 through 2147483647."); return;
+        }
+        operation.whenComplete((saved, failure) -> {
+            if (failure != null) report(null, "config-" + key, failure);
+            if (closed) return;
+            try { nextTick.accept(() -> {
+                if (closed) return;
+                boolean applied = failure == null && hardMobXpSettings.publish(saved);
+                if (applied) combatExperience.configure(combatExperience.rules().withHardPool(saved.pool()));
+                if (!sender.hasPermission(PERMISSION)
+                        || sender instanceof org.bukkit.entity.Player player && !player.isOnline()) return;
+                if (failure != null) sender.sendMessage("Hard-mob XP save failed; the effective pool is unchanged.");
+                else if (!applied) sender.sendMessage("Saved request was superseded; effective " + key + "="
+                    + hardMobXpSettings.value() + ".");
+                else sender.sendMessage("Saved " + key + "=" + saved.value()
+                    + " for future uncaptured Witch defeats; existing progress and captured rewards are unchanged.");
+            }); } catch (RuntimeException rejected) { report(null, "config-response", rejected); }
+        });
+    }
+
+    private void adventureQuestConfiguration(CommandSender sender, String[] args) {
+        String key=args[1]; if(args.length==2){sender.sendMessage(key+"="+adventureQuestSettings.value(key)+" (applies to the owning later catalog, acceptance or encounter attempt)");return;}
+        java.util.concurrent.CompletionStage<games.dmg.fantasystick.persistence.AdventureQuestSettings.Update> operation;
+        try{operation=adventureQuestSettings.set(key,args[2]);}catch(IllegalArgumentException invalid){sender.sendMessage("Adventure quest 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;boolean applied=failure==null&&adventureQuestSettings.publish(saved);if(!sender.hasPermission(PERMISSION)||sender instanceof org.bukkit.entity.Player player&&!player.isOnline())return;if(failure!=null)sender.sendMessage("Adventure quest configuration save failed; effective values are unchanged.");else if(!applied)sender.sendMessage("Saved request was superseded; effective "+key+"="+adventureQuestSettings.value(key)+".");else sender.sendMessage("Saved "+key+"="+saved.value()+" for later catalogs, acceptances or attempts; active state is unchanged.");});}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);}});}
@@ -1173,9 +1424,24 @@ public final class EquipmentAdminCommand implements TabExecutor, AutoCloseable {
 
     // 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 (closed) return List.of();
+        if (adventureQuestCommands != null) {
+            if (args.length == 1 && !sender.hasPermission(PERMISSION)) return matching(List.of("adventure"), args[0]);
+            if (args.length > 1) {
+                var adventure = adventureQuestCommands.complete(sender,args); if(!adventure.isEmpty()) return adventure;
+                if(args[0].equals("adventure")||args[0].equals("adventure-site")||args[0].equals("quest-giver"))return List.of();
+            }
+        }
+        if (!sender.hasPermission(PERMISSION)) return List.of();
         if (args.length == 1) return matching(sender instanceof org.bukkit.entity.Player
-            ? List.of("config", "experience", "give", "inspect", "party-registrar", "recover", "revive") : List.of("config", "experience", "give", "inspect", "party-registrar", "recover"), args[0]);
+            ? List.of("adventure", "adventure-site", "config", "experience", "give", "inspect", "party-registrar", "quest-giver", "recover", "revive", "shop", "training-dummy")
+            : List.of("adventure-site", "config", "experience", "give", "inspect", "party-registrar", "quest-giver", "recover", "shop", "training-dummy"), args[0]);
+        if(args.length==2&&args[0].equals("shop"))return matching(sender instanceof org.bukkit.entity.Player?List.of("list","place","remove","restock"):List.of("list","remove","restock"),args[1]);
+        if(args.length==3&&args[0].equals("shop")&&args[1].equals("remove")&&armorers!=null)return matching(armorers.all().stream().map(value->value.id().toString()).toList(),args[2]);
+        if (args.length == 2 && args[0].equals("training-dummy")) return matching(
+            sender instanceof org.bukkit.entity.Player ? List.of("list", "place", "remove") : List.of("list", "remove"), args[1]);
+        if (args.length == 3 && args[0].equals("training-dummy") && args[1].equals("remove") && trainingDummies != null)
+            return matching(trainingDummies.all().stream().map(value -> value.id().toString()).toList(), args[2]);
         if (args.length == 2 && args[0].equals("party-registrar")) return matching(
             sender instanceof org.bukkit.entity.Player ? List.of("list","place","remove") : List.of("list","remove"),args[1]);
         if (args.length == 3 && args[0].equals("party-registrar") && args[1].equals("remove") && partyRegistrars!=null)
@@ -1190,11 +1456,15 @@ public final class EquipmentAdminCommand implements TabExecutor, AutoCloseable {
         if (args.length == 2 && args[0].equals("config")) {
             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.PartyEconomySettings.keys());
+            keys.addAll(games.dmg.fantasystick.persistence.GearSettings.keys());
             keys.addAll(games.dmg.fantasystick.persistence.CoinSettings.keys());
+            keys.add(games.dmg.fantasystick.persistence.HardMobXpSettings.KEY);
+            keys.addAll(games.dmg.fantasystick.persistence.AdventureQuestSettings.keys());
             keys.addAll(games.dmg.fantasystick.persistence.OutOfCombatRecoverySettings.keys());
             keys.add(games.dmg.fantasystick.persistence.QuickerRegenerationSettings.KEY);
             keys.add(games.dmg.fantasystick.persistence.QuickerRegenerationIISettings.KEY);
             keys.add(games.dmg.fantasystick.persistence.HealthStealSettings.KEY);
+            keys.addAll(games.dmg.fantasystick.persistence.FireballSettings.keys());
             keys.addAll(games.dmg.fantasystick.persistence.FrostShardSettings.keys());
             keys.addAll(games.dmg.fantasystick.persistence.LongbowSettings.keys());
             keys.addAll(games.dmg.fantasystick.persistence.QuickstepSettings.keys());
@@ -1221,7 +1491,13 @@ public final class EquipmentAdminCommand implements TabExecutor, AutoCloseable {
             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(partyEconomySettings!=null&&games.dmg.fantasystick.persistence.PartyEconomySettings.keys().contains(args[1])){String current=partyEconomySettings.value(args[1]);String defaults=games.dmg.fantasystick.persistence.PartyEconomySettings.defaultValue(args[1]);return matching(current.equals(defaults)?List.of(current):List.of(current,defaults),args[2]);}
+            if(gearSettings!=null&&games.dmg.fantasystick.persistence.GearSettings.keys().contains(args[1])){String current=gearSettings.value(args[1]);String defaults=games.dmg.fantasystick.persistence.GearSettings.defaultValue(args[1]);return matching(current.equals(defaults)?List.of(current):List.of(current,defaults),args[2]);}
             if(coinSettings!=null&&games.dmg.fantasystick.persistence.CoinSettings.keys().contains(args[1])){String current=coinSettings.value(args[1]);String defaults=games.dmg.fantasystick.persistence.CoinSettings.defaultValue(args[1]);return matching(current.equals(defaults)?List.of(current):List.of(current,defaults),args[2]);}
+            if (hardMobXpSettings != null && args[1].equals(games.dmg.fantasystick.persistence.HardMobXpSettings.KEY)) {
+                String current = hardMobXpSettings.value(); String defaults = games.dmg.fantasystick.persistence.HardMobXpSettings.DEFAULT;
+                return matching(current.equals(defaults) ? List.of(current) : List.of(current, defaults), args[2]);
+            }
+            if(adventureQuestSettings!=null&&games.dmg.fantasystick.persistence.AdventureQuestSettings.keys().contains(args[1])){String current=adventureQuestSettings.value(args[1]);String defaults=games.dmg.fantasystick.persistence.AdventureQuestSettings.defaultValue(args[1]);return matching(current.equals(defaults)?List.of(current):List.of(current,defaults),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 (outOfCombatRecoverySettings != null
                     && games.dmg.fantasystick.persistence.OutOfCombatRecoverySettings.keys().contains(args[1])) {
@@ -1246,6 +1522,11 @@ public final class EquipmentAdminCommand implements TabExecutor, AutoCloseable {
                 return matching(current.equals(games.dmg.fantasystick.persistence.HealthStealSettings.DEFAULT)
                     ? List.of(current) : List.of(current, games.dmg.fantasystick.persistence.HealthStealSettings.DEFAULT), args[2]);
             }
+            if (fireballSettings != null && games.dmg.fantasystick.persistence.FireballSettings.keys().contains(args[1])) {
+                String current = fireballSettings.value(args[1]);
+                String defaults = games.dmg.fantasystick.persistence.FireballSettings.defaultValue(args[1]);
+                return matching(current.equals(defaults) ? List.of(current) : List.of(current, defaults), 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]);

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

@@ -4,6 +4,7 @@ import games.dmg.fantasystick.crafting.ManualDropDelivery;
 import games.dmg.fantasystick.crafting.PlayerSheetDrops;
 import games.dmg.fantasystick.items.CharacterSheets;
 import games.dmg.fantasystick.items.EquipmentStorage;
+import games.dmg.fantasystick.items.GearItems;
 import games.dmg.fantasystick.items.SessionControls;
 import io.papermc.paper.event.player.PlayerInventorySlotChangeEvent;
 import java.util.Arrays;
@@ -41,6 +42,7 @@ public final class EquipmentSessionEvents implements Listener, AutoCloseable {
     private final Consumer<EquipmentSessions.Failure> diagnostics;
     private final CharacterSheets sheets = new CharacterSheets();
     private SessionControls controls = new SessionControls();
+    private GearItems gear;
     private static final class Intent { boolean started; }
     private final Map<UUID, Intent> swaps = new HashMap<>();
     private final Map<UUID, UUID> observed = new HashMap<>();
@@ -71,6 +73,7 @@ public final class EquipmentSessionEvents implements Listener, AutoCloseable {
     }
     private boolean closed;
     private Consumer<ControlInput> inputs = ignored -> { };
+    private java.util.function.Predicate<org.bukkit.entity.Entity> managedInteractionTarget = ignored -> false;
     private record Draw(Player player, ItemStack item, EquipmentSessions.SelectedControl selected) { }
     private final Map<UUID, Draw> draws = new HashMap<>();
 
@@ -94,6 +97,13 @@ public final class EquipmentSessionEvents implements Listener, AutoCloseable {
         controls = new SessionControls(Objects.requireNonNull(registry));
     }
 
+    public void attachGear(GearItems gear){if(closed||this.gear!=null)throw new IllegalStateException("Gear already attached or events closed");this.gear=Objects.requireNonNull(gear);}
+
+    public void attachManagedInteractionTarget(java.util.function.Predicate<org.bukkit.entity.Entity> target) {
+        if (closed) throw new IllegalStateException("Events closed");
+        managedInteractionTarget = Objects.requireNonNull(target);
+    }
+
     /** The input recipient belongs to this plugin; it does not authorize vanilla item use. */
     public EquipmentSessionEvents(EquipmentSessions sessions, Consumer<Runnable> nextTick,
                                   Consumer<EquipmentSessions.Failure> diagnostics, Consumer<ControlInput> inputs) {
@@ -343,6 +353,7 @@ 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 && !selected.ability().isEmpty() && doorInteraction(event)) return;
             if (selected != null && useGesture(selected)) {
                 org.bukkit.entity.Entity target = selected.ability().equals("hex")
                         || selected.ability().equals("mending_light")
@@ -357,6 +368,12 @@ public final class EquipmentSessionEvents implements Listener, AutoCloseable {
         }
     }
 
+    private boolean doorInteraction(org.bukkit.event.player.PlayerInteractEvent event) {
+        var block = event.getClickedBlock();
+        return event.getAction() == org.bukkit.event.block.Action.RIGHT_CLICK_BLOCK && block != null
+            && block.getBlockData() instanceof org.bukkit.block.data.type.Door;
+    }
+
     private void beginDraw(Player player, ItemStack item, EquipmentSessions.SelectedControl selected) {
         UUID owner = player.getUniqueId();
         if (closed || draws.containsKey(owner) || player.hasActiveItem()) return;
@@ -436,6 +453,7 @@ public final class EquipmentSessionEvents implements Listener, AutoCloseable {
 
     @EventHandler(priority = EventPriority.HIGHEST, ignoreCancelled = true)
     public void useEntity(org.bukkit.event.player.PlayerInteractEntityEvent event) {
+        if (managedInteractionTarget.test(event.getRightClicked())) return;
         var player = event.getPlayer();
         var item = player.getInventory().getItem(event.getHand());
         if (special(item)) event.setCancelled(true);
@@ -570,7 +588,7 @@ public final class EquipmentSessionEvents implements Listener, AutoCloseable {
 
     private boolean active(Player player) { return sessions.active(player.getUniqueId()).isPresent(); }
     private boolean control(ItemStack item) { return pickupClaim(item, "control_move_") || controls.identify(item).isPresent(); }
-    private boolean special(ItemStack item) { return control(item) || box(item) != null; }
+    private boolean special(ItemStack item) { return control(item) || box(item) != null || gear != null && gear.gear(item); }
     private static boolean ownInventory(Player player, Inventory inventory) {
         return inventory instanceof PlayerInventory && inventory.equals(player.getInventory());
     }

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

@@ -2,6 +2,7 @@ package games.dmg.fantasystick.session;
 
 import games.dmg.fantasystick.items.CharacterSheets;
 import games.dmg.fantasystick.items.EquipmentStorage;
+import games.dmg.fantasystick.items.GearItems;
 import games.dmg.fantasystick.items.SessionControls;
 import games.dmg.fantasystick.persistence.CharacterRecord;
 import games.dmg.fantasystick.persistence.CharacterStorage;
@@ -53,6 +54,7 @@ public final class EquipmentSessions implements AutoCloseable {
     private final SessionClaims claims = new SessionClaims();
     private final EquipmentStorage equipment = new EquipmentStorage();
     private SessionControls controls;
+    private GearItems gear;
     private final CharacterSheets sheets = new CharacterSheets();
     private final Map<UUID, Attempt> pending = new HashMap<>();
     private final Map<UUID, Attempt> owned = new HashMap<>();
@@ -155,6 +157,8 @@ public final class EquipmentSessions implements AutoCloseable {
     }
 
     /** Install before exposing entry so later checks/exits capture the acknowledged live policy. */
+    public synchronized void attachGear(GearItems gear){if(closed||this.gear!=null)throw new IllegalStateException("Gear already attached or sessions closed");this.gear=Objects.requireNonNull(gear);}
+
     public synchronized void attachSwitchDelay(Supplier<Duration> policy) {
         if (!owned.isEmpty()) throw new IllegalStateException("Sessions already started");
         switchDelay = Objects.requireNonNull(policy);
@@ -282,8 +286,9 @@ public final class EquipmentSessions implements AutoCloseable {
         var previous = attempt.record;
         if (vitals != null) vitals.updateProgress(attempt.player, attempt.session, previous, saved);
         attempt.record = saved; // Persisted truth precedes any reentrant native presentation setter.
-        if ((!previous.loadout().equals(saved.loadout()) || !previous.cooldowns().equals(saved.cooldowns()))
-                && !refreshControls(attempt, session)) return false;
+        if(gear!=null&&!previous.gear().equals(saved.gear()))gear.install(attempt.player.getInventory(),saved,attempt.owner,attempt.session);
+        if ((!previous.loadout().equals(saved.loadout()) || !previous.cooldowns().equals(saved.cooldowns())
+                || !previous.passives().equals(saved.passives())) && !refreshControls(attempt, session)) return false;
         return true;
     }
 
@@ -312,7 +317,7 @@ public final class EquipmentSessions implements AutoCloseable {
     private boolean refreshControls(Attempt attempt, Active session) {
         var refreshed = controls.create(attempt.record, attempt.owner, attempt.session);
         boolean changed = false;
-        for (int slot = 2; slot < 9; slot++) {
+        for (int slot = 1; slot < 9; slot++) {
             if (active.get(attempt.owner) != attempt || !current(session)) return false;
             if (Objects.equals(attempt.player.getInventory().getItem(slot), refreshed[slot])) continue;
             attempt.player.getInventory().setItem(slot, refreshed[slot]);
@@ -426,7 +431,7 @@ public final class EquipmentSessions implements AutoCloseable {
         // Even malformed/foreign remnants are unsafe to pack as ordinary equipment.
         return item.getItemMeta().getPersistentDataContainer().getKeys().stream().anyMatch(key ->
             key.getNamespace().equals("fantasystick")
-                && (key.getKey().startsWith("storage_") || key.getKey().startsWith("control_")));
+                && (key.getKey().startsWith("storage_") || key.getKey().startsWith("control_") || key.getKey().startsWith("character_gear")));
     }
 
     private synchronized void loaded(Attempt attempt, Loaded loaded, Throwable failure) {
@@ -521,6 +526,7 @@ public final class EquipmentSessions implements AutoCloseable {
                 attempt.player.getInventory().setItem(slot, items[slot]);
                 if (interrupted(attempt)) return;
             }
+            if(gear!=null)gear.install(attempt.player.getInventory(),record,attempt.owner,attempt.session);
             mark(attempt, EquipmentSessionMarker.Phase.PACKED);
             if (vitals != null) {
                 attempt.vitalsStarted = true;
@@ -792,7 +798,7 @@ public final class EquipmentSessions implements AutoCloseable {
         }
         mark(attempt, EquipmentSessionMarker.Phase.RESTORING);
         var result = equipment.restore(attempt.player.getInventory(), attempt.owner, attempt.session,
-            item -> controls.owned(item, attempt.owner, attempt.session),
+            item -> controls.owned(item, attempt.owner, attempt.session)||(gear!=null&&gear.owned(item,attempt.owner,attempt.session)),
             attempt.player.getItemOnCursor(), attempt.player::setItemOnCursor);
         // Returned refusals are read-only. Exceptions must retain the ambiguous RESTORING phase.
         mark(attempt, result == EquipmentStorage.RestoreResult.RESTORED

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

@@ -0,0 +1,68 @@
+package games.dmg.fantasystick.session;
+
+import games.dmg.fantasystick.persistence.PlayerFeedbackPreferences;
+import java.util.List;
+import java.util.Locale;
+import java.util.Objects;
+import java.util.function.Consumer;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandSender;
+import org.bukkit.command.TabExecutor;
+import org.bukkit.entity.Player;
+
+/** Ordinary-player command for one durable account-owned routine effect-feedback switch. */
+public final class FantasyFeedbackCommand implements TabExecutor, AutoCloseable {
+    private final PlayerFeedbackPreferences preferences;
+    private final Consumer<Runnable> nextTick;
+    private final Consumer<Throwable> failures;
+    private boolean closed;
+
+    public FantasyFeedbackCommand(PlayerFeedbackPreferences preferences, Consumer<Runnable> nextTick,
+                                  Consumer<Throwable> failures) {
+        this.preferences = Objects.requireNonNull(preferences);
+        this.nextTick = Objects.requireNonNull(nextTick);
+        this.failures = Objects.requireNonNull(failures);
+    }
+
+    @Override public boolean onCommand(CommandSender sender, Command command, String label, String[] args) {
+        if (!(sender instanceof Player player)) {
+            sender.sendMessage("Fantasy feedback is a player-account preference.");
+            return true;
+        }
+        if (args.length == 0) {
+            player.sendMessage("Fantasy feedback is " + state(preferences.enabled(player.getUniqueId())) + ".");
+            return true;
+        }
+        if (args.length != 1 || !(args[0].equals("on") || args[0].equals("off"))) return false;
+        boolean enabled = args[0].equals("on");
+        var account = player.getUniqueId();
+        preferences.set(account, enabled).whenComplete((saved, failure) -> {
+            if (failure != null) report(failure);
+            try {
+                nextTick.accept(() -> {
+                    if (closed) return;
+                    if (failure != null) {
+                        if (player.isOnline()) player.sendMessage(
+                            "Fantasy feedback preference could not be saved; it remains "
+                                + state(preferences.enabled(account)) + ".");
+                        return;
+                    }
+                    boolean published = preferences.publish(saved);
+                    if (player.isOnline()) player.sendMessage("Fantasy feedback is "
+                        + (published ? "now " : "already ") + state(preferences.enabled(account)) + ".");
+                });
+            } catch (RuntimeException rejected) { report(rejected); }
+        });
+        return true;
+    }
+
+    @Override public List<String> onTabComplete(CommandSender sender, Command command, String alias, String[] args) {
+        if (!(sender instanceof Player) || args.length != 1) return List.of();
+        String prefix = args[0].toLowerCase(Locale.ROOT);
+        return List.of("off", "on").stream().filter(value -> value.startsWith(prefix)).toList();
+    }
+
+    private static String state(boolean enabled) { return enabled ? "on" : "off"; }
+    private void report(Throwable failure) { try { failures.accept(failure); } catch (RuntimeException ignored) { } }
+    @Override public void close() { closed = true; }
+}

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

@@ -1,6 +1,8 @@
 package games.dmg.fantasystick.session;
 
+import games.dmg.fantasystick.ability.AbilityReport;
 import games.dmg.fantasystick.party.CombatSources;
+import games.dmg.fantasystick.presentation.CombatFeedback;
 import games.dmg.fantasystick.persistence.CharacterRecord;
 import games.dmg.fantasystick.persistence.CharacterStorage;
 import java.math.BigDecimal;
@@ -38,7 +40,7 @@ public final class OutOfCombatRecovery implements Listener, AutoCloseable {
             }
         }
         public static Settings defaults() {
-            return new Settings(Duration.ofSeconds(30), Duration.ofSeconds(10), BigInteger.ONE);
+            return new Settings(Duration.ofSeconds(10), Duration.ofSeconds(10), BigInteger.ONE);
         }
     }
 
@@ -61,6 +63,7 @@ public final class OutOfCombatRecovery implements Listener, AutoCloseable {
     private final Consumer<EntityRegainHealthEvent> healingEvents;
     private final Supplier<BigDecimal> nativeLimit;
     private final Consumer<Failure> failures;
+    private final CombatFeedback feedback;
     private final CombatSources sources;
     private java.util.function.Function<CharacterRecord, BigInteger> bonusHealing = ignored -> BigInteger.ZERO;
     private final Map<UUID, State> states = new HashMap<>();
@@ -73,11 +76,17 @@ public final class OutOfCombatRecovery implements Listener, AutoCloseable {
     public OutOfCombatRecovery(Settings settings, CharacterStorage characters, EquipmentSessions sessions, Clock clock,
             Consumer<Runnable> nextTick, Consumer<EntityRegainHealthEvent> healingEvents,
             Supplier<BigDecimal> nativeLimit, Consumer<Failure> failures) {
+        this(settings, characters, sessions, clock, nextTick, healingEvents, nativeLimit, failures, null);
+    }
+
+    public OutOfCombatRecovery(Settings settings, CharacterStorage characters, EquipmentSessions sessions, Clock clock,
+            Consumer<Runnable> nextTick, Consumer<EntityRegainHealthEvent> healingEvents,
+            Supplier<BigDecimal> nativeLimit, Consumer<Failure> failures, CombatFeedback feedback) {
         this.settings = Objects.requireNonNull(settings); this.characters = Objects.requireNonNull(characters);
         this.sessions = Objects.requireNonNull(sessions); this.clock = Objects.requireNonNull(clock);
         this.nextTick = Objects.requireNonNull(nextTick); this.healingEvents = Objects.requireNonNull(healingEvents);
         this.nativeLimit = Objects.requireNonNull(nativeLimit); this.failures = Objects.requireNonNull(failures);
-        sources = new CombatSources(sessions);
+        this.feedback = feedback; sources = new CombatSources(sessions);
     }
 
     public void configure(Settings value) { settings = Objects.requireNonNull(value); }
@@ -225,6 +234,8 @@ public final class OutOfCombatRecovery implements Listener, AutoCloseable {
         double publish = Math.min(maximum, persisted.health().doubleValue());
         if (!Double.isFinite(maximum) || !Double.isFinite(publish) || publish <= nativeBefore) return;
         player.setHealth(publish);
+        if (feedback != null) feedback.report("Out-of-Combat Recovery", player, AbilityReport.Type.HEALING, player,
+            BigDecimal.valueOf(publish - nativeBefore).stripTrailingZeros());
     }
 
     private void remove(UUID owner) {

src/main/java/games/dmg/fantasystick/shop/ArmorCatalog.java

@@ -0,0 +1,85 @@
+package games.dmg.fantasystick.shop;
+
+import games.dmg.fantasystick.persistence.GearSlot;
+import games.dmg.fantasystick.persistence.GearTier;
+import java.math.BigInteger;
+import java.time.Instant;
+import java.time.LocalDate;
+import java.util.*;
+
+/** One acknowledged server-wide generation shared by every Fantasy Armorer. */
+public record ArmorCatalog(LocalDate day, UUID revision, Instant refreshedAt, RefreshReason reason,
+                           Map<ArmorProduct, Offer> products, Map<UUID, Transaction> transactions) {
+    public enum RefreshReason { STARTUP, SCHEDULED, ADMINISTRATIVE }
+    public enum TransactionState { RESERVED, CONSUMED, CANCELLED }
+    public record Offer(BigInteger price, int remaining) {
+        public Offer {
+            Objects.requireNonNull(price);
+            if (price.signum() <= 0 || remaining < 0) throw new IllegalArgumentException("Invalid catalog offer");
+        }
+    }
+    public record Transaction(ArmorProduct product, TransactionState state) {
+        public Transaction { Objects.requireNonNull(product); Objects.requireNonNull(state); }
+    }
+
+    public ArmorCatalog(LocalDate day, UUID revision, Instant refreshedAt, RefreshReason reason,
+                        Map<ArmorProduct, Offer> products) {
+        this(day, revision, refreshedAt, reason, products, Map.of());
+    }
+
+    public ArmorCatalog {
+        Objects.requireNonNull(day);
+        Objects.requireNonNull(revision);
+        Objects.requireNonNull(refreshedAt);
+        Objects.requireNonNull(reason);
+        products = Map.copyOf(products);
+        transactions = Map.copyOf(transactions);
+        var expected = new HashSet<ArmorProduct>();
+        for (var slot : GearSlot.values()) for (var tier : GearTier.values())
+            if (tier != GearTier.NONE) expected.add(new ArmorProduct(slot,tier));
+        if (!products.keySet().equals(expected)) throw new IllegalArgumentException("Catalog must contain all 18 products");
+    }
+
+    public Offer offer(ArmorProduct product) {
+        var offer = products.get(Objects.requireNonNull(product));
+        if (offer == null) throw new IllegalArgumentException("Product is absent from catalog");
+        return offer;
+    }
+
+    public ArmorCatalog reserve(UUID operation, ArmorProduct product) {
+        Objects.requireNonNull(operation);
+        var existing=transactions.get(operation);
+        if(existing!=null) {
+            if(!existing.product().equals(product))throw new IllegalArgumentException("Operation identity collision");
+            return this;
+        }
+        var offer=offer(product);
+        if(offer.remaining()==0)throw new IllegalStateException("Product is sold out");
+        var nextProducts=new LinkedHashMap<>(products);
+        nextProducts.put(product,new Offer(offer.price(),offer.remaining()-1));
+        var nextTransactions=new LinkedHashMap<>(transactions);
+        nextTransactions.put(operation,new Transaction(product,TransactionState.RESERVED));
+        return new ArmorCatalog(day,revision,refreshedAt,reason,nextProducts,nextTransactions);
+    }
+
+    public ArmorCatalog settle(UUID operation, boolean consumed) {
+        var transaction=transactions.get(Objects.requireNonNull(operation));
+        if(transaction==null)return this;
+        if(transaction.state()!=TransactionState.RESERVED)return this;
+        var nextProducts=new LinkedHashMap<>(products);
+        if(!consumed) {
+            var offer=offer(transaction.product());
+            nextProducts.put(transaction.product(),new Offer(offer.price(),Math.addExact(offer.remaining(),1)));
+        }
+        var nextTransactions=new LinkedHashMap<>(transactions);
+        nextTransactions.put(operation,new Transaction(transaction.product(),
+            consumed?TransactionState.CONSUMED:TransactionState.CANCELLED));
+        return new ArmorCatalog(day,revision,refreshedAt,reason,nextProducts,nextTransactions);
+    }
+
+    public ArmorCatalog prune(UUID operation) {
+        if(!transactions.containsKey(operation))return this;
+        var next=new LinkedHashMap<>(transactions); next.remove(operation);
+        return new ArmorCatalog(day,revision,refreshedAt,reason,products,next);
+    }
+}

src/main/java/games/dmg/fantasystick/shop/ArmorCatalogGenerator.java

@@ -0,0 +1,45 @@
+package games.dmg.fantasystick.shop;
+
+import games.dmg.fantasystick.persistence.GearSlot;
+import games.dmg.fantasystick.persistence.GearTier;
+import java.math.BigInteger;
+import java.time.Instant;
+import java.time.LocalDate;
+import java.util.LinkedHashMap;
+import java.util.Objects;
+import java.util.UUID;
+
+/** Exact integer catalog generation without floating-point price drift. */
+public final class ArmorCatalogGenerator {
+    @FunctionalInterface public interface InclusiveRoll { int roll(int minimum, int maximum); }
+    private static final BigInteger BASIS_POINTS = BigInteger.valueOf(10_000);
+
+    private ArmorCatalogGenerator() { }
+
+    public static ArmorCatalog generate(LocalDate day, Instant refreshedAt, ArmorCatalog.RefreshReason reason,
+                                        ArmorMarketRules rules, InclusiveRoll random) {
+        Objects.requireNonNull(rules);
+        Objects.requireNonNull(random);
+        var products = new LinkedHashMap<ArmorProduct, ArmorCatalog.Offer>();
+        for (var slot : GearSlot.values()) {
+            for (var tier : GearTier.values()) {
+                if (tier == GearTier.NONE) continue;
+                int spread = Math.multiplyExact(100, rules.variancePercent());
+                int offset = checked(random, -spread, spread);
+                var numerator = rules.basePrices().get(tier).multiply(BigInteger.valueOf(10_000L + offset));
+                var division = numerator.divideAndRemainder(BASIS_POINTS);
+                var price = division[0].add(division[1].signum() == 0 ? BigInteger.ZERO : BigInteger.ONE).max(BigInteger.ONE);
+                var range = rules.stock().get(tier);
+                int remaining = checked(random, range.minimum(), range.maximum());
+                products.put(new ArmorProduct(slot, tier), new ArmorCatalog.Offer(price, remaining));
+            }
+        }
+        return new ArmorCatalog(day, UUID.randomUUID(), refreshedAt, reason, products);
+    }
+
+    private static int checked(InclusiveRoll random, int minimum, int maximum) {
+        int result = random.roll(minimum, maximum);
+        if (result < minimum || result > maximum) throw new IllegalArgumentException("Random roll outside requested range");
+        return result;
+    }
+}

src/main/java/games/dmg/fantasystick/shop/ArmorMarket.java

@@ -0,0 +1,163 @@
+package games.dmg.fantasystick.shop;
+
+import games.dmg.fantasystick.persistence.*;
+import java.io.IOException;
+import java.time.*;
+import java.util.*;
+import java.util.concurrent.*;
+import java.util.function.Consumer;
+import java.util.function.Supplier;
+
+/** Serialized durable authority for the one shared daily armor catalog. */
+public final class ArmorMarket implements AutoCloseable {
+    public enum PurchaseStatus { APPLIED, SOLD_OUT, STALE, INSUFFICIENT, NOT_UPGRADE, UNAVAILABLE, FAILED }
+    public record PurchaseOutcome(PurchaseStatus status, Optional<CharacterRecord> record, ArmorCatalog catalog) {
+        public PurchaseOutcome { Objects.requireNonNull(status); Objects.requireNonNull(record); Objects.requireNonNull(catalog); }
+    }
+
+    private final ArmorCatalogRepository catalogs;
+    private final ArmorPurchaseOperationStore operations;
+    private final CharacterStorage characters;
+    private final Supplier<ArmorMarketRules> rules;
+    private final Clock clock;
+    private final ArmorCatalogGenerator.InclusiveRoll random;
+    private final ExecutorService worker=Executors.newSingleThreadExecutor(r->new Thread(r,"fantasy-armor-market"));
+    private final CompletionStage<Void> readiness;
+    private volatile ArmorCatalog snapshot;
+    private volatile boolean initialized;
+    private volatile Consumer<ArmorCatalog> listener=ignored->{};
+    private boolean closed,operationsClosing;
+    private int pending;
+    private final CompletableFuture<Void> drained=new CompletableFuture<>();
+
+    public ArmorMarket(ArmorCatalogRepository catalogs, ArmorPurchaseOperationStore operations,
+                       CharacterStorage characters, Supplier<ArmorMarketRules> rules, Clock clock,
+                       ArmorCatalogGenerator.InclusiveRoll random) {
+        this.catalogs=Objects.requireNonNull(catalogs);this.operations=Objects.requireNonNull(operations);
+        this.characters=Objects.requireNonNull(characters);this.rules=Objects.requireNonNull(rules);
+        this.clock=Objects.requireNonNull(clock);this.random=Objects.requireNonNull(random);
+        readiness=submit(()->{initialize();return null;});
+    }
+
+    public void attachListener(Consumer<ArmorCatalog> listener){this.listener=Objects.requireNonNull(listener);}
+    public Optional<ArmorCatalog> snapshot(){return Optional.ofNullable(snapshot);}
+    public Instant now(){return clock.instant();}
+    public CompletionStage<Void> ready(){return readiness;}
+    public CompletionStage<ArmorCatalog> current(){return readiness.thenCompose(ignored->submit(()->ensureCurrent(ArmorCatalog.RefreshReason.SCHEDULED)));}
+    public CompletionStage<ArmorCatalog> restock(){return readiness.thenCompose(ignored->submit(()->{
+        var current=ensureCurrent(ArmorCatalog.RefreshReason.SCHEDULED);
+        if(!current.transactions().isEmpty())throw new IOException("Armor purchases are unresolved");
+        var generated=ArmorCatalogGenerator.generate(LocalDate.now(clock.withZone(ZoneOffset.UTC)),
+            clock.instant().truncatedTo(java.time.temporal.ChronoUnit.SECONDS),
+            ArmorCatalog.RefreshReason.ADMINISTRATIVE,rules.get(),random);
+        persist(generated,true);return generated;
+    }));}
+    public static Instant nextScheduledRestock(Instant now){return Objects.requireNonNull(now).atZone(ZoneOffset.UTC)
+        .toLocalDate().plusDays(1).atStartOfDay(ZoneOffset.UTC).toInstant();}
+    public CompletionStage<PurchaseOutcome> purchase(UUID character, java.math.BigInteger expectedCharacterRevision,
+                                                      UUID expectedCatalogRevision, ArmorProduct product) {
+        Objects.requireNonNull(character);Objects.requireNonNull(expectedCharacterRevision);
+        Objects.requireNonNull(expectedCatalogRevision);Objects.requireNonNull(product);
+        return readiness.thenCompose(ignored->submit(()->purchaseBlocking(character,expectedCharacterRevision,
+            expectedCatalogRevision,product)));
+    }
+
+    private void initialize() throws Exception {
+        snapshot=catalogs.load().orElse(null);
+        var plans=operations.load().toCompletableFuture().join();
+        if(snapshot==null&&!plans.isEmpty())throw new IOException("Armor catalog is missing for pending purchases");
+        for(var plan:plans)execute(plan);
+        if(snapshot!=null&&!snapshot.transactions().isEmpty()) {
+            var next=snapshot;
+            for(var entry:snapshot.transactions().entrySet()) {
+                if(entry.getValue().state()==ArmorCatalog.TransactionState.RESERVED)
+                    throw new IOException("Orphan reserved armor purchase "+entry.getKey());
+                next=next.prune(entry.getKey());
+            }
+            persist(next,false);
+        }
+        ensureCurrent(ArmorCatalog.RefreshReason.STARTUP);
+        initialized=true;
+    }
+
+    private PurchaseOutcome purchaseBlocking(UUID character,java.math.BigInteger expectedCharacterRevision,
+                                               UUID expectedCatalogRevision,ArmorProduct product)throws Exception {
+        var catalog=ensureCurrent(ArmorCatalog.RefreshReason.SCHEDULED);
+        if(!catalog.transactions().isEmpty())return new PurchaseOutcome(PurchaseStatus.FAILED,Optional.empty(),catalog);
+        if(!catalog.revision().equals(expectedCatalogRevision))
+            return new PurchaseOutcome(PurchaseStatus.STALE,Optional.empty(),catalog);
+        var offer=catalog.offer(product);
+        if(offer.remaining()==0)return new PurchaseOutcome(PurchaseStatus.SOLD_OUT,Optional.empty(),catalog);
+        var plan=new ArmorPurchaseOperationStore.Plan(UUID.randomUUID(),character,expectedCharacterRevision,
+            catalog.revision(),product,offer.price());
+        operations.prepare(plan).toCompletableFuture().join();
+        return execute(plan);
+    }
+
+    private PurchaseOutcome execute(ArmorPurchaseOperationStore.Plan plan)throws Exception {
+        var catalog=Objects.requireNonNull(snapshot,"Armor catalog unavailable");
+        if(!catalog.revision().equals(plan.catalogRevision()))
+            throw new IOException("Pending armor purchase belongs to another catalog revision");
+        var transaction=catalog.transactions().get(plan.id());
+        if(transaction==null) {
+            try { catalog=catalog.reserve(plan.id(),plan.product()); }
+            catch(IllegalStateException soldOut) {
+                operations.complete(plan.id()).toCompletableFuture().join();
+                return new PurchaseOutcome(PurchaseStatus.SOLD_OUT,Optional.empty(),catalog);
+            }
+            persist(catalog,false);
+            transaction=catalog.transactions().get(plan.id());
+        }
+        if(!transaction.product().equals(plan.product()))throw new IOException("Armor reservation product mismatch");
+        if(transaction.state()!=ArmorCatalog.TransactionState.RESERVED) {
+            operations.complete(plan.id()).toCompletableFuture().join();
+            var pruned=catalog.prune(plan.id());persist(pruned,false);
+            var record=characters.find(plan.character()).join();
+            return new PurchaseOutcome(transaction.state()==ArmorCatalog.TransactionState.CONSUMED
+                ?PurchaseStatus.APPLIED:PurchaseStatus.FAILED,record,pruned);
+        }
+        CharacterStorage.GearPurchase purchase;
+        try {
+            purchase=characters.purchaseGear(plan.character(),plan.expectedCharacterRevision(),plan.id(),
+                plan.product().slot(),plan.product().tier(),plan.price()).join();
+        } catch(CompletionException failure) { throw failure; }
+        boolean consumed=purchase.status()==CharacterStorage.GearPurchaseStatus.APPLIED||
+            purchase.status()==CharacterStorage.GearPurchaseStatus.DUPLICATE;
+        catalog=catalog.settle(plan.id(),consumed);persist(catalog,consumed);
+        operations.complete(plan.id()).toCompletableFuture().join();
+        catalog=catalog.prune(plan.id());persist(catalog,false);
+        var status=switch(purchase.status()) {
+            case APPLIED,DUPLICATE->PurchaseStatus.APPLIED;
+            case INSUFFICIENT->PurchaseStatus.INSUFFICIENT;
+            case NOT_UPGRADE->PurchaseStatus.NOT_UPGRADE;
+            case STALE->PurchaseStatus.STALE;
+            case UNAVAILABLE->PurchaseStatus.UNAVAILABLE;
+        };
+        return new PurchaseOutcome(status,purchase.record(),catalog);
+    }
+
+    private ArmorCatalog ensureCurrent(ArmorCatalog.RefreshReason reason)throws IOException {
+        LocalDate today=LocalDate.now(clock.withZone(ZoneOffset.UTC));
+        var current=snapshot;
+        if(current!=null&&current.day().equals(today))return current;
+        if(current!=null&&!current.transactions().isEmpty())throw new IOException("Armor purchases are unresolved at catalog rollover");
+        var generated=ArmorCatalogGenerator.generate(today,
+            clock.instant().truncatedTo(java.time.temporal.ChronoUnit.SECONDS),reason,rules.get(),random);
+        persist(generated,true);
+        return generated;
+    }
+
+    private void persist(ArmorCatalog catalog,boolean notify)throws IOException {
+        catalogs.save(catalog);snapshot=catalog;if(notify)publish(catalog);
+    }
+
+    private void publish(ArmorCatalog catalog){if(!initialized)return;try{listener.accept(catalog);}catch(RuntimeException ignored){}}
+    private <T>CompletionStage<T> submit(Callable<T> action){synchronized(this){if(closed)return CompletableFuture.failedStage(
+        new IOException("Armor market closed"));pending++;}return CompletableFuture.supplyAsync(()->{try{return action.call();}
+        catch(Exception failure){throw new CompletionException(failure);}finally{finished();}},worker).minimalCompletionStage();}
+    private synchronized void finished(){pending--;if(closed&&pending==0)closeOperations();}
+    private void closeOperations(){if(operationsClosing)return;operationsClosing=true;operations.close();
+        operations.drained().whenComplete((ignored,failure)->{if(failure==null)drained.complete(null);else drained.completeExceptionally(failure);});}
+    public CompletionStage<Void> drained(){return drained.minimalCompletionStage();}
+    @Override public synchronized void close(){closed=true;worker.shutdown();if(pending==0)closeOperations();}
+}

src/main/java/games/dmg/fantasystick/shop/ArmorMarketRules.java

@@ -0,0 +1,34 @@
+package games.dmg.fantasystick.shop;
+
+import games.dmg.fantasystick.persistence.GearTier;
+import java.math.BigInteger;
+import java.util.EnumMap;
+import java.util.Map;
+import java.util.Objects;
+
+/** Validated configuration captured for one future catalog generation. */
+public record ArmorMarketRules(Map<GearTier, BigInteger> basePrices, int variancePercent,
+                               Map<GearTier, StockRange> stock) {
+    public record StockRange(int minimum, int maximum) {
+        public StockRange {
+            if (minimum <= 0 || maximum < minimum) throw new IllegalArgumentException("Invalid stock range");
+        }
+    }
+
+    public ArmorMarketRules {
+        Objects.requireNonNull(basePrices);
+        Objects.requireNonNull(stock);
+        if (variancePercent < 0 || variancePercent > 100) throw new IllegalArgumentException("Invalid variance");
+        var prices = new EnumMap<GearTier, BigInteger>(GearTier.class);
+        var ranges = new EnumMap<GearTier, StockRange>(GearTier.class);
+        for (var tier : GearTier.values()) {
+            if (tier == GearTier.NONE) continue;
+            var price = Objects.requireNonNull(basePrices.get(tier), "Missing base price");
+            if (price.signum() < 0) throw new IllegalArgumentException("Negative base price");
+            prices.put(tier, price);
+            ranges.put(tier, Objects.requireNonNull(stock.get(tier), "Missing stock range"));
+        }
+        basePrices = Map.copyOf(prices);
+        stock = Map.copyOf(ranges);
+    }
+}

src/main/java/games/dmg/fantasystick/shop/ArmorProduct.java

@@ -0,0 +1,14 @@
+package games.dmg.fantasystick.shop;
+
+import games.dmg.fantasystick.persistence.GearSlot;
+import games.dmg.fantasystick.persistence.GearTier;
+import java.util.Objects;
+
+/** One independently priced and stocked armor slot/tier product. */
+public record ArmorProduct(GearSlot slot, GearTier tier) {
+    public ArmorProduct {
+        Objects.requireNonNull(slot);
+        Objects.requireNonNull(tier);
+        if (tier == GearTier.NONE) throw new IllegalArgumentException("None is not purchasable");
+    }
+}

src/main/java/games/dmg/fantasystick/shop/ArmorShop.java

@@ -0,0 +1,88 @@
+package games.dmg.fantasystick.shop;
+
+import games.dmg.fantasystick.persistence.CharacterRecord;
+import games.dmg.fantasystick.session.EquipmentSessions;
+import java.time.Instant;
+import java.util.*;
+import java.util.function.Consumer;
+import org.bukkit.entity.Player;
+
+/** Active-character Armorer boundary backed by the one recoverable shared market. */
+public final class ArmorShop {
+    public enum Status { APPLIED, INVALID_SESSION, SOLD_OUT, INSUFFICIENT, NOT_UPGRADE, STALE, FAILED }
+    public record Outcome(Status status,Optional<CharacterRecord> record){}
+    public record View(CharacterRecord record,UUID session,ArmorCatalog catalog){}
+    private record Context(EquipmentSessions.Active active,CharacterRecord record,FantasyArmorer shop){}
+
+    private final FantasyArmorerDirectory shops;
+    private final EquipmentSessions sessions;
+    private final ArmorMarket market;
+    private final Consumer<Runnable> nextTick;
+    private final Consumer<Throwable> failures;
+
+    public ArmorShop(FantasyArmorerDirectory shops,EquipmentSessions sessions,ArmorMarket market,
+                     Consumer<Runnable> nextTick,Consumer<Throwable> failures){
+        this.shops=Objects.requireNonNull(shops);this.sessions=Objects.requireNonNull(sessions);
+        this.market=Objects.requireNonNull(market);this.nextTick=Objects.requireNonNull(nextTick);
+        this.failures=Objects.requireNonNull(failures);
+    }
+
+    public Optional<CharacterRecord> active(Player player,UUID shop){return context(player,shop).map(Context::record);}
+    public Optional<UUID> activeSession(Player player,UUID shop){return context(player,shop).map(value->value.active().session());}
+    public Instant now(){return market.now();}
+
+    public void view(Player player,UUID shopId,Consumer<Optional<View>> result){
+        var captured=context(player,shopId);
+        if(captured.isEmpty()){result.accept(Optional.empty());return;}
+        market.current().whenComplete((catalog,failure)->{
+            if(failure!=null){report(failure);publish(()->result.accept(Optional.empty()));return;}
+            publish(()->{
+                var current=context(player,shopId);
+                if(current.isEmpty()||!current.orElseThrow().active().session().equals(captured.orElseThrow().active().session()))
+                    result.accept(Optional.empty());
+                else result.accept(Optional.of(new View(current.orElseThrow().record(),current.orElseThrow().active().session(),catalog)));
+            });
+        });
+    }
+
+    public void buy(Player player,UUID shopId,UUID catalogRevision,ArmorProduct product,Consumer<Outcome> result){
+        var lease=shops.acquire(shopId);
+        if(lease.isEmpty()){result.accept(new Outcome(Status.INVALID_SESSION,Optional.empty()));return;}
+        var held=lease.orElseThrow();
+        var context=context(player,shopId);
+        if(context.isEmpty()){held.close();result.accept(new Outcome(Status.INVALID_SESSION,Optional.empty()));return;}
+        var captured=context.orElseThrow();
+        market.purchase(captured.record().id(),captured.record().revision(),catalogRevision,product).whenComplete((purchase,failure)->{
+            if(failure!=null){report(failure);publishHeld(held,()->result.accept(new Outcome(Status.FAILED,Optional.empty())));return;}
+            publishHeld(held,()->{
+                var current=context(player,shopId);
+                if(current.isEmpty()||!current.orElseThrow().active().session().equals(captured.active().session())){
+                    result.accept(new Outcome(Status.STALE,purchase.record()));return;
+                }
+                Status status=switch(purchase.status()){
+                    case APPLIED->Status.APPLIED;case SOLD_OUT->Status.SOLD_OUT;case INSUFFICIENT->Status.INSUFFICIENT;
+                    case NOT_UPGRADE->Status.NOT_UPGRADE;case STALE->Status.STALE;
+                    case UNAVAILABLE,FAILED->Status.FAILED;
+                };
+                if(purchase.status()==ArmorMarket.PurchaseStatus.APPLIED&&purchase.record().isPresent())
+                    sessions.acknowledgeProgress(captured.active(),captured.record().revision(),purchase.record().orElseThrow());
+                result.accept(new Outcome(status,purchase.record()));
+            });
+        });
+    }
+
+    private Optional<Context> context(Player player,UUID shopId){
+        var shop=shops.find(shopId).orElse(null);
+        var active=sessions.active(player.getUniqueId()).filter(sessions::current).orElse(null);
+        var record=active==null?null:sessions.currentRecord(active).filter(value->!value.dead()).orElse(null);
+        if(shop==null||record==null)return Optional.empty();
+        var location=player.getLocation();
+        if(location.getWorld()==null||!location.getWorld().getUID().equals(shop.world()))return Optional.empty();
+        double x=location.getX()-shop.x(),y=location.getY()-shop.y(),z=location.getZ()-shop.z();
+        return x*x+y*y+z*z<=36?Optional.of(new Context(active,record,shop)):Optional.empty();
+    }
+    private void publishHeld(FantasyArmorerDirectory.Lease lease,Runnable action){try{nextTick.accept(()->{try{action.run();}finally{lease.close();}});}
+        catch(RuntimeException failure){lease.close();report(failure);}}
+    private void publish(Runnable action){try{nextTick.accept(action);}catch(RuntimeException failure){report(failure);}}
+    private void report(Throwable failure){try{failures.accept(failure);}catch(RuntimeException ignored){}}
+}

src/main/java/games/dmg/fantasystick/shop/ArmorShopMenus.java

@@ -0,0 +1,113 @@
+package games.dmg.fantasystick.shop;
+
+import games.dmg.fantasystick.persistence.*;
+import java.time.Duration;
+import java.time.Instant;
+import java.time.ZoneOffset;
+import java.util.*;
+import org.bukkit.*;
+import org.bukkit.entity.Player;
+import org.bukkit.event.*;
+import org.bukkit.event.inventory.*;
+import org.bukkit.inventory.*;
+import org.bukkit.persistence.PersistentDataType;
+import org.bukkit.plugin.Plugin;
+
+/** Bounded shared-catalog armor shop; every click revalidates generation, character, session and shop. */
+public final class ArmorShopMenus implements Listener,AutoCloseable {
+    private record Holder(UUID shop,UUID character,UUID session,UUID catalog)implements InventoryHolder{
+        public Inventory getInventory(){return null;}}
+    private final ArmorShop service;
+    private final org.bukkit.Server server;
+    private final NamespacedKey slotKey,tierKey;
+    private boolean closed;
+
+    public ArmorShopMenus(Plugin plugin,ArmorShop service){this.service=Objects.requireNonNull(service);server=plugin.getServer();
+        slotKey=new NamespacedKey(plugin,"armor_shop_slot");tierKey=new NamespacedKey(plugin,"armor_shop_tier");}
+
+    public void open(Player player,UUID shop){
+        service.view(player,shop,view->{
+            if(closed||!player.isOnline())return;
+            if(view.isEmpty()){
+                player.sendMessage("You must be actively playing a living fantasy character beside this Fantasy Armorer; the market must also be available.");return;
+            }
+            var current=view.orElseThrow();
+            var inventory=server.createInventory(new Holder(shop,current.record().id(),current.session(),current.catalog().revision()),
+                54,net.kyori.adventure.text.Component.text("Fantasy Armorer"));
+            int column=0;
+            for(var slot:GearSlot.values()){
+                int row=0;
+                for(var tier:GearTier.values()){
+                    if(tier==GearTier.NONE)continue;
+                    var product=new ArmorProduct(slot,tier);
+                    inventory.setItem(row*9+column,item(product,current.catalog().offer(product)));
+                    row++;
+                }
+                column+=3;
+            }
+            inventory.setItem(8,schedule(current.catalog(),service.now()));
+            player.openInventory(inventory);
+        });
+    }
+
+    private ItemStack item(ArmorProduct product,ArmorCatalog.Offer offer){
+        var tier=product.tier();var slot=product.slot();
+        var item=new ItemStack(Material.valueOf((tier==GearTier.GOLD?"GOLDEN":tier.name())+"_"+switch(slot){
+            case CHESTPLATE->"CHESTPLATE";case LEGGINGS->"LEGGINGS";case BOOTS->"BOOTS";}));
+        var meta=item.getItemMeta();
+        meta.displayName(net.kyori.adventure.text.Component.text("Buy "+title(tier.name())+" "+title(slot.name())+
+            " — "+offer.price()+" coins"));
+        meta.lore(List.of(net.kyori.adventure.text.Component.text("Stock: "+offer.remaining())));
+        meta.getPersistentDataContainer().set(slotKey,PersistentDataType.STRING,slot.name());
+        meta.getPersistentDataContainer().set(tierKey,PersistentDataType.STRING,tier.name());
+        item.setItemMeta(meta);return item;
+    }
+
+    private static ItemStack schedule(ArmorCatalog catalog,Instant now){
+        var next=catalog.day().plusDays(1).atStartOfDay(ZoneOffset.UTC).toInstant();
+        long seconds=Math.max(0,Duration.between(now,next).toSeconds());
+        long hours=seconds/3600,minutes=(seconds%3600)/60;
+        var item=new ItemStack(Material.CLOCK);var meta=item.getItemMeta();
+        meta.displayName(net.kyori.adventure.text.Component.text("Restock in: "+hours+"h "+minutes+"m"));
+        item.setItemMeta(meta);return item;
+    }
+
+    public void refreshOpen(){
+        if(closed)return;
+        for(var player:server.getOnlinePlayers()){
+            var view=player.getOpenInventory();
+            if(view==null)continue;
+            var inventory=view.getTopInventory();
+            if(inventory!=null&&inventory.getHolder() instanceof Holder holder)open(player,holder.shop());
+        }
+    }
+
+    @EventHandler(priority=EventPriority.HIGHEST,ignoreCancelled=true)
+    public void click(InventoryClickEvent event){
+        if(!(event.getInventory().getHolder() instanceof Holder holder)||!(event.getWhoClicked() instanceof Player player))return;
+        event.setCancelled(true);
+        if(closed||!service.active(player,holder.shop()).map(value->value.id().equals(holder.character())).orElse(false)||
+            !service.activeSession(player,holder.shop()).map(holder.session()::equals).orElse(false)){
+            player.sendMessage("Armor purchase refused: the character, session or shop changed.");return;
+        }
+        var item=event.getCurrentItem();if(item==null)return;
+        var data=item.getItemMeta().getPersistentDataContainer();
+        try{
+            var product=new ArmorProduct(GearSlot.valueOf(data.get(slotKey,PersistentDataType.STRING)),
+                GearTier.valueOf(data.get(tierKey,PersistentDataType.STRING)));
+            service.buy(player,holder.shop(),holder.catalog(),product,outcome->{
+                if(outcome.status()==ArmorShop.Status.APPLIED)player.sendMessage("Purchased "+title(product.tier().name())+" "+title(product.slot().name())+".");
+                else{
+                    player.sendMessage("Armor purchase refused: "+outcome.status().name().toLowerCase(Locale.ROOT).replace('_',' ')+".");
+                    if(outcome.status()==ArmorShop.Status.STALE||outcome.status()==ArmorShop.Status.SOLD_OUT)open(player,holder.shop());
+                }
+            });
+        }catch(RuntimeException ignored){ }
+    }
+
+    @EventHandler(priority=EventPriority.HIGHEST,ignoreCancelled=true)
+    public void drag(InventoryDragEvent event){if(event.getInventory().getHolder() instanceof Holder)event.setCancelled(true);}
+    private static String title(String value){String lower=value.toLowerCase(Locale.ROOT).replace('_',' ');
+        return Character.toUpperCase(lower.charAt(0))+lower.substring(1);}
+    @Override public void close(){closed=true;}
+}

src/main/java/games/dmg/fantasystick/shop/FantasyArmorer.java

@@ -0,0 +1,4 @@
+package games.dmg.fantasystick.shop;
+import java.util.*;
+/** Durable desired location for one administrator-managed Fantasy Armorer. */
+public record FantasyArmorer(UUID id,String name,UUID world,double x,double y,double z,float yaw,float pitch){public FantasyArmorer{Objects.requireNonNull(id);Objects.requireNonNull(name);Objects.requireNonNull(world);name=name.strip();if(name.codePointCount(0,name.length())>64||name.codePoints().anyMatch(codePoint->{int type=Character.getType(codePoint);return type==Character.CONTROL||type==Character.FORMAT||type==Character.SURROGATE;})||!Double.isFinite(x)||!Double.isFinite(y)||!Double.isFinite(z)||!Float.isFinite(yaw)||!Float.isFinite(pitch))throw new IllegalArgumentException("Invalid Fantasy Armorer");}}

src/main/java/games/dmg/fantasystick/shop/FantasyArmorerController.java

@@ -0,0 +1,12 @@
+package games.dmg.fantasystick.shop;
+import java.util.*;import java.util.function.BiConsumer;import org.bukkit.*;import org.bukkit.entity.*;import org.bukkit.event.*;import org.bukkit.persistence.PersistentDataType;import org.bukkit.plugin.Plugin;
+/** Loaded-chunk Armorer reconciliation and native protection, distinct from Party Registrars. */
+public final class FantasyArmorerController implements Listener,AutoCloseable{
+ private final Plugin plugin;private final FantasyArmorerDirectory directory;private final BiConsumer<Player,UUID> interactions;private final NamespacedKey idKey,typeKey;private final Set<Entity> relocating=Collections.newSetFromMap(new IdentityHashMap<>());private boolean closed;public FantasyArmorerController(Plugin plugin,FantasyArmorerDirectory directory,BiConsumer<Player,UUID> interactions){this.plugin=Objects.requireNonNull(plugin);this.directory=Objects.requireNonNull(directory);this.interactions=Objects.requireNonNull(interactions);idKey=new NamespacedKey(plugin,"fantasy_armorer_id");typeKey=new NamespacedKey(plugin,"managed_npc_type");}
+ public void install(){for(var world:plugin.getServer().getWorlds()){var chunks=world.getLoadedChunks();if(chunks!=null)for(var chunk:chunks)reconcile(chunk);}}public boolean tagged(Entity entity){return "fantasy_armorer".equals(entity.getPersistentDataContainer().get(typeKey,PersistentDataType.STRING));}
+ public void reconcile(Chunk chunk){if(closed)return;var desired=new HashMap<UUID,FantasyArmorer>();for(var value:directory.all())if(value.world().equals(chunk.getWorld().getUID())&&section(value.x())==chunk.getX()&&section(value.z())==chunk.getZ())desired.put(value.id(),value);var retained=new HashSet<UUID>();for(var entity:chunk.getEntities()){if(!tagged(entity))continue;UUID id=id(entity);var target=id==null?null:desired.get(id);if(!(entity instanceof Villager villager)||target==null||!retained.add(id)){entity.remove();continue;}configure(villager,target);var current=villager.getLocation();var expected=location(target);if(current.distanceSquared(expected)>0.000001||Math.abs(current.getYaw()-expected.getYaw())>0.001||Math.abs(current.getPitch()-expected.getPitch())>0.001){relocating.add(villager);boolean moved;try{moved=villager.teleport(expected);}finally{relocating.remove(villager);}if(!moved){villager.remove();spawn(target);}}}for(var target:desired.values())if(!retained.contains(target.id()))spawn(target);}
+ public void removeLoaded(UUID id){for(var world:plugin.getServer().getWorlds()){var entities=world.getEntities();if(entities!=null)for(var entity:entities)if(tagged(entity)&&id.equals(id(entity)))entity.remove();}}
+ private void spawn(FantasyArmorer value){var world=plugin.getServer().getWorld(value.world());if(world==null)return;int x=section(value.x()),z=section(value.z());if(world.isChunkLoaded(x,z))world.spawn(location(value),Villager.class,villager->configure(villager,value));}private void configure(Villager villager,FantasyArmorer value){var data=villager.getPersistentDataContainer();data.set(typeKey,PersistentDataType.STRING,"fantasy_armorer");data.set(idKey,PersistentDataType.STRING,value.id().toString());villager.setAI(false);villager.setGravity(false);villager.setSilent(true);villager.setInvulnerable(true);villager.setCollidable(false);villager.setCanPickupItems(false);villager.setLeashHolder(null);villager.setRemoveWhenFarAway(false);villager.setAdult();villager.setAgeLock(true);villager.customName(net.kyori.adventure.text.Component.text(value.name().isBlank()?"Fantasy Armorer":value.name()));villager.setCustomNameVisible(true);}private Location location(FantasyArmorer value){return new Location(plugin.getServer().getWorld(value.world()),value.x(),value.y(),value.z(),value.yaw(),value.pitch());}private UUID id(Entity entity){String value=entity.getPersistentDataContainer().get(idKey,PersistentDataType.STRING);try{return value==null?null:UUID.fromString(value);}catch(IllegalArgumentException invalid){return null;}}private static int section(double value){return((int)Math.floor(value))>>4;}
+ @EventHandler(priority=EventPriority.HIGHEST,ignoreCancelled=true)public void interact(org.bukkit.event.player.PlayerInteractEntityEvent event){if(!tagged(event.getRightClicked()))return;event.setCancelled(true);if(event.getHand()!=org.bukkit.inventory.EquipmentSlot.HAND)return;UUID id=id(event.getRightClicked());if(id!=null&&directory.find(id).isPresent())interactions.accept(event.getPlayer(),id);}@EventHandler(priority=EventPriority.HIGHEST,ignoreCancelled=true)public void damage(org.bukkit.event.entity.EntityDamageEvent event){if(tagged(event.getEntity()))event.setCancelled(true);}@EventHandler(priority=EventPriority.HIGHEST,ignoreCancelled=true)public void combust(org.bukkit.event.entity.EntityCombustEvent event){if(tagged(event.getEntity()))event.setCancelled(true);}@EventHandler(priority=EventPriority.HIGHEST,ignoreCancelled=true)public void transform(org.bukkit.event.entity.EntityTransformEvent event){if(tagged(event.getEntity()))event.setCancelled(true);}@EventHandler(priority=EventPriority.HIGHEST,ignoreCancelled=true)public void breed(org.bukkit.event.entity.EntityBreedEvent event){if(tagged(event.getMother())||tagged(event.getFather()))event.setCancelled(true);}@EventHandler(priority=EventPriority.HIGHEST,ignoreCancelled=true)public void vehicle(org.bukkit.event.vehicle.VehicleEnterEvent event){if(tagged(event.getEntered()))event.setCancelled(true);}@EventHandler(priority=EventPriority.HIGHEST,ignoreCancelled=true)public void leash(org.bukkit.event.entity.PlayerLeashEntityEvent event){if(tagged(event.getEntity()))event.setCancelled(true);}@EventHandler(priority=EventPriority.HIGHEST,ignoreCancelled=true)public void teleport(org.bukkit.event.entity.EntityTeleportEvent event){if(tagged(event.getEntity())&&!relocating.contains(event.getEntity()))event.setCancelled(true);}@EventHandler(priority=EventPriority.MONITOR)public void chunk(org.bukkit.event.world.ChunkLoadEvent event){reconcile(event.getChunk());}
+ @Override public void close(){closed=true;for(var world:plugin.getServer().getWorlds()){var entities=world.getEntities();if(entities!=null)for(var entity:entities)if(tagged(entity))entity.remove();}}
+}

src/main/java/games/dmg/fantasystick/shop/FantasyArmorerDirectory.java

@@ -0,0 +1,9 @@
+package games.dmg.fantasystick.shop;
+import games.dmg.fantasystick.persistence.YamlFantasyArmorerRepository;import java.io.*;import java.util.*;import java.util.concurrent.*;
+/** Serialized durable Fantasy Armorer desired state. */
+public final class FantasyArmorerDirectory implements AutoCloseable{
+ private final YamlFantasyArmorerRepository repository;private final ExecutorService worker=Executors.newSingleThreadExecutor(r->new Thread(r,"fantasy-armorer-persistence"));private volatile List<FantasyArmorer> snapshot;private final Map<UUID,Integer> leases=new HashMap<>();private boolean closed;private int pending;private final CompletableFuture<Void> drained=new CompletableFuture<>();public FantasyArmorerDirectory(YamlFantasyArmorerRepository repository)throws IOException{this.repository=Objects.requireNonNull(repository);snapshot=repository.load();}public List<FantasyArmorer> all(){return snapshot;}public Optional<FantasyArmorer> find(UUID id){return snapshot.stream().filter(value->value.id().equals(id)).findFirst();}
+ public CompletableFuture<FantasyArmorer> place(String name,UUID world,double x,double y,double z,float yaw,float pitch){return submit(()->{synchronized(this){var value=new FantasyArmorer(UUID.randomUUID(),name,world,x,y,z,yaw,pitch);var next=new ArrayList<>(snapshot);next.add(value);repository.save(next);snapshot=List.copyOf(next);return value;}});}public CompletableFuture<Optional<FantasyArmorer>> remove(UUID id){return submit(()->{synchronized(this){var found=find(id);if(found.isEmpty())return Optional.empty();if(leases.getOrDefault(id,0)>0)throw new IOException("Fantasy Armorer has an active purchase");var next=snapshot.stream().filter(value->!value.id().equals(id)).toList();repository.save(next);snapshot=next;return found;}});}public CompletableFuture<FantasyArmorer> restore(FantasyArmorer value){return submit(()->{synchronized(this){var found=find(value.id());if(found.isPresent()){if(found.orElseThrow().equals(value))return value;throw new IOException("Armorer identity collision");}var next=new ArrayList<>(snapshot);next.add(value);repository.save(next);snapshot=List.copyOf(next);return value;}});}
+ public synchronized Optional<Lease> acquire(UUID id){if(closed||find(id).isEmpty())return Optional.empty();leases.merge(id,1,Integer::sum);return Optional.of(new Lease(id));}public final class Lease implements AutoCloseable{private final UUID id;private boolean released;private Lease(UUID id){this.id=id;}public FantasyArmorer shop(){return find(id).orElseThrow();}@Override public void close(){synchronized(FantasyArmorerDirectory.this){if(released)return;released=true;int remaining=leases.getOrDefault(id,0)-1;if(remaining<=0)leases.remove(id);else leases.put(id,remaining);}}}
+ private <T>CompletableFuture<T> submit(Callable<T> operation){var result=new CompletableFuture<T>();synchronized(this){if(closed){result.completeExceptionally(new IOException("Armorer directory closed"));return result;}pending++;}worker.execute(()->{try{result.complete(operation.call());}catch(Throwable failure){result.completeExceptionally(failure);}finally{finished();}});return result;}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/training/TrainingDamage.java

@@ -0,0 +1,18 @@
+package games.dmg.fantasystick.training;
+
+import java.math.BigDecimal;
+import java.util.Optional;
+import org.bukkit.entity.LivingEntity;
+import org.bukkit.entity.Player;
+
+/** Applies native damage while allowing a managed dummy to return its intercepted final amount. */
+@FunctionalInterface
+public interface TrainingDamage {
+    Optional<BigDecimal> apply(Player source, LivingEntity target, Runnable nativeDamage);
+
+    default boolean target(org.bukkit.entity.Entity entity) { return false; }
+
+    static TrainingDamage passthrough() {
+        return (source, target, nativeDamage) -> { nativeDamage.run(); return Optional.empty(); };
+    }
+}

src/main/java/games/dmg/fantasystick/training/TrainingDummy.java

@@ -0,0 +1,21 @@
+package games.dmg.fantasystick.training;
+
+import java.util.Objects;
+import java.util.UUID;
+
+/** Durable desired location for one administrator-managed training dummy. */
+public record TrainingDummy(UUID id, String name, UUID world, double x, double y, double z, float yaw, float pitch) {
+    public TrainingDummy {
+        Objects.requireNonNull(id); Objects.requireNonNull(name); Objects.requireNonNull(world);
+        name = name.strip();
+        if (name.codePointCount(0, name.length()) > 64 || name.codePoints().anyMatch(codePoint -> {
+            int type = Character.getType(codePoint);
+            return type == Character.CONTROL || type == Character.FORMAT || type == Character.SURROGATE;
+        }) || !Double.isFinite(x) || !Double.isFinite(y) || !Double.isFinite(z)
+                || !Float.isFinite(yaw) || !Float.isFinite(pitch)) {
+            throw new IllegalArgumentException("Invalid training dummy");
+        }
+    }
+
+    public String displayName() { return name.isBlank() ? "Training Dummy" : name; }
+}

src/main/java/games/dmg/fantasystick/training/TrainingDummyController.java

@@ -0,0 +1,190 @@
+package games.dmg.fantasystick.training;
+
+import java.math.BigDecimal;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.Objects;
+import java.util.Optional;
+import java.util.UUID;
+import org.bukkit.Chunk;
+import org.bukkit.Location;
+import org.bukkit.NamespacedKey;
+import org.bukkit.entity.Entity;
+import org.bukkit.entity.LivingEntity;
+import org.bukkit.entity.Player;
+import org.bukkit.entity.Zombie;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.EventPriority;
+import org.bukkit.event.Listener;
+import org.bukkit.event.entity.EntityDamageEvent;
+import org.bukkit.persistence.PersistentDataType;
+import org.bukkit.plugin.Plugin;
+
+/** Loaded-chunk reconciliation, containment and final-damage interception for training dummies. */
+public final class TrainingDummyController implements Listener, TrainingDamage, AutoCloseable {
+    private static final String TYPE = "training_dummy";
+    private final Plugin plugin;
+    private final TrainingDummyDirectory directory;
+    private final NamespacedKey idKey;
+    private final NamespacedKey typeKey;
+    private final java.util.Set<Entity> relocating = java.util.Collections.newSetFromMap(new java.util.IdentityHashMap<>());
+    private Attempt pending;
+    private boolean closed;
+
+    private static final class Attempt {
+        final LivingEntity target; BigDecimal amount;
+        Attempt(LivingEntity target) { this.target = target; }
+    }
+
+    public TrainingDummyController(Plugin plugin, TrainingDummyDirectory directory) {
+        this.plugin = Objects.requireNonNull(plugin); this.directory = Objects.requireNonNull(directory);
+        idKey = new NamespacedKey(plugin, "training_dummy_id");
+        typeKey = new NamespacedKey(plugin, "managed_npc_type");
+    }
+
+    public void install() {
+        for (var world : plugin.getServer().getWorlds()) {
+            var chunks = world.getLoadedChunks(); if (chunks != null) for (var chunk : chunks) reconcile(chunk);
+        }
+    }
+
+    public boolean tagged(Entity entity) {
+        var data = entity.getPersistentDataContainer();
+        return data != null && TYPE.equals(data.get(typeKey, PersistentDataType.STRING));
+    }
+
+    public void reconcile(Chunk chunk) {
+        if (closed) return;
+        var desired = new HashMap<UUID, TrainingDummy>();
+        for (var value : directory.all()) {
+            if (value.world().equals(chunk.getWorld().getUID()) && chunk(value.x()) == chunk.getX()
+                    && chunk(value.z()) == chunk.getZ()) desired.put(value.id(), value);
+        }
+        var retained = new HashSet<UUID>();
+        for (var entity : chunk.getEntities()) {
+            if (!tagged(entity)) continue;
+            UUID id = id(entity); var target = id == null ? null : desired.get(id);
+            if (!(entity instanceof Zombie zombie) || target == null || !retained.add(id)) { entity.remove(); continue; }
+            configure(zombie, target);
+            var current = zombie.getLocation(); var expected = location(target);
+            if (current.distanceSquared(expected) > 0.000001 || Math.abs(current.getYaw() - expected.getYaw()) > 0.001
+                    || Math.abs(current.getPitch() - expected.getPitch()) > 0.001) {
+                relocating.add(zombie); boolean moved;
+                try { moved = zombie.teleport(expected); } finally { relocating.remove(zombie); }
+                if (!moved) { zombie.remove(); spawn(target); }
+            }
+        }
+        for (var value : desired.values()) if (!retained.contains(value.id())) spawn(value);
+    }
+
+    public void removeLoaded(UUID id) {
+        for (var world : plugin.getServer().getWorlds()) {
+            var entities = world.getEntities(); if (entities != null) for (var entity : entities) {
+                if (tagged(entity) && id.equals(id(entity))) entity.remove();
+            }
+        }
+    }
+
+    @Override public Optional<BigDecimal> apply(Player source, LivingEntity target, Runnable nativeDamage) {
+        Objects.requireNonNull(source); Objects.requireNonNull(target); Objects.requireNonNull(nativeDamage);
+        if (closed || !managed(target)) { nativeDamage.run(); return Optional.empty(); }
+        if (pending != null) throw new IllegalStateException("Nested training damage is unavailable");
+        var attempt = new Attempt(target); pending = attempt;
+        try { nativeDamage.run(); }
+        finally { if (pending == attempt) pending = null; }
+        return Optional.ofNullable(attempt.amount);
+    }
+
+    @Override public boolean target(Entity entity) { return managed(entity); }
+
+    private boolean managed(Entity entity) {
+        if (!(entity instanceof Zombie) || !tagged(entity)) return false;
+        UUID id = id(entity); return id != null && directory.find(id).isPresent();
+    }
+
+    private void spawn(TrainingDummy value) {
+        var world = plugin.getServer().getWorld(value.world()); if (world == null) return;
+        int x = chunk(value.x()), z = chunk(value.z()); if (!world.isChunkLoaded(x, z)) return;
+        world.spawn(location(value), Zombie.class, zombie -> configure(zombie, value));
+    }
+
+    private void configure(Zombie zombie, TrainingDummy value) {
+        zombie.getPersistentDataContainer().set(typeKey, PersistentDataType.STRING, TYPE);
+        zombie.getPersistentDataContainer().set(idKey, PersistentDataType.STRING, value.id().toString());
+        zombie.setAI(false); zombie.setAware(false); zombie.setGravity(false); zombie.setSilent(true);
+        zombie.setInvulnerable(false); zombie.setCollidable(false); zombie.setCanPickupItems(false);
+        zombie.setLeashHolder(null); zombie.setRemoveWhenFarAway(false); zombie.setPersistent(true);
+        zombie.setShouldBurnInDay(false); zombie.setBaby(false); zombie.setCanBreakDoors(false);
+        zombie.setFireTicks(0); zombie.setFreezeTicks(0); zombie.setVelocity(new org.bukkit.util.Vector());
+        for (var effect : java.util.List.copyOf(zombie.getActivePotionEffects())) zombie.removePotionEffect(effect.getType());
+        zombie.customName(net.kyori.adventure.text.Component.text(value.displayName()));
+        zombie.setCustomNameVisible(true);
+    }
+
+    private Location location(TrainingDummy value) {
+        return new Location(plugin.getServer().getWorld(value.world()), value.x(), value.y(), value.z(), value.yaw(), value.pitch());
+    }
+    private UUID id(Entity entity) {
+        String value = entity.getPersistentDataContainer().get(idKey, PersistentDataType.STRING);
+        try { return value == null ? null : UUID.fromString(value); }
+        catch (IllegalArgumentException invalid) { return null; }
+    }
+    private static int chunk(double coordinate) { return ((int) Math.floor(coordinate)) >> 4; }
+
+    @EventHandler(priority = EventPriority.HIGHEST, ignoreCancelled = true)
+    public void damage(EntityDamageEvent event) {
+        if (!tagged(event.getEntity())) return;
+        var attempt = pending;
+        if (attempt != null && attempt.target == event.getEntity() && managed(event.getEntity())
+                && Double.isFinite(event.getFinalDamage()) && event.getFinalDamage() > 0) {
+            attempt.amount = BigDecimal.valueOf(event.getFinalDamage()).stripTrailingZeros();
+        }
+        event.setCancelled(true);
+    }
+
+    @EventHandler(priority = EventPriority.HIGHEST, ignoreCancelled = true)
+    public void combust(org.bukkit.event.entity.EntityCombustEvent event) {
+        if (tagged(event.getEntity())) event.setCancelled(true);
+    }
+    @EventHandler(priority = EventPriority.HIGHEST, ignoreCancelled = true)
+    public void transform(org.bukkit.event.entity.EntityTransformEvent event) {
+        if (tagged(event.getEntity())) event.setCancelled(true);
+    }
+    @EventHandler(priority = EventPriority.HIGHEST, ignoreCancelled = true)
+    public void breed(org.bukkit.event.entity.EntityBreedEvent event) {
+        if (tagged(event.getMother()) || tagged(event.getFather())) event.setCancelled(true);
+    }
+    @EventHandler(priority = EventPriority.HIGHEST, ignoreCancelled = true)
+    public void vehicle(org.bukkit.event.vehicle.VehicleEnterEvent event) {
+        if (tagged(event.getEntered())) event.setCancelled(true);
+    }
+    @EventHandler(priority = EventPriority.HIGHEST, ignoreCancelled = true)
+    public void leash(org.bukkit.event.entity.PlayerLeashEntityEvent event) {
+        if (tagged(event.getEntity())) event.setCancelled(true);
+    }
+    @EventHandler(priority = EventPriority.HIGHEST, ignoreCancelled = true)
+    public void teleport(org.bukkit.event.entity.EntityTeleportEvent event) {
+        if (tagged(event.getEntity()) && !relocating.contains(event.getEntity())) event.setCancelled(true);
+    }
+    @EventHandler(priority = EventPriority.HIGHEST, ignoreCancelled = true)
+    public void potion(org.bukkit.event.entity.EntityPotionEffectEvent event) {
+        if (tagged(event.getEntity())) event.setCancelled(true);
+    }
+    @EventHandler(priority = EventPriority.HIGHEST, ignoreCancelled = true)
+    public void splash(org.bukkit.event.entity.PotionSplashEvent event) {
+        for (var entity : java.util.List.copyOf(event.getAffectedEntities())) if (tagged(entity)) event.setIntensity(entity, 0);
+    }
+    @EventHandler(priority = EventPriority.HIGHEST, ignoreCancelled = true)
+    public void cloud(org.bukkit.event.entity.AreaEffectCloudApplyEvent event) {
+        event.getAffectedEntities().removeIf(this::tagged);
+    }
+    @EventHandler(priority = EventPriority.MONITOR)
+    public void chunk(org.bukkit.event.world.ChunkLoadEvent event) { reconcile(event.getChunk()); }
+
+    @Override public void close() {
+        closed = true; pending = null;
+        for (var world : plugin.getServer().getWorlds()) {
+            var entities = world.getEntities(); if (entities != null) for (var entity : entities) if (tagged(entity)) entity.remove();
+        }
+    }
+}

src/main/java/games/dmg/fantasystick/training/TrainingDummyDirectory.java

@@ -0,0 +1,73 @@
+package games.dmg.fantasystick.training;
+
+import games.dmg.fantasystick.persistence.YamlTrainingDummyRepository;
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.Comparator;
+import java.util.List;
+import java.util.Objects;
+import java.util.Optional;
+import java.util.UUID;
+import java.util.concurrent.Callable;
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.Executors;
+
+/** Serialized durable desired state for training dummy entities. */
+public final class TrainingDummyDirectory implements AutoCloseable {
+    private final YamlTrainingDummyRepository repository;
+    private final java.util.concurrent.ExecutorService worker = Executors.newSingleThreadExecutor(
+        task -> new Thread(task, "fantasy-training-dummy-persistence"));
+    private volatile List<TrainingDummy> snapshot;
+    private volatile boolean closed;
+    private int pending;
+    private final CompletableFuture<Void> drained = new CompletableFuture<>();
+
+    public TrainingDummyDirectory(YamlTrainingDummyRepository repository) throws IOException {
+        this.repository = Objects.requireNonNull(repository); snapshot = repository.load();
+    }
+    public List<TrainingDummy> all() { return snapshot; }
+    public Optional<TrainingDummy> find(UUID id) {
+        return snapshot.stream().filter(value -> value.id().equals(id)).findFirst();
+    }
+    public CompletableFuture<TrainingDummy> place(String name, UUID world, double x, double y, double z,
+                                                   float yaw, float pitch) {
+        var value = new TrainingDummy(UUID.randomUUID(), name, world, x, y, z, yaw, pitch);
+        return submit(() -> {
+            var next = new ArrayList<>(snapshot); next.add(value); repository.save(next);
+            snapshot = List.copyOf(next); return value;
+        });
+    }
+    public CompletableFuture<Optional<TrainingDummy>> remove(UUID id) {
+        return submit(() -> {
+            var found = find(id); if (found.isEmpty()) return Optional.empty();
+            var next = snapshot.stream().filter(value -> !value.id().equals(id)).toList();
+            repository.save(next); snapshot = next; return found;
+        });
+    }
+    public CompletableFuture<TrainingDummy> restore(TrainingDummy dummy) {
+        return submit(() -> {
+            var found = find(dummy.id());
+            if (found.isPresent()) {
+                if (found.orElseThrow().equals(dummy)) return dummy;
+                throw new IOException("Training dummy identity collision");
+            }
+            var next = new ArrayList<>(snapshot); next.add(dummy);
+            next.sort(Comparator.comparing(value -> value.id().toString()));
+            repository.save(next); snapshot = List.copyOf(next); return dummy;
+        });
+    }
+    private <T> CompletableFuture<T> submit(Callable<T> operation) {
+        var future = new CompletableFuture<T>();
+        synchronized (this) {
+            if (closed) { future.completeExceptionally(new IOException("Training dummy directory closed")); return future; }
+            pending++;
+        }
+        worker.execute(() -> { try { future.complete(operation.call()); }
+            catch (Throwable failure) { future.completeExceptionally(failure); }
+            finally { finished(); } });
+        return future;
+    }
+    private synchronized void finished() { pending--; if (closed && pending == 0) drained.complete(null); }
+    public java.util.concurrent.CompletionStage<Void> drained() { return drained.minimalCompletionStage(); }
+    @Override public synchronized void close() { closed = true; worker.shutdown(); if (pending == 0) drained.complete(null); }
+}

src/main/resources/config.yml

@@ -9,12 +9,31 @@ roleplay-disabled: false
 party-max-size: 6
 party-registration-price: 10
 party-leader-change-price: 10
+gear-price-leather: 2
+gear-price-copper: 10
+gear-price-gold: 25
+gear-price-iron: 75
+gear-price-diamond: 150
+gear-price-netherite: 500
+gear-price-variance-percent: 10
+gear-stock-leather-min: 25
+gear-stock-leather-max: 50
+gear-stock-copper-min: 20
+gear-stock-copper-max: 40
+gear-stock-gold-min: 15
+gear-stock-gold-max: 30
+gear-stock-iron-min: 10
+gear-stock-iron-max: 20
+gear-stock-diamond-min: 5
+gear-stock-diamond-max: 10
+gear-stock-netherite-min: 1
+gear-stock-netherite-max: 3
 sheet-resource-pack-url: ''
 sheet-resource-pack-sha1: ''
 
 # Active-session recovery after actual accepted damage has stopped.
 # Admin command: /fantasystick config <key> [value]
-out-of-combat-healing-delay-seconds: 30
+out-of-combat-healing-delay-seconds: 10
 out-of-combat-healing-interval-seconds: 10
 out-of-combat-healing-amount: 1
 quicker-regeneration-i-bonus-healing: 1
@@ -37,18 +56,33 @@ boss-coin-drop-max: 50
 # Character-bound combat rewards. Restricted hostile/neutral/boss history uses mob death positions.
 passive-xp: 1
 ordinary-xp: 10
+hard-mob-xp: 20
 boss-xp: 100
 restricted-kill-spacing-blocks: 3
 
+# UTC-daily shared adventure catalogs, camp attempts and per-unit completion rewards.
+adventure-daily-site-count: 3
+adventure-site-radius: 16
+adventure-site-reset-seconds: 30
+adventure-camp-enemies: 8
+adventure-camp-reward-xp: 100
+adventure-camp-reward-coins: 20
+adventure-champion-health: 100
+adventure-champion-damage: 8
+adventure-champion-reward-xp: 150
+adventure-champion-reward-coins: 40
+
 # Fireball defaults from the reviewed starter catalogue.
+# Admin command: /fantasystick config <key> [value]
 fireball-base-damage: 6
-fireball-cooldown-seconds: 4
+fireball-cooldown-seconds: 1.2
 fireball-range-blocks: 32
 fireball-lifetime-seconds: 5
+fireball-projectile-speed-blocks-per-tick: 3
 
 # Great Sword defaults from the reviewed starter catalogue.
 great-sword-base-damage: 7
-great-sword-recovery-seconds: 1.2
+great-sword-recovery-seconds: 0.75
 
 # Frost Shard defaults from the reviewed remaining-development packet.
 # Admin command: /fantasystick config <key> [value]
@@ -56,7 +90,7 @@ frost-shard-base-damage: 4
 frost-shard-cooldown-seconds: 5
 frost-shard-range-blocks: 32
 frost-shard-lifetime-seconds: 5
-frost-shard-projectile-speed-blocks-per-tick: 1
+frost-shard-projectile-speed-blocks-per-tick: 3
 frost-shard-slowness-amplifier: 0
 frost-shard-slowness-duration-seconds: 2
 
@@ -90,7 +124,7 @@ 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-cooldown-seconds: 3
 shield-bash-range-blocks: 3
 shield-bash-horizontal-knockback: 0.8
 shield-bash-minimum-vertical-knockback: 0.35

src/main/resources/plugin.yml

@@ -7,9 +7,12 @@ description: Transferable characters, native fantasy health, recoverable equipme
 author: dmg.games
 commands:
   fantasystick:
-    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
+    description: Inspect daily adventures or administer Fantasy Stick.
+    usage: /fantasystick adventure [reroll confirm] | adventure-site <place <camp|champion> [name...]|remove <site-uuid>|list> | quest-giver <place [name...]|remove <giver-uuid>|list> | <admin route>
+
+  fantasyfeedback:
+    description: Read or change routine Fantasy Stick combat and ability feedback for your player account.
+    usage: /fantasyfeedback [on|off]
 permissions:
   fantasystick.admin:
     description: Issue/revive sheets, grant fantasy experience, recover sessions and configure fantasy mode.

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

@@ -135,7 +135,7 @@ class AbilityEngineNativeTest {
             var registry = (AbilityRegistry) FantasyStickLifecycleNativeTest.Fixture.field(f.plugin, "abilityRegistry");
             var effects = new AtomicInteger();
             registry.register(new AbilityDefinition("test_focus", "Test Focus", Material.AMETHYST_SHARD,
-                List.of("A registered test effect"), "Use the equipped shard", Map.of(), BigInteger.ONE,
+                List.of("A registered test effect"), "Use the equipped shard", Map.of(), BigInteger.ONE, AbilityDefinition.Category.BUF,
                 AbilityDefinition.Activation.IMMEDIATE, ControlInput.Gesture.USE, Duration.ofSeconds(4),
                 Map.of("range", BigDecimal.valueOf(12)), AbilityDefinition.TargetPolicy.SELF,
                 execution -> { assertTrue(execution.stillCurrent()); effects.incrementAndGet(); }));
@@ -206,7 +206,7 @@ class AbilityEngineNativeTest {
     private static AbilityDefinition definition(String id, AbilityDefinition.Activation activation,
             AbilityDefinition.TargetPolicy targetPolicy, games.dmg.fantasystick.ability.AbilityEffect effect) {
         return new AbilityDefinition(id, id, Material.AMETHYST_SHARD, List.of("Test definition"), "Use test input",
-            Map.of(), BigInteger.ONE, activation, ControlInput.Gesture.USE, Duration.ZERO,
+            Map.of(), BigInteger.ONE, AbilityDefinition.Category.ATK, activation, ControlInput.Gesture.USE, Duration.ZERO,
             Map.of(), targetPolicy, effect);
     }
 

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

@@ -36,16 +36,19 @@ class AbilityRegistryNativeTest {
             () -> assertThrows(IllegalArgumentException.class, () -> copy(valid, "UPPER", valid.requirements(), valid.parameters(), valid.cooldown())),
             () -> assertThrows(IllegalArgumentException.class, () -> copy(valid, "", valid.requirements(), valid.parameters(), valid.cooldown())),
             () -> assertThrows(IllegalArgumentException.class, () -> new AbilityDefinition("x", " ", Material.STONE,
-                List.of("Lore"), "Use", Map.of(Stat.INT, BigInteger.TEN), BigInteger.ONE,
+                List.of("Lore"), "Use", Map.of(Stat.INT, BigInteger.TEN), BigInteger.ONE, AbilityDefinition.Category.ATK,
                 AbilityDefinition.Activation.IMMEDIATE, ControlInput.Gesture.USE, Duration.ZERO,
                 Map.of(), AbilityDefinition.TargetPolicy.HOSTILE, ignored -> {})),
+            () -> assertThrows(NullPointerException.class, () -> new AbilityDefinition("category", "Category", Material.STONE,
+                List.of("Lore"), "Use", Map.of(), BigInteger.ONE, null, AbilityDefinition.Activation.IMMEDIATE,
+                ControlInput.Gesture.USE, Duration.ZERO, Map.of(), AbilityDefinition.TargetPolicy.SELF, ignored -> {})),
             () -> assertThrows(IllegalArgumentException.class, () -> copy(valid, "low", Map.of(Stat.INT, BigInteger.valueOf(9)), Map.of(), Duration.ZERO)),
             () -> assertThrows(IllegalArgumentException.class, () -> copy(valid, "negative", valid.requirements(), Map.of("range", BigDecimal.valueOf(-1)), Duration.ZERO)),
             () -> assertThrows(IllegalArgumentException.class, () -> copy(valid, "infinite", valid.requirements(), Map.of("range", new BigDecimal("1E1000000")), Duration.ZERO)),
             () -> assertThrows(IllegalArgumentException.class, () -> copy(valid, "cooldown", valid.requirements(), Map.of(), Duration.ofSeconds(-1))),
             () -> assertThrows(IllegalArgumentException.class, () -> copy(valid, "long_cooldown", valid.requirements(), Map.of(), Duration.ofDays(366))),
             () -> assertThrows(IllegalArgumentException.class, () -> new AbilityDefinition("air", "Air", Material.AIR,
-                List.of("Lore"), "Use", Map.of(), BigInteger.ONE, AbilityDefinition.Activation.IMMEDIATE,
+                List.of("Lore"), "Use", Map.of(), BigInteger.ONE, AbilityDefinition.Category.ATK, AbilityDefinition.Activation.IMMEDIATE,
                 ControlInput.Gesture.USE, Duration.ZERO, Map.of(), AbilityDefinition.TargetPolicy.SELF, ignored -> {}))
         );
     }
@@ -68,7 +71,7 @@ class AbilityRegistryNativeTest {
             for (var policy : AbilityDefinition.TargetPolicy.values()) {
                 var base = definition("x");
                 assertDoesNotThrow(() -> new AbilityDefinition("a_" + activation.name().toLowerCase() + "_" + policy.name().toLowerCase(),
-                    base.name(), base.icon(), base.lore(), base.instructions(), base.requirements(), base.pointCost(), activation,
+                    base.name(), base.icon(), base.lore(), base.instructions(), base.requirements(), base.pointCost(), base.category(), activation,
                     base.gesture(), base.cooldown(), base.parameters(), policy, base.effect()));
             }
         }
@@ -76,7 +79,7 @@ class AbilityRegistryNativeTest {
 
     static AbilityDefinition definition(String id) {
         return new AbilityDefinition(id, "Test Bolt", Material.AMETHYST_SHARD, List.of("A focused test effect"),
-            "Use the equipped control", Map.of(Stat.INT, BigInteger.valueOf(12)), BigInteger.ONE,
+            "Use the equipped control", Map.of(Stat.INT, BigInteger.valueOf(12)), BigInteger.ONE, AbilityDefinition.Category.ATK,
             AbilityDefinition.Activation.PROJECTILE, ControlInput.Gesture.USE, Duration.ofSeconds(4),
             Map.of("range", BigDecimal.valueOf(12), "duration", BigDecimal.valueOf(5)),
             AbilityDefinition.TargetPolicy.HOSTILE, ignored -> {});
@@ -85,6 +88,6 @@ class AbilityRegistryNativeTest {
     private static AbilityDefinition copy(AbilityDefinition value, String id, Map<Stat, BigInteger> requirements,
                                           Map<String, BigDecimal> parameters, Duration cooldown) {
         return new AbilityDefinition(id, value.name(), value.icon(), value.lore(), value.instructions(), requirements,
-            value.pointCost(), value.activation(), value.gesture(), cooldown, parameters, value.targetPolicy(), value.effect());
+            value.pointCost(), value.category(), value.activation(), value.gesture(), cooldown, parameters, value.targetPolicy(), value.effect());
     }
 }

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

@@ -0,0 +1,75 @@
+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 org.bukkit.*;
+import org.bukkit.entity.*;
+import org.bukkit.event.inventory.InventoryClickEvent;
+import org.bukkit.event.player.PlayerInteractEntityEvent;
+import org.bukkit.inventory.EquipmentSlot;
+import org.bukkit.persistence.PersistentDataContainer;
+import org.bukkit.persistence.PersistentDataType;
+import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.io.TempDir;
+
+class AdventureQuestNativeTest {
+    @TempDir Path data;
+    @BeforeAll static void bootstrap() throws Exception { NativeRuntime.bootstrap(); }
+
+    @SuppressWarnings({"unchecked", "rawtypes"})
+    @Test void registeredCommandsGiverMenuAcceptanceCampCombatAndExactRewardUseConnectedPath() throws Exception {
+        java.nio.file.Files.writeString(data.resolve("config.yml"),
+            "adventure-daily-site-count: 3\nadventure-site-reset-seconds: 0\nadventure-camp-enemies: 4\n");
+        try (var f = new FantasyStickLifecycleNativeTest.Fixture(data)) {
+            f.plugin.setEnabled(true); var actor = new FantasyStickLifecycleNativeTest.Actor(data);
+            f.players.put(actor.core.id, actor.player); doReturn(true).when(actor.player).hasPermission("fantasystick.admin");
+            UUID worldId=UUID.randomUUID();when(actor.world.getUID()).thenReturn(worldId);when(actor.world.isChunkLoaded(anyInt(),anyInt())).thenReturn(true);
+            int chunkX=actor.core.location.getBlockX()>>4,chunkZ=actor.core.location.getBlockZ()>>4;
+            var chunk=mock(Chunk.class);when(chunk.getWorld()).thenReturn(actor.world);when(chunk.getX()).thenReturn(chunkX);when(chunk.getZ()).thenReturn(chunkZ);when(chunk.getEntities()).thenReturn(new Entity[0]);when(actor.world.getChunkAt(anyInt(),anyInt())).thenReturn(chunk);when(actor.world.getLoadedChunks()).thenReturn(new Chunk[]{chunk});
+            var spawned=new ArrayList<LivingEntity>();
+            doAnswer(call->{Class<?> type=call.getArgument(1);LivingEntity entity=type==Villager.class?mock(Villager.class):mock(type.asSubclass(LivingEntity.class));var pdc=new org.bukkit.craftbukkit.persistence.CraftPersistentDataContainer(new org.bukkit.craftbukkit.persistence.CraftPersistentDataTypeRegistry());when(entity.getPersistentDataContainer()).thenReturn(pdc);when(entity.getUniqueId()).thenReturn(UUID.randomUUID());when(entity.getWorld()).thenReturn(actor.world);when(entity.getLocation()).thenReturn(((Location)call.getArgument(0)).clone());((java.util.function.Consumer<LivingEntity>)call.getArgument(2)).accept(entity);spawned.add(entity);return entity;}).when(actor.world).spawn(any(Location.class),any(Class.class),any(java.util.function.Consumer.class));
+
+            assertEquals(List.of("adventure-camp-enemies","adventure-camp-reward-coins","adventure-camp-reward-xp"),f.command.tabComplete(actor.player,"fantasystick",new String[]{"config","adventure-camp"}));
+            f.command.execute(actor.player,"fantasystick",new String[]{"config","adventure-site-radius","20"});drainOne(f);
+            var questSettings=(games.dmg.fantasystick.persistence.AdventureQuestSettings)FantasyStickLifecycleNativeTest.Fixture.field(f.plugin,"adventureQuestSettings");assertEquals(20,questSettings.rules().radius());
+            f.command.execute(actor.player,"fantasystick",new String[]{"adventure-site","place","camp","Dawn Camp"}); drainOne(f);
+            f.command.execute(actor.player,"fantasystick",new String[]{"quest-giver","place","Guide"}); drainOne(f);
+            var directory=(games.dmg.fantasystick.adventure.AdventureQuestDirectory)FantasyStickLifecycleNativeTest.Fixture.field(f.plugin,"adventureQuests");
+            assertEquals(1,directory.snapshot().sites().size());assertEquals(1,directory.snapshot().givers().size());
+            assertEquals(List.of("camp","champion"),f.command.tabComplete(actor.player,"fantasystick",new String[]{"adventure-site","place","c"}));
+            var current=directory.snapshot();var snapshotField=directory.getClass().getDeclaredField("snapshot");snapshotField.setAccessible(true);snapshotField.set(directory,new games.dmg.fantasystick.adventure.AdventureQuestState(current.sites(),current.givers(),null,current.quests(),current.unitClaims(),current.characterClaims(),current.rosters()));directory.ensureToday().get(5,java.util.concurrent.TimeUnit.SECONDS);
+            var controller=(games.dmg.fantasystick.adventure.AdventureQuestController)FantasyStickLifecycleNativeTest.Fixture.field(f.plugin,"adventureQuestController");controller.reconcile(chunk);
+            var giver=spawned.stream().filter(Villager.class::isInstance).map(Villager.class::cast).findFirst().orElseThrow();verify(giver,atLeastOnce()).setAI(false);verify(giver,atLeastOnce()).setGravity(false);verify(giver,atLeastOnce()).setInvulnerable(true);verify(giver,atLeastOnce()).setCollidable(false);
+            f.activate(actor);int books=actor.books.size();var interaction=new PlayerInteractEntityEvent(actor.player,giver,EquipmentSlot.HAND);f.dispatcher.accept(interaction);drainOne(f);assertTrue(interaction.isCancelled());assertEquals(books,actor.books.size());assertFalse(actor.inventories.isEmpty());int menus=actor.inventories.size();var duplicate=new PlayerInteractEntityEvent(actor.player,giver,EquipmentSlot.OFF_HAND);f.dispatcher.accept(duplicate);assertTrue(duplicate.isCancelled());assertEquals(menus,actor.inventories.size());
+            var menu=actor.inventories.getLast();assertFalse(menu.getItem(0).getItemMeta().lore().stream().map(Object::toString).anyMatch(line->line.contains("0.0")),"Coordinates stay hidden before acceptance");var originalCatalog=directory.snapshot().catalog();
+            doReturn(false).when(actor.player).hasPermission("fantasystick.admin");f.command.execute(actor.player,"fantasystick",new String[]{"adventure","reroll","confirm"});assertTrue(actor.messages.getLast().contains("Permission denied"));assertTrue(f.command.tabComplete(actor.player,"fantasystick",new String[]{"adventure",""}).isEmpty());assertEquals(originalCatalog,directory.snapshot().catalog());doReturn(true).when(actor.player).hasPermission("fantasystick.admin");f.command.execute(actor.player,"fantasystick",new String[]{"adventure","reroll","confirm","extra"});assertTrue(actor.messages.getLast().contains("Usage"));assertEquals(originalCatalog,directory.snapshot().catalog());
+            f.command.execute(actor.player,"fantasystick",new String[]{"adventure","reroll"});assertTrue(actor.messages.getLast().contains("confirm"));assertEquals(originalCatalog,directory.snapshot().catalog());assertEquals(List.of("reroll"),f.command.tabComplete(actor.player,"fantasystick",new String[]{"adventure","r"}));assertEquals(List.of("confirm"),f.command.tabComplete(actor.player,"fantasystick",new String[]{"adventure","reroll","c"}));
+            f.command.execute(actor.player,"fantasystick",new String[]{"adventure","reroll","confirm"});drainOne(f);assertNotEquals(originalCatalog.revision(),directory.snapshot().catalog().revision());assertTrue(actor.messages.getLast().contains("Rerolled")&&actor.messages.getLast().contains("expires"));
+            var stale=mock(InventoryClickEvent.class);when(stale.getWhoClicked()).thenReturn(actor.player);when(stale.getInventory()).thenReturn(menu);when(stale.getCurrentItem()).thenReturn(menu.getItem(0));controller.click(stale);drainOne(f);assertTrue(actor.messages.getLast().contains("stale"));
+            f.dispatcher.accept(new PlayerInteractEntityEvent(actor.player,giver,EquipmentSlot.HAND));drainOne(f);menu=actor.inventories.getLast();var click=mock(InventoryClickEvent.class);when(click.getWhoClicked()).thenReturn(actor.player);when(click.getInventory()).thenReturn(menu);when(click.getCurrentItem()).thenReturn(menu.getItem(0));controller.click(click);drainOne(f);
+            assertTrue(actor.messages.stream().anyMatch(message->message.contains("Accepted")&&message.contains("Dawn Camp")));
+            f.command.execute(actor.player,"fantasystick",new String[]{"adventure"});assertTrue(actor.messages.getLast().contains("Dawn Camp"));assertTrue(actor.messages.getLast().contains("0.0"));
+            var partyA=new FantasyStickLifecycleNativeTest.Actor(data);var partyB=new FantasyStickLifecycleNativeTest.Actor(data);partyA.core.location.setWorld(actor.world);partyB.core.location.setWorld(actor.world);f.players.put(partyA.core.id,partyA.player);f.players.put(partyB.core.id,partyB.player);f.activate(partyA);f.activate(partyB);var parties=PartyLifecycleNativeTest.parties(f);var party=parties.create(partyA.core.id).orElseThrow();assertTrue(parties.accept(partyB.core.id,parties.invite(partyA.core.id,party.id(),partyB.core.id).orElseThrow().id()));var catalog=directory.snapshot().catalog();var siteId=catalog.sites().getFirst();assertEquals(games.dmg.fantasystick.adventure.AdventureQuestDirectory.Acceptance.APPLIED,directory.accept(catalog.revision(),siteId,games.dmg.fantasystick.adventure.AdventureQuestState.UnitType.PARTY,party.id(),Set.of(partyA.core.record.id(),partyB.core.record.id())).get(5,java.util.concurrent.TimeUnit.SECONDS).status());
+            var storage=(games.dmg.fantasystick.persistence.CharacterStorage)FantasyStickLifecycleNativeTest.Fixture.field(f.plugin,"characters");var actorCoins=storage.find(actor.core.record.id()).get().orElseThrow().coins();var partyACoins=storage.find(partyA.core.record.id()).get().orElseThrow().coins();var partyBCoins=storage.find(partyB.core.record.id()).get().orElseThrow().coins();
+
+            for(Runnable pulse:List.copyOf(f.pulses))pulse.run();drainOne(f);
+            var enemies=spawned.stream().filter(entity->!(entity instanceof Villager)).toList();assertEquals(4,enemies.size());var activeCatalog=directory.snapshot().catalog();f.command.execute(actor.player,"fantasystick",new String[]{"adventure","reroll","confirm"});assertEquals(activeCatalog,directory.snapshot().catalog());assertTrue(actor.messages.getLast().contains("active"));
+            var enemy=enemies.getFirst();var outsider=new FantasyStickLifecycleNativeTest.Actor(data);outsider.core.location.setWorld(actor.world);f.players.put(outsider.core.id,outsider.player);var outsiderSource=mock(org.bukkit.damage.DamageSource.class);when(outsiderSource.getCausingEntity()).thenReturn(outsider.player);when(outsiderSource.getDirectEntity()).thenReturn(outsider.player);var refusedHit=new org.bukkit.event.entity.EntityDamageByEntityEvent(outsider.player,enemy,org.bukkit.event.entity.EntityDamageEvent.DamageCause.ENTITY_ATTACK,outsiderSource,1);f.dispatcher.accept(refusedHit);assertTrue(refusedHit.isCancelled());var enemySource=mock(org.bukkit.damage.DamageSource.class);when(enemySource.getCausingEntity()).thenReturn(enemy);when(enemySource.getDirectEntity()).thenReturn(enemy);var refusedAttack=new org.bukkit.event.entity.EntityDamageByEntityEvent(enemy,outsider.player,org.bukkit.event.entity.EntityDamageEvent.DamageCause.ENTITY_ATTACK,enemySource,1);f.dispatcher.accept(refusedAttack);assertTrue(refusedAttack.isCancelled());var targetEvent=new org.bukkit.event.entity.EntityTargetLivingEntityEvent(enemy,outsider.player,org.bukkit.event.entity.EntityTargetEvent.TargetReason.CLOSEST_PLAYER);f.dispatcher.accept(targetEvent);assertTrue(targetEvent.isCancelled());
+            var source=mock(org.bukkit.damage.DamageSource.class);when(source.getCausingEntity()).thenReturn(actor.player);when(source.getDirectEntity()).thenReturn(actor.player);
+            var hit=new org.bukkit.event.entity.EntityDamageByEntityEvent(actor.player,enemy,org.bukkit.event.entity.EntityDamageEvent.DamageCause.ENTITY_ATTACK,source,1);f.dispatcher.accept(hit);assertFalse(hit.isCancelled());
+            var attemptsField=controller.getClass().getDeclaredField("attempts");attemptsField.setAccessible(true);var attempts=(Map<?,?>)attemptsField.get(controller);assertEquals(1,attempts.size());var attempt=attempts.values().iterator().next();var representedField=attempt.getClass().getDeclaredField("represented");representedField.setAccessible(true);assertEquals(1,((Set<?>)representedField.get(attempt)).size());var recipientsMethod=controller.getClass().getDeclaredMethod("recipients",games.dmg.fantasystick.adventure.AdventureQuestState.Quest.class,UUID.class);recipientsMethod.setAccessible(true);var activeQuest=directory.active().getFirst();assertEquals(List.of(actor.core.record.id()),recipientsMethod.invoke(controller,activeQuest,activeQuest.site()));
+            for(var value:enemies){var death=new org.bukkit.event.entity.EntityDeathEvent(value,source,new ArrayList<>(),7);f.dispatcher.accept(death);assertEquals(0,death.getDroppedExp());assertTrue(death.getDrops().isEmpty());}
+            assertTrue(((Map<?,?>)attemptsField.get(controller)).isEmpty());
+            for(int i=0;i<50&&(directory.active().size()!=1||storage.find(actor.core.record.id()).get().orElseThrow().experience().signum()==0);i++){var task=f.tasks.poll(100,java.util.concurrent.TimeUnit.MILLISECONDS);if(task!=null)task.run();Thread.sleep(10);}
+            var saved=storage.find(actor.core.record.id()).get().orElseThrow();assertEquals(java.math.BigInteger.valueOf(100),saved.experience());assertEquals(actorCoins.add(java.math.BigInteger.valueOf(20)),saved.coins());assertEquals(1,directory.active().size(),"Unrepresented party retains its quest");assertEquals(java.math.BigInteger.ZERO,storage.find(partyA.core.record.id()).get().orElseThrow().experience());assertEquals(java.math.BigInteger.ZERO,storage.find(partyB.core.record.id()).get().orElseThrow().experience());
+            int priorEnemies=enemies.size();for(Runnable pulse:List.copyOf(f.pulses))pulse.run();drainOne(f);var second=spawned.stream().filter(entity->!(entity instanceof Villager)).skip(priorEnemies).toList();assertEquals(4,second.size());var partySource=mock(org.bukkit.damage.DamageSource.class);when(partySource.getCausingEntity()).thenReturn(partyA.player);when(partySource.getDirectEntity()).thenReturn(partyA.player);var partyHit=new org.bukkit.event.entity.EntityDamageByEntityEvent(partyA.player,second.getFirst(),org.bukkit.event.entity.EntityDamageEvent.DamageCause.ENTITY_ATTACK,partySource,1);f.dispatcher.accept(partyHit);for(var value:second)f.dispatcher.accept(new org.bukkit.event.entity.EntityDeathEvent(value,partySource,new ArrayList<>(),0));for(int i=0;i<50&&!directory.active().isEmpty();i++){var task=f.tasks.poll(100,java.util.concurrent.TimeUnit.MILLISECONDS);if(task!=null)task.run();Thread.sleep(10);}var savedA=storage.find(partyA.core.record.id()).get().orElseThrow();var savedB=storage.find(partyB.core.record.id()).get().orElseThrow();assertEquals(java.math.BigInteger.valueOf(100),savedA.experience().add(savedB.experience()));assertTrue(savedA.experience().signum()>0&&savedB.experience().signum()>0,"Present non-attacker shares party reward");assertEquals(java.math.BigInteger.valueOf(20),savedA.coins().subtract(partyACoins).add(savedB.coins().subtract(partyBCoins)));assertTrue(directory.active().isEmpty());var completedCatalog=directory.snapshot().catalog();assertFalse(directory.snapshot().rosters().isEmpty());f.command.execute(actor.player,"fantasystick",new String[]{"adventure","reroll","confirm"});drainOne(f);var replacement=directory.snapshot().catalog();assertNotEquals(completedCatalog.revision(),replacement.revision());assertTrue(directory.snapshot().rosters().isEmpty());assertEquals(games.dmg.fantasystick.adventure.AdventureQuestDirectory.Acceptance.CLAIMED,directory.accept(replacement.revision(),replacement.sites().getFirst(),games.dmg.fantasystick.adventure.AdventureQuestState.UnitType.SOLO,actor.core.record.id(),Set.of(actor.core.record.id())).get(5,java.util.concurrent.TimeUnit.SECONDS).status());
+        }
+    }
+
+    private static void drainOne(FantasyStickLifecycleNativeTest.Fixture f)throws Exception{var task=f.tasks.poll(5,java.util.concurrent.TimeUnit.SECONDS);assertNotNull(task);task.run();}
+}

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

@@ -28,6 +28,7 @@ class BasicAttackNativeTest {
             var basic = new games.dmg.fantasystick.combat.BasicAttack(sessions, clock);
             var target = mock(org.bukkit.entity.LivingEntity.class);
             var cancelled = new java.util.concurrent.atomic.AtomicBoolean(true);
+            var zero = new java.util.concurrent.atomic.AtomicBoolean(false);
             doAnswer(call -> {
                 var source = mock(org.bukkit.damage.DamageSource.class);
                 when(source.getCausingEntity()).thenReturn(a.player);
@@ -35,6 +36,7 @@ class BasicAttackNativeTest {
                 var event = new org.bukkit.event.entity.EntityDamageByEntityEvent(a.player, target,
                     org.bukkit.event.entity.EntityDamageEvent.DamageCause.ENTITY_ATTACK, source, (Double) call.getArgument(0));
                 event.setCancelled(cancelled.get());
+                if (zero.get()) event.setDamage(0);
                 basic.acceptedDamage(event);
                 return null;
             }).when(target).damage(anyDouble(), same(a.player));
@@ -43,12 +45,13 @@ class BasicAttackNativeTest {
                 games.dmg.fantasystick.session.ControlInput.Gesture.ATTACK, target, 0, 1,
                 () -> sessions.current(active));
             basic.accept(input); // Cancelled: no cadence spent.
-            cancelled.set(false);
-            basic.accept(input); // Accepted at t=0.
+            cancelled.set(false); zero.set(true);
+            basic.accept(input); // Zero final damage: no cadence spent.
+            zero.set(false); basic.accept(input); // Accepted at t=0.
             clock.advance(java.time.Duration.ofMillis(999)); basic.accept(input);
-            verify(target, times(2)).damage(1.0, a.player);
-            clock.advance(java.time.Duration.ofMillis(1)); basic.accept(input);
             verify(target, times(3)).damage(1.0, a.player);
+            clock.advance(java.time.Duration.ofMillis(1)); basic.accept(input);
+            verify(target, times(4)).damage(1.0, a.player);
             a.core.inventory.setItemInOffHand(null); f.changed(a);
             clock.advance(java.time.Duration.ofSeconds(1)); basic.accept(input);
             verifyNoMoreInteractions(target);
@@ -80,11 +83,40 @@ class BasicAttackNativeTest {
             assertTrue(parties.leave(a.core.id, party.id()));
             f.dispatcher.accept(new io.papermc.paper.event.player.PrePlayerAttackEntityEvent(a.player, b.player, true));
             assertEquals(2, events.size()); assertFalse(events.getLast().isCancelled());
+            String feedback = "Basic Attack did 1 damage to " + b.core.record.name() + ".";
+            assertEquals(1, a.messages.stream().filter(feedback::equals).count());
+            assertEquals(0, b.messages.stream().filter(feedback::equals).count(), "Targets receive no incoming-damage report");
             f.dispatcher.accept(new io.papermc.paper.event.player.PrePlayerAttackEntityEvent(a.player, b.player, true));
             assertEquals(2, events.size(), "The accepted second hit starts cadence; the cancelled first hit did not");
         }
     }
 
+    @Test void packagedBasicStickUsesBasePlusStrengthModifierAcrossApprovedBoundaries() throws Exception {
+        try (var f = new FantasyStickLifecycleNativeTest.Fixture(data)) {
+            f.plugin.setEnabled(true);
+            int[] strengths = {0, 9, 10, 11, 12, 13, 14, 15};
+            double[] expected = {1, 1, 1, 1, 2, 2, 3, 3};
+            for (int index = 0; index < strengths.length; index++) {
+                var actor = new FantasyStickLifecycleNativeTest.Actor(data);
+                withStrength(data, actor, java.math.BigInteger.valueOf(strengths[index]));
+                f.players.put(actor.core.id, actor.player); f.activate(actor);
+                actor.core.inventory.getInventory().setSelectedSlot(1);
+                var target = mock(org.bukkit.entity.LivingEntity.class);
+                var attack = new io.papermc.paper.event.player.PrePlayerAttackEntityEvent(actor.player, target, true);
+                f.dispatcher.accept(attack);
+                assertTrue(attack.isCancelled()); verify(target).damage(expected[index], actor.player);
+                actor.core.inventory.setItemInOffHand(null); f.changed(actor); f.awaitCharacterAndReceipt(actor);
+            }
+            var actor = new FantasyStickLifecycleNativeTest.Actor(data);
+            withStrength(data, actor, java.math.BigInteger.TEN.pow(1000));
+            f.players.put(actor.core.id, actor.player); f.activate(actor);
+            actor.core.inventory.getInventory().setSelectedSlot(1);
+            var target = mock(org.bukkit.entity.LivingEntity.class);
+            f.dispatcher.accept(new io.papermc.paper.event.player.PrePlayerAttackEntityEvent(actor.player, target, true));
+            verify(target).damage(Double.MAX_VALUE, actor.player);
+        }
+    }
+
     @Test void packagedBasicStickInputDealsOneLowStrengthHitWithoutVanillaContinuation() throws Exception {
         try (var f = new FantasyStickLifecycleNativeTest.Fixture(data)) {
             f.plugin.setEnabled(true);
@@ -103,7 +135,20 @@ class BasicAttackNativeTest {
         }
     }
 
-    private static final class MutableClock extends Clock {
+    private static void withStrength(Path data, FantasyStickLifecycleNativeTest.Actor actor,
+                                     java.math.BigInteger strength) throws Exception {
+        var repository = new games.dmg.fantasystick.persistence.YamlCharacterRepository(data);
+        var old = repository.load(actor.core.record.id()).orElseThrow();
+        var stats = new java.util.EnumMap<>(old.stats());
+        stats.put(games.dmg.fantasystick.progression.Stat.STR, strength);
+        repository.replace(new games.dmg.fantasystick.persistence.CharacterRecord(old.id(), old.name(),
+            old.revision().add(java.math.BigInteger.ONE), stats, old.level(), old.experience(), old.unspentPoints(),
+            old.health(), old.learned(), old.loadout(), old.passives(), old.cooldowns(), old.restrictedKills(),
+            false, null, null, old.coins(), old.coinsInitialized(), old.rewardReceipts(), old.pvpCoinEscrow(), old.gear()),
+            old.revision());
+    }
+
+    static final class MutableClock extends Clock {
         private Instant now;
         MutableClock(Instant now) { this.now = now; }
         void advance(java.time.Duration duration) { now = now.plus(duration); }

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

@@ -40,6 +40,7 @@ class ChainLightningNativeTest {
             PartyBookNativeTest.click(fixture, caster, button(caster, "[Learn]", "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);
+            when(first.getName()).thenReturn("Zombie"); when(second.getName()).thenReturn("Skeleton");
             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);
@@ -51,6 +52,8 @@ class ChainLightningNativeTest {
             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);
+            assertEquals(1, caster.messages.stream().filter("Chain Lightning did 13 damage to Zombie."::equals).count());
+            assertEquals(1, caster.messages.stream().filter("Chain Lightning did 9.75 damage to Skeleton."::equals).count());
             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"));
@@ -58,6 +61,49 @@ class ChainLightningNativeTest {
         }
     }
 
+    @SuppressWarnings("unchecked")
+    @Test void chainedDamageMeasuresEachTrainingDummyIndependentlyWithoutContribution() throws Exception {
+        try (var fixture = new FantasyStickLifecycleNativeTest.Fixture(data)) {
+            fixture.plugin.setEnabled(true); var caster = new FantasyStickLifecycleNativeTest.Actor(data); prepareCaster(data, caster, true);
+            fixture.players.put(caster.core.id, caster.player); fixture.activate(caster);
+            UUID worldId = UUID.randomUUID(); when(caster.world.getUID()).thenReturn(worldId);
+            var directory = (games.dmg.fantasystick.training.TrainingDummyDirectory)
+                FantasyStickLifecycleNativeTest.Fixture.field(fixture.plugin, "trainingDummies");
+            var firstRecord = directory.place("First Target", worldId, 10, 64, 0, 0, 0).get();
+            var secondRecord = directory.place("Second Target", worldId, 14, 64, 0, 0, 0).get();
+            int chunkX = 0, chunkZ = 0; var chunk = mock(org.bukkit.Chunk.class); when(chunk.getWorld()).thenReturn(caster.world);
+            when(chunk.getX()).thenReturn(chunkX); when(chunk.getZ()).thenReturn(chunkZ); when(chunk.getEntities()).thenReturn(new org.bukkit.entity.Entity[0]);
+            when(caster.world.isChunkLoaded(chunkX, chunkZ)).thenReturn(true);
+            var first = TrainingDummyNativeTest.zombie(new Location(caster.world, firstRecord.x(), firstRecord.y(), firstRecord.z()));
+            var second = TrainingDummyNativeTest.zombie(new Location(caster.world, secondRecord.x(), secondRecord.y(), secondRecord.z()));
+            when(first.getName()).thenReturn("First Target"); when(second.getName()).thenReturn("Second Target");
+            var spawning = new ArrayDeque<>(List.of(first, second));
+            doAnswer(call -> { var dummy = spawning.removeFirst(); ((java.util.function.Consumer<org.bukkit.entity.Zombie>) call.getArgument(2)).accept(dummy); return dummy; })
+                .when(caster.world).spawn(any(Location.class), eq(org.bukkit.entity.Zombie.class), any(java.util.function.Consumer.class));
+            var controller = (games.dmg.fantasystick.training.TrainingDummyController)
+                FantasyStickLifecycleNativeTest.Fixture.field(fixture.plugin, "trainingDummyController");
+            controller.reconcile(chunk); assertTrue(controller.tagged(first)); assertTrue(controller.tagged(second));
+            assertTrue(controller.target(first)); assertTrue(controller.target(second));
+            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(true).when(first).hasLineOfSight(second);
+            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());
+            var events = new ArrayList<EntityDamageEvent>();
+            for (var target : List.of(first, second)) doAnswer(call -> {
+                var source = (DamageSource) call.getArgument(1);
+                var event = new EntityDamageEvent(target, EntityDamageEvent.DamageCause.LIGHTNING, source, (Double) call.getArgument(0));
+                events.add(event); fixture.dispatcher.accept(event); return null;
+            }).when(target).damage(anyDouble(), any(DamageSource.class));
+            use(fixture, caster); drain(fixture, 2);
+            assertEquals(2, events.size()); assertTrue(events.stream().allMatch(EntityDamageEvent::isCancelled));
+            assertEquals(1, caster.messages.stream().filter("Chain Lightning did 13 damage to First Target."::equals).count(), caster.messages::toString);
+            assertEquals(1, caster.messages.stream().filter("Chain Lightning did 9.75 damage to Second Target."::equals).count());
+        }
+    }
+
     @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);
@@ -226,6 +272,8 @@ class ChainLightningNativeTest {
         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);
+        doAnswer(call -> { ((LivingEntity) call.getArgument(0)).damage((Double) call.getArgument(1), (org.bukkit.damage.DamageSource) call.getArgument(2)); return null; })
+            .when(execution).damage(any(LivingEntity.class), anyDouble(), any(org.bukkit.damage.DamageSource.class));
         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,

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

@@ -0,0 +1,48 @@
+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 org.bukkit.*;
+import org.bukkit.attribute.Attribute;
+import org.bukkit.attribute.AttributeInstance;
+import org.bukkit.entity.*;
+import org.bukkit.event.inventory.InventoryClickEvent;
+import org.bukkit.event.player.PlayerInteractEntityEvent;
+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 ChampionQuestNativeTest {
+    @TempDir Path data;
+    @BeforeAll static void bootstrap() throws Exception { NativeRuntime.bootstrap(); }
+
+    @SuppressWarnings({"unchecked", "rawtypes"})
+    @Test void registeredChampionOfferNativeEncounterBossBarAndExactRewardUseConnectedPath() throws Exception {
+        java.nio.file.Files.writeString(data.resolve("config.yml"),
+            "adventure-daily-site-count: 1\nadventure-site-reset-seconds: 0\n"+
+            "adventure-champion-health: 100\nadventure-champion-damage: 8\n"+
+            "adventure-champion-reward-xp: 150\nadventure-champion-reward-coins: 40\n");
+        try(var f=new FantasyStickLifecycleNativeTest.Fixture(data)){
+            f.plugin.setEnabled(true);var actor=new FantasyStickLifecycleNativeTest.Actor(data);f.players.put(actor.core.id,actor.player);doReturn(true).when(actor.player).hasPermission("fantasystick.admin");
+            UUID worldId=UUID.randomUUID();when(actor.world.getUID()).thenReturn(worldId);when(actor.world.isChunkLoaded(anyInt(),anyInt())).thenReturn(true);int chunkX=actor.core.location.getBlockX()>>4,chunkZ=actor.core.location.getBlockZ()>>4;var chunk=mock(Chunk.class);when(chunk.getWorld()).thenReturn(actor.world);when(chunk.getX()).thenReturn(chunkX);when(chunk.getZ()).thenReturn(chunkZ);when(chunk.getEntities()).thenReturn(new Entity[0]);when(actor.world.getChunkAt(anyInt(),anyInt())).thenReturn(chunk);when(actor.world.getLoadedChunks()).thenReturn(new Chunk[]{chunk});
+            var spawned=new ArrayList<LivingEntity>();var maxHealth=mock(AttributeInstance.class);when(maxHealth.getValue()).thenReturn(100.0);var attack=mock(AttributeInstance.class);
+            doAnswer(call->{Class<?> type=call.getArgument(1);LivingEntity entity=mock(type.asSubclass(LivingEntity.class));var pdc=new org.bukkit.craftbukkit.persistence.CraftPersistentDataContainer(new org.bukkit.craftbukkit.persistence.CraftPersistentDataTypeRegistry());when(entity.getPersistentDataContainer()).thenReturn(pdc);when(entity.getUniqueId()).thenReturn(UUID.randomUUID());when(entity.getWorld()).thenReturn(actor.world);when(entity.getLocation()).thenReturn(((Location)call.getArgument(0)).clone());when(entity.getHealth()).thenReturn(100.0);if(entity instanceof Vindicator){when(entity.getAttribute(Attribute.MAX_HEALTH)).thenReturn(maxHealth);when(entity.getAttribute(Attribute.ATTACK_DAMAGE)).thenReturn(attack);}((java.util.function.Consumer<LivingEntity>)call.getArgument(2)).accept(entity);spawned.add(entity);return entity;}).when(actor.world).spawn(any(Location.class),any(Class.class),any(java.util.function.Consumer.class));
+
+            assertEquals(List.of("adventure-champion-damage","adventure-champion-health","adventure-champion-reward-coins","adventure-champion-reward-xp"),f.command.tabComplete(actor.player,"fantasystick",new String[]{"config","adventure-champion"}));
+            assertEquals(List.of("champion"),f.command.tabComplete(actor.player,"fantasystick",new String[]{"adventure-site","place","ch"}));
+            f.command.execute(actor.player,"fantasystick",new String[]{"config","adventure-champion-damage","9"});drainOne(f);assertEquals(List.of("8","9"),f.command.tabComplete(actor.player,"fantasystick",new String[]{"config","adventure-champion-damage",""}));
+            f.command.execute(actor.player,"fantasystick",new String[]{"adventure-site","place","champion","Summit"});drainOne(f);f.command.execute(actor.player,"fantasystick",new String[]{"quest-giver","place","Guide"});drainOne(f);
+            var directory=(games.dmg.fantasystick.adventure.AdventureQuestDirectory)FantasyStickLifecycleNativeTest.Fixture.field(f.plugin,"adventureQuests");var current=directory.snapshot();var snapshotField=directory.getClass().getDeclaredField("snapshot");snapshotField.setAccessible(true);snapshotField.set(directory,new games.dmg.fantasystick.adventure.AdventureQuestState(current.sites(),current.givers(),null,current.quests(),current.unitClaims(),current.characterClaims(),current.rosters()));directory.ensureToday().get(5,java.util.concurrent.TimeUnit.SECONDS);
+            var controller=(games.dmg.fantasystick.adventure.AdventureQuestController)FantasyStickLifecycleNativeTest.Fixture.field(f.plugin,"adventureQuestController");controller.reconcile(chunk);var giver=spawned.stream().filter(Villager.class::isInstance).map(Villager.class::cast).findFirst().orElseThrow();f.activate(actor);var member=new FantasyStickLifecycleNativeTest.Actor(data);member.core.location.setWorld(actor.world);f.players.put(member.core.id,member.player);f.activate(member);var parties=PartyLifecycleNativeTest.parties(f);var party=parties.create(actor.core.id).orElseThrow();assertTrue(parties.accept(member.core.id,parties.invite(actor.core.id,party.id(),member.core.id).orElseThrow().id()));f.dispatcher.accept(new PlayerInteractEntityEvent(actor.player,giver,EquipmentSlot.HAND));drainOne(f);var menu=actor.inventories.getLast();var lore=menu.getItem(0).getItemMeta().lore().toString();assertTrue(lore.contains("Champion"));assertTrue(lore.contains("150 XP, 40 coins"));var click=mock(InventoryClickEvent.class);when(click.getWhoClicked()).thenReturn(actor.player);when(click.getInventory()).thenReturn(menu);when(click.getCurrentItem()).thenReturn(menu.getItem(0));controller.click(click);drainOne(f);
+            var solo=new FantasyStickLifecycleNativeTest.Actor(data);solo.core.location.setWorld(actor.world);f.players.put(solo.core.id,solo.player);f.activate(solo);var catalog=directory.snapshot().catalog();var site=catalog.sites().getFirst();assertEquals(games.dmg.fantasystick.adventure.AdventureQuestDirectory.Acceptance.APPLIED,directory.accept(catalog.revision(),site,games.dmg.fantasystick.adventure.AdventureQuestState.UnitType.SOLO,solo.core.record.id(),Set.of(solo.core.record.id())).get(5,java.util.concurrent.TimeUnit.SECONDS).status());var storage=(games.dmg.fantasystick.persistence.CharacterStorage)FantasyStickLifecycleNativeTest.Fixture.field(f.plugin,"characters");var initial=storage.find(actor.core.record.id()).get().orElseThrow();var memberInitial=storage.find(member.core.record.id()).get().orElseThrow();var soloInitial=storage.find(solo.core.record.id()).get().orElseThrow();for(Runnable pulse:List.copyOf(f.pulses))pulse.run();var champion=spawned.stream().filter(Vindicator.class::isInstance).map(Vindicator.class::cast).findFirst().orElseThrow();verify(maxHealth).setBaseValue(100);verify(attack).setBaseValue(9);verify(champion).setHealth(100);verify(champion).customName(argThat(component->component.toString().contains("Daybreak Champion")));assertEquals(1,f.bossBars.size());verify(f.bossBars.getFirst()).addPlayer(actor.player);verify(f.bossBars.getFirst()).addPlayer(member.player);verify(f.bossBars.getFirst()).addPlayer(solo.player);member.core.location.setX(100);for(Runnable pulse:List.copyOf(f.pulses))pulse.run();verify(f.bossBars.getFirst()).removePlayer(member.player);member.core.location.setX(0);for(Runnable pulse:List.copyOf(f.pulses))pulse.run();verify(f.bossBars.getFirst(),atLeast(2)).addPlayer(member.player);f.command.execute(actor.player,"fantasystick",new String[]{"config","adventure-champion-health","120"});drainOne(f);f.command.execute(actor.player,"fantasystick",new String[]{"config","adventure-champion-damage","10"});drainOne(f);verify(maxHealth,times(1)).setBaseValue(100);verify(attack,times(1)).setBaseValue(9);
+            var source=mock(org.bukkit.damage.DamageSource.class);when(source.getCausingEntity()).thenReturn(actor.player);when(source.getDirectEntity()).thenReturn(actor.player);var cancelled=new org.bukkit.event.entity.EntityDamageByEntityEvent(actor.player,champion,org.bukkit.event.entity.EntityDamageEvent.DamageCause.ENTITY_ATTACK,source,1);cancelled.setCancelled(true);f.dispatcher.accept(cancelled);verify(f.bossBars.getFirst(),never()).setProgress(0.99);var hit=new org.bukkit.event.entity.EntityDamageByEntityEvent(actor.player,champion,org.bukkit.event.entity.EntityDamageEvent.DamageCause.ENTITY_ATTACK,source,1);f.dispatcher.accept(hit);assertFalse(hit.isCancelled());verify(f.bossBars.getFirst()).setProgress(0.99);var death=new org.bukkit.event.entity.EntityDeathEvent(champion,source,new ArrayList<>(),9);f.dispatcher.accept(death);assertEquals(0,death.getDroppedExp());assertTrue(death.getDrops().isEmpty());for(int i=0;i<50&&(directory.active().size()!=1||storage.find(actor.core.record.id()).get().orElseThrow().experience().signum()==0);i++){var task=f.tasks.poll(100,java.util.concurrent.TimeUnit.MILLISECONDS);if(task!=null)task.run();Thread.sleep(10);}var saved=storage.find(actor.core.record.id()).get().orElseThrow();var savedMember=storage.find(member.core.record.id()).get().orElseThrow();assertEquals(java.math.BigInteger.valueOf(150),saved.experience().subtract(initial.experience()).add(savedMember.experience().subtract(memberInitial.experience())));assertEquals(java.math.BigInteger.valueOf(40),saved.coins().subtract(initial.coins()).add(savedMember.coins().subtract(memberInitial.coins())));assertEquals(1,directory.active().size(),"Unrepresented solo quest remains");verify(f.bossBars.getFirst(),atLeastOnce()).removeAll();
+            for(Runnable pulse:List.copyOf(f.pulses))pulse.run();var second=spawned.stream().filter(Vindicator.class::isInstance).map(Vindicator.class::cast).skip(1).findFirst().orElseThrow();assertEquals(2,f.bossBars.size());verify(maxHealth).setBaseValue(120);verify(attack).setBaseValue(10);verify(second).setHealth(120);var soloSource=mock(org.bukkit.damage.DamageSource.class);when(soloSource.getCausingEntity()).thenReturn(solo.player);when(soloSource.getDirectEntity()).thenReturn(solo.player);f.dispatcher.accept(new org.bukkit.event.entity.EntityDamageByEntityEvent(solo.player,second,org.bukkit.event.entity.EntityDamageEvent.DamageCause.ENTITY_ATTACK,soloSource,1));f.dispatcher.accept(new org.bukkit.event.entity.EntityDeathEvent(second,soloSource,new ArrayList<>(),0));for(int i=0;i<50&&!directory.active().isEmpty();i++){var task=f.tasks.poll(100,java.util.concurrent.TimeUnit.MILLISECONDS);if(task!=null)task.run();Thread.sleep(10);}var savedSolo=storage.find(solo.core.record.id()).get().orElseThrow();assertEquals(soloInitial.experience().add(java.math.BigInteger.valueOf(150)),savedSolo.experience());assertEquals(soloInitial.coins().add(java.math.BigInteger.valueOf(40)),savedSolo.coins());verify(f.bossBars.get(1),atLeastOnce()).removeAll();
+        }
+    }
+    private static void drainOne(FantasyStickLifecycleNativeTest.Fixture f)throws Exception{var task=f.tasks.poll(5,java.util.concurrent.TimeUnit.SECONDS);assertNotNull(task);task.run();}
+}

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

@@ -327,30 +327,67 @@ class CharacterBookNativeTest {
             assertTrue(pages.size() <= 100, "Keep each native linked-book view bounded");
             assertTrue(pages.get(0).getString().contains("STR: 0 [+1 STR]"));
             assertTrue(pages.get(0).getString().contains("INT: 12 [+1 INT]"));
-            assertTrue(pages.get(1).getString().startsWith("Active abilities"));
-            assertTrue(pages.get(1).getString().contains("3: No Ability"));
+            assertTrue(pages.get(1).getString().startsWith("Gear\n\nHead: Cosmetic\nChestplate:"));
+            assertFalse(pages.get(1).getString().contains("Current gear"));
+            assertFalse(pages.get(1).getString().contains("Cosmetic\nonly"));
+            assertTrue(pages.get(2).getString().startsWith("Active abilities"));
+            assertTrue(pages.get(2).getString().contains("3: No Ability"));
             int index = firstPageStarting(pages, "Ability index");
-            assertTrue(index > 1);
-            var indexedNames = new java.util.ArrayList<String>();
+            assertTrue(index > 2);
+            var categorized = new java.util.LinkedHashMap<String, java.util.List<String>>();
+            var indexPageByAbility = new java.util.HashMap<String, Integer>();
             int partyPage = firstPageStarting(pages, "Party");
             for (int page = index; page < pages.size() && pages.get(page).getString().startsWith("Ability index"); page++) {
-                for (String line : pages.get(page).getString().split("\\n")) if (!line.isBlank() && !line.equals("Ability index")) {
-                    indexedNames.add(line);
-                    var jump = changePage(pages.get(page), line);
-                    assertNotNull(jump, line);
+                var lines = pages.get(page).getString().split("\\n");
+                assertTrue(lines.length >= 2); String category = lines[1];
+                assertTrue(java.util.List.of("ATK", "BUF", "HEAL").contains(category));
+                var names = categorized.computeIfAbsent(category, ignored -> new java.util.ArrayList<>());
+                for (int line = 2; line < lines.length; line++) if (!lines[line].isBlank()) {
+                    names.add(lines[line]); indexPageByAbility.put(lines[line], page);
+                    var jump = changePage(pages.get(page), lines[line]);
+                    assertNotNull(jump, lines[line]);
                     assertTrue(jump.page() - 1 < partyPage, "Ability details must precede party controls");
                 }
             }
-            var sortedNames = indexedNames.stream().sorted().toList();
-            assertEquals(sortedNames, indexedNames);
-            assertEquals(20, indexedNames.size());
+            assertEquals(java.util.List.of("ATK", "BUF", "HEAL"), new java.util.ArrayList<>(categorized.keySet()));
+            assertEquals(java.util.List.of("Chain Lightning", "Fireball", "Frost Nova", "Frost Shard", "Great Sword",
+                "Hex", "Longbow", "Meteor", "Shield Bash"), categorized.get("ATK"));
+            assertEquals(java.util.List.of("Guardian Bond", "Inspire", "Purify", "Quickstep", "Rallying Cry",
+                "Stone Skin", "War Banner"), categorized.get("BUF"));
+            assertEquals(java.util.List.of("Mending Light", "Revive", "Sanctuary", "Second Wind"), categorized.get("HEAL"));
+            assertEquals(20, categorized.values().stream().mapToInt(java.util.List::size).sum());
+            var detailStartByAbility = new java.util.HashMap<String, Integer>();
+            for (var entry : indexPageByAbility.entrySet()) {
+                var jump = changePage(pages.get(entry.getValue()), entry.getKey()); assertNotNull(jump);
+                detailStartByAbility.put(entry.getKey(), jump.page() - 1);
+            }
+            int passiveIndex = firstPageStarting(pages, "Passive index");
+            int firstPassiveDetail = Integer.MAX_VALUE;
+            for (int page = passiveIndex; page < pages.size() && pages.get(page).getString().startsWith("Passive index"); page++) {
+                for (String line : pages.get(page).getString().split("\\n")) if (!line.isBlank() && !line.equals("Passive index")) {
+                    var jump = changePage(pages.get(page), line); if (jump != null) firstPassiveDetail = Math.min(firstPassiveDetail, jump.page() - 1);
+                }
+            }
+            for (var entry : indexPageByAbility.entrySet()) {
+                int detailPage = detailStartByAbility.get(entry.getKey());
+                assertTrue(pages.get(detailPage).getString().startsWith(entry.getKey() + "\n"));
+                assertTrue(pages.get(detailPage).getString().split("\\n")[1].matches("ATK|BUF|HEAL"));
+                int end = firstPassiveDetail;
+                for (int other : detailStartByAbility.values()) if (other > detailPage) end = Math.min(end, other);
+                var backPages = new java.util.ArrayList<Integer>();
+                for (int candidate = detailPage; candidate < end; candidate++)
+                    if (changePage(pages.get(candidate), "[Back to index]") != null) backPages.add(candidate);
+                assertEquals(java.util.List.of(end - 1), backPages, entry.getKey());
+                var back = changePage(pages.get(end - 1), "[Back to index]"); assertNotNull(back);
+                assertEquals(entry.getValue() + 1, back.page(), entry.getKey());
+            }
             var fireballJump = changePage(pages.get(index), "Fireball");
             assertNotNull(fireballJump);
             var detail = pages.get(fireballJump.page() - 1);
-            assertTrue(detail.getString().startsWith("Fireball\nINT 12\n[Learn]"), detail.getString());
+            assertTrue(detail.getString().startsWith("Fireball\nATK\nINT 12\n[Learn]"), detail.getString());
             assertFalse(text(a.books.getLast()).contains("Cost:"));
             assertFalse(text(a.books.getLast()).contains("Requires:"));
-            assertTrue(text(a.books.getLast()).contains("Shield Bash\nSTR 12, CON 12"));
+            assertTrue(text(a.books.getLast()).contains("Shield Bash\nATK\nSTR 12, CON 12"));
             assertFalse(detail.getString().contains("Icon:"));
             assertFalse(text(a.books.getLast()).contains("Assign ability"));
             assertFalse(text(a.books.getLast()).contains("[3]"));
@@ -360,10 +397,32 @@ class CharacterBookNativeTest {
             var saved = characters(f).find(a.core.record.id()).get(5, TimeUnit.SECONDS).orElseThrow();
             assertEquals("fireball", saved.loadout().get(0));
             var refreshed = nativePages(a);
-            assertTrue(refreshed.get(1).getString().contains("3: Fireball"));
-            var activeJump = changePage(refreshed.get(1), "Fireball");
+            assertTrue(refreshed.get(2).getString().contains("3: Fireball"));
+            var activeJump = changePage(refreshed.get(2), "Fireball");
             assertNotNull(activeJump);
-            assertTrue(refreshed.get(activeJump.page() - 1).getString().startsWith("Fireball\nINT 12\n[Unlearn]"));
+            assertTrue(refreshed.get(activeJump.page() - 1).getString().startsWith("Fireball\nATK\nINT 12\n[Unlearn]"));
+        }
+    }
+
+    @Test void mixedCategorySlotsAndUnknownIdsRemainUnrestrictedAndUnchanged() throws Exception {
+        try (var f = new FantasyStickLifecycleNativeTest.Fixture(data)) {
+            f.plugin.setEnabled(true); var a = new FantasyStickLifecycleNativeTest.Actor(data);
+            var repository = new games.dmg.fantasystick.persistence.YamlCharacterRepository(data);
+            var old = repository.load(a.core.record.id()).orElseThrow();
+            var mixed = new games.dmg.fantasystick.persistence.CharacterRecord(old.id(), old.name(), old.revision().add(java.math.BigInteger.ONE),
+                old.stats(), old.level(), old.experience(), old.unspentPoints(), old.health(),
+                java.util.Set.of("fireball", "quickstep", "second_wind", "unknown_saved"),
+                java.util.List.of("fireball", "quickstep", "second_wind", "unknown_saved", "", "", ""),
+                old.cooldowns(), old.restrictedKills(), false, null, null);
+            repository.replace(mixed, old.revision()); f.players.put(a.core.id, a.player); f.activate(a); PartyBookNativeTest.open(f, a);
+            var pages = nativePages(a); var active = pages.get(firstPageStarting(pages, "Active abilities"));
+            assertTrue(active.getString().contains("3: Fireball")); assertTrue(active.getString().contains("4: Quickstep"));
+            assertTrue(active.getString().contains("5: Second Wind")); assertTrue(active.getString().contains("6: unknown_saved"));
+            for (String ability : java.util.List.of("Fireball", "Quickstep", "Second Wind")) {
+                var jump = changePage(active, ability); assertNotNull(jump, ability);
+                assertTrue(pages.get(jump.page() - 1).getString().startsWith(ability + "\n"));
+            }
+            assertEquals(mixed, characters(f).find(mixed.id()).get(5, TimeUnit.SECONDS).orElseThrow());
         }
     }
 

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

@@ -32,6 +32,48 @@ class CombatExperienceNativeTest {
             games.dmg.fantasystick.party.CombatExperience.coinTarget(wither));
         assertEquals(games.dmg.fantasystick.progression.CombatRewardRules.Target.ORDINARY,
             games.dmg.fantasystick.party.CombatExperience.classify(wither));
+        var witch = type(EntityType.WITCH);
+        assertEquals(games.dmg.fantasystick.progression.CombatRewardRules.Target.HARD,
+            games.dmg.fantasystick.party.CombatExperience.classify(witch));
+        assertEquals(games.dmg.fantasystick.progression.CoinRules.Target.HOSTILE,
+            games.dmg.fantasystick.party.CombatExperience.coinTarget(witch));
+    }
+
+    @Test void packagedWitchPoolFlowsThroughExactSoloAndPartyAllocationWithOrdinaryCoins() throws Exception {
+        try (var f = new FantasyStickLifecycleNativeTest.Fixture(data)) {
+            f.plugin.setEnabled(true);
+            var solo = new FantasyStickLifecycleNativeTest.Actor(data);
+            var a = new FantasyStickLifecycleNativeTest.Actor(data);
+            var b = new FantasyStickLifecycleNativeTest.Actor(data);
+            var c = new FantasyStickLifecycleNativeTest.Actor(data);
+            for (var actor : java.util.List.of(solo, a, b, c)) { f.players.put(actor.core.id, actor.player); f.activate(actor); }
+            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()));
+            assertTrue(parties.accept(c.core.id, parties.invite(a.core.id, party.id(), c.core.id).orElseThrow().id()));
+            var beforeCoins = record(f, solo).coins().add(record(f, a).coins())
+                .add(record(f, b).coins()).add(record(f, c).coins());
+            var world = mock(org.bukkit.World.class); when(world.getUID()).thenReturn(UUID.randomUUID());
+            var witch = mob(EntityType.WITCH, new Location(world, 10, 64, 0));
+            hit(f, solo.player, witch, false);
+            var projectile = PartyCombatNativeTest.projectile(f, a.player); hit(f, projectile, witch, false);
+            die(f, witch); settle(f); settle(f); settle(f);
+            assertEquals(java.math.BigInteger.TEN, record(f, solo).experience());
+            var partyXp = java.util.List.of(record(f, a).experience(), record(f, b).experience(), record(f, c).experience());
+            assertEquals(java.math.BigInteger.TEN,
+                partyXp.stream().reduce(java.math.BigInteger.ZERO, java.math.BigInteger::add));
+            assertEquals(java.util.List.of(java.math.BigInteger.valueOf(3), java.math.BigInteger.valueOf(3),
+                java.math.BigInteger.valueOf(4)), partyXp.stream().sorted().toList());
+            var afterCoins = record(f, solo).coins().add(record(f, a).coins())
+                .add(record(f, b).coins()).add(record(f, c).coins());
+            var delta = afterCoins.subtract(beforeCoins);
+            assertTrue(delta.compareTo(java.math.BigInteger.ONE) >= 0 && delta.compareTo(java.math.BigInteger.valueOf(5)) <= 0,
+                "Witch uses one ordinary hostile coin pool");
+            assertTrue(solo.messages.stream().anyMatch(message -> message.contains("10") && message.contains("XP")));
+            solo.core.inventory.getInventory().setSelectedSlot(0); PartyBookNativeTest.open(f, solo);
+            assertTrue(PartyBookNativeTest.text(solo).contains("XP: 10/100"));
+            die(f, witch); settle(f);
+            assertEquals(java.math.BigInteger.TEN, record(f, solo).experience(), "Duplicate death callbacks are consumed once");
+        }
     }
 
     @Test void packagedBasicAttackToBossDeathPersistsLevelAndUpdatesBookFeedbackExactlyOnce() throws Exception {
@@ -197,13 +239,13 @@ class CombatExperienceNativeTest {
         var failed = new java.util.concurrent.CompletableFuture<games.dmg.fantasystick.persistence.CharacterStorage.CombatAward>();
         failed.completeExceptionally(new java.io.IOException("simulated write failure"));
         var saved = new games.dmg.fantasystick.persistence.CharacterRecord(original.id(), original.name(), java.math.BigInteger.ONE,
-            original.stats(), original.level(), java.math.BigInteger.TEN, original.unspentPoints(), original.health(),
+            original.stats(), original.level(), java.math.BigInteger.valueOf(20), original.unspentPoints(), original.health(),
             original.learned(), original.loadout(), original.cooldowns(), original.restrictedKills(), false, null, null);
         var success = java.util.concurrent.CompletableFuture.completedFuture(
             new games.dmg.fantasystick.persistence.CharacterStorage.CombatAward(
                 games.dmg.fantasystick.persistence.CharacterStorage.CombatAwardStatus.APPLIED, java.util.Optional.of(saved), 0));
         var writes = new java.util.concurrent.atomic.AtomicInteger();
-        when(storage.awardCombatReward(eq(original.id()), any(), any(), eq(java.math.BigInteger.TEN), any(),
+        when(storage.awardCombatReward(eq(original.id()), any(), any(), eq(java.math.BigInteger.valueOf(20)), any(),
             same(progression), any(), any())).thenAnswer(ignored -> writes.getAndIncrement() == 0 ? failed : success);
         var failures = new ArrayList<games.dmg.fantasystick.party.CombatExperience.Failure>();
         var service = new games.dmg.fantasystick.party.CombatExperience(storage, progression,
@@ -211,13 +253,14 @@ class CombatExperienceNativeTest {
             java.time.Clock.fixed(java.time.Instant.parse("2026-09-19T20:00:00Z"), java.time.ZoneOffset.UTC), Runnable::run,
             ignored -> attacker, failures::add);
         var world = mock(org.bukkit.World.class); when(world.getUID()).thenReturn(UUID.randomUUID());
-        var target = mob(EntityType.ZOMBIE, new Location(world, 0, 64, 0));
+        var target = mob(EntityType.WITCH, new Location(world, 0, 64, 0));
         var damageSource = mock(org.bukkit.damage.DamageSource.class);
         when(damageSource.getDirectEntity()).thenReturn(attacker); when(damageSource.getCausingEntity()).thenReturn(attacker);
         service.damage(new EntityDamageByEntityEvent(attacker, target, DamageCause.ENTITY_ATTACK, damageSource, 1));
         service.mobDeath(new org.bukkit.event.entity.EntityDeathEvent(target, damageSource, new ArrayList<>(), 0));
         verify(storage, times(1)).awardCombatReward(eq(original.id()), any(), any(), any(), any(), any(), any(), any());
         assertEquals(1, failures.size());
+        service.configure(service.rules().withHardPool(java.math.BigInteger.valueOf(25)));
         service.retryPending();
         verify(storage, times(2)).awardCombatReward(eq(original.id()), any(), any(), any(), any(), any(), any(), any());
         service.mobDeath(new org.bukkit.event.entity.EntityDeathEvent(target, damageSource, new ArrayList<>(), 0));
@@ -261,6 +304,40 @@ class CombatExperienceNativeTest {
         }
     }
 
+    @Test void hardMobXpCommandPersistsBeforePublishingAndAffectsOnlyFutureWitchDefeats() throws Exception {
+        java.nio.file.Files.writeString(data.resolve("config.yml"),
+            "hard-mob-xp: 25\nunrelated: retained\n");
+        try (var f = new FantasyStickLifecycleNativeTest.Fixture(data)) {
+            f.plugin.setEnabled(true);
+            var sender = new EquipmentAdminCommandNativeTest.Sender(); sender.allowed = true;
+            assertEquals(java.util.List.of("hard-mob-xp"),
+                f.command.tabComplete(sender.port, "fantasystick", new String[]{"config", "hard"}));
+            assertEquals(java.util.List.of("20", "25"),
+                f.command.tabComplete(sender.port, "fantasystick", new String[]{"config", "hard-mob-xp", ""}));
+            f.command.execute(sender.port, "fantasystick", new String[]{"config", "hard-mob-xp"});
+            assertTrue(sender.messages.getLast().contains("=25"));
+            f.command.execute(sender.port, "fantasystick", new String[]{"config", "hard-mob-xp", "2147483648"});
+            assertTrue(sender.messages.getLast().contains("invalid"));
+            var service = (games.dmg.fantasystick.party.CombatExperience)
+                FantasyStickLifecycleNativeTest.Fixture.field(f.plugin, "combatExperience");
+            assertEquals(java.math.BigInteger.valueOf(25), service.rules().hardPool());
+            f.command.execute(sender.port, "fantasystick", new String[]{"config", "hard-mob-xp", "30"});
+            Runnable response = f.tasks.poll(5, java.util.concurrent.TimeUnit.SECONDS); assertNotNull(response);
+            assertEquals(java.math.BigInteger.valueOf(25), service.rules().hardPool(), "Durable write precedes publication");
+            response.run(); assertEquals(java.math.BigInteger.valueOf(30), service.rules().hardPool());
+            var yaml = (java.util.Map<?, ?>) new org.yaml.snakeyaml.Yaml().load(
+                java.nio.file.Files.readString(data.resolve("config.yml")));
+            assertEquals("retained", yaml.get("unrelated")); assertEquals("30", String.valueOf(yaml.get("hard-mob-xp")));
+            var actor = new FantasyStickLifecycleNativeTest.Actor(data); f.players.put(actor.core.id, actor.player); f.activate(actor);
+            var world = mock(org.bukkit.World.class); when(world.getUID()).thenReturn(UUID.randomUUID());
+            var witch = mob(EntityType.WITCH, new Location(world, 0, 64, 0));
+            hit(f, actor.player, witch, false); die(f, witch); settle(f);
+            assertEquals(java.math.BigInteger.valueOf(30), record(f, actor).experience());
+            sender.allowed = false;
+            assertTrue(f.command.tabComplete(sender.port, "fantasystick", new String[]{"config", "hard"}).isEmpty());
+        }
+    }
+
     @Test void interceptedFantasyDefeatUsesVictimLevelPoolAndCancelledDamageCreatesNoCredit() throws Exception {
         try (var f = new FantasyStickLifecycleNativeTest.Fixture(data)) {
             f.plugin.setEnabled(true);

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

@@ -53,7 +53,7 @@ class EquipmentAdminCommandNativeTest {
         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","party-registrar","recover"),f.command.tabComplete(sender.port,"fantasystick",new String[]{""}));
+            assertEquals(List.of("adventure-site","config","experience","give","inspect","party-registrar","quest-giver","recover","shop","training-dummy"),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"}));
@@ -94,7 +94,7 @@ class EquipmentAdminCommandNativeTest {
             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", "party-registrar", "recover"), f.command.tabComplete(sender.port, "fantasystick", new String[]{""}));
+            assertEquals(List.of("adventure-site", "config", "experience", "give", "inspect", "party-registrar", "quest-giver", "recover", "shop", "training-dummy"), 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", ""}));
@@ -109,7 +109,8 @@ class EquipmentAdminCommandNativeTest {
             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", ""},
+            assertEquals(List.of("adventure"), f.command.tabComplete(sender.port, "fantasystick", new String[]{""}));
+            for (String[] args : List.of(new String[]{"inspect", ""}, new String[]{"config", ""},
                     new String[]{"config", "adventure-mode", ""})) {
                 assertTrue(f.command.tabComplete(sender.port, "fantasystick", args).isEmpty());
             }

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

@@ -1283,6 +1283,40 @@ class EquipmentSessionEventsNativeTest {
         }
     }
 
+    @Test void nativeDoorInteractionTakesPrecedenceOverAbilityUseAndLongbowDraw() throws Exception {
+        try (var f = new Fixture()) {
+            f.loadout("quickstep", "longbow");
+            var a = f.actor; f.core.activate(a);
+            var door = org.mockito.Mockito.mock(org.bukkit.block.Block.class);
+            org.mockito.Mockito.doReturn(org.mockito.Mockito.mock(org.bukkit.block.data.type.Door.class)).when(door).getBlockData();
+            for (int slot : new int[]{2, 3}) {
+                a.inventory.getInventory().setSelectedSlot(slot);
+                var event = new org.bukkit.event.player.PlayerInteractEvent(a.player,
+                    org.bukkit.event.block.Action.RIGHT_CLICK_BLOCK, a.inventory.getItem(slot), door,
+                    org.bukkit.block.BlockFace.UP, org.bukkit.inventory.EquipmentSlot.HAND);
+                event.setUseInteractedBlock(org.bukkit.event.Event.Result.ALLOW);
+                int beforeInputs = f.inputs.size(); int beforeDraws = a.useStarts;
+                f.dispatcher.accept(event);
+                assertEquals(org.bukkit.event.Event.Result.ALLOW, event.useInteractedBlock());
+                assertEquals(org.bukkit.event.Event.Result.DENY, event.useItemInHand());
+                assertEquals(beforeInputs, f.inputs.size(), "A door click is not an ability input");
+                assertEquals(beforeDraws, a.useStarts, "A door click does not begin Longbow drawing");
+            }
+            var stone = org.mockito.Mockito.mock(org.bukkit.block.Block.class);
+            org.mockito.Mockito.doReturn(org.mockito.Mockito.mock(org.bukkit.block.data.BlockData.class)).when(stone).getBlockData();
+            a.inventory.getInventory().setSelectedSlot(2);
+            var ordinaryBlock = new org.bukkit.event.player.PlayerInteractEvent(a.player,
+                org.bukkit.event.block.Action.RIGHT_CLICK_BLOCK, a.inventory.getItem(2), stone,
+                org.bukkit.block.BlockFace.UP, org.bukkit.inventory.EquipmentSlot.HAND);
+            f.dispatcher.accept(ordinaryBlock); assertEquals(1, f.inputs.size(), "Non-door ability use remains active");
+            a.inventory.getInventory().setSelectedSlot(3);
+            var air = new org.bukkit.event.player.PlayerInteractEvent(a.player,
+                org.bukkit.event.block.Action.RIGHT_CLICK_AIR, a.inventory.getItem(3), null,
+                org.bukkit.block.BlockFace.SELF, org.bukkit.inventory.EquipmentSlot.HAND);
+            f.dispatcher.accept(air); assertEquals(1, a.useStarts, "Air use still begins Longbow drawing");
+        }
+    }
+
     @Test void selectedAbilityUseReachesItsHandlerWithoutVanillaThrowDrinkEquipBlockOrPlacement() throws Exception {
         try (var f = new Fixture()) {
             String[] abilities = {"chain_lightning", "purify", "guardian_bond", "shield_bash", "rallying_cry", "frost_nova", "revive"};

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

@@ -0,0 +1,7 @@
+package games.dmg.fantasystick;
+import static org.junit.jupiter.api.Assertions.*;import static org.mockito.Mockito.*;import games.dmg.fantasystick.items.GearItems;import games.dmg.fantasystick.persistence.*;import java.math.BigInteger;import java.nio.file.Path;import java.util.*;import org.bukkit.Material;import org.bukkit.event.player.PlayerDropItemEvent;import org.bukkit.inventory.ItemStack;import org.junit.jupiter.api.*;import org.junit.jupiter.api.io.TempDir;
+class FantasyArmorNativeTest{
+ @TempDir Path data;@BeforeAll static void bootstrap()throws Exception{NativeRuntime.bootstrap();}
+ @Test void everyTierAndHelmetFreeSlotProducesBoundUnbreakableUnenchantedNativeArmor()throws Exception{try(var f=new FantasyStickLifecycleNativeTest.Fixture(data)){f.plugin.setEnabled(true);var gear=new GearItems(f.plugin);for(var slot:GearSlot.values())for(var tier:GearTier.values())if(tier!=GearTier.NONE){var item=gear.create(slot,tier,UUID.randomUUID(),UUID.randomUUID());assertEquals(Material.valueOf((tier==GearTier.GOLD?"GOLDEN":tier.name())+"_"+switch(slot){case CHESTPLATE->"CHESTPLATE";case LEGGINGS->"LEGGINGS";case BOOTS->"BOOTS";}),item.getType());assertTrue(item.getItemMeta().isUnbreakable());assertTrue(item.getEnchantments().isEmpty());}assertEquals(3,GearSlot.values().length);}}
+ @Test void purchasedGearMaterializesOnlyInFantasyModeIsContainedAndOrdinaryArmorRestores()throws Exception{try(var f=new FantasyStickLifecycleNativeTest.Fixture(data)){f.plugin.setEnabled(true);var actor=new FantasyStickLifecycleNativeTest.Actor(data);f.players.put(actor.core.id,actor.player);var repository=new YamlCharacterRepository(data);var old=repository.load(actor.core.record.id()).orElseThrow();var funded=new CharacterRecord(old.id(),old.name(),old.revision().add(BigInteger.ONE),old.stats(),old.level(),old.experience(),old.unspentPoints(),old.health(),old.learned(),old.loadout(),old.passives(),old.cooldowns(),old.restrictedKills(),false,null,null,BigInteger.valueOf(1000),true,old.rewardReceipts(),old.pvpCoinEscrow(),old.gear());repository.replace(funded,old.revision());try(var storage=new CharacterStorage(repository,java.time.Clock.systemUTC())){storage.purchaseGear(funded.id(),funded.revision(),UUID.randomUUID(),GearSlot.CHESTPLATE,GearTier.IRON,BigInteger.valueOf(75)).join();}var ordinary=new ItemStack(Material.DIAMOND_CHESTPLATE);actor.core.inventory.setChestplate(ordinary);f.activate(actor);var fantasy=actor.core.inventory.getChestplate();assertEquals(Material.IRON_CHESTPLATE,fantasy.getType());assertTrue(fantasy.getItemMeta().isUnbreakable());var dropped=mock(org.bukkit.entity.Item.class);when(dropped.getItemStack()).thenReturn(fantasy);var event=new PlayerDropItemEvent(actor.player,dropped);f.dispatcher.accept(event);assertTrue(event.isCancelled());actor.core.inventory.setItemInOffHand(null);f.changed(actor);PartyBookNativeTest.drain(f);f.awaitCharacterAndReceipt(actor);assertEquals(ordinary,actor.core.inventory.getChestplate());assertFalse(Arrays.stream(actor.core.inventory.getContents()).filter(Objects::nonNull).anyMatch(item->new GearItems(f.plugin).gear(item)));actor.core.inventory.setItemInOffHand(new games.dmg.fantasystick.items.CharacterSheets().create(repository.load(old.id()).orElseThrow()));f.activate(actor);assertEquals(Material.IRON_CHESTPLATE,actor.core.inventory.getChestplate().getType());actor.core.inventory.setItemInOffHand(null);f.changed(actor);PartyBookNativeTest.drain(f);f.awaitCharacterAndReceipt(actor);assertEquals(ordinary,actor.core.inventory.getChestplate());}}
+}

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

@@ -0,0 +1,6 @@
+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.*;import java.math.BigInteger;import java.nio.file.Path;import java.util.*;import org.bukkit.*;import org.bukkit.entity.*;import org.bukkit.event.inventory.InventoryClickEvent;import org.bukkit.event.player.PlayerInteractEntityEvent;import org.bukkit.inventory.EquipmentSlot;import org.bukkit.persistence.*;import org.junit.jupiter.api.*;import org.junit.jupiter.api.io.TempDir;
+class FantasyArmorerNativeTest{
+ @TempDir Path data;@BeforeAll static void bootstrap()throws Exception{NativeRuntime.bootstrap();}
+ @SuppressWarnings("unchecked")@Test void adminPlacementDistinctNpcAndActiveShopPurchaseUseActualRegisteredPath()throws Exception{try(var f=new FantasyStickLifecycleNativeTest.Fixture(data)){f.plugin.setEnabled(true);var actor=new FantasyStickLifecycleNativeTest.Actor(data);f.players.put(actor.core.id,actor.player);doReturn(true).when(actor.player).hasPermission("fantasystick.admin");var console=mock(org.bukkit.command.CommandSender.class);when(console.hasPermission("fantasystick.admin")).thenReturn(true);var consoleMessages=new ArrayList<String>();doAnswer(call->{consoleMessages.add(call.getArgument(0));return null;}).when(console).sendMessage(anyString());UUID worldId=UUID.randomUUID();when(actor.world.getUID()).thenReturn(worldId);int x=actor.core.location.getBlockX()>>4,z=actor.core.location.getBlockZ()>>4;var chunk=mock(Chunk.class);when(chunk.getWorld()).thenReturn(actor.world);when(chunk.getX()).thenReturn(x);when(chunk.getZ()).thenReturn(z);when(chunk.getEntities()).thenReturn(new org.bukkit.entity.Entity[0]);when(actor.world.getChunkAt(x,z)).thenReturn(chunk);when(actor.world.isChunkLoaded(x,z)).thenReturn(true);when(actor.world.getEntities()).thenReturn(List.of());assertEquals(List.of("gear-price-copper","gear-price-diamond","gear-price-gold","gear-price-iron","gear-price-leather","gear-price-netherite","gear-price-variance-percent"),f.command.tabComplete(actor.player,"fantasystick",new String[]{"config","gear-price-"}));assertEquals(List.of("gear-stock-copper-max","gear-stock-copper-min","gear-stock-diamond-max","gear-stock-diamond-min","gear-stock-gold-max","gear-stock-gold-min","gear-stock-iron-max","gear-stock-iron-min","gear-stock-leather-max","gear-stock-leather-min","gear-stock-netherite-max","gear-stock-netherite-min"),f.command.tabComplete(actor.player,"fantasystick",new String[]{"config","gear-stock-"}));assertEquals(List.of("list","place","remove","restock"),f.command.tabComplete(actor.player,"fantasystick",new String[]{"shop",""}));assertEquals(List.of("list","remove","restock"),f.command.tabComplete(console,"fantasystick",new String[]{"shop",""}));Runnable task;f.command.execute(console,"fantasystick",new String[]{"config","gear-price-variance-percent","0"});for(int attempt=0;attempt<10&&consoleMessages.stream().noneMatch(message->message.contains("Saved gear-price-variance-percent=0"));attempt++){task=f.tasks.poll(5,java.util.concurrent.TimeUnit.SECONDS);assertNotNull(task);task.run();}f.command.execute(console,"fantasystick",new String[]{"config","gear-stock-iron-min","20"});for(int attempt=0;attempt<10&&consoleMessages.stream().noneMatch(message->message.contains("Saved gear-stock-iron-min=20"));attempt++){task=f.tasks.poll(5,java.util.concurrent.TimeUnit.SECONDS);assertNotNull(task);task.run();}var villager=mock(Villager.class);when(villager.getLocation()).thenReturn(actor.core.location);var values=new HashMap<String,String>();var pdc=mock(PersistentDataContainer.class);when(villager.getPersistentDataContainer()).thenReturn(pdc);doAnswer(call->{values.put(((NamespacedKey)call.getArgument(0)).getKey(),call.getArgument(2));return null;}).when(pdc).set(any(NamespacedKey.class),eq(PersistentDataType.STRING),anyString());when(pdc.get(any(NamespacedKey.class),eq(PersistentDataType.STRING))).thenAnswer(call->values.get(((NamespacedKey)call.getArgument(0)).getKey()));doAnswer(call->{((java.util.function.Consumer<Villager>)call.getArgument(2)).accept(villager);return villager;}).when(actor.world).spawn(any(Location.class),eq(Villager.class),any(java.util.function.Consumer.class));f.command.execute(actor.player,"fantasystick",new String[]{"shop","place","Forge"});task=f.tasks.poll(5,java.util.concurrent.TimeUnit.SECONDS);assertNotNull(task);task.run();var directory=(games.dmg.fantasystick.shop.FantasyArmorerDirectory)FantasyStickLifecycleNativeTest.Fixture.field(f.plugin,"armorers");var shop=directory.all().getFirst();assertEquals("Forge",shop.name());assertEquals(List.of(shop.id().toString()),f.command.tabComplete(actor.player,"fantasystick",new String[]{"shop","remove",shop.id().toString().substring(0,8)}));var armorer=(games.dmg.fantasystick.shop.FantasyArmorerController)FantasyStickLifecycleNativeTest.Fixture.field(f.plugin,"armorerController");var registrar=(games.dmg.fantasystick.party.PartyRegistrarController)FantasyStickLifecycleNativeTest.Fixture.field(f.plugin,"partyRegistrarController");assertTrue(armorer.tagged(villager));assertFalse(registrar.tagged(villager));when(chunk.getEntities()).thenReturn(new org.bukkit.entity.Entity[]{villager});armorer.reconcile(chunk);verify(actor.world,times(1)).spawn(any(Location.class),eq(Villager.class),any(java.util.function.Consumer.class));verify(villager,times(2)).setAI(false);verify(villager,times(2)).setGravity(false);verify(villager,times(2)).setSilent(true);verify(villager,times(2)).setInvulnerable(true);verify(villager,times(2)).setCollidable(false);var damage=mock(org.bukkit.event.entity.EntityDamageEvent.class);when(damage.getEntity()Line truncated
+}

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

@@ -0,0 +1,138 @@
+package games.dmg.fantasystick;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+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 FantasyFeedbackCommandNativeTest {
+    @TempDir Path data;
+    @BeforeAll static void bootstrap() throws Exception { NativeRuntime.bootstrap(); }
+
+    @Test void registeredPlayerCommandDefaultsOnDurablyTurnsOffAndReloadsWithoutAdminPermission() throws Exception {
+        try (var fixture = new FantasyStickLifecycleNativeTest.Fixture(data)) {
+            fixture.plugin.setEnabled(true);
+            assertNotNull(fixture.feedbackCommand);
+            var player = new FantasyStickLifecycleNativeTest.Actor(data);
+            fixture.players.put(player.core.id, player.player);
+
+            assertTrue(fixture.feedbackCommand.execute(player.player, "fantasyfeedback", new String[]{}));
+            assertEquals("Fantasy feedback is on.", player.messages.getLast());
+            assertEquals(List.of("off", "on"), fixture.feedbackCommand.tabComplete(
+                player.player, "fantasyfeedback", new String[]{""}));
+            assertEquals(List.of("off"), fixture.feedbackCommand.tabComplete(
+                player.player, "fantasyfeedback", new String[]{"of"}));
+
+            int before = player.messages.size();
+            assertTrue(fixture.feedbackCommand.execute(player.player, "fantasyfeedback", new String[]{"off"}));
+            assertEquals(before, player.messages.size(), "queued persistence is not an acknowledged preference change");
+            fixture.tick();
+            assertEquals("Fantasy feedback is now off.", player.messages.getLast());
+
+            fixture.plugin.setEnabled(false);
+            fixture.plugin.setEnabled(true);
+            assertTrue(fixture.feedbackCommand.execute(player.player, "fantasyfeedback", new String[]{}));
+            assertEquals("Fantasy feedback is off.", player.messages.getLast());
+            assertTrue(player.messageComponents.isEmpty(), "preference/status notices keep their existing presentation");
+        }
+    }
+
+    @Test void consoleMalformedAndExtraArgumentsCannotChangeAnAccountPreference() throws Exception {
+        try (var fixture = new FantasyStickLifecycleNativeTest.Fixture(data)) {
+            fixture.plugin.setEnabled(true);
+            var console = new EquipmentAdminCommandNativeTest.Sender();
+            assertTrue(fixture.feedbackCommand.execute(console.port, "fantasyfeedback", new String[]{"off"}));
+            assertTrue(console.messages.getLast().contains("player-account"));
+            assertTrue(fixture.feedbackCommand.tabComplete(console.port, "fantasyfeedback", new String[]{""}).isEmpty());
+            var player = new FantasyStickLifecycleNativeTest.Actor(data);
+            fixture.players.put(player.core.id, player.player);
+            assertFalse(fixture.feedbackCommand.getExecutor().onCommand(player.player, fixture.feedbackCommand,
+                "fantasyfeedback", new String[]{"OFF"}));
+            assertFalse(fixture.feedbackCommand.getExecutor().onCommand(player.player, fixture.feedbackCommand,
+                "fantasyfeedback", new String[]{"off", "extra"}));
+            assertTrue(((games.dmg.fantasystick.persistence.PlayerFeedbackPreferences)
+                FantasyStickLifecycleNativeTest.Fixture.field(fixture.plugin, "feedbackPreferences"))
+                .enabled(player.core.id));
+            assertTrue(player.messageComponents.isEmpty(), "refusals are not routine outcome components");
+        }
+    }
+
+    @Test void sourceAndAffectedAccountPreferencesIndependentlyFilterPerTickMessages() throws Exception {
+        try (var fixture = new FantasyStickLifecycleNativeTest.Fixture(data)) {
+            fixture.plugin.setEnabled(true);
+            var source = new FantasyStickLifecycleNativeTest.Actor(data);
+            var target = new FantasyStickLifecycleNativeTest.Actor(data);
+            fixture.players.put(source.core.id, source.player);
+            fixture.players.put(target.core.id, target.player);
+            fixture.activate(source); fixture.activate(target);
+            var feedback = (games.dmg.fantasystick.presentation.CombatFeedback)
+                FantasyStickLifecycleNativeTest.Fixture.field(fixture.plugin, "combatFeedback");
+
+            feedback.report("Mending Light", source.player,
+                games.dmg.fantasystick.ability.AbilityReport.Type.HEALING, target.player,
+                new java.math.BigDecimal("1.234"));
+            String healing = "Mending Light healed " + target.core.record.name() + " for 1.23 health.";
+            assertEquals(1, source.messages.stream().filter(healing::equals).count());
+            assertEquals(1, target.messages.stream().filter(healing::equals).count());
+            assertEquals(net.kyori.adventure.text.format.NamedTextColor.GRAY,
+                source.messageComponents.getLast().color());
+            assertEquals(net.kyori.adventure.text.format.NamedTextColor.GRAY,
+                target.messageComponents.getLast().color());
+
+            fixture.feedbackCommand.execute(source.player, "fantasyfeedback", new String[]{"off"}); fixture.tick();
+            feedback.report("Sanctuary", source.player,
+                games.dmg.fantasystick.ability.AbilityReport.Type.HEALING, target.player,
+                new java.math.BigDecimal("2"));
+            String pulse = "Sanctuary healed " + target.core.record.name() + " for 2 health.";
+            assertEquals(0, source.messages.stream().filter(pulse::equals).count());
+            assertEquals(1, target.messages.stream().filter(pulse::equals).count());
+
+            fixture.feedbackCommand.execute(target.player, "fantasyfeedback", new String[]{"off"}); fixture.tick();
+            feedback.report("Sanctuary", source.player,
+                games.dmg.fantasystick.ability.AbilityReport.Type.HEALING, target.player,
+                new java.math.BigDecimal("2"));
+            assertEquals(0, source.messages.stream().filter(pulse::equals).count());
+            assertEquals(1, target.messages.stream().filter(pulse::equals).count());
+
+            fixture.feedbackCommand.execute(source.player, "fantasyfeedback", new String[]{"on"}); fixture.tick();
+            var zombie = org.mockito.Mockito.mock(org.bukkit.entity.LivingEntity.class);
+            org.mockito.Mockito.when(zombie.getName()).thenReturn("Zombie");
+            org.mockito.Mockito.when(zombie.getType()).thenReturn(org.bukkit.entity.EntityType.ZOMBIE);
+            for (int tick = 0; tick < 2; tick++) feedback.report("Burning Ground", source.player,
+                games.dmg.fantasystick.ability.AbilityReport.Type.DAMAGE, zombie,
+                new java.math.BigDecimal("2.345"));
+            assertEquals(2, source.messages.stream()
+                .filter("Burning Ground did 2.35 damage to Zombie."::equals).count());
+            feedback.report("Purify", source.player,
+                games.dmg.fantasystick.ability.AbilityReport.Type.CLEANSING, target.player,
+                new java.math.BigDecimal("2"));
+            feedback.report("Stone Skin", source.player,
+                games.dmg.fantasystick.ability.AbilityReport.Type.PREVENTION, target.player,
+                new java.math.BigDecimal("1.005"));
+            feedback.report("Rallying Cry", source.player,
+                games.dmg.fantasystick.ability.AbilityReport.Type.BOOST_USED, zombie,
+                new java.math.BigDecimal("0.5"));
+            assertTrue(source.messages.contains("Purify removed 2 harmful effects from "
+                + target.core.record.name() + "."));
+            assertTrue(source.messages.contains("Stone Skin prevented 1.01 damage to "
+                + target.core.record.name() + "."));
+            assertTrue(source.messages.contains("Rallying Cry added 0.5 damage against Zombie."));
+            assertEquals(6, source.messageComponents.size());
+            assertEquals(2, target.messageComponents.size());
+            assertTrue(source.messageComponents.stream().allMatch(component ->
+                net.kyori.adventure.text.format.NamedTextColor.GRAY.equals(component.color())));
+            assertTrue(target.messageComponents.stream().allMatch(component ->
+                net.kyori.adventure.text.format.NamedTextColor.GRAY.equals(component.color())));
+            assertTrue(source.messages.stream().noneMatch(message -> message.indexOf('\u00a7') >= 0));
+            int messages = source.messages.size();
+            int components = source.messageComponents.size();
+            feedback.report("No-op", source.player,
+                games.dmg.fantasystick.ability.AbilityReport.Type.DAMAGE, zombie, java.math.BigDecimal.ZERO);
+            assertEquals(messages, source.messages.size());
+            assertEquals(components, source.messageComponents.size());
+        }
+    }
+}