feat(characters): audit craft rename and observed transfer

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

@@ -177,6 +177,10 @@ public final class FantasyStickPlugin extends JavaPlugin {
     private games.dmg.fantasystick.events.CombatRewardEventBridge combatRewardEvents;
     private games.dmg.fantasystick.events.CoinEventBridge coinEvents;
     private games.dmg.fantasystick.events.SessionEventBridge sessionAuditEvents;
+    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.CharacterIdentityEventBridge identityAuditEvents;
+    private java.util.concurrent.CompletionStage<Void> identityAuditDrain = java.util.concurrent.CompletableFuture.completedFuture(null);
     private games.dmg.fantasystick.events.MessageEventBridge messageAuditEvents;
     private java.util.concurrent.CompletionStage<Void> configurationDrain = java.util.concurrent.CompletableFuture.completedStage(null);
 
@@ -747,6 +751,18 @@ public final class FantasyStickPlugin extends JavaPlugin {
                 combatRewardEvents = new games.dmg.fantasystick.events.CombatRewardEventBridge(eventLog::emit,Clock.systemUTC());combatExperience.attachEvents(combatRewardEvents);
                 coinEvents = new games.dmg.fantasystick.events.CoinEventBridge(eventLog::emit,Clock.systemUTC());characters.attachCoinEvents(coinEvents);admin.attachCoinEvents(coinEvents);
                 sessionAuditEvents = new games.dmg.fantasystick.events.SessionEventBridge(eventLog::emit,Clock.systemUTC());sessions.attachSessionEvents(sessionAuditEvents);
+                switchAuditEvents = new games.dmg.fantasystick.events.SwitchDelayEventBridge(
+                    eventLog::emit, Clock.systemUTC(), getDataFolder().toPath(),
+                    failure -> getLogger().log(Level.WARNING, "Switch deadline event intent failed", failure));
+                sessions.attachSwitchEvents(switchAuditEvents);
+                var identitySessions = sessions;
+                identityAuditEvents = new games.dmg.fantasystick.events.CharacterIdentityEventBridge(
+                    eventLog::emit, Clock.systemUTC(), getDataFolder().toPath(),
+                    playerId -> identitySessions.active(playerId).map(games.dmg.fantasystick.session.EquipmentSessions.Active::session),
+                    failure -> getLogger().log(Level.WARNING, "Character identity event intent failed", failure));
+                crafting.attachIdentityEvents(identityAuditEvents);
+                anvilNames.attachIdentityEvents(identityAuditEvents);
+                sessions.attachIdentityEvents(identityAuditEvents);
                 sessions.attachDownedEvents(downedEvents);
                 downedController.attachEvents(downedEvents);
                 revive.attachDownedEvents(downedEvents);
@@ -756,7 +772,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; abilityEvents = null; passiveEvents = null; recoveryEvents = null; reviveEvents = null; partyAuditEvents = null; combatRewardEvents = null; coinEvents = null; sessionAuditEvents = null; messageAuditEvents = null;
+                eventLog = null; eventCapture = null; downedEvents = null; rareEvents = null; bookEvents = null; progressionEvents = null; reviveEvents = null; partyAuditEvents = null; combatRewardEvents = null; coinEvents = null; sessionAuditEvents = null; switchAuditEvents = null; identityAuditEvents = null; messageAuditEvents = null;
                 getLogger().log(Level.WARNING,"Fantasy Stick local events are unavailable; gameplay remains enabled",failure);
             }
             getServer().getPluginManager().registerEvents(crafting, this);
@@ -831,6 +847,24 @@ public final class FantasyStickPlugin extends JavaPlugin {
             recipeRegistered = getServer().addRecipe(new CharacterSheets().recipe());
             if (!recipeRegistered) throw new IllegalStateException("Character-sheet recipe key is already registered");
             recipeDiscovery = new RecipeDiscovery(CharacterSheets.RECIPE, getLogger());
+            if (eventLog != null) {
+                var recipeEvents = new games.dmg.fantasystick.events.RecipeDiscoveryEventBridge(
+                    eventLog::emit, Clock.systemUTC(), getDataFolder().toPath(),
+                    failure -> getLogger().log(Level.WARNING, "Recipe discovery event intent failed", failure));
+                recipeDiscovery.attachEvents(recipeEvents);
+                eventLog.ready(); // Queue startup recovery before any recipe event handoff.
+                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 replayIdentityEvents = identityAuditEvents;
+                identityAuditDrain.whenComplete((ignored, failure) -> {
+                    if (failure != null) getLogger().log(Level.WARNING, "Previous identity event intent drain failed", failure);
+                    if (replayIdentityEvents != null) replayIdentityEvents.replay();
+                });
+                recipeEvents.replay(); // Serial worker replays old intents before new discoveries are captured.
+            }
             getServer().getPluginManager().registerEvents(recipeDiscovery, this);
             var onlinePlayers = List.copyOf(getServer().getOnlinePlayers());
             recipeDiscovery.discoverAll(onlinePlayers);
@@ -867,6 +901,8 @@ public final class FantasyStickPlugin extends JavaPlugin {
         combatFeedback = null;
         var closingEvents = sessionEvents; sessionEvents = null;
         var closingEventLog = eventLog; eventLog = null; preferenceEvents = null;
+        var closingSwitchAuditEvents = switchAuditEvents; switchAuditEvents = null;
+        var closingIdentityAuditEvents = identityAuditEvents; identityAuditEvents = 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;
         var closingBooks = books; books = null;
         var closingPartyEvents = partyEvents; partyEvents = null;
@@ -1170,6 +1206,16 @@ public final class FantasyStickPlugin extends JavaPlugin {
         if (closingEvents != null) cleanup("session events", closingEvents::close);
         if (closingCrafting != null) cleanup("craft attempts", closingCrafting::close);
         if (closingSessions != null) cleanup("equipment sessions", closingSessions::close);
+        if (closingRecipeDiscovery != null) cleanup("recipe discovery event intents", closingRecipeDiscovery::close);
+        if (closingSwitchAuditEvents != null) cleanup("switch event intent drain", () -> {
+            var sessionsDrained = closingSessions == null
+                ? java.util.concurrent.CompletableFuture.<Void>completedFuture(null) : closingSessions.drained();
+            switchAuditDrain = sessionsDrained.handle((ignored, failure) -> {
+                if (failure != null) getLogger().log(Level.WARNING, "Switch exit drain failed", failure);
+                closingSwitchAuditEvents.close();
+                return null;
+            }).thenCompose(ignored -> closingSwitchAuditEvents.drained());
+        });
         if (closingEventLog != null) cleanup("local events", closingEventLog::close);
         if (closingVitals != null) cleanup("native health hooks", closingVitals::close);
         unregister(closingModes);
@@ -1215,6 +1261,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 (closingIdentityAuditEvents != null) cleanup("character identity event intent drain", () -> {
+            var charactersDrained = closingCharacters == null
+                ? java.util.concurrent.CompletableFuture.<Void>completedFuture(null) : closingCharacters.drained();
+            identityAuditDrain = charactersDrained.handle((ignored, failure) -> {
+                if (failure != null) getLogger().log(Level.WARNING, "Character save drain failed", failure);
+                closingIdentityAuditEvents.close();
+                return null;
+            }).thenCompose(ignored -> closingIdentityAuditEvents.drained());
+        });
         if (closingRevivals != null) cleanup("revival storage", closingRevivals::close);
         // Never await IO on the server thread or close receipts ahead of accepted preparations.
         if (closingReceipts != null) cleanup("equipment receipt drain", () -> {

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

@@ -61,7 +61,8 @@ public final class CharacterBookController implements Consumer<ControlInput>, Au
     private static final java.util.regex.Pattern ABILITY_PAYLOAD = java.util.regex.Pattern.compile("\"([a-f0-9-]{36}):([a-z][a-z0-9_]{0,63})\"");
     private static final java.util.regex.Pattern RARE_PAYLOAD = java.util.regex.Pattern.compile("\"([a-f0-9-]{36}):([a-z][a-z0-9-]{0,63})\"");
     private static final java.util.regex.Pattern RARE_CONFIRM_PAYLOAD = java.util.regex.Pattern.compile("\"([a-f0-9-]{36})\"");
-    private record View(String nonce, ControlInput input, int previous, int next) { }
+    private record View(String nonce, ControlInput input, int start, int navigationPage,
+                        int previous, int next) { }
     private record AdminView(String nonce, UUID administrator, org.bukkit.entity.Player target,
                              games.dmg.fantasystick.session.EquipmentSessions.Active active,
                              int previous, int next) { }
@@ -244,6 +245,10 @@ public final class CharacterBookController implements Consumer<ControlInput>, Au
     }
 
     private void load(ControlInput input, int offset, boolean userRequested) {
+        load(input, offset, userRequested, null);
+    }
+
+    private void load(ControlInput input, int offset, boolean userRequested, View from) {
         if (closed || input.kind() != ControlInput.Kind.BOOK || input.gesture() != ControlInput.Gesture.USE
                 || !input.stillCurrent()) return;
         var owner = input.session().player();
@@ -255,7 +260,9 @@ public final class CharacterBookController implements Consumer<ControlInput>, Au
         rareViews.remove(owner);
         reskillViews.remove(owner);
         var current=sessions.currentRecord(input.session()).orElse(null);
-        var audit=userRequested&&bookEvents!=null&&current!=null?bookEvents.request(input,current,offset):null;
+        var navigation=from==null?null:new games.dmg.fantasystick.events.BookEventBridge.Navigation(
+            from.start(),from.navigationPage(),offset);
+        var audit=userRequested&&bookEvents!=null&&current!=null?bookEvents.request(input,current,offset,navigation):null;
         var superseded=pendingBookEvents.remove(owner);if(superseded!=null)bookEvents.refused(superseded,"superseded");
         if(audit!=null)pendingBookEvents.put(owner,audit);
         Object ticket = new Object();
@@ -398,8 +405,8 @@ public final class CharacterBookController implements Consumer<ControlInput>, Au
         if (allOverview.size() > VOLUME_SIZE) {
             Component navigation = Component.text("Character pages\n\n" + (start + 1) + "–" + end + "/" + allOverview.size());
             if (interactive) {
-                var view = new View(UUID.randomUUID().toString(), input, start > 0 ? start - VOLUME_SIZE : -1,
-                    end < allOverview.size() ? end : -1);
+                var view = new View(UUID.randomUUID().toString(), input, start, pages.size() + 1,
+                    start > 0 ? start - VOLUME_SIZE : -1, end < allOverview.size() ? end : -1);
                 views.put(input.session().player(), view);
                 if (view.previous() >= 0) navigation = navigation.append(Component.newline())
                     .append(pageButton("Previous pages", view, 0));
@@ -775,7 +782,7 @@ public final class CharacterBookController implements Consumer<ControlInput>, Au
         int offset = match.group(2).equals("0") ? view.previous() : view.next();
         if (offset < 0 || !views.remove(player.getUniqueId(), view) || !view.input().stillCurrent()) { refusePage(player,"stale_or_unavailable_page"); return; }
         // Reread authoritative data, rather than retaining a stale giant character snapshot.
-        load(view.input(), offset, true);
+        load(view.input(), offset, true, view);
     }
 
     private void refusePage(org.bukkit.entity.Player player,String reason){

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

@@ -17,6 +17,12 @@ public final class CharacterAnvilNames implements Listener {
     private final Consumer<Failure> failures;
     private final org.bukkit.inventory.ItemFactory items;
     private final Consumer<games.dmg.fantasystick.persistence.CharacterRecord> acknowledged;
+    private games.dmg.fantasystick.events.CharacterIdentityEventBridge identityEvents;
+
+    public void attachIdentityEvents(games.dmg.fantasystick.events.CharacterIdentityEventBridge events) {
+        if (identityEvents != null) throw new IllegalStateException("Anvil identity events already attached");
+        identityEvents = java.util.Objects.requireNonNull(events);
+    }
 
     /** Diagnostics may run on the persistence worker and must not access native player state. */
     public CharacterAnvilNames(CharacterStorage storage, Consumer<Failure> failures, org.bukkit.inventory.ItemFactory items) {
@@ -44,9 +50,19 @@ public final class CharacterAnvilNames implements Listener {
         if (name.equals(name(input))) return;
         var player = event.getPlayer().getUniqueId();
         var character = identity.orElseThrow().character();
-        storage.renameCharacter(character, name, identity.orElseThrow().generation()).whenComplete((renamed, failure) -> {
-            if (failure != null || renamed.isEmpty()) { failures.accept(new Failure(player, character, failure)); return; }
-            try { acknowledged.accept(renamed.orElseThrow()); }
+        var audit = identityEvents;
+        var action = audit == null ? null : audit.rename(event.getPlayer(), character, name);
+        storage.renameCharacterObserved(character, name, identity.orElseThrow().generation()).whenComplete((outcome, failure) -> {
+            if (failure != null || outcome.record().isEmpty()) {
+                failures.accept(new Failure(player, character, failure));
+                if (audit != null) audit.resolved(action, "refused", failure == null ? outcome.status() : "save_failed");
+                return;
+            }
+            if (audit != null) {
+                if ("renamed".equals(outcome.status())) audit.renamed(action, outcome.before().orElseThrow(), outcome.record().orElseThrow());
+                audit.resolved(action, "renamed".equals(outcome.status()) ? "accepted" : "refused", outcome.status());
+            }
+            try { acknowledged.accept(outcome.record().orElseThrow()); }
             catch (RuntimeException | LinkageError error) { failures.accept(new Failure(player, character, error)); }
         });
     }

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

@@ -34,6 +34,14 @@ public final class ManualCraftingController implements Listener, AutoCloseable {
     private final Consumer<Failure> failures;
     private final java.util.concurrent.ConcurrentMap<UUID, Attempt> pending = new java.util.concurrent.ConcurrentHashMap<>();
     private volatile boolean closed;
+    private games.dmg.fantasystick.events.CharacterIdentityEventBridge identityEvents;
+    private final java.util.Set<CraftItemEvent> handledCrafts =
+        java.util.Collections.newSetFromMap(new java.util.WeakHashMap<>());
+
+    public void attachIdentityEvents(games.dmg.fantasystick.events.CharacterIdentityEventBridge events) {
+        if (identityEvents != null || !pending.isEmpty()) throw new IllegalStateException("Craft identity events already attached or attempts started");
+        identityEvents = java.util.Objects.requireNonNull(events);
+    }
     // Server-thread reservation outlives close/reopen invalidation and includes client-sync callbacks.
     private final java.util.Set<UUID> delivering = new java.util.HashSet<>();
 
@@ -50,22 +58,30 @@ public final class ManualCraftingController implements Listener, AutoCloseable {
     public void onCraft(CraftItemEvent event) {
         if (event.isCancelled() || !(event.getRecipe() instanceof Keyed keyed)
                 || !CharacterSheets.RECIPE.equals(keyed.getKey())) return;
+        handledCrafts.add(event); // MONITOR can distinguish our containment from an existing veto.
         java.util.Optional<ManualCraftPlan> plan;
         try {
             plan = ManualCraftPlan.capture(event);
         } catch (RuntimeException failure) {
             failures.accept(new Failure(event.getWhoClicked().getUniqueId(), List.of(), "plan", failure));
+            refuseCraft(event, "failed", "plan");
             return;
         } finally {
             // capture must see the original cancellation state, but exceptions must never expose the plain preview.
             event.setCancelled(true);
         }
         if (closed || plan.isEmpty() || !(event.getWhoClicked() instanceof Player player) || !player.isOnline()
-                || !plan.orElseThrow().matches(player.getOpenInventory())) return;
+                || !plan.orElseThrow().matches(player.getOpenInventory())) {
+            refuseCraft(event, "refused", "invalid_or_stale_preflight");
+            return;
+        }
         var attempt = new Attempt(player.getUniqueId(), player, plan.orElseThrow());
         if (delivering.contains(attempt.id) || pending.putIfAbsent(attempt.id, attempt) != null) return;
+        var audit = identityEvents;
+        if (audit != null) attempt.craft = audit.craft(player, attempt.plan.route().name().toLowerCase(java.util.Locale.ROOT), attempt.plan.quantity());
         try {
             var records = java.util.stream.IntStream.range(0, attempt.plan.quantity()).mapToObj(index -> allocate.get()).toList();
+            attempt.records = records;
             attempt.characters = records.stream().map(CharacterRecord::id).toList();
             attempt.preparation = storage.prepareCraft(records);
             attempt.preparation.ready().whenComplete((batch, failure) -> schedule(attempt, batch, failure));
@@ -73,9 +89,24 @@ public final class ManualCraftingController implements Listener, AutoCloseable {
             pending.remove(attempt.id, attempt);
             abandon(attempt);
             failures.accept(new Failure(attempt.id, attempt.characters, "prepare", failure));
+            if (audit != null) audit.resolved(attempt.craft, "failed", "prepare", 0);
         }
     }
 
+    @EventHandler(priority = EventPriority.MONITOR)
+    public void onCraftDecision(CraftItemEvent event) {
+        if (!(event.getRecipe() instanceof Keyed keyed) || !CharacterSheets.RECIPE.equals(keyed.getKey())) return;
+        if (handledCrafts.remove(event) || !event.isCancelled()) return;
+        refuseCraft(event, "cancelled", "prior_cancellation");
+    }
+
+    private void refuseCraft(CraftItemEvent event, String outcome, String reason) {
+        var audit = identityEvents;
+        if (audit == null || !(event.getWhoClicked() instanceof Player player)) return;
+        var action = audit.craft(player, "unknown", 0);
+        audit.resolved(action, outcome, reason, 0);
+    }
+
     private void schedule(Attempt attempt, CharacterStorage.CraftBatch batch, Throwable failure) {
         if (closed || pending.get(attempt.id) != attempt) {
             abandon(attempt);
@@ -98,22 +129,45 @@ public final class ManualCraftingController implements Listener, AutoCloseable {
         }
         if (!delivering.add(attempt.id)) return;
         try {
-            if (failure != null) failures.accept(new Failure(attempt.id, attempt.characters, "save", failure));
-            else if (attempt.player.isOnline()) {
+            var audit = identityEvents;
+            if (failure != null) {
+                failures.accept(new Failure(attempt.id, attempt.characters, "save", failure));
+                if (audit != null) audit.resolved(attempt.craft, "failed", "save", 0);
+            } else if (attempt.player.isOnline()) {
                 attempt.handoffStarted = true;
                 if (attempt.plan.route() == ManualCraftPlan.Route.DROP) {
                     var result = ManualDropDelivery.commit(attempt.plan, batch, attempt.player::getOpenInventory,
                         () -> !closed && pending.get(attempt.id) == attempt && attempt.player.isOnline(), drops.apply(attempt.player));
+                    if (audit != null) {
+                        for (int index = 0; index < result.completed(); index++) audit.created(attempt.craft, attempt.records.get(index), index);
+                        var outcome = switch (result.status()) {
+                            case COMPLETE -> "accepted";
+                            case CANCELLED -> "cancelled";
+                            case STALE -> "stale";
+                            case UNCONFIRMED -> "uncertain";
+                            case UNAVAILABLE, UNSUPPORTED_ROUTE -> "refused";
+                        };
+                        audit.resolved(attempt.craft, outcome,
+                            "drop_" + result.status().name().toLowerCase(java.util.Locale.ROOT), result.completed());
+                    }
                     if (result.status() != ManualDropDelivery.Status.COMPLETE) {
                         failures.accept(new Failure(attempt.id, attempt.characters, "drop-" + result.status().name().toLowerCase(java.util.Locale.ROOT), null));
                     }
                 } else {
                     var result = ManualCraftDelivery.commit(attempt.plan, batch, attempt.player.getOpenInventory());
                     attempt.handoffStarted = result == ManualCraftDelivery.Result.DELIVERED;
+                    if (audit != null) {
+                        if (attempt.handoffStarted) for (int index = 0; index < attempt.records.size(); index++)
+                            audit.created(attempt.craft, attempt.records.get(index), index);
+                        audit.resolved(attempt.craft, attempt.handoffStarted ? "accepted"
+                            : result == ManualCraftDelivery.Result.STALE ? "stale" : "refused",
+                            result.name().toLowerCase(java.util.Locale.ROOT), attempt.handoffStarted ? attempt.records.size() : 0);
+                    }
                 }
             }
         } catch (RuntimeException unexpected) {
             failures.accept(new Failure(attempt.id, attempt.characters, "delivery", unexpected));
+            if (identityEvents != null) identityEvents.resolved(attempt.craft, "uncertain", "delivery", 0);
         } finally {
             pending.remove(attempt.id, attempt);
             abandon(attempt);
@@ -132,6 +186,8 @@ public final class ManualCraftingController implements Listener, AutoCloseable {
         final Player player;
         final ManualCraftPlan plan;
         List<UUID> characters = List.of();
+        List<CharacterRecord> records = List.of();
+        games.dmg.fantasystick.events.CharacterIdentityEventBridge.Craft craft;
         CharacterStorage.CraftPreparation preparation;
         volatile boolean handoffStarted;
         final java.util.concurrent.atomic.AtomicBoolean cleanupObserved = new java.util.concurrent.atomic.AtomicBoolean();

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

@@ -11,37 +11,50 @@ import org.bukkit.event.Listener;
 import org.bukkit.event.player.PlayerJoinEvent;
 
 /** Idempotent recipe-book visibility; recipe registration and crafting remain separate authorities. */
-public final class RecipeDiscovery implements Listener {
+public final class RecipeDiscovery implements Listener, AutoCloseable {
     private final NamespacedKey recipe;
     private final Logger logger;
+    private games.dmg.fantasystick.events.RecipeDiscoveryEventBridge events;
 
     public RecipeDiscovery(NamespacedKey recipe, Logger logger) {
         this.recipe = Objects.requireNonNull(recipe, "recipe");
         this.logger = Objects.requireNonNull(logger, "logger");
     }
 
+    public void attachEvents(games.dmg.fantasystick.events.RecipeDiscoveryEventBridge bridge) {
+        events = Objects.requireNonNull(bridge);
+    }
+
     public void discoverAll(Iterable<? extends Player> players) {
-        for (var player : players) discover(player);
+        for (var player : players) discover(player, "enable_online");
     }
 
     @EventHandler
     public void onJoin(PlayerJoinEvent event) {
-        discover(event.getPlayer());
+        discover(event.getPlayer(), "join");
     }
 
-    public void discover(Player player) {
+    public void discover(Player player) { discover(player, "join"); }
+
+    private void discover(Player player, String trigger) {
         Objects.requireNonNull(player, "player");
         try {
             if (player.hasDiscoveredRecipe(recipe)) return;
-            player.discoverRecipes(List.of(recipe));
+            int notifications = player.discoverRecipes(List.of(recipe));
             if (!player.hasDiscoveredRecipe(recipe)) {
                 logger.warning("Could not discover character-sheet recipe for " + label(player));
-            }
+                if (events != null) events.failed(player, trigger, "native_unavailable");
+            } else if (events != null) events.discovered(player, trigger, notifications);
         } catch (RuntimeException failure) {
             logger.log(Level.WARNING, "Could not discover character-sheet recipe for " + label(player), failure);
+            if (events != null) events.failed(player, trigger, "native_failed");
         }
     }
 
+    @Override public void close() {
+        if (events != null) events.close();
+    }
+
     private static String label(Player player) {
         try { return player.getName(); }
         catch (RuntimeException ignored) { return "an unidentified player"; }

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

@@ -14,8 +14,16 @@ import org.bukkit.Location;
 
 /** Stable feature-owned character-book outcomes; event delivery never authorizes or rolls back an open. */
 public final class BookEventBridge {
+    public record Navigation(int sourceVolumeStart, int sourceNavigationPage, int destinationVolumeStart) {
+        public Navigation {
+            if (sourceVolumeStart < 0 || sourceNavigationPage < 1 || sourceNavigationPage > 100
+                    || destinationVolumeStart < 0 || sourceVolumeStart == destinationVolumeStart)
+                throw new IllegalArgumentException("Invalid book volume navigation");
+        }
+    }
+
     public record Request(UUID actionId, EventInput.Context context, String actionKind, String viewKind,
-                          int offset, BigInteger requestedRevision) {
+                          int offset, BigInteger requestedRevision, Navigation navigation) {
         public Request {
             Objects.requireNonNull(actionId); Objects.requireNonNull(context); Objects.requireNonNull(actionKind);
             Objects.requireNonNull(viewKind); Objects.requireNonNull(requestedRevision);
@@ -32,10 +40,15 @@ public final class BookEventBridge {
     }
 
     public Request request(ControlInput input, CharacterRecord current, int offset) {
+        Objects.requireNonNull(input); Objects.requireNonNull(current);
+        return request(input, current, offset, null);
+    }
+
+    public Request request(ControlInput input, CharacterRecord current, int offset, Navigation navigation) {
         Objects.requireNonNull(input); Objects.requireNonNull(current);
         var request = new Request(UUID.randomUUID(), context(input, current.name()),
-            offset == 0 ? "character_book_open" : "character_book_navigate", "active", offset,
-            current.revision());
+            navigation == null ? "character_book_open" : "character_book_navigate", "active", offset,
+            current.revision(), navigation);
         emit("action.observed", request, "observed", null, null, null, null);
         return request;
     }
@@ -47,7 +60,7 @@ public final class BookEventBridge {
     public void refused(org.bukkit.entity.Player player, games.dmg.fantasystick.session.EquipmentSessions.Active active,
                         CharacterRecord current, String actionKind, String reason) {
         Objects.requireNonNull(player); Objects.requireNonNull(active); Objects.requireNonNull(current);
-        var request=new Request(UUID.randomUUID(),context(player,active,current.name()),actionKind,"active",-1,current.revision());
+        var request=new Request(UUID.randomUUID(),context(player,active,current.name()),actionKind,"active",-1,current.revision(),null);
         emit("action.observed",request,"observed",null,null,null,null);
         refused(request,reason);
     }
@@ -60,7 +73,7 @@ public final class BookEventBridge {
         Objects.requireNonNull(loaded);
         emit("action.resolved", request, "accepted", "acknowledged", loaded.revision(), presentedPages,
             presentedVolumes);
-        emit(request.offset() == 0 ? "character_book.opened" : "character_book.navigated", request,
+        emit(request.navigation() == null ? "character_book.opened" : "character_book.navigated", request,
             "accepted", "acknowledged", loaded.revision(), presentedPages, presentedVolumes);
     }
 
@@ -68,7 +81,18 @@ public final class BookEventBridge {
                       Integer pages, Integer volumes) {
         var data = new LinkedHashMap<String, Object>();
         data.put("action_kind", request.actionKind()); data.put("view_kind", request.viewKind());
-        data.put("section", "character_inspection"); data.put("control_kind", "book"); data.put("control_slot", "0");
+        data.put("section", request.navigation() == null ? "overview" : "volume_navigation");
+        data.put("control_kind", "book"); data.put("control_slot", "0");
+        if (request.navigation() != null) {
+            var navigation = request.navigation();
+            data.put("source_volume_start", Integer.toString(navigation.sourceVolumeStart()));
+            data.put("source_navigation_page", navigation.sourceNavigationPage());
+            data.put("destination_volume_start", Integer.toString(navigation.destinationVolumeStart()));
+            data.put("destination_page", "1");
+            data.put("destination_section", navigation.destinationVolumeStart() == 0 ? "overview" : "volume_start");
+            data.put("volume_direction", navigation.destinationVolumeStart() > navigation.sourceVolumeStart()
+                ? "next" : "previous");
+        }
         data.put("offset", request.offset()<0?"unknown":Integer.toString(request.offset()));
         data.put("requested_revision", request.requestedRevision().toString()); data.put("outcome", outcome);
         if (reason != null) data.put(type.startsWith("character_book.") ? "native_open" : "reason", reason);

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

@@ -0,0 +1,192 @@
+package games.dmg.fantasystick.events;
+
+import games.dmg.fantasystick.persistence.CharacterRecord;
+import java.nio.charset.StandardCharsets;
+import java.time.Clock;
+import java.time.Instant;
+import java.util.LinkedHashMap;
+import java.util.Map;
+import java.util.Objects;
+import java.util.Optional;
+import java.util.UUID;
+import java.nio.file.Path;
+import java.util.concurrent.CompletionStage;
+import java.util.function.Consumer;
+import java.util.function.Function;
+import org.bukkit.Location;
+import org.bukkit.entity.Player;
+
+/** Captures actual identity-creating and identity-changing native actions, never previews. */
+public final class CharacterIdentityEventBridge implements AutoCloseable {
+    private final Function<EventInput, CompletionStage<LocalEventLog.Delivery>> sink;
+    private final CharacterIdentityEventOutbox outbox;
+    private final Clock clock;
+    private final Function<UUID, Optional<UUID>> activeSession;
+    private static final int MAX_RECENT_HOLDERS = 8192;
+    private final Map<UUID, Holder> lastObserved = new LinkedHashMap<>(16, .75f, true) {
+        @Override protected boolean removeEldestEntry(Map.Entry<UUID, Holder> eldest) {
+            return size() > MAX_RECENT_HOLDERS; // Eviction is uncertainty, never an invented transfer.
+        }
+    };
+    private record Holder(UUID player, UUID session, EventInput.Location entryLocation) { }
+
+    public CharacterIdentityEventBridge(Function<EventInput, CompletionStage<LocalEventLog.Delivery>> sink,
+                                        Clock clock, Path dataFolder, Function<UUID, Optional<UUID>> activeSession,
+                                        Consumer<Throwable> failures) {
+        this.sink = Objects.requireNonNull(sink);
+        this.clock = Objects.requireNonNull(clock);
+        this.activeSession = Objects.requireNonNull(activeSession);
+        this.outbox = new CharacterIdentityEventOutbox(Objects.requireNonNull(dataFolder), sink,
+            Objects.requireNonNull(failures));
+    }
+
+    public void replay() { outbox.replay(); }
+    @Override public void close() { outbox.close(); }
+    public CompletionStage<Void> drained() { return outbox.drained(); }
+
+    /** A later acknowledged activation proves a transfer only if we observed a different prior holder. */
+    public void entered(Player player, UUID session, CharacterRecord record) {
+        try {
+            var actor = new EventInput.Context(player.getUniqueId(), player.getName(), record.id(), record.name(),
+                session, location(player.getLocation()));
+            Holder previous;
+            synchronized (lastObserved) {
+                previous = lastObserved.put(record.id(), new Holder(actor.playerId(), session, actor.location()));
+            }
+            if (previous == null || previous.player().equals(actor.playerId())) return;
+            var action = id(previous.session(), session.toString());
+            var values = new LinkedHashMap<String, Object>();
+            values.put("character_id", record.id().toString());
+            values.put("generation", record.sheetGeneration().toString());
+            values.put("from_player_id", previous.player().toString());
+            values.put("to_player_id", actor.playerId().toString());
+            values.put("from_session_id", previous.session().toString());
+            values.put("to_session_id", session.toString());
+            values.put("observation_boundary", "acknowledged_activation");
+            values.put("custody_quality", "activation_after_prior_holder");
+            if (previous.entryLocation() != null) values.put("from_location", locationMap(previous.entryLocation(), "cached_at_previous_activation"));
+            else values.put("from_location_status", "unavailable");
+            if (actor.location() != null) values.put("to_location", locationMap(actor.location(), "exact"));
+            else values.put("to_location_status", "unavailable");
+            values.put("outcome", "observed");
+            emit("character.transfer_observed", action, clock.instant(), actor, values, "transfer_observed");
+        } catch (RuntimeException ignored) { /* Observation never authorizes a character session. */ }
+    }
+
+    public record Craft(UUID action, Instant time, EventInput.Context actor, String route, int quantity,
+                        UUID holderSession) { }
+
+    public Craft craft(Player player, String route, int quantity) {
+        try {
+            var context = new EventInput.Context(player.getUniqueId(), player.getName(), null, null, null,
+                location(player.getLocation()));
+            var craft = new Craft(UUID.randomUUID(), clock.instant(), context, route, quantity,
+                activeSession.apply(context.playerId()).orElse(null));
+            emit("action.observed", craft.action(), craft.time(), context, Map.of(
+                "action_kind", "character_craft", "recipe_id", "fantasystick:character_sheet",
+                "delivery_route", route, "quantity", Integer.toString(quantity), "outcome", "observed"), "observed");
+            return craft;
+        } catch (RuntimeException ignored) { return null; }
+    }
+
+    public record Rename(UUID action, Instant time, EventInput.Context actor, UUID character,
+                         String requestedName, UUID holderSession) { }
+
+    public Rename rename(Player player, UUID character, String requestedName) {
+        try {
+            var actor = new EventInput.Context(player.getUniqueId(), player.getName(), null, null, null,
+                location(player.getLocation()));
+            var action = new Rename(UUID.randomUUID(), clock.instant(), actor, character, requestedName,
+                activeSession.apply(actor.playerId()).orElse(null));
+            emit("action.observed", action.action(), action.time(), actor, Map.of(
+                "action_kind", "character_rename", "character_id", character.toString(),
+                "outcome", "observed"), "observed");
+            return action;
+        } catch (RuntimeException ignored) { return null; }
+    }
+
+    public void renamed(Rename action, CharacterRecord before, CharacterRecord after) {
+        if (action == null) return;
+        var values = new LinkedHashMap<String, Object>();
+        values.put("action_kind", "character_rename");
+        values.put("anvil_action_id", action.action().toString());
+        holder(values, action.actor().playerId(), action.holderSession());
+        values.put("character_id", after.id().toString());
+        values.put("generation", after.sheetGeneration().toString());
+        values.put("before_name", before.name());
+        values.put("after_name", after.name());
+        values.put("revision_before", before.revision().toString());
+        values.put("revision_after", after.revision().toString());
+        values.put("native_item_outcome", "unverified");
+        values.put("outcome", "acknowledged");
+        durable("character.renamed", action.action(), action.time(), action.actor(), values, "renamed");
+    }
+
+    public void resolved(Rename action, String outcome, String reason) {
+        if (action == null) return;
+        emit("action.resolved", action.action(), clock.instant(), action.actor(), Map.of(
+            "action_kind", "character_rename", "character_id", action.character().toString(),
+            "outcome", outcome, "reason", reason), "resolved");
+    }
+
+    public void created(Craft craft, CharacterRecord record, int index) {
+        if (craft == null) return;
+        var values = new LinkedHashMap<String, Object>();
+        values.put("action_kind", "character_craft");
+        values.put("craft_operation_id", craft.action().toString());
+        holder(values, craft.actor().playerId(), craft.holderSession());
+        values.put("character_id", record.id().toString());
+        values.put("character_name", record.name());
+        values.put("generation", record.sheetGeneration().toString());
+        values.put("revision", record.revision().toString());
+        values.put("recipe_id", "fantasystick:character_sheet");
+        values.put("quantity", Integer.toString(craft.quantity()));
+        values.put("index", index);
+        values.put("delivery_route", craft.route());
+        values.put("outcome", "acknowledged_delivered");
+        durable("character.created", craft.action(), craft.time(), craft.actor(), values, record.id().toString());
+    }
+
+    public void resolved(Craft craft, String outcome, String reason, int delivered) {
+        if (craft == null) return;
+        emit("action.resolved", craft.action(), clock.instant(), craft.actor(), Map.of(
+            "action_kind", "character_craft", "recipe_id", "fantasystick:character_sheet",
+            "delivery_route", craft.route(), "quantity", Integer.toString(craft.quantity()),
+            "delivered", Integer.toString(delivered), "outcome", outcome, "reason", reason), "resolved");
+    }
+
+    private void durable(String kind, UUID action, Instant time, EventInput.Context context,
+                         Map<String, Object> values, String stage) {
+        try { outbox.accepted(new EventInput(id(action, stage), action, time, kind, context, values)); }
+        catch (RuntimeException ignored) { /* Auditing never changes acknowledged gameplay. */ }
+    }
+
+    private void emit(String kind, UUID action, Instant time, EventInput.Context context,
+                      Map<String, Object> values, String stage) {
+        try { sink.apply(new EventInput(id(action, stage), action, time, kind, context, values)); }
+        catch (RuntimeException ignored) { /* The audit cannot change native craft outcomes. */ }
+    }
+
+    private static void holder(Map<String, Object> data, UUID player, UUID session) {
+        data.put("holder_player_id", player.toString());
+        data.put("holder_session_status", session == null ? "no_active_session" : "active_at_request");
+        if (session != null) data.put("holder_session_id", session.toString());
+    }
+
+    private static Map<String, Object> locationMap(EventInput.Location location, String quality) {
+        return Map.of("world_id", location.worldId().toString(), "world_name", location.worldName(),
+            "x", location.x(), "y", location.y(), "z", location.z(),
+            "captured_at", location.capturedAt().toString(), "quality", quality);
+    }
+
+    private EventInput.Location location(Location value) {
+        return value == null || value.getWorld() == null ? null
+            : new EventInput.Location(value.getWorld().getUID(), value.getWorld().getName(), value.getX(), value.getY(),
+                value.getZ(), clock.instant(), "exact");
+    }
+
+    private static UUID id(UUID action, String stage) {
+        return UUID.nameUUIDFromBytes(("fantasystick:character-identity:" + action + ':' + stage)
+            .getBytes(StandardCharsets.UTF_8));
+    }
+}

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

@@ -0,0 +1,190 @@
+package games.dmg.fantasystick.events;
+
+import java.io.ByteArrayInputStream;
+import java.io.ByteArrayOutputStream;
+import java.io.IOException;
+import java.nio.ByteBuffer;
+import java.nio.channels.FileChannel;
+import java.nio.file.Files;
+import java.nio.file.LinkOption;
+import java.nio.file.Path;
+import java.nio.file.StandardCopyOption;
+import java.nio.file.StandardOpenOption;
+import java.time.Instant;
+import java.util.LinkedHashMap;
+import java.util.Properties;
+import java.util.Set;
+import java.util.UUID;
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.CompletionStage;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import java.util.concurrent.TimeUnit;
+import java.util.function.Consumer;
+import java.util.function.Function;
+
+/** Recoverable intent after acknowledged craft delivery or character-file rename. Never replays gameplay. */
+final class CharacterIdentityEventOutbox implements AutoCloseable {
+    private static final int MAX_BYTES = 16_384;
+    private static final Set<String> TYPES = Set.of("character.created", "character.renamed");
+    private final Path directory;
+    private final Function<EventInput, CompletionStage<LocalEventLog.Delivery>> sink;
+    private final Consumer<Throwable> failures;
+    private final ExecutorService worker = Executors.newSingleThreadExecutor(task ->
+        new Thread(task, "fantasy-character-identity-events"));
+    private final CompletableFuture<Void> drained = new CompletableFuture<>();
+
+    CharacterIdentityEventOutbox(Path data, Function<EventInput, CompletionStage<LocalEventLog.Delivery>> sink,
+                                 Consumer<Throwable> failures) {
+        directory = data.toAbsolutePath().resolve("character-identity-event-intents");
+        this.sink = sink;
+        this.failures = failures;
+    }
+
+    void accepted(EventInput event) {
+        try { worker.execute(() -> {
+            try { publish(write(event)); } catch (IOException | RuntimeException failure) { report(failure); }
+        }); } catch (RuntimeException failure) { report(failure); }
+    }
+
+    void replay() {
+        if (worker.isShutdown()) return;
+        try { worker.execute(() -> {
+            try {
+                if (!Files.exists(directory, LinkOption.NOFOLLOW_LINKS)) return;
+                if (!Files.isDirectory(directory, LinkOption.NOFOLLOW_LINKS)) throw new IOException("Unsafe character event directory");
+                try (var files = Files.list(directory)) {
+                    for (var path : files.filter(value -> value.getFileName().toString().endsWith(".pending")).sorted().toList()) {
+                        try { publish(read(path)); } catch (IOException | RuntimeException failure) { report(failure); }
+                    }
+                }
+            } catch (IOException | RuntimeException failure) { report(failure); }
+        }); } catch (RuntimeException failure) { report(failure); }
+    }
+
+    private Path path(EventInput event) { return directory.resolve(event.id() + ".pending"); }
+
+    private EventInput write(EventInput event) throws IOException {
+        if (!TYPES.contains(event.type())) throw new IOException("Unsupported character intent type");
+        if (Files.exists(directory, LinkOption.NOFOLLOW_LINKS)
+                && !Files.isDirectory(directory, LinkOption.NOFOLLOW_LINKS)) throw new IOException("Unsafe character event directory");
+        Files.createDirectories(directory);
+        var target = path(event);
+        if (Files.exists(target, LinkOption.NOFOLLOW_LINKS)) return read(target);
+        var fields = new Properties();
+        fields.setProperty("id", event.id().toString());
+        fields.setProperty("action", event.actionId().toString());
+        fields.setProperty("time", event.time().toString());
+        fields.setProperty("type", event.type());
+        var context = event.context();
+        fields.setProperty("player", context.playerId().toString());
+        fields.setProperty("player_name", context.playerName());
+        if (context.characterId() != null) {
+            fields.setProperty("character", context.characterId().toString());
+            fields.setProperty("character_name", context.characterName());
+            fields.setProperty("session", context.sessionId().toString());
+        }
+        if (context.location() != null) {
+            var location = context.location();
+            fields.setProperty("world", location.worldId().toString());
+            fields.setProperty("world_name", location.worldName());
+            fields.setProperty("x", Double.toString(location.x()));
+            fields.setProperty("y", Double.toString(location.y()));
+            fields.setProperty("z", Double.toString(location.z()));
+            fields.setProperty("captured_at", location.capturedAt().toString());
+            fields.setProperty("quality", location.quality());
+        }
+        event.data().forEach((key, value) -> {
+            if (value instanceof String text) fields.setProperty("data." + key, "s" + text);
+            else if (value instanceof Boolean bool) fields.setProperty("data." + key, "b" + bool);
+            else if (value instanceof Integer number) fields.setProperty("data." + key, "i" + number);
+            else throw new IllegalArgumentException("Unsupported character intent value");
+        });
+        var output = new ByteArrayOutputStream();
+        fields.store(output, "acknowledged character identity event");
+        var bytes = output.toByteArray();
+        if (bytes.length > MAX_BYTES) throw new IOException("Character event intent too large");
+        var temporary = Files.createTempFile(directory, ".identity-", ".tmp");
+        try {
+            try (var channel = FileChannel.open(temporary, StandardOpenOption.WRITE, LinkOption.NOFOLLOW_LINKS)) {
+                var buffer = ByteBuffer.wrap(bytes);
+                while (buffer.hasRemaining()) channel.write(buffer);
+                channel.force(true);
+            }
+            Files.move(temporary, target, StandardCopyOption.ATOMIC_MOVE, StandardCopyOption.REPLACE_EXISTING);
+            forceDirectory();
+        } finally { Files.deleteIfExists(temporary); }
+        return event;
+    }
+
+    private EventInput read(Path path) throws IOException {
+        if (!Files.isRegularFile(path, LinkOption.NOFOLLOW_LINKS)) throw new IOException("Unsafe character event intent");
+        var fields = new Properties();
+        try (var input = Files.newInputStream(path, LinkOption.NOFOLLOW_LINKS)) {
+            var bytes = input.readNBytes(MAX_BYTES + 1);
+            if (bytes.length > MAX_BYTES) throw new IOException("Character event intent too large");
+            fields.load(new ByteArrayInputStream(bytes));
+        }
+        try {
+            var id = UUID.fromString(fields.getProperty("id"));
+            var action = UUID.fromString(fields.getProperty("action"));
+            var type = fields.getProperty("type");
+            if (!path.equals(directory.resolve(id + ".pending")) || !TYPES.contains(type))
+                throw new IOException("Invalid character event intent identity");
+            EventInput.Location location = fields.containsKey("world")
+                ? new EventInput.Location(UUID.fromString(fields.getProperty("world")), fields.getProperty("world_name"),
+                    Double.parseDouble(fields.getProperty("x")), Double.parseDouble(fields.getProperty("y")),
+                    Double.parseDouble(fields.getProperty("z")), Instant.parse(fields.getProperty("captured_at")),
+                    fields.getProperty("quality")) : null;
+            var character = fields.containsKey("character") ? UUID.fromString(fields.getProperty("character")) : null;
+            var context = new EventInput.Context(UUID.fromString(fields.getProperty("player")),
+                fields.getProperty("player_name"), character, fields.getProperty("character_name"),
+                fields.containsKey("session") ? UUID.fromString(fields.getProperty("session")) : null, location);
+            var data = new LinkedHashMap<String, Object>();
+            for (var key : fields.stringPropertyNames()) if (key.startsWith("data.")) {
+                var value = fields.getProperty(key);
+                if (value.isEmpty()) throw new IOException("Invalid character event value");
+                data.put(key.substring(5), switch (value.charAt(0)) {
+                    case 's' -> value.substring(1);
+                    case 'b' -> {
+                        if (!value.equals("btrue") && !value.equals("bfalse")) throw new IOException("Invalid boolean");
+                        yield Boolean.valueOf(value.substring(1));
+                    }
+                    case 'i' -> Integer.valueOf(value.substring(1));
+                    default -> throw new IOException("Invalid character event value type");
+                });
+            }
+            return new EventInput(id, action, Instant.parse(fields.getProperty("time")), type, context, data);
+        } catch (RuntimeException failure) { throw new IOException("Invalid character event intent", failure); }
+    }
+
+    private void publish(EventInput event) {
+        try { sink.apply(event).whenComplete((delivery, failure) -> {
+            if (failure != null) { report(failure); return; }
+            if (delivery == LocalEventLog.Delivery.REJECTED) return;
+            try { if (Files.deleteIfExists(path(event))) forceDirectory(); }
+            catch (IOException error) { report(error); }
+        }); } catch (RuntimeException failure) { report(failure); }
+    }
+
+    private void forceDirectory() throws IOException {
+        try (var channel = FileChannel.open(directory, StandardOpenOption.READ)) { channel.force(true); }
+    }
+
+    private void report(Throwable error) {
+        try { failures.accept(error); } catch (RuntimeException ignored) { }
+    }
+
+    @Override public void close() {
+        worker.shutdown();
+        CompletableFuture.runAsync(() -> {
+            try {
+                if (!worker.awaitTermination(5, TimeUnit.SECONDS)) report(new IOException("Character event intents did not drain"));
+            } catch (InterruptedException interrupted) {
+                Thread.currentThread().interrupt(); report(interrupted);
+            } finally { drained.complete(null); }
+        });
+    }
+
+    CompletionStage<Void> drained() { return drained; }
+}

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

@@ -0,0 +1,223 @@
+package games.dmg.fantasystick.events;
+
+import java.io.ByteArrayOutputStream;
+import java.io.IOException;
+import java.nio.ByteBuffer;
+import java.nio.channels.FileChannel;
+import java.nio.charset.StandardCharsets;
+import java.nio.file.Files;
+import java.nio.file.LinkOption;
+import java.nio.file.Path;
+import java.nio.file.StandardCopyOption;
+import java.nio.file.StandardOpenOption;
+import java.time.Clock;
+import java.time.Instant;
+import java.util.LinkedHashMap;
+import java.util.Map;
+import java.util.Objects;
+import java.util.Properties;
+import java.util.UUID;
+import java.util.concurrent.CompletionStage;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import java.util.concurrent.TimeUnit;
+import java.util.function.Consumer;
+import java.util.function.Function;
+import org.bukkit.entity.Player;
+
+/** An acknowledged native discovery has one recoverable, account-keyed event intent. */
+public final class RecipeDiscoveryEventBridge implements AutoCloseable {
+    private static final String RECIPE = "fantasystick:character_sheet";
+    private static final int MAX_BYTES = 16_384;
+    private final Function<EventInput, CompletionStage<LocalEventLog.Delivery>> sink;
+    private final Clock clock;
+    private final Path pending;
+    private final Consumer<Throwable> failures;
+    private final ExecutorService worker = Executors.newSingleThreadExecutor(task ->
+        new Thread(task, "fantasy-recipe-discovery-events"));
+
+    public RecipeDiscoveryEventBridge(Function<EventInput, CompletionStage<LocalEventLog.Delivery>> sink,
+                                      Clock clock, Path dataFolder, Consumer<Throwable> failures) {
+        this.sink = Objects.requireNonNull(sink);
+        this.clock = Objects.requireNonNull(clock);
+        this.pending = Objects.requireNonNull(dataFolder).toAbsolutePath().resolve("recipe-event-intents");
+        this.failures = Objects.requireNonNull(failures);
+    }
+
+    public void discovered(Player player, String trigger, int notifications) {
+        try {
+            var record = capture(player, trigger, notifications > 0);
+            worker.execute(() -> {
+                try { publish(write(record)); }
+                catch (IOException | RuntimeException failure) { report(failure); }
+            });
+        } catch (RuntimeException failure) { report(failure); }
+    }
+
+    /** Called only after the shared writer's startup recovery is ready. */
+    public void replay() {
+        try {
+            worker.execute(() -> {
+                try {
+                    if (!Files.exists(pending, LinkOption.NOFOLLOW_LINKS)) return;
+                    if (!Files.isDirectory(pending, LinkOption.NOFOLLOW_LINKS)) throw new IOException("Unsafe recipe event intents");
+                    try (var entries = Files.list(pending)) {
+                        for (var path : entries.filter(p -> p.getFileName().toString().endsWith(".pending")).sorted().toList()) {
+                            try { publish(read(path)); }
+                            catch (IOException | RuntimeException failure) { report(failure); }
+                        }
+                    }
+                } catch (IOException | RuntimeException failure) { report(failure); }
+            });
+        } catch (RuntimeException failure) { report(failure); }
+    }
+
+    public void failed(Player player, String trigger, String reason) {
+        try {
+            var action = UUID.randomUUID();
+            var context = context(player);
+            emit(new EventInput(UUID.nameUUIDFromBytes(("fantasystick:recipe:" + action + ":failed")
+                .getBytes(StandardCharsets.UTF_8)), action, clock.instant(), "action.resolved", context,
+                Map.of("action_kind", "recipe_discovery", "recipe_id", RECIPE, "trigger", trigger,
+                    "outcome", "failed", "reason", reason)));
+        } catch (RuntimeException failure) { report(failure); }
+    }
+
+    private record Record(UUID account, UUID action, Instant time, String name, String trigger,
+                          boolean notification, EventInput.Location location) { }
+
+    private Record capture(Player player, String trigger, boolean notification) {
+        var context = context(player);
+        return new Record(context.playerId(), id(context.playerId()), clock.instant(), context.playerName(),
+            trigger, notification, context.location());
+    }
+
+    private EventInput.Context context(Player player) {
+        var location = player.getLocation();
+        EventInput.Location where = location == null || location.getWorld() == null ? null
+            : new EventInput.Location(location.getWorld().getUID(), location.getWorld().getName(),
+                location.getX(), location.getY(), location.getZ(), clock.instant(), "exact");
+        return new EventInput.Context(player.getUniqueId(), player.getName(), null, null, null, where);
+    }
+
+    private void publish(Record record) {
+        var fields = new LinkedHashMap<String, Object>();
+        fields.put("action_kind", "recipe_discovery");
+        fields.put("recipe_id", RECIPE);
+        fields.put("recipe_category", "misc");
+        fields.put("trigger", record.trigger());
+        fields.put("outcome", "acknowledged");
+        fields.put("first_discovery_notification", record.notification());
+        var input = new EventInput(UUID.nameUUIDFromBytes(("fantasystick:recipe:" + record.action()
+            + ":recipe.discovered").getBytes(StandardCharsets.UTF_8)), record.action(), record.time(),
+            "recipe.discovered", new EventInput.Context(record.account(), record.name(), null, null, null,
+                record.location()), fields);
+        emit(input).whenComplete((delivery, failure) -> {
+            if (failure != null) { report(failure); return; }
+            if (delivery == LocalEventLog.Delivery.REJECTED) return;
+            try {
+                if (Files.deleteIfExists(file(record.account()))) forceDirectory();
+            } catch (IOException deleteFailure) { report(deleteFailure); }
+        });
+    }
+
+    private CompletionStage<LocalEventLog.Delivery> emit(EventInput input) {
+        try { return sink.apply(input); }
+        catch (RuntimeException failure) {
+            report(failure);
+            return java.util.concurrent.CompletableFuture.completedStage(LocalEventLog.Delivery.REJECTED);
+        }
+    }
+
+    private Path file(UUID account) { return pending.resolve(account + ".pending"); }
+
+    private Record write(Record record) throws IOException {
+        if (Files.exists(pending, LinkOption.NOFOLLOW_LINKS)
+                && !Files.isDirectory(pending, LinkOption.NOFOLLOW_LINKS)) throw new IOException("Unsafe recipe event intents");
+        Files.createDirectories(pending);
+        Path target = file(record.account());
+        if (Files.exists(target, LinkOption.NOFOLLOW_LINKS)) {
+            if (!Files.isRegularFile(target, LinkOption.NOFOLLOW_LINKS)) throw new IOException("Unsafe recipe event intent");
+            return read(target); // Preserve the first native acknowledgment and its original identity.
+        }
+        var values = new Properties();
+        values.setProperty("account", record.account().toString());
+        values.setProperty("action", record.action().toString());
+        values.setProperty("time", record.time().toString());
+        values.setProperty("name", record.name());
+        values.setProperty("trigger", record.trigger());
+        values.setProperty("notification", Boolean.toString(record.notification()));
+        if (record.location() != null) {
+            var location = record.location();
+            values.setProperty("world", location.worldId().toString());
+            values.setProperty("world_name", location.worldName());
+            values.setProperty("x", Double.toString(location.x()));
+            values.setProperty("y", Double.toString(location.y()));
+            values.setProperty("z", Double.toString(location.z()));
+            values.setProperty("location_time", location.capturedAt().toString());
+        }
+        var output = new ByteArrayOutputStream();
+        values.store(output, "acknowledged native recipe discovery");
+        var bytes = output.toByteArray();
+        if (bytes.length > MAX_BYTES) throw new IOException("Recipe event intent too large");
+        Path temporary = Files.createTempFile(pending, ".recipe-", ".tmp");
+        try {
+            try (var channel = FileChannel.open(temporary, StandardOpenOption.WRITE, LinkOption.NOFOLLOW_LINKS)) {
+                var buffer = ByteBuffer.wrap(bytes);
+                while (buffer.hasRemaining()) channel.write(buffer);
+                channel.force(true);
+            }
+            Files.move(temporary, target, StandardCopyOption.ATOMIC_MOVE, StandardCopyOption.REPLACE_EXISTING);
+            forceDirectory();
+        } finally { Files.deleteIfExists(temporary); }
+        return record;
+    }
+
+    private void forceDirectory() throws IOException {
+        try (var channel = FileChannel.open(pending, StandardOpenOption.READ)) { channel.force(true); }
+    }
+
+    private Record read(Path path) throws IOException {
+        if (!Files.isRegularFile(path, LinkOption.NOFOLLOW_LINKS)) throw new IOException("Unsafe recipe event intent");
+        var values = new Properties();
+        try (var input = Files.newInputStream(path, LinkOption.NOFOLLOW_LINKS)) {
+            var bytes = input.readNBytes(MAX_BYTES + 1);
+            if (bytes.length > MAX_BYTES) throw new IOException("Recipe event intent too large");
+            values.load(new java.io.ByteArrayInputStream(bytes));
+        }
+        try {
+            var account = UUID.fromString(values.getProperty("account"));
+            var action = UUID.fromString(values.getProperty("action"));
+            if (!path.equals(file(account)) || !action.equals(id(account))) throw new IOException("Invalid recipe event identity");
+            EventInput.Location location = values.containsKey("world")
+                ? new EventInput.Location(UUID.fromString(values.getProperty("world")), values.getProperty("world_name"),
+                    Double.parseDouble(values.getProperty("x")), Double.parseDouble(values.getProperty("y")),
+                    Double.parseDouble(values.getProperty("z")), Instant.parse(values.getProperty("location_time")), "exact")
+                : null;
+            var trigger = values.getProperty("trigger");
+            if (!"join".equals(trigger) && !"enable_online".equals(trigger)) throw new IOException("Invalid recipe event trigger");
+            var notification = values.getProperty("notification");
+            if (!"true".equals(notification) && !"false".equals(notification)) throw new IOException("Invalid recipe notification");
+            return new Record(account, action, Instant.parse(values.getProperty("time")),
+                Objects.requireNonNull(values.getProperty("name")), trigger, Boolean.parseBoolean(notification), location);
+        } catch (RuntimeException invalid) { throw new IOException("Invalid recipe event intent", invalid); }
+    }
+
+    public static UUID id(UUID player) {
+        return UUID.nameUUIDFromBytes(("fantasystick:recipe:character_sheet:" + player)
+            .getBytes(StandardCharsets.UTF_8));
+    }
+
+    private void report(Throwable failure) {
+        try { failures.accept(failure); } catch (RuntimeException ignored) { }
+    }
+
+    @Override public void close() {
+        worker.shutdown();
+        try {
+            if (!worker.awaitTermination(5, TimeUnit.SECONDS)) report(new IOException("Recipe event intents did not drain"));
+        } catch (InterruptedException interrupted) {
+            Thread.currentThread().interrupt(); report(interrupted);
+        }
+    }
+}

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

@@ -0,0 +1,265 @@
+package games.dmg.fantasystick.events;
+
+import games.dmg.fantasystick.persistence.CharacterRecord;
+import games.dmg.fantasystick.persistence.EquipmentSessionStore;
+import java.io.ByteArrayOutputStream;
+import java.io.IOException;
+import java.nio.ByteBuffer;
+import java.nio.channels.FileChannel;
+import java.nio.charset.StandardCharsets;
+import java.nio.file.Files;
+import java.nio.file.LinkOption;
+import java.nio.file.Path;
+import java.nio.file.StandardCopyOption;
+import java.nio.file.StandardOpenOption;
+import java.time.Clock;
+import java.time.Duration;
+import java.time.Instant;
+import java.util.LinkedHashMap;
+import java.util.Objects;
+import java.util.Properties;
+import java.util.UUID;
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.CompletionStage;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import java.util.concurrent.TimeUnit;
+import java.util.function.Consumer;
+import java.util.function.Function;
+import org.bukkit.Location;
+import org.bukkit.entity.Player;
+
+/** Observes persisted switch deadlines and pre-pack admission without authorizing either. */
+public final class SwitchDelayEventBridge implements AutoCloseable {
+    private static final int MAX_BYTES = 16_384;
+    private final Function<EventInput, CompletionStage<LocalEventLog.Delivery>> sink;
+    private final Clock clock;
+    private final Path pending;
+    private final Consumer<Throwable> failures;
+    private final ExecutorService worker = Executors.newSingleThreadExecutor(task ->
+        new Thread(task, "fantasy-switch-delay-events"));
+    private final CompletableFuture<Void> drained = new CompletableFuture<>();
+
+    public SwitchDelayEventBridge(Function<EventInput, CompletionStage<LocalEventLog.Delivery>> sink, Clock clock,
+                                  Path dataFolder, Consumer<Throwable> failures) {
+        this.sink = Objects.requireNonNull(sink);
+        this.clock = Objects.requireNonNull(clock);
+        this.pending = Objects.requireNonNull(dataFolder).toAbsolutePath().resolve("switch-event-intents");
+        this.failures = Objects.requireNonNull(failures);
+    }
+
+    public record ExitContext(UUID player, String playerName, UUID character, String characterName,
+                              UUID session, EventInput.Location location, String reason) { }
+
+    public ExitContext exit(Player player, UUID session, CharacterRecord character, String reason) {
+        try {
+            return new ExitContext(player.getUniqueId(), player.getName(), character.id(), character.name(),
+                session, location(player.getLocation()), reason);
+        } catch (RuntimeException ignored) { return null; }
+    }
+
+    private record SavedStart(ExitContext capture, EquipmentSessionStore.Exit exit,
+                              String revisionBefore, String revisionAfter, Instant time) { }
+
+    public void started(ExitContext captured, EquipmentSessionStore.State saved) {
+        if (captured == null || saved == null || saved.pending() != null || saved.lastExit() == null
+                || !captured.session().equals(saved.lastExit().sessionId())) return;
+        var start = new SavedStart(captured, saved.lastExit(),
+            saved.revision().subtract(java.math.BigInteger.ONE).toString(), saved.revision().toString(),
+            saved.lastExit().exitedAt());
+        try { worker.execute(() -> {
+            try { publish(write(start)); }
+            catch (IOException | RuntimeException failure) { report(failure); }
+        }); } catch (RuntimeException rejected) { report(rejected); }
+    }
+
+    private void publish(SavedStart start) {
+        var captured = start.capture();
+        var exit = start.exit();
+        var values = new LinkedHashMap<String, Object>();
+        values.put("outcome", "acknowledged");
+        values.put("exit_reason", captured.reason());
+        values.put("exit_operation_id", captured.session().toString());
+        values.put("character_id", exit.characterId().toString());
+        values.put("session_id", exit.sessionId().toString());
+        values.put("duration_seconds", Long.toString(Duration.between(exit.exitedAt(), exit.deadline()).getSeconds()));
+        values.put("exited_at", exit.exitedAt().toString());
+        values.put("deadline", exit.deadline().toString());
+        values.put("revision_before", start.revisionBefore());
+        values.put("revision_after", start.revisionAfter());
+        values.put("zero_duration", exit.deadline().equals(exit.exitedAt()));
+        var input = new EventInput(id(captured.session(), "started"), captured.session(), start.time(),
+            "character.switch_delay_started", new EventInput.Context(captured.player(), captured.playerName(),
+                captured.character(), captured.characterName(), captured.session(), captured.location()), values);
+        try { sink.apply(input).whenComplete((delivery, failure) -> {
+            if (failure != null) { report(failure); return; }
+            if (delivery == LocalEventLog.Delivery.REJECTED) return;
+            try { if (Files.deleteIfExists(file(captured.session()))) forceDirectory(); }
+            catch (IOException error) { report(error); }
+        }); } catch (RuntimeException failure) { report(failure); }
+    }
+
+    /** Replay only persisted, previously acknowledged exits, before any new native session observations. */
+    public void replay() {
+        if (worker.isShutdown()) return;
+        try { worker.execute(() -> {
+            try {
+                if (!Files.exists(pending, LinkOption.NOFOLLOW_LINKS)) return;
+                if (!Files.isDirectory(pending, LinkOption.NOFOLLOW_LINKS)) throw new IOException("Unsafe switch event intents");
+                try (var entries = Files.list(pending)) {
+                    for (var path : entries.filter(p -> p.getFileName().toString().endsWith(".pending")).sorted().toList()) {
+                        try { publish(read(path)); }
+                        catch (IOException | RuntimeException failure) { report(failure); }
+                    }
+                }
+            } catch (IOException | RuntimeException failure) { report(failure); }
+        }); } catch (RuntimeException rejected) { report(rejected); }
+    }
+
+    private Path file(UUID session) { return pending.resolve(session + ".pending"); }
+
+    private SavedStart write(SavedStart value) throws IOException {
+        if (Files.exists(pending, LinkOption.NOFOLLOW_LINKS)
+                && !Files.isDirectory(pending, LinkOption.NOFOLLOW_LINKS)) throw new IOException("Unsafe switch event intents");
+        Files.createDirectories(pending);
+        Path target = file(value.capture().session());
+        if (Files.exists(target, LinkOption.NOFOLLOW_LINKS)) return read(target);
+        var fields = new Properties();
+        var capture = value.capture(); var exit = value.exit();
+        fields.setProperty("player", capture.player().toString());
+        fields.setProperty("player_name", capture.playerName());
+        fields.setProperty("character", capture.character().toString());
+        fields.setProperty("character_name", capture.characterName());
+        fields.setProperty("session", capture.session().toString());
+        fields.setProperty("reason", capture.reason());
+        fields.setProperty("exited_at", exit.exitedAt().toString());
+        fields.setProperty("deadline", exit.deadline().toString());
+        fields.setProperty("revision_before", value.revisionBefore());
+        fields.setProperty("revision_after", value.revisionAfter());
+        fields.setProperty("time", value.time().toString());
+        if (capture.location() != null) {
+            var location = capture.location();
+            fields.setProperty("world", location.worldId().toString());
+            fields.setProperty("world_name", location.worldName());
+            fields.setProperty("x", Double.toString(location.x()));
+            fields.setProperty("y", Double.toString(location.y()));
+            fields.setProperty("z", Double.toString(location.z()));
+            fields.setProperty("location_time", location.capturedAt().toString());
+        }
+        var output = new ByteArrayOutputStream();
+        fields.store(output, "acknowledged switch deadline");
+        byte[] bytes = output.toByteArray();
+        if (bytes.length > MAX_BYTES) throw new IOException("Switch event intent too large");
+        Path temporary = Files.createTempFile(pending, ".switch-", ".tmp");
+        try {
+            try (var channel = FileChannel.open(temporary, StandardOpenOption.WRITE, LinkOption.NOFOLLOW_LINKS)) {
+                var buffer = ByteBuffer.wrap(bytes);
+                while (buffer.hasRemaining()) channel.write(buffer);
+                channel.force(true);
+            }
+            Files.move(temporary, target, StandardCopyOption.ATOMIC_MOVE, StandardCopyOption.REPLACE_EXISTING);
+            forceDirectory();
+        } finally { Files.deleteIfExists(temporary); }
+        return value;
+    }
+
+    private void forceDirectory() throws IOException {
+        try (var channel = FileChannel.open(pending, StandardOpenOption.READ)) { channel.force(true); }
+    }
+
+    private SavedStart read(Path path) throws IOException {
+        if (!Files.isRegularFile(path, LinkOption.NOFOLLOW_LINKS)) throw new IOException("Unsafe switch event intent");
+        var fields = new Properties();
+        try (var input = Files.newInputStream(path, LinkOption.NOFOLLOW_LINKS)) {
+            var bytes = input.readNBytes(MAX_BYTES + 1);
+            if (bytes.length > MAX_BYTES) throw new IOException("Switch event intent too large");
+            fields.load(new java.io.ByteArrayInputStream(bytes));
+        }
+        try {
+            var player = UUID.fromString(fields.getProperty("player"));
+            var character = UUID.fromString(fields.getProperty("character"));
+            var session = UUID.fromString(fields.getProperty("session"));
+            if (!path.equals(file(session))) throw new IOException("Switch event identity mismatch");
+            var reason = fields.getProperty("reason");
+            if (!java.util.Set.of("voluntary", "logout", "defeat", "shutdown").contains(reason))
+                throw new IOException("Invalid switch exit reason");
+            EventInput.Location location = fields.containsKey("world")
+                ? new EventInput.Location(UUID.fromString(fields.getProperty("world")), fields.getProperty("world_name"),
+                    Double.parseDouble(fields.getProperty("x")), Double.parseDouble(fields.getProperty("y")),
+                    Double.parseDouble(fields.getProperty("z")), Instant.parse(fields.getProperty("location_time")), "exact")
+                : null;
+            var before = fields.getProperty("revision_before"); var after = fields.getProperty("revision_after");
+            if (!before.matches("0|[1-9][0-9]*") || !after.matches("[1-9][0-9]*"))
+                throw new IOException("Invalid switch revision");
+            var exit = new EquipmentSessionStore.Exit(session, character,
+                Instant.parse(fields.getProperty("exited_at")), Instant.parse(fields.getProperty("deadline")));
+            return new SavedStart(new ExitContext(player, Objects.requireNonNull(fields.getProperty("player_name")),
+                character, Objects.requireNonNull(fields.getProperty("character_name")), session, location, reason),
+                exit, before, after, Instant.parse(fields.getProperty("time")));
+        } catch (RuntimeException invalid) { throw new IOException("Invalid switch event intent", invalid); }
+    }
+
+    private void report(Throwable failure) {
+        try { failures.accept(failure); } catch (RuntimeException ignored) { }
+    }
+
+    /** Shutdown does not wait for file I/O on the Minecraft thread. */
+    @Override public void close() {
+        worker.shutdown();
+        CompletableFuture.runAsync(() -> {
+            try {
+                if (!worker.awaitTermination(5, TimeUnit.SECONDS))
+                    report(new IOException("Switch event intents did not drain"));
+            } catch (InterruptedException interrupted) {
+                Thread.currentThread().interrupt(); report(interrupted);
+            } finally { drained.complete(null); }
+        });
+    }
+
+    public CompletionStage<Void> drained() { return drained; }
+
+    public void evaluated(Player player, UUID requested, EquipmentSessionStore.State state,
+                          Duration configured, Instant now, boolean allowed) {
+        try {
+            var action = UUID.randomUUID();
+            var values = new LinkedHashMap<String, Object>();
+            values.put("action_kind", "character_switch_preflight");
+            values.put("requested_character_id", requested.toString());
+            values.put("configured_duration_seconds", Long.toString(configured.getSeconds()));
+            values.put("preflight_order", "before_equipment_pack");
+            values.put("outcome", "observed");
+            var exit = state == null ? null : state.lastExit();
+            boolean same = exit != null && requested.equals(exit.characterId());
+            values.put("same_character", same);
+            values.put("last_exited_character_id", exit == null ? "none" : exit.characterId().toString());
+            if (exit != null) {
+                values.put("deadline", exit.deadline().toString());
+                var remaining = Duration.between(now, exit.deadline());
+                values.put("remaining_seconds", Long.toString(Math.max(0,
+                    remaining.getSeconds() + (remaining.getNano() > 0 ? 1 : 0))));
+                values.put("receipt_revision", state.revision().toString());
+            }
+            var context = new EventInput.Context(player.getUniqueId(), player.getName(), null, null, null,
+                location(player.getLocation()));
+            emit(new EventInput(id(action, "observed"), action, clock.instant(), "action.observed", context, values));
+            values.put("outcome", allowed ? "allowed" : "refused");
+            values.put("reason", allowed ? (same ? "same_character" : "prepack_allowed") : "cooldown");
+            emit(new EventInput(id(action, "resolved"), action, clock.instant(), "action.resolved", context, values));
+        } catch (RuntimeException ignored) { /* Logging cannot change entry admission. */ }
+    }
+
+    private EventInput.Location location(Location value) {
+        return value == null || value.getWorld() == null ? null
+            : new EventInput.Location(value.getWorld().getUID(), value.getWorld().getName(), value.getX(), value.getY(),
+                value.getZ(), clock.instant(), "exact");
+    }
+
+    private void emit(EventInput event) {
+        try { sink.apply(event); } catch (RuntimeException ignored) { }
+    }
+
+    private static UUID id(UUID action, String kind) {
+        return UUID.nameUUIDFromBytes(("fantasystick:switch-delay:" + action + ':' + kind)
+            .getBytes(StandardCharsets.UTF_8));
+    }
+}

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

@@ -370,20 +370,29 @@ public final class CharacterStorage implements AutoCloseable {
 
     public CompletableFuture<Optional<CharacterRecord>> renameCharacter(
             UUID characterId, String name, BigInteger expectedSheetGeneration) {
+        return renameCharacterObserved(characterId, name, expectedSheetGeneration).thenApply(RenameOutcome::record);
+    }
+
+    /** Capture the authoritative before/after pair in the same serialized save, not from stale item text. */
+    public record RenameOutcome(Optional<CharacterRecord> record, Optional<CharacterRecord> before, String status) { }
+
+    public CompletableFuture<RenameOutcome> renameCharacterObserved(
+            UUID characterId, String name, BigInteger expectedSheetGeneration) {
         Objects.requireNonNull(characterId);
         Objects.requireNonNull(name);
         return submit(() -> {
             var found = repository.load(characterId);
-            if (found.isEmpty() || found.orElseThrow().dead()) return Optional.empty();
+            if (found.isEmpty() || found.orElseThrow().dead())
+                return new RenameOutcome(Optional.empty(), Optional.empty(), "unavailable");
             var old = found.orElseThrow();
             if (expectedSheetGeneration != null && !old.sheetGeneration().equals(expectedSheetGeneration))
-                return Optional.empty();
-            if (old.name().equals(name)) return Optional.of(old);
+                return new RenameOutcome(Optional.empty(), Optional.of(old), "stale_generation");
+            if (old.name().equals(name)) return new RenameOutcome(Optional.of(old), Optional.of(old), "unchanged");
             var renamed = new CharacterRecord(old.id(), name, old.revision().add(BigInteger.ONE), old.stats(), old.level(),
                 old.experience(), old.unspentPoints(), old.health(), old.learned(), old.loadout(), old.passives(), old.cooldowns(),
                 old.restrictedKills(), false, old.deathId(), old.diedAt(), old.coins(), old.coinsInitialized(), old.rewardReceipts(),old.pvpCoinEscrow(),old.gear(),old.sheetGeneration());
             repository.replace(renamed, old.revision());
-            return Optional.of(renamed);
+            return new RenameOutcome(Optional.of(renamed), Optional.of(old), "renamed");
         });
     }
 
@@ -882,6 +891,19 @@ public final class CharacterStorage implements AutoCloseable {
         }
     }
 
+    /** Observe accepted save callbacks without waiting for file I/O on the native thread. */
+    public java.util.concurrent.CompletionStage<Void> drained() {
+        return java.util.concurrent.CompletableFuture.runAsync(() -> {
+            try {
+                if (!worker.awaitTermination(5, java.util.concurrent.TimeUnit.SECONDS))
+                    throw new java.util.concurrent.CompletionException(new java.io.IOException("Character storage did not drain"));
+            } catch (InterruptedException interrupted) {
+                Thread.currentThread().interrupt();
+                throw new java.util.concurrent.CompletionException(interrupted);
+            }
+        });
+    }
+
     /** Stop accepting work without blocking shutdown; already queued file writes may finish. */
     @Override
     public void close() {

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

@@ -166,7 +166,7 @@ public final class EquipmentSessionEvents implements Listener, AutoCloseable {
         queued.remove(owner);
         swaps.remove(owner);
         boolean reserved = writing.add(owner);
-        try { sessions.invalidateContext(owner); sessions.exit(player); }
+        try { sessions.invalidateContext(owner); sessions.exit(player, "logout"); }
         finally { if (reserved) writing.remove(owner); observed.remove(owner); }
     }
 

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

@@ -48,6 +48,8 @@ public final class EquipmentSessions implements AutoCloseable {
     private java.util.function.Function<DownedEpisode,List<DownedEpisode.Reward>> downedRewardAllocation=ignored->List.of();
     private games.dmg.fantasystick.events.DownedEventBridge downedEvents;
     private games.dmg.fantasystick.events.SessionEventBridge sessionEvents;
+    private games.dmg.fantasystick.events.SwitchDelayEventBridge switchEvents;
+    private games.dmg.fantasystick.events.CharacterIdentityEventBridge identityEvents;
     private java.util.function.Function<DownedEpisode,CompletionStage<?>> downedDefeatRewards=ignored->CompletableFuture.completedStage(null);
     private java.util.function.Predicate<UUID> unavailableCharacter = ignored -> false;
     private java.util.function.Function<UUID,java.util.concurrent.CompletionStage<?>> partyDefeat =
@@ -117,6 +119,9 @@ public final class EquipmentSessions implements AutoCloseable {
         boolean exitRequested;
         games.dmg.fantasystick.events.SessionEventBridge.ExitCapture exitEvent;
         boolean exitEventWritten;
+        games.dmg.fantasystick.events.SwitchDelayEventBridge.ExitContext switchExit;
+        boolean switchEventWritten;
+        String exitReason = "voluntary";
         Duration exitDelay;
         boolean arrival;
         Attempt recoveryOwner;
@@ -210,6 +215,8 @@ public final class EquipmentSessions implements AutoCloseable {
     public synchronized void attachDownedRewardAllocation(java.util.function.Function<DownedEpisode,List<DownedEpisode.Reward>> allocation){if(!owned.isEmpty())throw new IllegalStateException("Sessions already started");downedRewardAllocation=Objects.requireNonNull(allocation);}
     public synchronized void attachDownedEvents(games.dmg.fantasystick.events.DownedEventBridge events){if(!owned.isEmpty()||downedEvents!=null)throw new IllegalStateException("Downed events already attached or sessions started");downedEvents=Objects.requireNonNull(events);}
     public synchronized void attachSessionEvents(games.dmg.fantasystick.events.SessionEventBridge events){if(!owned.isEmpty()||sessionEvents!=null)throw new IllegalStateException("Session events already attached or sessions started");sessionEvents=Objects.requireNonNull(events);}
+    public synchronized void attachSwitchEvents(games.dmg.fantasystick.events.SwitchDelayEventBridge events){if(!owned.isEmpty()||switchEvents!=null)throw new IllegalStateException("Switch events already attached or sessions started");switchEvents=Objects.requireNonNull(events);}
+    public synchronized void attachIdentityEvents(games.dmg.fantasystick.events.CharacterIdentityEventBridge events){if(!owned.isEmpty()||identityEvents!=null)throw new IllegalStateException("Identity events already attached or sessions started");identityEvents=Objects.requireNonNull(events);}
     public synchronized void attachDownedDefeatRewards(java.util.function.Function<DownedEpisode,CompletionStage<?>> settlement){if(!owned.isEmpty())throw new IllegalStateException("Sessions already started");downedDefeatRewards=Objects.requireNonNull(settlement);}
     public synchronized List<DownedEpisode.Reward> finalRewards(DownedEpisode episode){return List.copyOf(downedRewardAllocation.apply(Objects.requireNonNull(episode)));}
 
@@ -610,13 +617,17 @@ public final class EquipmentSessions implements AutoCloseable {
                 refuse(attempt, "RECOVERY_REQUIRED", "An unresolved equipment receipt requires validated recovery."); return;
             }
             Instant now = clock.instant();
-            if (!state.canEnter(attempt.character, switchDelay.get(), now)) {
+            boolean admitted = state.canEnter(attempt.character, switchDelay.get(), now);
+            if (switchEvents != null) switchEvents.evaluated(attempt.player, attempt.character,
+                state, switchDelay.get(), now, admitted);
+            if (!admitted) {
                 Duration remaining = Duration.between(now, state.lastExit().deadline());
                 long seconds = remaining.getSeconds() + (remaining.getNano() == 0 ? 0 : 1);
                 refuse(attempt, "COOLDOWN", "Wait " + seconds
                     + " seconds to switch characters; the same character may be resumed now."); return;
             }
-        }
+        } else if (switchEvents != null) switchEvents.evaluated(attempt.player, attempt.character,
+            null, switchDelay.get(), clock.instant(), true);
         if (!entryNativeSafe(attempt, loaded.state().orElse(null))) {
             refuse(attempt, "NATIVE_RECOVERY_REQUIRED", "Native equipment marker or control/box remnants require inspection; entry did not change items.");
             return;
@@ -708,6 +719,7 @@ public final class EquipmentSessions implements AutoCloseable {
             }
             attempt.player.updateInventory();
             if(active.get(attempt.owner)==attempt&&sessionEvents!=null)sessionEvents.entered(attempt.player,attempt.session,record,attempt.entryLocation,attempt.resumedDowned!=null,attempt.previousGameMode!=null);
+            if(active.get(attempt.owner)==attempt&&identityEvents!=null)identityEvents.entered(attempt.player,attempt.session,record);
         } catch (RuntimeException error) {
             fail(attempt, error); // Effects may have started: never roll back or replay them.
             notice(attempt.owner, "NATIVE_UNCERTAIN", "Equipment mutation failed; items and receipt require inspection.");
@@ -737,9 +749,14 @@ public final class EquipmentSessions implements AutoCloseable {
      * A native exception returns INVALID_BOX with NATIVE_UNCERTAIN notice/diagnostic; never retry it.
      */
     public synchronized EquipmentStorage.RestoreResult exit(Player player) {
+        return exit(player, "voluntary");
+    }
+
+    public synchronized EquipmentStorage.RestoreResult exit(Player player, String reason) {
         UUID owner = player.getUniqueId();
         var transition = transitioning.get(owner);
         if (transition != null) {
+            transition.exitReason = Objects.requireNonNull(reason);
             captureExitDelay(transition);
             active.remove(owner, transition);
             withdrawPresentation(transition);
@@ -750,6 +767,7 @@ public final class EquipmentSessions implements AutoCloseable {
         cancelEntry(owner);
         var attempt = active.remove(owner);
         if (attempt == null) { invalidateCursor(owner); return EquipmentStorage.RestoreResult.NOT_FOUND; }
+        attempt.exitReason = Objects.requireNonNull(reason);
         captureExitDelay(attempt);
         return restoreExit(attempt);
     }
@@ -785,6 +803,7 @@ public final class EquipmentSessions implements AutoCloseable {
         }
         withdrawPresentation(attempt);
         attempt.defeated = true;
+        attempt.exitReason = "defeat";
         event.setCancelled(true);
         boolean reserved = transitioning.putIfAbsent(attempt.owner, attempt) == null;
         // Submit first: any subsequent native getter/setter/notice can reenter disable, which
@@ -854,7 +873,7 @@ public final class EquipmentSessions implements AutoCloseable {
     public synchronized void reviveDowned(DownedEpisode episode,Consumer<Boolean> completion){Objects.requireNonNull(episode);Objects.requireNonNull(completion);if(episode.phase()!=DownedEpisode.Phase.RESOLVED||episode.outcome()!=DownedEpisode.Outcome.REVIVED){completion.accept(false);return;}var attempt=active.get(episode.player());if(attempt==null||attempt.downed==null||!attempt.downed.id().equals(episode.id())||!attempt.session.equals(episode.session())||!attempt.character.equals(episode.character())){completion.accept(false);return;}var expected=attempt.record.revision();var maximum=attempt.record.maximumHealth().min(NativeHealthLimit.read());characters.saveHealth(attempt.character,expected,maximum,maximum).whenComplete((saved,failure)->persistReturn(()->{synchronized(EquipmentSessions.this){if(failure!=null||saved==null||saved.isEmpty()||active.get(attempt.owner)!=attempt||attempt.downed==null||!attempt.downed.id().equals(episode.id())){if(failure!=null)diagnostic(attempt,failure);completion.accept(false);return;}var record=saved.orElseThrow();try{if(vitals!=null&&!record.revision().equals(attempt.record.revision()))vitals.updateProgress(attempt.player,attempt.session,attempt.record,record);attempt.record=record;attempt.downed=null;attempt.downing=false;attempt.downedProtectionUntil=episode.protectionUntil();double nativeMaximum=Objects.requireNonNull(attempt.player.getAttribute(org.bukkit.attribute.Attribute.MAX_HEALTH)).getValue();attempt.player.setHealth(Math.min(nativeMaximum,record.health().doubleValue()));refreshControls(attempt,new Active(attempt.owner,attempt.session,attempt.character));attempt.player.closeInventory();notice(attempt.owner,"REVIVED","§aRevive restored your downed character.");completion.accept(true);}catch(RuntimeException publicationFailure){diagnostic(attempt,publicationFailure);completion.accept(false);}}}));}
 
     /** Publish one already-durable final-death outcome through the existing restoration/Tail custody path. */
-    public synchronized boolean finalizeDowned(DownedEpisode episode){Objects.requireNonNull(episode);if(episode.phase()!=DownedEpisode.Phase.RESOLVED||episode.outcome()!=DownedEpisode.Outcome.FINAL_DEATH)return false;var attempt=active.get(episode.player());if(attempt==null){persist(()->recordOfflineFinalDeath(episode),(dead,failure)->{if(failure!=null)diagnostic(new Failure(episode.player(),episode.session(),failure));else if(dead.isEmpty())diagnostic(new Failure(episode.player(),episode.session(),new IllegalStateException("Offline final death conflicted with saved character")));});return true;}if(attempt.downed==null||!attempt.downed.id().equals(episode.id())||!attempt.session.equals(episode.session())||!attempt.character.equals(episode.character()))return false;active.remove(attempt.owner,attempt);attempt.finalDowned=episode;attempt.downed=null;withdrawPresentation(attempt);attempt.defeated=true;boolean reserved=transitioning.putIfAbsent(attempt.owner,attempt)==null;boolean loseCoins=episode.attribution().playerDefeat();persist(()->characters.recordFinalDeath(attempt.character,attempt.record.revision(),episode.id(),episode.resolvedAt(),loseCoins),(dead,failure)->{if(failure!=null){diagnostic(attempt,failure);conversionUncertain(attempt,"Final death save failed or is uncertain");return;}if(dead.isEmpty()){conversionUncertain(attempt,"Character was missing or final death conflicted; no Tail authorized");return;}attempt.deathResolved=true;attempt.deathRecord=dead.orElseThrow();if(downedEvents!=null)downedEvents.finalDeathRecorded(episode);if(closed){conversionUncertain(attempt,"Shutdown before reward, party defeat and Tail conversion");return;}java.util.concurrent.CompletionStage<?> partyMutation=finalConsequences(episode);partyMutation.whenComplete((ignored,partyFailure)->{synchronized(EquipmentSessions.this){if(partyFailure!=null){diagnostic(attempt,partyFailure);conversionUncertain(attempt,"Party defeat mutation failed");return;}attempt.partyDefeatAcknowledged=true;queueTail(attempt);}});});try{var restored=restoreExit(attempt);if(restored==EquipmentStorage.RestoreResult.RESTORED){var retained=attempt.player.getInventory().getItemInOffHand();attempt.deathReference=copy(retained);attempt.deathNativeReference=nativeIdentity(retained);attempt.deathView=attempt.player.getOpenInventory();}double maximum=Objects.requireNonNull(attempt.player.getAttribute(org.bukkit.attribute.Attribute.MAX_HEALTH)).getValue();attempt.player.setHealth(maximum);notice(attempt.owner,"DEFEAT","§cYour character was defeated.");attempt.defeatReturnTeleport=true;try{boolean returned;try{returned=attempt.player.teleport(attempt.entryLocation.clone());}catch(RuntimeException uncertain){if(downedEvents!=null)downedEvents.returnAttempted(episode,"uncertain");throw uncertain;}if(downedEvents!=null)downedEvents.returnAttempted(episode,returned?"returned":"refused");if(!returned)notice(attempt.owner,"DEFEAT_RETURN_FAILED","Return to the session entry location was refused; you remain here.");}finally{attempt.defeatReturnTeleport=false;if(!attempt.deliveryInvalidated&&owned.get(attempt.owner)==attempt&&attempt.player.isOnline())attempt.deathView=attempt.player.getOpenInventory();}}catch(RuntimeException failure){diagnostic(attempt,failure);conversionUncertain(attempt,"Native final-death transition failed; inspect retained equipment and death state");}finally{if(reserved)transitioning.remove(attempt.owner,attempt);finishDrain();}return true;}
+    public synchronized boolean finalizeDowned(DownedEpisode episode){Objects.requireNonNull(episode);if(episode.phase()!=DownedEpisode.Phase.RESOLVED||episode.outcome()!=DownedEpisode.Outcome.FINAL_DEATH)return false;var attempt=active.get(episode.player());if(attempt==null){persist(()->recordOfflineFinalDeath(episode),(dead,failure)->{if(failure!=null)diagnostic(new Failure(episode.player(),episode.session(),failure));else if(dead.isEmpty())diagnostic(new Failure(episode.player(),episode.session(),new IllegalStateException("Offline final death conflicted with saved character")));});return true;}if(attempt.downed==null||!attempt.downed.id().equals(episode.id())||!attempt.session.equals(episode.session())||!attempt.character.equals(episode.character()))return false;active.remove(attempt.owner,attempt);attempt.finalDowned=episode;attempt.downed=null;withdrawPresentation(attempt);attempt.defeated=true;attempt.exitReason="defeat";boolean reserved=transitioning.putIfAbsent(attempt.owner,attempt)==null;boolean loseCoins=episode.attribution().playerDefeat();persist(()->characters.recordFinalDeath(attempt.character,attempt.record.revision(),episode.id(),episode.resolvedAt(),loseCoins),(dead,failure)->{if(failure!=null){diagnostic(attempt,failure);conversionUncertain(attempt,"Final death save failed or is uncertain");return;}if(dead.isEmpty()){conversionUncertain(attempt,"Character was missing or final death conflicted; no Tail authorized");return;}attempt.deathResolved=true;attempt.deathRecord=dead.orElseThrow();if(downedEvents!=null)downedEvents.finalDeathRecorded(episode);if(closed){conversionUncertain(attempt,"Shutdown before reward, party defeat and Tail conversion");return;}java.util.concurrent.CompletionStage<?> partyMutation=finalConsequences(episode);partyMutation.whenComplete((ignored,partyFailure)->{synchronized(EquipmentSessions.this){if(partyFailure!=null){diagnostic(attempt,partyFailure);conversionUncertain(attempt,"Party defeat mutation failed");return;}attempt.partyDefeatAcknowledged=true;queueTail(attempt);}});});try{var restored=restoreExit(attempt);if(restored==EquipmentStorage.RestoreResult.RESTORED){var retained=attempt.player.getInventory().getItemInOffHand();attempt.deathReference=copy(retained);attempt.deathNativeReference=nativeIdentity(retained);attempt.deathView=attempt.player.getOpenInventory();}double maximum=Objects.requireNonNull(attempt.player.getAttribute(org.bukkit.attribute.Attribute.MAX_HEALTH)).getValue();attempt.player.setHealth(maximum);notice(attempt.owner,"DEFEAT","§cYour character was defeated.");attempt.defeatReturnTeleport=true;try{boolean returned;try{returned=attempt.player.teleport(attempt.entryLocation.clone());}catch(RuntimeException uncertain){if(downedEvents!=null)downedEvents.returnAttempted(episode,"uncertain");throw uncertain;}if(downedEvents!=null)downedEvents.returnAttempted(episode,returned?"returned":"refused");if(!returned)notice(attempt.owner,"DEFEAT_RETURN_FAILED","Return to the session entry location was refused; you remain here.");}finally{attempt.defeatReturnTeleport=false;if(!attempt.deliveryInvalidated&&owned.get(attempt.owner)==attempt&&attempt.player.isOnline())attempt.deathView=attempt.player.getOpenInventory();}}catch(RuntimeException failure){diagnostic(attempt,failure);conversionUncertain(attempt,"Native final-death transition failed; inspect retained equipment and death state");}finally{if(reserved)transitioning.remove(attempt.owner,attempt);finishDrain();}return true;}
 
     private CompletionStage<Void> finalConsequences(DownedEpisode episode){var result=new CompletableFuture<Void>();try{nextTick.accept(()->{CompletionStage<?> work;try{work=downedDefeatRewards.apply(episode).thenCompose(ignored->partyDefeat.apply(episode.character()));}catch(RuntimeException failure){result.completeExceptionally(failure);return;}work.whenComplete((ignored,failure)->{if(failure==null)result.complete(null);else result.completeExceptionally(failure);});});}catch(RuntimeException rejected){result.completeExceptionally(rejected);}return result;}
 
@@ -1008,6 +1027,8 @@ public final class EquipmentSessions implements AutoCloseable {
     }
 
     private EquipmentStorage.RestoreResult restoreExit(Attempt attempt) {
+        if(switchEvents!=null&&attempt.switchExit==null&&attempt.record!=null)
+            attempt.switchExit=switchEvents.exit(attempt.player,attempt.session,attempt.record,attempt.exitReason);
         if(sessionEvents!=null&&attempt.exitEvent==null&&!attempt.defeated&&attempt.downed==null&&!closed&&attempt.player.isOnline()&&attempt.record!=null)
             attempt.exitEvent=sessionEvents.captureExit(attempt.player,attempt.session,attempt.record,attempt.entryLocation);
         captureExitDelay(attempt);
@@ -1130,6 +1151,10 @@ public final class EquipmentSessions implements AutoCloseable {
                         "Equipment restoration persistence failed before Tail conversion");
                 } else if (complete) {
                     attempt.gearAcknowledged = true;
+                    if (!attempt.switchEventWritten && switchEvents != null) {
+                        attempt.switchEventWritten = true;
+                        switchEvents.started(attempt.switchExit, state);
+                    }
                     if (!attempt.defeated && !attempt.exitEventWritten && attempt.exitEvent != null && sessionEvents != null) {
                         attempt.exitEventWritten = true;
                         sessionEvents.exited(attempt.session,attempt.exitEvent);
@@ -1357,7 +1382,7 @@ public final class EquipmentSessions implements AutoCloseable {
                 if (attempt.defeated && !attempt.bookDelivered) conversionUncertain(attempt, "Shutdown before confirmed Tail conversion");
             }
             for (var owner : java.util.List.copyOf(pending.keySet())) cancelEntry(owner);
-            for (var attempt : java.util.List.copyOf(active.values())) exit(attempt.player);
+            for (var attempt : java.util.List.copyOf(active.values())) exit(attempt.player, "shutdown");
             characterRecoveries.clear();
             recoveryRecipients.clear();
             claims.close();

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

@@ -232,6 +232,52 @@ class CharacterBookNativeTest {
         }
     }
 
+    @Test void previousVolumeReturnsToOverviewWithoutInventingAnotherBookOpen() throws Exception {
+        try (var f = new FantasyStickLifecycleNativeTest.Fixture(data)) {
+            f.plugin.setEnabled(true);
+            var actor = new FantasyStickLifecycleNativeTest.Actor(data);
+            f.players.put(actor.core.id, actor.player); f.activate(actor);
+            var old = actor.core.record;
+            var stats = new java.util.EnumMap<games.dmg.fantasystick.progression.Stat, java.math.BigInteger>(games.dmg.fantasystick.progression.Stat.class);
+            stats.putAll(old.stats()); stats.put(games.dmg.fantasystick.progression.Stat.STR,
+                new java.math.BigInteger("1234567890".repeat(4000)));
+            var saved = new games.dmg.fantasystick.persistence.CharacterRecord(old.id(), old.name(),
+                old.revision().add(java.math.BigInteger.ONE), stats, old.level(), old.experience(),
+                java.math.BigInteger.ZERO, old.health(), old.learned(), old.loadout(), old.cooldowns(), false, null, null);
+            new games.dmg.fantasystick.persistence.YamlCharacterRepository(data).replace(saved, old.revision());
+            click(f, actor); drainReads(f); runQueued(f);
+            var next = PartyBookNativeTest.button(actor, "[Next pages]");
+            PartyBookNativeTest.click(f, actor, next); drainReads(f); runQueued(f);
+            assertTrue(actor.books.size() >= 2);
+            var previous = PartyBookNativeTest.button(actor, "[Previous pages]");
+            PartyBookNativeTest.click(f, actor, previous); drainReads(f); runQueued(f);
+            assertEquals(3, actor.books.size());
+            PartyBookNativeTest.click(f, actor, previous);
+            assertEquals(3, actor.books.size(), "Replayed nonce cannot reopen a volume");
+        }
+        var records = new java.util.ArrayList<com.google.gson.JsonObject>();
+        try (var files = Files.walk(data.resolve("events"))) {
+            for (var path : files.filter(p -> p.getFileName().toString().endsWith(".jsonl")).toList())
+                for (var line : Files.readAllLines(path))
+                    if (!line.isBlank()) records.add(com.google.gson.JsonParser.parseString(line).getAsJsonObject());
+        }
+        var opened = records.stream().filter(e -> e.get("type").getAsString().endsWith("character_book.opened"))
+            .map(e -> e.get("id").getAsString()).distinct().toList();
+        assertEquals(1, opened.size());
+        var navigations = records.stream().filter(e -> e.get("type").getAsString().endsWith("character_book.navigated"))
+            .collect(java.util.stream.Collectors.toMap(e -> e.get("id").getAsString(), e -> e,
+                (first, duplicate) -> first, java.util.LinkedHashMap::new));
+        assertEquals(2, navigations.size());
+        var previous = navigations.values().stream().map(e -> e.getAsJsonObject("data"))
+            .filter(d -> d.get("volume_direction").getAsString().equals("previous")).findFirst().orElseThrow();
+        assertEquals("30", previous.get("source_volume_start").getAsString());
+        assertEquals("0", previous.get("destination_volume_start").getAsString());
+        assertEquals("overview", previous.get("destination_section").getAsString());
+        assertTrue(records.stream().anyMatch(e -> e.get("type").getAsString().endsWith("action.resolved")
+            && e.getAsJsonObject("data").has("reason")
+            && e.getAsJsonObject("data").get("reason").getAsString().equals("stale_or_forged_payload")));
+    }
+
     @Test void largeRecordsRemainCompleteThroughBoundedSingleUseNavigation() throws Exception {
         int expectedNavigations;
         try (var f = new FantasyStickLifecycleNativeTest.Fixture(data)) {
@@ -279,6 +325,16 @@ class CharacterBookNativeTest {
             assertArrayEquals(bytes, Files.readAllBytes(data.resolve("characters").resolve(saved.id() + ".yml")));
         }
         var events=new java.util.ArrayList<com.google.gson.JsonObject>();try(var files=Files.walk(data.resolve("events"))){for(var file:files.filter(path->path.getFileName().toString().endsWith(".jsonl")).toList())for(var line:Files.readAllLines(file))if(!line.isBlank())events.add(com.google.gson.JsonParser.parseString(line).getAsJsonObject());}assertEquals(expectedNavigations,events.stream().filter(event->event.get("type").getAsString().endsWith("character_book.navigated")).count());assertEquals(expectedNavigations,events.stream().filter(event->event.get("type").getAsString().endsWith("character_book.navigated")&&event.getAsJsonObject("data").get("native_open").getAsString().equals("acknowledged")&&event.getAsJsonObject("data").get("offset").getAsInt()>0).count());
+        var navigation=events.stream().filter(event->event.get("type").getAsString().endsWith("character_book.navigated"))
+            .findFirst().orElseThrow().getAsJsonObject("data");
+        assertEquals("0",navigation.get("source_volume_start").getAsString());
+        assertEquals("30",navigation.get("destination_volume_start").getAsString());
+        assertEquals("next",navigation.get("volume_direction").getAsString());
+        assertTrue(navigation.get("source_navigation_page").getAsInt()>0);
+        assertEquals("1",navigation.get("destination_page").getAsString());
+        assertEquals("volume_start",navigation.get("destination_section").getAsString());
+        assertFalse(navigation.has("ability_id"));assertFalse(navigation.has("passive_id"));
+        assertTrue(navigation.has("location"));
     }
 
     @Test void acknowledgedRenameTransferAndReloadInspectTheCurrentRecordWithoutCarryingTheFormerHoldersView() throws Exception {

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

@@ -0,0 +1,391 @@
+package games.dmg.fantasystick;
+
+import static org.junit.jupiter.api.Assertions.*;
+import static org.mockito.Mockito.*;
+
+import com.google.gson.JsonObject;
+import com.google.gson.JsonParser;
+import games.dmg.fantasystick.items.CharacterSheets;
+import games.dmg.fantasystick.persistence.YamlCharacterRepository;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.UUID;
+import java.util.concurrent.TimeUnit;
+import org.bukkit.Location;
+import org.bukkit.craftbukkit.CraftWorld;
+import org.bukkit.event.inventory.ClickType;
+import org.bukkit.event.inventory.CraftItemEvent;
+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 CharacterIdentityEventsNativeTest {
+    @TempDir Path data;
+    @BeforeAll static void bootstrap() throws Exception { NativeRuntime.bootstrap(); }
+
+    @Test void registeredManualCraftOnlyPublishesAnAcknowledgedDeliveredCharacter() throws Exception {
+        try (var fixture = new FantasyStickLifecycleNativeTest.Fixture(data)) {
+            fixture.plugin.setEnabled(true);
+            var actor = new ManualCraftingControllerNativeTest.Actor(2, 2);
+            var world = mock(CraftWorld.class);
+            when(world.getUID()).thenReturn(UUID.randomUUID());
+            when(world.getName()).thenReturn("world");
+            actor.eyeLocation = new Location(world, 12, 70, 31);
+            var preview = fixture.recipes.get(CharacterSheets.RECIPE);
+            var event = new CraftItemEvent(preview, actor.fixture.view, InventoryType.SlotType.RESULT, 0,
+                ClickType.LEFT, InventoryAction.PICKUP_ALL);
+            fixture.dispatcher.accept(event);
+            assertTrue(event.isCancelled());
+            var complete = fixture.tasks.poll(5, TimeUnit.SECONDS);
+            assertNotNull(complete);
+            complete.run();
+            var id = new CharacterSheets().identify(actor.fixture.view.getCursor()).orElseThrow();
+            var saved = new YamlCharacterRepository(data).load(id).orElseThrow();
+            complete.run(); // A repeated completion cannot create or deliver a second logical success.
+            for (int i = 0; i < 100 && records().stream().noneMatch(entry -> entry.get("type").getAsString()
+                    .endsWith("character.created")); i++) Thread.sleep(10);
+            fixture.plugin.setEnabled(false);
+            var created = records().stream().filter(entry -> entry.get("type").getAsString()
+                .endsWith("character.created")).filter(entry -> entry.getAsJsonObject("data")
+                .get("character_id").getAsString().equals(id.toString())).toList();
+            assertEquals(1, created.stream().map(entry -> entry.get("id").getAsString()).distinct().count());
+            var values = created.getFirst().getAsJsonObject("data");
+            assertEquals(saved.revision().toString(), values.get("revision").getAsString());
+            assertEquals("fantasystick:character_sheet", values.get("recipe_id").getAsString());
+            assertEquals("cursor", values.get("delivery_route").getAsString());
+            assertEquals(actor.id.toString(), values.get("holder_player_id").getAsString());
+            assertEquals("no_active_session", values.get("holder_session_status").getAsString());
+            assertFalse(values.has("holder_session_id"));
+            assertEquals(world.getUID().toString(), values.getAsJsonObject("location").get("world_id").getAsString());
+        }
+    }
+
+    @Test void priorCancellationAndStaleCraftDoNotInventCreation() throws Exception {
+        try (var fixture = new FantasyStickLifecycleNativeTest.Fixture(data)) {
+            fixture.plugin.setEnabled(true);
+            var actor = new ManualCraftingControllerNativeTest.Actor(2, 2);
+            var recipe = fixture.recipes.get(CharacterSheets.RECIPE);
+            var cancelled = new CraftItemEvent(recipe, actor.fixture.view, InventoryType.SlotType.RESULT, 0,
+                ClickType.LEFT, InventoryAction.PICKUP_ALL);
+            cancelled.setCancelled(true);
+            fixture.dispatcher.accept(cancelled);
+            assertTrue(fixture.tasks.isEmpty());
+            var stale = new CraftItemEvent(recipe, actor.fixture.view, InventoryType.SlotType.RESULT, 0,
+                ClickType.LEFT, InventoryAction.PICKUP_ALL);
+            fixture.dispatcher.accept(stale);
+            assertTrue(stale.isCancelled());
+            var complete = fixture.tasks.poll(5, TimeUnit.SECONDS); assertNotNull(complete);
+            actor.fixture.grid.getMatrix()[0].setAmount(7);
+            complete.run();
+            assertTrue(actor.fixture.view.getCursor().isEmpty());
+            fixture.plugin.setEnabled(false);
+            var entries = records();
+            assertTrue(entries.stream().noneMatch(entry -> entry.get("type").getAsString().endsWith("character.created")));
+            var resolutions = entries.stream().filter(entry -> entry.get("type").getAsString().endsWith("action.resolved"))
+                .map(entry -> entry.getAsJsonObject("data"))
+                .filter(details -> details.has("action_kind")
+                    && details.get("action_kind").getAsString().equals("character_craft")).toList();
+            assertTrue(resolutions.stream().anyMatch(details -> details.get("outcome").getAsString().equals("cancelled")));
+            assertTrue(resolutions.stream().anyMatch(details -> details.get("outcome").getAsString().equals("stale")));
+        }
+    }
+
+    @Test void failedNativeCraftSaveNeverReportsCreatedOrDeliversASheet() throws Exception {
+        try (var fixture = new FantasyStickLifecycleNativeTest.Fixture(data)) {
+            fixture.plugin.setEnabled(true);
+            var actor = new ManualCraftingControllerNativeTest.Actor(2, 2);
+            var before = actor.fixture.grid.getMatrix()[0].getAmount();
+            var event = new CraftItemEvent(fixture.recipes.get(CharacterSheets.RECIPE), actor.fixture.view,
+                InventoryType.SlotType.RESULT, 0, ClickType.LEFT, InventoryAction.PICKUP_ALL);
+            Files.createDirectories(data.resolve("characters"));
+            if (!Files.exists(data.resolve("characters/.records.lock"))) Files.createFile(data.resolve("characters/.records.lock"));
+            try (var channel = java.nio.channels.FileChannel.open(data.resolve("characters/.records.lock"),
+                     java.nio.file.StandardOpenOption.WRITE); var lock = channel.lock()) {
+                assertTrue(lock.isValid());
+                fixture.dispatcher.accept(event);
+                var complete = fixture.tasks.poll(5, TimeUnit.SECONDS); assertNotNull(complete);
+                complete.run();
+            }
+            assertTrue(event.isCancelled());
+            assertTrue(actor.fixture.view.getCursor().isEmpty());
+            assertEquals(before, actor.fixture.grid.getMatrix()[0].getAmount());
+            fixture.plugin.setEnabled(false);
+            var entries = records();
+            assertTrue(entries.stream().noneMatch(entry -> entry.get("type").getAsString().endsWith("character.created")));
+            assertTrue(entries.stream().filter(entry -> entry.get("type").getAsString().endsWith("action.resolved"))
+                .map(entry -> entry.getAsJsonObject("data"))
+                .anyMatch(values -> values.has("action_kind") && values.get("action_kind").getAsString()
+                    .equals("character_craft") && values.get("reason").getAsString().equals("save")));
+        }
+    }
+
+    @Test void cancelledNativeDropSpawnRemainsUnconfirmedWithoutClaimingACreatedSheet() throws Exception {
+        try (var fixture = new FantasyStickLifecycleNativeTest.Fixture(data)) {
+            fixture.plugin.setEnabled(true);
+            var actor = new ManualCraftingControllerNativeTest.Actor(2, 2);
+            var world = new PlayerSheetDropsNativeTest.WorldFixture();
+            actor.eyeLocation = new Location(world.world, 3, 72, 8);
+            world.onSpawn = spawn -> spawn.setCancelled(true);
+            var before = actor.fixture.grid.getMatrix()[0].getAmount();
+            var event = new CraftItemEvent(fixture.recipes.get(CharacterSheets.RECIPE), actor.fixture.view,
+                InventoryType.SlotType.RESULT, 0, ClickType.DROP, InventoryAction.DROP_ONE_SLOT);
+            fixture.dispatcher.accept(event);
+            var complete = fixture.tasks.poll(5, TimeUnit.SECONDS); assertNotNull(complete); complete.run();
+            assertEquals(1, world.spawnCalls);
+            assertEquals(before, actor.fixture.grid.getMatrix()[0].getAmount());
+            assertTrue(actor.fixture.view.getCursor().isEmpty());
+            fixture.plugin.setEnabled(false);
+            var entries = records();
+            assertTrue(entries.stream().noneMatch(entry -> entry.get("type").getAsString()
+                .endsWith("character.created")), "Unconfirmed spawn is not a delivered sheet");
+            assertTrue(entries.stream().filter(entry -> entry.get("type").getAsString().endsWith("action.resolved"))
+                .map(entry -> entry.getAsJsonObject("data"))
+                .anyMatch(value -> value.has("action_kind") && value.get("action_kind").getAsString()
+                    .equals("character_craft") && value.get("reason").getAsString().equals("drop_unconfirmed")
+                    && value.get("outcome").getAsString().equals("uncertain")));
+        }
+    }
+
+    @Test void registeredNativeAnvilPublishesOnlyItsAcknowledgedUnicodeRename() throws Exception {
+        try (var fixture = new FantasyStickLifecycleNativeTest.Fixture(data)) {
+            fixture.plugin.setEnabled(true);
+            var original = new games.dmg.fantasystick.crafting.CharacterFactory()
+                .create(games.dmg.fantasystick.progression.ProgressionRules.defaults());
+            var repository = new YamlCharacterRepository(data);
+            repository.create(original);
+            var anvil = new CharacterAnvilNamesNativeTest.AnvilFixture();
+            var world = mock(CraftWorld.class);
+            when(world.getUID()).thenReturn(UUID.randomUUID());
+            when(world.getName()).thenReturn("world");
+            anvil.actor.eyeLocation = new Location(world, 4, 64, 9);
+            var sheet = new CharacterSheets().create(original);
+            var output = CharacterAnvilNamesNativeTest.named(sheet,
+                net.kyori.adventure.text.Component.text("雪 🐉 <literal>"));
+            anvil.grid.setItem(0, sheet);
+            anvil.grid.setItem(2, output);
+            var event = new org.purpurmc.purpur.event.inventory.AnvilTakeResultEvent(anvil.actor.player, anvil.view, output);
+            fixture.dispatcher.accept(event);
+            fixture.dispatcher.accept(event);
+            var deadline = System.nanoTime() + TimeUnit.SECONDS.toNanos(5);
+            while (repository.load(original.id()).orElseThrow().revision().equals(original.revision())
+                    && System.nanoTime() < deadline) Thread.sleep(5);
+            var saved = repository.load(original.id()).orElseThrow();
+            assertEquals("雪 🐉 <literal>", saved.name());
+            for (int i = 0; i < 100 && records().stream().noneMatch(entry -> entry.get("type").getAsString()
+                    .endsWith("character.renamed")); i++) Thread.sleep(10);
+            fixture.plugin.setEnabled(false);
+            var renamed = records().stream().filter(entry -> entry.get("type").getAsString()
+                .endsWith("character.renamed")).toList();
+            assertEquals(1, renamed.stream().map(entry -> entry.get("id").getAsString()).distinct().count());
+            var values = renamed.getFirst().getAsJsonObject("data");
+            assertEquals(original.name(), values.get("before_name").getAsString());
+            assertEquals(saved.name(), values.get("after_name").getAsString());
+            assertEquals(original.revision().toString(), values.get("revision_before").getAsString());
+            assertEquals(saved.revision().toString(), values.get("revision_after").getAsString());
+            assertEquals(saved.sheetGeneration().toString(), values.get("generation").getAsString());
+            assertEquals("unverified", values.get("native_item_outcome").getAsString());
+            assertEquals(anvil.actor.id.toString(), values.get("holder_player_id").getAsString());
+            assertEquals("no_active_session", values.get("holder_session_status").getAsString());
+            assertEquals(world.getUID().toString(), values.getAsJsonObject("location").get("world_id").getAsString());
+        }
+    }
+
+    @Test void acknowledgedCraftAndRenameReplayOriginalEventsAfterWriterOutage() throws Exception {
+        try (var fixture = new FantasyStickLifecycleNativeTest.Fixture(data)) {
+            fixture.plugin.setEnabled(true);
+            var actor = new ManualCraftingControllerNativeTest.Actor(2, 2);
+            ((games.dmg.fantasystick.events.LocalEventLog)
+                FantasyStickLifecycleNativeTest.Fixture.field(fixture.plugin, "eventLog")).close();
+            var event = new CraftItemEvent(fixture.recipes.get(CharacterSheets.RECIPE), actor.fixture.view,
+                InventoryType.SlotType.RESULT, 0, ClickType.LEFT, InventoryAction.PICKUP_ALL);
+            fixture.dispatcher.accept(event);
+            var complete = fixture.tasks.poll(5, TimeUnit.SECONDS); assertNotNull(complete); complete.run();
+            var id = new CharacterSheets().identify(actor.fixture.view.getCursor()).orElseThrow();
+            var saved = new YamlCharacterRepository(data).load(id).orElseThrow();
+            var anvil = new CharacterAnvilNamesNativeTest.AnvilFixture();
+            var sheet = new CharacterSheets().create(saved);
+            var result = CharacterAnvilNamesNativeTest.named(sheet,
+                net.kyori.adventure.text.Component.text("Archived 雪 🐉"));
+            anvil.grid.setItem(0, sheet); anvil.grid.setItem(2, result);
+            fixture.dispatcher.accept(new org.purpurmc.purpur.event.inventory.AnvilTakeResultEvent(
+                anvil.actor.player, anvil.view, result));
+            var deadline = System.nanoTime() + TimeUnit.SECONDS.toNanos(5);
+            while (new YamlCharacterRepository(data).load(id).orElseThrow().name().equals(saved.name())
+                    && System.nanoTime() < deadline) Thread.sleep(5);
+            assertEquals("Archived 雪 🐉", new YamlCharacterRepository(data).load(id).orElseThrow().name());
+            fixture.plugin.setEnabled(false);
+            fixture.awaitWorkers();
+            java.util.Set<String> pendingIds;
+            try (var files = Files.list(data.resolve("character-identity-event-intents"))) {
+                pendingIds = files.filter(path -> path.getFileName().toString().endsWith(".pending"))
+                    .map(path -> path.getFileName().toString().replace(".pending", ""))
+                    .collect(java.util.stream.Collectors.toSet());
+            }
+            assertEquals(2, pendingIds.size(), "Each acknowledged mutation has independent recoverable intent");
+            fixture.plugin.setEnabled(true);
+            for (int i = 0; i < 100 && records().stream().noneMatch(entry -> entry.get("type").getAsString()
+                    .endsWith("character.renamed")); i++) Thread.sleep(10);
+            fixture.plugin.setEnabled(false);
+            var domain = records().stream().filter(entry -> entry.get("type").getAsString()
+                .endsWith("character.created") || entry.get("type").getAsString().endsWith("character.renamed")).toList();
+            assertEquals(pendingIds, domain.stream().map(entry -> entry.get("id").getAsString())
+                .collect(java.util.stream.Collectors.toSet()), "Recovery keeps the original accepted event IDs");
+            assertEquals(id.toString(), domain.stream().filter(entry -> entry.get("type").getAsString()
+                .endsWith("character.created")).findFirst().orElseThrow().getAsJsonObject("data")
+                .get("character_id").getAsString());
+        }
+    }
+
+    @Test void distinctNativeHolderActivationObservesOnlyProvenCharacterTransfer() throws Exception {
+        try (var fixture = new FantasyStickLifecycleNativeTest.Fixture(data)) {
+            fixture.plugin.setEnabled(true);
+            var first = new FantasyStickLifecycleNativeTest.Actor(data);
+            var second = new FantasyStickLifecycleNativeTest.Actor(data);
+            fixture.players.put(first.core.id, first.player);
+            fixture.players.put(second.core.id, second.player);
+            var world = mock(CraftWorld.class);
+            when(world.getUID()).thenReturn(UUID.randomUUID());
+            when(world.getName()).thenReturn("other-world");
+            second.core.location.setWorld(world);
+            fixture.activate(first);
+            var firstSession = ((games.dmg.fantasystick.session.EquipmentSessions)
+                FantasyStickLifecycleNativeTest.Fixture.field(fixture.plugin, "sessions"))
+                .active(first.core.id).orElseThrow().session();
+            var sheet = first.core.inventory.getItemInOffHand().clone();
+            ((games.dmg.fantasystick.session.EquipmentSessions)
+                FantasyStickLifecycleNativeTest.Fixture.field(fixture.plugin, "sessions")).exit(first.player);
+            fixture.awaitCharacterAndReceipt(first);
+            first.core.inventory.setItemInOffHand(null);
+            second.core.inventory.setItemInOffHand(sheet);
+            fixture.activate(second);
+            var sessions = (games.dmg.fantasystick.session.EquipmentSessions)
+                FantasyStickLifecycleNativeTest.Fixture.field(fixture.plugin, "sessions");
+            var secondSession = sessions.active(second.core.id).orElseThrow().session();
+            assertEquals(first.core.record.id(), sessions.active(second.core.id).orElseThrow().character());
+            sessions.exit(second.player);
+            fixture.awaitCharacterAndReceipt(second);
+            fixture.reenter(second);
+            assertEquals(first.core.record.id(), sessions.active(second.core.id).orElseThrow().character());
+            fixture.plugin.setEnabled(false);
+            var transfers = records().stream().filter(entry -> entry.get("type").getAsString()
+                .endsWith("character.transfer_observed")).toList();
+            assertEquals(1, transfers.stream().map(entry -> entry.get("id").getAsString()).distinct().count());
+            var values = transfers.getFirst().getAsJsonObject("data");
+            assertEquals(first.core.id.toString(), values.get("from_player_id").getAsString());
+            assertEquals(second.core.id.toString(), values.get("to_player_id").getAsString());
+            assertEquals(firstSession.toString(), values.get("from_session_id").getAsString());
+            assertEquals(secondSession.toString(), values.get("to_session_id").getAsString());
+            assertEquals("activation_after_prior_holder", values.get("custody_quality").getAsString());
+            assertEquals(first.world.getUID().toString(), values.getAsJsonObject("from_location")
+                .get("world_id").getAsString());
+            assertEquals("cached_at_previous_activation", values.getAsJsonObject("from_location")
+                .get("quality").getAsString());
+            assertEquals(world.getUID().toString(), values.getAsJsonObject("to_location")
+                .get("world_id").getAsString());
+            assertEquals(world.getUID().toString(), values.getAsJsonObject("location").get("world_id").getAsString());
+        }
+    }
+
+    @Test void firstActivationAfterRestartDoesNotInventUnseenSheetTransfer() throws Exception {
+        org.bukkit.inventory.ItemStack transferred;
+        try (var firstBoot = new FantasyStickLifecycleNativeTest.Fixture(data)) {
+            firstBoot.plugin.setEnabled(true);
+            var owner = new FantasyStickLifecycleNativeTest.Actor(data);
+            firstBoot.players.put(owner.core.id, owner.player);
+            firstBoot.activate(owner);
+            transferred = owner.core.inventory.getItemInOffHand().clone();
+            ((games.dmg.fantasystick.session.EquipmentSessions)
+                FantasyStickLifecycleNativeTest.Fixture.field(firstBoot.plugin, "sessions")).exit(owner.player);
+            firstBoot.awaitCharacterAndReceipt(owner);
+            firstBoot.plugin.setEnabled(false);
+        }
+        try (var secondBoot = new FantasyStickLifecycleNativeTest.Fixture(data)) {
+            secondBoot.plugin.setEnabled(true);
+            var newHolder = new FantasyStickLifecycleNativeTest.Actor(data);
+            secondBoot.players.put(newHolder.core.id, newHolder.player);
+            newHolder.core.inventory.setItemInOffHand(transferred);
+            secondBoot.activate(newHolder);
+            secondBoot.plugin.setEnabled(false);
+        }
+        assertTrue(records().stream().noneMatch(entry -> entry.get("type").getAsString()
+            .endsWith("character.transfer_observed")), "Offline custody was not seen by this plugin lifetime");
+    }
+
+    @Test void staleGenerationAndSaveFailureResolveAnvilAttemptsWithoutRenameSuccess() throws Exception {
+        try (var fixture = new FantasyStickLifecycleNativeTest.Fixture(data)) {
+            fixture.plugin.setEnabled(true);
+            var repository = new YamlCharacterRepository(data);
+            var original = new games.dmg.fantasystick.crafting.CharacterFactory()
+                .create(games.dmg.fantasystick.progression.ProgressionRules.defaults());
+            repository.create(original);
+            var storage = (games.dmg.fantasystick.persistence.CharacterStorage)
+                FantasyStickLifecycleNativeTest.Fixture.field(fixture.plugin, "characters");
+            var operation = UUID.randomUUID();
+            storage.beginRecovery(new games.dmg.fantasystick.persistence.CharacterStorage.RecoveryRequest(
+                operation, original.id(), UUID.randomUUID(), UUID.randomUUID(), original.revision(),
+                original.sheetGeneration(), false, null, java.math.BigDecimal.valueOf(20))).join();
+            storage.completeRecovery(original.id(), operation).join();
+            var anvil = new CharacterAnvilNamesNativeTest.AnvilFixture();
+            var stale = new CharacterSheets().create(original);
+            anvil.grid.setItem(0, stale);
+            var result = CharacterAnvilNamesNativeTest.named(stale,
+                net.kyori.adventure.text.Component.text("forged revision 雪"));
+            anvil.grid.setItem(2, result);
+            fixture.dispatcher.accept(new org.purpurmc.purpur.event.inventory.AnvilTakeResultEvent(
+                anvil.actor.player, anvil.view, result));
+            storage.find(original.id()).join();
+
+            var second = new games.dmg.fantasystick.crafting.CharacterFactory()
+                .create(games.dmg.fantasystick.progression.ProgressionRules.defaults());
+            repository.create(second);
+            var live = new CharacterSheets().create(second);
+            anvil.grid.setItem(0, live);
+            var attempted = CharacterAnvilNamesNativeTest.named(live,
+                net.kyori.adventure.text.Component.text("not persisted"));
+            anvil.grid.setItem(2, attempted);
+            try (var channel = java.nio.channels.FileChannel.open(data.resolve("characters/.records.lock"),
+                     java.nio.file.StandardOpenOption.WRITE); var lock = channel.lock()) {
+                assertTrue(lock.isValid());
+                fixture.dispatcher.accept(new org.purpurmc.purpur.event.inventory.AnvilTakeResultEvent(
+                    anvil.actor.player, anvil.view, attempted));
+                storage.find(second.id()).handle((ignored, failure) -> null).join();
+            }
+            for (int i = 0; i < 100 && records().stream().filter(entry -> entry.get("type").getAsString()
+                    .endsWith("action.resolved")).count() < 2; i++) Thread.sleep(10);
+            fixture.plugin.setEnabled(false);
+            assertEquals(second.name(), repository.load(second.id()).orElseThrow().name());
+            var entries = records();
+            assertTrue(entries.stream().noneMatch(entry -> entry.get("type").getAsString()
+                .endsWith("character.renamed")));
+            var resolved = entries.stream().filter(entry -> entry.get("type").getAsString()
+                .endsWith("action.resolved")).map(entry -> entry.getAsJsonObject("data"))
+                .filter(value -> value.has("action_kind") && value.get("action_kind").getAsString()
+                    .equals("character_rename")).toList();
+            assertTrue(resolved.stream().anyMatch(value -> value.get("reason").getAsString().equals("stale_generation")));
+            assertTrue(resolved.stream().anyMatch(value -> value.get("reason").getAsString().equals("save_failed")));
+        }
+    }
+
+    private List<JsonObject> records() throws Exception {
+        var results = new ArrayList<JsonObject>();
+        try (var dates = Files.list(data.resolve("events"))) {
+            for (var date : dates.filter(path -> path.getFileName().toString().matches("[0-9]{4}-[0-9]{2}-[0-9]{2}"))
+                    .toList()) {
+                try (var files = Files.list(date)) {
+                    for (var file : files.filter(path -> path.getFileName().toString().endsWith(".jsonl")).toList()) {
+                        var content = Files.readString(file);
+                        var complete = content.lastIndexOf('\n');
+                        if (complete < 0) continue;
+                        for (var line : content.substring(0, complete).lines().toList())
+                            if (!line.isBlank()) results.add(JsonParser.parseString(line).getAsJsonObject());
+                    }
+                }
+            }
+        }
+        return results;
+    }
+}

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

@@ -61,8 +61,12 @@ class DownedSessionNativeTest{
  }
  @Test void deathMenuAcceptanceFinalizesTheSameEpisodeAndDeliversOneTail()throws Exception{
   games.dmg.fantasystick.party.CharacterParty finalParty;
-  try(var f=new FantasyStickLifecycleNativeTest.Fixture(data)){f.plugin.setEnabled(true);var actor=new FantasyStickLifecycleNativeTest.Actor(data);f.players.put(actor.core.id,actor.player);org.mockito.Mockito.when(actor.world.getUID()).thenReturn(UUID.randomUUID());f.activate(actor);var persistentParties=PartyLifecycleNativeTest.directory(f);finalParty=persistentParties.create(actor.core.record.id(),"Finalists").join().party().orElseThrow();var retainedPhoenix=(games.dmg.fantasystick.shop.RareInventoryDirectory)FantasyStickLifecycleNativeTest.Fixture.field(f.plugin,"rareInventory");retainedPhoenix.add(actor.core.record.id(),games.dmg.fantasystick.shop.RareProduct.PHOENIX_DOWN,UUID.randomUUID()).join();actor.core.health=0;f.dispatcher.accept(death(actor));var directory=(games.dmg.fantasystick.session.DownedDirectory)FantasyStickLifecycleNativeTest.Fixture.field(f.plugin,"downed");for(int attempt=0;attempt<80&&(directory.all().isEmpty()||actor.inventories.isEmpty());attempt++){var task=f.tasks.poll(50,java.util.concurrent.TimeUnit.MILLISECONDS);if(task!=null)task.run();Thread.sleep(5);}var episode=directory.all().getFirst();assertEquals(finalParty.id(),persistentParties.partyOf(actor.core.record.id()).orElseThrow().id());var menu=actor.inventories.getLast();assertTrue(plain(menu.getItem(11)).contains("Accept Death"));assertTrue(plain(menu.getItem(13)).contains("Phoenix Down"));assertTrue(plain(menu.getItem(15)).contains("Wait for Revive"));var view=org.mockito.Mockito.mock(org.bukkit.inventory.InventoryView.class);org.mockito.Mockito.when(view.getTopInventory()).thenReturn(menu);var click=org.mockito.Mockito.mock(org.bukkit.event.inventory.InventoryClickEvent.class);org.mockito.Mockito.when(click.getView()).thenReturn(view);org.mockito.Mockito.when(click.getWhoClicked()).thenReturn(actor.player);org.mockito.Mockito.when(click.getRawSlot()).thenReturn(11);var controller=(games.dmg.fantasystick.session.DownedController)FantasyStickLifecycleNativeTest.Fixture.field(f.plugin,"downedController");controller.click(click);controller.click(click);for(int attempt=0;attempt<120&&!new games.dmg.fantasystick.persistence.YamlCharacterRepository(data).load(actor.core.record.id()).orElseThrow().dead();attempt++){var task=f.tasks.poll(50,java.util.concurrent.TimeUnit.MILLISECONDS);if(task!=null)task.run();Thread.sleep(5);}PartyLifecycleNativeTest.directory(f).defeat(UUID.randomUUID()).join();f.awaitCharacterAndReceipt(actor);PartyBookNativeTest.drain(f);var dead=new games.dmg.fantasystick.persistence.YamlCharacterRepository(data).load(actor.core.record.id()).orElseThrow();assertTrue(dead.dead());assertEquals(episode.id(),dead.deathId());assertEquals(games.dmg.fantasystick.session.DownedEpisode.Outcome.FINAL_DEATH,directory.find(dead.id()).join().orElseThrow().outcome());for(int attempt=0;attempt<80&&!directory.find(dead.id()).join().orElseThrow().published();attempt++){var task=f.tasks.poll(50,java.util.concurrent.TimeUnit.MILLISECONDS);if(task!=null)task.run();Thread.sleep(5);}assertTrue(directory.find(dead.id()).join().orElseThrow().published());assertEquals(org.bukkit.Material.WRITTEN_BOOK,actor.core.inventory.getItemInOffHand().getType());assertEquals(java.math.BigInteger.ONE,retainedPhoenix.quantity(actor.core.record.id(),games.dmg.fantasystick.shop.RareProduct.PHOENIX_DOWN));assertTrue(persistentParties.partyOf(actor.core.record.id()).isEmpty());}
-  var events=new java.util.ArrayList<com.google.gson.JsonObject>();try(var files=java.nio.file.Files.walk(data.resolve("events"))){for(var file:files.filter(path->path.getFileName().toString().endsWith(".jsonl")).toList())for(var line:java.nio.file.Files.readAllLines(file))if(!line.isBlank())events.add(com.google.gson.JsonParser.parseString(line).getAsJsonObject());}assertEquals(1,events.stream().filter(event->event.get("type").getAsString().contains(".party.")).count());var ended=events.stream().filter(event->event.get("type").getAsString().endsWith("party.disbanded")&&event.getAsJsonObject("data").has("reason")&&event.getAsJsonObject("data").get("reason").getAsString().equals("final_death")).toList();assertFalse(ended.isEmpty());assertEquals(1,ended.stream().map(event->event.get("id").getAsString()).distinct().count());assertEquals(finalParty.id().toString(),ended.getFirst().getAsJsonObject("data").get("party_id").getAsString());
+  games.dmg.fantasystick.events.SwitchDelayEventBridge switchAudit;
+  UUID exitedSession;
+  try(var f=new FantasyStickLifecycleNativeTest.Fixture(data)){f.plugin.setEnabled(true);switchAudit=(games.dmg.fantasystick.events.SwitchDelayEventBridge)FantasyStickLifecycleNativeTest.Fixture.field(f.plugin,"switchAuditEvents");var actor=new FantasyStickLifecycleNativeTest.Actor(data);f.players.put(actor.core.id,actor.player);org.mockito.Mockito.when(actor.world.getUID()).thenReturn(UUID.randomUUID());f.activate(actor);var persistentParties=PartyLifecycleNativeTest.directory(f);finalParty=persistentParties.create(actor.core.record.id(),"Finalists").join().party().orElseThrow();var retainedPhoenix=(games.dmg.fantasystick.shop.RareInventoryDirectory)FantasyStickLifecycleNativeTest.Fixture.field(f.plugin,"rareInventory");retainedPhoenix.add(actor.core.record.id(),games.dmg.fantasystick.shop.RareProduct.PHOENIX_DOWN,UUID.randomUUID()).join();actor.core.health=0;f.dispatcher.accept(death(actor));var directory=(games.dmg.fantasystick.session.DownedDirectory)FantasyStickLifecycleNativeTest.Fixture.field(f.plugin,"downed");for(int attempt=0;attempt<80&&(directory.all().isEmpty()||actor.inventories.isEmpty());attempt++){var task=f.tasks.poll(50,java.util.concurrent.TimeUnit.MILLISECONDS);if(task!=null)task.run();Thread.sleep(5);}var episode=directory.all().getFirst();exitedSession=episode.session();assertEquals(finalParty.id(),persistentParties.partyOf(actor.core.record.id()).orElseThrow().id());var menu=actor.inventories.getLast();assertTrue(plain(menu.getItem(11)).contains("Accept Death"));assertTrue(plain(menu.getItem(13)).contains("Phoenix Down"));assertTrue(plain(menu.getItem(15)).contains("Wait for Revive"));var view=org.mockito.Mockito.mock(org.bukkit.inventory.InventoryView.class);org.mockito.Mockito.when(view.getTopInventory()).thenReturn(menu);var click=org.mockito.Mockito.mock(org.bukkit.event.inventory.InventoryClickEvent.class);org.mockito.Mockito.when(click.getView()).thenReturn(view);org.mockito.Mockito.when(click.getWhoClicked()).thenReturn(actor.player);org.mockito.Mockito.when(click.getRawSlot()).thenReturn(11);var controller=(games.dmg.fantasystick.session.DownedController)FantasyStickLifecycleNativeTest.Fixture.field(f.plugin,"downedController");controller.click(click);controller.click(click);for(int attempt=0;attempt<120&&!new games.dmg.fantasystick.persistence.YamlCharacterRepository(data).load(actor.core.record.id()).orElseThrow().dead();attempt++){var task=f.tasks.poll(50,java.util.concurrent.TimeUnit.MILLISECONDS);if(task!=null)task.run();Thread.sleep(5);}PartyLifecycleNativeTest.directory(f).defeat(UUID.randomUUID()).join();f.awaitCharacterAndReceipt(actor);PartyBookNativeTest.drain(f);var dead=new games.dmg.fantasystick.persistence.YamlCharacterRepository(data).load(actor.core.record.id()).orElseThrow();assertTrue(dead.dead());assertEquals(episode.id(),dead.deathId());assertEquals(games.dmg.fantasystick.session.DownedEpisode.Outcome.FINAL_DEATH,directory.find(dead.id()).join().orElseThrow().outcome());for(int attempt=0;attempt<80&&!directory.find(dead.id()).join().orElseThrow().published();attempt++){var task=f.tasks.poll(50,java.util.concurrent.TimeUnit.MILLISECONDS);if(task!=null)task.run();Thread.sleep(5);}assertTrue(directory.find(dead.id()).join().orElseThrow().published());assertEquals(org.bukkit.Material.WRITTEN_BOOK,actor.core.inventory.getItemInOffHand().getType());assertEquals(java.math.BigInteger.ONE,retainedPhoenix.quantity(actor.core.record.id(),games.dmg.fantasystick.shop.RareProduct.PHOENIX_DOWN));assertTrue(persistentParties.partyOf(actor.core.record.id()).isEmpty());}
+  switchAudit.drained().toCompletableFuture().get(5,java.util.concurrent.TimeUnit.SECONDS);
+  try(var restarted=new FantasyStickLifecycleNativeTest.Fixture(data)){restarted.plugin.setEnabled(true);for(int i=0;i<100&&!java.nio.file.Files.exists(data.resolve("events"));i++)Thread.sleep(10);for(int i=0;i<100;i++){boolean found=false;try(var files=java.nio.file.Files.walk(data.resolve("events"))){for(var file:files.filter(path->path.getFileName().toString().endsWith(".jsonl")).toList())if(java.nio.file.Files.readString(file).contains("character.switch_delay_started")){found=true;break;}}if(found)break;Thread.sleep(10);}}
+  var events=new java.util.ArrayList<com.google.gson.JsonObject>();try(var files=java.nio.file.Files.walk(data.resolve("events"))){for(var file:files.filter(path->path.getFileName().toString().endsWith(".jsonl")).toList())for(var line:java.nio.file.Files.readAllLines(file))if(!line.isBlank())events.add(com.google.gson.JsonParser.parseString(line).getAsJsonObject());}var switchStarts=events.stream().filter(event->event.get("type").getAsString().endsWith("character.switch_delay_started")).filter(event->event.getAsJsonObject("data").get("session_id").getAsString().equals(exitedSession.toString())).toList();assertEquals(1,switchStarts.stream().map(event->event.get("id").getAsString()).distinct().count());assertEquals("defeat",switchStarts.getFirst().getAsJsonObject("data").get("exit_reason").getAsString());assertEquals(1,events.stream().filter(event->event.get("type").getAsString().contains(".party.")).count());var ended=events.stream().filter(event->event.get("type").getAsString().endsWith("party.disbanded")&&event.getAsJsonObject("data").has("reason")&&event.getAsJsonObject("data").get("reason").getAsString().equals("final_death")).toList();assertFalse(ended.isEmpty());assertEquals(1,ended.stream().map(event->event.get("id").getAsString()).distinct().count());assertEquals(finalParty.id().toString(),ended.getFirst().getAsJsonObject("data").get("party_id").getAsString());
  }
  @Test void explicitPhoenixDownChoiceConsumesOneAndRescuesTheExactDownedCharacter()throws Exception{
   try(var f=new FantasyStickLifecycleNativeTest.Fixture(data)){f.plugin.setEnabled(true);var actor=new FantasyStickLifecycleNativeTest.Actor(data);f.players.put(actor.core.id,actor.player);org.mockito.Mockito.when(actor.world.getUID()).thenReturn(UUID.randomUUID());f.activate(actor);var inventory=(games.dmg.fantasystick.shop.RareInventoryDirectory)FantasyStickLifecycleNativeTest.Fixture.field(f.plugin,"rareInventory");inventory.add(actor.core.record.id(),games.dmg.fantasystick.shop.RareProduct.PHOENIX_DOWN,UUID.randomUUID()).join();inventory.add(actor.core.record.id(),games.dmg.fantasystick.shop.RareProduct.PHOENIX_DOWN,UUID.randomUUID()).join();PartyBookNativeTest.open(f,actor);String inventoryText=PartyBookNativeTest.text(actor);assertTrue(inventoryText.contains("Phoenix Down: 2"),inventoryText);assertTrue(inventoryText.contains("Use Phoenix Down"),inventoryText);assertFalse(inventoryText.contains("[Use]"),inventoryText);actor.core.health=0;var death=death(actor);f.dispatcher.accept(death);var directory=(games.dmg.fantasystick.session.DownedDirectory)FantasyStickLifecycleNativeTest.Fixture.field(f.plugin,"downed");for(int attempt=0;attempt<80&&(directory.all().isEmpty()||actor.inventories.isEmpty());attempt++){var task=f.tasks.poll(50,java.util.concurrent.TimeUnit.MILLISECONDS);if(task!=null)task.run();Thread.sleep(5);}var episode=directory.all().getFirst();var menu=actor.inventories.getLast();assertEquals(org.bukkit.Material.FEATHER,menu.getItem(13).getType());assertTrue(plain(menu.getItem(13)).contains("Use Phoenix Down"));assertTrue(plain(menu.getItem(13)).contains("2"));var view=org.mockito.Mockito.mock(org.bukkit.inventory.InventoryView.class);org.mockito.Mockito.when(view.getTopInventory()).thenReturn(menu);var click=org.mockito.Mockito.mock(org.bukkit.event.inventory.InventoryClickEvent.class);org.mockito.Mockito.when(click.getView()).thenReturn(view);org.mockito.Mockito.when(click.getWhoClicked()).thenReturn(actor.player);org.mockito.Mockito.when(click.getRawSlot()).thenReturn(13);var controller=(games.dmg.fantasystick.session.DownedController)FantasyStickLifecycleNativeTest.Fixture.field(f.plugin,"downedController");controller.click(click);controller.click(click);for(int attempt=0;attempt<160&&(!directory.find(actor.core.record.id()).join().orElseThrow().published()||inventory.quantity(actor.core.record.id(),games.dmg.fantasystick.shop.RareProduct.PHOENIX_DOWN).compareTo(java.math.BigInteger.ONE)!=0||actor.player.getHealth()!=actor.maximumHealth.getValue());attempt++){var task=f.tasks.poll(50,java.util.concurrent.TimeUnit.MILLISECONDS);if(task!=null)task.run();Thread.sleep(5);}var resolved=directory.find(actor.core.record.id()).join().orElseThrow();assertEquals(games.dmg.fantasystick.session.DownedEpisode.Outcome.REVIVED,resolved.outcome());assertEquals("phoenix_down",resolved.decision().source());assertEquals(episode.id(),resolved.id());assertEquals(java.math.BigInteger.ONE,inventory.quantity(actor.core.record.id(),games.dmg.fantasystick.shop.RareProduct.PHOENIX_DOWN));assertEquals(actor.maximumHealth.getValue(),actor.player.getHealth());assertTrue(((games.dmg.fantasystick.session.EquipmentSessions)FantasyStickLifecycleNativeTest.Fixture.field(f.plugin,"sessions")).downedProtected(actor.core.id));assertFalse(new games.dmg.fantasystick.persistence.YamlCharacterRepository(data).load(actor.core.record.id()).orElseThrow().dead());assertNotEquals(org.bukkit.Material.WRITTEN_BOOK,actor.core.inventory.getItemInOffHand().getType());var protectedDamage=org.mockito.Mockito.mock(org.bukkit.event.entity.EntityDamageEvent.class);org.mockito.Mockito.when(protectedDamage.getEntity()).thenReturn(actor.player);org.mockito.Mockito.when(protectedDamage.getFinalDamage()).thenReturn(3d);controller.damage(protectedDamage);org.mockito.Mockito.verify(protectedDamage).setCancelled(true);f.plugin.setEnabled(false);var events=new java.util.ArrayList<com.google.gson.JsonObject>();try(var files=java.nio.file.Files.walk(data.resolve("events"))){for(var file:files.filter(path->path.getFileName().toString().endsWith(".jsonl")).toList())for(var line:java.nio.file.Files.readAllLines(file))if(!line.isBlank())events.add(com.google.gson.JsonParser.parseString(line).getAsJsonObject());}var phoenixEvents=events.stream().filter(event->event.get("type").getAsString().endsWith("character.downed_resolved")&&event.getAsJsonObject("data").get("outcome").getAsString().equals("phoenix_down")).toList();assertFalse(phoenixEvents.isEmpty());assertEquals(1,phoenixEvents.stream().map(event->event.get("id").getAsString()).distinct().count());var phoenixData=phoenixEvents.getFirst().getAsJsonObject("data");assertEquals("downed_menu",phoenixData.get("selection_entry_point").getAsString());assertEquals("2",phoenixData.get("quantity_before").getAsString());assertEquals("1",phoenixData.get("quantity_after").getAsString());assertEquals("10.0",phoenixData.get("maximum_health").getAsString());assertTrue(events.stream().filter(event->event.get("type").getLine truncated

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

@@ -42,7 +42,9 @@ class FantasyFeedbackCommandNativeTest {
         assertEquals(2, records.stream().filter(e -> e.get("type").getAsString().endsWith("preference.read")
             && e.getAsJsonObject("data").get("preference_key").getAsString().equals("combat_feedback")).count());
         assertEquals(1, records.stream().filter(e -> e.get("type").getAsString().endsWith("preference.changed")
-            && e.getAsJsonObject("data").get("preference_key").getAsString().equals("combat_feedback")).count());
+            && e.getAsJsonObject("data").get("preference_key").getAsString().equals("combat_feedback"))
+            .map(e -> e.get("id").getAsString()).distinct().count(),
+            "At-least-once file export may repeat a line, not a logical preference change");
     }
 
     @Test void consoleMalformedAndExtraArgumentsCannotChangeAnAccountPreference() throws Exception {

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

@@ -149,8 +149,13 @@ class FantasyStickLifecycleNativeTest {
             assertTrue(records.contains("\"item_kind\":\"control\""));
             assertTrue(records.contains("\"control_kind\":\"book\""));
             assertTrue(records.contains("\"guard_reason\":\"protected_item\""));
-            assertEquals(1, records.split("games.dmg.minecraft.fantasystick.action.observed", -1).length - 1,
-                "The duplicate offhand callback must not create another logical observation");
+            assertEquals(1, records.lines().filter(line -> !line.isBlank())
+                .map(line -> com.google.gson.JsonParser.parseString(line).getAsJsonObject())
+                .filter(entry -> entry.get("type").getAsString().endsWith("action.observed"))
+                .map(entry -> entry.getAsJsonObject("data"))
+                .filter(details -> details.has("guard_reason")
+                    && details.get("guard_reason").getAsString().equals("protected_item"))
+                .count(), "The duplicate offhand callback must not create another logical observation");
         }
     }
 
@@ -431,6 +436,23 @@ class FantasyStickLifecycleNativeTest {
                 if (route >= 4) assertEquals(quantity, world.spawnCalls);
                 complete.run();
                 assertEquals(1, actor.syncs);
+                java.util.List<com.google.gson.JsonObject> created = java.util.List.of();
+                for (int attempt = 0; attempt < 100; attempt++) {
+                    created = localRecords(directory).stream().filter(entry -> entry.get("type").getAsString()
+                        .endsWith("character.created")).toList();
+                    if (created.size() == quantity) break;
+                    Thread.sleep(10);
+                }
+                assertEquals(quantity, created.stream().map(entry -> entry.get("id").getAsString()).distinct().count());
+                assertEquals(java.util.stream.IntStream.range(0, quantity).boxed().collect(java.util.stream.Collectors.toSet()),
+                    created.stream().map(entry -> entry.getAsJsonObject("data").get("index").getAsInt())
+                        .collect(java.util.stream.Collectors.toSet()));
+                assertEquals(1, created.stream().map(entry -> entry.getAsJsonObject("data").get("action_id").getAsString())
+                    .distinct().count(), "All outputs share their actual craft action");
+                assertEquals(new java.util.HashSet<>(ids), created.stream().map(entry ->
+                    java.util.UUID.fromString(entry.getAsJsonObject("data").get("character_id").getAsString()))
+                    .collect(java.util.stream.Collectors.toSet()));
+                assertTrue(created.stream().allMatch(entry -> entry.getAsJsonObject("data").get("quantity").getAsInt() == quantity));
             }
         }
     }
@@ -580,13 +602,17 @@ class FantasyStickLifecycleNativeTest {
 
     @Test void packagedRemovalSwapQuitAndDisableRestoreExactlyOnce() throws Exception {
         for (String route : List.of("removal", "swap", "quit", "disable")) {
+            java.util.UUID exitedSession;
+            games.dmg.fantasystick.events.SwitchDelayEventBridge audit;
             try (var f = new Fixture(data.resolve(route))) {
                 f.plugin.setEnabled(true);
                 var a = new Actor(data.resolve(route)); f.players.put(a.core.id, a.player);
                 var viewer = f.viewer(a, data.resolve(route)); f.activate(a);
+                audit = (games.dmg.fantasystick.events.SwitchDelayEventBridge) Fixture.field(f.plugin, "switchAuditEvents");
                 assertNativeName(f, a, viewer, a.core.record.name()); assertChat(f, a, a.core.record.name());
                 var receipts = f.receipts();
                 var session = receipts.find(a.core.id).toCompletableFuture().get(5, java.util.concurrent.TimeUnit.SECONDS).orElseThrow().pending();
+                exitedSession = session.sessionId();
                 var characters = (CharacterStorage) Fixture.field(f.plugin, "characters");
                 var worker = (java.util.concurrent.ExecutorService) Fixture.field(characters, "worker");
                 var entered = new java.util.concurrent.CountDownLatch(1);
@@ -643,9 +669,42 @@ class FantasyStickLifecycleNativeTest {
                     }
                 } finally { release.countDown(); }
             }
+            audit.drained().toCompletableFuture().get(5, java.util.concurrent.TimeUnit.SECONDS);
+            Path directory = data.resolve(route);
+            if (route.equals("disable")) {
+                var intent = directory.resolve("switch-event-intents").resolve(exitedSession + ".pending");
+                assertTrue(java.nio.file.Files.exists(intent), "Shutdown exit intent survives closed event writer");
+            }
+            try (var restarted = new Fixture(directory)) {
+                restarted.plugin.setEnabled(true);
+                for (int i = 0; i < 100 && localRecords(directory).stream()
+                        .noneMatch(entry -> entry.get("type").getAsString().endsWith("character.switch_delay_started")); i++)
+                    Thread.sleep(10);
+            }
+            var events = localRecords(directory);
+            var starts = events.stream().filter(entry -> entry.get("type").getAsString()
+                .endsWith("character.switch_delay_started"))
+                .filter(entry -> entry.getAsJsonObject("data").get("session_id").getAsString()
+                    .equals(exitedSession.toString())).toList();
+            assertEquals(1, starts.stream().map(entry -> entry.get("id").getAsString()).distinct().count(), route);
+            var start = starts.getFirst().getAsJsonObject("data");
+            assertEquals(route.equals("quit") ? "logout" : route.equals("disable") ? "shutdown" : "voluntary",
+                start.get("exit_reason").getAsString());
+            assertEquals("900", start.get("duration_seconds").getAsString());
+            assertEquals(starts.getFirst().get("time").getAsString(), start.get("exited_at").getAsString());
         }
     }
 
+    private static java.util.List<com.google.gson.JsonObject> localRecords(Path directory) throws IOException {
+        var events = new java.util.ArrayList<com.google.gson.JsonObject>();
+        try (var files = java.nio.file.Files.walk(directory.resolve("events"))) {
+            for (var path : files.filter(p -> p.getFileName().toString().endsWith(".jsonl")).toList())
+                for (var line : java.nio.file.Files.readAllLines(path))
+                    if (!line.isBlank()) events.add(com.google.gson.JsonParser.parseString(line).getAsJsonObject());
+        }
+        return events;
+    }
+
     @Test void packagedRefusalsExplainSpaceAndIneligibleEquipmentWithoutMutation() throws Exception {
         for (boolean full : new boolean[]{false, true}) try (var f = new Fixture(data.resolve("refusal-" + full))) {
             f.plugin.setEnabled(true);
@@ -1013,6 +1072,21 @@ class FantasyStickLifecycleNativeTest {
                     }
                 } finally { release.countDown(); }
             }
+            var records = new java.util.ArrayList<com.google.gson.JsonObject>();
+            try (var files = java.nio.file.Files.walk(directory.resolve("events"))) {
+                for (var path : files.filter(p -> p.getFileName().toString().endsWith(".jsonl")).toList())
+                    for (var line : java.nio.file.Files.readAllLines(path))
+                        if (!line.isBlank()) records.add(com.google.gson.JsonParser.parseString(line).getAsJsonObject());
+            }
+            var started = records.stream().filter(e -> e.get("type").getAsString().endsWith("character.switch_delay_started"))
+                .map(e -> e.getAsJsonObject("data")).findFirst().orElseThrow();
+            assertEquals(value.equals("default") ? "900" : value, started.get("duration_seconds").getAsString());
+            assertEquals("logout", started.get("exit_reason").getAsString());
+            assertEquals(value.equals("0"), started.get("zero_duration").getAsBoolean());
+            assertTrue(records.stream().anyMatch(e -> e.get("type").getAsString().endsWith("action.resolved")
+                && e.getAsJsonObject("data").has("action_kind")
+                && e.getAsJsonObject("data").get("action_kind").getAsString().equals("character_switch_preflight")
+                && e.getAsJsonObject("data").get("outcome").getAsString().equals(value.equals("0") ? "allowed" : "refused")));
         }
     }
 
@@ -1483,6 +1557,12 @@ class FantasyStickLifecycleNativeTest {
             try {
                 for (var worker : workers) assertTrue(worker.awaitTermination(5, java.util.concurrent.TimeUnit.SECONDS),
                     "Accepted persistence must drain before fixture disposal; production shutdown is nonblocking");
+                ((java.util.concurrent.CompletionStage<?>) field(plugin, "switchAuditDrain"))
+                    .toCompletableFuture().get(5, java.util.concurrent.TimeUnit.SECONDS);
+                ((java.util.concurrent.CompletionStage<?>) field(plugin, "identityAuditDrain"))
+                    .toCompletableFuture().get(5, java.util.concurrent.TimeUnit.SECONDS);
+            } catch (java.util.concurrent.ExecutionException | java.util.concurrent.TimeoutException failure) {
+                throw new IOException("Switch event intent worker did not drain before fixture disposal", failure);
             } catch (InterruptedException interrupted) { Thread.currentThread().interrupt(); throw new IOException(interrupted); }
         }
         @Override public void close() throws IOException {

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

@@ -438,6 +438,7 @@ class ManualCraftingControllerNativeTest {
                         case "getUniqueId" -> id;
                         case "getOpenInventory" -> current;
                         case "getEyeLocation" -> java.util.Objects.requireNonNull(eyeLocation).clone();
+                        case "getLocation" -> eyeLocation == null ? null : eyeLocation.clone();
                         case "isOnline" -> online;
                         case "updateInventory" -> { syncs++; onSync.run(); yield null; }
                         case "getName" -> "CraftingActor";

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

@@ -268,6 +268,7 @@ class PlayerSheetDropsNativeTest {
     static final class WorldFixture {
         final UUID playerId = UUID.randomUUID();
         final World world;
+        final UUID worldId = UUID.randomUUID();
         final Player player;
         final Item item;
         ItemStack stack;
@@ -307,6 +308,8 @@ class PlayerSheetDropsNativeTest {
                 default -> throw new AssertionError("Unexpected item call " + name);
             });
             world = proxy(World.class, (name, args) -> switch (name) {
+                case "getUID" -> worldId;
+                case "getName" -> "craft-world";
                 case "createEntity" -> {
                     creates++;
                     assertEquals(Item.class, args[1]);

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

@@ -48,7 +48,17 @@ class RecipeDiscoveryNativeTest {
             f.plugin.setEnabled(true);
             assertEquals(List.of(List.of(CharacterSheets.RECIPE)), online.recipeAwards);
             assertEquals(List.of(List.of(CharacterSheets.RECIPE)), joining.recipeAwards);
+            f.plugin.setEnabled(false);
         }
+        var discoveries = events(data).stream().filter(e -> e.get("type").getAsString().endsWith("recipe.discovered"))
+            .toList();
+        assertEquals(2, discoveries.size(), "One native first discovery per account; reload/join creates no duplicate");
+        assertEquals(java.util.Set.of("enable_online", "join"), discoveries.stream()
+            .map(e -> e.getAsJsonObject("data").get("trigger").getAsString())
+            .collect(java.util.stream.Collectors.toSet()));
+        assertTrue(discoveries.stream().allMatch(e -> e.getAsJsonObject("data").get("recipe_id")
+            .getAsString().equals("fantasystick:character_sheet")));
+        assertEquals(2, discoveries.stream().map(e -> e.get("id").getAsString()).distinct().count());
     }
 
     @Test void playerFailureIsLoggedIsolatedAndRetryableButRegistrationFailureAwardsNobody() throws Exception {
@@ -80,6 +90,13 @@ class RecipeDiscoveryNativeTest {
                 assertEquals(java.util.Set.of(CharacterSheets.RECIPE), failing.knownRecipes);
             } finally { f.plugin.getLogger().removeHandler(handler); }
         }
+        var first = events(data.resolve("player-failure"));
+        assertEquals(1, first.stream().filter(e -> e.get("type").getAsString().endsWith("action.resolved")
+            && e.getAsJsonObject("data").has("action_kind")
+            && e.getAsJsonObject("data").get("action_kind").getAsString().equals("recipe_discovery")
+            && e.getAsJsonObject("data").get("reason").getAsString().equals("native_failed")).count());
+        assertEquals(2, first.stream().filter(e -> e.get("type").getAsString().endsWith("recipe.discovered")).count(),
+            "Healthy and retried players each get one first-discovery acknowledgment");
         try (var f = new FantasyStickLifecycleNativeTest.Fixture(data.resolve("registration-failure"))) {
             var online = new FantasyStickLifecycleNativeTest.Actor(data.resolve("registration-failure"));
             f.players.put(online.core.id, online.player); f.failRegistrationAt = "recipe";
@@ -88,6 +105,68 @@ class RecipeDiscoveryNativeTest {
             assertTrue(online.recipeAwards.isEmpty());
             assertTrue(f.recipes.isEmpty());
         }
+        var registration = data.resolve("registration-failure").resolve("events");
+        if (java.nio.file.Files.isDirectory(registration))
+            assertEquals(0, events(data.resolve("registration-failure")).stream()
+                .filter(e -> e.get("type").getAsString().endsWith("recipe.discovered")).count());
+    }
+
+    @Test void nativeDiscoveryWithoutPostconditionReportsUnavailableAndRetriesWithoutInventingSuccess() throws Exception {
+        try (var f = new FantasyStickLifecycleNativeTest.Fixture(data)) {
+            f.plugin.setEnabled(true);
+            var player = new FantasyStickLifecycleNativeTest.Actor(data);
+            var unavailable = new AtomicBoolean(true);
+            doAnswer(call -> {
+                if (unavailable.getAndSet(false)) return 0;
+                var requested = ((java.util.Collection<?>) call.getArgument(0)).stream()
+                    .map(org.bukkit.NamespacedKey.class::cast).toList();
+                player.recipeAwards.add(requested); player.knownRecipes.addAll(requested); return requested.size();
+            }).when(player.player).discoverRecipes(anyCollection());
+            f.players.put(player.core.id, player.player);
+            f.dispatcher.accept(new PlayerJoinEvent(player.player, "unavailable"));
+            assertTrue(player.knownRecipes.isEmpty());
+            f.dispatcher.accept(new PlayerJoinEvent(player.player, "retry"));
+            assertEquals(java.util.Set.of(CharacterSheets.RECIPE), player.knownRecipes);
+            f.plugin.setEnabled(false);
+            var records = events(data);
+            assertEquals(1, records.stream().filter(e -> e.get("type").getAsString().endsWith("recipe.discovered")
+                && e.getAsJsonObject("data").get("player_id").getAsString().equals(player.core.id.toString())).count());
+            assertEquals(1, records.stream().filter(e -> e.get("type").getAsString().endsWith("action.resolved")
+                && e.getAsJsonObject("data").has("reason")
+                && e.getAsJsonObject("data").get("reason").getAsString().equals("native_unavailable")).count());
+        }
+    }
+
+    @Test void acknowledgedNativeDiscoveryRetainsStableIdentityThroughEventSinkOutage() throws Exception {
+        try (var f = new FantasyStickLifecycleNativeTest.Fixture(data)) {
+            f.plugin.setEnabled(true);
+            ((games.dmg.fantasystick.events.LocalEventLog)
+                FantasyStickLifecycleNativeTest.Fixture.field(f.plugin, "eventLog")).close();
+            var joining = new FantasyStickLifecycleNativeTest.Actor(data);
+            f.players.put(joining.core.id, joining.player);
+            f.dispatcher.accept(new PlayerJoinEvent(joining.player, "join"));
+            assertEquals(java.util.Set.of(CharacterSheets.RECIPE), joining.knownRecipes);
+            f.plugin.setEnabled(false);
+            f.plugin.setEnabled(true);
+            f.dispatcher.accept(new PlayerJoinEvent(joining.player, "already known"));
+            f.plugin.setEnabled(false);
+            var discoveries = events(data).stream().filter(e -> e.get("type").getAsString().endsWith("recipe.discovered")
+                && e.getAsJsonObject("data").get("player_id").getAsString().equals(joining.core.id.toString())).toList();
+            assertEquals(1, discoveries.stream().map(e -> e.get("id").getAsString()).distinct().count(),
+                "An acknowledged first discovery must be recoverable with its original event identity");
+            assertEquals("join", discoveries.getFirst().getAsJsonObject("data").get("trigger").getAsString());
+            assertEquals(List.of(List.of(CharacterSheets.RECIPE)), joining.recipeAwards);
+        }
+    }
+
+    private static List<com.google.gson.JsonObject> events(Path directory) throws Exception {
+        var entries = new java.util.ArrayList<com.google.gson.JsonObject>();
+        try (var files = java.nio.file.Files.walk(directory.resolve("events"))) {
+            for (var path : files.filter(p -> p.getFileName().toString().endsWith(".jsonl")).toList())
+                for (var line : java.nio.file.Files.readAllLines(path))
+                    if (!line.isBlank()) entries.add(com.google.gson.JsonParser.parseString(line).getAsJsonObject());
+        }
+        return entries;
     }
 
     private static long records(Path directory) throws Exception {

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

@@ -0,0 +1,157 @@
+package games.dmg.fantasystick;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+import games.dmg.fantasystick.items.CharacterSheets;
+import games.dmg.fantasystick.session.EquipmentSessions;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.concurrent.TimeUnit;
+import org.bukkit.event.player.PlayerJoinEvent;
+import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.io.TempDir;
+
+class SwitchDelayEventsNativeTest {
+    @TempDir Path data;
+    @BeforeAll static void bootstrap() throws Exception { NativeRuntime.bootstrap(); }
+
+    @Test void persistedExitAndPrepackSameOrDifferentCharacterDecisionsReachJsonl() throws Exception {
+        try (var fixture = new FantasyStickLifecycleNativeTest.Fixture(data)) {
+            fixture.plugin.setEnabled(true);
+            var actor = new FantasyStickLifecycleNativeTest.Actor(data);
+            fixture.players.put(actor.core.id, actor.player);
+            fixture.activate(actor);
+            var sessions = (EquipmentSessions) FantasyStickLifecycleNativeTest.Fixture.field(fixture.plugin, "sessions");
+            actor.core.location.add(3, 0, 1);
+            double exitX = actor.core.location.getX();
+            sessions.exit(actor.player);
+            fixture.awaitCharacterAndReceipt(actor);
+            actor.core.location.add(8, 0, 0);
+            double attemptX = actor.core.location.getX();
+            var saved = fixture.receipts().find(actor.core.id).toCompletableFuture()
+                .get(5, TimeUnit.SECONDS).orElseThrow();
+            var exit = saved.lastExit();
+            assertNotNull(exit);
+            var another = new FantasyStickLifecycleNativeTest.Actor(data);
+            actor.core.inventory.setItemInOffHand(another.core.inventory.getItemInOffHand().clone());
+            var before = actor.core.snapshot();
+            fixture.dispatcher.accept(new PlayerJoinEvent(actor.player, (net.kyori.adventure.text.Component) null));
+            fixture.tick(); fixture.tick();
+            assertArrayEquals(before, actor.core.snapshot(), "A refused switch cannot alter equipment");
+            assertTrue(actor.messages.getLast().contains("same character may be resumed now"));
+            actor.core.inventory.setItemInOffHand(new CharacterSheets().create(actor.core.record));
+            fixture.dispatcher.accept(new PlayerJoinEvent(actor.player, (net.kyori.adventure.text.Component) null));
+            fixture.tick(); fixture.tick(); fixture.tick();
+            assertTrue(actor.core.marker().endsWith("|PACKED"));
+            fixture.plugin.setEnabled(false);
+            var events = records();
+            var started = events.stream().filter(e -> e.get("type").getAsString().endsWith("character.switch_delay_started"))
+                .findFirst().orElseThrow().getAsJsonObject("data");
+            assertEquals(actor.core.id.toString(), started.get("player_id").getAsString());
+            assertEquals(exit.characterId().toString(), started.get("character_id").getAsString());
+            assertEquals(exit.deadline().toString(), started.get("deadline").getAsString());
+            assertEquals("900", started.get("duration_seconds").getAsString());
+            assertEquals(saved.revision().toString(), started.get("revision_after").getAsString());
+            assertEquals(exitX, started.getAsJsonObject("location").get("x").getAsDouble());
+            assertEquals(exit.exitedAt().toString(), events.stream()
+                .filter(e -> e.get("type").getAsString().endsWith("character.switch_delay_started"))
+                .findFirst().orElseThrow().get("time").getAsString());
+            var decisions = events.stream().filter(e -> e.get("type").getAsString().endsWith("action.resolved"))
+                .map(e -> e.getAsJsonObject("data"))
+                .filter(d -> d.has("action_kind") && d.get("action_kind").getAsString().equals("character_switch_preflight"))
+                .toList();
+            assertEquals(3, decisions.size(), "Initial entry, refused switch and same-character resumption are distinct preflights");
+            assertTrue(decisions.stream().anyMatch(d -> d.get("outcome").getAsString().equals("allowed")
+                && d.get("last_exited_character_id").getAsString().equals("none")));
+            assertTrue(decisions.stream().anyMatch(d -> d.get("outcome").getAsString().equals("refused")
+                && d.get("reason").getAsString().equals("cooldown")
+                && d.getAsJsonObject("location").get("x").getAsDouble() == attemptX));
+            var observations = events.stream().filter(e -> e.get("type").getAsString().endsWith("action.observed"))
+                .map(e -> e.getAsJsonObject("data"))
+                .filter(d -> d.has("action_kind") && d.get("action_kind").getAsString().equals("character_switch_preflight"))
+                .toList();
+            assertEquals(decisions.stream().map(d -> d.get("action_id").getAsString()).collect(java.util.stream.Collectors.toSet()),
+                observations.stream().map(d -> d.get("action_id").getAsString()).collect(java.util.stream.Collectors.toSet()));
+            assertTrue(decisions.stream().anyMatch(d -> d.get("outcome").getAsString().equals("allowed")
+                && d.get("same_character").getAsBoolean()));
+        }
+    }
+
+    @Test void acknowledgedExitRecoversSameDeadlineEventAfterWriterOutage() throws Exception {
+        try (var fixture = new FantasyStickLifecycleNativeTest.Fixture(data)) {
+            fixture.plugin.setEnabled(true);
+            var actor = new FantasyStickLifecycleNativeTest.Actor(data);
+            fixture.players.put(actor.core.id, actor.player);
+            fixture.activate(actor);
+            ((games.dmg.fantasystick.events.LocalEventLog)
+                FantasyStickLifecycleNativeTest.Fixture.field(fixture.plugin, "eventLog")).close();
+            var sessions = (EquipmentSessions) FantasyStickLifecycleNativeTest.Fixture.field(fixture.plugin, "sessions");
+            sessions.exit(actor.player);
+            fixture.awaitCharacterAndReceipt(actor);
+            var exit = fixture.receipts().find(actor.core.id).toCompletableFuture()
+                .get(5, TimeUnit.SECONDS).orElseThrow().lastExit();
+            fixture.plugin.setEnabled(false);
+            fixture.plugin.setEnabled(true);
+            for (int i = 0; i < 80 && records().stream()
+                    .noneMatch(e -> e.get("type").getAsString().endsWith("character.switch_delay_started")); i++)
+                Thread.sleep(10);
+            fixture.plugin.setEnabled(false);
+            var recovered = records().stream().filter(e -> e.get("type").getAsString()
+                .endsWith("character.switch_delay_started")).toList();
+            assertEquals(1, recovered.stream().map(e -> e.get("id").getAsString()).distinct().count());
+            assertEquals(exit.deadline().toString(), recovered.getFirst().getAsJsonObject("data")
+                .get("deadline").getAsString());
+            assertEquals(actor.core.record.id().toString(), recovered.getFirst().getAsJsonObject("data")
+                .get("character_id").getAsString());
+        }
+    }
+
+    @Test void twoPersistedExitsRemainDistinctDuringWriterOutageAndRestart() throws Exception {
+        try (var fixture = new FantasyStickLifecycleNativeTest.Fixture(data)) {
+            fixture.plugin.setEnabled(true);
+            var actor = new FantasyStickLifecycleNativeTest.Actor(data);
+            fixture.players.put(actor.core.id, actor.player);
+            fixture.activate(actor);
+            ((games.dmg.fantasystick.events.LocalEventLog)
+                FantasyStickLifecycleNativeTest.Fixture.field(fixture.plugin, "eventLog")).close();
+            var sessions = (EquipmentSessions) FantasyStickLifecycleNativeTest.Fixture.field(fixture.plugin, "sessions");
+            sessions.exit(actor.player);
+            fixture.awaitCharacterAndReceipt(actor);
+            var first = fixture.receipts().find(actor.core.id).toCompletableFuture()
+                .get(5, TimeUnit.SECONDS).orElseThrow().lastExit();
+            fixture.reenter(actor);
+            sessions.exit(actor.player);
+            fixture.awaitCharacterAndReceipt(actor);
+            var second = fixture.receipts().find(actor.core.id).toCompletableFuture()
+                .get(5, TimeUnit.SECONDS).orElseThrow().lastExit();
+            assertNotEquals(first.sessionId(), second.sessionId());
+            fixture.plugin.setEnabled(false);
+            fixture.plugin.setEnabled(true);
+            for (int i = 0; i < 80 && records().stream().filter(e -> e.get("type").getAsString()
+                    .endsWith("character.switch_delay_started")).map(e -> e.get("id").getAsString()).distinct().count() < 2; i++)
+                Thread.sleep(10);
+            fixture.plugin.setEnabled(false);
+            var starts = records().stream().filter(e -> e.get("type").getAsString()
+                .endsWith("character.switch_delay_started"))
+                .collect(java.util.stream.Collectors.toMap(e -> e.get("id").getAsString(), e -> e,
+                    (one, duplicate) -> one, java.util.LinkedHashMap::new));
+            assertEquals(2, starts.size());
+            assertEquals(java.util.Set.of(first.sessionId().toString(), second.sessionId().toString()),
+                starts.values().stream().map(e -> e.getAsJsonObject("data").get("session_id").getAsString())
+                    .collect(java.util.stream.Collectors.toSet()));
+        }
+    }
+
+    private List<com.google.gson.JsonObject> records() throws Exception {
+        var events = new ArrayList<com.google.gson.JsonObject>();
+        try (var files = Files.walk(data.resolve("events"))) {
+            for (var path : files.filter(p -> p.getFileName().toString().endsWith(".jsonl")).toList())
+                for (var line : Files.readAllLines(path))
+                    if (!line.isBlank()) events.add(com.google.gson.JsonParser.parseString(line).getAsJsonObject());
+        }
+        return events;
+    }
+}