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;
@@ -781,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()));
@@ -796,6 +805,10 @@ 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(),
@@ -823,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);
@@ -909,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);
@@ -969,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;
@@ -1289,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();
@@ -1363,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/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/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/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/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,6 +404,13 @@ 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);
@@ -1862,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/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/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;
+    }
+}