feat(config): export acknowledged switch-delay changes

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

@@ -174,6 +174,8 @@ public final class FantasyStickPlugin extends JavaPlugin {
     private games.dmg.fantasystick.events.PassiveEventBridge passiveEvents;
     private games.dmg.fantasystick.events.RecoveryEventBridge recoveryEvents;
     private games.dmg.fantasystick.events.ReviveEventBridge reviveEvents;
+    private games.dmg.fantasystick.events.AdminRevivalEventBridge adminRevivalEvents;
+    private java.util.concurrent.CompletionStage<Void> adminRevivalAuditDrain = java.util.concurrent.CompletableFuture.completedFuture(null);
     private games.dmg.fantasystick.events.PartyEventBridge partyAuditEvents;
     private games.dmg.fantasystick.events.CombatRewardEventBridge combatRewardEvents;
     private games.dmg.fantasystick.events.CoinEventBridge coinEvents;
@@ -182,6 +184,8 @@ public final class FantasyStickPlugin extends JavaPlugin {
     private java.util.concurrent.CompletionStage<Void> nutritionAuditDrain = java.util.concurrent.CompletableFuture.completedFuture(null);
     private games.dmg.fantasystick.events.SwitchDelayEventBridge switchAuditEvents;
     private java.util.concurrent.CompletionStage<Void> switchAuditDrain = java.util.concurrent.CompletableFuture.completedFuture(null);
+    private games.dmg.fantasystick.events.SwitchConfigEventBridge switchConfigEvents;
+    private java.util.concurrent.CompletionStage<Void> switchConfigAuditDrain = java.util.concurrent.CompletableFuture.completedFuture(null);
     private games.dmg.fantasystick.events.CharacterIdentityEventBridge identityAuditEvents;
     private java.util.concurrent.CompletionStage<Void> identityAuditDrain = java.util.concurrent.CompletableFuture.completedFuture(null);
     private games.dmg.fantasystick.events.EquipmentEventBridge equipmentAuditEvents;
@@ -744,6 +748,7 @@ public final class FantasyStickPlugin extends JavaPlugin {
                 eventCapture.excludeOwnedDamage(frostShard::ownsAcceptedDamage);
                 eventCapture.excludeOwnedDamage(longbow::ownsAcceptedDamage);
                 eventCapture.excludeOwnedDamage(greatSword::ownsAcceptedDamage);
+                eventCapture.excludeOwnedDamage(shieldBash::ownsAcceptedDamage);
                 eventCapture.excludeOwnedDamage(guardianBond::ownsAcceptedRedirect);
                 eventCapture.excludeOwnedDamage(frostNova::ownsAcceptedDamage);
                 eventCapture.excludeOwnedDamage(chainLightning::ownsAcceptedDamage);
@@ -761,6 +766,12 @@ public final class FantasyStickPlugin extends JavaPlugin {
                 abilityEngine.enableCastEventsFor("great_sword");
                 abilityEngine.enableCastEventsFor("frost_shard");
                 abilityEngine.enableCastEventsFor("longbow");
+                abilityEngine.enableCastEventsFor("quickstep");
+                abilityEngine.enableCastEventsFor("second_wind");
+                abilityEngine.enableCastEventsFor("stone_skin");
+                abilityEngine.enableCastEventsFor("shield_bash");
+                abilityEngine.enableCastEventsFor("hex");
+                abilityEngine.enableCastEventsFor("inspire");
                 abilityEngine.enableCastEventsFor("mending_light");
                 abilityEngine.enableCastEventsFor("purify");
                 abilityEngine.enableCastEventsFor("guardian_bond");
@@ -774,6 +785,11 @@ public final class FantasyStickPlugin extends JavaPlugin {
                 passiveEvents = new games.dmg.fantasystick.events.PassiveEventBridge(eventLog::emit, Clock.systemUTC());books.attachPassiveEvents(passiveEvents);admin.attachPassiveEvents(passiveEvents);
                 recoveryEvents = new games.dmg.fantasystick.events.RecoveryEventBridge(eventLog::emit, Clock.systemUTC());outOfCombatRecovery.attachEvents(recoveryEvents,record->record.passives().contains(games.dmg.fantasystick.passive.QuickerRegenerationI.ID)?quickerRegeneration.bonus():java.math.BigInteger.ZERO);
                 reviveEvents = new games.dmg.fantasystick.events.ReviveEventBridge(eventLog::emit, Clock.systemUTC());revive.attachEvents(reviveEvents);
+                adminRevivalEvents = new games.dmg.fantasystick.events.AdminRevivalEventBridge(
+                    eventLog::emit, Clock.systemUTC(), getDataFolder().toPath(), sessions,
+                    failure -> getLogger().log(Level.WARNING, "Admin revival event intent failed", failure));
+                admin.attachAdminRevivalEvents(adminRevivalEvents);
+                revive.attachAdminRevivalEvents(adminRevivalEvents);
                 partyAuditEvents = new games.dmg.fantasystick.events.PartyEventBridge(eventLog::emit, Clock.systemUTC());partyManagement.attachEvents(partyAuditEvents);admin.attachPartyEvents(partyAuditEvents);
                 partyCombat.attachProtectionEvents(new games.dmg.fantasystick.events.PartyProtectionEventBridge(
                     eventLog::emit, Clock.systemUTC()));
@@ -789,12 +805,17 @@ public final class FantasyStickPlugin extends JavaPlugin {
                     eventLog::emit, Clock.systemUTC(), getDataFolder().toPath(),
                     failure -> getLogger().log(Level.WARNING, "Switch deadline event intent failed", failure));
                 sessions.attachSwitchEvents(switchAuditEvents);
+                switchConfigEvents = new games.dmg.fantasystick.events.SwitchConfigEventBridge(
+                    eventLog::emit, Clock.systemUTC(), getDataFolder().toPath(), sessions,
+                    failure -> getLogger().log(Level.WARNING, "Switch configuration event intent failed", failure));
+                admin.attachSwitchConfigEvents(switchConfigEvents);
                 var identitySessions = sessions;
                 identityAuditEvents = new games.dmg.fantasystick.events.CharacterIdentityEventBridge(
                     eventLog::emit, Clock.systemUTC(), getDataFolder().toPath(),
                     playerId -> identitySessions.active(playerId).map(games.dmg.fantasystick.session.EquipmentSessions.Active::session),
                     failure -> getLogger().log(Level.WARNING, "Character identity event intent failed", failure));
                 crafting.attachIdentityEvents(identityAuditEvents);
+                admin.attachCharacterIssueEvents(identityAuditEvents);
                 anvilNames.attachIdentityEvents(identityAuditEvents);
                 sessions.attachIdentityEvents(identityAuditEvents);
                 equipmentAuditEvents = new games.dmg.fantasystick.events.EquipmentEventBridge(
@@ -815,7 +836,7 @@ public final class FantasyStickPlugin extends JavaPlugin {
                     id -> presentation.snapshot().get(id),sessionAuditEvents,eventLog::emit,Clock.systemUTC());
                 getServer().getPluginManager().registerEvents(messageAuditEvents,this);
             } catch (java.io.IOException failure) {
-                eventLog = null; eventCapture = null; downedEvents = null; rareEvents = null; bookEvents = null; progressionEvents = null; reviveEvents = null; partyAuditEvents = null; combatRewardEvents = null; coinEvents = null; sessionAuditEvents = null; nutritionAuditEvents = null; switchAuditEvents = null; identityAuditEvents = null; equipmentAuditEvents = null; sessionRecoveryAuditEvents = null; messageAuditEvents = null;
+                eventLog = null; eventCapture = null; downedEvents = null; rareEvents = null; bookEvents = null; progressionEvents = null; reviveEvents = null; adminRevivalEvents = null; partyAuditEvents = null; combatRewardEvents = null; coinEvents = null; sessionAuditEvents = null; nutritionAuditEvents = null; switchAuditEvents = null; switchConfigEvents = null; identityAuditEvents = null; equipmentAuditEvents = null; sessionRecoveryAuditEvents = null; messageAuditEvents = null;
                 getLogger().log(Level.WARNING,"Fantasy Stick local events are unavailable; gameplay remains enabled",failure);
             }
             getServer().getPluginManager().registerEvents(crafting, this);
@@ -901,11 +922,21 @@ public final class FantasyStickPlugin extends JavaPlugin {
                     if (failure != null) getLogger().log(Level.WARNING, "Previous nutrition event intent drain failed", failure);
                     if (replayNutritionEvents != null) replayNutritionEvents.replay();
                 });
+                var replaySwitchConfigEvents = switchConfigEvents;
+                switchConfigAuditDrain.whenComplete((ignored, failure) -> {
+                    if (failure != null) getLogger().log(Level.WARNING, "Previous switch configuration intent drain failed", failure);
+                    if (replaySwitchConfigEvents != null) replaySwitchConfigEvents.replay();
+                });
                 var replaySwitchEvents = switchAuditEvents;
                 switchAuditDrain.whenComplete((ignored, failure) -> {
                     if (failure != null) getLogger().log(Level.WARNING, "Previous switch event intent drain failed", failure);
                     if (replaySwitchEvents != null) replaySwitchEvents.replay();
                 });
+                var replayAdminRevivalEvents = adminRevivalEvents;
+                adminRevivalAuditDrain.whenComplete((ignored, failure) -> {
+                    if (failure != null) getLogger().log(Level.WARNING, "Previous admin revival event intent drain failed", failure);
+                    if (replayAdminRevivalEvents != null) replayAdminRevivalEvents.replay();
+                });
                 var replayIdentityEvents = identityAuditEvents;
                 identityAuditDrain.whenComplete((ignored, failure) -> {
                     if (failure != null) getLogger().log(Level.WARNING, "Previous identity event intent drain failed", failure);
@@ -961,7 +992,9 @@ public final class FantasyStickPlugin extends JavaPlugin {
         var closingEventLog = eventLog; eventLog = null; preferenceEvents = null;
         var closingNutritionAuditEvents = nutritionAuditEvents; nutritionAuditEvents = null;
         var closingSwitchAuditEvents = switchAuditEvents; switchAuditEvents = null;
+        var closingSwitchConfigEvents = switchConfigEvents; switchConfigEvents = null;
         var closingIdentityAuditEvents = identityAuditEvents; identityAuditEvents = null;
+        var closingAdminRevivalAuditEvents = adminRevivalEvents; adminRevivalEvents = null;
         var closingEquipmentAuditEvents = equipmentAuditEvents; equipmentAuditEvents = null;
         var closingSessionRecoveryAuditEvents = sessionRecoveryAuditEvents; sessionRecoveryAuditEvents = null;
         var closingEventCapture = eventCapture; eventCapture = null; var closingMessageAuditEvents = messageAuditEvents; messageAuditEvents = null; downedEvents = null; rareEvents = null; bookEvents = null; progressionEvents = null; abilityEvents = null; passiveEvents = null; recoveryEvents = null; reviveEvents = null; partyAuditEvents = null; combatRewardEvents = null; coinEvents = null; sessionAuditEvents = null;
@@ -1281,6 +1314,16 @@ public final class FantasyStickPlugin extends JavaPlugin {
                 return null;
             }).thenCompose(ignored -> closingNutritionAuditEvents.drained());
         });
+        if (closingSwitchConfigEvents != null) cleanup("switch configuration event intent drain", () -> {
+            var settingsDrained = closingSwitchDelaySettings == null
+                ? java.util.concurrent.CompletableFuture.<Void>completedFuture(null)
+                : closingSwitchDelaySettings.drained();
+            switchConfigAuditDrain = settingsDrained.handle((ignored, failure) -> {
+                if (failure != null) getLogger().log(Level.WARNING, "Switch setting drain failed", failure);
+                closingSwitchConfigEvents.close();
+                return null;
+            }).thenCompose(ignored -> closingSwitchConfigEvents.drained());
+        });
         if (closingSwitchAuditEvents != null) cleanup("switch event intent drain", () -> {
             var sessionsDrained = closingSessions == null
                 ? java.util.concurrent.CompletableFuture.<Void>completedFuture(null) : closingSessions.drained();
@@ -1355,6 +1398,15 @@ public final class FantasyStickPlugin extends JavaPlugin {
             recipeRegistered = false; // Retain ownership for a later retry if removal failed.
         });
         if (closingCharacters != null) cleanup("character storage", closingCharacters::close);
+        if (closingAdminRevivalAuditEvents != null) cleanup("admin revival event intent drain", () -> {
+            var charactersDrained = closingCharacters == null
+                ? java.util.concurrent.CompletableFuture.<Void>completedFuture(null) : closingCharacters.drained();
+            adminRevivalAuditDrain = charactersDrained.handle((ignored, failure) -> {
+                if (failure != null) getLogger().log(Level.WARNING, "Character save drain failed", failure);
+                closingAdminRevivalAuditEvents.close();
+                return null;
+            }).thenCompose(ignored -> closingAdminRevivalAuditEvents.drained());
+        });
         if (closingIdentityAuditEvents != null) cleanup("character identity event intent drain", () -> {
             var charactersDrained = closingCharacters == null
                 ? java.util.concurrent.CompletableFuture.<Void>completedFuture(null) : closingCharacters.drained();

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

@@ -71,7 +71,10 @@ public final class AbilityEngine implements Consumer<ControlInput>, AutoCloseabl
 
     private void refuseCast(ControlInput input, CharacterRecord record, AbilityDefinition definition, String reason) {
         if (castEvents == null || record == null
-                || !(definition.id().equals("great_sword") || definition.id().equals("longbow"))
+                || !(definition.id().equals("great_sword") || definition.id().equals("longbow")
+                    || definition.id().equals("quickstep") || definition.id().equals("second_wind")
+                    || definition.id().equals("shield_bash") || definition.id().equals("hex")
+                    || definition.id().equals("inspire"))
                 || !eventOwnedAbilities.contains(definition.id())) return;
         resolve(castEvents.begin(input, record, definition), "refused", reason);
     }
@@ -252,25 +255,31 @@ public final class AbilityEngine implements Consumer<ControlInput>, AutoCloseabl
             return;
         }
         CharacterRecord saved = mutation.record().orElseThrow();
-        if (castEvents != null) castEvents.cast(audit, saved, readyAt, definition);
+        boolean deferNativeCast = audit != null && definition.id().equals("quickstep");
+        if (castEvents != null && !deferNativeCast) castEvents.cast(audit, saved, readyAt, definition);
         boolean synchronizedProgress = unchangedDeadline
             ? sessions.currentRecord(input.session()).filter(saved::equals).isPresent()
             : sessions.acknowledgeProgress(input.session(), expectedRevision, saved);
         if (!synchronizedProgress) {
+            if (deferNativeCast) castEvents.cast(audit, saved, readyAt, definition);
             resolve(audit, "interrupted", "session_publication_changed");
             input.player().sendMessage("The cooldown was saved, but the session changed; no effect was applied."); return;
         }
         if (!input.stillCurrent() || generations.getOrDefault(key, 0L) != generation
                 || !eligible(definition.targetPolicy(), input, input.target())) {
+            if (deferNativeCast) castEvents.cast(audit, saved, readyAt, definition);
             resolve(audit, "interrupted", "eligibility_changed");
             input.player().sendMessage("The cooldown was saved, but eligibility changed; no effect was applied."); return;
         }
-        var runtime = new Runtime(key, input, definition, generation, audit);
+        var runtime = new Runtime(key, input, definition, generation, audit,
+            deferNativeCast ? saved : null, readyAt);
         active.computeIfAbsent(key, ignored -> new HashSet<>()).add(runtime);
         try {
             definition.effect().activate(runtime);
+            runtime.publishCast();
             if (definition.activation() == AbilityDefinition.Activation.IMMEDIATE) runtime.finish();
         } catch (RuntimeException effectFailure) {
+            runtime.publishCast();
             runtime.resolve("failed"); runtime.close(); report(key.character(), key.ability(), effectFailure);
             input.player().sendMessage("The cooldown was saved, but the ability effect failed safely.");
         }
@@ -341,17 +350,41 @@ public final class AbilityEngine implements Consumer<ControlInput>, AutoCloseabl
         private final AbilityDefinition definition;
         private final long generation;
         private final games.dmg.fantasystick.events.AbilityCastEventBridge.Cast audit;
+        private final CharacterRecord deferredCastRecord;
+        private final Instant deferredDeadline;
+        private final Map<String, Object> castEvidence = new HashMap<>();
+        private boolean castPublished;
         private final Map<UUID, String> observedEffects = new HashMap<>();
+        private final Map<UUID, Map<String, Object>> observedEndEvidence = new HashMap<>();
         private final Set<AutoCloseable> owned = new HashSet<>();
         private String outcome;
         private Map<String, Object> resolutionEvidence = Map.of();
         private boolean finished;
+        private boolean closing;
         private int scheduled;
 
         Runtime(Key key, ControlInput input, AbilityDefinition definition, long generation,
-                games.dmg.fantasystick.events.AbilityCastEventBridge.Cast audit) {
+                games.dmg.fantasystick.events.AbilityCastEventBridge.Cast audit,
+                CharacterRecord deferredCastRecord, Instant deferredDeadline) {
             this.key = key; this.input = input; this.definition = definition; this.generation = generation;
-            this.audit = audit;
+            this.audit = audit; this.deferredCastRecord = deferredCastRecord; this.deferredDeadline = deferredDeadline;
+        }
+        void publishCast() {
+            if (deferredCastRecord == null || castPublished) return;
+            castPublished = true;
+            if (castEvents != null) castEvents.cast(audit, deferredCastRecord, deferredDeadline, definition,
+                Map.copyOf(castEvidence));
+        }
+        @Override public void castEvidence(Map<String, Object> evidence) {
+            if (!castPublished && !finished && deferredCastRecord != null)
+                castEvidence.putAll(Objects.requireNonNull(evidence));
+        }
+        @Override public void resolutionEvidence(Map<String, Object> evidence) {
+            if (!finished) {
+                var combined = new java.util.LinkedHashMap<>(resolutionEvidence);
+                combined.putAll(Objects.requireNonNull(evidence));
+                resolutionEvidence = Map.copyOf(combined);
+            }
         }
         @Override public AbilityDefinition definition() { return definition; }
         @Override public ControlInput input() { return input; }
@@ -359,7 +392,7 @@ public final class AbilityEngine implements Consumer<ControlInput>, AutoCloseabl
             return sessions.currentRecord(input.session()).orElseThrow(() -> new IllegalStateException("Ability session ended"));
         }
         @Override public boolean stillCurrent() {
-            return !closed && !finished && input.stillCurrent() && sessions.current(input.session())
+            return !closed && !finished && !closing && input.stillCurrent() && sessions.current(input.session())
                 && generations.getOrDefault(key, 0L) == generation
                 && sessions.currentRecord(input.session()).filter(record -> record.learned().contains(key.ability())).isPresent();
         }
@@ -414,6 +447,7 @@ public final class AbilityEngine implements Consumer<ControlInput>, AutoCloseabl
             try { feedback.report(definition, input, type, target, report.amount()); }
             catch (RuntimeException failure) { AbilityEngine.this.report(key.character(), key.ability(), failure); }
         }
+        @Override public java.time.Instant now() { return clock.instant(); }
         @Override public UUID effectApplied(String effectId, Entity target, Map<String, Object> evidence) {
             if (!stillCurrent()) throw new IllegalStateException("Ability execution ended");
             Objects.requireNonNull(effectId); Objects.requireNonNull(evidence);
@@ -452,6 +486,29 @@ public final class AbilityEngine implements Consumer<ControlInput>, AutoCloseabl
                 castEvents.prevented(audit, ally, aided.character(), aided.session(), attacker,
                     incoming, actual, remaining, bondApplication);
         }
+        @Override public void acceptedOutgoingMitigation(UUID application, Entity debuffedAttacker,
+                                                         Entity protectedTarget, double incoming, double remaining, double actual) {
+            if (castEvents == null || audit == null) return;
+            var evidence = new java.util.LinkedHashMap<String, Object>();
+            if (protectedTarget instanceof Player player)
+                sessions.active(player.getUniqueId()).filter(sessions::current).ifPresent(active -> {
+                    evidence.put("protected_character_id", active.character().toString());
+                    evidence.put("protected_session_id", active.session().toString());
+                });
+            castEvents.outgoingPrevented(audit, application, debuffedAttacker, protectedTarget,
+                incoming, remaining, actual, evidence);
+        }
+        @Override public void acceptedAbsorption(UUID application, Player target, Entity attacker,
+                                                  double incoming, double before, double after,
+                                                  double consumed, double remaining,
+                                                  org.bukkit.Location targetAtHit, org.bukkit.Location attackerAtHit) {
+            if (castEvents == null || audit == null) return;
+            try {
+                var aided = sessions.active(target.getUniqueId()).filter(sessions::current).orElse(null);
+                castEvents.absorbed(audit, application, target, aided, attacker, incoming,
+                    before, after, consumed, remaining, targetAtHit, attackerAtHit);
+            } catch (RuntimeException ignored) { /* Recording cannot change native absorption or support. */ }
+        }
         @Override public void acceptedBoost(EquipmentSessions.Active attacking, Player attacker,
                                             Entity target, double base, double bonus, double finalDamage,
                                             java.math.BigDecimal percent) {
@@ -459,18 +516,23 @@ public final class AbilityEngine implements Consumer<ControlInput>, AutoCloseabl
                 castEvents.boosted(audit, attacking, attacker, target, base, bonus, finalDamage, percent);
         }
         @Override public void effectEnded(UUID application, String reason) {
-            effectEnded(application, reason, Map.of());
+            effectEnded(application, reason, observedEndEvidence.getOrDefault(application, Map.of()));
+        }
+        @Override public void effectEndEvidence(UUID application, Map<String, Object> evidence) {
+            if (observedEffects.containsKey(application))
+                observedEndEvidence.put(application, Map.copyOf(Objects.requireNonNull(evidence)));
         }
         @Override public void effectEnded(UUID application, String reason, Map<String, Object> evidence) {
             Objects.requireNonNull(application); Objects.requireNonNull(reason); Objects.requireNonNull(evidence);
             var effectId = observedEffects.remove(application);
+            observedEndEvidence.remove(application);
             if (effectId != null && castEvents != null)
                 castEvents.effectEnded(audit, application, effectId, reason, evidence);
         }
         @Override public void resolve(String result) { resolve(result, Map.of()); }
         @Override public void resolve(String result, Map<String, Object> evidence) {
             if (!Set.of("completed", "hit", "miss", "expired", "interrupted", "failed", "cancelled",
-                    "healed", "cleansed", "protected", "boosted").contains(result))
+                    "healed", "cleansed", "protected", "boosted", "obstructed", "replaced").contains(result))
                 throw new IllegalArgumentException("Unsupported ability resolution");
             if (!finished) { outcome = result; resolutionEvidence = Map.copyOf(Objects.requireNonNull(evidence)); }
         }
@@ -479,11 +541,13 @@ public final class AbilityEngine implements Consumer<ControlInput>, AutoCloseabl
             close();
         }
         @Override public void close() {
-            if (finished) return;
-            finished = true;
+            if (finished || closing) return;
+            closing = true;
+            publishCast();
             if (outcome == null) outcome = "interrupted";
             var resources = List.copyOf(owned); owned.clear();
             for (var resource : resources) try { resource.close(); } catch (Exception failure) { AbilityEngine.this.report(key.character(), key.ability(), failure); }
+            finished = true;
             for (var application : List.copyOf(observedEffects.keySet())) effectEnded(application, outcome);
             if (castEvents != null) castEvents.resolved(audit, outcome,
                 outcome.equals("completed") ? "effect_finished_without_hit_claim" : "effect_ended", resolutionEvidence);

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

@@ -17,6 +17,8 @@ public interface AbilityExecution extends AutoCloseable {
     ControlInput input();
     games.dmg.fantasystick.persistence.CharacterRecord character();
     boolean stillCurrent();
+    /** Native-thread clock shared with cast and effect audit timestamps. */
+    default java.time.Instant now() { return java.time.Instant.now(); }
     List<Entity> eligible(Collection<? extends Entity> candidates, int maximum);
     AbilityScheduler.Task later(Duration delay, Runnable action);
     void own(AutoCloseable resource);
@@ -40,6 +42,14 @@ public interface AbilityExecution extends AutoCloseable {
     void acceptedPrevention(games.dmg.fantasystick.session.EquipmentSessions.Active aided,
                             org.bukkit.entity.Player ally, Entity attacker, double incoming,
                             double actual, double remaining, UUID bondApplication);
+    /** Record only the winning owned outgoing reduction after final uncancelled native damage. */
+    default void acceptedOutgoingMitigation(UUID application, Entity debuffedAttacker, Entity protectedTarget,
+                                            double incoming, double remaining, double actual) { }
+    /** Record only observed native consumption of this execution's owned temporary health. */
+    default void acceptedAbsorption(UUID application, org.bukkit.entity.Player target, Entity attacker,
+                                    double incoming, double before, double after, double consumed,
+                                    double remaining, org.bukkit.Location targetAtHit,
+                                    org.bukkit.Location attackerAtHit) { }
     /** Record a winning outgoing bonus only after a positive uncancelled native hit. */
     void acceptedBoost(games.dmg.fantasystick.session.EquipmentSessions.Active attacking,
                        org.bukkit.entity.Player attacker, Entity target,
@@ -50,6 +60,12 @@ public interface AbilityExecution extends AutoCloseable {
     default void effectEnded(UUID applicationId, String reason, Map<String, Object> evidence) {
         effectEnded(applicationId, reason);
     }
+    /** Capture remaining owned effect state during resource cleanup for the terminal effect record. */
+    default void effectEndEvidence(UUID applicationId, Map<String, Object> evidence) { }
+    /** Attach an observed native admission to the one pending cast record; never publish guessed velocity. */
+    default void castEvidence(Map<String, Object> evidence) { }
+    /** Attach actual final native position to an already chosen or interrupted resolution during cleanup. */
+    default void resolutionEvidence(Map<String, Object> evidence) { }
     /** An owner may specify a truthful terminal outcome before finishing. */
     void resolve(String outcome);
     void resolve(String outcome, Map<String, Object> evidence);

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

@@ -19,9 +19,9 @@ import org.bukkit.event.entity.EntityDamageEvent;
 public final class CombatMitigation implements Listener, AutoCloseable {
     private final class Grant implements AutoCloseable {
         final AbilityExecution execution; final Player player; final BigDecimal percent; final BooleanSupplier current;
-        final java.util.function.BiConsumer<EntityDamageEvent, Double> acceptedObservation; boolean closed;
+        final java.util.function.Consumer<Accepted> acceptedObservation; boolean closed;
         Grant(AbilityExecution execution, Player player, BigDecimal percent, BooleanSupplier current,
-              java.util.function.BiConsumer<EntityDamageEvent, Double> acceptedObservation) {
+              java.util.function.Consumer<Accepted> acceptedObservation) {
             this.execution = execution; this.player = player; this.percent = percent; this.current = current;
             this.acceptedObservation = acceptedObservation;
         }
@@ -35,7 +35,8 @@ public final class CombatMitigation implements Listener, AutoCloseable {
             if (owned != null) { owned.remove(this); if (owned.isEmpty()) grants.remove(player.getUniqueId()); }
         }
     }
-    private record Prevention(Grant grant, BigDecimal amount) { }
+    public record Accepted(EntityDamageByEntityEvent event, double incoming, double remaining, double prevented) { }
+    private record Prevention(Grant grant, double incoming, double reduced) { }
     private final Map<UUID, List<Grant>> grants = new java.util.HashMap<>();
     private final Map<EntityDamageEvent, Prevention> pending = new IdentityHashMap<>();
     private boolean closed;
@@ -48,9 +49,16 @@ public final class CombatMitigation implements Listener, AutoCloseable {
         return grant(execution, player, percent, current, null);
     }
 
-    /** An owner may observe only the selected, positive native prevention after final cancellation. */
+    /** Legacy owner observation; keep existing prevention consumers unchanged. */
     public AutoCloseable grant(AbilityExecution execution, Player player, BigDecimal percent, BooleanSupplier current,
-                               java.util.function.BiConsumer<EntityDamageEvent, Double> acceptedObservation) {
+                               java.util.function.BiConsumer<EntityDamageEvent, Double> observation) {
+        return grantAccepted(execution, player, percent, current,
+            observation == null ? null : accepted -> observation.accept(accepted.event(), accepted.prevented()));
+    }
+
+    /** An owner may observe the selected, positive native prevention and its original hit value. */
+    public AutoCloseable grantAccepted(AbilityExecution execution, Player player, BigDecimal percent, BooleanSupplier current,
+                                       java.util.function.Consumer<Accepted> acceptedObservation) {
         Objects.requireNonNull(execution); Objects.requireNonNull(player); Objects.requireNonNull(percent); Objects.requireNonNull(current);
         if (closed || percent.signum() < 0 || percent.compareTo(BigDecimal.valueOf(100)) > 0)
             throw new IllegalArgumentException("Invalid combat mitigation grant");
@@ -75,8 +83,7 @@ public final class CombatMitigation implements Listener, AutoCloseable {
             .multiply(BigDecimal.ONE.subtract(strongest.percent.movePointLeft(2))).doubleValue();
         if (!Double.isFinite(reduced) || reduced < 0) return;
         event.setDamage(reduced);
-        BigDecimal prevented = BigDecimal.valueOf(original - reduced);
-        if (prevented.signum() > 0) pending.put(event, new Prevention(strongest, prevented));
+        if (original > reduced) pending.put(event, new Prevention(strongest, original, reduced));
     }
 
     @EventHandler(priority = EventPriority.MONITOR)
@@ -84,9 +91,15 @@ public final class CombatMitigation implements Listener, AutoCloseable {
         var prevention = pending.remove(event);
         if (prevention == null || event.isCancelled() || event.getFinalDamage() <= 0
                 || !prevention.grant.valid()) return;
-        prevention.grant.execution.report(AbilityReport.Type.PREVENTION, event.getEntity(), prevention.amount);
+        double remaining = event.getDamage();
+        double actual = Math.min(prevention.incoming - prevention.reduced, prevention.incoming - remaining);
+        if (!Double.isFinite(remaining) || !Double.isFinite(actual) || actual <= 0) return;
+        try { prevention.grant.execution.report(AbilityReport.Type.PREVENTION, event.getEntity(),
+            BigDecimal.valueOf(actual)); }
+        catch (RuntimeException ignored) { /* Feedback cannot interrupt an accepted native hit or its audit. */ }
         if (prevention.grant.acceptedObservation != null) try {
-            prevention.grant.acceptedObservation.accept(event, prevention.amount.doubleValue());
+            prevention.grant.acceptedObservation.accept(new Accepted((EntityDamageByEntityEvent) event,
+                prevention.incoming, remaining, actual));
         } catch (RuntimeException ignored) { /* Audit cannot alter the accepted native hit. */ }
     }
 

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

@@ -35,15 +35,37 @@ public final class Hex implements AbilityEffect,AutoCloseable{
             "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.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);}
+    @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.trainingDummy(target)) {
+            execution.resolve("miss", Map.of("reason", "target_ineligible_after_cooldown"));
+            execution.finish(); return;
+        }
+        var application = new java.util.concurrent.atomic.AtomicReference<UUID>();
+        var grant = mitigation.grantObserved(execution, target, current.reductionPercent(), accepted -> {
+            try { execution.acceptedOutgoingMitigation(application.get(), accepted.debuffedAttacker(),
+                accepted.recipient(), accepted.incoming(), accepted.remaining(), accepted.prevented()); }
+            catch (RuntimeException ignored) { /* Native damage and support do not depend on auditing. */ }
+        });
+        var state = new State(execution, target, grant);
+        var previous = hexes.put(target.getUniqueId(), state);
+        if (previous != null) { previous.execution.resolve("replaced"); previous.execution.finish(); }
+        execution.own(state);
+        var evidence = new java.util.LinkedHashMap<String, Object>();
+        evidence.put("reduction_percent", current.reductionPercent().stripTrailingZeros().toPlainString());
+        evidence.put("duration_seconds", seconds(current.duration()));
+        var activatedAt = execution.now();
+        if (activatedAt != null) evidence.put("effect_until", activatedAt.plus(current.duration()).toString());
+        application.set(execution.effectApplied("hex", target, evidence));
+        execution.later(current.duration(), () -> { execution.resolve("expired"); execution.finish(); });
+    }
     private static boolean inRange(ControlInput input,LivingEntity target,double range){try{Location source=input.player().getLocation(),destination=target.getLocation();
         return source.getWorld()==destination.getWorld()&&source.distanceSquared(destination)<=range*range&&input.player().hasLineOfSight(target);
         }catch(RuntimeException invalid){return false;}}
     private static Settings from(AbilityDefinition definition){var p=definition.parameters();return new Settings(definition.cooldown(),p.get("range").doubleValue(),
         Duration.ofNanos(p.get("duration-seconds").movePointRight(9).longValueExact()),p.get("damage-reduction-percent"));}
     private static String seconds(Duration value){return BigDecimal.valueOf(value.toNanos()).movePointLeft(9).stripTrailingZeros().toPlainString();}
-    @Override public void close(){if(closed)return;closed=true;for(var state:List.copyOf(hexes.values()))state.execution.finish();hexes.clear();}
+    @Override public void close(){if(closed)return;closed=true;for(var state:List.copyOf(hexes.values())){
+        state.execution.resolve("interrupted"); state.execution.finish();}hexes.clear();}
 }

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

@@ -8,7 +8,38 @@ public final class Inspire implements AbilityEffect,AutoCloseable{
  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);}
+ @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.resolve("miss",Map.of("reason","target_ineligible_after_cooldown"));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.resolve("miss",Map.of("reason","no_positive_temporary_health"));execution.finish();return;}
+  var application=new java.util.concurrent.atomic.AtomicReference<UUID>();
+  var grant=temporaryHealth.grantObserved(execution,target,nativeAmount,accepted->{
+   try{execution.acceptedAbsorption(application.get(),accepted.target(),accepted.attacker(),accepted.incoming(),
+    accepted.before(),accepted.after(),accepted.consumed(),accepted.remaining(),accepted.targetAtHit(),accepted.attackerAtHit());}
+   catch(RuntimeException ignored){/* Audit cannot change native absorption or party rewards. */}
+  },remaining->{
+   var id=application.get();
+   if(id!=null)execution.effectEndEvidence(id,Map.of("remaining_amount",
+    BigDecimal.valueOf(remaining).stripTrailingZeros().toPlainString()));
+  });
+  execution.own(grant);
+  var evidence=new LinkedHashMap<String,Object>();
+  evidence.put("granted_amount",BigDecimal.valueOf(nativeAmount).stripTrailingZeros().toPlainString());
+  evidence.put("remaining_amount",BigDecimal.valueOf(nativeAmount).stripTrailingZeros().toPlainString());
+  evidence.put("duration_seconds",seconds(s.duration()));
+  var activatedAt=execution.now();if(activatedAt!=null)evidence.put("effect_until",activatedAt.plus(s.duration()).toString());
+  temporaryHealth.currentSession(target).ifPresent(active->{
+   evidence.put("target_character_id",active.character().toString());
+   evidence.put("target_session_id",active.session().toString());
+  });
+  application.set(execution.effectApplied("inspire",target,evidence));
+  execution.later(s.duration(),()->{execution.resolve("expired");execution.finish();});
+ }
  private static boolean inRange(Player source,Player target,double range){try{var a=source.getLocation();var b=target.getLocation();return a.getWorld()==b.getWorld()&&a.distanceSquared(b)<=range*range&&source.hasLineOfSight(target);}catch(RuntimeException invalid){return false;}}
  private static Settings from(AbilityDefinition d){var p=d.parameters();return new Settings(p.get("base-temporary-health").toBigIntegerExact(),d.cooldown(),p.get("range").doubleValue(),Duration.ofNanos(p.get("duration-seconds").movePointRight(9).longValueExact()));}
  private static String seconds(Duration d){return BigDecimal.valueOf(d.toNanos()).movePointLeft(9).stripTrailingZeros().toPlainString();}

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

@@ -25,24 +25,36 @@ import org.bukkit.projectiles.ProjectileSource;
 public final class OutgoingDamageMitigation implements Listener, AutoCloseable {
     public record Support(UUID target, UUID supportingCharacter, EquipmentSessions.Active aided, BigDecimal amount) { }
     private final class Grant implements AutoCloseable {
-        final long sequence; final AbilityExecution execution; final LivingEntity target; final BigDecimal percent; boolean closed;
-        Grant(AbilityExecution execution, LivingEntity target, BigDecimal percent) {
+        final long sequence; final AbilityExecution execution; final LivingEntity target; final BigDecimal percent;
+        final Consumer<Accepted> observation; boolean closed;
+        Grant(AbilityExecution execution, LivingEntity target, BigDecimal percent, Consumer<Accepted> observation) {
             this.sequence=++sequences;this.execution=execution;this.target=target;this.percent=percent;
+            this.observation = observation;
         }
         @Override public void close(){if(closed)return;closed=true;var owned=grants.get(target.getUniqueId());
             if(owned!=null){owned.remove(this);if(owned.isEmpty())grants.remove(target.getUniqueId());}}
     }
-    private record Prevention(Grant grant, Entity recipient, BigDecimal amount) { }
+    public record Accepted(LivingEntity debuffedAttacker, Entity recipient,
+                           double incoming, double remaining, double prevented) { }
+    private record Prevention(Grant grant, Entity recipient, double incoming, double reduced) { }
     private final EquipmentSessions sessions; private final PartyRoster parties; private final Consumer<Support> supports;
     private final Map<UUID,List<Grant>> grants=new java.util.HashMap<>();
     private final Map<EntityDamageEvent,Prevention> pending=new IdentityHashMap<>();
     private long sequences; private boolean closed;
     public OutgoingDamageMitigation(EquipmentSessions sessions,PartyRoster parties,Consumer<Support> supports){
         this.sessions=Objects.requireNonNull(sessions);this.parties=Objects.requireNonNull(parties);this.supports=Objects.requireNonNull(supports);}
-    public AutoCloseable grant(AbilityExecution execution,LivingEntity target,BigDecimal percent){
-        Objects.requireNonNull(execution);Objects.requireNonNull(target);Objects.requireNonNull(percent);
-        if(closed||percent.signum()<0||percent.compareTo(BigDecimal.valueOf(100))>0)throw new IllegalArgumentException("Invalid outgoing mitigation grant");
-        var grant=new Grant(execution,target,percent);grants.computeIfAbsent(target.getUniqueId(),ignored->new ArrayList<>()).add(grant);return grant;}
+    public AutoCloseable grant(AbilityExecution execution, LivingEntity target, BigDecimal percent) {
+        return grantObserved(execution, target, percent, null);
+    }
+    public AutoCloseable grantObserved(AbilityExecution execution, LivingEntity target, BigDecimal percent,
+                                      Consumer<Accepted> observation) {
+        Objects.requireNonNull(execution); Objects.requireNonNull(target); Objects.requireNonNull(percent);
+        if (closed || percent.signum() < 0 || percent.compareTo(BigDecimal.valueOf(100)) > 0)
+            throw new IllegalArgumentException("Invalid outgoing mitigation grant");
+        var grant = new Grant(execution, target, percent, observation);
+        grants.computeIfAbsent(target.getUniqueId(), ignored -> new ArrayList<>()).add(grant);
+        return grant;
+    }
 
     @EventHandler(priority=EventPriority.NORMAL,ignoreCancelled=true)
     public void reduce(EntityDamageByEntityEvent event){
@@ -53,20 +65,31 @@ public final class OutgoingDamageMitigation implements Listener, AutoCloseable {
         double original=event.getDamage();if(strongest==null||!Double.isFinite(original)||original<=0)return;
         double reduced=BigDecimal.valueOf(original).multiply(BigDecimal.ONE.subtract(strongest.percent.movePointLeft(2))).doubleValue();
         if(!Double.isFinite(reduced)||reduced<0)return;event.setDamage(reduced);var prevented=BigDecimal.valueOf(original-reduced);
-        if(prevented.signum()>0)pending.put(event,new Prevention(strongest,event.getEntity(),prevented));
+        if(prevented.signum()>0)pending.put(event,new Prevention(strongest,event.getEntity(),original,reduced));
     }
 
     @EventHandler(priority=EventPriority.MONITOR)
     public void accepted(EntityDamageEvent event){
-        var prevention=pending.remove(event);if(prevention==null||event.isCancelled()||!prevention.grant.execution.stillCurrent())return;
-        prevention.grant.execution.report(AbilityReport.Type.PREVENTION,prevention.grant.target,prevention.amount);
-        if(!(prevention.recipient instanceof Player player))return;
+        var prevention = pending.remove(event);
+        if (prevention == null || event.isCancelled() || !Double.isFinite(event.getFinalDamage())
+                || event.getFinalDamage() <= 0 || !prevention.grant.execution.stillCurrent()) return;
+        double remaining = event.getDamage();
+        double actual = Math.min(prevention.incoming - prevention.reduced, prevention.incoming - remaining);
+        if (!Double.isFinite(remaining) || !Double.isFinite(actual) || actual <= 0) return;
+        var amount = BigDecimal.valueOf(actual);
+        try { prevention.grant.execution.report(AbilityReport.Type.PREVENTION, prevention.grant.target, amount); }
+        catch (RuntimeException ignored) { /* Feedback cannot interrupt accepted native prevention. */ }
+        if (prevention.grant.observation != null) try {
+            prevention.grant.observation.accept(new Accepted(prevention.grant.target,
+                prevention.recipient, prevention.incoming, remaining, actual));
+        } catch (RuntimeException ignored) { /* Audit cannot alter damage or rewards. */ }
+        if (!(prevention.recipient instanceof Player player)) return;
         var aided=sessions.active(player.getUniqueId()).orElse(null);if(aided==null||!sessions.current(aided))return;
         var input=prevention.grant.execution.input();if(aided.character().equals(input.session().character()))return;
         var sourceParty=parties.partyOf(input.player().getUniqueId()).orElse(null);
         var aidedParty=parties.partyOf(player.getUniqueId()).orElse(null);
         if(sourceParty==null||aidedParty==null||!sourceParty.id().equals(aidedParty.id()))return;
-        supports.accept(new Support(prevention.grant.target.getUniqueId(),input.session().character(),aided,prevention.amount));
+        supports.accept(new Support(prevention.grant.target.getUniqueId(),input.session().character(),aided,amount));
     }
 
     private static Entity attacker(EntityDamageByEntityEvent event){

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

@@ -41,11 +41,20 @@ public final class Quickstep implements AbilityEffect, Listener, AutoCloseable {
         final Location origin;
         final Vector horizontal;
         final Settings settings;
+        final long started = System.nanoTime();
+        final long boundTicks;
+        Location lastObserved;
         boolean owned = true;
         boolean closed;
-        State(AbilityExecution execution, Player player, Location origin, Vector horizontal, Settings settings) {
+        State(AbilityExecution execution, Player player, Location origin, Vector horizontal,
+              Settings settings, long boundTicks) {
             this.execution = execution; this.player = player; this.origin = origin;
-            this.horizontal = horizontal; this.settings = settings;
+            this.horizontal = horizontal; this.settings = settings; this.boundTicks = boundTicks;
+        }
+        void finish(String outcome, Location observed) {
+            lastObserved = observed == null ? null : observed.clone();
+            execution.resolve(outcome);
+            execution.finish();
         }
         boolean stillOwns(Vector current) {
             var horizontalCurrent = new Vector(current.getX(), 0, current.getZ());
@@ -57,6 +66,20 @@ public final class Quickstep implements AbilityEffect, Listener, AutoCloseable {
         @Override public void close() {
             if (closed) return;
             closed = true; dashes.remove(player.getUniqueId(), this);
+            try {
+                var to = lastObserved == null ? player.getLocation() : lastObserved;
+                if (to != null) {
+                    var evidence = new java.util.LinkedHashMap<String, Object>();
+                    evidence.put("to_location", locationData(to));
+                    evidence.put("elapsed_ms", Math.max(0, (System.nanoTime() - started) / 1_000_000L));
+                    evidence.put("bound_ticks", boundTicks);
+                    if (to.getWorld() != null && to.getWorld().equals(origin.getWorld())) {
+                        double dx = to.getX() - origin.getX(), dz = to.getZ() - origin.getZ();
+                        evidence.put("horizontal_distance", Math.hypot(dx, dz));
+                    } else evidence.put("horizontal_distance_status", "not_comparable_cross_world");
+                    execution.resolutionEvidence(evidence);
+                }
+            } catch (RuntimeException ignored) { /* Auditing cannot change native motion or cleanup. */ }
             if (!owned) return;
             Vector current = player.getVelocity();
             if (!stillOwns(current)) return;
@@ -98,24 +121,41 @@ public final class Quickstep implements AbilityEffect, Listener, AutoCloseable {
         if (closed || !execution.stillCurrent()) return;
         var current = from(execution.definition());
         var player = execution.input().player();
-        if (!accepts(execution.input())) { execution.finish(); return; }
+        var origin = player.getLocation().clone();
+        try { execution.castEvidence(Map.of("from_location", locationData(origin))); }
+        catch (RuntimeException ignored) { /* Capturing an origin cannot affect admission. */ }
+        if (!accepts(execution.input())) {
+            rejectedVelocity(execution, origin, "native_recheck_refused"); return;
+        }
         Vector direction = player.getEyeLocation().getDirection(); direction.setY(0).normalize();
         Vector before = player.getVelocity();
-        Vector horizontal = direction.multiply(current.speedPerTick());
+        Vector horizontal = direction.clone().multiply(current.speedPerTick());
         var proposed = new Vector(horizontal.getX(), before.getY(), horizontal.getZ());
+        try { execution.castEvidence(Map.of("intended_direction", vectorData(direction),
+            "native_velocity_status", "pending_native_decision")); }
+        catch (RuntimeException ignored) { /* Capturing intent cannot affect native velocity. */ }
         var event = new PlayerVelocityEvent(player, proposed.clone());
         velocityEvents.accept(event);
-        if (event.isCancelled() || !finite(event.getVelocity())) { execution.finish(); return; }
+        if (event.isCancelled() || !finite(event.getVelocity())) {
+            rejectedVelocity(execution, origin, "native_velocity_cancelled_or_invalid"); return;
+        }
         Vector accepted = event.getVelocity().clone(); accepted.setY(before.getY());
         Vector acceptedHorizontal = new Vector(accepted.getX(), 0, accepted.getZ());
-        if (acceptedHorizontal.lengthSquared() < 1.0e-12) { execution.finish(); return; }
-        var state = new State(execution, player, player.getLocation().clone(), acceptedHorizontal, current);
+        if (acceptedHorizontal.lengthSquared() < 1.0e-12) {
+            rejectedVelocity(execution, origin, "native_velocity_without_horizontal_motion"); return;
+        }
+        try { execution.castEvidence(Map.of("accepted_velocity", vectorData(accepted),
+            "native_velocity_status", "accepted")); }
+        catch (RuntimeException ignored) { /* Capturing accepted velocity cannot affect movement. */ }
+        long ticks = Math.max(1, (long) Math.ceil(current.distance() / acceptedHorizontal.length()));
+        var state = new State(execution, player, origin, acceptedHorizontal, current, ticks + 1);
         var previous = dashes.put(player.getUniqueId(), state);
-        if (previous != null) previous.execution.finish();
+        if (previous != null) previous.finish("replaced", previous.player.getLocation());
         execution.own(state);
         player.setVelocity(accepted);
-        long ticks = Math.max(1, (long) Math.ceil(current.distance() / acceptedHorizontal.length()));
-        execution.later(Duration.ofMillis(Math.multiplyExact(ticks + 1, 50)), execution::finish);
+        execution.later(Duration.ofMillis(Math.multiplyExact(ticks + 1, 50)), () -> {
+            execution.resolve("completed", Map.of("reason", "elapsed_bound")); execution.finish();
+        });
     }
 
     @EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = true)
@@ -123,18 +163,44 @@ public final class Quickstep implements AbilityEffect, Listener, AutoCloseable {
         var state = dashes.get(event.getPlayer().getUniqueId());
         if (state == null || state.player != event.getPlayer()) return;
         var to = event.getTo();
-        if (to == null || !state.execution.stillCurrent()) { state.execution.finish(); return; }
+        if (to == null || !state.execution.stillCurrent()) {
+            state.finish("interrupted", to); return;
+        }
+        state.lastObserved = to.clone();
+        if (to.getWorld() == null || !to.getWorld().equals(state.origin.getWorld())) {
+            state.finish("interrupted", to); return;
+        }
         Vector current = state.player.getVelocity();
         if (!state.stillOwns(current)) {
-            state.owned = false; state.execution.finish(); return;
+            state.owned = false; state.finish("replaced", to); return;
         }
         double dx = to.getX() - state.origin.getX(); double dz = to.getZ() - state.origin.getZ();
-        if (dx * dx + dz * dz >= state.settings.distance() * state.settings.distance()
-                || new Vector(current.getX(), 0, current.getZ()).lengthSquared() < 1.0e-12) {
-            state.execution.finish();
+        if (dx * dx + dz * dz >= state.settings.distance() * state.settings.distance()) {
+            state.finish("completed", to);
+        } else if (new Vector(current.getX(), 0, current.getZ()).lengthSquared() < 1.0e-12) {
+            state.finish("obstructed", to);
         }
     }
 
+    private static void rejectedVelocity(AbilityExecution execution, Location origin, String reason) {
+        try { execution.castEvidence(Map.of("native_velocity_status", "cancelled"));
+            execution.resolve("cancelled", Map.of("reason", reason,
+                "to_location", locationData(origin), "horizontal_distance", 0)); }
+        catch (RuntimeException ignored) { /* Native rejection is not contingent on audit capture. */ }
+        execution.finish();
+    }
+
+    private static Map<String, Object> vectorData(Vector vector) {
+        return Map.of("x", vector.getX(), "y", vector.getY(), "z", vector.getZ());
+    }
+
+    private static Map<String, Object> locationData(Location location) {
+        if (location == null || location.getWorld() == null) return Map.of("status", "unavailable");
+        return Map.of("world_id", location.getWorld().getUID().toString(),
+            "world_name", location.getWorld().getName(), "x", location.getX(), "y", location.getY(),
+            "z", location.getZ(), "captured_at", java.time.Instant.now().toString());
+    }
+
     private static boolean finite(Vector vector) {
         return Double.isFinite(vector.getX()) && Double.isFinite(vector.getY()) && Double.isFinite(vector.getZ());
     }

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

@@ -53,6 +53,7 @@ public final class Revive implements AbilityEffect, Listener, AutoCloseable {
     private games.dmg.fantasystick.session.DownedController downed;
     private games.dmg.fantasystick.events.DownedEventBridge downedEvents;
     private games.dmg.fantasystick.events.ReviveEventBridge reviveEvents;
+    private games.dmg.fantasystick.events.AdminRevivalEventBridge adminRevivalEvents;
     private java.util.function.Supplier<Duration> downedProtection=()->Duration.ofSeconds(5);
     private final Map<Inventory, View> inventories = new IdentityHashMap<>();
     private final Map<UUID, View> targets = new LinkedHashMap<>();
@@ -93,6 +94,11 @@ public final class Revive implements AbilityEffect, Listener, AutoCloseable {
     public void attachDowned(games.dmg.fantasystick.session.DownedController controller,java.util.function.Supplier<Duration> protection){if(closed||downed!=null)throw new IllegalStateException("Downed Revive already attached or closed");downed=Objects.requireNonNull(controller);downedProtection=Objects.requireNonNull(protection);}
     public void attachDownedEvents(games.dmg.fantasystick.events.DownedEventBridge events){if(closed||downedEvents!=null)throw new IllegalStateException("Downed Revive events already attached or closed");downedEvents=Objects.requireNonNull(events);}
     public void attachEvents(games.dmg.fantasystick.events.ReviveEventBridge events){if(closed||reviveEvents!=null)throw new IllegalStateException("Revive events already attached or closed");reviveEvents=Objects.requireNonNull(events);}
+    public void attachAdminRevivalEvents(games.dmg.fantasystick.events.AdminRevivalEventBridge events){if(closed||adminRevivalEvents!=null)throw new IllegalStateException("Admin revival events already attached or closed");adminRevivalEvents=Objects.requireNonNull(events);}
+    private void recoveryEvent(RevivalStore.Reservation reservation,CharacterRecord restored,Player target){
+        if(reservation.administrative()){if(adminRevivalEvents!=null)adminRevivalEvents.recovered(reservation,restored,target);}
+        else if(reviveEvents!=null)reviveEvents.recovered(reservation,restored,target);
+    }
 
     public AbilityDefinition definition() {
         return new AbilityDefinition("revive", "Revive", Material.ECHO_SHARD,
@@ -358,7 +364,7 @@ public final class Revive implements AbilityEffect, Listener, AutoCloseable {
             : source != null && source.getAmount() == reservation.sourceAmount() - 1
                 && tails.identify(source).filter(id -> id.deathId().equals(reservation.death())).isPresent();
         if (!record.dead() && hasSheet && installFinalSheet(target, record)) {
-            if(reviveEvents!=null)reviveEvents.recovered(reservation,record,target);reservations.clear(reservation.character(), reservation.id()); return;
+            recoveryEvent(reservation,record,target);reservations.clear(reservation.character(), reservation.id()); return;
         }
         if (record.dead() && unchangedTail && !hasSheet) {
             reservations.clear(reservation.character(), reservation.id()); return;
@@ -375,7 +381,7 @@ public final class Revive implements AbilityEffect, Listener, AutoCloseable {
                 .whenComplete((restored, failure) -> schedule(() -> {
                     if (failure != null) { report(failure); return; }
                     if (restored.isPresent() && installFinalSheet(target, restored.orElseThrow())) {
-                        if(reviveEvents!=null)reviveEvents.recovered(reservation,restored.orElseThrow(),target);reservations.clear(reservation.character(), reservation.id());
+                        recoveryEvent(reservation,restored.orElseThrow(),target);reservations.clear(reservation.character(), reservation.id());
                     }
                 }));
         }

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

@@ -80,17 +80,24 @@ public final class SecondWind implements AbilityEffect {
         BigInteger base = definition.parameters().get("base-healing").toBigIntegerExact();
         var player = execution.input().player();
         var attribute = player.getAttribute(Attribute.MAX_HEALTH);
-        if (attribute == null) { execution.finish(); return; }
+        if (attribute == null) { execution.resolve("cancelled", Map.of("reason", "maximum_unavailable")); execution.finish(); return; }
         double current = player.getHealth(); double maximum = attribute.getValue();
         double missing = maximum - current;
-        if (!Double.isFinite(current) || !Double.isFinite(maximum) || missing <= 0) { execution.finish(); return; }
+        if (!Double.isFinite(current) || !Double.isFinite(maximum) || missing <= 0) {
+            execution.resolve("cancelled", Map.of("reason", "health_unavailable_or_full")); execution.finish(); return;
+        }
         BigInteger exact = healing(base, execution.character().stats().get(Stat.WIS));
         double proposed = exact.bitLength() > 1023 ? missing : Math.min(missing, exact.doubleValue());
-        if (!Double.isFinite(proposed) || proposed <= 0) { execution.finish(); return; }
+        if (!Double.isFinite(proposed) || proposed <= 0) {
+            execution.resolve("cancelled", Map.of("reason", "healing_nonpositive")); execution.finish(); return;
+        }
         var event = new EntityRegainHealthEvent(player, proposed, EntityRegainHealthEvent.RegainReason.CUSTOM);
         healingEvents.accept(event);
         double accepted = Math.min(missing, event.getAmount());
-        if (event.isCancelled() || !Double.isFinite(accepted) || accepted <= 0) { execution.finish(); return; }
+        if (event.isCancelled() || !Double.isFinite(accepted) || accepted <= 0) {
+            execution.resolve("cancelled", Map.of("reason", "native_healing_cancelled_or_nonpositive"));
+            execution.finish(); return;
+        }
         var record = execution.character(); var expected = record.revision();
         BigDecimal target = BigDecimal.valueOf(current + accepted);
         BigDecimal limit = nativeLimit.get();
@@ -99,18 +106,33 @@ public final class SecondWind implements AbilityEffect {
                 nextTick.accept(() -> {
                     try {
                         if (failure != null || saved == null || saved.isEmpty() || !execution.stillCurrent()) {
+                            execution.resolve(failure != null || saved == null || saved.isEmpty() ? "failed" : "interrupted",
+                                Map.of("reason", failure != null ? "health_save_failed" : saved == null || saved.isEmpty()
+                                    ? "health_save_unconfirmed" : "session_changed_before_healing"));
                             player.sendMessage("Second Wind health could not be saved; no healing was applied."); return;
                         }
                         var persisted = saved.orElseThrow();
                         if (!sessions.acknowledgeProgress(execution.input().session(), expected, persisted)) {
+                            execution.resolve("interrupted", Map.of("reason", "health_saved_session_changed"));
                             player.sendMessage("Second Wind was saved, but the session changed; no native healing was applied."); return;
                         }
                         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());
+                        try { player.setHealth(publish); }
+                        catch (RuntimeException nativeFailure) {
+                            execution.resolve("failed", Map.of("reason", "native_health_publication_failed"));
+                            throw nativeFailure;
+                        }
+                        double nativeAfter = player.getHealth();
+                        double restored = nativeAfter - nativeBefore;
+                        if (Double.isFinite(restored) && restored > 0) {
+                            try { execution.acceptedHeal(execution.input().session(), player, persisted, proposed,
+                                restored, nativeBefore, nativeAfter, maximum); }
+                            catch (RuntimeException ignored) { /* Auditing cannot change an applied native heal. */ }
+                            execution.resolve("healed", Map.of("reason", "native_self_heal_applied"));
+                            execution.report(AbilityReport.Type.HEALING, player,
+                                BigDecimal.valueOf(restored).stripTrailingZeros());
+                        } else execution.resolve("cancelled", Map.of("reason", "native_heal_not_observed"));
                     } finally { execution.finish(); }
                 });
             } catch (RuntimeException rejected) { execution.finish(); }

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

@@ -19,6 +19,7 @@ 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.player.PlayerVelocityEvent;
 import org.bukkit.util.Vector;
 
@@ -39,9 +40,12 @@ public final class ShieldBash implements AbilityEffect, Listener, AutoCloseable
         }
     }
     private static final class Attempt {
-        final AbilityExecution execution; final LivingEntity target; final Settings settings; boolean accepted;
-        Attempt(AbilityExecution execution, LivingEntity target, Settings settings) {
+        final AbilityExecution execution; final LivingEntity target; final Settings settings;
+        final double requested; final double healthBefore;
+        double finalDamage; boolean accepted; boolean cancelled;
+        Attempt(AbilityExecution execution, LivingEntity target, Settings settings, double requested, double healthBefore) {
             this.execution = execution; this.target = target; this.settings = settings;
+            this.requested = requested; this.healthBefore = healthBefore;
         }
     }
 
@@ -85,42 +89,109 @@ public final class ShieldBash implements AbilityEffect, Listener, AutoCloseable
     @Override public void activate(AbilityExecution execution) {
         if (closed || !execution.stillCurrent() || !(execution.input().target() instanceof LivingEntity target)) return;
         var current = from(execution.definition()); var player = execution.input().player();
-        if (!inRange(player, target, current.range())) { execution.finish(); return; }
+        if (!inRange(player, target, current.range())) {
+            execution.resolve("miss", Map.of("reason", "target_out_of_range_or_obstructed"));
+            execution.finish(); return;
+        }
         var exact = damage(current.baseDamage(), execution.character().stats().get(Stat.STR));
         double amount = exact.bitLength() > 1023 ? Double.MAX_VALUE : exact.doubleValue();
-        if (!Double.isFinite(amount) || amount <= 0) { execution.finish(); return; }
+        if (!Double.isFinite(amount) || amount <= 0) {
+            execution.resolve("miss", Map.of("reason", "damage_nonpositive")); 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 { execution.damage(target, amount, source); }
-        finally { if (damaging == attempt) damaging = null; execution.finish(); }
+        double beforeHealth;
+        try { beforeHealth = target.getHealth(); }
+        catch (RuntimeException unavailable) { beforeHealth = Double.NaN; }
+        var attempt = new Attempt(execution, target, current, amount, beforeHealth); damaging = attempt;
+        boolean nativeFailed = false;
+        try {
+            execution.damage(target, amount, source);
+            if (attempt.accepted) publishAccepted(attempt);
+        }
+        catch (RuntimeException failed) {
+            nativeFailed = true;
+            if (!attempt.accepted) execution.resolve("failed", Map.of("reason", "native_damage_failed"));
+            throw failed;
+        } finally {
+            if (damaging == attempt) damaging = null;
+            if (!attempt.accepted && !nativeFailed)
+                execution.resolve(attempt.cancelled ? "cancelled" : "miss",
+                    Map.of("reason", attempt.cancelled ? "native_damage_cancelled" : "native_damage_not_accepted"));
+            execution.finish();
+        }
     }
 
-    @EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = true)
+    /** Yield generic incoming-player capture to the owning accepted Shield Bash strike. */
+    public boolean ownsAcceptedDamage(EntityDamageEvent event) {
+        return event instanceof EntityDamageByEntityEvent by && matches(damaging, by);
+    }
+
+    private boolean matches(Attempt attempt, EntityDamageByEntityEvent event) {
+        if (closed || attempt == null || event.getDamager() != attempt.execution.input().player()
+                || event.getEntity() != attempt.target) return false;
+        var source = event.getDamageSource();
+        return (source.getCausingEntity() == null || source.getCausingEntity() == attempt.execution.input().player())
+            && (source.getDirectEntity() == null || source.getDirectEntity() == attempt.execution.input().player());
+    }
+
+    @EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = false)
     public void acceptedDamage(EntityDamageByEntityEvent event) {
         var attempt = damaging;
-        if (closed || attempt == null || attempt.accepted || event.isCancelled() || event.getFinalDamage() <= 0
-                || !Double.isFinite(event.getFinalDamage()) || event.getDamager() != attempt.execution.input().player()
-                || event.getEntity() != attempt.target || !attempt.execution.stillCurrent()) return;
+        if (!matches(attempt, event) || attempt.accepted || !attempt.execution.stillCurrent()) return;
+        if (event.isCancelled()) { attempt.cancelled = true; return; }
+        if (event.getFinalDamage() <= 0 || !Double.isFinite(event.getFinalDamage())) return;
         attempt.accepted = true;
-        attempt.execution.report(AbilityReport.Type.DAMAGE, event.getEntity(),
-            BigDecimal.valueOf(event.getFinalDamage()).stripTrailingZeros());
-        knockback(attempt);
+        attempt.finalDamage = event.getFinalDamage();
     }
 
-    private void knockback(Attempt attempt) {
-        var player = attempt.execution.input().player(); var target = attempt.target;
-        Vector away = target.getLocation().toVector().subtract(player.getLocation().toVector()); away.setY(0);
-        if (!finite(away) || away.lengthSquared() < 1.0e-12) return;
-        Vector current = target.getVelocity();
-        Vector proposed = current.clone().add(away.normalize().multiply(attempt.settings.horizontalKnockback()));
-        proposed.setY(Math.max(current.getY(), attempt.settings.minimumVerticalKnockback()));
-        if (!finite(proposed)) return;
-        if (target instanceof Player targetPlayer) {
-            var event = new PlayerVelocityEvent(targetPlayer, proposed.clone()); velocityEvents.accept(event);
-            if (event.isCancelled() || !finite(event.getVelocity())) return;
-            proposed = event.getVelocity().clone();
-        }
-        target.setVelocity(proposed);
+    private void publishAccepted(Attempt attempt) {
+        var evidence = new java.util.LinkedHashMap<String, Object>();
+        evidence.put("stage", "native_damage_accepted");
+        try {
+            double afterHealth = attempt.target.getHealth();
+            if (Double.isFinite(attempt.healthBefore) && attempt.healthBefore > 0
+                    && Double.isFinite(afterHealth) && afterHealth >= 0) {
+                evidence.put("target_health_before", BigDecimal.valueOf(attempt.healthBefore).stripTrailingZeros().toPlainString());
+                evidence.put("target_health_after", BigDecimal.valueOf(afterHealth).stripTrailingZeros().toPlainString());
+            }
+        } catch (RuntimeException ignored) { /* Target health may be unavailable after a native hit. */ }
+        try { attempt.execution.acceptedDamage(attempt.target, attempt.requested, attempt.finalDamage,
+            attempt.execution.input().player(), evidence); }
+        catch (RuntimeException ignored) { /* File auditing cannot interrupt accepted native damage. */ }
+        try { attempt.execution.report(AbilityReport.Type.DAMAGE, attempt.target,
+            BigDecimal.valueOf(attempt.finalDamage).stripTrailingZeros()); }
+        catch (RuntimeException ignored) { /* Feedback cannot alter accepted damage or knockback. */ }
+        String knockbackStatus = knockback(attempt);
+        attempt.execution.resolve("hit", Map.of("reason", "native_damage_accepted",
+            "knockback_status", knockbackStatus));
+    }
+
+    private String knockback(Attempt attempt) {
+        if (!attempt.execution.stillCurrent()) return "session_changed_after_damage";
+        try {
+            var player = attempt.execution.input().player(); var target = attempt.target;
+            Vector away = target.getLocation().toVector().subtract(player.getLocation().toVector()); away.setY(0);
+            if (!finite(away) || away.lengthSquared() < 1.0e-12) return "direction_unavailable";
+            Vector current = target.getVelocity();
+            Vector proposed = current.clone().add(away.normalize().multiply(attempt.settings.horizontalKnockback()));
+            proposed.setY(Math.max(current.getY(), attempt.settings.minimumVerticalKnockback()));
+            if (!finite(proposed)) return "velocity_invalid";
+            if (target instanceof Player targetPlayer) {
+                var event = new PlayerVelocityEvent(targetPlayer, proposed.clone()); velocityEvents.accept(event);
+                if (event.isCancelled()) return "native_velocity_cancelled";
+                if (!finite(event.getVelocity())) return "velocity_invalid";
+                proposed = event.getVelocity().clone();
+            }
+            target.setVelocity(proposed);
+            try { attempt.execution.effectApplied("shield_bash_knockback", target,
+                Map.of("knockback_horizontal", decimal(attempt.settings.horizontalKnockback()),
+                    "accepted_velocity_x", decimal(proposed.getX()),
+                    "accepted_velocity_y", decimal(proposed.getY()),
+                    "accepted_velocity_z", decimal(proposed.getZ()),
+                    "status", "native_velocity_accepted")); }
+            catch (RuntimeException ignored) { /* Accepted movement does not depend on auditing. */ }
+            return "native_velocity_accepted";
+        } catch (RuntimeException invalid) { return "native_velocity_failed"; }
     }
 
     private static boolean inRange(Player player, LivingEntity target, double range) {

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

@@ -62,11 +62,24 @@ public final class StoneSkin implements AbilityEffect, AutoCloseable {
     @Override public void activate(AbilityExecution execution) {
         if (closed || !execution.stillCurrent()) return;
         var current = from(execution.definition()); var player = execution.input().player();
-        var grant = mitigation.grant(execution, player, current.reductionPercent());
+        var grant = mitigation.grantAccepted(execution, player, current.reductionPercent(), () -> true,
+            accepted -> {
+                try {
+                    execution.acceptedPrevention(execution.input().session(), player, accepted.event().getDamager(),
+                        accepted.incoming(), accepted.prevented(), accepted.remaining(), null);
+                } catch (RuntimeException ignored) { /* Auditing cannot change an accepted native hit. */ }
+            });
         var state = new State(execution, player, grant);
         var previous = protections.put(player.getUniqueId(), state);
-        if (previous != null) previous.execution.finish();
-        execution.own(state); execution.later(current.duration(), execution::finish);
+        if (previous != null) { previous.execution.resolve("replaced"); previous.execution.finish(); }
+        execution.own(state);
+        var evidence = new java.util.LinkedHashMap<String, Object>();
+        evidence.put("reduction_percent", current.reductionPercent().stripTrailingZeros().toPlainString());
+        evidence.put("duration_seconds", BigDecimal.valueOf(current.duration().toNanos()).movePointLeft(9).stripTrailingZeros().toPlainString());
+        var activatedAt = execution.now();
+        if (activatedAt != null) evidence.put("effect_until", activatedAt.plus(current.duration()).toString());
+        execution.effectApplied("stone_skin", player, evidence);
+        execution.later(current.duration(), () -> { execution.resolve("expired"); execution.finish(); });
     }
 
     private static Settings from(AbilityDefinition definition) {
@@ -78,7 +91,9 @@ public final class StoneSkin implements AbilityEffect, AutoCloseable {
 
     @Override public void close() {
         if (closed) return; closed = true;
-        for (var state : List.copyOf(protections.values())) state.execution.finish();
+        for (var state : List.copyOf(protections.values())) {
+            state.execution.resolve("interrupted"); state.execution.finish();
+        }
         protections.clear();
     }
 }

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

@@ -13,21 +13,83 @@ import org.bukkit.projectiles.ProjectileSource;
 /** Plugin-owned temporary-health ledger layered over unrelated native absorption. */
 public final class TemporaryHealth implements Listener,AutoCloseable{
  public record Support(UUID target,UUID supportingCharacter,EquipmentSessions.Active aided,BigDecimal amount){}
- private final class Grant implements AutoCloseable{final long sequence;final AbilityExecution execution;final Player target;double remaining;boolean closed;
-  Grant(AbilityExecution e,Player t,double amount){sequence=++sequences;execution=e;target=t;remaining=amount;}
-  @Override public void close(){if(closed)return;double before=owned(target.getUniqueId());closed=true;var list=grants.get(target.getUniqueId());if(list!=null){list.remove(this);if(list.isEmpty())grants.remove(target.getUniqueId());}double after=owned(target.getUniqueId());removeNative(target,Math.max(0,before-after));}}
+ public record Accepted(Player target,Entity attacker,double incoming,double before,double after,
+                        double consumed,double remaining,org.bukkit.Location targetAtHit,
+                        org.bukkit.Location attackerAtHit){}
+ private final class Grant implements AutoCloseable{final long sequence;final AbilityExecution execution;final Player target;
+  final Consumer<Accepted> observation;final Consumer<Double> onEnd;double remaining;boolean closed;
+  Grant(AbilityExecution e,Player t,double amount,Consumer<Accepted> observation,Consumer<Double> onEnd){
+   sequence=++sequences;execution=e;target=t;remaining=amount;this.observation=observation;this.onEnd=onEnd;}
+  @Override public void close(){if(closed)return;double before=owned(target.getUniqueId());closed=true;var list=grants.get(target.getUniqueId());if(list!=null){list.remove(this);if(list.isEmpty())grants.remove(target.getUniqueId());}double after=owned(target.getUniqueId());removeNative(target,Math.max(0,before-after));if(onEnd!=null)try{onEnd.accept(Math.max(0,remaining));}catch(RuntimeException ignored){/* Cleanup is independent of recording. */}}
+ }
  private final EquipmentSessions sessions;private final PartyRoster parties;private final Consumer<Runnable> nextTick;private final Consumer<Support> supports;
- private final Map<UUID,List<Grant>> grants=new HashMap<>();private long sequences;private boolean closed;
+ private final Map<UUID,List<Grant>> grants=new HashMap<>();
+ private final Set<EntityDamageEvent> pending=Collections.newSetFromMap(new IdentityHashMap<>());
+ 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();
-  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));}
+ public AutoCloseable grant(AbilityExecution execution,Player target,double amount){
+  return grantObserved(execution,target,amount,null);
+ }
+ public AutoCloseable grantObserved(AbilityExecution execution,Player target,double amount,Consumer<Accepted> observation){
+  return grantObserved(execution,target,amount,observation,null);
+ }
+ public AutoCloseable grantObserved(AbilityExecution execution,Player target,double amount,
+                                   Consumer<Accepted> observation,Consumer<Double> onEnd){
+  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,observation,onEnd);
+  addNative(target,Math.max(0,amount-before)); // Do not retain an owned grant if the native setter refuses it.
+  grants.computeIfAbsent(target.getUniqueId(),ignored->new ArrayList<>()).add(grant);
+  return grant;
+ }
+ public Optional<EquipmentSessions.Active> currentSession(Player target){
+  return sessions.active(target.getUniqueId()).filter(sessions::current);
+ }
+ @EventHandler(priority=EventPriority.MONITOR,ignoreCancelled=true)public void damage(EntityDamageEvent event){
+  if(closed||pending.contains(event)||!(event.getEntity() instanceof Player target)
+      ||!Double.isFinite(event.getDamage())||event.getDamage()<=0)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 targetAtHit=auditLocation(target);var attackerAtHit=auditLocation(attacker);
+  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();double incoming=event.getDamage();
+  pending.add(event);
+  try{nextTick.accept(()->{
+   try{consume(event,target,before,owned,owner,qualifies?aided:null,enemy,attacker,incoming,targetAtHit,attackerAtHit);}
+   finally{pending.remove(event);}
+  });}
+  catch(RuntimeException ignored){pending.remove(event);}
+ }
+ private void consume(EntityDamageEvent event,Player target,double before,double ownedBefore,Grant owner,
+                      EquipmentSessions.Active aided,UUID enemy,Entity attacker,double incoming,
+                      org.bukkit.Location targetAtHit,org.bukkit.Location attackerAtHit){
+  if(closed||event.isCancelled()||!Double.isFinite(event.getDamage())||event.getDamage()<=0)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||owner.closed||!list.contains(owner)||!owner.execution.stillCurrent())return;
+  var amount=BigDecimal.valueOf(consumed).stripTrailingZeros();
+  try{owner.execution.report(AbilityReport.Type.PREVENTION,target,amount);}
+  catch(RuntimeException ignored){/* Feedback must not affect accepted absorption. */}
+  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(owner.observation!=null)try{owner.observation.accept(new Accepted(target,attacker,incoming,before,after,
+   consumed,Math.max(0,owner.remaining),targetAtHit,attackerAtHit));}
+  catch(RuntimeException ignored){/* Audit must not affect native absorption or rewards. */}
+  if(aided!=null&&enemy!=null)supports.accept(new Support(enemy,owner.execution.input().session().character(),aided,amount));
+ }
+ private static org.bukkit.Location auditLocation(Entity entity){
+  if(entity==null)return null;
+  try{var location=entity.getLocation();return location==null?null:location.clone();}
+  catch(RuntimeException unavailable){return null;}
+ }
  private boolean sameParty(Player source,Player target){var a=parties.partyOf(source.getUniqueId()).orElse(null);var b=parties.partyOf(target.getUniqueId()).orElse(null);return a!=null&&b!=null&&a.id().equals(b.id());}
  private Grant strongest(UUID target){Grant result=null;var list=grants.get(target);if(list!=null)for(var grant:List.copyOf(list))if(!grant.closed&&grant.remaining>0&&grant.execution.stillCurrent()&&(result==null||grant.remaining>result.remaining||grant.remaining==result.remaining&&grant.sequence>result.sequence))result=grant;return result;}
  private double owned(UUID target){double result=0;var list=grants.get(target);if(list!=null)for(var grant:List.copyOf(list))if(!grant.closed&&grant.remaining>result)result=grant.remaining;return result;}
  private static Entity attacker(EntityDamageByEntityEvent event){Entity causing=event.getDamageSource().getCausingEntity();if(causing!=null)return causing;if(event.getDamager() instanceof Projectile p){ProjectileSource shooter=p.getShooter();if(shooter instanceof Entity e)return e;}return event.getDamager();}
  private static void addNative(Player target,double amount){if(amount<=0)return;double current=target.getAbsorptionAmount(),next=current+amount;if(!Double.isFinite(current)||current<0||!Double.isFinite(next))throw new IllegalStateException("Temporary health exceeds native range");target.setAbsorptionAmount(next);}
  private static void removeNative(Player target,double amount){if(amount<=0)return;double current=target.getAbsorptionAmount();if(Double.isFinite(current)&&current>=0)target.setAbsorptionAmount(Math.max(0,current-amount));}
- @Override public void close(){if(closed)return;for(var list:List.copyOf(grants.values()))for(var grant:List.copyOf(list))grant.close();closed=true;grants.clear();}
+ @Override public void close(){if(closed)return;for(var list:List.copyOf(grants.values()))for(var grant:List.copyOf(list))grant.close();closed=true;grants.clear();pending.clear();}
 }

src/main/java/games/dmg/fantasystick/events/AbilityCastEventBridge.java

@@ -19,12 +19,18 @@ import org.bukkit.entity.Entity;
 public final class AbilityCastEventBridge {
     public record Cast(UUID actionId, EventInput.Context context, String abilityId, UUID targetId,
                        String targetType, Map<String, Object> targetLocation, Instant requestedAt,
-                       float attackCharge, int heldTicks, UUID executionId) {
+                       float attackCharge, int heldTicks, int slot, UUID executionId) {
+        public Cast(UUID actionId, EventInput.Context context, String abilityId, UUID targetId,
+                    String targetType, Map<String, Object> targetLocation, Instant requestedAt,
+                    float attackCharge, int heldTicks, int slot) {
+            this(actionId, context, abilityId, targetId, targetType, targetLocation, requestedAt,
+                attackCharge, heldTicks, slot, UUID.randomUUID());
+        }
         public Cast(UUID actionId, EventInput.Context context, String abilityId, UUID targetId,
                     String targetType, Map<String, Object> targetLocation, Instant requestedAt,
                     float attackCharge, int heldTicks) {
             this(actionId, context, abilityId, targetId, targetType, targetLocation, requestedAt,
-                attackCharge, heldTicks, UUID.randomUUID());
+                attackCharge, heldTicks, -1);
         }
         public Cast(UUID actionId, EventInput.Context context, String abilityId, UUID targetId,
                     String targetType, Map<String, Object> targetLocation, Instant requestedAt, float attackCharge) {
@@ -55,7 +61,7 @@ public final class AbilityCastEventBridge {
                 definition.id(), target == null ? null : target.getUniqueId(),
                 target == null ? null : target instanceof org.bukkit.entity.Player ? "PLAYER" : target.getType().name(),
                 targetAtRequest == null ? Map.of() : locationData(targetAtRequest),
-                clock.instant(), input.attackStrength(), input.heldTicks());
+                clock.instant(), input.attackStrength(), input.heldTicks(), input.slot());
             emit(cast, "action.observed", "observed", Map.of("action_kind", "ability_cast"));
             return cast;
         } catch (RuntimeException ignored) {
@@ -64,6 +70,11 @@ public final class AbilityCastEventBridge {
     }
 
     public void cast(Cast cast, CharacterRecord saved, Instant deadline, AbilityDefinition definition) {
+        cast(cast, saved, deadline, definition, Map.of());
+    }
+
+    public void cast(Cast cast, CharacterRecord saved, Instant deadline, AbilityDefinition definition,
+                     Map<String, Object> nativeEvidence) {
         if (cast == null) return;
         try {
             var settings = new LinkedHashMap<String, Object>();
@@ -71,11 +82,18 @@ public final class AbilityCastEventBridge {
             var data = new LinkedHashMap<String, Object>();
             data.put("cooldown_until", deadline);
             data.put("after_revision", saved.revision().toString());
+            if (cast.slot() >= 0) data.put("slot", cast.slot());
             data.put("stage", "cooldown_committed");
             data.put("activation", definition.activation().name().toLowerCase(java.util.Locale.ROOT));
             data.put("captured_settings", settings);
             data.put("settings_scope", "definition_at_request");
             if (cast.abilityId().equals("great_sword")) data.put("captured_charge", Float.toString(cast.attackCharge()));
+            if (cast.abilityId().equals("quickstep")) {
+                data.put("intended_distance", definition.parameters().get("distance").toPlainString());
+                for (String key : java.util.List.of("from_location", "intended_direction", "accepted_velocity",
+                        "native_velocity_status"))
+                    if (nativeEvidence.containsKey(key)) data.put(key, nativeEvidence.get(key));
+            }
             if (cast.abilityId().equals("longbow")) {
                 data.put("draw_ticks", cast.heldTicks());
                 data.put("draw_power", games.dmg.fantasystick.ability.Longbow.power(cast.heldTicks(),
@@ -203,6 +221,10 @@ public final class AbilityCastEventBridge {
             data.put("target_location", locationData(ally.getLocation()));
             data.put("attacker_entity_id", attacker.getUniqueId().toString());
             data.put("attacker_entity_type", entityType(attacker));
+            if (cast.abilityId().equals("stone_skin")) {
+                var attackLocation = attacker.getLocation();
+                if (attackLocation != null) data.put("attacker_location", locationData(attackLocation));
+            }
             data.put("incoming_amount", decimal(incoming));
             data.put("actual_amount", decimal(actual));
             data.put("remaining_amount", decimal(remaining));
@@ -210,6 +232,63 @@ public final class AbilityCastEventBridge {
         } catch (RuntimeException ignored) { /* Prevention authority belongs to the native damage event. */ }
     }
 
+    /** Hex owns outgoing prevention even when the protected recipient is not a player. */
+    public void outgoingPrevented(Cast cast, UUID effectApplication, Entity debuffedAttacker,
+                                  Entity protectedTarget, double incoming, double remaining, double actual,
+                                  Map<String, Object> recipientEvidence) {
+        if (cast == null || !Double.isFinite(actual) || actual <= 0) return;
+        try {
+            var data = new LinkedHashMap<String, Object>(recipientEvidence);
+            UUID application = UUID.randomUUID();
+            data.put("application_id", application.toString());
+            data.put("effect_application_id", effectApplication.toString());
+            data.put("causation_id", cast.actionId().toString());
+            data.put("debuffed_attacker_id", debuffedAttacker.getUniqueId().toString());
+            data.put("debuffed_attacker_type", entityType(debuffedAttacker));
+            data.put("attacker_location", locationData(debuffedAttacker.getLocation()));
+            data.put("protected_target_id", protectedTarget.getUniqueId().toString());
+            data.put("protected_target_type", entityType(protectedTarget));
+            data.put("protected_location", locationData(protectedTarget.getLocation()));
+            data.put("incoming_amount", incoming);
+            data.put("remaining_amount", remaining);
+            data.put("actual_amount", actual);
+            emit(cast, "combat.prevented", "accepted", data, application);
+        } catch (RuntimeException ignored) { /* Logging cannot alter accepted native damage. */ }
+    }
+
+    /** Inspire reports actual accepted native absorption, not a displayed health grant. */
+    public void absorbed(Cast cast, UUID effectApplication, org.bukkit.entity.Player protectedTarget,
+                         games.dmg.fantasystick.session.EquipmentSessions.Active aided, Entity attacker,
+                         double incoming, double before, double after, double consumed, double remaining,
+                         Location targetAtHit, Location attackerAtHit) {
+        if (cast == null || effectApplication == null || !Double.isFinite(consumed) || consumed <= 0) return;
+        try {
+            var data = new LinkedHashMap<String, Object>();
+            UUID application = UUID.randomUUID();
+            data.put("application_id", application.toString());
+            data.put("effect_application_id", effectApplication.toString());
+            data.put("causation_id", cast.actionId().toString());
+            data.put("protected_target_id", protectedTarget.getUniqueId().toString());
+            data.put("protected_target_type", "PLAYER");
+            if (aided != null) {
+                data.put("protected_character_id", aided.character().toString());
+                data.put("protected_session_id", aided.session().toString());
+            }
+            if (targetAtHit != null) data.put("protected_location", locationData(targetAtHit));
+            if (attacker != null) {
+                data.put("attacker_entity_id", attacker.getUniqueId().toString());
+                data.put("attacker_entity_type", entityType(attacker));
+                if (attackerAtHit != null) data.put("attacker_location", locationData(attackerAtHit));
+            } else data.put("attacker_status", "not_applicable");
+            data.put("incoming_amount", decimal(incoming));
+            data.put("absorption_before", decimal(before));
+            data.put("absorption_after", decimal(after));
+            data.put("actual_amount", decimal(consumed));
+            data.put("remaining_amount", decimal(remaining));
+            emit(cast, "combat.prevented", "accepted", data, application);
+        } catch (RuntimeException ignored) { /* Native absorption and party rewards are independent of logging. */ }
+    }
+
     public void boosted(Cast cast, games.dmg.fantasystick.session.EquipmentSessions.Active attacking,
                         org.bukkit.entity.Player attacker, Entity target, double base, double bonus,
                         double finalDamage, java.math.BigDecimal percent) {

src/main/java/games/dmg/fantasystick/events/AdminRevivalEventBridge.java

@@ -0,0 +1,197 @@
+package games.dmg.fantasystick.events;
+
+import games.dmg.fantasystick.persistence.AdminReviveSettings;
+import games.dmg.fantasystick.persistence.CharacterRecord;
+import games.dmg.fantasystick.persistence.RevivalStore;
+import java.math.BigInteger;
+import java.nio.charset.StandardCharsets;
+import java.nio.file.Path;
+import java.time.Clock;
+import java.time.Duration;
+import java.util.LinkedHashMap;
+import java.util.Map;
+import java.util.Objects;
+import java.util.UUID;
+import java.util.concurrent.CompletionStage;
+import java.util.function.Consumer;
+import java.util.function.Function;
+import org.bukkit.Location;
+import org.bukkit.command.BlockCommandSender;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+
+/** Real administrator Tail restoration and acknowledged selection-timeout configuration. */
+public final class AdminRevivalEventBridge implements AutoCloseable {
+    public record Actor(String kind, EventInput.Context context, UUID id) { }
+    public record Selection(Actor actor, UUID targetId, String targetName,
+                            EventInput.Location targetLocation,
+                            games.dmg.fantasystick.session.EquipmentSessions.Active targetSession) { }
+
+    private final Function<EventInput, CompletionStage<LocalEventLog.Delivery>> sink;
+    private final FeatureEventOutbox outbox;
+    private final Clock clock;
+    private final games.dmg.fantasystick.session.EquipmentSessions sessions;
+
+    public AdminRevivalEventBridge(Function<EventInput, CompletionStage<LocalEventLog.Delivery>> sink,
+                                   Clock clock, Path data, games.dmg.fantasystick.session.EquipmentSessions sessions,
+                                   Consumer<Throwable> failures) {
+        this.sink = Objects.requireNonNull(sink);
+        this.clock = Objects.requireNonNull(clock);
+        this.sessions = Objects.requireNonNull(sessions);
+        outbox = new FeatureEventOutbox(data, "admin-revival-event-intents",
+            java.util.Set.of("character.revived", "config.changed"), sink, failures);
+    }
+
+    public Actor actor(CommandSender sender) {
+        try {
+            var player = sender instanceof Player value ? value : null;
+            var kind = player != null ? "player" : sender instanceof BlockCommandSender ? "command_block" : "console";
+            var active = player == null ? null : sessions.active(player.getUniqueId()).orElse(null);
+            var record = active == null ? null : sessions.currentRecord(active).orElse(null);
+            return new Actor(kind, player == null ? null : new EventInput.Context(player.getUniqueId(),
+                player.getName(), record == null ? null : record.id(),
+                record == null ? null : record.name(), record == null ? null : active.session(), safeLocation(player)),
+                player == null ? null : player.getUniqueId());
+        } catch (RuntimeException unavailable) { return null; }
+    }
+
+    public Selection selection(Player admin, Player target) {
+        try { return new Selection(actor(admin), target.getUniqueId(), target.getName(),
+            safeLocation(target), sessions.active(target.getUniqueId()).orElse(null)); }
+        catch (RuntimeException unavailable) { return null; }
+    }
+
+    public void revived(Selection selection, RevivalStore.Reservation reservation,
+                        CharacterRecord dead, CharacterRecord restored, Player target) {
+        if (selection == null || selection.actor() == null) return;
+        try {
+            var data = revivalData(reservation, restored, target);
+            data.put("revision_before", dead.revision().toString());
+            data.put("death_time", dead.diedAt().toString());
+            data.put("death_age_seconds", Long.toString(Math.max(0, Duration.between(dead.diedAt(), clock.instant()).getSeconds())));
+            data.put("recovery_reconciliation", false);
+            location(data, "target_location", selection.targetLocation());
+            targetSession(data, selection.targetSession());
+            var actor = selection.actor();
+            data.put("admin_player_id", selection.actor().id().toString());
+            data.put("admin_player_name", actor.context().playerName());
+            if (actor.context().location() == null) data.put("actor_location_status", "unavailable");
+            durable("character.revived", reservation.id(), actor.context(), data);
+        } catch (RuntimeException ignored) { /* Audit failure cannot consume or restore a Tail. */ }
+    }
+
+    /** Reconciliation has the reservation's exact admin UUID, but never invents its old location or name. */
+    public void recovered(RevivalStore.Reservation reservation, CharacterRecord restored, Player target) {
+        if (!reservation.administrative()) return;
+        try {
+            var data = revivalData(reservation, restored, target);
+            data.put("actor_kind", "system");
+            data.put("admin_player_id", reservation.casterCharacter().toString());
+            data.put("admin_name_status", "unavailable");
+            data.put("actor_location_status", "unavailable");
+            data.put("revision_before", restored.revision().subtract(BigInteger.ONE).toString());
+            data.put("death_time", restored.diedAt().toString());
+            data.put("death_age_seconds", Long.toString(Math.max(0,
+                Duration.between(restored.diedAt(), reservation.createdAt()).getSeconds())));
+            data.put("recovery_reconciliation", true);
+            location(data, "target_location", safeLocation(target));
+            targetSession(data, sessions.active(target.getUniqueId()).orElse(null));
+            durable("character.revived", reservation.id(), null, data);
+        } catch (RuntimeException ignored) { }
+    }
+
+    private Map<String, Object> revivalData(RevivalStore.Reservation reservation, CharacterRecord restored, Player target) {
+        var data = new LinkedHashMap<String, Object>();
+        data.put("revival_kind", "admin_tail");
+        data.put("revival_operation_id", reservation.id().toString());
+        data.put("target_player_id", reservation.targetPlayer().toString());
+        data.put("target_player_name", target.getName());
+        data.put("character_id", restored.id().toString());
+        data.put("character_name", restored.name());
+        data.put("death_id", reservation.death().toString());
+        data.put("revision_after", restored.revision().toString());
+        data.put("tail_slot", reservation.sourceSlot());
+        data.put("tail_custody_id", reservation.death().toString());
+        data.put("sheet_slot", reservation.sourceAmount() == 1 ? reservation.sourceSlot() : reservation.destinationSlot());
+        data.put("source_quantity_before", Integer.toString(reservation.sourceAmount()));
+        data.put("source_quantity_after", Integer.toString(reservation.sourceAmount() - 1));
+        data.put("restored_health", restored.health().toPlainString());
+        data.put("maximum_health", restored.maximumHealth().toPlainString());
+        data.put("cooldowns_retained", true);
+        data.put("native_delivery", "acknowledged");
+        data.put("outcome", "acknowledged");
+        return data;
+    }
+
+    public void read(Actor actor, String effective) {
+        if (actor == null) return;
+        var data = config(actor);
+        data.put("effective", effective);
+        data.put("outcome", "acknowledged_read");
+        emit(UUID.randomUUID(), "config.read", actor.context(), data);
+    }
+
+    public void changed(Actor actor, String before, AdminReviveSettings.Update saved) {
+        if (actor == null) return;
+        var data = config(actor);
+        data.put("before", before);
+        data.put("after", saved.value());
+        data.put("effective", saved.value());
+        data.put("outcome", "acknowledged");
+        durable("config.changed", UUID.randomUUID(), actor.context(), data);
+    }
+
+    private static Map<String, Object> config(Actor actor) {
+        var data = new LinkedHashMap<String, Object>();
+        data.put("actor_kind", actor.kind());
+        data.put("key", AdminReviveSettings.KEY);
+        data.put("applies_to", "later_selections");
+        if (actor.context() == null) data.put("location_status", "not_applicable");
+        else if (actor.context().location() == null) data.put("location_status", "unavailable");
+        return data;
+    }
+
+    private static void targetSession(Map<String, Object> data,
+                                      games.dmg.fantasystick.session.EquipmentSessions.Active active) {
+        if (active == null) { data.put("target_session_status", "no_active_session"); return; }
+        data.put("target_session_id", active.session().toString());
+        data.put("target_active_character_id", active.character().toString());
+        data.put("target_session_status", "captured");
+    }
+
+    private void location(Map<String, Object> data, String key, EventInput.Location value) {
+        if (value == null) { data.put(key + "_status", "unavailable"); return; }
+        data.put(key, Map.of("world_id", value.worldId().toString(), "world_name", value.worldName(),
+            "x", value.x(), "y", value.y(), "z", value.z(),
+            "captured_at", value.capturedAt().toString(), "quality", value.quality()));
+    }
+
+    private EventInput.Location safeLocation(Player player) {
+        try { return location(player.getLocation()); }
+        catch (RuntimeException unavailable) { return null; }
+    }
+
+    private EventInput.Location location(Location value) {
+        try {
+            if (value == null || value.getWorld() == null) return null;
+            return new EventInput.Location(value.getWorld().getUID(), value.getWorld().getName(),
+                value.getX(), value.getY(), value.getZ(), clock.instant(), "exact");
+        } catch (RuntimeException unavailable) { return null; }
+    }
+
+    private void durable(String type, UUID action, EventInput.Context context, Map<String, Object> data) {
+        try { outbox.accepted(new EventInput(id(action, type), action, clock.instant(), type, context, data)); }
+        catch (RuntimeException ignored) { }
+    }
+    private void emit(UUID action, String type, EventInput.Context context, Map<String, Object> data) {
+        try { sink.apply(new EventInput(id(action, type), action, clock.instant(), type, context, data)); }
+        catch (RuntimeException ignored) { }
+    }
+    private static UUID id(UUID action, String kind) {
+        return UUID.nameUUIDFromBytes(("fantasystick:admin-revival:" + action + ":" + kind)
+            .getBytes(StandardCharsets.UTF_8));
+    }
+    public void replay() { outbox.replay(); }
+    public CompletionStage<Void> drained() { return outbox.drained(); }
+    @Override public void close() { outbox.close(); }
+}

src/main/java/games/dmg/fantasystick/events/CharacterIdentityEventBridge.java

@@ -14,6 +14,8 @@ import java.util.concurrent.CompletionStage;
 import java.util.function.Consumer;
 import java.util.function.Function;
 import org.bukkit.Location;
+import org.bukkit.command.BlockCommandSender;
+import org.bukkit.command.CommandSender;
 import org.bukkit.entity.Player;
 
 /** Captures actual identity-creating and identity-changing native actions, never previews. */
@@ -37,7 +39,7 @@ public final class CharacterIdentityEventBridge implements AutoCloseable {
         this.clock = Objects.requireNonNull(clock);
         this.activeSession = Objects.requireNonNull(activeSession);
         this.outbox = new FeatureEventOutbox(Objects.requireNonNull(dataFolder),
-            "character-identity-event-intents", java.util.Set.of("character.created", "character.renamed"),
+            "character-identity-event-intents", java.util.Set.of("character.created", "character.renamed", "character.issued"),
             sink, Objects.requireNonNull(failures));
     }
 
@@ -74,6 +76,57 @@ public final class CharacterIdentityEventBridge implements AutoCloseable {
         } catch (RuntimeException ignored) { /* Observation never authorizes a character session. */ }
     }
 
+    public record Issue(UUID operation, String actorKind, EventInput.Context actor,
+                        UUID targetPlayer, String targetName) { }
+
+    /** Capture the administrator before asynchronous saving; no second admin.action is produced. */
+    public Issue issue(CommandSender sender, Player target) {
+        try {
+            var player = sender instanceof Player actor ? actor : null;
+            var kind = player != null ? "player" : sender instanceof BlockCommandSender ? "command_block" : "console";
+            EventInput.Context context = player == null ? null : new EventInput.Context(player.getUniqueId(),
+                player.getName(), null, null, null, safeLocation(player));
+            return new Issue(UUID.randomUUID(), kind, context, target.getUniqueId(), target.getName());
+        } catch (RuntimeException ignored) { return null; }
+    }
+
+    /** The saved character and exact native inventory slot were acknowledged before this call. */
+    public void issued(Issue issue, Player target, CharacterRecord record, int slot) {
+        if (issue == null) return;
+        try {
+            var data = new LinkedHashMap<String, Object>();
+            data.put("actor_kind", issue.actorKind());
+            data.put("issue_operation_id", issue.operation().toString());
+            data.put("target_player_id", issue.targetPlayer().toString());
+            data.put("target_player_name", issue.targetName());
+            data.put("character_id", record.id().toString());
+            data.put("character_name", record.name());
+            data.put("revision", record.revision().toString());
+            data.put("generation", record.sheetGeneration().toString());
+            data.put("starting_level", Integer.toString(record.level()));
+            data.put("starting_unspent_points", record.unspentPoints().toString());
+            data.put("starting_health", record.health().toPlainString());
+            data.put("starting_coins", record.coins().toString());
+            var stats = new LinkedHashMap<String, Object>();
+            record.stats().forEach((stat, value) -> stats.put(stat.name().toLowerCase(java.util.Locale.ROOT), value.toString()));
+            data.put("starting_stats", stats);
+            data.put("delivered_slot", slot);
+            data.put("delivery_outcome", "native_inventory_acknowledged");
+            data.put("outcome", "acknowledged_delivered");
+            if (issue.actor() == null) data.put("actor_location_status", "not_applicable");
+            else if (issue.actor().location() == null) data.put("actor_location_status", "unavailable");
+            var targetLocation = safeLocation(target);
+            if (targetLocation != null) data.put("target_location", locationMap(targetLocation, "exact"));
+            else data.put("target_location_status", "unavailable");
+            durable("character.issued", issue.operation(), clock.instant(), issue.actor(), data, "issued");
+        } catch (RuntimeException ignored) { /* Audit cannot change acknowledged native issuance. */ }
+    }
+
+    private EventInput.Location safeLocation(Player player) {
+        try { return location(player.getLocation()); }
+        catch (RuntimeException unavailable) { return null; }
+    }
+
     public record Craft(UUID action, Instant time, EventInput.Context actor, String route, int quantity,
                         UUID holderSession) { }
 

src/main/java/games/dmg/fantasystick/events/FeatureEventOutbox.java

@@ -100,15 +100,14 @@ final class FeatureEventOutbox implements AutoCloseable {
             fields.setProperty("quality", location.quality());
         }
         event.data().forEach((key, value) -> {
-            if (value instanceof String text) fields.setProperty("data." + key, "s" + text);
-            else if (value instanceof Boolean bool) fields.setProperty("data." + key, "b" + bool);
-            else if (value instanceof Integer number) fields.setProperty("data." + key, "i" + number);
-            else if (value instanceof Double number && Double.isFinite(number))
-                fields.setProperty("data." + key, "d" + number);
-            else if (value instanceof java.util.List<?> list && list.stream().allMatch(item -> item instanceof String text
-                    && (text.equals("hotbar") || text.equals("armor"))))
-                fields.setProperty("data." + key, "l" + String.join(",", list.stream().map(String.class::cast).toList()));
-            else throw new IllegalArgumentException("Unsupported feature intent value");
+            if (value instanceof java.util.Map<?, ?> nested) {
+                if (key.contains(".")) throw new IllegalArgumentException("Unsafe nested feature intent key");
+                nested.forEach((name, part) -> {
+                    if (!(name instanceof String child) || child.contains("."))
+                        throw new IllegalArgumentException("Unsafe nested feature intent key");
+                    encode(fields, "data." + key + "." + child, part);
+                });
+            } else encode(fields, "data." + key, value);
         });
         var output = new ByteArrayOutputStream();
         fields.store(output, "acknowledged character identity event");
@@ -127,6 +126,17 @@ final class FeatureEventOutbox implements AutoCloseable {
         return event;
     }
 
+    private static void encode(Properties fields, String key, Object value) {
+        if (value instanceof String text) fields.setProperty(key, "s" + text);
+        else if (value instanceof Boolean bool) fields.setProperty(key, "b" + bool);
+        else if (value instanceof Integer number) fields.setProperty(key, "i" + number);
+        else if (value instanceof Double number && Double.isFinite(number)) fields.setProperty(key, "d" + number);
+        else if (value instanceof java.util.List<?> list && list.stream().allMatch(item -> item instanceof String text
+                && (text.equals("hotbar") || text.equals("armor"))))
+            fields.setProperty(key, "l" + String.join(",", list.stream().map(String.class::cast).toList()));
+        else throw new IllegalArgumentException("Unsupported feature intent value");
+    }
+
     private EventInput read(Path path) throws IOException {
         if (!Files.isRegularFile(path, LinkOption.NOFOLLOW_LINKS)) throw new IOException("Unsafe character event intent");
         var fields = new Properties();
@@ -155,10 +165,11 @@ final class FeatureEventOutbox implements AutoCloseable {
                     fields.containsKey("session") ? UUID.fromString(fields.getProperty("session")) : null, location)
                 : null;
             var data = new LinkedHashMap<String, Object>();
+            var nested = new LinkedHashMap<String, java.util.Map<String, Object>>();
             for (var key : fields.stringPropertyNames()) if (key.startsWith("data.")) {
                 var value = fields.getProperty(key);
                 if (value.isEmpty()) throw new IOException("Invalid character event value");
-                data.put(key.substring(5), switch (value.charAt(0)) {
+                var decoded = switch (value.charAt(0)) {
                     case 's' -> value.substring(1);
                     case 'b' -> {
                         if (!value.equals("btrue") && !value.equals("bfalse")) throw new IOException("Invalid boolean");
@@ -178,8 +189,20 @@ final class FeatureEventOutbox implements AutoCloseable {
                         yield list;
                     }
                     default -> throw new IOException("Invalid feature event value type");
-                });
+                };
+                var name = key.substring(5);
+                var separator = name.indexOf('.');
+                if (separator < 0) data.put(name, decoded);
+                else {
+                    if (separator == 0 || separator == name.length() - 1 || name.indexOf('.', separator + 1) >= 0)
+                        throw new IOException("Invalid nested feature intent key");
+                    nested.computeIfAbsent(name.substring(0, separator), ignored -> new LinkedHashMap<>())
+                        .put(name.substring(separator + 1), decoded);
+                }
             }
+            nested.forEach((key, value) -> {
+                if (data.putIfAbsent(key, value) != null) throw new IllegalArgumentException("Conflicting feature intent key");
+            });
             return new EventInput(id, action, Instant.parse(fields.getProperty("time")), type, context, data);
         } catch (RuntimeException failure) { throw new IOException("Invalid character event intent", failure); }
     }

src/main/java/games/dmg/fantasystick/events/RecoveryEventBridge.java

@@ -27,9 +27,9 @@ public final class RecoveryEventBridge {
     public void refused(Action action,String reason){emit("action.resolved",action,"refused",reason,null,null,null,null);}
     public void failed(Action action,String reason){emit("action.resolved",action,"failed",reason,null,null,null,null);}
     public void healed(Action action,BigDecimal healthAfter,BigDecimal acceptedTotal,BigDecimal baseContribution,BigDecimal passiveContribution){emit("action.resolved",action,"accepted","acknowledged",healthAfter,acceptedTotal,baseContribution,passiveContribution);emit("combat.healed",action,"accepted","acknowledged",healthAfter,acceptedTotal,baseContribution,passiveContribution);}
-    private void emit(String type,Action action,String outcome,String reason,BigDecimal healthAfter,BigDecimal acceptedTotal,BigDecimal baseContribution,BigDecimal passiveContribution){var data=new LinkedHashMap<String,Object>();data.put("action_kind","out_of_combat_recovery");data.put("recovery_kind","out_of_combat");data.put("cause","recovery_timer");data.put("expected_revision",action.expectedRevision().toString());data.put("health_before",action.healthBefore().toPlainString());data.put("proposed_total",action.proposed().toPlainString());data.put("configured_base",action.configuredBase().toString());data.put("configured_quicker_regeneration_i",action.configuredQuickerRegeneration().toString());data.put("outcome",outcome);if(healthAfter!=null)data.put("health_after",healthAfter.toPlainString());if(acceptedTotal!=null){data.put("accepted_total",acceptedTotal.toPlainString());data.put("base_contribution",baseContribution.toPlainString());if(passiveContribution.signum()>0)data.put("passive_contributions",Map.of("quicker_regeneration_i",passiveContribution.toPlainString()));data.put("native_publication","acknowledged");}if(reason!=null)data.put(type.equals("combat.healed")?"native_boundary":"reason",reason);try{sink.accept(new EventInput(id(action.actionId(),type),action.actionId(),clock.instant(),type,action.context(),Map.copyOf(data)));}catch(RuntimeException ignored){}
+    private void emit(String type,Action action,String outcome,String reason,BigDecimal healthAfter,BigDecimal acceptedTotal,BigDecimal baseContribution,BigDecimal passiveContribution){var data=new LinkedHashMap<String,Object>();data.put("action_kind","out_of_combat_recovery");data.put("recovery_kind","out_of_combat");data.put("cause","recovery_timer");data.put("expected_revision",action.expectedRevision().toString());data.put("health_before",action.healthBefore().toPlainString());data.put("proposed_total",action.proposed().toPlainString());data.put("configured_base",action.configuredBase().toString());data.put("configured_quicker_regeneration_i",action.configuredQuickerRegeneration().toString());data.put("outcome",outcome);if(action.context().location()==null)data.put("location_status","unavailable");if(healthAfter!=null)data.put("health_after",healthAfter.toPlainString());if(acceptedTotal!=null){data.put("accepted_total",acceptedTotal.toPlainString());data.put("base_contribution",baseContribution.toPlainString());if(passiveContribution.signum()>0)data.put("passive_contributions",Map.of("quicker_regeneration_i",passiveContribution.toPlainString()));data.put("native_publication","acknowledged");}if(reason!=null)data.put(type.equals("combat.healed")?"native_boundary":"reason",reason);try{sink.accept(new EventInput(id(action.actionId(),type),action.actionId(),clock.instant(),type,action.context(),Map.copyOf(data)));}catch(RuntimeException ignored){}
     }
-    private EventInput.Context context(Player player,EquipmentSessions.Active active,String name){return new EventInput.Context(player.getUniqueId(),player.getName(),active.character(),name,active.session(),location(player.getLocation()));}
+    private EventInput.Context context(Player player,EquipmentSessions.Active active,String name){EventInput.Location captured;try{captured=location(player.getLocation());}catch(RuntimeException unavailable){captured=null;}return new EventInput.Context(player.getUniqueId(),player.getName(),active.character(),name,active.session(),captured);}
     private EventInput.Location location(Location value){return new EventInput.Location(value.getWorld().getUID(),value.getWorld().getName(),value.getX(),value.getY(),value.getZ(),clock.instant(),"exact");}
     private static UUID id(UUID action,String type){return UUID.nameUUIDFromBytes(("fantasystick:recovery:"+action+":"+type).getBytes(StandardCharsets.UTF_8));}
 }

src/main/java/games/dmg/fantasystick/events/SwitchConfigEventBridge.java

@@ -0,0 +1,110 @@
+package games.dmg.fantasystick.events;
+
+import games.dmg.fantasystick.persistence.SwitchDelaySettings;
+import games.dmg.fantasystick.session.EquipmentSessions;
+import java.nio.charset.StandardCharsets;
+import java.nio.file.Path;
+import java.time.Clock;
+import java.util.LinkedHashMap;
+import java.util.Map;
+import java.util.Objects;
+import java.util.UUID;
+import java.util.concurrent.CompletionStage;
+import java.util.function.Consumer;
+import java.util.function.Function;
+import org.bukkit.Location;
+import org.bukkit.command.BlockCommandSender;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+
+/** Observes the registered administrator's acknowledged switch policy; never changes deadlines. */
+public final class SwitchConfigEventBridge implements AutoCloseable {
+    public record Actor(String kind, EventInput.Context context) { }
+
+    private final Function<EventInput, CompletionStage<LocalEventLog.Delivery>> sink;
+    private final Clock clock;
+    private final EquipmentSessions sessions;
+    private final FeatureEventOutbox outbox;
+
+    public SwitchConfigEventBridge(Function<EventInput, CompletionStage<LocalEventLog.Delivery>> sink,
+                                   Clock clock, Path data, EquipmentSessions sessions,
+                                   Consumer<Throwable> failures) {
+        this.sink = Objects.requireNonNull(sink);
+        this.clock = Objects.requireNonNull(clock);
+        this.sessions = Objects.requireNonNull(sessions);
+        outbox = new FeatureEventOutbox(data, "switch-config-event-intents", java.util.Set.of("config.changed"),
+            sink, failures);
+    }
+
+    public Actor actor(CommandSender sender) {
+        try {
+            var player = sender instanceof Player value ? value : null;
+            var kind = player != null ? "player" : sender instanceof BlockCommandSender ? "command_block" : "console";
+            var active = player == null ? null : sessions.active(player.getUniqueId()).orElse(null);
+            var record = active == null ? null : sessions.currentRecord(active).orElse(null);
+            return new Actor(kind, player == null ? null : new EventInput.Context(player.getUniqueId(),
+                player.getName(), record == null ? null : record.id(),
+                record == null ? null : record.name(), record == null ? null : active.session(),
+                safeLocation(player)));
+        } catch (RuntimeException unavailable) { return null; }
+    }
+
+    public void read(Actor actor, String effective) {
+        if (actor == null) return;
+        var data = common(actor);
+        data.put("effective", effective);
+        data.put("outcome", "acknowledged_read");
+        var action = UUID.randomUUID();
+        try { sink.apply(new EventInput(id(action, "config.read"), action, clock.instant(),
+            "config.read", actor.context(), data)); }
+        catch (RuntimeException ignored) { /* Observation cannot change the policy. */ }
+    }
+
+    public void changed(Actor actor, UUID operation, String before, String effective,
+                        SwitchDelaySettings.Update saved) {
+        if (actor == null) return;
+        try {
+            var data = common(actor);
+            data.put("operation_id", operation.toString());
+            data.put("store_sequence", Long.toString(saved.sequence()));
+            data.put("before", before);
+            data.put("after", saved.value());
+            data.put("effective", effective);
+            data.put("zero_disabled", saved.delay().isZero());
+            data.put("outcome", "acknowledged");
+            outbox.accepted(new EventInput(id(operation, "config.changed"), operation, clock.instant(),
+                "config.changed", actor.context(), data));
+        } catch (RuntimeException ignored) { /* A failed audit cannot roll back an effective setting. */ }
+    }
+
+    private static Map<String, Object> common(Actor actor) {
+        var data = new LinkedHashMap<String, Object>();
+        data.put("key", SwitchDelaySettings.KEY);
+        data.put("default", SwitchDelaySettings.DEFAULT);
+        data.put("application_scope", "future_exit");
+        data.put("existing_deadlines_unchanged", true);
+        data.put("actor_kind", actor.kind());
+        if (actor.context() == null) data.put("location_status", "not_applicable");
+        else if (actor.context().location() == null) data.put("location_status", "unavailable");
+        return data;
+    }
+
+    private EventInput.Location safeLocation(Player player) {
+        try {
+            Location location = player.getLocation();
+            if (location == null || location.getWorld() == null) return null;
+            var world = location.getWorld();
+            return new EventInput.Location(world.getUID(), world.getName(), location.getX(),
+                location.getY(), location.getZ(), clock.instant(), "exact");
+        } catch (RuntimeException unavailable) { return null; }
+    }
+
+    private static UUID id(UUID action, String kind) {
+        return UUID.nameUUIDFromBytes(("fantasystick:switch-config:" + action + ":" + kind)
+            .getBytes(StandardCharsets.UTF_8));
+    }
+
+    public void replay() { outbox.replay(); }
+    public CompletionStage<Void> drained() { return outbox.drained(); }
+    @Override public void close() { outbox.close(); }
+}

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

@@ -72,11 +72,12 @@ public final class HexSettings implements AutoCloseable {
     public Hex.Settings settings() { return parse(effectiveValues); }
 
     /** Publish only after the caller returns the durable acknowledgment to the server thread. */
-    public synchronized void publish(Update update) {
+    public synchronized boolean publish(Update update) {
         Objects.requireNonNull(update);
-        if (update.sequence() <= publishedSequence) return;
+        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) {

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

@@ -72,11 +72,12 @@ public final class InspireSettings implements AutoCloseable {
     public Inspire.Settings settings() { return parse(effectiveValues); }
 
     /** Publish only after the caller returns the durable acknowledgment to the server thread. */
-    public synchronized void publish(Update update) {
+    public synchronized boolean publish(Update update) {
         Objects.requireNonNull(update);
-        if (update.sequence() <= publishedSequence) return;
+        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) {

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

@@ -71,11 +71,12 @@ public final class QuickstepSettings implements AutoCloseable {
     public Quickstep.Settings settings() { return parse(effectiveValues); }
 
     /** Publish only after the caller returns the durable acknowledgment to the server thread. */
-    public synchronized void publish(Update update) {
+    public synchronized boolean publish(Update update) {
         Objects.requireNonNull(update);
-        if (update.sequence() <= publishedSequence) return;
+        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) {

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

@@ -70,11 +70,12 @@ public final class SecondWindSettings implements AutoCloseable {
     public SecondWind.Settings settings() { return parse(effectiveValues); }
 
     /** Publish only after the caller returns the durable acknowledgment to the server thread. */
-    public synchronized void publish(Update update) {
+    public synchronized boolean publish(Update update) {
         Objects.requireNonNull(update);
-        if (update.sequence() <= publishedSequence) return;
+        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) {

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

@@ -74,11 +74,12 @@ public final class ShieldBashSettings implements AutoCloseable {
     public ShieldBash.Settings settings() { return parse(effectiveValues); }
 
     /** Publish only after the caller returns the durable acknowledgment to the server thread. */
-    public synchronized void publish(Update update) {
+    public synchronized boolean publish(Update update) {
         Objects.requireNonNull(update);
-        if (update.sequence() <= publishedSequence) return;
+        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) {

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

@@ -71,11 +71,12 @@ public final class StoneSkinSettings implements AutoCloseable {
     public StoneSkin.Settings settings() { return parse(effectiveValues); }
 
     /** Publish only after the caller returns the durable acknowledgment to the server thread. */
-    public synchronized void publish(Update update) {
+    public synchronized boolean publish(Update update) {
         Objects.requireNonNull(update);
-        if (update.sequence() <= publishedSequence) return;
+        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) {

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

@@ -9,6 +9,7 @@ import java.util.UUID;
 import java.util.concurrent.ConcurrentHashMap;
 import java.util.function.Consumer;
 import java.util.function.Supplier;
+import org.bukkit.command.CommandSender;
 import org.bukkit.entity.Player;
 
 /** Persists one fresh character before handing its authentic sheet to a still-valid native inventory slot. */
@@ -22,6 +23,11 @@ public final class AdminCharacterIssuer implements AutoCloseable {
     private final Consumer<Failure> failures;
     private final ConcurrentHashMap<UUID, Attempt> pending = new ConcurrentHashMap<>();
     private volatile boolean closed;
+    private games.dmg.fantasystick.events.CharacterIdentityEventBridge identityEvents;
+
+    public void attachIdentityEvents(games.dmg.fantasystick.events.CharacterIdentityEventBridge events) {
+        identityEvents = Objects.requireNonNull(events);
+    }
 
     public AdminCharacterIssuer(CharacterStorage storage, Supplier<CharacterRecord> allocate,
                                 Consumer<Runnable> nextTick, Consumer<Failure> failures) {
@@ -32,12 +38,13 @@ public final class AdminCharacterIssuer implements AutoCloseable {
     }
 
     /** Must be entered on the server thread. Completion is delivered on that thread. */
-    public void issue(Player player, Consumer<Outcome> response) {
-        Objects.requireNonNull(player); Objects.requireNonNull(response);
+    public void issue(CommandSender sender, Player player, Consumer<Outcome> response) {
+        Objects.requireNonNull(sender); Objects.requireNonNull(player); Objects.requireNonNull(response);
         if (closed || !player.isOnline()) { response.accept(Outcome.STALE); return; }
         int slot = player.getInventory().firstEmpty();
         if (slot < 0) { response.accept(Outcome.FULL); return; }
-        var attempt = new Attempt(player, slot, response);
+        var audit = identityEvents;
+        var attempt = new Attempt(player, slot, response, audit == null ? null : audit.issue(sender, player));
         if (pending.putIfAbsent(attempt.playerId, attempt) != null) { response.accept(Outcome.BUSY); return; }
         try {
             attempt.record = allocate.get();
@@ -74,9 +81,15 @@ public final class AdminCharacterIssuer implements AutoCloseable {
                 || !claimed.orElseThrow().getFirst().id().equals(attempt.record.id())) {
             abandon(attempt); respond(attempt, Outcome.RETAINED); return;
         }
+        var savedRecord = claimed.orElseThrow().getFirst();
         try {
-            var sheet = new CharacterSheets().create(attempt.record);
+            var sheets = new CharacterSheets();
+            var sheet = sheets.create(savedRecord);
             attempt.player.getInventory().setItem(attempt.slot, sheet);
+            if (!sheets.identify(attempt.player.getInventory().getItem(attempt.slot))
+                    .filter(savedRecord.id()::equals).isPresent()) {
+                respond(attempt, Outcome.RETAINED); return;
+            }
             attempt.delivered = true;
         } catch (RuntimeException uncertain) {
             report(attempt, "delivery", uncertain);
@@ -85,6 +98,8 @@ public final class AdminCharacterIssuer implements AutoCloseable {
         }
         try { attempt.player.updateInventory(); }
         catch (RuntimeException syncFailure) { report(attempt, "sync", syncFailure); }
+        var events = identityEvents;
+        if (events != null) events.issued(attempt.issue, attempt.player, savedRecord, attempt.slot);
         respond(attempt, Outcome.DELIVERED);
     }
 
@@ -114,8 +129,12 @@ public final class AdminCharacterIssuer implements AutoCloseable {
 
     private static final class Attempt {
         final Player player; final UUID playerId; final int slot; final Consumer<Outcome> response;
+        final games.dmg.fantasystick.events.CharacterIdentityEventBridge.Issue issue;
         final java.util.concurrent.atomic.AtomicBoolean abandoned = new java.util.concurrent.atomic.AtomicBoolean();
         CharacterRecord record; CharacterStorage.CraftPreparation preparation; volatile boolean delivered;
-        Attempt(Player player, int slot, Consumer<Outcome> response) { this.player=player; this.playerId=player.getUniqueId(); this.slot=slot; this.response=response; }
+        Attempt(Player player, int slot, Consumer<Outcome> response,
+                games.dmg.fantasystick.events.CharacterIdentityEventBridge.Issue issue) {
+            this.player=player; this.playerId=player.getUniqueId(); this.slot=slot; this.response=response; this.issue=issue;
+        }
     }
 }

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

@@ -36,6 +36,12 @@ public final class AdminRevival implements Listener, AutoCloseable {
     private final Consumer<Runnable> nextTick; private final Scheduler scheduler; private final PopupFactory popups;
     private final Consumer<Throwable> failures; private final TailBooks tails=new TailBooks();private final CharacterSheets sheets=new CharacterSheets();
     private final Map<Inventory,View> views=new IdentityHashMap<>();private boolean closed;
+    private games.dmg.fantasystick.events.AdminRevivalEventBridge auditEvents;
+
+    public void attachEvents(games.dmg.fantasystick.events.AdminRevivalEventBridge events) {
+        if (closed || auditEvents != null) throw new IllegalStateException("Admin revival events already attached");
+        auditEvents = Objects.requireNonNull(events);
+    }
 
     private final class View implements AutoCloseable {
         final Player admin,target;final Inventory inventory;final Map<Integer,Choice> choices;final Instant deadline;final AutoCloseable expiry;boolean selecting,finished;
@@ -58,9 +64,9 @@ public final class AdminRevival implements Listener, AutoCloseable {
     @EventHandler(priority=EventPriority.MONITOR) public void quit(org.bukkit.event.player.PlayerQuitEvent event){for(var view:List.copyOf(views.values()))if(view.admin==event.getPlayer()||view.target==event.getPlayer())view.close();}
 
     private void confirm(View view,Choice choice){if(!view.current()||!unchanged(view.target,choice.candidate)){view.close();return;}characters.find(choice.record.id()).whenComplete((found,failure)->schedule(()->{if(failure!=null){report(failure);view.admin.sendMessage("Admin revival could not recheck that Tail; no item changed.");view.close();return;}if(!view.current()||found.isEmpty()||!eligible(found.orElseThrow(),choice.candidate.identity)||!unchanged(view.target,choice.candidate)){view.admin.sendMessage("That Tail selection is stale; no item changed.");view.close();return;}reserve(view,choice.candidate,found.orElseThrow());}));}
-    private void reserve(View view,Candidate candidate,CharacterRecord dead){var source=view.target.getInventory().getItem(candidate.slot);int destination=source.getAmount()==1?-1:emptySlot(view.target,candidate.slot);if(source.getAmount()>1&&destination<0){view.admin.sendMessage("Admin revival needs one empty direct inventory slot to preserve copied Tails.");view.close();return;}var reservation=new RevivalStore.Reservation(UUID.randomUUID(),view.admin.getUniqueId(),view.target.getUniqueId(),dead.id(),dead.deathId(),clock.instant().truncatedTo(ChronoUnit.SECONDS),candidate.slot,source.getAmount(),destination,true);reservations.reserve(reservation).whenComplete((saved,failure)->schedule(()->{if(failure!=null){report(failure);view.admin.sendMessage("Admin revival reservation failed; no item changed.");view.close();return;}if(saved.isEmpty()||!view.current()||!unchanged(view.target,candidate)){view.admin.sendMessage("Admin revival became stale after reservation; no item changed.");view.close();return;}deliver(view,dead,reservation);}));}
+    private void reserve(View view,Candidate candidate,CharacterRecord dead){var source=view.target.getInventory().getItem(candidate.slot);int destination=source.getAmount()==1?-1:emptySlot(view.target,candidate.slot);if(source.getAmount()>1&&destination<0){view.admin.sendMessage("Admin revival needs one empty direct inventory slot to preserve copied Tails.");view.close();return;}var reservation=new RevivalStore.Reservation(UUID.randomUUID(),view.admin.getUniqueId(),view.target.getUniqueId(),dead.id(),dead.deathId(),clock.instant().truncatedTo(ChronoUnit.SECONDS),candidate.slot,source.getAmount(),destination,true);var audit=auditEvents==null?null:auditEvents.selection(view.admin,view.target);reservations.reserve(reservation).whenComplete((saved,failure)->schedule(()->{if(failure!=null){report(failure);view.admin.sendMessage("Admin revival reservation failed; no item changed.");view.close();return;}if(saved.isEmpty()||!view.current()||!unchanged(view.target,candidate)){view.admin.sendMessage("Admin revival became stale after reservation; no item changed.");view.close();return;}deliver(view,dead,reservation,audit);}));}
     private static int emptySlot(Player target,int source){for(int slot=0;slot<=40;slot++){if(slot>35&&slot!=40||slot==source)continue;var item=target.getInventory().getItem(slot);if(item==null||item.isEmpty())return slot;}return-1;}
-    private void deliver(View view,CharacterRecord dead,RevivalStore.Reservation reservation){try{var provisional=new CharacterRecord(dead.id(),dead.name(),dead.revision(),dead.stats(),dead.level(),dead.experience(),dead.unspentPoints(),dead.maximumHealth(),dead.learned(),dead.loadout(),dead.passives(),dead.cooldowns(),dead.restrictedKills(),false,dead.deathId(),dead.diedAt(),dead.sheetGeneration());var sheet=sheets.create(provisional);var source=view.target.getInventory().getItem(reservation.sourceSlot());if(reservation.sourceAmount()==1)view.target.getInventory().setItem(reservation.sourceSlot(),sheet);else{view.target.getInventory().setItem(reservation.destinationSlot(),sheet);var remaining=source.clone();remaining.setAmount(reservation.sourceAmount()-1);view.target.getInventory().setItem(reservation.sourceSlot(),remaining);}view.target.updateInventory();}catch(RuntimeException uncertain){report(uncertain);view.admin.sendMessage("Admin revival delivery is uncertain; retained proof requires recovery.");view.close();return;}characters.restoreDeathRecordAdministratively(reservation.character(),reservation.death(),NativeHealthLimit.read()).whenComplete((restored,failure)->schedule(()->{if(failure!=null||restored.isEmpty()){if(failure!=null)report(failure);view.admin.sendMessage("The Tail changed, but restoration is pending proof-based recovery.");view.close();return;}if(installFinal(view.target,restored.orElseThrow())){reservations.clear(reservation.character(),reservation.id()).exceptionally(error->{report(error);return false;});view.admin.sendMessage("Administratively restored "+restored.orElseThrow().name()+" for "+view.target.getName()+".");view.target.sendMessage("An administrator restored character sheet: "+restored.orElseThrow().name()+".");}else view.admin.sendMessage("Character restoration was saved, but sheet custody is ambiguous; retained proof requires recovery.");view.close();}));}
+    private void deliver(View view,CharacterRecord dead,RevivalStore.Reservation reservation,games.dmg.fantasystick.events.AdminRevivalEventBridge.Selection audit){try{var provisional=new CharacterRecord(dead.id(),dead.name(),dead.revision(),dead.stats(),dead.level(),dead.experience(),dead.unspentPoints(),dead.maximumHealth(),dead.learned(),dead.loadout(),dead.passives(),dead.cooldowns(),dead.restrictedKills(),false,dead.deathId(),dead.diedAt(),dead.sheetGeneration());var sheet=sheets.create(provisional);var source=view.target.getInventory().getItem(reservation.sourceSlot());if(reservation.sourceAmount()==1)view.target.getInventory().setItem(reservation.sourceSlot(),sheet);else{view.target.getInventory().setItem(reservation.destinationSlot(),sheet);var remaining=source.clone();remaining.setAmount(reservation.sourceAmount()-1);view.target.getInventory().setItem(reservation.sourceSlot(),remaining);}view.target.updateInventory();}catch(RuntimeException uncertain){report(uncertain);view.admin.sendMessage("Admin revival delivery is uncertain; retained proof requires recovery.");view.close();return;}characters.restoreDeathRecordAdministratively(reservation.character(),reservation.death(),NativeHealthLimit.read()).whenComplete((restored,failure)->schedule(()->{if(failure!=null||restored.isEmpty()){if(failure!=null)report(failure);view.admin.sendMessage("The Tail changed, but restoration is pending proof-based recovery.");view.close();return;}if(installFinal(view.target,restored.orElseThrow())){if(auditEvents!=null)auditEvents.revived(audit,reservation,dead,restored.orElseThrow(),view.target);reservations.clear(reservation.character(),reservation.id()).exceptionally(error->{report(error);return false;});view.admin.sendMessage("Administratively restored "+restored.orElseThrow().name()+" for "+view.target.getName()+".");view.target.sendMessage("An administrator restored character sheet: "+restored.orElseThrow().name()+".");}else view.admin.sendMessage("Character restoration was saved, but sheet custody is ambiguous; retained proof requires recovery.");view.close();}));}
     private boolean installFinal(Player target,CharacterRecord record){int found=-1;for(int slot=0;slot<=40;slot++){if(slot>35&&slot!=40)continue;if(sheets.identify(target.getInventory().getItem(slot)).filter(record.id()::equals).isEmpty())continue;if(found>=0)return false;found=slot;}if(found<0)return false;target.getInventory().setItem(found,sheets.create(record));target.updateInventory();return true;}
     private void schedule(Runnable action){try{nextTick.accept(action);}catch(RuntimeException rejected){report(rejected);}}
     private void report(Throwable failure){try{failures.accept(failure);}catch(RuntimeException ignored){}}

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

@@ -68,9 +68,11 @@ public final class EquipmentAdminCommand implements TabExecutor, AutoCloseable {
     private games.dmg.fantasystick.ability.Meteor meteor;
     private AdminCharacterIssuer characterIssuer;
     private AdminRevival adminRevival;
+    private games.dmg.fantasystick.events.AdminRevivalEventBridge adminRevivalEvents;
     private AdminExperienceGrant experienceGrant;
     private games.dmg.fantasystick.persistence.AdminReviveSettings adminReviveSettings;
     private games.dmg.fantasystick.persistence.SwitchDelaySettings switchDelaySettings;
+    private games.dmg.fantasystick.events.SwitchConfigEventBridge switchConfigEvents;
     private games.dmg.fantasystick.persistence.RoleplaySettings roleplaySettings;
     private games.dmg.fantasystick.persistence.PartySettings partySettings;
     private games.dmg.fantasystick.persistence.PartyEconomySettings partyEconomySettings;
@@ -336,6 +338,10 @@ public final class EquipmentAdminCommand implements TabExecutor, AutoCloseable {
     }
 
     public void attachSwitchDelay(games.dmg.fantasystick.persistence.SwitchDelaySettings settings){if(closed||switchDelaySettings!=null)throw new IllegalStateException("Switch delay already attached or command closed");switchDelaySettings=Objects.requireNonNull(settings);}
+    public void attachSwitchConfigEvents(games.dmg.fantasystick.events.SwitchConfigEventBridge events){
+        if(closed||switchDelaySettings==null||switchConfigEvents!=null)throw new IllegalStateException("Switch config events unavailable");
+        switchConfigEvents=Objects.requireNonNull(events);
+    }
     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);}
@@ -398,11 +404,23 @@ public final class EquipmentAdminCommand implements TabExecutor, AutoCloseable {
         adminRevival=Objects.requireNonNull(revival);adminReviveSettings=Objects.requireNonNull(settings);
     }
 
+    public void attachAdminRevivalEvents(games.dmg.fantasystick.events.AdminRevivalEventBridge events) {
+        if (closed || adminRevivalEvents != null || adminRevival == null)
+            throw new IllegalStateException("Admin revival event bridge unavailable");
+        adminRevivalEvents = Objects.requireNonNull(events);
+        adminRevival.attachEvents(events);
+    }
+
     public void attachCharacterIssuer(AdminCharacterIssuer issuer) {
         if (closed || characterIssuer != null) throw new IllegalStateException("Character issuer already attached or command closed");
         characterIssuer = Objects.requireNonNull(issuer);
     }
 
+    public void attachCharacterIssueEvents(games.dmg.fantasystick.events.CharacterIdentityEventBridge events) {
+        if (closed || characterIssuer == null) throw new IllegalStateException("Character issuer unavailable");
+        characterIssuer.attachIdentityEvents(events);
+    }
+
     public void attachCharacterBooks(games.dmg.fantasystick.book.CharacterBookController books,
             games.dmg.fantasystick.persistence.CharacterStorage storage) {
         if (closed || characterBooks != null) throw new IllegalStateException("Character books already attached or command closed");
@@ -959,7 +977,7 @@ public final class EquipmentAdminCommand implements TabExecutor, AutoCloseable {
             sender.sendMessage("Character issue refused: target must name one online player. No character or item was created."); return;
         }
         var target = matches.getFirst();
-        characterIssuer.issue(target, outcome -> {
+        characterIssuer.issue(sender, target, outcome -> {
             if (closed || !sender.hasPermission(PERMISSION)
                     || sender instanceof org.bukkit.entity.Player player && !player.isOnline()) return;
             sender.sendMessage(switch (outcome) {
@@ -1324,8 +1342,11 @@ public final class EquipmentAdminCommand implements TabExecutor, AutoCloseable {
 
     private void quickstepConfiguration(CommandSender sender, String[] args) {
         String key = args[1];
+        var actor = abilityConfigEvents == null ? null : abilityConfigEvents.capture(sender);
+        String before = quickstepSettings.value(key);
         if (args.length == 2) {
-            sender.sendMessage(key + "=" + quickstepSettings.value(key) + " (applies to future Quickstep dashes only)");
+            if (abilityConfigEvents != null) abilityConfigEvents.read(actor, "quickstep", key, before);
+            sender.sendMessage(key + "=" + before + " (applies to future Quickstep dashes only)");
             return;
         }
         java.util.concurrent.CompletionStage<games.dmg.fantasystick.persistence.QuickstepSettings.Update> operation;
@@ -1339,21 +1360,56 @@ public final class EquipmentAdminCommand implements TabExecutor, AutoCloseable {
             try {
                 nextTick.accept(() -> {
                     if (closed) return;
-                    if (failure == null) {
-                        quickstep.configure(saved.settings()); abilities.replace(quickstep.definition());
-                        quickstepSettings.publish(saved);
+                    boolean applied = failure == null && quickstepSettings.publish(saved);
+                    if (applied) {
+                        quickstep.configure(quickstepSettings.settings()); abilities.replace(quickstep.definition());
+                        if (abilityConfigEvents != null) abilityConfigEvents.changed(actor, "quickstep", key, before, saved.value());
                     }
                     if (!sender.hasPermission(PERMISSION)
                             || sender instanceof org.bukkit.entity.Player player && !player.isOnline()) return;
-                    sender.sendMessage(failure == null
-                        ? "Saved " + key + "=" + saved.value() + " for future Quickstep dashes; active movement and deadlines are unchanged."
-                        : "Quickstep configuration save failed; the effective setting is unchanged.");
+                    sender.sendMessage(failure != null
+                        ? "Quickstep configuration save failed; the effective setting is unchanged."
+                        : applied ? "Saved " + key + "=" + saved.value() + " for future Quickstep dashes; active movement and deadlines are unchanged."
+                        : "Saved request was superseded; effective " + key + "=" + quickstepSettings.value(key) + ".");
                 });
             } catch (RuntimeException rejected) { report(null, "config-response", rejected); }
         });
     }
 
-    private void inspireConfiguration(CommandSender sender,String[] args){String key=args[1];if(args.length==2){sender.sendMessage(key+"="+inspireSettings.value(key)+" (applies to future Inspire casts only)");return;}java.util.concurrent.CompletionStage<games.dmg.fantasystick.persistence.InspireSettings.Update> operation;try{operation=inspireSettings.set(key,args[2]);}catch(IllegalArgumentException invalid){sender.sendMessage("Inspire setting is invalid; the effective value is unchanged.");return;}operation.whenComplete((saved,failure)->{if(failure!=null)report(null,"config-"+key,failure);if(closed)return;try{nextTick.accept(()->{if(closed)return;if(failure==null){inspire.configure(saved.settings());abilities.replace(inspire.definition());inspireSettings.publish(saved);}if(!sender.hasPermission(PERMISSION)||sender instanceof org.bukkit.entity.Player player&&!player.isOnline())return;sender.sendMessage(failure==null?"Saved "+key+"="+saved.value()+" for future Inspire casts; active effects and deadlines are unchanged.":"Inspire configuration save failed; the effective setting is unchanged.");});}catch(RuntimeException rejected){report(null,"config-response",rejected);}});}
+    private void inspireConfiguration(CommandSender sender, String[] args) {
+        String key = args[1];
+        var actor = abilityConfigEvents == null ? null : abilityConfigEvents.capture(sender);
+        String before = inspireSettings.value(key);
+        if (args.length == 2) {
+            if (abilityConfigEvents != null) abilityConfigEvents.read(actor, "inspire", key, before);
+            sender.sendMessage(key + "=" + before + " (applies to future Inspire casts only)"); return;
+        }
+        java.util.concurrent.CompletionStage<games.dmg.fantasystick.persistence.InspireSettings.Update> operation;
+        try { operation = inspireSettings.set(key, args[2]); }
+        catch (IllegalArgumentException invalid) {
+            sender.sendMessage("Inspire setting is invalid; the effective value is unchanged."); return;
+        }
+        operation.whenComplete((saved, failure) -> {
+            if (failure != null) report(null, "config-" + key, failure);
+            if (closed) return;
+            try { nextTick.accept(() -> {
+                if (closed) return;
+                String effectiveBefore = failure == null ? inspireSettings.value(key) : null;
+                boolean applied = failure == null && inspireSettings.publish(saved);
+                if (applied) {
+                    inspire.configure(inspireSettings.settings()); abilities.replace(inspire.definition());
+                    if (abilityConfigEvents != null)
+                        abilityConfigEvents.changed(actor, "inspire", key, effectiveBefore, saved.value());
+                }
+                if (!sender.hasPermission(PERMISSION)
+                        || sender instanceof org.bukkit.entity.Player player && !player.isOnline()) return;
+                sender.sendMessage(failure != null
+                    ? "Inspire configuration save failed; the effective setting is unchanged."
+                    : applied ? "Saved " + key + "=" + saved.value() + " for future Inspire casts; active effects and deadlines are unchanged."
+                    : "Saved request was superseded; effective " + key + "=" + inspireSettings.value(key) + ".");
+            }); } catch (RuntimeException rejected) { report(null, "config-response", rejected); }
+        });
+    }
 
     private void mendingLightConfiguration(CommandSender sender, String[] args) {
         String key = args[1];
@@ -1637,19 +1693,47 @@ public final class EquipmentAdminCommand implements TabExecutor, AutoCloseable {
     }
 
     private void hexConfiguration(CommandSender sender, String[] args) {
-        String key=args[1];if(args.length==2){sender.sendMessage(key+"="+hexSettings.value(key)+" (applies to future Hex casts only)");return;}
+        String key = args[1];
+        var actor = abilityConfigEvents == null ? null : abilityConfigEvents.capture(sender);
+        String before = hexSettings.value(key);
+        if (args.length == 2) {
+            if (abilityConfigEvents != null) abilityConfigEvents.read(actor, "hex", key, before);
+            sender.sendMessage(key + "=" + before + " (applies to future Hex casts only)"); return;
+        }
         java.util.concurrent.CompletionStage<games.dmg.fantasystick.persistence.HexSettings.Update> operation;
-        try{operation=hexSettings.set(key,args[2]);}catch(IllegalArgumentException invalid){sender.sendMessage("Hex setting is invalid; the effective value is unchanged.");return;}
-        operation.whenComplete((saved,failure)->{if(failure!=null)report(null,"config-"+key,failure);if(closed)return;
-            try{nextTick.accept(()->{if(closed)return;if(failure==null){hex.configure(saved.settings());abilities.replace(hex.definition());hexSettings.publish(saved);}
-                if(!sender.hasPermission(PERMISSION)||sender instanceof org.bukkit.entity.Player player&&!player.isOnline())return;
-                sender.sendMessage(failure==null?"Saved "+key+"="+saved.value()+" for future Hex casts; active effects and deadlines are unchanged."
-                    :"Hex configuration save failed; the effective setting is unchanged.");});}catch(RuntimeException rejected){report(null,"config-response",rejected);}});
+        try { operation = hexSettings.set(key, args[2]); }
+        catch (IllegalArgumentException invalid) {
+            sender.sendMessage("Hex setting is invalid; the effective value is unchanged."); return;
+        }
+        operation.whenComplete((saved, failure) -> {
+            if (failure != null) report(null, "config-" + key, failure);
+            if (closed) return;
+            try { nextTick.accept(() -> {
+                if (closed) return;
+                String effectiveBefore = failure == null ? hexSettings.value(key) : null;
+                boolean applied = failure == null && hexSettings.publish(saved);
+                if (applied) {
+                    hex.configure(hexSettings.settings()); abilities.replace(hex.definition());
+                    if (abilityConfigEvents != null) abilityConfigEvents.changed(actor, "hex", key, effectiveBefore, saved.value());
+                }
+                if (!sender.hasPermission(PERMISSION)
+                        || sender instanceof org.bukkit.entity.Player player && !player.isOnline()) return;
+                sender.sendMessage(failure != null
+                    ? "Hex configuration save failed; the effective setting is unchanged."
+                    : applied ? "Saved " + key + "=" + saved.value() + " for future Hex casts; active effects and deadlines are unchanged."
+                    : "Saved request was superseded; effective " + key + "=" + hexSettings.value(key) + ".");
+            }); } catch (RuntimeException rejected) { report(null, "config-response", rejected); }
+        });
     }
 
     private void shieldBashConfiguration(CommandSender sender, String[] args) {
         String key = args[1];
-        if (args.length == 2) { sender.sendMessage(key + "=" + shieldBashSettings.value(key) + " (applies to future Shield Bash strikes only)"); return; }
+        var actor = abilityConfigEvents == null ? null : abilityConfigEvents.capture(sender);
+        String before = shieldBashSettings.value(key);
+        if (args.length == 2) {
+            if (abilityConfigEvents != null) abilityConfigEvents.read(actor, "shield_bash", key, before);
+            sender.sendMessage(key + "=" + before + " (applies to future Shield Bash strikes only)"); return;
+        }
         java.util.concurrent.CompletionStage<games.dmg.fantasystick.persistence.ShieldBashSettings.Update> operation;
         try { operation = shieldBashSettings.set(key, args[2]); }
         catch (IllegalArgumentException invalid) { sender.sendMessage("Shield Bash setting is invalid; the effective value is unchanged."); return; }
@@ -1658,22 +1742,29 @@ public final class EquipmentAdminCommand implements TabExecutor, AutoCloseable {
             if (closed) return;
             try { nextTick.accept(() -> {
                 if (closed) return;
-                if (failure == null) {
-                    shieldBash.configure(saved.settings()); abilities.replace(shieldBash.definition()); shieldBashSettings.publish(saved);
+                String effectiveBefore = failure == null ? shieldBashSettings.value(key) : null;
+                boolean applied = failure == null && shieldBashSettings.publish(saved);
+                if (applied) {
+                    shieldBash.configure(shieldBashSettings.settings()); abilities.replace(shieldBash.definition());
+                    if (abilityConfigEvents != null) abilityConfigEvents.changed(actor, "shield_bash", key, effectiveBefore, saved.value());
                 }
                 if (!sender.hasPermission(PERMISSION)
                         || sender instanceof org.bukkit.entity.Player player && !player.isOnline()) return;
-                sender.sendMessage(failure == null
-                    ? "Saved " + key + "=" + saved.value() + " for future Shield Bash strikes; active work and deadlines are unchanged."
-                    : "Shield Bash configuration save failed; the effective setting is unchanged.");
+                sender.sendMessage(failure != null
+                    ? "Shield Bash configuration save failed; the effective setting is unchanged."
+                    : applied ? "Saved " + key + "=" + saved.value() + " for future Shield Bash strikes; active work and deadlines are unchanged."
+                    : "Saved request was superseded; effective " + key + "=" + shieldBashSettings.value(key) + ".");
             }); } catch (RuntimeException rejected) { report(null, "config-response", rejected); }
         });
     }
 
     private void stoneSkinConfiguration(CommandSender sender, String[] args) {
         String key = args[1];
+        var actor = abilityConfigEvents == null ? null : abilityConfigEvents.capture(sender);
+        String before = stoneSkinSettings.value(key);
         if (args.length == 2) {
-            sender.sendMessage(key + "=" + stoneSkinSettings.value(key) + " (applies to future Stone Skin casts only)"); return;
+            if (abilityConfigEvents != null) abilityConfigEvents.read(actor, "stone_skin", key, before);
+            sender.sendMessage(key + "=" + before + " (applies to future Stone Skin casts only)"); return;
         }
         java.util.concurrent.CompletionStage<games.dmg.fantasystick.persistence.StoneSkinSettings.Update> operation;
         try { operation = stoneSkinSettings.set(key, args[2]); }
@@ -1683,22 +1774,29 @@ public final class EquipmentAdminCommand implements TabExecutor, AutoCloseable {
             if (closed) return;
             try { nextTick.accept(() -> {
                 if (closed) return;
-                if (failure == null) {
-                    stoneSkin.configure(saved.settings()); abilities.replace(stoneSkin.definition()); stoneSkinSettings.publish(saved);
+                String effectiveBefore = failure == null ? stoneSkinSettings.value(key) : null;
+                boolean applied = failure == null && stoneSkinSettings.publish(saved);
+                if (applied) {
+                    stoneSkin.configure(stoneSkinSettings.settings()); abilities.replace(stoneSkin.definition());
+                    if (abilityConfigEvents != null) abilityConfigEvents.changed(actor, "stone_skin", key, effectiveBefore, saved.value());
                 }
                 if (!sender.hasPermission(PERMISSION)
                         || sender instanceof org.bukkit.entity.Player player && !player.isOnline()) return;
-                sender.sendMessage(failure == null
-                    ? "Saved " + key + "=" + saved.value() + " for future Stone Skin casts; active effects and deadlines are unchanged."
-                    : "Stone Skin configuration save failed; the effective setting is unchanged.");
+                sender.sendMessage(failure != null
+                    ? "Stone Skin configuration save failed; the effective setting is unchanged."
+                    : applied ? "Saved " + key + "=" + saved.value() + " for future Stone Skin casts; active effects and deadlines are unchanged."
+                    : "Saved request was superseded; effective " + key + "=" + stoneSkinSettings.value(key) + ".");
             }); } catch (RuntimeException rejected) { report(null, "config-response", rejected); }
         });
     }
 
     private void secondWindConfiguration(CommandSender sender, String[] args) {
         String key = args[1];
+        var actor = abilityConfigEvents == null ? null : abilityConfigEvents.capture(sender);
+        String before = secondWindSettings.value(key);
         if (args.length == 2) {
-            sender.sendMessage(key + "=" + secondWindSettings.value(key) + " (applies to future Second Wind casts only)");
+            if (abilityConfigEvents != null) abilityConfigEvents.read(actor, "second_wind", key, before);
+            sender.sendMessage(key + "=" + before + " (applies to future Second Wind casts only)");
             return;
         }
         java.util.concurrent.CompletionStage<games.dmg.fantasystick.persistence.SecondWindSettings.Update> operation;
@@ -1712,15 +1810,18 @@ public final class EquipmentAdminCommand implements TabExecutor, AutoCloseable {
             try {
                 nextTick.accept(() -> {
                     if (closed) return;
-                    if (failure == null) {
-                        secondWind.configure(saved.settings()); abilities.replace(secondWind.definition());
-                        secondWindSettings.publish(saved);
+                    String effectiveBefore = failure == null ? secondWindSettings.value(key) : null;
+                    boolean applied = failure == null && secondWindSettings.publish(saved);
+                    if (applied) {
+                        secondWind.configure(secondWindSettings.settings()); abilities.replace(secondWind.definition());
+                        if (abilityConfigEvents != null) abilityConfigEvents.changed(actor, "second_wind", key, effectiveBefore, saved.value());
                     }
                     if (!sender.hasPermission(PERMISSION)
                             || sender instanceof org.bukkit.entity.Player player && !player.isOnline()) return;
-                    sender.sendMessage(failure == null
-                        ? "Saved " + key + "=" + saved.value() + " for future Second Wind casts; active work and deadlines are unchanged."
-                        : "Second Wind configuration save failed; the effective setting is unchanged.");
+                    sender.sendMessage(failure != null
+                        ? "Second Wind configuration save failed; the effective setting is unchanged."
+                        : applied ? "Saved " + key + "=" + saved.value() + " for future Second Wind casts; active work and deadlines are unchanged."
+                        : "Saved request was superseded; effective " + key + "=" + secondWindSettings.value(key) + ".");
                 });
             } catch (RuntimeException rejected) { report(null, "config-response", rejected); }
         });
@@ -1774,9 +1875,72 @@ public final class EquipmentAdminCommand implements TabExecutor, AutoCloseable {
 
     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: /fstickadmin config roleplay-disabled [true|false]");return;}operation.whenComplete((saved,failure)->{if(failure!=null)report(null,"config-roleplay",failure);if(closed)return;try{nextTick.accept(()->{if(closed)return;boolean applied=false;if(failure==null){applied=roleplaySettings.publish(saved);if(applied&&saved.disabled())sessions.disableRoleplay();}if(!sender.hasPermission(PERMISSION)||sender instanceof org.bukkit.entity.Player player&&!player.isOnline())return;if(failure!=null)sender.sendMessage("Roleplay configuration save failed; policy and sessions are unchanged.");else if(!applied)sender.sendMessage("Saved request was superseded; effective "+games.dmg.fantasystick.persistence.RoleplaySettings.KEY+"="+roleplaySettings.value()+".");else sender.sendMessage("Saved "+games.dmg.fantasystick.persistence.RoleplaySettings.KEY+"="+saved.disabled()+(saved.disabled()?"; ordinary exits were requested for active sessions.":"; normal sheet activation is available."));});}catch(RuntimeException rejected){report(null,"config-response",rejected);}});}
 
-    private void switchDelayConfiguration(CommandSender sender,String[] args){if(switchDelaySettings==null){configurationUsage(sender);return;}if(args.length==2){sender.sendMessage(games.dmg.fantasystick.persistence.SwitchDelaySettings.KEY+"="+switchDelaySettings.value()+" (new exits use this delay; existing deadlines are unchanged)");return;}java.util.concurrent.CompletionStage<games.dmg.fantasystick.persistence.SwitchDelaySettings.Update> operation;try{operation=switchDelaySettings.set(args[2]);}catch(IllegalArgumentException invalid){sender.sendMessage("Character switch delay is invalid; the effective value is unchanged.");return;}operation.whenComplete((saved,failure)->{if(failure!=null)report(null,"config-switch-delay",failure);if(closed)return;try{nextTick.accept(()->{if(closed)return;if(failure==null)switchDelaySettings.publish(saved);if(!sender.hasPermission(PERMISSION)||sender instanceof org.bukkit.entity.Player player&&!player.isOnline())return;sender.sendMessage(failure==null?"Saved "+games.dmg.fantasystick.persistence.SwitchDelaySettings.KEY+"="+saved.value()+"; new exits use it and existing deadlines are unchanged.":"Character switch delay save failed; the effective value is unchanged.");});}catch(RuntimeException rejected){report(null,"config-response",rejected);}});}
+    private void switchDelayConfiguration(CommandSender sender,String[] args){
+        if(switchDelaySettings==null){configurationUsage(sender);return;}
+        var audit=switchConfigEvents;
+        if(args.length==2){
+            var effective=switchDelaySettings.value();
+            if(audit!=null)audit.read(audit.actor(sender),effective);
+            sender.sendMessage(games.dmg.fantasystick.persistence.SwitchDelaySettings.KEY+"="+effective
+                +" (new exits use this delay; existing deadlines are unchanged)");
+            return;
+        }
+        var actor=audit==null?null:audit.actor(sender);
+        var operationId=java.util.UUID.randomUUID();
+        java.util.concurrent.CompletionStage<games.dmg.fantasystick.persistence.SwitchDelaySettings.Update> operation;
+        try{operation=switchDelaySettings.set(args[2]);}
+        catch(IllegalArgumentException invalid){sender.sendMessage("Character switch delay is invalid; the effective value is unchanged.");return;}
+        operation.whenComplete((saved,failure)->{
+            if(failure!=null)report(null,"config-switch-delay",failure);
+            if(closed)return;
+            try{nextTick.accept(()->{
+                if(closed)return;
+                if(failure==null){
+                    var before=switchDelaySettings.value();
+                    switchDelaySettings.publish(saved);
+                    var effective=switchDelaySettings.value();
+                    if(audit!=null&&!before.equals(effective))audit.changed(actor,operationId,before,effective,saved);
+                }
+                if(!sender.hasPermission(PERMISSION)||sender instanceof org.bukkit.entity.Player player&&!player.isOnline())return;
+                sender.sendMessage(failure==null?"Saved "+games.dmg.fantasystick.persistence.SwitchDelaySettings.KEY+"="+saved.value()
+                    +"; new exits use it and existing deadlines are unchanged."
+                    :"Character switch delay save failed; the effective value is unchanged.");
+            });}catch(RuntimeException rejected){report(null,"config-response",rejected);}
+        });
+    }
 
-    private void adminReviveConfiguration(CommandSender sender,String[] args){if(adminReviveSettings==null){configurationUsage(sender);return;}if(args.length==2){sender.sendMessage(games.dmg.fantasystick.persistence.AdminReviveSettings.KEY+"="+adminReviveSettings.value()+" (applies to later admin revival selections only)");return;}java.util.concurrent.CompletionStage<games.dmg.fantasystick.persistence.AdminReviveSettings.Update> operation;try{operation=adminReviveSettings.set(args[2]);}catch(IllegalArgumentException invalid){sender.sendMessage("Admin revival timeout is invalid; the effective value is unchanged.");return;}operation.whenComplete((saved,failure)->{if(failure!=null)report(null,"config-admin-revive",failure);if(closed)return;try{nextTick.accept(()->{if(closed)return;if(failure==null)adminReviveSettings.publish(saved);if(!sender.hasPermission(PERMISSION)||sender instanceof org.bukkit.entity.Player player&&!player.isOnline())return;sender.sendMessage(failure==null?"Saved "+games.dmg.fantasystick.persistence.AdminReviveSettings.KEY+"="+saved.value()+" for later selections; open selections retain their deadline.":"Admin revival configuration save failed; the effective setting is unchanged.");});}catch(RuntimeException rejected){report(null,"config-response",rejected);}});}
+    private void adminReviveConfiguration(CommandSender sender,String[] args){
+        if(adminReviveSettings==null){configurationUsage(sender);return;}
+        var audit = adminRevivalEvents;
+        if(args.length==2){
+            var value=adminReviveSettings.value();
+            if(audit!=null)audit.read(audit.actor(sender),value);
+            sender.sendMessage(games.dmg.fantasystick.persistence.AdminReviveSettings.KEY+"="+value
+                +" (applies to later admin revival selections only)");
+            return;
+        }
+        var actor=audit==null?null:audit.actor(sender);
+        java.util.concurrent.CompletionStage<games.dmg.fantasystick.persistence.AdminReviveSettings.Update> operation;
+        try{operation=adminReviveSettings.set(args[2]);}
+        catch(IllegalArgumentException invalid){sender.sendMessage("Admin revival timeout is invalid; the effective value is unchanged.");return;}
+        operation.whenComplete((saved,failure)->{
+            if(failure!=null)report(null,"config-admin-revive",failure);
+            if(closed)return;
+            try{nextTick.accept(()->{
+                if(closed)return;
+                if(failure==null){
+                    var before=adminReviveSettings.value();
+                    adminReviveSettings.publish(saved);
+                    if(audit!=null && !before.equals(adminReviveSettings.value()))
+                        audit.changed(actor,before,saved);
+                }
+                if(!sender.hasPermission(PERMISSION)||sender instanceof org.bukkit.entity.Player player&&!player.isOnline())return;
+                sender.sendMessage(failure==null?"Saved "+games.dmg.fantasystick.persistence.AdminReviveSettings.KEY+"="+saved.value()
+                    +" for later selections; open selections retain their deadline."
+                    :"Admin revival configuration save failed; the effective setting is unchanged.");
+            });}catch(RuntimeException rejected){report(null,"config-response",rejected);}
+        });
+    }
 
     private void adventureConfiguration(CommandSender sender, String[] args) {
         var action = sessionRecoveryEvents == null ? null : sessionRecoveryEvents.capture(sender, null);

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

@@ -0,0 +1,281 @@
+package games.dmg.fantasystick;
+
+import static org.junit.jupiter.api.Assertions.*;
+import static org.mockito.Mockito.*;
+
+import com.google.gson.JsonObject;
+import com.google.gson.JsonParser;
+import games.dmg.fantasystick.items.CharacterSheets;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.UUID;
+import java.util.concurrent.TimeUnit;
+import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.io.TempDir;
+
+/** Registered administrator issuance is not an event success until native delivery is acknowledged. */
+class AdminCharacterIssueEventsNativeTest {
+    @TempDir Path data;
+    @BeforeAll static void bootstrap() throws Exception { NativeRuntime.bootstrap(); }
+
+    @Test void registeredConsoleIssueExportsOnlyAcknowledgedSavedAndDeliveredSheet() throws Exception {
+        UUID issued;
+        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 EquipmentAdminCommandNativeTest.Sender();
+            f.adminCommand.execute(sender.port, "fstickadmin", new String[]{"give", target.accountName});
+            assertTrue(sender.messages.isEmpty(), "A queued save is not delivery");
+            assertTrue(issuedEvents().isEmpty(), "A queued save cannot export issuance");
+            var storage = (games.dmg.fantasystick.persistence.CharacterStorage)
+                FantasyStickLifecycleNativeTest.Fixture.field(f.plugin, "characters");
+            storage.find(UUID.randomUUID()).get(5, TimeUnit.SECONDS);
+            var completion = f.tasks.poll(5, TimeUnit.SECONDS); assertNotNull(completion);
+            completion.run(); completion.run();
+            assertTrue(sender.messages.getLast().contains("Issued one new character sheet"));
+            var sheets = new CharacterSheets();
+            var delivered = java.util.stream.IntStream.range(0, 36)
+                .filter(slot -> sheets.identify(target.core.inventory.getItem(slot)).isPresent()
+                    && !sheets.identify(target.core.inventory.getItem(slot)).orElseThrow().equals(target.core.record.id()))
+                .toArray();
+            assertEquals(1, delivered.length);
+            issued = sheets.identify(target.core.inventory.getItem(delivered[0])).orElseThrow();
+            var saved = storage.find(issued).get(5, TimeUnit.SECONDS).orElseThrow();
+            for (int i = 0; i < 200 && issuedEvents().isEmpty(); i++) Thread.sleep(10);
+            var matching = issuedEvents().stream().filter(event -> event.getAsJsonObject("data")
+                .get("character_id").getAsString().equals(issued.toString())).toList();
+            assertEquals(1, matching.size(), "One native delivery has one stable success record");
+            var event = matching.getFirst(); var payload = event.getAsJsonObject("data");
+            assertEquals("console", payload.get("actor_kind").getAsString());
+            assertEquals(target.core.id.toString(), payload.get("target_player_id").getAsString());
+            assertEquals(target.accountName, payload.get("target_player_name").getAsString());
+            assertEquals(issued.toString(), payload.get("character_id").getAsString());
+            assertEquals(saved.name(), payload.get("character_name").getAsString());
+            assertEquals(saved.revision().toString(), payload.get("revision").getAsString());
+            assertEquals(saved.unspentPoints().toString(), payload.get("starting_unspent_points").getAsString());
+            assertEquals(saved.stats().size(), payload.getAsJsonObject("starting_stats").size());
+            assertEquals(delivered[0], payload.get("delivered_slot").getAsInt());
+            assertEquals("acknowledged_delivered", payload.get("outcome").getAsString());
+            assertEquals("not_applicable", payload.get("actor_location_status").getAsString());
+            assertEquals(target.world.getUID().toString(),
+                payload.getAsJsonObject("target_location").get("world_id").getAsString());
+            assertEquals(payload.get("issue_operation_id").getAsString(), payload.get("action_id").getAsString());
+            assertEquals(1, matching.stream().map(item -> item.get("id").getAsString()).distinct().count());
+        }
+        var beforeRestart = issuedEvents().stream().filter(event -> event.getAsJsonObject("data")
+            .get("character_id").getAsString().equals(issued.toString())).toList();
+        assertEquals(1, beforeRestart.size());
+        try (var restarted = new FantasyStickLifecycleNativeTest.Fixture(data)) {
+            restarted.plugin.setEnabled(true);
+            restarted.plugin.setEnabled(false);
+        }
+        var afterRestart = issuedEvents().stream().filter(event -> event.getAsJsonObject("data")
+            .get("character_id").getAsString().equals(issued.toString())).toList();
+        assertEquals(1, afterRestart.stream().map(item -> item.get("id").getAsString()).distinct().count());
+    }
+
+    @Test void registeredPlayerAdministratorCapturesActualActorAndTargetLocations() throws Exception {
+        try (var f = new FantasyStickLifecycleNativeTest.Fixture(data)) {
+            f.plugin.setEnabled(true);
+            var admin = new FantasyStickLifecycleNativeTest.Actor(data);
+            admin.accountName = "Administrator";
+            var target = new FantasyStickLifecycleNativeTest.Actor(data);
+            f.players.put(admin.core.id, admin.player); f.players.put(target.core.id, target.player);
+            f.adminCommand.execute(admin.player, "fstickadmin", new String[]{"give", target.accountName});
+            var storage = (games.dmg.fantasystick.persistence.CharacterStorage)
+                FantasyStickLifecycleNativeTest.Fixture.field(f.plugin, "characters");
+            storage.find(UUID.randomUUID()).get(5, TimeUnit.SECONDS);
+            var completion = f.tasks.poll(5, TimeUnit.SECONDS); assertNotNull(completion); completion.run();
+            for (int i = 0; i < 200 && issuedEvents().isEmpty(); i++) Thread.sleep(10);
+            var events = issuedEvents(); assertEquals(1, events.size());
+            var data = events.getFirst().getAsJsonObject("data");
+            assertEquals(admin.core.id.toString(), data.get("player_id").getAsString());
+            assertEquals("player", data.get("actor_kind").getAsString());
+            assertEquals(admin.world.getUID().toString(), data.getAsJsonObject("location").get("world_id").getAsString());
+            assertEquals(target.world.getUID().toString(), data.getAsJsonObject("target_location").get("world_id").getAsString());
+        }
+    }
+
+    @Test void fullInventoryAndDeniedCommandCannotExportIssuance() throws Exception {
+        try (var f = new FantasyStickLifecycleNativeTest.Fixture(data)) {
+            f.plugin.setEnabled(true);
+            var target = new FantasyStickLifecycleNativeTest.Actor(data);
+            f.players.put(target.core.id, target.player);
+            var sender = new EquipmentAdminCommandNativeTest.Sender();
+            sender.allowed = false;
+            f.adminCommand.execute(sender.port, "fstickadmin", new String[]{"give", target.accountName});
+            sender.allowed = true;
+            for (int slot = 0; slot < 36; slot++)
+                target.core.inventory.setItem(slot, new org.bukkit.inventory.ItemStack(org.bukkit.Material.STONE));
+            f.adminCommand.execute(sender.port, "fstickadmin", new String[]{"give", target.accountName});
+            assertTrue(sender.messages.getLast().contains("no inventory space"));
+            assertTrue(f.tasks.isEmpty());
+            f.plugin.setEnabled(false);
+        }
+        assertTrue(issuedEvents().isEmpty());
+    }
+
+    @Test void failedSaveDisconnectAndCloseCannotExportIssuance() throws Exception {
+        for (var route : List.of("save", "disconnect", "close")) {
+            var dir = data.resolve(route); Files.createDirectories(dir);
+            try (var f = new FantasyStickLifecycleNativeTest.Fixture(dir)) {
+                f.plugin.setEnabled(true);
+                var target = new FantasyStickLifecycleNativeTest.Actor(dir);
+                f.players.put(target.core.id, target.player);
+                var sender = new EquipmentAdminCommandNativeTest.Sender();
+                var storage = (games.dmg.fantasystick.persistence.CharacterStorage)
+                    FantasyStickLifecycleNativeTest.Fixture.field(f.plugin, "characters");
+                var worker = (java.util.concurrent.ExecutorService)
+                    FantasyStickLifecycleNativeTest.Fixture.field(storage, "worker");
+                var entered = new java.util.concurrent.CountDownLatch(1);
+                var release = new java.util.concurrent.CountDownLatch(1);
+                worker.execute(() -> {
+                    entered.countDown();
+                    try { release.await(5, TimeUnit.SECONDS); }
+                    catch (InterruptedException interrupted) { Thread.currentThread().interrupt(); }
+                });
+                try {
+                    assertTrue(entered.await(5, TimeUnit.SECONDS));
+                    f.adminCommand.execute(sender.port, "fstickadmin", new String[]{"give", target.accountName});
+                    if (route.equals("save")) {
+                        var issuer = FantasyStickLifecycleNativeTest.Fixture.field(f.command.getExecutor(), "characterIssuer");
+                        var pending = (java.util.Map<?, ?>) FantasyStickLifecycleNativeTest.Fixture.field(issuer, "pending");
+                        var attempt = pending.values().iterator().next();
+                        var record = (games.dmg.fantasystick.persistence.CharacterRecord)
+                            FantasyStickLifecycleNativeTest.Fixture.field(attempt, "record");
+                        Files.createDirectory(dir.resolve("characters").resolve(record.id() + ".yml"));
+                    }
+                } finally { release.countDown(); }
+                storage.find(UUID.randomUUID()).get(5, TimeUnit.SECONDS);
+                var callback = f.tasks.poll(5, TimeUnit.SECONDS); assertNotNull(callback);
+                if (route.equals("disconnect")) target.core.online = false;
+                if (route.equals("close")) f.plugin.setEnabled(false);
+                callback.run();
+                assertFalse(sender.messages.stream().anyMatch(message -> message.startsWith("Issued one")));
+                if (!route.equals("close")) f.plugin.setEnabled(false);
+            }
+            assertTrue(issuedEvents(dir).isEmpty(), route + " is not acknowledged delivery");
+        }
+    }
+
+    @Test void unavailableEventStoreCannotUndoAcknowledgedNativeIssue() throws Exception {
+        try (var f = new FantasyStickLifecycleNativeTest.Fixture(data)) {
+            f.plugin.setEnabled(true);
+            Files.writeString(data.resolve("character-identity-event-intents"), "obstructed");
+            var target = new FantasyStickLifecycleNativeTest.Actor(data);
+            f.players.put(target.core.id, target.player);
+            var sender = new EquipmentAdminCommandNativeTest.Sender();
+            f.adminCommand.execute(sender.port, "fstickadmin", new String[]{"give", target.accountName});
+            var storage = (games.dmg.fantasystick.persistence.CharacterStorage)
+                FantasyStickLifecycleNativeTest.Fixture.field(f.plugin, "characters");
+            storage.find(UUID.randomUUID()).get(5, TimeUnit.SECONDS);
+            var callback = f.tasks.poll(5, TimeUnit.SECONDS); assertNotNull(callback); callback.run();
+            assertTrue(sender.messages.getLast().contains("Issued one new character sheet"));
+            var sheets = new CharacterSheets();
+            assertEquals(1, java.util.stream.IntStream.range(0, 36).filter(slot ->
+                sheets.identify(target.core.inventory.getItem(slot)).filter(id -> !id.equals(target.core.record.id()))
+                    .isPresent()).count());
+            f.plugin.setEnabled(false);
+        }
+        assertTrue(issuedEvents().isEmpty(), "A failed audit store never fabricates an exported record");
+    }
+
+    @Test void staleReservedSlotAndFailedNativeSetterCannotClaimAnIssuedSheet() throws Exception {
+        for (var route : List.of("slot", "native")) {
+            var dir = data.resolve(route); Files.createDirectories(dir);
+            try (var f = new FantasyStickLifecycleNativeTest.Fixture(dir)) {
+                f.plugin.setEnabled(true);
+                var target = new FantasyStickLifecycleNativeTest.Actor(dir);
+                f.players.put(target.core.id, target.player);
+                var sender = new EquipmentAdminCommandNativeTest.Sender();
+                if (route.equals("native")) {
+                    var inventory = mock(org.bukkit.inventory.PlayerInventory.class);
+                    when(inventory.firstEmpty()).thenReturn(1);
+                    doThrow(new IllegalStateException("native setter rejected"))
+                        .when(inventory).setItem(eq(1), any(org.bukkit.inventory.ItemStack.class));
+                    doReturn(inventory).when(target.player).getInventory();
+                }
+                f.adminCommand.execute(sender.port, "fstickadmin", new String[]{"give", target.accountName});
+                var storage = (games.dmg.fantasystick.persistence.CharacterStorage)
+                    FantasyStickLifecycleNativeTest.Fixture.field(f.plugin, "characters");
+                storage.find(UUID.randomUUID()).get(5, TimeUnit.SECONDS);
+                var callback = f.tasks.poll(5, TimeUnit.SECONDS); assertNotNull(callback);
+                if (route.equals("slot"))
+                    target.core.inventory.setItem(1, new org.bukkit.inventory.ItemStack(org.bukkit.Material.DIAMOND));
+                callback.run();
+                assertFalse(sender.messages.stream().anyMatch(message -> message.startsWith("Issued one")));
+                f.plugin.setEnabled(false);
+            }
+            assertTrue(issuedEvents(dir).isEmpty(), route + " must not claim confirmed delivery");
+        }
+    }
+
+    @Test void rejectedEventStoreRetainsTheSameIssuanceIdentityForReplayWithoutRedelivery() throws Exception {
+        var target = mock(org.bukkit.entity.Player.class);
+        var playerId = UUID.randomUUID();
+        when(target.getUniqueId()).thenReturn(playerId); when(target.getName()).thenReturn("Target");
+        var sender = mock(org.bukkit.command.CommandSender.class);
+        var record = new games.dmg.fantasystick.crafting.CharacterFactory()
+            .create(games.dmg.fantasystick.progression.ProgressionRules.defaults());
+        var initial = new games.dmg.fantasystick.events.CharacterIdentityEventBridge(
+            ignored -> java.util.concurrent.CompletableFuture.completedFuture(
+                games.dmg.fantasystick.events.LocalEventLog.Delivery.REJECTED),
+            java.time.Clock.systemUTC(), data, ignored -> java.util.Optional.empty(), failure -> fail(failure));
+        var issue = initial.issue(sender, target);
+        assertNotNull(issue);
+        initial.issued(issue, target, record, 1);
+        initial.close(); initial.drained().toCompletableFuture().get(5, TimeUnit.SECONDS);
+        try (var pending = Files.list(data.resolve("character-identity-event-intents"))) {
+            assertEquals(1, pending.filter(path -> path.toString().endsWith(".pending")).count());
+        }
+        var exported = new java.util.concurrent.CopyOnWriteArrayList<games.dmg.fantasystick.events.EventInput>();
+        var replay = new games.dmg.fantasystick.events.CharacterIdentityEventBridge(event -> {
+            exported.add(event);
+            return java.util.concurrent.CompletableFuture.completedFuture(
+                games.dmg.fantasystick.events.LocalEventLog.Delivery.EXPORTED);
+        }, java.time.Clock.systemUTC(), data, ignored -> java.util.Optional.empty(), failure -> fail(failure));
+        replay.replay(); replay.close(); replay.drained().toCompletableFuture().get(5, TimeUnit.SECONDS);
+        assertEquals(1, exported.size());
+        assertEquals(issue.operation(), exported.getFirst().actionId());
+        assertEquals(issue.operation().toString(), exported.getFirst().data().get("issue_operation_id"));
+        assertEquals(playerId.toString(), exported.getFirst().data().get("target_player_id"));
+        assertEquals(1, exported.getFirst().data().get("delivered_slot"));
+        assertEquals(record.stats().size(), ((java.util.Map<?, ?>) exported.getFirst().data().get("starting_stats")).size());
+        assertEquals("unavailable", exported.getFirst().data().get("target_location_status"));
+        var again = new games.dmg.fantasystick.events.CharacterIdentityEventBridge(event -> {
+            exported.add(event);
+            return java.util.concurrent.CompletableFuture.completedFuture(
+                games.dmg.fantasystick.events.LocalEventLog.Delivery.EXPORTED);
+        }, java.time.Clock.systemUTC(), data, ignored -> java.util.Optional.empty(), failure -> fail(failure));
+        again.replay(); again.close(); again.drained().toCompletableFuture().get(5, TimeUnit.SECONDS);
+        assertEquals(1, exported.size(), "Acknowledged export removes the recoverable intent");
+    }
+
+    private List<JsonObject> issuedEvents() throws Exception { return issuedEvents(data); }
+
+    private List<JsonObject> issuedEvents(Path root) throws Exception {
+        var results = new ArrayList<JsonObject>();
+        if (!Files.isDirectory(root.resolve("events"))) return results;
+        try (var days = Files.list(root.resolve("events"))) {
+            for (var day : days.filter(path -> path.getFileName().toString().matches("\\d{4}-\\d{2}-\\d{2}"))
+                    .toList()) {
+                try (var segments = Files.list(day)) {
+                    for (var path : segments.filter(file -> file.getFileName().toString().startsWith("events-")
+                            && file.getFileName().toString().endsWith(".jsonl")).toList()) {
+                        for (var line : Files.readAllLines(path)) {
+                            if (!line.isBlank()) {
+                                var event = JsonParser.parseString(line).getAsJsonObject();
+                                if (event.get("type").getAsString().endsWith("character.issued")) results.add(event);
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        return results;
+    }
+}

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

@@ -0,0 +1,351 @@
+package games.dmg.fantasystick;
+
+import static org.junit.jupiter.api.Assertions.*;
+import static org.mockito.Mockito.*;
+
+import com.google.gson.JsonObject;
+import com.google.gson.JsonParser;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.time.Instant;
+import java.time.temporal.ChronoUnit;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.UUID;
+import java.util.concurrent.TimeUnit;
+import org.bukkit.event.inventory.ClickType;
+import org.bukkit.event.inventory.InventoryAction;
+import org.bukkit.event.inventory.InventoryType;
+import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.io.TempDir;
+
+class AdminRevivalEventsNativeTest {
+    @TempDir Path data;
+    @BeforeAll static void bootstrap() throws Exception { NativeRuntime.bootstrap(); }
+
+    @Test void registeredSelectionPublishesOneAcknowledgedAdminTailRestorationNotMenuOrRequest() throws Exception {
+        UUID character;
+        try (var f = new FantasyStickLifecycleNativeTest.Fixture(data)) {
+            f.plugin.setEnabled(true);
+            var admin = new FantasyStickLifecycleNativeTest.Actor(data);
+            var target = new FantasyStickLifecycleNativeTest.Actor(data);
+            doReturn("Administrator").when(admin.player).getName();
+            doReturn("Target").when(target.player).getName();
+            doReturn(true).when(admin.player).hasPermission("fantasystick.admin");
+            f.players.put(admin.core.id, admin.player); f.players.put(target.core.id, target.player);
+            f.activate(target);
+            var active = ((games.dmg.fantasystick.session.EquipmentSessions)
+                FantasyStickLifecycleNativeTest.Fixture.field(f.plugin, "sessions"))
+                .active(target.core.id).orElseThrow();
+            var dead = AdminRevivalNativeTest.dead(data, Instant.now().minusSeconds(172800)
+                .truncatedTo(ChronoUnit.SECONDS));
+            character = dead.id();
+            target.core.inventory.setItem(10, new games.dmg.fantasystick.items.TailBooks().create(dead));
+            f.adminCommand.execute(admin.player, "fstickadmin", new String[]{"revive", "Target"});
+            var storage = (games.dmg.fantasystick.persistence.CharacterStorage)
+                FantasyStickLifecycleNativeTest.Fixture.field(f.plugin, "characters");
+            storage.find(dead.id()).get(5, TimeUnit.SECONDS); f.tick();
+            assertEquals(1, admin.inventories.size());
+            assertTrue(revivals().isEmpty(), "Opening the selection is not a revival");
+            var popup = admin.inventories.getFirst();
+            var view = mock(org.bukkit.inventory.InventoryView.class);
+            when(view.getTopInventory()).thenReturn(popup);
+            when(view.getBottomInventory()).thenReturn(admin.core.inventory);
+            when(view.getPlayer()).thenReturn(admin.player);
+            var click = new org.bukkit.event.inventory.InventoryClickEvent(view, InventoryType.SlotType.CONTAINER,
+                0, ClickType.LEFT, InventoryAction.PICKUP_ALL);
+            f.dispatcher.accept(click); assertTrue(click.isCancelled());
+            PartyBookNativeTest.drain(f);
+            var reservations = (games.dmg.fantasystick.persistence.RevivalStore)
+                FantasyStickLifecycleNativeTest.Fixture.field(f.plugin, "revivals");
+            reservations.find(dead.id()).join();
+            for (int i = 0; i < 4; i++) PartyBookNativeTest.drain(f);
+            var saved = storage.find(dead.id()).get(5, TimeUnit.SECONDS).orElseThrow();
+            assertFalse(saved.dead());
+            assertEquals(dead.id(), new games.dmg.fantasystick.items.CharacterSheets()
+                .identify(target.core.inventory.getItem(10)).orElseThrow());
+            for (int i = 0; i < 200 && revivals().isEmpty(); i++) Thread.sleep(10);
+            var own = revivals(); assertEquals(1, own.size());
+            var event = own.getFirst(); var payload = event.getAsJsonObject("data");
+            assertEquals("admin_tail", payload.get("revival_kind").getAsString());
+            assertEquals(admin.core.id.toString(), payload.get("player_id").getAsString());
+            assertEquals(target.core.id.toString(), payload.get("target_player_id").getAsString());
+            assertEquals(dead.id().toString(), payload.get("character_id").getAsString());
+            assertEquals(dead.deathId().toString(), payload.get("death_id").getAsString());
+            assertEquals(dead.revision().toString(), payload.get("revision_before").getAsString());
+            assertEquals(saved.revision().toString(), payload.get("revision_after").getAsString());
+            assertEquals(10, payload.get("tail_slot").getAsInt());
+            assertEquals(active.session().toString(), payload.get("target_session_id").getAsString());
+            assertEquals(active.character().toString(), payload.get("target_active_character_id").getAsString());
+            assertEquals("acknowledged", payload.get("outcome").getAsString());
+            assertEquals(admin.world.getUID().toString(), payload.getAsJsonObject("location").get("world_id").getAsString());
+            assertEquals(target.world.getUID().toString(), payload.getAsJsonObject("target_location").get("world_id").getAsString());
+            f.dispatcher.accept(click);
+            assertEquals(1, revivals().size(), "Repeated selection cannot create another revival");
+        }
+        assertEquals(1, revivals().stream().filter(event -> event.getAsJsonObject("data")
+            .get("character_id").getAsString().equals(character.toString())).count());
+    }
+
+    @Test void registeredTimeoutReadAndAcknowledgedUpdateReachExportedJsonlOnlyAfterSave() throws Exception {
+        try (var f = new FantasyStickLifecycleNativeTest.Fixture(data)) {
+            f.plugin.setEnabled(true);
+            var sender = new EquipmentAdminCommandNativeTest.Sender();
+            f.adminCommand.execute(sender.port, "fstickadmin", new String[]{"config", "admin-revive-selection-timeout-seconds"});
+            f.adminCommand.execute(sender.port, "fstickadmin", new String[]{"config", "admin-revive-selection-timeout-seconds", "90"});
+            assertTrue(sender.messages.getLast().contains("=60"), "Queued save cannot claim an update");
+            var callback = f.tasks.poll(5, TimeUnit.SECONDS); assertNotNull(callback); callback.run();
+            assertTrue(sender.messages.getLast().contains("=90"));
+            for (int i = 0; i < 200 && ownConfig().size() < 2; i++) Thread.sleep(10);
+            var config = ownConfig();
+            assertEquals(1, config.stream().filter(event -> event.get("type").getAsString().endsWith("config.read")).count());
+            var changed = config.stream().filter(event -> event.get("type").getAsString().endsWith("config.changed")).toList();
+            assertEquals(1, changed.size());
+            assertEquals("60", changed.getFirst().getAsJsonObject("data").get("before").getAsString());
+            assertEquals("90", changed.getFirst().getAsJsonObject("data").get("after").getAsString());
+            assertEquals("later_selections", changed.getFirst().getAsJsonObject("data").get("applies_to").getAsString());
+        }
+    }
+
+    @Test void queuedAcknowledgedTimeoutChangesDescribeActualEffectiveTransitions() throws Exception {
+        try (var f = new FantasyStickLifecycleNativeTest.Fixture(data)) {
+            f.plugin.setEnabled(true);
+            var sender = new EquipmentAdminCommandNativeTest.Sender();
+            f.adminCommand.execute(sender.port, "fstickadmin", new String[]{
+                "config", "admin-revive-selection-timeout-seconds", "90"});
+            f.adminCommand.execute(sender.port, "fstickadmin", new String[]{
+                "config", "admin-revive-selection-timeout-seconds", "120"});
+            for (int i = 0; i < 20 && sender.messages.size() < 2; i++) {
+                var callback = f.tasks.poll(5, TimeUnit.SECONDS);
+                assertNotNull(callback, "Both acknowledged configuration responses need a native callback");
+                callback.run();
+            }
+            assertEquals(2, sender.messages.size(), sender.messages.toString());
+            assertTrue(sender.messages.stream().allMatch(message -> message.startsWith("Saved ")),
+                sender.messages.toString());
+            for (int i = 0; i < 200 && ownConfig().stream().filter(event -> event.get("type")
+                .getAsString().endsWith("config.changed")).count() < 2; i++) Thread.sleep(10);
+            f.plugin.setEnabled(false);
+        }
+        var changed = ownConfig().stream().filter(event -> event.get("type").getAsString()
+            .endsWith("config.changed")).map(event -> event.getAsJsonObject("data")).toList();
+        assertEquals(2, changed.size());
+        assertEquals(List.of("60", "90"), changed.stream().map(data -> data.get("before").getAsString()).toList());
+        assertEquals(List.of("90", "120"), changed.stream().map(data -> data.get("after").getAsString()).toList());
+        assertEquals(List.of("90", "120"), changed.stream().map(data -> data.get("effective").getAsString()).toList());
+    }
+
+    @Test void failedAuthoritativeRestorationRetainsProofButExportsNoRevival() throws Exception {
+        try (var f = new FantasyStickLifecycleNativeTest.Fixture(data)) {
+            f.plugin.setEnabled(true);
+            var admin = new FantasyStickLifecycleNativeTest.Actor(data);
+            var target = new FantasyStickLifecycleNativeTest.Actor(data);
+            doReturn("Administrator").when(admin.player).getName();
+            doReturn("Target").when(target.player).getName();
+            doReturn(true).when(admin.player).hasPermission("fantasystick.admin");
+            f.players.put(admin.core.id, admin.player); f.players.put(target.core.id, target.player);
+            var dead = AdminRevivalNativeTest.dead(data, Instant.now().minusSeconds(172800)
+                .truncatedTo(ChronoUnit.SECONDS));
+            target.core.inventory.setItem(10, new games.dmg.fantasystick.items.TailBooks().create(dead));
+            f.adminCommand.execute(admin.player, "fstickadmin", new String[]{"revive", "Target"});
+            PartyBookNativeTest.drain(f);
+            var popup = admin.inventories.getFirst();
+            var corrupted = new java.util.concurrent.atomic.AtomicBoolean();
+            target.core.mutation = () -> {
+                if (!corrupted.compareAndSet(false, true)) return;
+                try {
+                    var path = data.resolve("characters").resolve(dead.id() + ".yml");
+                    Files.delete(path); Files.createDirectory(path);
+                } catch (Exception error) { throw new RuntimeException(error); }
+            };
+            var view = mock(org.bukkit.inventory.InventoryView.class);
+            when(view.getTopInventory()).thenReturn(popup);
+            when(view.getBottomInventory()).thenReturn(admin.core.inventory);
+            when(view.getPlayer()).thenReturn(admin.player);
+            f.dispatcher.accept(new org.bukkit.event.inventory.InventoryClickEvent(view,
+                InventoryType.SlotType.CONTAINER, 0, ClickType.LEFT, InventoryAction.PICKUP_ALL));
+            PartyBookNativeTest.drain(f);
+            var reservations = (games.dmg.fantasystick.persistence.RevivalStore)
+                FantasyStickLifecycleNativeTest.Fixture.field(f.plugin, "revivals");
+            reservations.find(dead.id()).join();
+            for (int i = 0; i < 4; i++) PartyBookNativeTest.drain(f);
+            assertTrue(reservations.find(dead.id()).join().isPresent());
+            assertFalse(admin.messages.stream().anyMatch(message -> message.startsWith("Administratively restored")));
+            target.core.mutation = () -> {};
+            f.plugin.setEnabled(false);
+        }
+        assertTrue(revivals().isEmpty(), "A provisional sheet is not authoritative revival");
+    }
+
+    @Test void failedAuditIntentStoreCannotBlockAcknowledgedAdminTailRestoration() throws Exception {
+        try (var f = new FantasyStickLifecycleNativeTest.Fixture(data)) {
+            f.plugin.setEnabled(true);
+            Files.writeString(data.resolve("admin-revival-event-intents"), "unavailable");
+            var admin = new FantasyStickLifecycleNativeTest.Actor(data);
+            var target = new FantasyStickLifecycleNativeTest.Actor(data);
+            doReturn("Administrator").when(admin.player).getName();
+            doReturn("Target").when(target.player).getName();
+            doReturn(true).when(admin.player).hasPermission("fantasystick.admin");
+            f.players.put(admin.core.id, admin.player); f.players.put(target.core.id, target.player);
+            var dead = AdminRevivalNativeTest.dead(data, Instant.now().minusSeconds(172800)
+                .truncatedTo(ChronoUnit.SECONDS));
+            target.core.inventory.setItem(10, new games.dmg.fantasystick.items.TailBooks().create(dead));
+            f.adminCommand.execute(admin.player, "fstickadmin", new String[]{"revive", "Target"});
+            PartyBookNativeTest.drain(f);
+            var popup = admin.inventories.getFirst();
+            var view = mock(org.bukkit.inventory.InventoryView.class);
+            when(view.getTopInventory()).thenReturn(popup);
+            when(view.getBottomInventory()).thenReturn(admin.core.inventory);
+            when(view.getPlayer()).thenReturn(admin.player);
+            f.dispatcher.accept(new org.bukkit.event.inventory.InventoryClickEvent(view,
+                InventoryType.SlotType.CONTAINER, 0, ClickType.LEFT, InventoryAction.PICKUP_ALL));
+            PartyBookNativeTest.drain(f);
+            ((games.dmg.fantasystick.persistence.RevivalStore)
+                FantasyStickLifecycleNativeTest.Fixture.field(f.plugin, "revivals")).find(dead.id()).join();
+            for (int i = 0; i < 4; i++) PartyBookNativeTest.drain(f);
+            var record = ((games.dmg.fantasystick.persistence.CharacterStorage)
+                FantasyStickLifecycleNativeTest.Fixture.field(f.plugin, "characters"))
+                .find(dead.id()).get(5, TimeUnit.SECONDS).orElseThrow();
+            assertFalse(record.dead());
+            assertEquals(dead.id(), new games.dmg.fantasystick.items.CharacterSheets()
+                .identify(target.core.inventory.getItem(10)).orElseThrow());
+            assertTrue(admin.messages.stream().anyMatch(message -> message.contains("Administratively restored")));
+            f.plugin.setEnabled(false);
+        }
+        assertTrue(revivals().isEmpty(), "An unavailable store cannot assert export or undo gameplay");
+    }
+
+    @Test void confirmedInterruptedAdminReservationReconcilesWithStableIdentityAfterRestart() throws Exception {
+        var target = new FantasyStickLifecycleNativeTest.Actor(data);
+        doReturn("Target").when(target.player).getName();
+        var dead = AdminRevivalNativeTest.dead(data, Instant.now().minusSeconds(172800)
+            .truncatedTo(ChronoUnit.SECONDS));
+        var provisional = new games.dmg.fantasystick.persistence.CharacterRecord(dead.id(), dead.name(),
+            dead.revision(), dead.stats(), dead.level(), dead.experience(), dead.unspentPoints(),
+            dead.maximumHealth(), dead.learned(), dead.loadout(), dead.cooldowns(), dead.restrictedKills(),
+            false, dead.deathId(), dead.diedAt());
+        target.core.inventory.setItem(10, new games.dmg.fantasystick.items.CharacterSheets().create(provisional));
+        var adminId = UUID.randomUUID();
+        var operation = UUID.randomUUID();
+        var reservation = new games.dmg.fantasystick.persistence.RevivalStore.Reservation(operation, adminId,
+            target.core.id, dead.id(), dead.deathId(), Instant.now().truncatedTo(ChronoUnit.SECONDS),
+            10, 1, -1, true);
+        try (var store = new games.dmg.fantasystick.persistence.RevivalStore(data)) {
+            assertTrue(store.reserve(reservation).join().isPresent());
+        }
+        try (var f = new FantasyStickLifecycleNativeTest.Fixture(data)) {
+            f.players.put(target.core.id, target.player); f.plugin.setEnabled(true);
+            var store = (games.dmg.fantasystick.persistence.RevivalStore)
+                FantasyStickLifecycleNativeTest.Fixture.field(f.plugin, "revivals");
+            store.target(target.core.id).join();
+            for (int i = 0; i < 4; i++) PartyBookNativeTest.drain(f);
+            var storage = (games.dmg.fantasystick.persistence.CharacterStorage)
+                FantasyStickLifecycleNativeTest.Fixture.field(f.plugin, "characters");
+            assertFalse(storage.find(dead.id()).get(5, TimeUnit.SECONDS).orElseThrow().dead());
+            for (int i = 0; i < 200 && revivals().isEmpty(); i++) Thread.sleep(10);
+            var entries = revivals(); assertEquals(1, entries.size());
+            var event = entries.getFirst(); var values = event.getAsJsonObject("data");
+            assertEquals(operation.toString(), values.get("revival_operation_id").getAsString());
+            assertEquals(adminId.toString(), values.get("admin_player_id").getAsString());
+            assertEquals("system", values.get("actor_kind").getAsString());
+            assertTrue(values.get("recovery_reconciliation").getAsBoolean());
+            assertEquals("unavailable", values.get("actor_location_status").getAsString());
+            assertEquals(dead.id().toString(), values.get("character_id").getAsString());
+        }
+        try (var restarted = new FantasyStickLifecycleNativeTest.Fixture(data)) {
+            restarted.players.put(target.core.id, target.player); restarted.plugin.setEnabled(true);
+            for (int i = 0; i < 4; i++) PartyBookNativeTest.drain(restarted);
+        }
+        assertEquals(1, revivals().size(), "Reconciliation and a later restart cannot export duplicate success");
+    }
+
+    @Test void deniedInvalidAndFailedTimeoutUpdatesCannotProduceConfigChanged() throws Exception {
+        try (var f = new FantasyStickLifecycleNativeTest.Fixture(data)) {
+            f.plugin.setEnabled(true);
+            var sender = new EquipmentAdminCommandNativeTest.Sender();
+            sender.allowed = false;
+            f.adminCommand.execute(sender.port, "fstickadmin", new String[]{"config", "admin-revive-selection-timeout-seconds", "90"});
+            sender.allowed = true;
+            f.adminCommand.execute(sender.port, "fstickadmin", new String[]{"config", "admin-revive-selection-timeout-seconds", "0"});
+            Files.createDirectory(data.resolve("config.yml"));
+            f.adminCommand.execute(sender.port, "fstickadmin", new String[]{"config", "admin-revive-selection-timeout-seconds", "90"});
+            var callback = f.tasks.poll(5, TimeUnit.SECONDS); assertNotNull(callback); callback.run();
+            assertTrue(sender.messages.getLast().contains("save failed"));
+            f.plugin.setEnabled(false);
+        }
+        assertTrue(ownConfig().stream().noneMatch(event -> event.get("type").getAsString().endsWith("config.changed")));
+    }
+
+    @Test void cancelledOrStaleTailSelectionCannotExportRevival() throws Exception {
+        for (var route : List.of("cancel", "movement", "permission")) {
+            var dir = data.resolve(route); Files.createDirectories(dir);
+            try (var f = new FantasyStickLifecycleNativeTest.Fixture(dir)) {
+                f.plugin.setEnabled(true);
+                var admin = new FantasyStickLifecycleNativeTest.Actor(dir);
+                var target = new FantasyStickLifecycleNativeTest.Actor(dir);
+                doReturn("Administrator").when(admin.player).getName();
+                doReturn("Target").when(target.player).getName();
+                doReturn(true).when(admin.player).hasPermission("fantasystick.admin");
+                f.players.put(admin.core.id, admin.player); f.players.put(target.core.id, target.player);
+                var dead = AdminRevivalNativeTest.dead(dir, Instant.now().minusSeconds(172800)
+                    .truncatedTo(ChronoUnit.SECONDS));
+                var tail = new games.dmg.fantasystick.items.TailBooks().create(dead);
+                target.core.inventory.setItem(10, tail);
+                f.adminCommand.execute(admin.player, "fstickadmin", new String[]{"revive", "Target"});
+                ((games.dmg.fantasystick.persistence.CharacterStorage)
+                    FantasyStickLifecycleNativeTest.Fixture.field(f.plugin, "characters"))
+                    .find(dead.id()).get(5, TimeUnit.SECONDS);
+                f.tick();
+                var popup = admin.inventories.getFirst();
+                if (!route.equals("cancel")) {
+                    if (route.equals("movement")) target.core.inventory.setItem(10,
+                        new org.bukkit.inventory.ItemStack(org.bukkit.Material.DIAMOND));
+                    if (route.equals("permission")) doReturn(false).when(admin.player).hasPermission("fantasystick.admin");
+                    var view = mock(org.bukkit.inventory.InventoryView.class);
+                    when(view.getTopInventory()).thenReturn(popup);
+                    when(view.getBottomInventory()).thenReturn(admin.core.inventory);
+                    when(view.getPlayer()).thenReturn(admin.player);
+                    f.dispatcher.accept(new org.bukkit.event.inventory.InventoryClickEvent(view,
+                        InventoryType.SlotType.CONTAINER, 0, ClickType.LEFT, InventoryAction.PICKUP_ALL));
+                    PartyBookNativeTest.drain(f);
+                }
+                f.plugin.setEnabled(false);
+            }
+            assertTrue(events(dir).stream().noneMatch(event -> event.get("type").getAsString()
+                .endsWith("character.revived")), route + " did not restore an acknowledged character");
+        }
+    }
+
+    private List<JsonObject> revivals() throws Exception {
+        return events().stream().filter(event -> event.get("type").getAsString().endsWith("character.revived"))
+            .filter(event -> event.getAsJsonObject("data").has("revival_kind")
+                && event.getAsJsonObject("data").get("revival_kind").getAsString().equals("admin_tail")).toList();
+    }
+    private List<JsonObject> ownConfig() throws Exception {
+        return events().stream().filter(event -> event.get("type").getAsString().endsWith("config.read")
+            || event.get("type").getAsString().endsWith("config.changed"))
+            .filter(event -> event.getAsJsonObject("data").has("key")
+                && event.getAsJsonObject("data").get("key").getAsString()
+                    .equals("admin-revive-selection-timeout-seconds")).toList();
+    }
+    private List<JsonObject> events() throws Exception { return events(data); }
+    private List<JsonObject> events(Path root) throws Exception {
+        var result = new ArrayList<JsonObject>();
+        if (!Files.isDirectory(root.resolve("events"))) return result;
+        try (var days = Files.list(root.resolve("events"))) {
+            for (var day : days.filter(path -> path.getFileName().toString().matches("\\d{4}-\\d{2}-\\d{2}"))
+                    .toList()) {
+                try (var segments = Files.list(day)) {
+                    for (var file : segments.filter(path -> path.getFileName().toString().startsWith("events-")
+                            && path.getFileName().toString().endsWith(".jsonl")).toList()) {
+                        for (var line : Files.readAllLines(file)) {
+                            if (!line.isBlank()) result.add(JsonParser.parseString(line).getAsJsonObject());
+                        }
+                    }
+                }
+            }
+        }
+        return result;
+    }
+}

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

@@ -326,14 +326,17 @@ class BasicAttackEventsNativeTest {
                                        games.dmg.fantasystick.session.EquipmentSessions sessions,
                                        FantasyStickLifecycleNativeTest.Actor actor) throws Exception {
         var transitioning = (java.util.Map<?, ?>) FantasyStickLifecycleNativeTest.Fixture.field(sessions, "transitioning");
-        for (int i = 0; i < 80; i++) {
+        var deadline = System.nanoTime() + java.util.concurrent.TimeUnit.SECONDS.toNanos(15);
+        while (System.nanoTime() < deadline) {
             if (sessions.active(actor.core.id).isEmpty() && !transitioning.containsKey(actor.core.id)
                     && restoredExitProof(fixture, actor)) return;
-            var task = fixture.tasks.poll(5, java.util.concurrent.TimeUnit.SECONDS);
-            assertNotNull(task, "No exit callback before acknowledged receipt and native RESTORED marker");
-            task.run();
+            // The receipt worker can advance independently of queued main-thread callbacks.
+            var task = fixture.tasks.poll(100, java.util.concurrent.TimeUnit.MILLISECONDS);
+            if (task != null) task.run();
         }
-        fail("Session exit did not clear owned native marker and acknowledged receipt before restart");
+        fail("Session exit did not clear owned native marker and acknowledged receipt before restart; "
+            + "active=" + sessions.active(actor.core.id) + ", transitioning=" + transitioning.containsKey(actor.core.id)
+            + ", marker=" + actor.core.marker() + ", receipt_proof=" + restoredExitProof(fixture, actor));
     }
 
     private static void awaitOrdinaryArrival(FantasyStickLifecycleNativeTest.Fixture fixture,

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

@@ -31,12 +31,12 @@ final class FishingQuestNativeTest {
             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 world=UUID.randomUUID();when(actor.world.getUID()).thenReturn(world);when(actor.world.getName()).thenReturn("Fishing Realm");f.activate(actor);doReturn(null).when(actor.player).getFishHook();
             assertEquals(List.of("fishing"),f.command.tabComplete(actor.player,"fantasystick",new String[]{"adventure-site","place","f"}));
             assertTrue(f.command.tabComplete(actor.player,"fantasystick",new String[]{"adventure-site","place","fishing",""}).contains("--name"));
-            f.command.execute(actor.player,"fantasystick",new String[]{"adventure-site","place","fishing","--name","\"Moonlit Pond\"","--item","\"Silver Scale\"","--required","1","--chance","100","--xp","10","--coins","4","--radius","16","--mode","individual-only"});drain(f);
+            f.command.execute(actor.player,"fantasystick",new String[]{"adventure-site","place","fishing","--name","\"Moonlit Pond\"","--item","\"Silver Scale\"","--required","1","--chance","100","--xp","10","--coins","4","--radius","16","--mode","individual-only"});await(f,()->actor.messages.stream().anyMatch(message->message.contains("Placed fishing site")&&message.contains("Moonlit Pond")));
             var adventures=(AdventureQuestDirectory)FantasyStickLifecycleNativeTest.Fixture.field(f.plugin,"adventureQuests");var fishing=(FishingDirectory)FantasyStickLifecycleNativeTest.Fixture.field(f.plugin,"fishing");var site=adventures.snapshot().sites().getFirst();assertEquals(AdventureQuestState.SiteType.FISHING,site.type());assertEquals("Moonlit Pond",site.name());assertEquals("Silver Scale",site.fishing().itemName());assertEquals(AdventureQuestState.ParticipationMode.INDIVIDUAL_ONLY,site.participationMode());
             f.command.execute(actor.player,"fantasystick",new String[]{"adventure-site","fishing",site.id().toString()});assertTrue(actor.messages.getLast().contains("Silver Scale"));assertEquals(List.of(site.id().toString()),f.command.tabComplete(actor.player,"fantasystick",new String[]{"adventure-site","fishing",""}));
             int before=adventures.snapshot().sites().size();f.command.execute(actor.player,"fantasystick",new String[]{"adventure-site","place","fishing","--name","Broken","--item","X","--required","0","--chance","101","--xp","1","--coins","1"});assertEquals(before,adventures.snapshot().sites().size());
             var oldCatalog=adventures.snapshot().catalog();f.command.execute(actor.player,"fantasystick",new String[]{"adventure","reroll","confirm"});await(f,()->adventures.snapshot().reset()==null&&adventures.snapshot().catalog()!=null&&(oldCatalog==null||!adventures.snapshot().catalog().revision().equals(oldCatalog.revision())));var catalog=adventures.snapshot().catalog();assertTrue(catalog.sites().contains(site.id()));
-            var controller=(AdventureQuestController)FantasyStickLifecycleNativeTest.Fixture.field(f.plugin,"adventureQuestController");controller.open(actor.player);drain(f);var offerMenu=actor.inventories.getLast();var offer=offer(offerMenu,"Moonlit Pond");var lore=plain(offer);assertTrue(lore.stream().anyMatch(line->line.contains("Mode: individual-only")));assertTrue(lore.stream().anyMatch(line->line.contains("Silver Scale × 1")));assertTrue(lore.stream().anyMatch(line->line.contains("Catch chance: 100%")));assertTrue(lore.stream().anyMatch(line->line.contains("10 XP, 4 coins")));click(controller,actor,offerMenu,offer);drain(f);var quest=adventures.active().getFirst();assertNotNull(quest.fishing());UUID stableItem=quest.fishing().itemId();f.command.execute(actor.player,"fantasystick",new String[]{"adventure-site","fishing",site.id().toString(),"--item","\"Golden Scale\"","--required","2","--chance","0","--xp","20","--coins","8","--radius","4"});drain(f);var updatedSite=adventures.findSite(site.id()).orElseThrow();assertEquals(stableItem,updatedSite.fishing().itemId());assertEquals("Golden Scale",updatedSite.fishing().itemName());assertEquals("Silver Scale",quest.fishing().itemName(),"accepted terms remain immutable");assertEquals(16,quest.fishing().radius());actor.core.location.setX(10);
+            var controller=(AdventureQuestController)FantasyStickLifecycleNativeTest.Fixture.field(f.plugin,"adventureQuestController");controller.open(actor.player);drain(f);var offerMenu=actor.inventories.getLast();var offer=offer(offerMenu,"Moonlit Pond");var lore=plain(offer);assertTrue(lore.stream().anyMatch(line->line.contains("Mode: individual-only")));assertTrue(lore.stream().anyMatch(line->line.contains("Silver Scale × 1")));assertTrue(lore.stream().anyMatch(line->line.contains("Catch chance: 100%")));assertTrue(lore.stream().anyMatch(line->line.contains("10 XP, 4 coins")));click(controller,actor,offerMenu,offer);drain(f);var quest=adventures.active().getFirst();assertNotNull(quest.fishing());UUID stableItem=quest.fishing().itemId();f.command.execute(actor.player,"fantasystick",new String[]{"adventure-site","fishing",site.id().toString(),"--item","\"Golden Scale\"","--required","2","--chance","0","--xp","20","--coins","8","--radius","4"});await(f,()->actor.messages.stream().anyMatch(message->message.contains("Updated fishing site")&&message.contains(site.id().toString())));var updatedSite=adventures.findSite(site.id()).orElseThrow();assertEquals(stableItem,updatedSite.fishing().itemId());assertEquals("Golden Scale",updatedSite.fishing().itemName());assertEquals("Silver Scale",quest.fishing().itemName(),"accepted terms remain immutable");assertEquals(16,quest.fishing().radius());actor.core.location.setX(10);
             for(int retry=0;retry<20&&actor.core.inventory.getItem(0).getType()!=Material.FISHING_ROD;retry++){pulse(f);drain(f);}var rod=actor.core.inventory.getItem(0);assertEquals(Material.FISHING_ROD,rod.getType());assertEquals(quest.id(),AdventureQuestNavigation.fishingQuest(rod));assertTrue(rod.getEnchantments().isEmpty());
             var use=new PlayerInteractEvent(actor.player,Action.RIGHT_CLICK_AIR,rod,null,org.bukkit.block.BlockFace.SELF,EquipmentSlot.HAND);f.dispatcher.accept(use);assertNotEquals(org.bukkit.event.Event.Result.DENY,use.useItemInHand(),"owned quest rod keeps native cast/reel mechanics");
             var ordinaryHook=mock(FishHook.class);when(ordinaryHook.getUniqueId()).thenReturn(UUID.randomUUID());var ordinaryEvent=new PlayerFishEvent(actor.player,null,ordinaryHook,EquipmentSlot.HAND,PlayerFishEvent.State.REEL_IN);actor.core.inventory.setItem(0,new ItemStack(Material.FISHING_ROD));f.dispatcher.accept(ordinaryEvent);assertFalse(ordinaryEvent.isCancelled(),"ordinary fishing remains unchanged");actor.core.inventory.setItem(0,rod);
@@ -95,7 +95,7 @@ final class FishingQuestNativeTest {
             var firstCatch=new PlayerFishEvent(actor.player,caught,first,EquipmentSlot.HAND,PlayerFishEvent.State.CAUGHT_FISH);firstCatch.setExpToDrop(6);f.dispatcher.accept(firstCatch);
             assertTrue(firstCatch.isCancelled());assertEquals(0,firstCatch.getExpToDrop());verify(caught).remove();verify(first).remove();
             var storage=(CharacterStorage)FantasyStickLifecycleNativeTest.Fixture.field(f.plugin,"characters");await(f,()->storage.find(actor.core.record.id()).join().orElseThrow().experience().equals(BigInteger.TWO));
-            assertEquals(BigInteger.ZERO,fishing.quantity(actor.core.record.id(),site.fishing().itemId()));assertTrue(actor.messages.stream().anyMatch(message->message.contains("no quest item")));
+            assertEquals(BigInteger.ZERO,fishing.quantity(actor.core.record.id(),site.fishing().itemId()));await(f,()->actor.messages.stream().anyMatch(message->message.contains("no quest item")));assertTrue(actor.messages.stream().anyMatch(message->message.contains("no quest item")));
             var next=mock(FishHook.class);when(next.getUniqueId()).thenReturn(UUID.randomUUID());when(next.getLocation()).thenReturn(actor.core.location.clone());
             f.dispatcher.accept(new PlayerFishEvent(actor.player,null,next,EquipmentSlot.HAND,PlayerFishEvent.State.FISHING));
             f.dispatcher.accept(new PlayerFishEvent(actor.player,caught,first,EquipmentSlot.HAND,PlayerFishEvent.State.CAUGHT_FISH));

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

@@ -28,6 +28,7 @@ class HexNativeTest {
     @BeforeAll static void bootstrap() throws Exception { NativeRuntime.bootstrap(); }
 
     @Test void bookCastActualPreventionAndQualifyingAllyDamagePersistTwoRewardShares() throws Exception {
+        java.util.UUID actorId, characterId, sessionId, enemyId, protectedId, protectedCharacterId, protectedSessionId, worldId;
         try (var f = new FantasyStickLifecycleNativeTest.Fixture(data)) {
             f.plugin.setEnabled(true);
             var a = new FantasyStickLifecycleNativeTest.Actor(data); var b = new FantasyStickLifecycleNativeTest.Actor(data);
@@ -39,11 +40,19 @@ class HexNativeTest {
             assertTrue(book.contains("Hex")); assertTrue(book.contains("CHR14")); assertTrue(book.contains("WIS12"));
             assertFalse(book.contains("Cost:")); assertTrue(book.contains("12")); assertTrue(book.contains("20%")); assertTrue(book.contains("4s"));
             PartyBookNativeTest.click(f, a, abilityButton(a, "[Learn]", "hex")); PartyBookNativeTest.drain(f); PartyBookNativeTest.drain(f);
+            assertTrue(f.feedbackCommand.execute(a.player, "fantasyfeedback", new String[]{"off"})); f.tick();
 
-            var enemy = mock(org.bukkit.entity.LivingEntity.class); var enemyId = java.util.UUID.randomUUID();
+            actorId = a.core.id; characterId = a.core.record.id(); protectedId = b.core.id;
+            protectedCharacterId = b.core.record.id();
+            var activeSessions = (games.dmg.fantasystick.session.EquipmentSessions)
+                FantasyStickLifecycleNativeTest.Fixture.field(f.plugin, "sessions");
+            sessionId = activeSessions.active(actorId).orElseThrow().session();
+            protectedSessionId = activeSessions.active(protectedId).orElseThrow().session();
+            var enemy = mock(org.bukkit.entity.LivingEntity.class); enemyId = java.util.UUID.randomUUID();
             when(enemy.getUniqueId()).thenReturn(enemyId); when(enemy.getType()).thenReturn(org.bukkit.entity.EntityType.ZOMBIE);
-            when(a.world.getUID()).thenReturn(java.util.UUID.randomUUID());
+            worldId = java.util.UUID.randomUUID(); when(a.world.getUID()).thenReturn(worldId);
             doReturn(new Location(a.world, 0, 64, 0)).when(a.player).getLocation();
+            doReturn(new Location(a.world, 0, 64, 1)).when(b.player).getLocation();
             when(enemy.getLocation()).thenReturn(new Location(a.world, 8, 64, 0)); doReturn(true).when(a.player).hasLineOfSight(enemy);
             doReturn(enemy).when(a.player).getTargetEntity(64);
             a.core.inventory.getInventory().setSelectedSlot(2);
@@ -65,6 +74,75 @@ class HexNativeTest {
             assertEquals(BigInteger.valueOf(5), storage.find(a.core.record.id()).get().orElseThrow().experience());
             assertEquals(BigInteger.valueOf(5), storage.find(b.core.record.id()).get().orElseThrow().experience());
         }
+        var own = events(data).stream().filter(event -> event.getAsJsonObject("data").has("ability_id")
+            && event.getAsJsonObject("data").get("ability_id").getAsString().equals("hex")).toList();
+        assertEquals(1, count(own, "ability.learned")); assertEquals(1, count(own, "ability.assigned"));
+        assertEquals(1, count(own, "ability.cast")); assertEquals(1, count(own, "effect.applied"));
+        assertEquals(1, count(own, "combat.prevented")); assertEquals(1, count(own, "effect.ended"));
+        var cast = record(own, "ability.cast"); var applied = record(own, "effect.applied");
+        var prevented = record(own, "combat.prevented"); var ended = record(own, "effect.ended");
+        assertEquals(2, cast.get("slot").getAsInt()); assertTrue(cast.has("cooldown_until"));
+        assertEquals(actorId.toString(), prevented.get("player_id").getAsString());
+        assertEquals(characterId.toString(), prevented.get("character_id").getAsString());
+        assertEquals(sessionId.toString(), prevented.get("session_id").getAsString());
+        assertEquals(enemyId.toString(), prevented.get("debuffed_attacker_id").getAsString());
+        assertEquals(protectedId.toString(), prevented.get("protected_target_id").getAsString());
+        assertEquals(protectedCharacterId.toString(), prevented.get("protected_character_id").getAsString());
+        assertEquals(protectedSessionId.toString(), prevented.get("protected_session_id").getAsString());
+        assertEquals(worldId.toString(), prevented.getAsJsonObject("attacker_location").get("world_id").getAsString());
+        assertEquals(8, prevented.getAsJsonObject("attacker_location").get("x").getAsDouble(), 1.0e-9);
+        assertEquals(worldId.toString(), prevented.getAsJsonObject("protected_location").get("world_id").getAsString());
+        assertEquals(1, prevented.getAsJsonObject("protected_location").get("z").getAsDouble(), 1.0e-9);
+        assertEquals(10, prevented.get("incoming_amount").getAsDouble(), 1.0e-9);
+        assertEquals(8, prevented.get("remaining_amount").getAsDouble(), 1.0e-9);
+        assertEquals(2, prevented.get("actual_amount").getAsDouble(), 1.0e-9);
+        assertEquals(cast.get("action_id").getAsString(), prevented.get("action_id").getAsString());
+        assertEquals(applied.get("application_id").getAsString(), ended.get("application_id").getAsString());
+        assertEquals(applied.get("application_id").getAsString(), prevented.get("effect_application_id").getAsString());
+        assertEquals("interrupted", record(own, "ability.resolved").get("outcome").getAsString());
+    }
+
+    @Test void rejectedEventWriterCannotAlterHexPreventionOrPersistedPartyReward() throws Exception {
+        try (var f = new FantasyStickLifecycleNativeTest.Fixture(data)) {
+            f.plugin.setEnabled(true);
+            var a = new FantasyStickLifecycleNativeTest.Actor(data);
+            var b = new FantasyStickLifecycleNativeTest.Actor(data);
+            withHex(data, a, true);
+            f.players.put(a.core.id, a.player); f.players.put(b.core.id, b.player);
+            f.activate(a); f.activate(b);
+            var parties = PartyLifecycleNativeTest.parties(f); var party = parties.create(a.core.id).orElseThrow();
+            assertTrue(parties.accept(b.core.id, parties.invite(a.core.id, party.id(), b.core.id).orElseThrow().id()));
+            var enemy = mock(org.bukkit.entity.LivingEntity.class);
+            when(enemy.getUniqueId()).thenReturn(java.util.UUID.randomUUID());
+            when(enemy.getType()).thenReturn(org.bukkit.entity.EntityType.ZOMBIE);
+            when(a.world.getUID()).thenReturn(java.util.UUID.randomUUID());
+            doReturn(new Location(a.world, 0, 64, 0)).when(a.player).getLocation();
+            doReturn(new Location(a.world, 1, 64, 0)).when(b.player).getLocation();
+            when(enemy.getLocation()).thenReturn(new Location(a.world, 8, 64, 0));
+            doReturn(true).when(a.player).hasLineOfSight(enemy);
+            doReturn(enemy).when(a.player).getTargetEntity(64);
+            use(f, a); PartyBookNativeTest.drain(f); PartyBookNativeTest.drain(f);
+            ((games.dmg.fantasystick.events.LocalEventLog)
+                FantasyStickLifecycleNativeTest.Fixture.field(f.plugin, "eventLog")).close();
+            var allySource = DamageSource.builder(DamageType.PLAYER_ATTACK)
+                .withCausingEntity(b.player).withDirectEntity(b.player).build();
+            f.dispatcher.accept(new EntityDamageByEntityEvent(b.player, enemy,
+                EntityDamageEvent.DamageCause.ENTITY_ATTACK, allySource, 3));
+            var enemySource = DamageSource.builder(DamageType.MOB_ATTACK)
+                .withCausingEntity(enemy).withDirectEntity(enemy).build();
+            var hit = new EntityDamageByEntityEvent(enemy, b.player,
+                EntityDamageEvent.DamageCause.ENTITY_ATTACK, enemySource, 10);
+            f.dispatcher.accept(hit); assertEquals(8, hit.getDamage(), 1.0e-9);
+            f.dispatcher.accept(new org.bukkit.event.entity.EntityDeathEvent(enemy, allySource,
+                new java.util.ArrayList<>(), 0));
+            for (int i = 0; i < 4; i++) PartyBookNativeTest.drain(f);
+            var storage = (CharacterStorage) FantasyStickLifecycleNativeTest.Fixture.field(f.plugin, "characters");
+            assertEquals(BigInteger.valueOf(5), storage.find(a.core.record.id()).get().orElseThrow().experience());
+            assertEquals(BigInteger.valueOf(5), storage.find(b.core.record.id()).get().orElseThrow().experience());
+            f.plugin.setEnabled(false);
+        }
+        assertEquals(0, events(data).stream().filter(event -> event.get("type").getAsString()
+            .endsWith("combat.prevented")).count());
     }
 
     @Test void trainingDummyConsumesNoOwnedHexEffect() {
@@ -87,10 +165,14 @@ class HexNativeTest {
         try(var f=new FantasyStickLifecycleNativeTest.Fixture(data)){
             f.plugin.setEnabled(true);var a=new FantasyStickLifecycleNativeTest.Actor(data);withHex(data,a,true);f.players.put(a.core.id,a.player);f.activate(a);
             var enemy=mock(org.bukkit.entity.LivingEntity.class);when(enemy.getUniqueId()).thenReturn(java.util.UUID.randomUUID());when(enemy.getType()).thenReturn(org.bukkit.entity.EntityType.ZOMBIE);
+            when(a.world.getUID()).thenReturn(java.util.UUID.randomUUID());
             doReturn(new Location(a.world,0,64,0)).when(a.player).getLocation();when(enemy.getLocation()).thenReturn(new Location(a.world,8,64,0));doReturn(true).when(a.player).hasLineOfSight(enemy);doReturn(enemy).when(a.player).getTargetEntity(64);
             use(f,a);PartyBookNativeTest.drain(f);PartyBookNativeTest.drain(f);use(f,a);PartyBookNativeTest.drain(f);PartyBookNativeTest.drain(f);
             assertEquals(2,f.delayed.size());f.delayed.getFirst().run();
-            var hit=new EntityDamageByEntityEvent(enemy,mock(org.bukkit.entity.Zombie.class),EntityDamageEvent.DamageCause.ENTITY_ATTACK,mock(DamageSource.class),10);
+            var recipient=mock(org.bukkit.entity.Zombie.class);when(recipient.getUniqueId()).thenReturn(java.util.UUID.randomUUID());
+            when(recipient.getType()).thenReturn(org.bukkit.entity.EntityType.ZOMBIE);
+            when(recipient.getLocation()).thenReturn(new Location(a.world,3,64,0));
+            var hit=new EntityDamageByEntityEvent(enemy,recipient,EntityDamageEvent.DamageCause.ENTITY_ATTACK,mock(DamageSource.class),10);
             f.dispatcher.accept(hit);assertEquals(8,hit.getDamage(),1.0e-9);f.delayed.getLast().run();
             var expired=new EntityDamageByEntityEvent(enemy,mock(org.bukkit.entity.Zombie.class),EntityDamageEvent.DamageCause.ENTITY_ATTACK,mock(DamageSource.class),10);
             f.dispatcher.accept(expired);assertEquals(10,expired.getDamage(),1.0e-9);
@@ -98,6 +180,15 @@ class HexNativeTest {
             var exited=new EntityDamageByEntityEvent(enemy,mock(org.bukkit.entity.Zombie.class),EntityDamageEvent.DamageCause.ENTITY_ATTACK,mock(DamageSource.class),10);
             f.dispatcher.accept(exited);assertEquals(10,exited.getDamage(),1.0e-9);
         }
+        var own = events(data).stream().filter(event -> event.getAsJsonObject("data").has("ability_id")
+            && event.getAsJsonObject("data").get("ability_id").getAsString().equals("hex")).toList();
+        assertEquals(3, count(own, "effect.applied"));
+        assertEquals(3, count(own, "effect.ended"));
+        assertEquals(1, count(own, "combat.prevented"));
+        assertEquals(1, own.stream().filter(event -> event.get("type").getAsString().endsWith("ability.resolved")
+            && event.getAsJsonObject("data").get("outcome").getAsString().equals("replaced")).count());
+        assertEquals(1, own.stream().filter(event -> event.get("type").getAsString().endsWith("ability.resolved")
+            && event.getAsJsonObject("data").get("outcome").getAsString().equals("expired")).count());
     }
 
     @Test void latestReplacementOwnsEffectivePreventionSupport() throws Exception {
@@ -109,6 +200,41 @@ class HexNativeTest {
             var storage=(CharacterStorage)FantasyStickLifecycleNativeTest.Fixture.field(f.plugin,"characters");var ax=storage.find(a.core.record.id()).get().orElseThrow().experience();var cx=storage.find(c.core.record.id()).get().orElseThrow().experience();var bx=storage.find(b.core.record.id()).get().orElseThrow().experience();assertEquals(BigInteger.TEN,ax.add(cx).add(bx));assertTrue(List.of(ax,cx,bx).stream().allMatch(value->value.equals(BigInteger.valueOf(3))||value.equals(BigInteger.valueOf(4))));
         }}
 
+    @Test void unusedOrLaterOverriddenDamageCannotClaimHexPrevention() throws Exception {
+        try (var f = new FantasyStickLifecycleNativeTest.Fixture(data)) {
+            f.plugin.setEnabled(true);
+            var a = new FantasyStickLifecycleNativeTest.Actor(data); withHex(data, a, true);
+            f.players.put(a.core.id, a.player); f.activate(a);
+            var enemy = mock(org.bukkit.entity.LivingEntity.class);
+            when(enemy.getUniqueId()).thenReturn(java.util.UUID.randomUUID());
+            when(enemy.getType()).thenReturn(org.bukkit.entity.EntityType.ZOMBIE);
+            when(a.world.getUID()).thenReturn(java.util.UUID.randomUUID());
+            doReturn(new Location(a.world, 0, 64, 0)).when(a.player).getLocation();
+            when(enemy.getLocation()).thenReturn(new Location(a.world, 8, 64, 0));
+            doReturn(true).when(a.player).hasLineOfSight(enemy);
+            doReturn(enemy).when(a.player).getTargetEntity(64);
+            use(f, a); PartyBookNativeTest.drain(f); PartyBookNativeTest.drain(f);
+            var recipient = mock(org.bukkit.entity.Zombie.class);
+            when(recipient.getUniqueId()).thenReturn(java.util.UUID.randomUUID());
+            when(recipient.getType()).thenReturn(org.bukkit.entity.EntityType.ZOMBIE);
+            when(recipient.getLocation()).thenReturn(new Location(a.world, 3, 64, 0));
+            class Override implements org.bukkit.event.Listener {
+                @org.bukkit.event.EventHandler(priority = org.bukkit.event.EventPriority.HIGHEST)
+                public void restore(EntityDamageByEntityEvent event) { event.setDamage(10); }
+            }
+            f.dispatcher.register(new Override(), f.plugin);
+            var source = DamageSource.builder(DamageType.MOB_ATTACK).withCausingEntity(enemy).withDirectEntity(enemy).build();
+            var hit = new EntityDamageByEntityEvent(enemy, recipient, EntityDamageEvent.DamageCause.ENTITY_ATTACK,
+                source, 10);
+            f.dispatcher.accept(hit); assertEquals(10, hit.getDamage(), 1.0e-9);
+            f.plugin.setEnabled(false);
+        }
+        var own = events(data).stream().filter(event -> event.getAsJsonObject("data").has("ability_id")
+            && event.getAsJsonObject("data").get("ability_id").getAsString().equals("hex")).toList();
+        assertEquals(1, count(own, "effect.applied"));
+        assertEquals(0, count(own, "combat.prevented"));
+    }
+
     @Test void unusedProtectionCannotManufactureSupportShare() throws Exception {
         try(var f=new FantasyStickLifecycleNativeTest.Fixture(data)){
             f.plugin.setEnabled(true);var a=new FantasyStickLifecycleNativeTest.Actor(data);var b=new FantasyStickLifecycleNativeTest.Actor(data);withHex(data,a,true);
@@ -124,6 +250,55 @@ class HexNativeTest {
         }
     }
 
+    @Test void failedPreventionFeedbackCannotInterruptNativeDamageOrOwnerAudit() {
+        var sessions = mock(games.dmg.fantasystick.session.EquipmentSessions.class);
+        var parties = mock(games.dmg.fantasystick.party.PartyRoster.class);
+        var mitigation = new games.dmg.fantasystick.ability.OutgoingDamageMitigation(sessions, parties, ignored -> {});
+        var execution = mock(games.dmg.fantasystick.ability.AbilityExecution.class);
+        when(execution.stillCurrent()).thenReturn(true);
+        doThrow(new IllegalStateException("simulated feedback failure")).when(execution).report(any(), any(), any());
+        var attacker = mock(org.bukkit.entity.Zombie.class);
+        when(attacker.getUniqueId()).thenReturn(java.util.UUID.randomUUID());
+        var target = mock(org.bukkit.entity.Zombie.class);
+        var accepted = new java.util.ArrayList<games.dmg.fantasystick.ability.OutgoingDamageMitigation.Accepted>();
+        mitigation.grantObserved(execution, attacker, new java.math.BigDecimal("20"), accepted::add);
+        var source = DamageSource.builder(DamageType.MOB_ATTACK).withCausingEntity(attacker).withDirectEntity(attacker).build();
+        var hit = new EntityDamageByEntityEvent(attacker, target, EntityDamageEvent.DamageCause.ENTITY_ATTACK, source, 10);
+        mitigation.reduce(hit); assertEquals(8, hit.getDamage(), 1.0e-9);
+        assertDoesNotThrow(() -> mitigation.accepted(hit));
+        assertEquals(1, accepted.size()); assertEquals(2, accepted.getFirst().prevented(), 1.0e-9);
+        mitigation.close();
+    }
+
+    @Test void failedCooldownSaveCannotPublishHexEffectOrPrevention() throws Exception {
+        try (var f = new FantasyStickLifecycleNativeTest.Fixture(data)) {
+            f.plugin.setEnabled(true);
+            var a = new FantasyStickLifecycleNativeTest.Actor(data); withHex(data, a, true);
+            f.players.put(a.core.id, a.player); f.activate(a);
+            var enemy = mock(org.bukkit.entity.LivingEntity.class);
+            when(enemy.getUniqueId()).thenReturn(java.util.UUID.randomUUID());
+            when(enemy.getType()).thenReturn(org.bukkit.entity.EntityType.ZOMBIE);
+            when(a.world.getUID()).thenReturn(java.util.UUID.randomUUID());
+            doReturn(new Location(a.world, 0, 64, 0)).when(a.player).getLocation();
+            when(enemy.getLocation()).thenReturn(new Location(a.world, 8, 64, 0));
+            doReturn(true).when(a.player).hasLineOfSight(enemy);
+            doReturn(enemy).when(a.player).getTargetEntity(64);
+            ((CharacterStorage) FantasyStickLifecycleNativeTest.Fixture.field(f.plugin, "characters")).close();
+            use(f, a); var response = f.tasks.poll(5, java.util.concurrent.TimeUnit.SECONDS);
+            assertNotNull(response); response.run();
+            var hit = new EntityDamageByEntityEvent(enemy, mock(org.bukkit.entity.Zombie.class),
+                EntityDamageEvent.DamageCause.ENTITY_ATTACK, mock(DamageSource.class), 10);
+            f.dispatcher.accept(hit); assertEquals(10, hit.getDamage(), 1.0e-9);
+            f.plugin.setEnabled(false);
+        }
+        var own = events(data).stream().filter(event -> event.getAsJsonObject("data").has("ability_id")
+            && event.getAsJsonObject("data").get("ability_id").getAsString().equals("hex")).toList();
+        assertEquals(0, count(own, "ability.cast"));
+        assertEquals(0, count(own, "effect.applied"));
+        assertEquals(0, count(own, "combat.prevented"));
+        assertEquals("failed", record(own, "ability.resolved").get("outcome").getAsString());
+    }
+
     @Test void failedCooldownPersistenceAppliesNoHex() {
         var storage=mock(CharacterStorage.class);var sessions=mock(games.dmg.fantasystick.session.EquipmentSessions.class);var parties=new games.dmg.fantasystick.party.PartyRoster(java.time.Clock.systemUTC(),ignored->true);
         var mitigation=new games.dmg.fantasystick.ability.OutgoingDamageMitigation(sessions,parties,ignored->{});var hex=new games.dmg.fantasystick.ability.Hex(games.dmg.fantasystick.ability.Hex.Settings.defaults(),mitigation);var registry=new games.dmg.fantasystick.ability.AbilityRegistry();registry.register(hex.definition());
@@ -139,11 +314,15 @@ class HexNativeTest {
     @Test void cancelledDamageCreatesNoReductionOrSupportButRetainsAcknowledgedCooldown() throws Exception {
         try(var f=new FantasyStickLifecycleNativeTest.Fixture(data)){f.plugin.setEnabled(true);var a=new FantasyStickLifecycleNativeTest.Actor(data);var b=new FantasyStickLifecycleNativeTest.Actor(data);withHex(data,a,true);
             f.players.put(a.core.id,a.player);f.players.put(b.core.id,b.player);f.activate(a);f.activate(b);var parties=PartyLifecycleNativeTest.parties(f);var party=parties.create(a.core.id).orElseThrow();assertTrue(parties.accept(b.core.id,parties.invite(a.core.id,party.id(),b.core.id).orElseThrow().id()));
-            var enemy=mock(org.bukkit.entity.LivingEntity.class);when(enemy.getUniqueId()).thenReturn(java.util.UUID.randomUUID());when(enemy.getType()).thenReturn(org.bukkit.entity.EntityType.ZOMBIE);doReturn(new Location(a.world,0,64,0)).when(a.player).getLocation();when(enemy.getLocation()).thenReturn(new Location(a.world,8,64,0));doReturn(true).when(a.player).hasLineOfSight(enemy);doReturn(enemy).when(a.player).getTargetEntity(64);use(f,a);PartyBookNativeTest.drain(f);PartyBookNativeTest.drain(f);
-            class Veto implements org.bukkit.event.Listener{@org.bukkit.event.EventHandler(priority=org.bukkit.event.EventPriority.LOWEST)public void damage(EntityDamageByEntityEvent event){if(event.getDamager()==enemy)event.setCancelled(true);}}
-            f.dispatcher.register(new Veto(),f.plugin);var source=DamageSource.builder(DamageType.MOB_ATTACK).withCausingEntity(enemy).withDirectEntity(enemy).build();var hit=new EntityDamageByEntityEvent(enemy,b.player,EntityDamageEvent.DamageCause.ENTITY_ATTACK,source,10);f.dispatcher.accept(hit);assertTrue(hit.isCancelled());assertEquals(10,hit.getDamage(),1.0e-9);
+            var enemy=mock(org.bukkit.entity.LivingEntity.class);when(enemy.getUniqueId()).thenReturn(java.util.UUID.randomUUID());when(enemy.getType()).thenReturn(org.bukkit.entity.EntityType.ZOMBIE);when(a.world.getUID()).thenReturn(java.util.UUID.randomUUID());doReturn(new Location(a.world,0,64,0)).when(a.player).getLocation();when(enemy.getLocation()).thenReturn(new Location(a.world,8,64,0));doReturn(true).when(a.player).hasLineOfSight(enemy);doReturn(enemy).when(a.player).getTargetEntity(64);use(f,a);PartyBookNativeTest.drain(f);PartyBookNativeTest.drain(f);
+            class Veto implements org.bukkit.event.Listener{@org.bukkit.event.EventHandler(priority=org.bukkit.event.EventPriority.HIGHEST)public void damage(EntityDamageByEntityEvent event){if(event.getDamager()==enemy)event.setCancelled(true);}}
+            f.dispatcher.register(new Veto(),f.plugin);var source=DamageSource.builder(DamageType.MOB_ATTACK).withCausingEntity(enemy).withDirectEntity(enemy).build();var hit=new EntityDamageByEntityEvent(enemy,b.player,EntityDamageEvent.DamageCause.ENTITY_ATTACK,source,10);f.dispatcher.accept(hit);assertTrue(hit.isCancelled());assertEquals(8,hit.getDamage(),1.0e-9);
             var storage=(CharacterStorage)FantasyStickLifecycleNativeTest.Fixture.field(f.plugin,"characters");assertNotNull(storage.find(a.core.record.id()).get().orElseThrow().cooldowns().get("hex"));
         }
+        var own = events(data).stream().filter(event -> event.getAsJsonObject("data").has("ability_id")
+            && event.getAsJsonObject("data").get("ability_id").getAsString().equals("hex")).toList();
+        assertEquals(1, count(own, "effect.applied"));
+        assertEquals(0, count(own, "combat.prevented"), "Cancellation after the outgoing stage cannot claim real prevention");
     }
 
     @Test void unlearnRelearnAndTransferRetainCooldownAndClearOwnedPenalty() throws Exception {
@@ -176,6 +355,38 @@ class HexNativeTest {
         for(String invalid:List.of("hex-cooldown-seconds: -1\n","hex-range-blocks: 0\n","hex-duration-seconds: 0\n","hex-damage-reduction-percent: 101\n")){var dir=data.resolve(Integer.toHexString(invalid.hashCode()));java.nio.file.Files.createDirectories(dir);java.nio.file.Files.writeString(dir.resolve("config.yml"),invalid);try(var f=new FantasyStickLifecycleNativeTest.Fixture(dir)){assertThrows(IllegalArgumentException.class,()->f.plugin.setEnabled(true));assertTrue(f.order.isEmpty());}}
     }
 
+    @Test void authorizedHexConfigurationReadAndAcknowledgedChangeReachJsonlOnlyAfterSave() throws Exception {
+        try (var f = new FantasyStickLifecycleNativeTest.Fixture(data)) {
+            f.plugin.setEnabled(true);
+            var admin = new EquipmentAdminCommandNativeTest.Sender(); admin.allowed = true;
+            f.command.execute(admin.port, "fstickadmin", new String[]{"config", "hex-damage-reduction-percent"});
+            assertTrue(admin.messages.getLast().contains("hex-damage-reduction-percent=20"));
+            f.command.execute(admin.port, "fstickadmin", new String[]{"config", "hex-damage-reduction-percent", "30"});
+            var response = f.tasks.poll(5, java.util.concurrent.TimeUnit.SECONDS); assertNotNull(response); response.run();
+            var registry = (games.dmg.fantasystick.ability.AbilityRegistry)
+                FantasyStickLifecycleNativeTest.Fixture.field(f.plugin, "abilityRegistry");
+            assertEquals(new java.math.BigDecimal("30"), registry.find("hex").orElseThrow()
+                .parameters().get("damage-reduction-percent"));
+            try (var channel = java.nio.channels.FileChannel.open(data.resolve(".config.lock"),
+                    java.nio.file.StandardOpenOption.CREATE, java.nio.file.StandardOpenOption.WRITE);
+                 var lock = channel.lock()) {
+                assertTrue(lock.isValid());
+                f.command.execute(admin.port, "fstickadmin", new String[]{"config", "hex-damage-reduction-percent", "40"});
+                var failed = f.tasks.poll(5, java.util.concurrent.TimeUnit.SECONDS); assertNotNull(failed); failed.run();
+            }
+            admin.allowed = false;
+            f.command.execute(admin.port, "fstickadmin", new String[]{"config", "hex-damage-reduction-percent"});
+            f.plugin.setEnabled(false);
+        }
+        var config = events(data).stream().filter(event -> event.getAsJsonObject("data").has("ability_id")
+            && event.getAsJsonObject("data").get("ability_id").getAsString().equals("hex")
+            && (event.get("type").getAsString().endsWith("config.read")
+                || event.get("type").getAsString().endsWith("config.changed"))).toList();
+        assertEquals(2, config.size());
+        assertEquals("20", config.getLast().getAsJsonObject("data").get("before").getAsString());
+        assertEquals("30", config.getLast().getAsJsonObject("data").get("after").getAsString());
+    }
+
     @Test void partyAndMixedModeAimedPlayersRefuseWithoutCooldown() throws Exception {
         for(int route=0;route<2;route++){var dir=data.resolve("player-refused-"+route);try(var f=new FantasyStickLifecycleNativeTest.Fixture(dir)){f.plugin.setEnabled(true);var a=new FantasyStickLifecycleNativeTest.Actor(dir);withHex(dir,a,true);f.players.put(a.core.id,a.player);f.activate(a);org.bukkit.entity.Player target;
             if(route==0){var b=new FantasyStickLifecycleNativeTest.Actor(dir);target=b.player;f.players.put(b.core.id,b.player);f.activate(b);var parties=PartyLifecycleNativeTest.parties(f);var party=parties.create(a.core.id).orElseThrow();assertTrue(parties.accept(b.core.id,parties.invite(a.core.id,party.id(),b.core.id).orElseThrow().id()));}else{target=mock(org.bukkit.entity.Player.class);when(target.getUniqueId()).thenReturn(java.util.UUID.randomUUID());}
@@ -184,8 +395,35 @@ class HexNativeTest {
 
     @Test void firstAimedOutOfRangeOrObstructedTargetRefusesWithoutFallbackOrCooldown() throws Exception {
         for(int route=0;route<2;route++){var dir=data.resolve("refused-"+route);try(var f=new FantasyStickLifecycleNativeTest.Fixture(dir)){f.plugin.setEnabled(true);var a=new FantasyStickLifecycleNativeTest.Actor(dir);withHex(dir,a,true);f.players.put(a.core.id,a.player);f.activate(a);
-            var enemy=mock(org.bukkit.entity.LivingEntity.class);when(enemy.getUniqueId()).thenReturn(java.util.UUID.randomUUID());when(enemy.getType()).thenReturn(org.bukkit.entity.EntityType.ZOMBIE);doReturn(new Location(a.world,0,64,0)).when(a.player).getLocation();when(enemy.getLocation()).thenReturn(new Location(a.world,route==0?13:8,64,0));doReturn(route==0).when(a.player).hasLineOfSight(enemy);doReturn(enemy).when(a.player).getTargetEntity(64);use(f,a);PartyBookNativeTest.drain(f);
-            var storage=(CharacterStorage)FantasyStickLifecycleNativeTest.Fixture.field(f.plugin,"characters");assertFalse(storage.find(a.core.record.id()).get().orElseThrow().cooldowns().containsKey("hex"));}}
+            var enemy=mock(org.bukkit.entity.LivingEntity.class);when(enemy.getUniqueId()).thenReturn(java.util.UUID.randomUUID());when(enemy.getType()).thenReturn(org.bukkit.entity.EntityType.ZOMBIE);when(a.world.getUID()).thenReturn(java.util.UUID.randomUUID());doReturn(new Location(a.world,0,64,0)).when(a.player).getLocation();when(enemy.getLocation()).thenReturn(new Location(a.world,route==0?13:8,64,0));doReturn(route==0).when(a.player).hasLineOfSight(enemy);doReturn(enemy).when(a.player).getTargetEntity(64);use(f,a);PartyBookNativeTest.drain(f);
+            var storage=(CharacterStorage)FantasyStickLifecycleNativeTest.Fixture.field(f.plugin,"characters");assertFalse(storage.find(a.core.record.id()).get().orElseThrow().cooldowns().containsKey("hex"));}
+            var own = events(dir).stream().filter(event -> event.getAsJsonObject("data").has("ability_id")
+                && event.getAsJsonObject("data").get("ability_id").getAsString().equals("hex")).toList();
+            assertEquals(0, count(own, "ability.cast"));
+            assertEquals(0, count(own, "effect.applied"));
+            assertEquals("refused", record(own, "ability.resolved").get("outcome").getAsString());
+        }
+    }
+
+    private static java.util.List<com.google.gson.JsonObject> events(Path data) throws Exception {
+        var results = new java.util.ArrayList<com.google.gson.JsonObject>();
+        try (var days = java.nio.file.Files.list(data.resolve("events"))) {
+            for (var day : days.filter(path -> path.getFileName().toString().matches("\\d{4}-\\d{2}-\\d{2}")).toList()) {
+                try (var segments = java.nio.file.Files.list(day)) {
+                    for (var path : segments.filter(file -> file.getFileName().toString().endsWith(".jsonl")).toList())
+                        for (var line : java.nio.file.Files.readAllLines(path))
+                            if (!line.isBlank()) results.add(com.google.gson.JsonParser.parseString(line).getAsJsonObject());
+                }
+            }
+        }
+        return results;
+    }
+    private static long count(java.util.List<com.google.gson.JsonObject> own, String suffix) {
+        return own.stream().filter(event -> event.get("type").getAsString().endsWith(suffix)).count();
+    }
+    private static com.google.gson.JsonObject record(java.util.List<com.google.gson.JsonObject> own, String suffix) {
+        return own.stream().filter(event -> event.get("type").getAsString().endsWith(suffix))
+            .findFirst().orElseThrow().getAsJsonObject("data");
     }
 
     private static void learnAndAssign(FantasyStickLifecycleNativeTest.Fixture f,FantasyStickLifecycleNativeTest.Actor a)throws Exception{a.core.inventory.getInventory().setSelectedSlot(0);PartyBookNativeTest.open(f,a);PartyBookNativeTest.click(f,a,abilityButton(a,"[Learn]","hex"));PartyBookNativeTest.drain(f);PartyBookNativeTest.drain(f);}

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

@@ -2,24 +2,223 @@ package games.dmg.fantasystick;
 import static org.junit.jupiter.api.Assertions.*;import static org.mockito.Mockito.*;
 import games.dmg.fantasystick.persistence.*;import games.dmg.fantasystick.progression.Stat;import java.math.BigInteger;import java.nio.file.Path;import java.util.*;import net.minecraft.network.chat.ClickEvent;import org.bukkit.event.player.PlayerInteractEvent;import org.bukkit.inventory.EquipmentSlot;import org.junit.jupiter.api.*;import org.junit.jupiter.api.io.TempDir;
 class InspireNativeTest{@TempDir Path data;@BeforeAll static void bootstrap()throws Exception{NativeRuntime.bootstrap();}
+ @Test void registeredBookSelfCastExpiryReachesExportedJsonlWithoutInventingPrevention()throws Exception{
+  UUID playerId,characterId,sessionId;
+  try(var f=new FantasyStickLifecycleNativeTest.Fixture(data)){
+   f.plugin.setEnabled(true);var actor=new FantasyStickLifecycleNativeTest.Actor(data);withInspire(data,actor,false);
+   f.players.put(actor.core.id,actor.player);f.activate(actor);playerId=actor.core.id;characterId=actor.core.record.id();
+   var sessions=(games.dmg.fantasystick.session.EquipmentSessions)FantasyStickLifecycleNativeTest.Fixture.field(f.plugin,"sessions");
+   sessionId=sessions.active(playerId).orElseThrow().session();
+   learnAndAssign(f,actor);var absorption=new java.util.concurrent.atomic.AtomicReference<>(2.0);
+   doAnswer(call->absorption.get()).when(actor.player).getAbsorptionAmount();
+   doAnswer(call->{absorption.set(call.getArgument(0));return null;}).when(actor.player).setAbsorptionAmount(anyDouble());
+   doReturn(true).when(actor.player).isSneaking();use(f,actor);PartyBookNativeTest.drain(f);PartyBookNativeTest.drain(f);
+   assertEquals(7,absorption.get(),1e-9);f.delayed.getLast().run();assertEquals(2,absorption.get(),1e-9);
+  }
+  var own=inspireEvents(data);assertEquals(1,count(own,"ability.learned"));assertEquals(1,count(own,"ability.assigned"));
+  assertEquals(1,count(own,"ability.cast"));assertEquals(1,count(own,"effect.applied"));
+  assertEquals(1,count(own,"effect.ended"));assertEquals(0,count(own,"combat.prevented"));
+  var cast=record(own,"ability.cast");var applied=record(own,"effect.applied");var ended=record(own,"effect.ended");
+  assertEquals(playerId.toString(),cast.get("player_id").getAsString());
+  assertEquals(characterId.toString(),cast.get("character_id").getAsString());
+  assertEquals(sessionId.toString(),cast.get("session_id").getAsString());
+  assertTrue(cast.has("cooldown_until"));assertEquals("5",applied.get("granted_amount").getAsString());
+  assertEquals(applied.get("application_id").getAsString(),ended.get("application_id").getAsString());
+  assertEquals("5",ended.get("remaining_amount").getAsString(),"unused native protection expires without prevention");
+  assertEquals("expired",ended.get("reason").getAsString());
+  assertEquals("expired",record(own,"ability.resolved").get("outcome").getAsString());
+ }
+ @Test void registeredAllyAbsorptionRecordsOnlyObservedConsumedHealth()throws Exception{
+  UUID actorId,characterId,sessionId,targetId,targetCharacterId,targetSessionId,worldId;
+  try(var f=new FantasyStickLifecycleNativeTest.Fixture(data)){
+   f.plugin.setEnabled(true);var a=new FantasyStickLifecycleNativeTest.Actor(data);var b=new FantasyStickLifecycleNativeTest.Actor(data);
+   withInspire(data,a,true);f.players.put(a.core.id,a.player);f.players.put(b.core.id,b.player);f.activate(a);f.activate(b);
+   var sessions=(games.dmg.fantasystick.session.EquipmentSessions)FantasyStickLifecycleNativeTest.Fixture.field(f.plugin,"sessions");
+   actorId=a.core.id;characterId=a.core.record.id();sessionId=sessions.active(actorId).orElseThrow().session();
+   targetId=b.core.id;targetCharacterId=b.core.record.id();targetSessionId=sessions.active(targetId).orElseThrow().session();
+   worldId=UUID.randomUUID();when(a.world.getUID()).thenReturn(worldId);
+   doReturn(false).when(a.player).isSneaking();doReturn(new org.bukkit.Location(a.world,0,64,0)).when(a.player).getLocation();
+   doReturn(new org.bukkit.Location(a.world,8,64,0)).when(b.player).getLocation();
+   doReturn(true).when(a.player).hasLineOfSight(b.player);doReturn(b.player).when(a.player).getTargetEntity(64);
+   var absorption=new java.util.concurrent.atomic.AtomicReference<>(0.0);
+   doAnswer(call->absorption.get()).when(b.player).getAbsorptionAmount();
+   doAnswer(call->{absorption.set(call.getArgument(0));return null;}).when(b.player).setAbsorptionAmount(anyDouble());
+   assertTrue(f.feedbackCommand.execute(a.player,"fantasyfeedback",new String[]{"off"}));f.tick();
+   use(f,a);PartyBookNativeTest.drain(f);PartyBookNativeTest.drain(f);assertEquals(5,absorption.get(),1e-9);
+   var enemy=mock(org.bukkit.entity.LivingEntity.class);when(enemy.getUniqueId()).thenReturn(UUID.randomUUID());
+   when(enemy.getType()).thenReturn(org.bukkit.entity.EntityType.ZOMBIE);
+   when(enemy.getLocation()).thenReturn(new org.bukkit.Location(a.world,8,64,1));
+   var source=org.bukkit.damage.DamageSource.builder(org.bukkit.damage.DamageType.MOB_ATTACK)
+    .withCausingEntity(enemy).withDirectEntity(enemy).build();
+   var cancelled=new org.bukkit.event.entity.EntityDamageByEntityEvent(enemy,b.player,
+    org.bukkit.event.entity.EntityDamageEvent.DamageCause.ENTITY_ATTACK,source,3);cancelled.setCancelled(true);
+   f.dispatcher.accept(cancelled);PartyBookNativeTest.drain(f);assertEquals(5,absorption.get(),1e-9);
+   var hit=new org.bukkit.event.entity.EntityDamageByEntityEvent(enemy,b.player,
+    org.bukkit.event.entity.EntityDamageEvent.DamageCause.ENTITY_ATTACK,source,3);
+   f.dispatcher.accept(hit);absorption.set(2.0);PartyBookNativeTest.drain(f);
+   assertEquals(2,absorption.get(),1e-9);
+  }
+  var own=inspireEvents(data);assertEquals(1,count(own,"ability.cast"));assertEquals(1,count(own,"effect.applied"));
+  assertEquals(1,count(own,"combat.prevented"));var consumed=record(own,"combat.prevented");
+  assertEquals(actorId.toString(),consumed.get("player_id").getAsString());
+  assertEquals(characterId.toString(),consumed.get("character_id").getAsString());
+  assertEquals(sessionId.toString(),consumed.get("session_id").getAsString());
+  assertEquals(targetId.toString(),consumed.get("protected_target_id").getAsString());
+  assertEquals(targetCharacterId.toString(),consumed.get("protected_character_id").getAsString());
+  assertEquals(targetSessionId.toString(),consumed.get("protected_session_id").getAsString());
+  assertEquals(worldId.toString(),consumed.getAsJsonObject("protected_location").get("world_id").getAsString());
+  assertEquals(8,consumed.getAsJsonObject("protected_location").get("x").getAsDouble(),1e-9);
+  assertEquals(3,consumed.get("actual_amount").getAsDouble(),1e-9);
+  assertEquals(record(own,"ability.cast").get("action_id").getAsString(),consumed.get("action_id").getAsString());
+  assertEquals(record(own,"effect.applied").get("application_id").getAsString(),consumed.get("effect_application_id").getAsString());
+ }
+ @Test void unavailableAuditOnlyAttackerLocationCannotInterruptNativeAbsorption()throws Exception{
+  try(var f=new FantasyStickLifecycleNativeTest.Fixture(data)){
+   f.plugin.setEnabled(true);var a=new FantasyStickLifecycleNativeTest.Actor(data);withInspire(data,a,true);
+   f.players.put(a.core.id,a.player);f.activate(a);var absorption=new java.util.concurrent.atomic.AtomicReference<>(0.0);
+   doAnswer(call->absorption.get()).when(a.player).getAbsorptionAmount();
+   doAnswer(call->{absorption.set(call.getArgument(0));return null;}).when(a.player).setAbsorptionAmount(anyDouble());
+   doReturn(true).when(a.player).isSneaking();use(f,a);PartyBookNativeTest.drain(f);PartyBookNativeTest.drain(f);
+   var enemy=mock(org.bukkit.entity.Zombie.class);when(enemy.getUniqueId()).thenReturn(UUID.randomUUID());
+   when(enemy.getLocation()).thenThrow(new IllegalStateException("unavailable audit location"));
+   var source=org.bukkit.damage.DamageSource.builder(org.bukkit.damage.DamageType.MOB_ATTACK)
+    .withCausingEntity(enemy).withDirectEntity(enemy).build();
+   var hit=new org.bukkit.event.entity.EntityDamageByEntityEvent(enemy,a.player,
+    org.bukkit.event.entity.EntityDamageEvent.DamageCause.ENTITY_ATTACK,source,3);
+   var owner=(games.dmg.fantasystick.ability.TemporaryHealth)FantasyStickLifecycleNativeTest.Fixture.field(f.plugin,"temporaryHealth");
+   owner.damage(hit);absorption.set(2.0);PartyBookNativeTest.drain(f);assertEquals(2,absorption.get(),1e-9);
+  }
+  var own=inspireEvents(data);assertEquals(1,count(own,"combat.prevented"));
+  assertFalse(record(own,"combat.prevented").has("attacker_location"));
+ }
+ @Test void rejectedNativeAbsorptionSetterCannotLeaveAnOrphanOwnedGrant()throws Exception{
+  var attempts=new java.util.concurrent.atomic.AtomicInteger();
+  try(var f=new FantasyStickLifecycleNativeTest.Fixture(data)){
+   f.plugin.setEnabled(true);var a=new FantasyStickLifecycleNativeTest.Actor(data);withInspire(data,a,true);
+   f.players.put(a.core.id,a.player);f.activate(a);
+   doReturn(0.0).when(a.player).getAbsorptionAmount();
+   doAnswer(call->{if(attempts.incrementAndGet()==1)throw new IllegalStateException("native refused");
+    return null;}).when(a.player).setAbsorptionAmount(anyDouble());
+   doReturn(true).when(a.player).isSneaking();use(f,a);PartyBookNativeTest.drain(f);PartyBookNativeTest.drain(f);
+   assertEquals(1,attempts.get(),"native admission was attempted once");
+  }
+  assertEquals(1,attempts.get(),"an unadmitted effect must not be cleaned up as an owned native grant");
+  var own=inspireEvents(data);assertEquals(1,count(own,"ability.cast"));
+  assertEquals(0,count(own,"effect.applied"));assertEquals(0,count(own,"combat.prevented"));
+  assertEquals("failed",record(own,"ability.resolved").get("outcome").getAsString());
+ }
+ @Test void duplicateNativeCallbackCannotDoubleClaimOneAbsorptionDrop()throws Exception{
+  try(var f=new FantasyStickLifecycleNativeTest.Fixture(data)){
+   f.plugin.setEnabled(true);var a=new FantasyStickLifecycleNativeTest.Actor(data);withInspire(data,a,true);
+   f.players.put(a.core.id,a.player);f.activate(a);var absorption=new java.util.concurrent.atomic.AtomicReference<>(0.0);
+   doAnswer(call->absorption.get()).when(a.player).getAbsorptionAmount();
+   doAnswer(call->{absorption.set(call.getArgument(0));return null;}).when(a.player).setAbsorptionAmount(anyDouble());
+   doReturn(true).when(a.player).isSneaking();use(f,a);PartyBookNativeTest.drain(f);PartyBookNativeTest.drain(f);
+   assertEquals(5,absorption.get(),1e-9);
+   var enemy=mock(org.bukkit.entity.Zombie.class);when(enemy.getUniqueId()).thenReturn(UUID.randomUUID());
+   var source=org.bukkit.damage.DamageSource.builder(org.bukkit.damage.DamageType.MOB_ATTACK)
+    .withCausingEntity(enemy).withDirectEntity(enemy).build();
+   var hit=new org.bukkit.event.entity.EntityDamageByEntityEvent(enemy,a.player,
+    org.bukkit.event.entity.EntityDamageEvent.DamageCause.ENTITY_ATTACK,source,3);
+   f.dispatcher.accept(hit);f.dispatcher.accept(hit);absorption.set(2.0);PartyBookNativeTest.drain(f);
+   assertEquals(2,absorption.get(),1e-9);
+  }
+  var own=inspireEvents(data);assertEquals(1,count(own,"combat.prevented"));
+  assertEquals(3,record(own,"combat.prevented").get("actual_amount").getAsDouble(),1e-9);
+ }
+ @Test void rejectedWriterCannotChangeNativeAbsorptionOrInventPrevention()throws Exception{
+  try(var f=new FantasyStickLifecycleNativeTest.Fixture(data)){
+   f.plugin.setEnabled(true);var a=new FantasyStickLifecycleNativeTest.Actor(data);withInspire(data,a,true);
+   f.players.put(a.core.id,a.player);f.activate(a);var absorption=new java.util.concurrent.atomic.AtomicReference<>(0.0);
+   doAnswer(call->absorption.get()).when(a.player).getAbsorptionAmount();
+   doAnswer(call->{absorption.set(call.getArgument(0));return null;}).when(a.player).setAbsorptionAmount(anyDouble());
+   doReturn(true).when(a.player).isSneaking();use(f,a);PartyBookNativeTest.drain(f);PartyBookNativeTest.drain(f);
+   ((games.dmg.fantasystick.events.LocalEventLog)FantasyStickLifecycleNativeTest.Fixture.field(f.plugin,"eventLog")).close();
+   var enemy=mock(org.bukkit.entity.Zombie.class);when(enemy.getUniqueId()).thenReturn(UUID.randomUUID());
+   var source=org.bukkit.damage.DamageSource.builder(org.bukkit.damage.DamageType.MOB_ATTACK)
+    .withCausingEntity(enemy).withDirectEntity(enemy).build();
+   var hit=new org.bukkit.event.entity.EntityDamageByEntityEvent(enemy,a.player,
+    org.bukkit.event.entity.EntityDamageEvent.DamageCause.ENTITY_ATTACK,source,3);
+   f.dispatcher.accept(hit);absorption.set(2.0);PartyBookNativeTest.drain(f);
+   assertEquals(2,absorption.get(),1e-9);f.delayed.getLast().run();assertEquals(0,absorption.get(),1e-9);
+  }
+  assertEquals(0,count(inspireEvents(data),"combat.prevented"));
+ }
+ @Test void acknowledgedInspireConfigurationReadAndChangeReachExportedJsonl()throws Exception{
+  try(var f=new FantasyStickLifecycleNativeTest.Fixture(data)){
+   f.plugin.setEnabled(true);var admin=new EquipmentAdminCommandNativeTest.Sender();admin.allowed=true;
+   f.command.execute(admin.port,"fstickadmin",new String[]{"config","inspire-base-temporary-health"});
+   assertTrue(admin.messages.getLast().contains("inspire-base-temporary-health=4"));
+   f.command.execute(admin.port,"fstickadmin",new String[]{"config","inspire-base-temporary-health","9"});
+   var response=f.tasks.poll(5,java.util.concurrent.TimeUnit.SECONDS);assertNotNull(response);response.run();
+   var registry=(games.dmg.fantasystick.ability.AbilityRegistry)FantasyStickLifecycleNativeTest.Fixture.field(f.plugin,"abilityRegistry");
+   assertEquals(new java.math.BigDecimal("9"),registry.find("inspire").orElseThrow().parameters().get("base-temporary-health"));
+   try(var channel=java.nio.channels.FileChannel.open(data.resolve(".config.lock"),java.nio.file.StandardOpenOption.CREATE,java.nio.file.StandardOpenOption.WRITE);
+    var lock=channel.lock()){
+    assertTrue(lock.isValid());
+    f.command.execute(admin.port,"fstickadmin",new String[]{"config","inspire-base-temporary-health","10"});
+    var failed=f.tasks.poll(5,java.util.concurrent.TimeUnit.SECONDS);assertNotNull(failed);failed.run();
+   }
+   admin.allowed=false;f.command.execute(admin.port,"fstickadmin",new String[]{"config","inspire-base-temporary-health"});
+  }
+  var own=inspireEvents(data);assertEquals(1,count(own,"config.read"));assertEquals(1,count(own,"config.changed"));
+  var changed=record(own,"config.changed");assertEquals("4",changed.get("before").getAsString());
+  assertEquals("9",changed.get("after").getAsString());
+ }
  @Test void bookAcquisitionSneakUseAddsOwnedTemporaryHealthAndExpiryPreservesUnrelatedAbsorption()throws Exception{try(var f=new FantasyStickLifecycleNativeTest.Fixture(data)){f.plugin.setEnabled(true);var a=new FantasyStickLifecycleNativeTest.Actor(data);withInspire(data,a,false);f.players.put(a.core.id,a.player);f.activate(a);a.core.inventory.getInventory().setSelectedSlot(0);PartyBookNativeTest.open(f,a);String book=PartyBookNativeTest.text(a).replaceAll("\\s+","");assertTrue(book.contains("Inspire"));assertTrue(book.contains("CHR12"));assertTrue(book.contains("WIS10"));assertFalse(book.contains("Cost:"));assertTrue(book.contains("12"));assertTrue(book.contains("6s"));PartyBookNativeTest.click(f,a,button(a,"[Learn]","inspire"));PartyBookNativeTest.drain(f);PartyBookNativeTest.drain(f);
    double maximum=a.maximumHealth.getBaseValue();var absorption=new java.util.concurrent.atomic.AtomicReference<>(2.0);doAnswer(c->absorption.get()).when(a.player).getAbsorptionAmount();doAnswer(c->{absorption.set(c.getArgument(0));return null;}).when(a.player).setAbsorptionAmount(anyDouble());doReturn(true).when(a.player).isSneaking();a.core.inventory.getInventory().setSelectedSlot(2);f.dispatcher.accept(new PlayerInteractEvent(a.player,org.bukkit.event.block.Action.RIGHT_CLICK_AIR,a.core.inventory.getItem(2),null,org.bukkit.block.BlockFace.SELF,EquipmentSlot.HAND));PartyBookNativeTest.drain(f);PartyBookNativeTest.drain(f);assertEquals(7,absorption.get(),1e-9);assertEquals(maximum,a.maximumHealth.getBaseValue(),1e-9);assertEquals(120L,f.delayedTicks.getLast());f.delayed.getLast().run();assertEquals(2,absorption.get(),1e-9);var storage=(CharacterStorage)FantasyStickLifecycleNativeTest.Fixture.field(f.plugin,"characters");assertNotNull(storage.find(a.core.record.id()).get().orElseThrow().cooldowns().get("inspire"));}}
  @Test void aimedPartyAllyActualAbsorptionCreatesPersistedSupportShare()throws Exception{try(var f=new FantasyStickLifecycleNativeTest.Fixture(data)){f.plugin.setEnabled(true);var a=new FantasyStickLifecycleNativeTest.Actor(data);var b=new FantasyStickLifecycleNativeTest.Actor(data);withInspire(data,a,true);f.players.put(a.core.id,a.player);f.players.put(b.core.id,b.player);f.activate(a);f.activate(b);var parties=PartyLifecycleNativeTest.parties(f);var party=parties.create(a.core.id).orElseThrow();assertTrue(parties.accept(b.core.id,parties.invite(a.core.id,party.id(),b.core.id).orElseThrow().id()));
   doReturn(false).when(a.player).isSneaking();doReturn(new org.bukkit.Location(a.world,0,64,0)).when(a.player).getLocation();doReturn(new org.bukkit.Location(a.world,8,64,0)).when(b.player).getLocation();doReturn(true).when(a.player).hasLineOfSight(b.player);doReturn(b.player).when(a.player).getTargetEntity(64);var absorption=new java.util.concurrent.atomic.AtomicReference<>(0.0);doAnswer(c->absorption.get()).when(b.player).getAbsorptionAmount();doAnswer(c->{absorption.set(c.getArgument(0));return null;}).when(b.player).setAbsorptionAmount(anyDouble());use(f,a);PartyBookNativeTest.drain(f);PartyBookNativeTest.drain(f);assertEquals(5,absorption.get(),1e-9);
   var enemy=mock(org.bukkit.entity.LivingEntity.class);when(enemy.getUniqueId()).thenReturn(java.util.UUID.randomUUID());when(enemy.getType()).thenReturn(org.bukkit.entity.EntityType.ZOMBIE);when(a.world.getUID()).thenReturn(java.util.UUID.randomUUID());when(enemy.getLocation()).thenReturn(new org.bukkit.Location(a.world,8,64,0));var enemySource=org.bukkit.damage.DamageSource.builder(org.bukkit.damage.DamageType.MOB_ATTACK).withCausingEntity(enemy).withDirectEntity(enemy).build();f.dispatcher.accept(new org.bukkit.event.entity.EntityDamageByEntityEvent(enemy,b.player,org.bukkit.event.entity.EntityDamageEvent.DamageCause.ENTITY_ATTACK,enemySource,3));absorption.set(2.0);PartyBookNativeTest.drain(f);String feedback="Inspire prevented 3 damage to "+b.core.record.name()+".";assertEquals(1,a.messages.stream().filter(feedback::equals).count());assertEquals(1,b.messages.stream().filter(feedback::equals).count());var sourceSheet=a.core.inventory.getItemInOffHand().clone();a.core.inventory.setItemInOffHand(null);f.changed(a);PartyBookNativeTest.drain(f);f.awaitCharacterAndReceipt(a);var holder=new FantasyStickLifecycleNativeTest.Actor(data);holder.core.inventory.setItemInOffHand(sourceSheet);f.players.put(holder.core.id,holder.player);f.activate(holder);
   var allySource=org.bukkit.damage.DamageSource.builder(org.bukkit.damage.DamageType.PLAYER_ATTACK).withCausingEntity(b.player).withDirectEntity(b.player).build();f.dispatcher.accept(new org.bukkit.event.entity.EntityDamageByEntityEvent(b.player,enemy,org.bukkit.event.entity.EntityDamageEvent.DamageCause.ENTITY_ATTACK,allySource,3));f.dispatcher.accept(new org.bukkit.event.entity.EntityDeathEvent(enemy,allySource,new java.util.ArrayList<>(),0));for(int i=0;i<4;i++)PartyBookNativeTest.drain(f);var storage=(CharacterStorage)FantasyStickLifecycleNativeTest.Fixture.field(f.plugin,"characters");assertEquals(BigInteger.valueOf(5),storage.find(a.core.record.id()).get().orElseThrow().experience());assertEquals(BigInteger.valueOf(5),storage.find(b.core.record.id()).get().orElseThrow().experience());}}
- @Test void normalSelfOrdinaryOutOfRangeAndObstructedTargetsRefuseBeforeCooldown()throws Exception{for(int route=0;route<4;route++){var dir=data.resolve("refuse-"+route);try(var f=new FantasyStickLifecycleNativeTest.Fixture(dir)){f.plugin.setEnabled(true);var a=new FantasyStickLifecycleNativeTest.Actor(dir);withInspire(dir,a,true);f.players.put(a.core.id,a.player);f.activate(a);org.bukkit.entity.Player target;if(route==0)target=a.player;else if(route==1){target=mock(org.bukkit.entity.Player.class);when(target.getUniqueId()).thenReturn(java.util.UUID.randomUUID());}else{var b=new FantasyStickLifecycleNativeTest.Actor(dir);target=b.player;f.players.put(b.core.id,b.player);f.activate(b);}doReturn(false).when(a.player).isSneaking();doReturn(new org.bukkit.Location(a.world,0,64,0)).when(a.player).getLocation();doReturn(new org.bukkit.Location(a.world,route==2?13:8,64,0)).when(target).getLocation();doReturn(route!=3).when(a.player).hasLineOfSight(target);doReturn(target).when(a.player).getTargetEntity(64);use(f,a);PartyBookNativeTest.drain(f);var storage=(CharacterStorage)FantasyStickLifecycleNativeTest.Fixture.field(f.plugin,"characters");assertFalse(storage.find(a.core.record.id()).get().orElseThrow().cooldowns().containsKey("inspire"));}}}
+ @Test void normalSelfOrdinaryOutOfRangeAndObstructedTargetsRefuseBeforeCooldown()throws Exception{for(int route=0;route<4;route++){var dir=data.resolve("refuse-"+route);try(var f=new FantasyStickLifecycleNativeTest.Fixture(dir)){f.plugin.setEnabled(true);var a=new FantasyStickLifecycleNativeTest.Actor(dir);withInspire(dir,a,true);f.players.put(a.core.id,a.player);f.activate(a);org.bukkit.entity.Player target;if(route==0)target=a.player;else if(route==1){target=mock(org.bukkit.entity.Player.class);when(target.getUniqueId()).thenReturn(java.util.UUID.randomUUID());}else{var b=new FantasyStickLifecycleNativeTest.Actor(dir);target=b.player;f.players.put(b.core.id,b.player);f.activate(b);}doReturn(false).when(a.player).isSneaking();doReturn(new org.bukkit.Location(a.world,0,64,0)).when(a.player).getLocation();doReturn(new org.bukkit.Location(a.world,route==2?13:8,64,0)).when(target).getLocation();doReturn(route!=3).when(a.player).hasLineOfSight(target);doReturn(target).when(a.player).getTargetEntity(64);use(f,a);PartyBookNativeTest.drain(f);var storage=(CharacterStorage)FantasyStickLifecycleNativeTest.Fixture.field(f.plugin,"characters");assertFalse(storage.find(a.core.record.id()).get().orElseThrow().cooldowns().containsKey("inspire"));}
+  var own=inspireEvents(dir);assertEquals(0,count(own,"ability.cast"));assertEquals(0,count(own,"effect.applied"));
+  assertEquals("refused",record(own,"ability.resolved").get("outcome").getAsString());
+ }}
  @Test void nonPartyTargetIsAllowedAndStrongestRemainingCopiesPreserveUnrelatedAbsorption()throws Exception{java.nio.file.Files.writeString(data.resolve("config.yml"),"inspire-cooldown-seconds: 0\n");try(var f=new FantasyStickLifecycleNativeTest.Fixture(data)){f.plugin.setEnabled(true);var a=new FantasyStickLifecycleNativeTest.Actor(data);var c=new FantasyStickLifecycleNativeTest.Actor(data);var b=new FantasyStickLifecycleNativeTest.Actor(data);withInspire(data,a,true);withInspire(data,c,true);f.players.put(a.core.id,a.player);f.players.put(c.core.id,c.player);f.players.put(b.core.id,b.player);f.activate(a);f.activate(c);f.activate(b);var absorption=new java.util.concurrent.atomic.AtomicReference<>(2.0);doAnswer(x->absorption.get()).when(b.player).getAbsorptionAmount();doAnswer(x->{absorption.set(x.getArgument(0));return null;}).when(b.player).setAbsorptionAmount(anyDouble());for(var caster:List.of(a,c)){doReturn(false).when(caster.player).isSneaking();doReturn(new org.bukkit.Location(a.world,0,64,0)).when(caster.player).getLocation();doReturn(true).when(caster.player).hasLineOfSight(b.player);doReturn(b.player).when(caster.player).getTargetEntity(64);}doReturn(new org.bukkit.Location(a.world,8,64,0)).when(b.player).getLocation();use(f,a);PartyBookNativeTest.drain(f);PartyBookNativeTest.drain(f);assertEquals(7,absorption.get(),1e-9);var sender=new EquipmentAdminCommandNativeTest.Sender();f.command.execute(sender.port,"fantasystick",new String[]{"config","inspire-base-temporary-health","6"});var response=f.tasks.poll(5,java.util.concurrent.TimeUnit.SECONDS);assertNotNull(response);response.run();use(f,c);PartyBookNativeTest.drain(f);PartyBookNativeTest.drain(f);assertEquals(9,absorption.get(),1e-9);
-  var enemy=mock(org.bukkit.entity.Zombie.class);when(enemy.getUniqueId()).thenReturn(java.util.UUID.randomUUID());var source=org.bukkit.damage.DamageSource.builder(org.bukkit.damage.DamageType.MOB_ATTACK).withCausingEntity(enemy).withDirectEntity(enemy).build();f.dispatcher.accept(new org.bukkit.event.entity.EntityDamageByEntityEvent(enemy,b.player,org.bukkit.event.entity.EntityDamageEvent.DamageCause.ENTITY_ATTACK,source,3));absorption.set(6.0);PartyBookNativeTest.drain(f);f.delayed.getLast().run();assertEquals(4,absorption.get(),1e-9);f.delayed.getFirst().run();assertEquals(2,absorption.get(),1e-9);}}
+  var enemy=mock(org.bukkit.entity.Zombie.class);when(enemy.getUniqueId()).thenReturn(java.util.UUID.randomUUID());var source=org.bukkit.damage.DamageSource.builder(org.bukkit.damage.DamageType.MOB_ATTACK).withCausingEntity(enemy).withDirectEntity(enemy).build();f.dispatcher.accept(new org.bukkit.event.entity.EntityDamageByEntityEvent(enemy,b.player,org.bukkit.event.entity.EntityDamageEvent.DamageCause.ENTITY_ATTACK,source,3));absorption.set(6.0);PartyBookNativeTest.drain(f);f.delayed.getLast().run();assertEquals(4,absorption.get(),1e-9);f.delayed.getFirst().run();assertEquals(2,absorption.get(),1e-9);}
+  var own=inspireEvents(data);assertEquals(2,count(own,"ability.cast"));assertEquals(2,count(own,"effect.applied"));
+  assertEquals(1,count(own,"combat.prevented"));assertEquals(2,count(own,"effect.ended"));
+  var applied=own.stream().filter(event->event.get("type").getAsString().endsWith("effect.applied")).toList();
+  var prevented=record(own,"combat.prevented");
+  assertEquals(applied.getLast().getAsJsonObject("data").get("application_id").getAsString(),
+   prevented.get("effect_application_id").getAsString(),"strongest accepted grant owns observed absorption");
+  assertEquals("7",applied.getLast().getAsJsonObject("data").get("granted_amount").getAsString());
+ }
  @Test void cancelledOrSelfOnlyProtectionCannotManufactureSupportShare()throws Exception{for(int route=0;route<2;route++){var dir=data.resolve("no-support-"+route);try(var f=new FantasyStickLifecycleNativeTest.Fixture(dir)){f.plugin.setEnabled(true);var a=new FantasyStickLifecycleNativeTest.Actor(dir);var b=new FantasyStickLifecycleNativeTest.Actor(dir);withInspire(dir,a,true);f.players.put(a.core.id,a.player);f.players.put(b.core.id,b.player);f.activate(a);f.activate(b);var parties=PartyLifecycleNativeTest.parties(f);var party=parties.create(a.core.id).orElseThrow();assertTrue(parties.accept(b.core.id,parties.invite(a.core.id,party.id(),b.core.id).orElseThrow().id()));var target=route==0?b.player:a.player;var absorption=new java.util.concurrent.atomic.AtomicReference<>(0.0);doAnswer(x->absorption.get()).when(target).getAbsorptionAmount();doAnswer(x->{absorption.set(x.getArgument(0));return null;}).when(target).setAbsorptionAmount(anyDouble());doReturn(route==1).when(a.player).isSneaking();doReturn(new org.bukkit.Location(a.world,0,64,0)).when(a.player).getLocation();doReturn(new org.bukkit.Location(a.world,8,64,0)).when(b.player).getLocation();doReturn(true).when(a.player).hasLineOfSight(b.player);doReturn(b.player).when(a.player).getTargetEntity(64);use(f,a);PartyBookNativeTest.drain(f);PartyBookNativeTest.drain(f);var enemy=mock(org.bukkit.entity.LivingEntity.class);when(enemy.getUniqueId()).thenReturn(java.util.UUID.randomUUID());when(enemy.getType()).thenReturn(org.bukkit.entity.EntityType.ZOMBIE);when(enemy.getLocation()).thenReturn(new org.bukkit.Location(a.world,8,64,0));when(a.world.getUID()).thenReturn(java.util.UUID.randomUUID());var enemySource=org.bukkit.damage.DamageSource.builder(org.bukkit.damage.DamageType.MOB_ATTACK).withCausingEntity(enemy).withDirectEntity(enemy).build();var hit=new org.bukkit.event.entity.EntityDamageByEntityEvent(enemy,target,org.bukkit.event.entity.EntityDamageEvent.DamageCause.ENTITY_ATTACK,enemySource,3);if(route==0)hit.setCancelled(true);f.dispatcher.accept(hit);if(route==1){absorption.set(2.0);PartyBookNativeTest.drain(f);}var allySource=org.bukkit.damage.DamageSource.builder(org.bukkit.damage.DamageType.PLAYER_ATTACK).withCausingEntity(b.player).withDirectEntity(b.player).build();f.dispatcher.accept(new org.bukkit.event.entity.EntityDamageByEntityEvent(b.player,enemy,org.bukkit.event.entity.EntityDamageEvent.DamageCause.ENTITY_ATTACK,allySource,3));f.dispatcher.accept(new org.bukkit.event.entity.EntityDeathEvent(enemy,allySource,new java.util.ArrayList<>(),0));for(int i=0;i<4;i++)PartyBookNativeTest.drain(f);var storage=(CharacterStorage)FantasyStickLifecycleNativeTest.Fixture.field(f.plugin,"characters");assertEquals(BigInteger.valueOf(5),storage.find(a.core.record.id()).get().orElseThrow().experience());assertEquals(BigInteger.valueOf(5),storage.find(b.core.record.id()).get().orElseThrow().experience());}}}
  @Test void exactFormulaSupportsFiniteUncappedCharisma(){assertEquals(BigInteger.valueOf(5),games.dmg.fantasystick.ability.Inspire.amount(BigInteger.valueOf(12)));assertEquals(BigInteger.valueOf(3),games.dmg.fantasystick.ability.Inspire.amount(BigInteger.valueOf(9)));var huge=BigInteger.TEN.pow(500);assertEquals(huge.subtract(BigInteger.TEN).divide(BigInteger.TWO).add(BigInteger.valueOf(4)),games.dmg.fantasystick.ability.Inspire.amount(huge));}
  @Test void failedCooldownPersistencePublishesNoTemporaryHealth(){var storage=mock(CharacterStorage.class);var sessions=mock(games.dmg.fantasystick.session.EquipmentSessions.class);var parties=new games.dmg.fantasystick.party.PartyRoster(java.time.Clock.systemUTC(),ignored->true);var temporary=new games.dmg.fantasystick.ability.TemporaryHealth(sessions,parties,Runnable::run,ignored->{});var inspire=new games.dmg.fantasystick.ability.Inspire(games.dmg.fantasystick.ability.Inspire.Settings.defaults(),temporary);var registry=new games.dmg.fantasystick.ability.AbilityRegistry();registry.register(inspire.definition());var base=new games.dmg.fantasystick.crafting.CharacterFactory().create(games.dmg.fantasystick.progression.ProgressionRules.defaults());var stats=new EnumMap<>(base.stats());stats.put(Stat.CHR,BigInteger.valueOf(12));stats.put(Stat.WIS,BigInteger.TEN);var record=new CharacterRecord(base.id(),base.name(),base.revision(),stats,base.level(),base.experience(),base.unspentPoints(),base.health(),Set.of("inspire"),List.of("inspire","","","","","",""),base.cooldowns(),base.restrictedKills(),false,null,null);var active=new games.dmg.fantasystick.session.EquipmentSessions.Active(java.util.UUID.randomUUID(),java.util.UUID.randomUUID(),record.id());var player=mock(org.bukkit.entity.Player.class);when(player.getUniqueId()).thenReturn(active.player());when(player.isSneaking()).thenReturn(true);when(sessions.active(active.player())).thenReturn(java.util.Optional.of(active));when(sessions.current(active)).thenReturn(true);when(sessions.currentRecord(active)).thenReturn(java.util.Optional.of(record));var failed=new java.util.concurrent.CompletableFuture<CharacterStorage.AbilityMutation>();failed.completeExceptionally(new java.io.IOException("simulated"));when(storage.commitAbilityCooldown(eq(record.id()),eq(record.revision()),eq("inspire"),any())).thenReturn(failed);var engine=new games.dmg.fantasystick.ability.AbilityEngine(registry,storage,sessions,parties,java.time.Clock.systemUTC(),Runnable::run,(delay,action)->()->{},ignored->{},ignored->{});engine.accept(new games.dmg.fantasystick.session.ControlInput(player,active,2,"inspire",games.dmg.fantasystick.session.ControlInput.Kind.ABILITY,games.dmg.fantasystick.session.ControlInput.Gesture.USE,player,0,0,()->true));verify(storage).commitAbilityCooldown(eq(record.id()),eq(record.revision()),eq("inspire"),any());verify(player,never()).setAbsorptionAmount(anyDouble());engine.close();inspire.close();temporary.close();parties.close();}
- @Test void unlearnRelearnAndTransferRetainCooldownAndClearOnlyOwnedTemporaryHealth()throws Exception{java.nio.file.Files.writeString(data.resolve("config.yml"),"inspire-cooldown-seconds: 60\n");try(var f=new FantasyStickLifecycleNativeTest.Fixture(data)){f.plugin.setEnabled(true);var a=new FantasyStickLifecycleNativeTest.Actor(data);withInspire(data,a,true);f.players.put(a.core.id,a.player);f.activate(a);var absorption=new java.util.concurrent.atomic.AtomicReference<>(2.0);doAnswer(x->absorption.get()).when(a.player).getAbsorptionAmount();doAnswer(x->{absorption.set(x.getArgument(0));return null;}).when(a.player).setAbsorptionAmount(anyDouble());doReturn(true).when(a.player).isSneaking();use(f,a);PartyBookNativeTest.drain(f);PartyBookNativeTest.drain(f);assertEquals(7,absorption.get(),1e-9);var storage=(CharacterStorage)FantasyStickLifecycleNativeTest.Fixture.field(f.plugin,"characters");var deadline=storage.find(a.core.record.id()).get().orElseThrow().cooldowns().get("inspire");a.core.inventory.getInventory().setSelectedSlot(0);PartyBookNativeTest.open(f,a);var unlearn=button(a,"[Unlearn]","inspire");PartyBookNativeTest.click(f,a,unlearn);PartyBookNativeTest.click(f,a,unlearn);PartyBookNativeTest.drain(f);PartyBookNativeTest.drain(f);assertEquals(2,absorption.get(),1e-9);var refunded=storage.find(a.core.record.id()).get().orElseThrow();assertEquals(BigInteger.valueOf(40),refunded.unspentPoints());assertEquals(deadline,refunded.cooldowns().get("inspire"));learnAndAssign(f,a);use(f,a);assertTrue(a.messages.stream().anyMatch(m->m.contains("ready in")));var sheet=a.core.inventory.getItemInOffHand().clone();a.core.inventory.setItemInOffHand(null);f.changed(a);PartyBookNativeTest.drain(f);f.awaitCharacterAndReceipt(a);var b=new FantasyStickLifecycleNativeTest.Actor(data);b.core.inventory.setItemInOffHand(sheet);f.players.put(b.core.id,b.player);f.activate(b);doReturn(true).when(b.player).isSneaking();use(f,b);assertTrue(b.messages.stream().anyMatch(m->m.contains("ready in")));assertEquals(deadline,storage.find(a.core.record.id()).get().orElseThrow().cooldowns().get("inspire"));}}
+ @Test void unlearnRelearnAndTransferRetainCooldownAndClearOnlyOwnedTemporaryHealth()throws Exception{java.nio.file.Files.writeString(data.resolve("config.yml"),"inspire-cooldown-seconds: 60\n");try(var f=new FantasyStickLifecycleNativeTest.Fixture(data)){f.plugin.setEnabled(true);var a=new FantasyStickLifecycleNativeTest.Actor(data);withInspire(data,a,true);f.players.put(a.core.id,a.player);f.activate(a);var absorption=new java.util.concurrent.atomic.AtomicReference<>(2.0);doAnswer(x->absorption.get()).when(a.player).getAbsorptionAmount();doAnswer(x->{absorption.set(x.getArgument(0));return null;}).when(a.player).setAbsorptionAmount(anyDouble());doReturn(true).when(a.player).isSneaking();use(f,a);PartyBookNativeTest.drain(f);PartyBookNativeTest.drain(f);assertEquals(7,absorption.get(),1e-9);var storage=(CharacterStorage)FantasyStickLifecycleNativeTest.Fixture.field(f.plugin,"characters");var deadline=storage.find(a.core.record.id()).get().orElseThrow().cooldowns().get("inspire");a.core.inventory.getInventory().setSelectedSlot(0);PartyBookNativeTest.open(f,a);var unlearn=button(a,"[Unlearn]","inspire");PartyBookNativeTest.click(f,a,unlearn);PartyBookNativeTest.click(f,a,unlearn);PartyBookNativeTest.drain(f);PartyBookNativeTest.drain(f);assertEquals(2,absorption.get(),1e-9);var refunded=storage.find(a.core.record.id()).get().orElseThrow();assertEquals(BigInteger.valueOf(40),refunded.unspentPoints());assertEquals(deadline,refunded.cooldowns().get("inspire"));learnAndAssign(f,a);use(f,a);assertTrue(a.messages.stream().anyMatch(m->m.contains("ready in")));var sheet=a.core.inventory.getItemInOffHand().clone();a.core.inventory.setItemInOffHand(null);f.changed(a);PartyBookNativeTest.drain(f);f.awaitCharacterAndReceipt(a);var b=new FantasyStickLifecycleNativeTest.Actor(data);b.core.inventory.setItemInOffHand(sheet);f.players.put(b.core.id,b.player);f.activate(b);doReturn(true).when(b.player).isSneaking();use(f,b);assertTrue(b.messages.stream().anyMatch(m->m.contains("ready in")));assertEquals(deadline,storage.find(a.core.record.id()).get().orElseThrow().cooldowns().get("inspire"));}
+  var own=inspireEvents(data);assertEquals(1,count(own,"ability.cast"));
+  assertEquals(1,count(own,"effect.applied"));assertEquals(1,count(own,"effect.ended"));
+  assertEquals(0,count(own,"combat.prevented"));
+  assertEquals("interrupted",record(own,"effect.ended").get("reason").getAsString());
+  assertEquals("5",record(own,"effect.ended").get("remaining_amount").getAsString());
+ }
  @Test void configuredDefinitionAdminRestartFutureCastAndStartupValidationCoverEverySetting()throws Exception{java.nio.file.Files.writeString(data.resolve("config.yml"),"inspire-base-temporary-health: 8\ninspire-cooldown-seconds: 0\ninspire-range-blocks: 16\ninspire-duration-seconds: 8\n");try(var f=new FantasyStickLifecycleNativeTest.Fixture(data)){f.plugin.setEnabled(true);var registry=(games.dmg.fantasystick.ability.AbilityRegistry)FantasyStickLifecycleNativeTest.Fixture.field(f.plugin,"abilityRegistry");var d=registry.find("inspire").orElseThrow();assertEquals(java.time.Duration.ZERO,d.cooldown());assertEquals(new java.math.BigDecimal("8"),d.parameters().get("base-temporary-health"));assertEquals(0,new java.math.BigDecimal("16").compareTo(d.parameters().get("range")));assertEquals(0,new java.math.BigDecimal("8").compareTo(d.parameters().get("duration-seconds")));
   var sender=new EquipmentAdminCommandNativeTest.Sender();sender.allowed=false;assertTrue(f.command.tabComplete(sender.port,"fantasystick",new String[]{"config","inspire-"}).isEmpty());f.command.execute(sender.port,"fantasystick",new String[]{"config","inspire-base-temporary-health","9"});assertTrue(sender.messages.getLast().contains("Permission denied"));sender.allowed=true;assertEquals(List.of("inspire-base-temporary-health","inspire-cooldown-seconds","inspire-duration-seconds","inspire-range-blocks"),f.command.tabComplete(sender.port,"fantasystick",new String[]{"config","inspire-"}));assertEquals(List.of("4","8"),f.command.tabComplete(sender.port,"fantasystick",new String[]{"config","inspire-base-temporary-health",""}));f.command.execute(sender.port,"fantasystick",new String[]{"config","inspire-base-temporary-health"});assertTrue(sender.messages.getLast().contains("=8"));f.command.execute(sender.port,"fantasystick",new String[]{"config","inspire-base-temporary-health","9"});var response=f.tasks.poll(5,java.util.concurrent.TimeUnit.SECONDS);assertNotNull(response);response.run();assertEquals(new java.math.BigDecimal("9"),registry.find("inspire").orElseThrow().parameters().get("base-temporary-health"));
   var a=new FantasyStickLifecycleNativeTest.Actor(data);withInspire(data,a,true);f.players.put(a.core.id,a.player);f.activate(a);var absorption=new java.util.concurrent.atomic.AtomicReference<>(0.0);doAnswer(c->absorption.get()).when(a.player).getAbsorptionAmount();doAnswer(c->{absorption.set(c.getArgument(0));return null;}).when(a.player).setAbsorptionAmount(anyDouble());doReturn(true).when(a.player).isSneaking();use(f,a);PartyBookNativeTest.drain(f);PartyBookNativeTest.drain(f);assertEquals(10,absorption.get(),1e-9);assertEquals(160L,f.delayedTicks.getLast());
   f.command.execute(sender.port,"fantasystick",new String[]{"config","inspire-base-temporary-health","-1"});assertTrue(sender.messages.getLast().contains("invalid"));f.command.execute(sender.port,"fantasystick",new String[]{"config","inspire-base-temporary-health","9","extra"});assertTrue(sender.messages.getLast().contains("Usage"));f.plugin.setEnabled(false);f.plugin.setEnabled(true);var reload=(games.dmg.fantasystick.ability.AbilityRegistry)FantasyStickLifecycleNativeTest.Fixture.field(f.plugin,"abilityRegistry");assertEquals(new java.math.BigDecimal("9"),reload.find("inspire").orElseThrow().parameters().get("base-temporary-health"));}
   for(String invalid:List.of("inspire-base-temporary-health: -1\n","inspire-cooldown-seconds: -1\n","inspire-range-blocks: 0\n","inspire-duration-seconds: 0\n")){var dir=data.resolve(Integer.toHexString(invalid.hashCode()));java.nio.file.Files.createDirectories(dir);java.nio.file.Files.writeString(dir.resolve("config.yml"),invalid);try(var f=new FantasyStickLifecycleNativeTest.Fixture(dir)){assertThrows(IllegalArgumentException.class,()->f.plugin.setEnabled(true));assertTrue(f.order.isEmpty());}}}
+ private static List<com.google.gson.JsonObject> inspireEvents(Path root)throws Exception{
+  var results=new java.util.ArrayList<com.google.gson.JsonObject>();
+  try(var days=java.nio.file.Files.list(root.resolve("events"))){
+   for(var day:days.filter(path->path.getFileName().toString().matches("\\d{4}-\\d{2}-\\d{2}")).toList())
+    try(var segments=java.nio.file.Files.list(day)){
+     for(var path:segments.filter(file->file.getFileName().toString().startsWith("events-")
+      &&file.getFileName().toString().endsWith(".jsonl")).toList())
+      for(var line:java.nio.file.Files.readAllLines(path))
+       if(!line.isBlank()){
+        var event=com.google.gson.JsonParser.parseString(line).getAsJsonObject();
+        var data=event.getAsJsonObject("data");
+        if(data!=null&&data.has("ability_id")&&data.get("ability_id").getAsString().equals("inspire"))results.add(event);
+       }
+    }
+  }
+  return results;
+ }
+ private static long count(List<com.google.gson.JsonObject> own,String suffix){return own.stream().filter(event->event.get("type").getAsString().endsWith(suffix)).count();}
+ private static com.google.gson.JsonObject record(List<com.google.gson.JsonObject> own,String suffix){return own.stream().filter(event->event.get("type").getAsString().endsWith(suffix)).findFirst().orElseThrow().getAsJsonObject("data");}
  private static void learnAndAssign(FantasyStickLifecycleNativeTest.Fixture f,FantasyStickLifecycleNativeTest.Actor a)throws Exception{a.core.inventory.getInventory().setSelectedSlot(0);PartyBookNativeTest.open(f,a);PartyBookNativeTest.click(f,a,button(a,"[Learn]","inspire"));PartyBookNativeTest.drain(f);PartyBookNativeTest.drain(f);}
  private static void use(FantasyStickLifecycleNativeTest.Fixture f,FantasyStickLifecycleNativeTest.Actor a){a.core.inventory.getInventory().setSelectedSlot(2);f.dispatcher.accept(new PlayerInteractEvent(a.player,org.bukkit.event.block.Action.RIGHT_CLICK_AIR,a.core.inventory.getItem(2),null,org.bukkit.block.BlockFace.SELF,EquipmentSlot.HAND));}
  private static ClickEvent.Custom button(FantasyStickLifecycleNativeTest.Actor a,String label,String ability){var b=org.bukkit.craftbukkit.inventory.CraftItemStack.asNMSCopy(a.books.getLast()).get(net.minecraft.core.component.DataComponents.WRITTEN_BOOK_CONTENT);assertNotNull(b);for(var p:b.pages()){var x=button(p.raw(),label,ability);if(x!=null)return x;}throw new AssertionError("missing action");}

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

@@ -118,6 +118,78 @@ class OutOfCombatRecoveryNativeTest {
 
     @Test void eventSinkFailureCannotChangeAnAcceptedRecoveryPulse(){var f=new Direct();f.recovery.attachBonusHealing(ignored->BigInteger.valueOf(3));f.recovery.attachEvents(new games.dmg.fantasystick.events.RecoveryEventBridge(event->{throw new IllegalStateException("disk");},f.clock),ignored->BigInteger.valueOf(3));assertDoesNotThrow(()->{f.recovery.sweep();f.clock.advance(Duration.ofSeconds(10));f.recovery.sweep();f.runNext();});assertEquals(8,f.health.get());assertEquals(0,new BigDecimal("8").compareTo(f.record.get().health()));}
 
+    @Test void unloadedAuditWorldCannotInterruptAcceptedOrRefusedRecovery() {
+        var f = new Direct();
+        var captured = new java.util.ArrayList<games.dmg.fantasystick.events.EventInput>();
+        f.recovery.attachEvents(new games.dmg.fantasystick.events.RecoveryEventBridge(captured::add, f.clock), ignored -> BigInteger.ZERO);
+        var location = mock(org.bukkit.Location.class);
+        when(location.getWorld()).thenThrow(new IllegalArgumentException("World unloaded"));
+        when(f.player.getLocation()).thenReturn(location);
+        f.recovery.sweep(); f.clock.advance(Duration.ofSeconds(10));
+        assertDoesNotThrow(() -> { f.recovery.sweep(); f.runNext(); });
+        assertEquals(5, f.health.get());
+        assertEquals(0, BigDecimal.valueOf(5).compareTo(f.record.get().health()));
+        assertEquals(List.of("action.observed", "action.resolved", "combat.healed"),
+            captured.stream().map(games.dmg.fantasystick.events.EventInput::type).toList());
+        captured.forEach(input -> {
+            assertEquals(f.active.player(), input.context().playerId());
+            assertEquals(f.active.character(), input.context().characterId());
+            assertEquals(f.active.session(), input.context().sessionId());
+            assertNull(input.context().location());
+            assertEquals("unavailable", input.data().get("location_status"));
+        });
+        f.clock.advance(Duration.ofSeconds(9)); f.recovery.sweep(); assertEquals(1, f.events.size());
+        f.clock.advance(Duration.ofSeconds(1)); f.recovery.sweep(); f.runNext();
+        assertEquals(6, f.health.get(), "The next interval is not suppressed or replayed");
+
+        var cancelled = new Direct(); cancelled.veto = true;
+        var refusals = new java.util.ArrayList<games.dmg.fantasystick.events.EventInput>();
+        cancelled.recovery.attachEvents(new games.dmg.fantasystick.events.RecoveryEventBridge(refusals::add, cancelled.clock), ignored -> BigInteger.ZERO);
+        when(cancelled.player.getLocation()).thenReturn(location);
+        cancelled.recovery.sweep(); cancelled.clock.advance(Duration.ofSeconds(10)); cancelled.recovery.sweep();
+        assertEquals(4, cancelled.health.get());
+        assertEquals(List.of("action.observed", "action.resolved"),
+            refusals.stream().map(games.dmg.fantasystick.events.EventInput::type).toList());
+        assertEquals("refused", refusals.getLast().data().get("outcome"));
+        assertEquals("unavailable", refusals.getLast().data().get("location_status"));
+    }
+
+    @Test void availableAuditLocationRetainsItsExactWorldAndCoordinates() {
+        var f = new Direct();
+        var captured = new java.util.ArrayList<games.dmg.fantasystick.events.EventInput>();
+        f.recovery.attachEvents(new games.dmg.fantasystick.events.RecoveryEventBridge(captured::add, f.clock), ignored -> BigInteger.ZERO);
+        var world = mock(org.bukkit.World.class); var worldId = java.util.UUID.randomUUID();
+        when(world.getUID()).thenReturn(worldId); when(world.getName()).thenReturn("known-world");
+        var location = mock(org.bukkit.Location.class);
+        when(location.getWorld()).thenReturn(world);
+        when(location.getX()).thenReturn(2.5); when(location.getY()).thenReturn(65d); when(location.getZ()).thenReturn(-3d);
+        when(f.player.getLocation()).thenReturn(location);
+        f.recovery.sweep(); f.clock.advance(Duration.ofSeconds(10)); f.recovery.sweep(); f.runNext();
+        assertEquals(5, f.health.get());
+        assertEquals(worldId, captured.getFirst().context().location().worldId());
+        assertEquals("known-world", captured.getFirst().context().location().worldName());
+        assertEquals(2.5, captured.getFirst().context().location().x());
+        assertEquals(65d, captured.getFirst().context().location().y());
+        assertEquals(-3d, captured.getFirst().context().location().z());
+        assertFalse(captured.getFirst().data().containsKey("location_status"));
+    }
+
+    @Test void auditLocationCaptureFailureAndFailedSaveNeverClaimHealing() {
+        var f = new Direct(); f.automatic = false;
+        var captured = new java.util.ArrayList<games.dmg.fantasystick.events.EventInput>();
+        f.recovery.attachEvents(new games.dmg.fantasystick.events.RecoveryEventBridge(captured::add, f.clock), ignored -> BigInteger.ZERO);
+        when(f.player.getLocation()).thenThrow(new IllegalStateException("location inaccessible"));
+        f.recovery.sweep(); f.clock.advance(Duration.ofSeconds(10));
+        assertDoesNotThrow(f.recovery::sweep);
+        assertNotNull(f.pending);
+        f.pending.completeExceptionally(new java.io.IOException("save failed")); f.runNext();
+        assertEquals(4, f.health.get());
+        assertEquals(List.of("action.observed", "action.resolved"),
+            captured.stream().map(games.dmg.fantasystick.events.EventInput::type).toList());
+        assertEquals("failed", captured.getLast().data().get("outcome"));
+        assertEquals("unavailable", captured.getLast().data().get("location_status"));
+    }
+
     @Test void passiveBonusZeroCancellationAndFullHealthStayInTheBasePulseTransaction() {
         var zero = new Direct(); zero.recovery.attachBonusHealing(ignored -> BigInteger.ZERO);
         zero.recovery.sweep(); zero.clock.advance(Duration.ofSeconds(10)); zero.recovery.sweep(); zero.runNext();
@@ -168,6 +240,48 @@ class OutOfCombatRecoveryNativeTest {
         }
     }
 
+    @Test void registeredRecoveryWithUnloadedAuditWorldPersistsAndExportsUnavailableLocation() throws Exception {
+        java.nio.file.Files.writeString(data.resolve("config.yml"),
+            "out-of-combat-healing-delay-seconds: 0\nout-of-combat-healing-interval-seconds: 10\n");
+        java.util.UUID playerId; java.util.UUID characterId;
+        try (var f = new FantasyStickLifecycleNativeTest.Fixture(data)) {
+            f.plugin.setEnabled(true);
+            var a = new FantasyStickLifecycleNativeTest.Actor(data); setHealth(data, a, BigDecimal.valueOf(4));
+            playerId = a.core.id; characterId = a.core.record.id();
+            f.players.put(playerId, a.player); f.activate(a);
+            var location = mock(org.bukkit.Location.class);
+            when(location.getWorld()).thenThrow(new IllegalArgumentException("World unloaded"));
+            doReturn(location).when(a.player).getLocation();
+            var recovery = (OutOfCombatRecovery) FantasyStickLifecycleNativeTest.Fixture.field(f.plugin, "outOfCombatRecovery");
+            assertDoesNotThrow(recovery::sweep);
+            doReturn(new org.bukkit.Location(a.world, 0, 64, 0)).when(a.player).getLocation();
+            PartyBookNativeTest.drain(f);
+            assertEquals(5, a.player.getHealth());
+            var storage = (CharacterStorage) FantasyStickLifecycleNativeTest.Fixture.field(f.plugin, "characters");
+            assertEquals(0, BigDecimal.valueOf(5).compareTo(storage.find(characterId).get().orElseThrow().health()));
+        }
+        var healed = new java.util.ArrayList<com.google.gson.JsonObject>();
+        try (var files = java.nio.file.Files.walk(data.resolve("events"))) {
+            for (var segment : files.filter(file -> file.getFileName().toString().startsWith("events-")
+                    && file.getFileName().toString().endsWith(".jsonl")).toList()) {
+                for (var line : java.nio.file.Files.readAllLines(segment)) {
+                    if (line.isBlank()) continue;
+                    var event = com.google.gson.JsonParser.parseString(line).getAsJsonObject();
+                    if (event.get("type").getAsString().endsWith("combat.healed")
+                            && event.getAsJsonObject("data").has("recovery_kind")) healed.add(event);
+                }
+            }
+        }
+        assertEquals(1, healed.size());
+        var event = healed.getFirst(); var payload = event.getAsJsonObject("data");
+        assertEquals(playerId.toString(), payload.get("player_id").getAsString());
+        assertEquals(characterId.toString(), payload.get("character_id").getAsString());
+        assertTrue(payload.has("session_id"));
+        assertEquals("unavailable", payload.get("location_status").getAsString());
+        assertFalse(payload.has("location"));
+        assertEquals("5.0", payload.get("health_after").getAsString());
+    }
+
     @Test void packagedPluginConnectsZeroDelayRecoveryConfigurationAndRestart() throws Exception {
         java.nio.file.Files.writeString(data.resolve("config.yml"),
             "out-of-combat-healing-delay-seconds: 0\nout-of-combat-healing-interval-seconds: 10\nout-of-combat-healing-amount: 1\n");

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

@@ -45,10 +45,32 @@ class QuickstepNativeTest {
             assertEquals(new Vector(1, 0.25, 0), velocity.get());
             verify(a.player, never()).setFallDistance(anyFloat());
             assertNotNull(storage.find(a.core.record.id()).get().orElseThrow().cooldowns().get("quickstep"));
-            var from = new Location(a.world, 0, 64, 0); var to = new Location(a.world, 4, 64, 0);
-            f.dispatcher.accept(new PlayerMoveEvent(a.player, from, to));
+            var from = a.core.location.clone(); var to = from.clone().add(4, 0, 0);
+            f.dispatcher.accept(new PlayerMoveEvent(a.player, from, from.clone().add(1, 0, 0)));
+            f.dispatcher.accept(new PlayerMoveEvent(a.player, from.clone().add(1, 0, 0), from.clone().add(2, 0, 0)));
+            f.dispatcher.accept(new PlayerMoveEvent(a.player, from.clone().add(2, 0, 0), to));
             assertEquals(new Vector(0, 0.25, 0), velocity.get(), "Only remaining owned horizontal motion is removed");
         }
+        var own = events(data).stream().filter(event -> event.getAsJsonObject("data").has("ability_id")
+            && event.getAsJsonObject("data").get("ability_id").getAsString().equals("quickstep")).toList();
+        assertEquals(1, own.stream().filter(event -> event.get("type").getAsString().endsWith("ability.learned")).count());
+        assertEquals(1, own.stream().filter(event -> event.get("type").getAsString().endsWith("ability.assigned")).count());
+        var cast = own.stream().filter(event -> event.get("type").getAsString().endsWith("ability.cast"))
+            .findFirst().orElseThrow().getAsJsonObject("data");
+        var result = own.stream().filter(event -> event.get("type").getAsString().endsWith("ability.resolved"))
+            .findFirst().orElseThrow().getAsJsonObject("data");
+        assertEquals("completed", result.get("outcome").getAsString());
+        assertEquals("12", cast.get("captured_dex").getAsString());
+        assertEquals(2, cast.get("slot").getAsInt());
+        assertEquals(4, cast.get("intended_distance").getAsDouble());
+        assertEquals(1, cast.getAsJsonObject("accepted_velocity").get("x").getAsDouble());
+        assertTrue(cast.getAsJsonObject("from_location").has("world_id"));
+        assertEquals(cast.getAsJsonObject("from_location").get("x").getAsDouble() + 4,
+            result.getAsJsonObject("to_location").get("x").getAsDouble());
+        assertEquals(4, result.get("horizontal_distance").getAsDouble());
+        assertEquals(cast.get("action_id").getAsString(), result.get("action_id").getAsString());
+        assertEquals(1, own.stream().filter(event -> event.get("type").getAsString().endsWith("ability.cast")).count());
+        assertEquals(1, own.stream().filter(event -> event.get("type").getAsString().endsWith("ability.resolved")).count());
     }
 
     @Test void airborneFlyingGlidingOrMountedUseRefusesBeforeCooldownAndMovement() throws Exception {
@@ -68,6 +90,14 @@ class QuickstepNativeTest {
             assertFalse(storage.find(a.core.record.id()).get().orElseThrow().cooldowns().containsKey("quickstep"));
             assertTrue(a.messages.stream().anyMatch(message -> message.contains("not eligible")));
         }
+        for (int route = 0; route < 4; route++) {
+            var own = events(data.resolve(Integer.toString(route))).stream()
+                .filter(event -> event.getAsJsonObject("data").has("ability_id")
+                    && event.getAsJsonObject("data").get("ability_id").getAsString().equals("quickstep")).toList();
+            assertEquals(1, own.stream().filter(event -> event.get("type").getAsString().endsWith("ability.resolved")
+                && event.getAsJsonObject("data").get("outcome").getAsString().equals("refused")).count());
+            assertEquals(0, own.stream().filter(event -> event.get("type").getAsString().endsWith("ability.cast")).count());
+        }
     }
 
     @Test void velocityCancellationObstacleAndUnrelatedReplacementAreAuthoritative() throws Exception {
@@ -92,17 +122,60 @@ class QuickstepNativeTest {
                 assertEquals(new Vector(0, 0.3, 0), velocity.get(), "Cancelled velocity applies no movement");
             } else if (route == 1) {
                 velocity.set(new Vector(0, 0.3, 0));
-                f.dispatcher.accept(new PlayerMoveEvent(a.player, new Location(a.world, 0, 64, 0),
-                    new Location(a.world, 0.2, 64, 0)));
+                var from = a.core.location.clone();
+                f.dispatcher.accept(new PlayerMoveEvent(a.player, from, from.clone().add(0.2, 0, 0)));
                 assertEquals(new Vector(0, 0.3, 0), velocity.get(), "Native collision stops movement early");
             } else {
                 velocity.set(new Vector(0, 0.6, 2));
-                f.dispatcher.accept(new PlayerMoveEvent(a.player, new Location(a.world, 0, 64, 0),
-                    new Location(a.world, 0.2, 64, 0)));
+                var from = a.core.location.clone();
+                f.dispatcher.accept(new PlayerMoveEvent(a.player, from, from.clone().add(0.2, 0, 0)));
                 assertEquals(new Vector(0, 0.6, 2), velocity.get(), "Replacement movement relinquishes ownership");
             }
             verify(a.player, never()).setFallDistance(anyFloat());
         }
+        for (int route = 0; route < 3; route++) {
+            var own = events(data.resolve("motion-" + route)).stream()
+                .filter(event -> event.getAsJsonObject("data").has("ability_id")
+                    && event.getAsJsonObject("data").get("ability_id").getAsString().equals("quickstep")).toList();
+            var cast = own.stream().filter(event -> event.get("type").getAsString().endsWith("ability.cast"))
+                .findFirst().orElseThrow().getAsJsonObject("data");
+            var result = own.stream().filter(event -> event.get("type").getAsString().endsWith("ability.resolved"))
+                .findFirst().orElseThrow().getAsJsonObject("data");
+            assertEquals(new String[]{"cancelled", "obstructed", "replaced"}[route],
+                result.get("outcome").getAsString());
+            assertEquals(route == 0 ? 0 : 0.2, result.get("horizontal_distance").getAsDouble(), 1.0e-8);
+            assertEquals(cast.getAsJsonObject("from_location").get("x").getAsDouble() + (route == 0 ? 0 : 0.2),
+                result.getAsJsonObject("to_location").get("x").getAsDouble(), 1.0e-8);
+            assertEquals(route == 0 ? "cancelled" : "accepted",
+                cast.get("native_velocity_status").getAsString());
+            assertEquals(route != 0, cast.has("accepted_velocity"));
+            assertEquals(1, own.stream().filter(event -> event.get("type").getAsString().endsWith("ability.resolved")).count());
+        }
+    }
+
+    @Test void crossWorldMoveInterruptsOwnedDashWithoutInventingComparableTravel() throws Exception {
+        try (var f = new FantasyStickLifecycleNativeTest.Fixture(data)) {
+            f.plugin.setEnabled(true);
+            var a = new FantasyStickLifecycleNativeTest.Actor(data); withStats(data, a, 12, true);
+            f.players.put(a.core.id, a.player); f.activate(a);
+            var velocity = prepareMovement(a, new Vector(0, 0.25, 0));
+            use(f, a); PartyBookNativeTest.drain(f); PartyBookNativeTest.drain(f);
+            var otherWorld = mock(org.bukkit.World.class);
+            when(otherWorld.getUID()).thenReturn(java.util.UUID.randomUUID());
+            when(otherWorld.getName()).thenReturn("another-test-world");
+            var from = a.core.location.clone();
+            f.dispatcher.accept(new PlayerMoveEvent(a.player, from, new Location(otherWorld, 123, 70, -8)));
+            assertEquals(new Vector(0, 0.25, 0), velocity.get());
+            f.plugin.setEnabled(false);
+        }
+        var result = events(data).stream().filter(event -> event.get("type").getAsString().endsWith("ability.resolved")
+            && event.getAsJsonObject("data").has("ability_id")
+            && event.getAsJsonObject("data").get("ability_id").getAsString().equals("quickstep"))
+            .findFirst().orElseThrow().getAsJsonObject("data");
+        assertEquals("interrupted", result.get("outcome").getAsString());
+        assertEquals("another-test-world", result.getAsJsonObject("to_location").get("world_name").getAsString());
+        assertEquals("not_comparable_cross_world", result.get("horizontal_distance_status").getAsString());
+        assertFalse(result.has("horizontal_distance"));
     }
 
     @Test void unlearnRelearnAndTransferRetainCooldownAndClearOnlyOwnedHorizontalMotion() throws Exception {
@@ -129,6 +202,90 @@ class QuickstepNativeTest {
             f.players.put(b.core.id, b.player); f.activate(b); prepareMovement(b, new Vector(0.2, 0.3, 0.4)); use(f, b);
             assertTrue(b.messages.stream().anyMatch(message -> message.contains("ready in")));
         }
+        var own = events(data).stream().filter(event -> event.getAsJsonObject("data").has("ability_id")
+            && event.getAsJsonObject("data").get("ability_id").getAsString().equals("quickstep")).toList();
+        assertEquals(1, own.stream().filter(event -> event.get("type").getAsString().endsWith("ability.unlearned")).count());
+        assertEquals(1, own.stream().filter(event -> event.get("type").getAsString().endsWith("ability.cast")).count());
+        var interruption = own.stream().filter(event -> event.get("type").getAsString().endsWith("ability.resolved")
+            && event.getAsJsonObject("data").get("outcome").getAsString().equals("interrupted")).toList();
+        assertEquals(1, interruption.size());
+        assertTrue(interruption.getFirst().getAsJsonObject("data").getAsJsonObject("to_location").has("world_id"));
+    }
+
+    @Test void restartedNewHolderCannotRepeatCommittedDashBeforeTheOriginalDeadline() throws Exception {
+        java.nio.file.Files.writeString(data.resolve("config.yml"), "quickstep-cooldown-seconds: 60\n");
+        org.bukkit.inventory.ItemStack sheet;
+        try (var f = new FantasyStickLifecycleNativeTest.Fixture(data)) {
+            f.plugin.setEnabled(true);
+            var a = new FantasyStickLifecycleNativeTest.Actor(data); withStats(data, a, 12, true);
+            f.players.put(a.core.id, a.player); f.activate(a); prepareMovement(a, new Vector(0, 0.25, 0));
+            use(f, a); PartyBookNativeTest.drain(f); PartyBookNativeTest.drain(f);
+            verify(a.player, times(1)).setVelocity(new Vector(1, 0.25, 0));
+            sheet = a.core.inventory.getItemInOffHand().clone();
+            a.core.inventory.setItemInOffHand(null); f.changed(a); PartyBookNativeTest.drain(f); f.awaitCharacterAndReceipt(a);
+            f.plugin.setEnabled(false);
+        }
+        try (var f = new FantasyStickLifecycleNativeTest.Fixture(data)) {
+            f.plugin.setEnabled(true);
+            var b = new FantasyStickLifecycleNativeTest.Actor(data);
+            b.core.inventory.setItemInOffHand(sheet); f.players.put(b.core.id, b.player); f.activate(b);
+            prepareMovement(b, new Vector(0, 0.3, 0)); use(f, b);
+            verify(b.player, never()).setVelocity(any(Vector.class));
+            assertTrue(b.messages.stream().anyMatch(message -> message.contains("ready in")));
+            f.plugin.setEnabled(false);
+        }
+        var own = events(data).stream().filter(event -> event.getAsJsonObject("data").has("ability_id")
+            && event.getAsJsonObject("data").get("ability_id").getAsString().equals("quickstep")).toList();
+        assertEquals(1, own.stream().filter(event -> event.get("type").getAsString().endsWith("ability.cast")).count());
+        var outcomes = own.stream().filter(event -> event.get("type").getAsString().endsWith("ability.resolved"))
+            .map(event -> event.getAsJsonObject("data").get("outcome").getAsString()).toList();
+        assertEquals(2, outcomes.size(), outcomes.toString());
+        assertEquals(java.util.Set.of("completed", "refused"), java.util.Set.copyOf(outcomes),
+            "Original bounded window ended before transfer; restart only refuses its retained deadline");
+    }
+
+    @Test void airborneAfterCooldownAcknowledgmentCannotClaimCompletedMovement() throws Exception {
+        try (var f = new FantasyStickLifecycleNativeTest.Fixture(data)) {
+            f.plugin.setEnabled(true);
+            var a = new FantasyStickLifecycleNativeTest.Actor(data); withStats(data, a, 12, true);
+            f.players.put(a.core.id, a.player); f.activate(a); prepareMovement(a, new Vector(0, 0.4, 0));
+            use(f, a);
+            var response = f.tasks.poll(5, java.util.concurrent.TimeUnit.SECONDS); assertNotNull(response);
+            doReturn(false).when(a.player).isOnGround(); response.run();
+            verify(a.player, never()).setVelocity(any(Vector.class));
+            f.plugin.setEnabled(false);
+        }
+        var own = events(data).stream().filter(event -> event.getAsJsonObject("data").has("ability_id")
+            && event.getAsJsonObject("data").get("ability_id").getAsString().equals("quickstep")).toList();
+        var cast = own.stream().filter(event -> event.get("type").getAsString().endsWith("ability.cast"))
+            .findFirst().orElseThrow().getAsJsonObject("data");
+        assertEquals("cancelled", cast.get("native_velocity_status").getAsString());
+        assertTrue(cast.getAsJsonObject("from_location").has("world_id"));
+        assertEquals(1, own.stream().filter(event -> event.get("type").getAsString().endsWith("ability.resolved")
+            && event.getAsJsonObject("data").get("outcome").getAsString().equals("cancelled")).count());
+    }
+
+    @Test void failedNativeCooldownSaveEmitsFailureWithoutAClaimedDashOrVelocity() throws Exception {
+        try (var f = new FantasyStickLifecycleNativeTest.Fixture(data)) {
+            f.plugin.setEnabled(true);
+            var a = new FantasyStickLifecycleNativeTest.Actor(data); withStats(data, a, 12, true);
+            f.players.put(a.core.id, a.player); f.activate(a); prepareMovement(a, new Vector(0, 0.4, 0));
+            var storage = (CharacterStorage) FantasyStickLifecycleNativeTest.Fixture.field(f.plugin, "characters");
+            storage.close();
+            use(f, a);
+            for (int tries = 0; tries < 4 && a.messages.stream().noneMatch(message -> message.contains("could not be saved")); tries++) {
+                var response = f.tasks.poll(5, java.util.concurrent.TimeUnit.SECONDS);
+                assertNotNull(response); response.run();
+            }
+            assertTrue(a.messages.stream().anyMatch(message -> message.contains("could not be saved")));
+            verify(a.player, never()).setVelocity(any(Vector.class));
+            f.plugin.setEnabled(false);
+        }
+        var own = events(data).stream().filter(event -> event.getAsJsonObject("data").has("ability_id")
+            && event.getAsJsonObject("data").get("ability_id").getAsString().equals("quickstep")).toList();
+        assertEquals(1, own.stream().filter(event -> event.get("type").getAsString().endsWith("ability.resolved")
+            && event.getAsJsonObject("data").get("outcome").getAsString().equals("failed")).count());
+        assertEquals(0, own.stream().filter(event -> event.get("type").getAsString().endsWith("ability.cast")).count());
     }
 
     @Test void failedCooldownPersistenceAppliesNoVelocity() {
@@ -166,6 +323,38 @@ class QuickstepNativeTest {
         engine.close(); quickstep.close(); parties.close();
     }
 
+    @Test void authorizedRegisteredConfigurationReadAndAcknowledgedChangeReachJsonlButFailuresDoNot() throws Exception {
+        try (var f = new FantasyStickLifecycleNativeTest.Fixture(data)) {
+            f.plugin.setEnabled(true);
+            var admin = new EquipmentAdminCommandNativeTest.Sender(); admin.allowed = true;
+            f.command.execute(admin.port, "fstickadmin", new String[]{"config", "quickstep-distance-blocks"});
+            assertTrue(admin.messages.getLast().contains("quickstep-distance-blocks=4"));
+            f.command.execute(admin.port, "fstickadmin", new String[]{"config", "quickstep-distance-blocks", "7"});
+            var saved = f.tasks.poll(5, java.util.concurrent.TimeUnit.SECONDS); assertNotNull(saved); saved.run();
+            var registry = (games.dmg.fantasystick.ability.AbilityRegistry)
+                FantasyStickLifecycleNativeTest.Fixture.field(f.plugin, "abilityRegistry");
+            assertEquals(new java.math.BigDecimal("7"), registry.find("quickstep").orElseThrow()
+                .parameters().get("distance"));
+            try (var channel = java.nio.channels.FileChannel.open(data.resolve(".config.lock"),
+                    java.nio.file.StandardOpenOption.CREATE, java.nio.file.StandardOpenOption.WRITE);
+                 var lock = channel.lock()) {
+                assertTrue(lock.isValid());
+                f.command.execute(admin.port, "fstickadmin", new String[]{"config", "quickstep-distance-blocks", "9"});
+                var failed = f.tasks.poll(5, java.util.concurrent.TimeUnit.SECONDS); assertNotNull(failed); failed.run();
+            }
+            admin.allowed = false;
+            f.command.execute(admin.port, "fstickadmin", new String[]{"config", "quickstep-distance-blocks"});
+            f.plugin.setEnabled(false);
+        }
+        var config = events(data).stream().filter(event -> event.getAsJsonObject("data").has("ability_id")
+            && event.getAsJsonObject("data").get("ability_id").getAsString().equals("quickstep")
+            && (event.get("type").getAsString().endsWith("config.read")
+                || event.get("type").getAsString().endsWith("config.changed"))).toList();
+        assertEquals(2, config.size());
+        assertEquals("4", config.getLast().getAsJsonObject("data").get("before").getAsString());
+        assertEquals("7", config.getLast().getAsJsonObject("data").get("after").getAsString());
+    }
+
     @Test void acknowledgedUpdatesAffectFutureDashesWhileActiveDashKeepsCapturedBounds() throws Exception {
         try (var f = new FantasyStickLifecycleNativeTest.Fixture(data)) {
             f.plugin.setEnabled(true);
@@ -240,6 +429,20 @@ class QuickstepNativeTest {
         }
     }
 
+    private static java.util.List<com.google.gson.JsonObject> events(Path data) throws Exception {
+        var results = new java.util.ArrayList<com.google.gson.JsonObject>();
+        try (var days = java.nio.file.Files.list(data.resolve("events"))) {
+            for (var day : days.filter(path -> path.getFileName().toString().matches("\\d{4}-\\d{2}-\\d{2}")).toList()) {
+                try (var segments = java.nio.file.Files.list(day)) {
+                    for (var path : segments.filter(file -> file.getFileName().toString().endsWith(".jsonl")).toList())
+                        for (var line : java.nio.file.Files.readAllLines(path))
+                            if (!line.isBlank()) results.add(com.google.gson.JsonParser.parseString(line).getAsJsonObject());
+                }
+            }
+        }
+        return results;
+    }
+
     private static void learnAndAssign(FantasyStickLifecycleNativeTest.Fixture fixture,
                                        FantasyStickLifecycleNativeTest.Actor actor) throws Exception {
         actor.core.inventory.getInventory().setSelectedSlot(0); PartyBookNativeTest.open(fixture, actor);

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

@@ -25,10 +25,16 @@ class SecondWindNativeTest {
     @BeforeAll static void bootstrap() throws Exception { NativeRuntime.bootstrap(); }
 
     @Test void bookAcquisitionActualNativeHealPersistsBeforePublicationAndRetainsCooldown() throws Exception {
+        java.util.UUID expectedPlayer, expectedCharacter, expectedSession, expectedWorld;
         try (var f = new FantasyStickLifecycleNativeTest.Fixture(data)) {
             f.plugin.setEnabled(true);
             var a = new FantasyStickLifecycleNativeTest.Actor(data); withSecondWind(data, a, false, BigDecimal.valueOf(4));
             f.players.put(a.core.id, a.player); f.activate(a);
+            expectedPlayer = a.core.id; expectedCharacter = a.core.record.id();
+            expectedSession = ((games.dmg.fantasystick.session.EquipmentSessions)
+                FantasyStickLifecycleNativeTest.Fixture.field(f.plugin, "sessions"))
+                .active(expectedPlayer).orElseThrow().session();
+            expectedWorld = a.core.location.getWorld().getUID();
             a.core.inventory.getInventory().setSelectedSlot(0); PartyBookNativeTest.open(f, a);
             String text = PartyBookNativeTest.text(a).replaceAll("\\s+", "");
             assertTrue(text.contains("SecondWind")); assertTrue(text.contains("CON12")); assertTrue(text.contains("WIS12"));
@@ -57,6 +63,34 @@ class SecondWindNativeTest {
             learnAndAssign(f, a); use(f, a);
             assertTrue(a.messages.stream().anyMatch(message -> message.contains("ready in")));
         }
+        var own = events(data).stream().filter(event -> event.getAsJsonObject("data").has("ability_id")
+            && event.getAsJsonObject("data").get("ability_id").getAsString().equals("second_wind")).toList();
+        assertEquals(2, own.stream().filter(event -> event.get("type").getAsString().endsWith("ability.learned")).count());
+        assertEquals(2, own.stream().filter(event -> event.get("type").getAsString().endsWith("ability.assigned")).count());
+        assertEquals(1, own.stream().filter(event -> event.get("type").getAsString().endsWith("ability.unlearned")).count());
+        var cast = own.stream().filter(event -> event.get("type").getAsString().endsWith("ability.cast"))
+            .findFirst().orElseThrow().getAsJsonObject("data");
+        var healed = own.stream().filter(event -> event.get("type").getAsString().endsWith("combat.healed"))
+            .findFirst().orElseThrow().getAsJsonObject("data");
+        assertEquals(2, cast.get("slot").getAsInt());
+        assertEquals("12", cast.get("captured_wis").getAsString());
+        assertTrue(cast.has("cooldown_until"));
+        assertEquals(cast.get("action_id").getAsString(), healed.get("action_id").getAsString());
+        assertEquals(expectedPlayer.toString(), cast.get("player_id").getAsString());
+        assertEquals(expectedCharacter.toString(), cast.get("character_id").getAsString());
+        assertEquals(expectedSession.toString(), cast.get("session_id").getAsString());
+        assertEquals(expectedPlayer.toString(), healed.get("target_player_id").getAsString());
+        assertEquals(expectedCharacter.toString(), healed.get("target_character_id").getAsString());
+        assertEquals(expectedSession.toString(), healed.get("target_session_id").getAsString());
+        assertEquals(expectedWorld.toString(), healed.getAsJsonObject("target_location").get("world_id").getAsString());
+        assertEquals("4", healed.get("health_before").getAsString());
+        assertEquals("11", healed.get("health_after").getAsString());
+        assertEquals("7", healed.get("actual_amount").getAsString());
+        assertEquals("7", healed.get("requested_amount").getAsString());
+        assertTrue(healed.getAsJsonObject("target_location").has("world_id"));
+        assertEquals(1, own.stream().filter(event -> event.get("type").getAsString().endsWith("combat.healed")).count());
+        assertEquals(1, own.stream().filter(event -> event.get("type").getAsString().endsWith("ability.resolved")
+            && event.getAsJsonObject("data").get("outcome").getAsString().equals("healed")).count());
     }
 
     @Test void fullHealthAndCancelledNativeHealingApplyNoHealth() throws Exception {
@@ -82,6 +116,114 @@ class SecondWindNativeTest {
             if (full) assertFalse(saved.cooldowns().containsKey("second_wind"));
             else assertNotNull(saved.cooldowns().get("second_wind"));
         }
+        for (boolean full : new boolean[]{true, false}) {
+            var own = events(data.resolve(Boolean.toString(full))).stream()
+                .filter(event -> event.getAsJsonObject("data").has("ability_id")
+                    && event.getAsJsonObject("data").get("ability_id").getAsString().equals("second_wind")).toList();
+            assertEquals(full ? 0 : 1, own.stream().filter(event -> event.get("type").getAsString().endsWith("ability.cast")).count());
+            assertEquals(1, own.stream().filter(event -> event.get("type").getAsString().endsWith("ability.resolved")
+                && event.getAsJsonObject("data").get("outcome").getAsString().equals(full ? "refused" : "cancelled")).count());
+            assertEquals(0, own.stream().filter(event -> event.get("type").getAsString().endsWith("combat.healed")).count());
+        }
+    }
+
+    @Test void nativeAdjustedHealIsAuditedDespiteDisabledRoutineFeedback() throws Exception {
+        try (var f = new FantasyStickLifecycleNativeTest.Fixture(data)) {
+            f.plugin.setEnabled(true);
+            var a = new FantasyStickLifecycleNativeTest.Actor(data);
+            withSecondWind(data, a, true, BigDecimal.valueOf(4));
+            f.players.put(a.core.id, a.player); f.activate(a);
+            assertTrue(f.feedbackCommand.execute(a.player, "fantasyfeedback", new String[]{"off"}));
+            f.tick();
+            class Reduce implements org.bukkit.event.Listener {
+                @org.bukkit.event.EventHandler public void heal(EntityRegainHealthEvent event) {
+                    if (event.getEntity() == a.player && event.getRegainReason() == EntityRegainHealthEvent.RegainReason.CUSTOM)
+                        event.setAmount(2);
+                }
+            }
+            f.dispatcher.register(new Reduce(), f.plugin);
+            use(f, a); PartyBookNativeTest.drain(f); PartyBookNativeTest.drain(f); PartyBookNativeTest.drain(f);
+            assertEquals(6, a.player.getHealth());
+            assertFalse(a.messages.stream().anyMatch(message -> message.contains("Second Wind healed")));
+            f.plugin.setEnabled(false);
+        }
+        var own = events(data).stream().filter(event -> event.getAsJsonObject("data").has("ability_id")
+            && event.getAsJsonObject("data").get("ability_id").getAsString().equals("second_wind")).toList();
+        assertEquals(1, own.stream().filter(event -> event.get("type").getAsString().endsWith("combat.healed")).count());
+        var healed = own.stream().filter(event -> event.get("type").getAsString().endsWith("combat.healed"))
+            .findFirst().orElseThrow().getAsJsonObject("data");
+        assertEquals("7", healed.get("requested_amount").getAsString());
+        assertEquals("2", healed.get("actual_amount").getAsString());
+        assertEquals("6", healed.get("health_after").getAsString());
+    }
+
+    @Test void rejectedEventStoreDoesNotChangeApprovedSelfHealingOrDurableHealth() throws Exception {
+        try (var f = new FantasyStickLifecycleNativeTest.Fixture(data)) {
+            f.plugin.setEnabled(true);
+            var a = new FantasyStickLifecycleNativeTest.Actor(data);
+            withSecondWind(data, a, true, BigDecimal.valueOf(4));
+            f.players.put(a.core.id, a.player); f.activate(a);
+            var eventLog = (games.dmg.fantasystick.events.LocalEventLog)
+                FantasyStickLifecycleNativeTest.Fixture.field(f.plugin, "eventLog");
+            eventLog.close();
+            use(f, a); PartyBookNativeTest.drain(f); PartyBookNativeTest.drain(f); PartyBookNativeTest.drain(f);
+            assertEquals(11, a.player.getHealth());
+            var storage = (CharacterStorage) FantasyStickLifecycleNativeTest.Fixture.field(f.plugin, "characters");
+            assertEquals(0, BigDecimal.valueOf(11).compareTo(storage.find(a.core.record.id()).get().orElseThrow().health()));
+            f.plugin.setEnabled(false);
+        }
+        assertEquals(0, events(data).stream().filter(event -> event.get("type").getAsString().endsWith("combat.healed"))
+            .count(), "A rejected audit record cannot manufacture healing or undo real native health");
+    }
+
+    @Test void staleHealthRevisionAfterCooldownCannotClaimAHealOrOverwriteAnotherWrite() throws Exception {
+        try (var f = new FantasyStickLifecycleNativeTest.Fixture(data)) {
+            f.plugin.setEnabled(true);
+            var a = new FantasyStickLifecycleNativeTest.Actor(data);
+            withSecondWind(data, a, true, BigDecimal.valueOf(4));
+            f.players.put(a.core.id, a.player); f.activate(a); use(f, a);
+            var cooldownResponse = f.tasks.poll(5, java.util.concurrent.TimeUnit.SECONDS); assertNotNull(cooldownResponse);
+            var storage = (CharacterStorage) FantasyStickLifecycleNativeTest.Fixture.field(f.plugin, "characters");
+            var before = storage.find(a.core.record.id()).get().orElseThrow();
+            assertNotNull(before.cooldowns().get("second_wind"));
+            assertTrue(storage.saveHealth(before.id(), before.revision(), BigDecimal.valueOf(5),
+                BigDecimal.valueOf(1024)).get().isPresent());
+            cooldownResponse.run();
+            var healthResponse = f.tasks.poll(5, java.util.concurrent.TimeUnit.SECONDS); assertNotNull(healthResponse);
+            healthResponse.run();
+            assertEquals(4, a.player.getHealth(), "Stale Second Wind cannot publish native health");
+            assertEquals(0, BigDecimal.valueOf(5).compareTo(storage.find(before.id()).get().orElseThrow().health()));
+            f.plugin.setEnabled(false);
+        }
+        var own = events(data).stream().filter(event -> event.getAsJsonObject("data").has("ability_id")
+            && event.getAsJsonObject("data").get("ability_id").getAsString().equals("second_wind")).toList();
+        assertEquals(1, own.stream().filter(event -> event.get("type").getAsString().endsWith("ability.resolved")
+            && event.getAsJsonObject("data").get("outcome").getAsString().equals("failed")).count());
+        assertEquals(0, own.stream().filter(event -> event.get("type").getAsString().endsWith("combat.healed")).count());
+    }
+
+    @Test void failedHealthSaveAfterAcknowledgedCooldownNeverClaimsNativeHealing() throws Exception {
+        try (var f = new FantasyStickLifecycleNativeTest.Fixture(data)) {
+            f.plugin.setEnabled(true);
+            var a = new FantasyStickLifecycleNativeTest.Actor(data);
+            withSecondWind(data, a, true, BigDecimal.valueOf(4));
+            f.players.put(a.core.id, a.player); f.activate(a);
+            use(f, a);
+            var cooldownResponse = f.tasks.poll(5, java.util.concurrent.TimeUnit.SECONDS);
+            assertNotNull(cooldownResponse, "Cooldown must commit before the health-save failure");
+            var storage = (CharacterStorage) FantasyStickLifecycleNativeTest.Fixture.field(f.plugin, "characters");
+            storage.close(); cooldownResponse.run();
+            var healthResponse = f.tasks.poll(5, java.util.concurrent.TimeUnit.SECONDS);
+            assertNotNull(healthResponse); healthResponse.run();
+            assertEquals(4, a.player.getHealth(), "Failed health save cannot publish native health");
+            f.plugin.setEnabled(false);
+        }
+        var own = events(data).stream().filter(event -> event.getAsJsonObject("data").has("ability_id")
+            && event.getAsJsonObject("data").get("ability_id").getAsString().equals("second_wind")).toList();
+        assertEquals(1, own.stream().filter(event -> event.get("type").getAsString().endsWith("ability.cast")).count());
+        assertEquals(1, own.stream().filter(event -> event.get("type").getAsString().endsWith("ability.resolved")
+            && event.getAsJsonObject("data").get("outcome").getAsString().equals("failed")).count());
+        assertEquals(0, own.stream().filter(event -> event.get("type").getAsString().endsWith("combat.healed")).count());
     }
 
     @Test void failedHealthPersistencePublishesNoNativeHealing() {
@@ -116,6 +258,38 @@ class SecondWindNativeTest {
         verify(player, never()).setHealth(anyDouble()); verify(execution).finish();
     }
 
+    @Test void authorizedRegisteredConfigurationReadAndAcknowledgedChangeReachJsonlOnlyAfterSave() throws Exception {
+        try (var f = new FantasyStickLifecycleNativeTest.Fixture(data)) {
+            f.plugin.setEnabled(true);
+            var admin = new EquipmentAdminCommandNativeTest.Sender(); admin.allowed = true;
+            f.command.execute(admin.port, "fstickadmin", new String[]{"config", "second-wind-base-healing"});
+            assertTrue(admin.messages.getLast().contains("second-wind-base-healing=6"));
+            f.command.execute(admin.port, "fstickadmin", new String[]{"config", "second-wind-base-healing", "9"});
+            var saved = f.tasks.poll(5, java.util.concurrent.TimeUnit.SECONDS); assertNotNull(saved); saved.run();
+            var registry = (games.dmg.fantasystick.ability.AbilityRegistry)
+                FantasyStickLifecycleNativeTest.Fixture.field(f.plugin, "abilityRegistry");
+            assertEquals(new BigDecimal("9"), registry.find("second_wind").orElseThrow()
+                .parameters().get("base-healing"));
+            try (var channel = java.nio.channels.FileChannel.open(data.resolve(".config.lock"),
+                    java.nio.file.StandardOpenOption.CREATE, java.nio.file.StandardOpenOption.WRITE);
+                 var lock = channel.lock()) {
+                assertTrue(lock.isValid());
+                f.command.execute(admin.port, "fstickadmin", new String[]{"config", "second-wind-base-healing", "11"});
+                var failed = f.tasks.poll(5, java.util.concurrent.TimeUnit.SECONDS); assertNotNull(failed); failed.run();
+            }
+            admin.allowed = false;
+            f.command.execute(admin.port, "fstickadmin", new String[]{"config", "second-wind-base-healing"});
+            f.plugin.setEnabled(false);
+        }
+        var config = events(data).stream().filter(event -> event.getAsJsonObject("data").has("ability_id")
+            && event.getAsJsonObject("data").get("ability_id").getAsString().equals("second_wind")
+            && (event.get("type").getAsString().endsWith("config.read")
+                || event.get("type").getAsString().endsWith("config.changed"))).toList();
+        assertEquals(2, config.size(), "Denied reads and failed writes cannot claim success");
+        assertEquals("6", config.getLast().getAsJsonObject("data").get("before").getAsString());
+        assertEquals("9", config.getLast().getAsJsonObject("data").get("after").getAsString());
+    }
+
     @Test void configuredDefinitionFormulaAndAdminRoutesCoverBothSettings() throws Exception {
         java.nio.file.Files.writeString(data.resolve("config.yml"),
             "second-wind-base-healing: 8\nsecond-wind-cooldown-seconds: 20\n");
@@ -168,6 +342,20 @@ class SecondWindNativeTest {
         }
     }
 
+    private static java.util.List<com.google.gson.JsonObject> events(Path data) throws Exception {
+        var results = new java.util.ArrayList<com.google.gson.JsonObject>();
+        try (var days = java.nio.file.Files.list(data.resolve("events"))) {
+            for (var day : days.filter(path -> path.getFileName().toString().matches("\\d{4}-\\d{2}-\\d{2}")).toList()) {
+                try (var segments = java.nio.file.Files.list(day)) {
+                    for (var path : segments.filter(file -> file.getFileName().toString().endsWith(".jsonl")).toList())
+                        for (var line : java.nio.file.Files.readAllLines(path))
+                            if (!line.isBlank()) results.add(com.google.gson.JsonParser.parseString(line).getAsJsonObject());
+                }
+            }
+        }
+        return results;
+    }
+
     private static void learnAndAssign(FantasyStickLifecycleNativeTest.Fixture fixture,
                                        FantasyStickLifecycleNativeTest.Actor actor) throws Exception {
         actor.core.inventory.getInventory().setSelectedSlot(0); PartyBookNativeTest.open(fixture, actor);

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

@@ -18,6 +18,20 @@ class SessionRecoveryEventsNativeTest {
     @TempDir Path data;
     @BeforeAll static void bootstrap() throws Exception { NativeRuntime.bootstrap(); }
 
+    @Test void recoveryReaderCountsOnlyExportedUtcDaySegments() throws Exception {
+        Path events = data.resolve("events");
+        Path pending = events.resolve("pending");
+        Path exported = events.resolve(java.time.LocalDate.now(java.time.ZoneOffset.UTC).toString());
+        Files.createDirectories(pending);
+        Files.createDirectories(exported);
+        Files.writeString(pending.resolve("unexported.jsonl"), "{\"type\":\"phantom.recovery\"}\n");
+        Files.writeString(exported.resolve("events-test-0.jsonl"), "{\"type\":\"recovery.resolved\"}\n");
+
+        var records = records();
+        assertEquals(1, records.size(), "Pending records are not exported delivery");
+        assertEquals("recovery.resolved", records.getFirst().get("type").getAsString());
+    }
+
     @Test void registeredAuthorizedInspectionOfPendingReceiptIsRecordedWithoutEquipmentContents() throws Exception {
         try (var fixture = new FantasyStickLifecycleNativeTest.Fixture(data)) {
             fixture.plugin.setEnabled(true);
@@ -502,13 +516,19 @@ class SessionRecoveryEventsNativeTest {
         var result = new ArrayList<JsonObject>();
         Path directory = data.resolve("events");
         if (!Files.exists(directory)) return result;
-        try (var files = Files.walk(directory)) {
-            for (var path : files.filter(item -> item.getFileName().toString().endsWith(".jsonl")).toList()) {
-                var contents = Files.readString(path);
-                int end = contents.lastIndexOf('\n');
-                if (end < 0) continue;
-                for (var line : contents.substring(0, end).lines().toList())
-                    if (!line.isBlank()) result.add(JsonParser.parseString(line).getAsJsonObject());
+        try (var days = Files.list(directory)) {
+            for (var day : days.filter(path -> path.getFileName().toString()
+                    .matches("\\d{4}-\\d{2}-\\d{2}")).toList()) {
+                try (var segments = Files.list(day)) {
+                    for (var path : segments.filter(item -> item.getFileName().toString().startsWith("events-")
+                            && item.getFileName().toString().endsWith(".jsonl")).toList()) {
+                        var contents = Files.readString(path);
+                        int end = contents.lastIndexOf('\n');
+                        if (end < 0) continue;
+                        for (var line : contents.substring(0, end).lines().toList())
+                            if (!line.isBlank()) result.add(JsonParser.parseString(line).getAsJsonObject());
+                    }
+                }
             }
         }
         return result;

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

@@ -25,10 +25,15 @@ class ShieldBashNativeTest {
     @BeforeAll static void bootstrap() throws Exception { NativeRuntime.bootstrap(); }
 
     @Test void bookAcquisitionAndEquippedAttackReplaceVanillaDamageThenKnockBack() throws Exception {
+        java.util.UUID playerId, characterId, sessionId, targetId, worldId;
         try (var f = new FantasyStickLifecycleNativeTest.Fixture(data)) {
             f.plugin.setEnabled(true);
             var a = new FantasyStickLifecycleNativeTest.Actor(data); withShieldBash(data, a, false);
             f.players.put(a.core.id, a.player); f.activate(a);
+            playerId = a.core.id; characterId = a.core.record.id();
+            sessionId = ((games.dmg.fantasystick.session.EquipmentSessions)
+                FantasyStickLifecycleNativeTest.Fixture.field(f.plugin, "sessions"))
+                .active(playerId).orElseThrow().session();
             a.core.inventory.getInventory().setSelectedSlot(0); PartyBookNativeTest.open(f, a);
             String book = PartyBookNativeTest.text(a).replaceAll("\\s+", "");
             assertTrue(book.contains("ShieldBash")); assertTrue(book.contains("STR12")); assertTrue(book.contains("CON12"));
@@ -46,18 +51,23 @@ class ShieldBashNativeTest {
             assertFalse(storage.find(a.core.record.id()).get().orElseThrow().cooldowns().containsKey("shield_bash"));
 
             var target = mock(org.bukkit.entity.LivingEntity.class);
-            when(target.getUniqueId()).thenReturn(java.util.UUID.randomUUID()); when(target.getType()).thenReturn(org.bukkit.entity.EntityType.ZOMBIE);
-            when(a.world.getUID()).thenReturn(java.util.UUID.randomUUID());
+            targetId = java.util.UUID.randomUUID(); when(target.getUniqueId()).thenReturn(targetId);
+            when(target.getType()).thenReturn(org.bukkit.entity.EntityType.ZOMBIE);
+            worldId = java.util.UUID.randomUUID(); when(a.world.getUID()).thenReturn(worldId);
             var origin = new Location(a.world, 0, 64, 0); var destination = new Location(a.world, 2, 64, 0);
             doReturn(origin).when(a.player).getLocation(); when(target.getLocation()).thenReturn(destination);
             doReturn(true).when(a.player).hasLineOfSight(target); when(target.getVelocity()).thenReturn(new Vector(0.1, 0.2, 0));
+            var targetHealth = new java.util.concurrent.atomic.AtomicReference<>(20.0);
+            when(target.getHealth()).thenAnswer(ignored -> targetHealth.get());
             var applied = new java.util.concurrent.atomic.AtomicReference<Vector>();
             doAnswer(call -> { applied.set(call.getArgument(0)); return null; }).when(target).setVelocity(any(Vector.class));
             var damages = new java.util.ArrayList<EntityDamageByEntityEvent>();
             doAnswer(call -> {
                 var source = (org.bukkit.damage.DamageSource) call.getArgument(1);
                 var event = new EntityDamageByEntityEvent(a.player, target, EntityDamageEvent.DamageCause.ENTITY_ATTACK,
-                    source, (Double) call.getArgument(0)); damages.add(event); f.dispatcher.accept(event); return null;
+                    source, (Double) call.getArgument(0)); damages.add(event); f.dispatcher.accept(event);
+                if (!event.isCancelled()) targetHealth.updateAndGet(health -> Math.max(0, health - event.getFinalDamage()));
+                return null;
             }).when(target).damage(anyDouble(), any(org.bukkit.damage.DamageSource.class));
             a.core.inventory.getInventory().setSelectedSlot(2);
             var attack = new io.papermc.paper.event.player.PrePlayerAttackEntityEvent(a.player, target, true);
@@ -73,6 +83,30 @@ class ShieldBashNativeTest {
             PartyBookNativeTest.drain(f); assertEquals(1, damages.size());
             assertTrue(a.messages.stream().anyMatch(message -> message.contains("ready in")));
         }
+        var own = events(data).stream().filter(event -> event.getAsJsonObject("data").has("ability_id")
+            && event.getAsJsonObject("data").get("ability_id").getAsString().equals("shield_bash")).toList();
+        assertEquals(1, count(own, "ability.learned"));
+        assertEquals(1, count(own, "ability.assigned"));
+        assertEquals(1, count(own, "ability.cast"));
+        assertEquals(1, count(own, "combat.damage"));
+        assertEquals(1, count(own, "effect.applied"));
+        var cast = record(own, "ability.cast"); var damage = record(own, "combat.damage");
+        var knockback = record(own, "effect.applied"); var resolution = record(own, "ability.resolved");
+        assertEquals(2, cast.get("slot").getAsInt()); assertTrue(cast.has("cooldown_until"));
+        assertEquals(playerId.toString(), damage.get("player_id").getAsString());
+        assertEquals(characterId.toString(), damage.get("character_id").getAsString());
+        assertEquals(sessionId.toString(), damage.get("session_id").getAsString());
+        assertEquals(targetId.toString(), damage.get("target_entity_id").getAsString());
+        assertEquals(worldId.toString(), damage.getAsJsonObject("target_location").get("world_id").getAsString());
+        assertEquals(5, damage.get("requested_amount").getAsDouble(), 1.0e-9);
+        assertEquals(5, damage.get("actual_amount").getAsDouble(), 1.0e-9);
+        assertEquals("20", damage.get("target_health_before").getAsString());
+        assertEquals("15", damage.get("target_health_after").getAsString());
+        assertEquals(cast.get("action_id").getAsString(), damage.get("action_id").getAsString());
+        assertEquals(cast.get("action_id").getAsString(), knockback.get("action_id").getAsString());
+        assertEquals("shield_bash_knockback", knockback.get("effect_id").getAsString());
+        assertEquals("hit", resolution.get("outcome").getAsString());
+        assertEquals("native_velocity_accepted", resolution.get("knockback_status").getAsString());
     }
 
     @Test void outOfRangeOrObstructedTargetRefusesBeforeCooldownWhileStillContainingShield() throws Exception {
@@ -93,6 +127,11 @@ class ShieldBashNativeTest {
                 var storage = (CharacterStorage) FantasyStickLifecycleNativeTest.Fixture.field(f.plugin, "characters");
                 assertFalse(storage.find(a.core.record.id()).get().orElseThrow().cooldowns().containsKey("shield_bash"));
             }
+            var own = events(directory).stream().filter(event -> event.getAsJsonObject("data").has("ability_id")
+                && event.getAsJsonObject("data").get("ability_id").getAsString().equals("shield_bash")).toList();
+            assertEquals(0, count(own, "ability.cast"));
+            assertEquals(0, count(own, "combat.damage"));
+            assertEquals("refused", record(own, "ability.resolved").get("outcome").getAsString());
         }
     }
 
@@ -132,6 +171,40 @@ class ShieldBashNativeTest {
             var storage = (CharacterStorage) FantasyStickLifecycleNativeTest.Fixture.field(f.plugin, "characters");
             assertNotNull(storage.find(a.core.record.id()).get().orElseThrow().cooldowns().get("shield_bash"));
         }
+        var own = events(data).stream().filter(event -> event.getAsJsonObject("data").has("ability_id")
+            && event.getAsJsonObject("data").get("ability_id").getAsString().equals("shield_bash")).toList();
+        assertEquals(1, count(own, "ability.cast"));
+        assertEquals(0, count(own, "combat.damage"));
+        assertEquals(0, count(own, "effect.applied"));
+        assertEquals("cancelled", record(own, "ability.resolved").get("outcome").getAsString());
+    }
+
+    @Test void zeroFinalNativeDamageNeverClaimsAHeldShieldHitOrKnockback() throws Exception {
+        try (var f = new FantasyStickLifecycleNativeTest.Fixture(data)) {
+            f.plugin.setEnabled(true); var a = new FantasyStickLifecycleNativeTest.Actor(data);
+            withShieldBash(data, a, true); f.players.put(a.core.id, a.player); f.activate(a);
+            var target = mock(org.bukkit.entity.LivingEntity.class);
+            when(target.getUniqueId()).thenReturn(java.util.UUID.randomUUID());
+            when(target.getType()).thenReturn(org.bukkit.entity.EntityType.ZOMBIE);
+            doReturn(new Location(a.world, 0, 64, 0)).when(a.player).getLocation();
+            when(target.getLocation()).thenReturn(new Location(a.world, 2, 64, 0));
+            doReturn(true).when(a.player).hasLineOfSight(target);
+            doAnswer(call -> {
+                var source = (org.bukkit.damage.DamageSource) call.getArgument(1);
+                var event = new EntityDamageByEntityEvent(a.player, target, EntityDamageEvent.DamageCause.ENTITY_ATTACK,
+                    source, (Double) call.getArgument(0)); event.setDamage(0); f.dispatcher.accept(event); return null;
+            }).when(target).damage(anyDouble(), any(org.bukkit.damage.DamageSource.class));
+            a.core.inventory.getInventory().setSelectedSlot(2);
+            f.dispatcher.accept(new io.papermc.paper.event.player.PrePlayerAttackEntityEvent(a.player, target, true));
+            PartyBookNativeTest.drain(f); PartyBookNativeTest.drain(f);
+            verify(target, never()).setVelocity(any(Vector.class));
+        }
+        var own = events(data).stream().filter(event -> event.getAsJsonObject("data").has("ability_id")
+            && event.getAsJsonObject("data").get("ability_id").getAsString().equals("shield_bash")).toList();
+        assertEquals(1, count(own, "ability.cast"));
+        assertEquals(0, count(own, "combat.damage"));
+        assertEquals(0, count(own, "effect.applied"));
+        assertEquals("miss", record(own, "ability.resolved").get("outcome").getAsString());
     }
 
     @Test void cancelledPlayerVelocityPreservesMovementAfterAcceptedDamage() throws Exception {
@@ -157,6 +230,81 @@ class ShieldBashNativeTest {
             f.dispatcher.accept(new io.papermc.paper.event.player.PrePlayerAttackEntityEvent(a.player, b.player, true));
             PartyBookNativeTest.drain(f); PartyBookNativeTest.drain(f); verify(b.player, never()).setVelocity(any(Vector.class));
         }
+        var damage = events(data).stream().filter(event -> event.get("type").getAsString().endsWith("combat.damage")).toList();
+        assertEquals(1, damage.size(), "Owned accepted strike must not also be generic incoming player damage");
+        assertEquals("shield_bash", damage.getFirst().getAsJsonObject("data").get("ability_id").getAsString());
+        var own = events(data).stream().filter(event -> event.getAsJsonObject("data").has("ability_id")
+            && event.getAsJsonObject("data").get("ability_id").getAsString().equals("shield_bash")).toList();
+        assertEquals(0, count(own, "effect.applied"), "Cancelled velocity is not an applied knockback");
+        assertEquals("native_velocity_cancelled", record(own, "ability.resolved").get("knockback_status").getAsString());
+    }
+
+    @Test void disabledRoutineFeedbackKeepsAuditAndRejectedWriterCannotChangeAcceptedStrike() throws Exception {
+        for (boolean rejectStore : new boolean[]{false, true}) {
+            var directory = data.resolve(Boolean.toString(rejectStore));
+            try (var f = new FantasyStickLifecycleNativeTest.Fixture(directory)) {
+                f.plugin.setEnabled(true); var a = new FantasyStickLifecycleNativeTest.Actor(directory);
+                withShieldBash(directory, a, true); f.players.put(a.core.id, a.player); f.activate(a);
+                assertTrue(f.feedbackCommand.execute(a.player, "fantasyfeedback", new String[]{"off"})); f.tick();
+                var target = mock(org.bukkit.entity.LivingEntity.class);
+                when(target.getUniqueId()).thenReturn(java.util.UUID.randomUUID());
+                when(target.getType()).thenReturn(org.bukkit.entity.EntityType.ZOMBIE);
+                doReturn(new Location(a.world, 0, 64, 0)).when(a.player).getLocation();
+                when(target.getLocation()).thenReturn(new Location(a.world, 2, 64, 0));
+                doReturn(true).when(a.player).hasLineOfSight(target);
+                when(target.getVelocity()).thenReturn(new Vector());
+                doAnswer(call -> {
+                    var source = (org.bukkit.damage.DamageSource) call.getArgument(1);
+                    f.dispatcher.accept(new EntityDamageByEntityEvent(a.player, target,
+                        EntityDamageEvent.DamageCause.ENTITY_ATTACK, source, (Double) call.getArgument(0)));
+                    return null;
+                }).when(target).damage(anyDouble(), any(org.bukkit.damage.DamageSource.class));
+                if (rejectStore) ((games.dmg.fantasystick.events.LocalEventLog)
+                    FantasyStickLifecycleNativeTest.Fixture.field(f.plugin, "eventLog")).close();
+                a.core.inventory.getInventory().setSelectedSlot(2);
+                f.dispatcher.accept(new io.papermc.paper.event.player.PrePlayerAttackEntityEvent(a.player, target, true));
+                PartyBookNativeTest.drain(f); PartyBookNativeTest.drain(f);
+                verify(target).damage(eq(5.0), any(org.bukkit.damage.DamageSource.class));
+                verify(target).setVelocity(any(Vector.class));
+                assertFalse(a.messages.stream().anyMatch(message -> message.contains("Shield Bash hit")));
+                f.plugin.setEnabled(false);
+            }
+            var own = events(directory).stream().filter(event -> event.getAsJsonObject("data").has("ability_id")
+                && event.getAsJsonObject("data").get("ability_id").getAsString().equals("shield_bash")).toList();
+            assertEquals(rejectStore ? 0 : 1, count(own, "combat.damage"));
+        }
+    }
+
+    @Test void failedNativeVelocityPublicationKeepsAcceptedDamageButNeverClaimsKnockback() throws Exception {
+        try (var f = new FantasyStickLifecycleNativeTest.Fixture(data)) {
+            f.plugin.setEnabled(true); var a = new FantasyStickLifecycleNativeTest.Actor(data);
+            withShieldBash(data, a, true); f.players.put(a.core.id, a.player); f.activate(a);
+            var target = mock(org.bukkit.entity.LivingEntity.class);
+            when(target.getUniqueId()).thenReturn(java.util.UUID.randomUUID());
+            when(target.getType()).thenReturn(org.bukkit.entity.EntityType.ZOMBIE);
+            when(a.world.getUID()).thenReturn(java.util.UUID.randomUUID());
+            doReturn(new Location(a.world, 0, 64, 0)).when(a.player).getLocation();
+            when(target.getLocation()).thenReturn(new Location(a.world, 2, 64, 0));
+            doReturn(true).when(a.player).hasLineOfSight(target);
+            when(target.getVelocity()).thenReturn(new Vector());
+            doThrow(new IllegalStateException("simulated native velocity refusal")).when(target).setVelocity(any(Vector.class));
+            doAnswer(call -> {
+                var source = (org.bukkit.damage.DamageSource) call.getArgument(1);
+                f.dispatcher.accept(new EntityDamageByEntityEvent(a.player, target, EntityDamageEvent.DamageCause.ENTITY_ATTACK,
+                    source, (Double) call.getArgument(0)));
+                return null;
+            }).when(target).damage(anyDouble(), any(org.bukkit.damage.DamageSource.class));
+            a.core.inventory.getInventory().setSelectedSlot(2);
+            f.dispatcher.accept(new io.papermc.paper.event.player.PrePlayerAttackEntityEvent(a.player, target, true));
+            PartyBookNativeTest.drain(f); PartyBookNativeTest.drain(f);
+            f.plugin.setEnabled(false);
+        }
+        var own = events(data).stream().filter(event -> event.getAsJsonObject("data").has("ability_id")
+            && event.getAsJsonObject("data").get("ability_id").getAsString().equals("shield_bash")).toList();
+        assertEquals(1, count(own, "combat.damage"));
+        assertEquals(0, count(own, "effect.applied"));
+        assertEquals("hit", record(own, "ability.resolved").get("outcome").getAsString());
+        assertEquals("native_velocity_failed", record(own, "ability.resolved").get("knockback_status").getAsString());
     }
 
     @Test void unlearnRelearnAndCharacterTransferRetainCooldown() throws Exception {
@@ -247,6 +395,38 @@ class ShieldBashNativeTest {
         }
     }
 
+    @Test void authorizedShieldConfigurationReadAndAcknowledgedChangeReachExportedJsonlOnlyAfterSave() throws Exception {
+        try (var f = new FantasyStickLifecycleNativeTest.Fixture(data)) {
+            f.plugin.setEnabled(true);
+            var admin = new EquipmentAdminCommandNativeTest.Sender(); admin.allowed = true;
+            f.command.execute(admin.port, "fstickadmin", new String[]{"config", "shield-bash-base-damage"});
+            assertTrue(admin.messages.getLast().contains("shield-bash-base-damage=4"));
+            f.command.execute(admin.port, "fstickadmin", new String[]{"config", "shield-bash-base-damage", "7"});
+            var response = f.tasks.poll(5, java.util.concurrent.TimeUnit.SECONDS); assertNotNull(response); response.run();
+            var registry = (games.dmg.fantasystick.ability.AbilityRegistry)
+                FantasyStickLifecycleNativeTest.Fixture.field(f.plugin, "abilityRegistry");
+            assertEquals(new java.math.BigDecimal("7"), registry.find("shield_bash").orElseThrow()
+                .parameters().get("base-damage"));
+            try (var channel = java.nio.channels.FileChannel.open(data.resolve(".config.lock"),
+                    java.nio.file.StandardOpenOption.CREATE, java.nio.file.StandardOpenOption.WRITE);
+                 var lock = channel.lock()) {
+                assertTrue(lock.isValid());
+                f.command.execute(admin.port, "fstickadmin", new String[]{"config", "shield-bash-base-damage", "8"});
+                var failed = f.tasks.poll(5, java.util.concurrent.TimeUnit.SECONDS); assertNotNull(failed); failed.run();
+            }
+            admin.allowed = false;
+            f.command.execute(admin.port, "fstickadmin", new String[]{"config", "shield-bash-base-damage"});
+            f.plugin.setEnabled(false);
+        }
+        var config = events(data).stream().filter(event -> event.getAsJsonObject("data").has("ability_id")
+            && event.getAsJsonObject("data").get("ability_id").getAsString().equals("shield_bash")
+            && (event.get("type").getAsString().endsWith("config.read")
+                || event.get("type").getAsString().endsWith("config.changed"))).toList();
+        assertEquals(2, config.size());
+        assertEquals("4", config.getLast().getAsJsonObject("data").get("before").getAsString());
+        assertEquals("7", config.getLast().getAsJsonObject("data").get("after").getAsString());
+    }
+
     @Test void retainedSixSecondCooldownIsHonoredWithoutRewritingConfiguration() throws Exception {
         String retained = "shield-bash-cooldown-seconds: 6\n";
         java.nio.file.Files.writeString(data.resolve("config.yml"), retained);
@@ -270,6 +450,32 @@ class ShieldBashNativeTest {
             games.dmg.fantasystick.ability.ShieldBash.damage(huge));
     }
 
+    @Test void failedCooldownSaveNeverPublishesShieldDamageOrKnockback() throws Exception {
+        try (var f = new FantasyStickLifecycleNativeTest.Fixture(data)) {
+            f.plugin.setEnabled(true); var a = new FantasyStickLifecycleNativeTest.Actor(data);
+            withShieldBash(data, a, true); f.players.put(a.core.id, a.player); f.activate(a);
+            var target = mock(org.bukkit.entity.LivingEntity.class);
+            when(target.getUniqueId()).thenReturn(java.util.UUID.randomUUID());
+            when(target.getType()).thenReturn(org.bukkit.entity.EntityType.ZOMBIE);
+            doReturn(new Location(a.world, 0, 64, 0)).when(a.player).getLocation();
+            when(target.getLocation()).thenReturn(new Location(a.world, 2, 64, 0));
+            doReturn(true).when(a.player).hasLineOfSight(target);
+            ((CharacterStorage) FantasyStickLifecycleNativeTest.Fixture.field(f.plugin, "characters")).close();
+            a.core.inventory.getInventory().setSelectedSlot(2);
+            f.dispatcher.accept(new io.papermc.paper.event.player.PrePlayerAttackEntityEvent(a.player, target, true));
+            var response = f.tasks.poll(5, java.util.concurrent.TimeUnit.SECONDS); assertNotNull(response); response.run();
+            verify(target, never()).damage(anyDouble(), any(org.bukkit.damage.DamageSource.class));
+            verify(target, never()).setVelocity(any(Vector.class));
+            f.plugin.setEnabled(false);
+        }
+        var own = events(data).stream().filter(event -> event.getAsJsonObject("data").has("ability_id")
+            && event.getAsJsonObject("data").get("ability_id").getAsString().equals("shield_bash")).toList();
+        assertEquals(0, count(own, "ability.cast"));
+        assertEquals(0, count(own, "combat.damage"));
+        assertEquals(0, count(own, "effect.applied"));
+        assertEquals("failed", record(own, "ability.resolved").get("outcome").getAsString());
+    }
+
     @Test void failedCooldownPersistenceDealsNoDamageOrKnockback() {
         var storage=mock(CharacterStorage.class);var sessions=mock(games.dmg.fantasystick.session.EquipmentSessions.class);
         var parties=new games.dmg.fantasystick.party.PartyRoster(java.time.Clock.systemUTC(),ignored->true);
@@ -361,6 +567,27 @@ class ShieldBashNativeTest {
         assertEquals(expected, value.get());
     }
 
+    private static java.util.List<com.google.gson.JsonObject> events(Path data) throws Exception {
+        var results = new java.util.ArrayList<com.google.gson.JsonObject>();
+        try (var days = java.nio.file.Files.list(data.resolve("events"))) {
+            for (var day : days.filter(path -> path.getFileName().toString().matches("\\d{4}-\\d{2}-\\d{2}")).toList()) {
+                try (var segments = java.nio.file.Files.list(day)) {
+                    for (var path : segments.filter(file -> file.getFileName().toString().endsWith(".jsonl")).toList())
+                        for (var line : java.nio.file.Files.readAllLines(path))
+                            if (!line.isBlank()) results.add(com.google.gson.JsonParser.parseString(line).getAsJsonObject());
+                }
+            }
+        }
+        return results;
+    }
+    private static long count(java.util.List<com.google.gson.JsonObject> own, String suffix) {
+        return own.stream().filter(event -> event.get("type").getAsString().endsWith(suffix)).count();
+    }
+    private static com.google.gson.JsonObject record(java.util.List<com.google.gson.JsonObject> own, String suffix) {
+        return own.stream().filter(event -> event.get("type").getAsString().endsWith(suffix))
+            .findFirst().orElseThrow().getAsJsonObject("data");
+    }
+
     private static void learnAndAssign(FantasyStickLifecycleNativeTest.Fixture fixture,
                                        FantasyStickLifecycleNativeTest.Actor actor) throws Exception {
         actor.core.inventory.getInventory().setSelectedSlot(0); PartyBookNativeTest.open(fixture, actor);

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

@@ -24,10 +24,15 @@ class StoneSkinNativeTest {
     @BeforeAll static void bootstrap() throws Exception { NativeRuntime.bootstrap(); }
 
     @Test void bookAcquisitionEquippedUseReducesNativeEntityDamageForFourSeconds() throws Exception {
+        java.util.UUID expectedPlayer, expectedCharacter, expectedSession, expectedWorld, expectedAttacker = java.util.UUID.randomUUID();
         try (var f = new FantasyStickLifecycleNativeTest.Fixture(data)) {
             f.plugin.setEnabled(true);
             var a = new FantasyStickLifecycleNativeTest.Actor(data); withStoneSkin(data, a, false);
             f.players.put(a.core.id, a.player); f.activate(a);
+            expectedPlayer = a.core.id; expectedCharacter = a.core.record.id(); expectedWorld = a.core.location.getWorld().getUID();
+            expectedSession = ((games.dmg.fantasystick.session.EquipmentSessions)
+                FantasyStickLifecycleNativeTest.Fixture.field(f.plugin, "sessions"))
+                .active(expectedPlayer).orElseThrow().session();
             a.core.inventory.getInventory().setSelectedSlot(0); PartyBookNativeTest.open(f, a);
             String text = PartyBookNativeTest.text(a).replaceAll("\\s+", "");
             assertTrue(text.contains("StoneSkin")); assertTrue(text.contains("CON14"));
@@ -39,6 +44,9 @@ class StoneSkinNativeTest {
             use(f, a); PartyBookNativeTest.drain(f); PartyBookNativeTest.drain(f);
             assertNotNull(storage.find(a.core.record.id()).get().orElseThrow().cooldowns().get("stone_skin"));
             var attacker = mock(org.bukkit.entity.Zombie.class);
+            when(attacker.getUniqueId()).thenReturn(expectedAttacker);
+            when(attacker.getType()).thenReturn(org.bukkit.entity.EntityType.ZOMBIE);
+            when(attacker.getLocation()).thenReturn(a.core.location.clone());
             var hit = new EntityDamageByEntityEvent(attacker, a.player,
                 EntityDamageEvent.DamageCause.ENTITY_ATTACK, mock(org.bukkit.damage.DamageSource.class), 8);
             f.dispatcher.accept(hit); assertEquals(6, hit.getDamage(), 1.0e-9);
@@ -59,9 +67,38 @@ class StoneSkinNativeTest {
             PartyBookNativeTest.drain(f); PartyBookNativeTest.drain(f); use(f, a);
             assertTrue(a.messages.stream().anyMatch(message -> message.contains("ready in")));
         }
+        var own = events(data).stream().filter(event -> event.getAsJsonObject("data").has("ability_id")
+            && event.getAsJsonObject("data").get("ability_id").getAsString().equals("stone_skin")).toList();
+        assertEquals(2, count(own, "ability.learned"));
+        assertEquals(2, count(own, "ability.assigned"));
+        assertEquals(1, count(own, "ability.unlearned"));
+        assertEquals(1, count(own, "ability.cast"));
+        assertEquals(1, count(own, "effect.applied"));
+        assertEquals(1, count(own, "effect.ended"));
+        assertEquals(1, count(own, "combat.prevented"));
+        var cast = record(own, "ability.cast"); var applied = record(own, "effect.applied");
+        var prevented = record(own, "combat.prevented"); var ended = record(own, "effect.ended");
+        assertEquals(2, cast.get("slot").getAsInt());
+        assertTrue(cast.has("cooldown_until"));
+        assertEquals(expectedPlayer.toString(), prevented.get("target_player_id").getAsString());
+        assertEquals(expectedCharacter.toString(), prevented.get("target_character_id").getAsString());
+        assertEquals(expectedSession.toString(), prevented.get("target_session_id").getAsString());
+        assertEquals(expectedWorld.toString(), prevented.getAsJsonObject("target_location").get("world_id").getAsString());
+        assertEquals(expectedAttacker.toString(), prevented.get("attacker_entity_id").getAsString());
+        assertEquals(expectedWorld.toString(), prevented.getAsJsonObject("attacker_location").get("world_id").getAsString());
+        assertEquals("25", applied.get("reduction_percent").getAsString());
+        assertTrue(applied.has("effect_until"));
+        assertEquals("8", prevented.get("incoming_amount").getAsString());
+        assertEquals("6", prevented.get("remaining_amount").getAsString());
+        assertEquals("2", prevented.get("actual_amount").getAsString());
+        assertEquals(cast.get("action_id").getAsString(), prevented.get("action_id").getAsString());
+        assertEquals(applied.get("application_id").getAsString(), ended.get("application_id").getAsString());
+        assertEquals("expired", ended.get("reason").getAsString());
+        assertEquals("expired", record(own, "ability.resolved").get("outcome").getAsString());
     }
 
     @Test void environmentalAndCancelledDamageRemainUntouchedWhileProjectileCombatIsReduced() throws Exception {
+        var arrowId = java.util.UUID.randomUUID();
         try (var f = new FantasyStickLifecycleNativeTest.Fixture(data)) {
             f.plugin.setEnabled(true);
             var a = new FantasyStickLifecycleNativeTest.Actor(data); withStoneSkin(data, a, true);
@@ -71,18 +108,26 @@ class StoneSkinNativeTest {
                 mock(org.bukkit.damage.DamageSource.class), 8);
             f.dispatcher.accept(fall); assertEquals(8, fall.getDamage(), 1.0e-9);
             var arrow = mock(org.bukkit.entity.Arrow.class);
+            when(arrow.getUniqueId()).thenReturn(arrowId);
+            when(arrow.getType()).thenReturn(org.bukkit.entity.EntityType.ARROW);
+            when(arrow.getLocation()).thenReturn(a.core.location.clone());
             var projectile = new EntityDamageByEntityEvent(arrow, a.player,
                 EntityDamageEvent.DamageCause.PROJECTILE, mock(org.bukkit.damage.DamageSource.class), 8);
             f.dispatcher.accept(projectile); assertEquals(6, projectile.getDamage(), 1.0e-9);
             class Veto implements org.bukkit.event.Listener {
-                @org.bukkit.event.EventHandler(priority = org.bukkit.event.EventPriority.LOWEST)
+                @org.bukkit.event.EventHandler(priority = org.bukkit.event.EventPriority.HIGHEST)
                 public void veto(EntityDamageByEntityEvent event) { event.setCancelled(true); }
             }
             f.dispatcher.register(new Veto(), f.plugin);
             var cancelled = new EntityDamageByEntityEvent(mock(org.bukkit.entity.Zombie.class), a.player,
                 EntityDamageEvent.DamageCause.ENTITY_ATTACK, mock(org.bukkit.damage.DamageSource.class), 8);
-            f.dispatcher.accept(cancelled); assertTrue(cancelled.isCancelled()); assertEquals(8, cancelled.getDamage(), 1.0e-9);
+            f.dispatcher.accept(cancelled); assertTrue(cancelled.isCancelled());
+            assertEquals(6, cancelled.getDamage(), 1.0e-9, "Late cancellation wins even after reduction was proposed");
         }
+        var own = events(data).stream().filter(event -> event.getAsJsonObject("data").has("ability_id")
+            && event.getAsJsonObject("data").get("ability_id").getAsString().equals("stone_skin")).toList();
+        assertEquals(1, count(own, "combat.prevented"), "Fall and cancelled native damage cannot claim prevention");
+        assertEquals(arrowId.toString(), record(own, "combat.prevented").get("attacker_entity_id").getAsString());
     }
 
     @Test void replacementExpirySessionExitAndTransferRemoveOnlyOwnedReductionAndRetainDeadline() throws Exception {
@@ -109,6 +154,63 @@ class StoneSkinNativeTest {
             f.players.put(b.core.id, b.player); f.activate(b);
             assertEquals(deadline, storage.find(a.core.record.id()).get().orElseThrow().cooldowns().get("stone_skin"));
         }
+        var own = events(data).stream().filter(event -> event.getAsJsonObject("data").has("ability_id")
+            && event.getAsJsonObject("data").get("ability_id").getAsString().equals("stone_skin")).toList();
+        assertEquals(3, count(own, "effect.applied"));
+        assertEquals(3, count(own, "effect.ended"));
+        assertEquals(1, own.stream().filter(event -> event.get("type").getAsString().endsWith("ability.resolved")
+            && event.getAsJsonObject("data").get("outcome").getAsString().equals("replaced")).count());
+        assertEquals(1, own.stream().filter(event -> event.get("type").getAsString().endsWith("ability.resolved")
+            && event.getAsJsonObject("data").get("outcome").getAsString().equals("expired")).count());
+    }
+
+    @Test void laterNativeDamageOverrideCannotClaimAnUnusedReduction() throws Exception {
+        try (var f = new FantasyStickLifecycleNativeTest.Fixture(data)) {
+            f.plugin.setEnabled(true);
+            var a = new FantasyStickLifecycleNativeTest.Actor(data); withStoneSkin(data, a, true);
+            f.players.put(a.core.id, a.player); f.activate(a);
+            use(f, a); PartyBookNativeTest.drain(f); PartyBookNativeTest.drain(f);
+            class Override implements org.bukkit.event.Listener {
+                @org.bukkit.event.EventHandler(priority = org.bukkit.event.EventPriority.HIGHEST)
+                public void restore(EntityDamageByEntityEvent event) { event.setDamage(8); }
+            }
+            f.dispatcher.register(new Override(), f.plugin);
+            assertEquals(8, hit(f, a, 8).getDamage(), 1.0e-9);
+            f.plugin.setEnabled(false);
+        }
+        var own = events(data).stream().filter(event -> event.getAsJsonObject("data").has("ability_id")
+            && event.getAsJsonObject("data").get("ability_id").getAsString().equals("stone_skin")).toList();
+        assertEquals(1, count(own, "effect.applied"));
+        assertEquals(0, count(own, "combat.prevented"));
+    }
+
+    @Test void feedbackOffPreservesPreventionAuditAndRejectedEventStorePreservesNativeReduction() throws Exception {
+        for (boolean rejectStore : new boolean[]{false, true}) {
+            var directory = data.resolve(Boolean.toString(rejectStore));
+            try (var f = new FantasyStickLifecycleNativeTest.Fixture(directory)) {
+                f.plugin.setEnabled(true);
+                var a = new FantasyStickLifecycleNativeTest.Actor(directory); withStoneSkin(directory, a, true);
+                f.players.put(a.core.id, a.player); f.activate(a);
+                assertTrue(f.feedbackCommand.execute(a.player, "fantasyfeedback", new String[]{"off"}));
+                f.tick();
+                if (rejectStore) ((games.dmg.fantasystick.events.LocalEventLog)
+                    FantasyStickLifecycleNativeTest.Fixture.field(f.plugin, "eventLog")).close();
+                use(f, a); PartyBookNativeTest.drain(f); PartyBookNativeTest.drain(f);
+                var attacker = mock(org.bukkit.entity.Zombie.class);
+                when(attacker.getUniqueId()).thenReturn(java.util.UUID.randomUUID());
+                when(attacker.getType()).thenReturn(org.bukkit.entity.EntityType.ZOMBIE);
+                when(attacker.getLocation()).thenReturn(a.core.location.clone());
+                var hit = new EntityDamageByEntityEvent(attacker, a.player, EntityDamageEvent.DamageCause.ENTITY_ATTACK,
+                    mock(org.bukkit.damage.DamageSource.class), 8);
+                f.dispatcher.accept(hit);
+                assertEquals(6, hit.getDamage(), 1.0e-9);
+                assertFalse(a.messages.stream().anyMatch(message -> message.contains("prevented")));
+                f.plugin.setEnabled(false);
+            }
+            var own = events(directory).stream().filter(event -> event.getAsJsonObject("data").has("ability_id")
+                && event.getAsJsonObject("data").get("ability_id").getAsString().equals("stone_skin")).toList();
+            assertEquals(rejectStore ? 0 : 1, count(own, "combat.prevented"));
+        }
     }
 
     @Test void acknowledgedConfigurationAffectsFutureCastsWhileActiveProtectionKeepsSnapshot() throws Exception {
@@ -158,6 +260,44 @@ class StoneSkinNativeTest {
         stone.close(); mitigation.close();
     }
 
+    @Test void rejectedCooldownSaveCannotEmitAStoneEffectOrClaimPrevention() throws Exception {
+        try (var f = new FantasyStickLifecycleNativeTest.Fixture(data)) {
+            f.plugin.setEnabled(true);
+            var a = new FantasyStickLifecycleNativeTest.Actor(data); withStoneSkin(data, a, true);
+            f.players.put(a.core.id, a.player); f.activate(a);
+            ((CharacterStorage) FantasyStickLifecycleNativeTest.Fixture.field(f.plugin, "characters")).close();
+            use(f, a); var rejected = f.tasks.poll(5, java.util.concurrent.TimeUnit.SECONDS);
+            assertNotNull(rejected); rejected.run();
+            assertEquals(8, hit(f, a, 8).getDamage(), 1.0e-9);
+            f.plugin.setEnabled(false);
+        }
+        var own = events(data).stream().filter(event -> event.getAsJsonObject("data").has("ability_id")
+            && event.getAsJsonObject("data").get("ability_id").getAsString().equals("stone_skin")).toList();
+        assertEquals(0, count(own, "ability.cast"));
+        assertEquals(0, count(own, "effect.applied"));
+        assertEquals(0, count(own, "combat.prevented"));
+        assertEquals("failed", record(own, "ability.resolved").get("outcome").getAsString());
+    }
+
+    @Test void failingPreventionFeedbackCannotInterruptAcceptedNativeDamageObservation() {
+        var mitigation = new games.dmg.fantasystick.ability.CombatMitigation();
+        var player = mock(org.bukkit.entity.Player.class);
+        when(player.getUniqueId()).thenReturn(java.util.UUID.randomUUID());
+        var execution = mock(games.dmg.fantasystick.ability.AbilityExecution.class);
+        when(execution.stillCurrent()).thenReturn(true);
+        doThrow(new IllegalStateException("broken feedback")).when(execution).report(any(), any(), any());
+        var observed = new java.util.ArrayList<games.dmg.fantasystick.ability.CombatMitigation.Accepted>();
+        mitigation.grantAccepted(execution, player, new java.math.BigDecimal("25"), () -> true, observed::add);
+        var hit = new EntityDamageByEntityEvent(mock(org.bukkit.entity.Zombie.class), player,
+            EntityDamageEvent.DamageCause.ENTITY_ATTACK, mock(org.bukkit.damage.DamageSource.class), 8);
+        mitigation.reduce(hit);
+        assertDoesNotThrow(() -> mitigation.accepted(hit));
+        assertEquals(6, hit.getDamage(), 1.0e-9);
+        assertEquals(1, observed.size());
+        assertEquals(2, observed.getFirst().prevented(), 1.0e-9);
+        mitigation.close();
+    }
+
     @Test void failedCooldownPersistenceCreatesNoReduction() {
         var storage = mock(CharacterStorage.class);
         var sessions = mock(games.dmg.fantasystick.session.EquipmentSessions.class);
@@ -192,6 +332,38 @@ class StoneSkinNativeTest {
         engine.close(); stone.close(); mitigation.close(); parties.close();
     }
 
+    @Test void authorizedStoneConfigurationReadAndAcknowledgedChangeReachJsonlOnlyAfterSave() throws Exception {
+        try (var f = new FantasyStickLifecycleNativeTest.Fixture(data)) {
+            f.plugin.setEnabled(true);
+            var admin = new EquipmentAdminCommandNativeTest.Sender(); admin.allowed = true;
+            f.command.execute(admin.port, "fstickadmin", new String[]{"config", "stone-skin-damage-reduction-percent"});
+            assertTrue(admin.messages.getLast().contains("stone-skin-damage-reduction-percent=25"));
+            f.command.execute(admin.port, "fstickadmin", new String[]{"config", "stone-skin-damage-reduction-percent", "40"});
+            var response = f.tasks.poll(5, java.util.concurrent.TimeUnit.SECONDS); assertNotNull(response); response.run();
+            var registry = (games.dmg.fantasystick.ability.AbilityRegistry)
+                FantasyStickLifecycleNativeTest.Fixture.field(f.plugin, "abilityRegistry");
+            assertEquals(0, new java.math.BigDecimal("40").compareTo(
+                registry.find("stone_skin").orElseThrow().parameters().get("damage-reduction-percent")));
+            try (var channel = java.nio.channels.FileChannel.open(data.resolve(".config.lock"),
+                    java.nio.file.StandardOpenOption.CREATE, java.nio.file.StandardOpenOption.WRITE);
+                 var lock = channel.lock()) {
+                assertTrue(lock.isValid());
+                f.command.execute(admin.port, "fstickadmin", new String[]{"config", "stone-skin-damage-reduction-percent", "50"});
+                var failed = f.tasks.poll(5, java.util.concurrent.TimeUnit.SECONDS); assertNotNull(failed); failed.run();
+            }
+            admin.allowed = false;
+            f.command.execute(admin.port, "fstickadmin", new String[]{"config", "stone-skin-damage-reduction-percent"});
+            f.plugin.setEnabled(false);
+        }
+        var config = events(data).stream().filter(event -> event.getAsJsonObject("data").has("ability_id")
+            && event.getAsJsonObject("data").get("ability_id").getAsString().equals("stone_skin")
+            && (event.get("type").getAsString().endsWith("config.read")
+                || event.get("type").getAsString().endsWith("config.changed"))).toList();
+        assertEquals(2, config.size());
+        assertEquals("25", config.getLast().getAsJsonObject("data").get("before").getAsString());
+        assertEquals("40", config.getLast().getAsJsonObject("data").get("after").getAsString());
+    }
+
     @Test void configuredDefinitionAdminRoutesAndStartupValidationCoverEverySetting() throws Exception {
         java.nio.file.Files.writeString(data.resolve("config.yml"),
             "stone-skin-cooldown-seconds: 2\nstone-skin-duration-seconds: 6\nstone-skin-damage-reduction-percent: 40\n");
@@ -237,6 +409,29 @@ class StoneSkinNativeTest {
         }
     }
 
+    private static java.util.List<com.google.gson.JsonObject> events(Path data) throws Exception {
+        var results = new java.util.ArrayList<com.google.gson.JsonObject>();
+        try (var days = java.nio.file.Files.list(data.resolve("events"))) {
+            for (var day : days.filter(path -> path.getFileName().toString().matches("\\d{4}-\\d{2}-\\d{2}")).toList()) {
+                try (var segments = java.nio.file.Files.list(day)) {
+                    for (var path : segments.filter(file -> file.getFileName().toString().endsWith(".jsonl")).toList())
+                        for (var line : java.nio.file.Files.readAllLines(path))
+                            if (!line.isBlank()) results.add(com.google.gson.JsonParser.parseString(line).getAsJsonObject());
+                }
+            }
+        }
+        return results;
+    }
+
+    private static long count(java.util.List<com.google.gson.JsonObject> own, String suffix) {
+        return own.stream().filter(event -> event.get("type").getAsString().endsWith(suffix)).count();
+    }
+
+    private static com.google.gson.JsonObject record(java.util.List<com.google.gson.JsonObject> own, String suffix) {
+        return own.stream().filter(event -> event.get("type").getAsString().endsWith(suffix))
+            .findFirst().orElseThrow().getAsJsonObject("data");
+    }
+
     private static EntityDamageByEntityEvent hit(FantasyStickLifecycleNativeTest.Fixture fixture,
                                                   FantasyStickLifecycleNativeTest.Actor target, double amount) {
         var event = new EntityDamageByEntityEvent(mock(org.bukkit.entity.Zombie.class), target.player,

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

@@ -0,0 +1,269 @@
+package games.dmg.fantasystick;
+
+import static org.junit.jupiter.api.Assertions.*;
+import static org.mockito.Mockito.*;
+
+import com.google.gson.JsonObject;
+import com.google.gson.JsonParser;
+import games.dmg.fantasystick.persistence.SwitchDelaySettings;
+import games.dmg.fantasystick.session.EquipmentSessions;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.time.Duration;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.concurrent.TimeUnit;
+import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.io.TempDir;
+
+/** Registered administrator policy changes must be independently visible in exported day segments. */
+class SwitchDelayAdminEventsNativeTest {
+    @TempDir Path data;
+    @BeforeAll static void bootstrap() throws Exception { NativeRuntime.bootstrap(); }
+
+    @Test void registeredReadAndAcknowledgedZeroThenNonzeroChangesReachExportedJsonlAndActualExits() throws Exception {
+        try (var f = new FantasyStickLifecycleNativeTest.Fixture(data)) {
+            f.plugin.setEnabled(true);
+            var admin = new EquipmentAdminCommandNativeTest.Sender();
+            f.adminCommand.execute(admin.port, "fstickadmin", new String[]{
+                "config", SwitchDelaySettings.KEY});
+            assertTrue(admin.messages.getLast().contains("=900"));
+            var player = new FantasyStickLifecycleNativeTest.Actor(data);
+            f.players.put(player.core.id, player.player); f.activate(player);
+            change(f, admin, "0");
+            var sessions = (EquipmentSessions) FantasyStickLifecycleNativeTest.Fixture.field(f.plugin, "sessions");
+            sessions.exit(player.player); f.awaitCharacterAndReceipt(player);
+            var first = f.receipts().find(player.core.id).toCompletableFuture()
+                .get(5, TimeUnit.SECONDS).orElseThrow().lastExit();
+            assertEquals(Duration.ZERO, Duration.between(first.exitedAt(), first.deadline()));
+            f.reenter(player);
+            change(f, admin, "37");
+            sessions.exit(player.player); f.awaitCharacterAndReceipt(player);
+            var second = f.receipts().find(player.core.id).toCompletableFuture()
+                .get(5, TimeUnit.SECONDS).orElseThrow().lastExit();
+            assertEquals(Duration.ofSeconds(37), Duration.between(second.exitedAt(), second.deadline()));
+            assertEquals(first.exitedAt(), first.deadline(), "Changing policy did not rewrite an existing deadline");
+            for (int i = 0; i < 200 && config().size() < 3; i++) Thread.sleep(10);
+            f.plugin.setEnabled(false);
+        }
+        var entries = config();
+        assertEquals(List.of("games.dmg.minecraft.fantasystick.config.read",
+            "games.dmg.minecraft.fantasystick.config.changed",
+            "games.dmg.minecraft.fantasystick.config.changed"), entries.stream()
+            .map(event -> event.get("type").getAsString()).toList());
+        assertEquals(List.of("900", "0", "37"), entries.stream()
+            .map(event -> event.getAsJsonObject("data").get("effective").getAsString()).toList());
+        assertEquals(List.of("900", "0"), entries.subList(1, 3).stream()
+            .map(event -> event.getAsJsonObject("data").get("before").getAsString()).toList());
+        assertTrue(entries.get(1).getAsJsonObject("data").get("zero_disabled").getAsBoolean());
+        assertFalse(entries.get(2).getAsJsonObject("data").get("zero_disabled").getAsBoolean());
+    }
+
+    @Test void deniedInvalidAndFailedWritesNeverClaimPolicyChange() throws Exception {
+        try (var f = new FantasyStickLifecycleNativeTest.Fixture(data)) {
+            f.plugin.setEnabled(true);
+            var admin = new EquipmentAdminCommandNativeTest.Sender();
+            admin.allowed = false;
+            f.adminCommand.execute(admin.port, "fstickadmin", new String[]{"config", SwitchDelaySettings.KEY});
+            f.adminCommand.execute(admin.port, "fstickadmin", new String[]{"config", SwitchDelaySettings.KEY, "0"});
+            admin.allowed = true;
+            for (var invalid : List.of("-1", "1.5", "not-a-number")) {
+                f.adminCommand.execute(admin.port, "fstickadmin", new String[]{"config", SwitchDelaySettings.KEY, invalid});
+                assertTrue(admin.messages.getLast().contains("invalid"));
+            }
+            Files.createDirectory(data.resolve("config.yml"));
+            f.adminCommand.execute(admin.port, "fstickadmin", new String[]{"config", SwitchDelaySettings.KEY, "0"});
+            for (int i = 0; i < 20 && !admin.messages.getLast().contains("save failed"); i++) {
+                var callback = f.tasks.poll(5, TimeUnit.SECONDS); assertNotNull(callback); callback.run();
+            }
+            assertTrue(admin.messages.getLast().contains("save failed"));
+            var settings = (SwitchDelaySettings) FantasyStickLifecycleNativeTest.Fixture.field(f.plugin, "switchDelaySettings");
+            assertEquals("900", settings.value());
+            f.plugin.setEnabled(false);
+        }
+        assertTrue(config().isEmpty(), "A rejected request, read or save has no domain success");
+    }
+
+    @Test void concurrentAcknowledgedWritesReportEffectiveBeforeAndAfterWithoutSupersededSuccess() throws Exception {
+        try (var f = new FantasyStickLifecycleNativeTest.Fixture(data)) {
+            f.plugin.setEnabled(true);
+            var admin = new EquipmentAdminCommandNativeTest.Sender();
+            f.adminCommand.execute(admin.port, "fstickadmin", new String[]{"config", SwitchDelaySettings.KEY, "0"});
+            f.adminCommand.execute(admin.port, "fstickadmin", new String[]{"config", SwitchDelaySettings.KEY, "37"});
+            for (int i = 0; i < 30 && admin.messages.size() < 2; i++) {
+                var callback = f.tasks.poll(5, TimeUnit.SECONDS); assertNotNull(callback); callback.run();
+            }
+            assertEquals(2, admin.messages.size(), admin.messages.toString());
+            assertTrue(admin.messages.stream().allMatch(message -> message.startsWith("Saved ")));
+            for (int i = 0; i < 200 && config().size() < 2; i++) Thread.sleep(10);
+            f.plugin.setEnabled(false);
+        }
+        var changes = config(); assertEquals(2, changes.size());
+        assertEquals(List.of("900", "0"), changes.stream()
+            .map(event -> event.getAsJsonObject("data").get("before").getAsString()).toList());
+        assertEquals(List.of("0", "37"), changes.stream()
+            .map(event -> event.getAsJsonObject("data").get("effective").getAsString()).toList());
+        assertEquals(2, changes.stream().map(event -> event.getAsJsonObject("data")
+            .get("operation_id").getAsString()).distinct().count());
+    }
+
+    @Test void supersededSavedCallbackCannotExportASecondOrRollbackEffectiveChange() throws Exception {
+        try (var f = new FantasyStickLifecycleNativeTest.Fixture(data)) {
+            f.plugin.setEnabled(true);
+            for (int i = 0; i < 30 && !f.tasks.isEmpty(); i++) f.tasks.remove().run();
+            var admin = new EquipmentAdminCommandNativeTest.Sender();
+            f.adminCommand.execute(admin.port, "fstickadmin", new String[]{"config", SwitchDelaySettings.KEY, "0"});
+            f.adminCommand.execute(admin.port, "fstickadmin", new String[]{"config", SwitchDelaySettings.KEY, "37"});
+            var settings = (SwitchDelaySettings) FantasyStickLifecycleNativeTest.Fixture.field(
+                f.plugin, "switchDelaySettings");
+            var worker = (java.util.concurrent.ExecutorService) FantasyStickLifecycleNativeTest.Fixture.field(
+                settings, "worker");
+            java.util.concurrent.CompletableFuture.runAsync(() -> {}, worker).get(5, TimeUnit.SECONDS);
+            var first = f.tasks.poll(5, TimeUnit.SECONDS); assertNotNull(first);
+            var second = f.tasks.poll(5, TimeUnit.SECONDS); assertNotNull(second);
+            second.run(); first.run();
+            assertEquals("37", settings.value());
+            for (int i = 0; i < 200 && config().isEmpty(); i++) Thread.sleep(10);
+            f.plugin.setEnabled(false);
+        }
+        var changes = config();
+        assertEquals(1, changes.size(), "The stale callback must not claim a policy publication");
+        assertEquals("900", changes.getFirst().getAsJsonObject("data").get("before").getAsString());
+        assertEquals("37", changes.getFirst().getAsJsonObject("data").get("effective").getAsString());
+    }
+
+    @Test void playerAdministratorReadCapturesExactIdentityAndLocationWithoutSaving() throws Exception {
+        try (var f = new FantasyStickLifecycleNativeTest.Fixture(data)) {
+            f.plugin.setEnabled(true);
+            var admin = new FantasyStickLifecycleNativeTest.Actor(data);
+            doReturn(true).when(admin.player).hasPermission("fantasystick.admin");
+            doReturn("Administrator").when(admin.player).getName();
+            f.players.put(admin.core.id, admin.player);
+            f.adminCommand.execute(admin.player, "fstickadmin", new String[]{"config", SwitchDelaySettings.KEY});
+            for (int i = 0; i < 200 && config().isEmpty(); i++) Thread.sleep(10);
+            f.plugin.setEnabled(false);
+            var entries = config(); assertEquals(1, entries.size());
+            var read = entries.getFirst(); var values = read.getAsJsonObject("data");
+            assertTrue(read.get("type").getAsString().endsWith("config.read"));
+            assertEquals(admin.core.id.toString(), values.get("player_id").getAsString());
+            assertEquals("player", values.get("actor_kind").getAsString());
+            assertEquals("future_exit", values.get("application_scope").getAsString());
+            assertEquals("900", values.get("default").getAsString());
+            assertEquals("900", values.get("effective").getAsString());
+            assertEquals(admin.core.location.getX(), values.getAsJsonObject("location").get("x").getAsDouble());
+        }
+        assertFalse(Files.exists(data.resolve("config.yml")), "A read does not persist configuration");
+    }
+
+    @Test void failedIntentHandoffCannotUndoSavedPolicyAndReplaysStableOperationAfterRestart() throws Exception {
+        try (var f = new FantasyStickLifecycleNativeTest.Fixture(data)) {
+            f.plugin.setEnabled(true);
+            var admin = new EquipmentAdminCommandNativeTest.Sender();
+            var log = (games.dmg.fantasystick.events.LocalEventLog)
+                FantasyStickLifecycleNativeTest.Fixture.field(f.plugin, "eventLog");
+            log.close();
+            change(f, admin, "0");
+            assertEquals("0", ((SwitchDelaySettings) FantasyStickLifecycleNativeTest.Fixture.field(
+                f.plugin, "switchDelaySettings")).value());
+            f.plugin.setEnabled(false);
+            assertTrue(config().isEmpty(), "No pending file counts as an exported event");
+            f.plugin.setEnabled(true);
+            for (int i = 0; i < 200 && config().isEmpty(); i++) Thread.sleep(10);
+            assertEquals("0", ((SwitchDelaySettings) FantasyStickLifecycleNativeTest.Fixture.field(
+                f.plugin, "switchDelaySettings")).value());
+            f.plugin.setEnabled(false);
+        }
+        assertEquals(1, config().size(), "One saved operation replays without another configuration request");
+        assertEquals("0", config().getFirst().getAsJsonObject("data").get("effective").getAsString());
+    }
+
+    @Test void auditIntentFailureCannotRollBackPolicyOrPreventActualZeroDurationExit() throws Exception {
+        Files.writeString(data.resolve("switch-config-event-intents"), "blocked");
+        try (var f = new FantasyStickLifecycleNativeTest.Fixture(data)) {
+            f.plugin.setEnabled(true);
+            var admin = new EquipmentAdminCommandNativeTest.Sender();
+            change(f, admin, "0");
+            var player = new FantasyStickLifecycleNativeTest.Actor(data);
+            f.players.put(player.core.id, player.player); f.activate(player);
+            var sessions = (EquipmentSessions) FantasyStickLifecycleNativeTest.Fixture.field(f.plugin, "sessions");
+            sessions.exit(player.player); f.awaitCharacterAndReceipt(player);
+            var exit = f.receipts().find(player.core.id).toCompletableFuture()
+                .get(5, TimeUnit.SECONDS).orElseThrow().lastExit();
+            assertEquals(Duration.ZERO, Duration.between(exit.exitedAt(), exit.deadline()));
+            assertEquals("0", ((SwitchDelaySettings) FantasyStickLifecycleNativeTest.Fixture.field(
+                f.plugin, "switchDelaySettings")).value());
+            f.plugin.setEnabled(false);
+        }
+        assertTrue(config().isEmpty(), "Audit-store failure cannot invent an exported change");
+    }
+
+    @Test void closingBeforeAcknowledgedCallbackNeverLogsUnpublishedRuntimeChange() throws Exception {
+        try (var f = new FantasyStickLifecycleNativeTest.Fixture(data)) {
+            f.plugin.setEnabled(true);
+            var settings = (SwitchDelaySettings) FantasyStickLifecycleNativeTest.Fixture.field(
+                f.plugin, "switchDelaySettings");
+            var worker = (java.util.concurrent.ExecutorService) FantasyStickLifecycleNativeTest.Fixture.field(
+                settings, "worker");
+            var entered = new java.util.concurrent.CountDownLatch(1);
+            var release = new java.util.concurrent.CountDownLatch(1);
+            worker.execute(() -> {
+                entered.countDown();
+                try { release.await(); } catch (InterruptedException interrupted) { Thread.currentThread().interrupt(); }
+            });
+            assertTrue(entered.await(5, TimeUnit.SECONDS));
+            var admin = new EquipmentAdminCommandNativeTest.Sender();
+            f.adminCommand.execute(admin.port, "fstickadmin", new String[]{"config", SwitchDelaySettings.KEY, "0"});
+            try { f.plugin.setEnabled(false); } finally { release.countDown(); }
+            settings.drained().toCompletableFuture().get(5, TimeUnit.SECONDS);
+            while (!f.tasks.isEmpty()) f.tasks.remove().run();
+            assertEquals("900", settings.value(), "Closed command cannot publish a late setting");
+            assertTrue(config().isEmpty(), "Persisted but unpublished work is not an acknowledged domain change");
+            f.plugin.setEnabled(true);
+            assertEquals("0", ((SwitchDelaySettings) FantasyStickLifecycleNativeTest.Fixture.field(
+                f.plugin, "switchDelaySettings")).value(), "The later boot loads the committed setting");
+            f.plugin.setEnabled(false);
+        }
+        assertTrue(config().isEmpty(), "Startup load does not invent a prior runtime config.changed");
+    }
+
+    private void change(FantasyStickLifecycleNativeTest.Fixture f,
+                        EquipmentAdminCommandNativeTest.Sender admin, String value) throws Exception {
+        int messages = admin.messages.size();
+        f.adminCommand.execute(admin.port, "fstickadmin", new String[]{"config", SwitchDelaySettings.KEY, value});
+        for (int i = 0; i < 30 && admin.messages.size() == messages; i++) {
+            var callback = f.tasks.poll(5, TimeUnit.SECONDS);
+            assertNotNull(callback, "Acknowledged setting needs a native callback");
+            callback.run();
+        }
+        assertTrue(admin.messages.getLast().startsWith("Saved "), admin.messages.toString());
+    }
+
+    private List<JsonObject> config() throws Exception {
+        var entries = new ArrayList<JsonObject>();
+        var root = data.resolve("events");
+        if (!Files.isDirectory(root)) return entries;
+        try (var days = Files.list(root)) {
+            for (var day : days.filter(path -> path.getFileName().toString().matches("\\d{4}-\\d{2}-\\d{2}")
+                    && Files.isDirectory(path, java.nio.file.LinkOption.NOFOLLOW_LINKS)).toList()) {
+                try (var segments = Files.list(day)) {
+                    for (var path : segments.filter(file -> file.getFileName().toString().endsWith(".jsonl")).toList()) {
+                        var content = Files.readString(path);
+                        int end = content.lastIndexOf('\n');
+                        if (end < 0) continue;
+                        for (var line : content.substring(0, end).lines().toList()) if (!line.isBlank()) {
+                            var event = JsonParser.parseString(line).getAsJsonObject();
+                            if (event.get("type").getAsString().endsWith("config.read")
+                                    || event.get("type").getAsString().endsWith("config.changed")) {
+                                var values = event.getAsJsonObject("data");
+                                if (values.has("key") && values.get("key").getAsString().equals(SwitchDelaySettings.KEY))
+                                    entries.add(event);
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        return entries;
+    }
+}