feat(ability): add Second Wind

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

@@ -55,6 +55,8 @@ public final class FantasyStickPlugin extends JavaPlugin {
     private games.dmg.fantasystick.persistence.LongbowSettings longbowSettings;
     private games.dmg.fantasystick.ability.Quickstep quickstep;
     private games.dmg.fantasystick.persistence.QuickstepSettings quickstepSettings;
+    private games.dmg.fantasystick.ability.SecondWind secondWind;
+    private games.dmg.fantasystick.persistence.SecondWindSettings secondWindSettings;
     private games.dmg.fantasystick.ability.GreatSword greatSword;
     private games.dmg.fantasystick.ability.Revive revive;
     private games.dmg.fantasystick.persistence.RevivalStore revivals;
@@ -92,6 +94,8 @@ public final class FantasyStickPlugin extends JavaPlugin {
             var longbowInitial = games.dmg.fantasystick.persistence.LongbowSettings.parse(longbowConfiguration);
             var quickstepConfiguration = quickstepConfiguration();
             var quickstepInitial = games.dmg.fantasystick.persistence.QuickstepSettings.parse(quickstepConfiguration);
+            var secondWindConfiguration = secondWindConfiguration();
+            var secondWindInitial = games.dmg.fantasystick.persistence.SecondWindSettings.parse(secondWindConfiguration);
             var factory = new CharacterFactory();
             characters = new CharacterStorage(new YamlCharacterRepository(getDataFolder().toPath()), Clock.systemUTC());
             crafting = new ManualCraftingController(characters, () -> factory.create(rules),
@@ -142,6 +146,10 @@ public final class FantasyStickPlugin extends JavaPlugin {
                 getDataFolder().toPath(), quickstepConfiguration);
             quickstep = new games.dmg.fantasystick.ability.Quickstep(quickstepInitial,
                 event -> getServer().getPluginManager().callEvent(event));
+            secondWindSettings = new games.dmg.fantasystick.persistence.SecondWindSettings(
+                getDataFolder().toPath(), secondWindConfiguration);
+            secondWind = new games.dmg.fantasystick.ability.SecondWind(secondWindInitial, characters, sessions, nextTick,
+                event -> getServer().getPluginManager().callEvent(event), games.dmg.fantasystick.session.NativeHealthLimit::read);
             greatSword = new games.dmg.fantasystick.ability.GreatSword(greatSwordSettings);
             revivals = new games.dmg.fantasystick.persistence.RevivalStore(getDataFolder().toPath());
             revive = new games.dmg.fantasystick.ability.Revive(characters, revivals, Clock.systemUTC(), nextTick,
@@ -151,6 +159,7 @@ public final class FantasyStickPlugin extends JavaPlugin {
             abilityRegistry.register(frostShard.definition());
             abilityRegistry.register(longbow.definition());
             abilityRegistry.register(quickstep.definition());
+            abilityRegistry.register(secondWind.definition());
             abilityRegistry.register(greatSword.definition());
             abilityRegistry.register(revive.definition());
             sessions.attachAbilityRegistry(abilityRegistry);
@@ -195,7 +204,7 @@ public final class FantasyStickPlugin extends JavaPlugin {
                 problem -> getLogger().log(Level.WARNING, "Equipment admin " + problem.operation()
                     + " for player " + problem.player(), problem.cause()), adventureSettings,
                 frostShardSettings, frostShard, longbowSettings, longbow,
-                quickstepSettings, quickstep, abilityRegistry);
+                quickstepSettings, quickstep, secondWindSettings, secondWind, abilityRegistry);
             var command = java.util.Objects.requireNonNull(getCommand("fantasystick"), "Missing packaged fantasystick command");
             command.setExecutor(admin);
             command.setTabCompleter(admin);
@@ -264,6 +273,8 @@ public final class FantasyStickPlugin extends JavaPlugin {
         var closingLongbowSettings = longbowSettings; longbowSettings = null;
         var closingQuickstep = quickstep; quickstep = null;
         var closingQuickstepSettings = quickstepSettings; quickstepSettings = null;
+        secondWind = null;
+        var closingSecondWindSettings = secondWindSettings; secondWindSettings = null;
         var closingGreatSword = greatSword; greatSword = null;
         var closingRevive = revive; revive = null;
         var closingRevivals = revivals; revivals = null;
@@ -277,6 +288,7 @@ public final class FantasyStickPlugin extends JavaPlugin {
         if (closingFrostSettings != null) cleanup("Frost Shard configuration", closingFrostSettings::close);
         if (closingLongbowSettings != null) cleanup("Longbow configuration", closingLongbowSettings::close);
         if (closingQuickstepSettings != null) cleanup("Quickstep configuration", closingQuickstepSettings::close);
+        if (closingSecondWindSettings != null) cleanup("Second Wind configuration", closingSecondWindSettings::close);
         configurationDrain = java.util.concurrent.CompletableFuture.allOf(
             closingSettings == null ? java.util.concurrent.CompletableFuture.completedFuture(null)
                 : closingSettings.drained().toCompletableFuture(),
@@ -285,7 +297,9 @@ public final class FantasyStickPlugin extends JavaPlugin {
             closingLongbowSettings == null ? java.util.concurrent.CompletableFuture.completedFuture(null)
                 : closingLongbowSettings.drained().toCompletableFuture(),
             closingQuickstepSettings == null ? java.util.concurrent.CompletableFuture.completedFuture(null)
-                : closingQuickstepSettings.drained().toCompletableFuture());
+                : closingQuickstepSettings.drained().toCompletableFuture(),
+            closingSecondWindSettings == null ? java.util.concurrent.CompletableFuture.completedFuture(null)
+                : closingSecondWindSettings.drained().toCompletableFuture());
         if (closingBooks != null) cleanup("character book", closingBooks::close);
         if (closingBasicAttack != null) cleanup("basic attack", closingBasicAttack::close);
         if (closingCombatExperience != null) cleanup("combat experience", closingCombatExperience::close);
@@ -415,6 +429,16 @@ public final class FantasyStickPlugin extends JavaPlugin {
         return java.util.Map.copyOf(values);
     }
 
+    private java.util.Map<String, String> secondWindConfiguration() {
+        var values = new java.util.LinkedHashMap<String, String>();
+        for (String key : games.dmg.fantasystick.persistence.SecondWindSettings.keys()) {
+            values.put(key, getConfig().getString(key,
+                games.dmg.fantasystick.persistence.SecondWindSettings.defaultValue(key)));
+        }
+        games.dmg.fantasystick.persistence.SecondWindSettings.parse(values);
+        return java.util.Map.copyOf(values);
+    }
+
     private games.dmg.fantasystick.ability.GreatSword.Settings greatSwordSettings() {
         try {
             var base = new java.math.BigInteger(getConfig().getString("great-sword-base-damage", "7"));

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

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

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

@@ -441,12 +441,19 @@ public final class CharacterStorage implements AutoCloseable {
     /** Session-owned remaining health; retain all other current fields and reject concurrent revision changes. */
     public CompletableFuture<Optional<CharacterRecord>> saveHealth(UUID characterId, java.math.BigDecimal health,
                                                                   java.math.BigDecimal nativeLimit) {
+        return saveHealth(characterId, null, health, nativeLimit);
+    }
+
+    /** Ability-owned health mutation that refuses a changed character revision rather than healing stale state. */
+    public CompletableFuture<Optional<CharacterRecord>> saveHealth(UUID characterId, BigInteger expectedRevision,
+            java.math.BigDecimal health, java.math.BigDecimal nativeLimit) {
         Objects.requireNonNull(characterId);
         if (health.signum() < 0 || nativeLimit.signum() <= 0) throw new IllegalArgumentException("Invalid health bound");
         return submit(() -> {
             var found = repository.load(characterId);
             if (found.isEmpty() || found.orElseThrow().dead()) return Optional.empty();
             var old = found.orElseThrow();
+            if (expectedRevision != null && !old.revision().equals(expectedRevision)) return Optional.empty();
             var bounded = health.min(old.maximumHealth()).min(nativeLimit);
             if (old.health().compareTo(bounded) == 0) return Optional.of(old);
             var saved = new CharacterRecord(old.id(), old.name(), old.revision().add(BigInteger.ONE), old.stats(), old.level(),

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

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

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

@@ -28,6 +28,8 @@ public final class EquipmentAdminCommand implements TabExecutor, AutoCloseable {
     private games.dmg.fantasystick.ability.Longbow longbow;
     private games.dmg.fantasystick.persistence.QuickstepSettings quickstepSettings;
     private games.dmg.fantasystick.ability.Quickstep quickstep;
+    private games.dmg.fantasystick.persistence.SecondWindSettings secondWindSettings;
+    private games.dmg.fantasystick.ability.SecondWind secondWind;
 
     public EquipmentAdminCommand(EquipmentSessionStore receipts, EquipmentSessions sessions, Server server,
                                  Consumer<Runnable> nextTick, Consumer<Failure> diagnostics) {
@@ -86,6 +88,24 @@ public final class EquipmentAdminCommand implements TabExecutor, AutoCloseable {
         this.quickstep = Objects.requireNonNull(quickstep);
     }
 
+    public EquipmentAdminCommand(EquipmentSessionStore receipts, EquipmentSessions sessions, Server server,
+                                 Consumer<Runnable> nextTick, Consumer<Failure> diagnostics,
+                                 games.dmg.fantasystick.persistence.AdventureSettings settings,
+                                 games.dmg.fantasystick.persistence.FrostShardSettings frostSettings,
+                                 games.dmg.fantasystick.ability.FrostShard frostShard,
+                                 games.dmg.fantasystick.persistence.LongbowSettings longbowSettings,
+                                 games.dmg.fantasystick.ability.Longbow longbow,
+                                 games.dmg.fantasystick.persistence.QuickstepSettings quickstepSettings,
+                                 games.dmg.fantasystick.ability.Quickstep quickstep,
+                                 games.dmg.fantasystick.persistence.SecondWindSettings secondWindSettings,
+                                 games.dmg.fantasystick.ability.SecondWind secondWind,
+                                 games.dmg.fantasystick.ability.AbilityRegistry abilities) {
+        this(receipts, sessions, server, nextTick, diagnostics, settings, frostSettings, frostShard,
+            longbowSettings, longbow, quickstepSettings, quickstep, abilities);
+        this.secondWindSettings = Objects.requireNonNull(secondWindSettings);
+        this.secondWind = Objects.requireNonNull(secondWind);
+    }
+
     @Override public boolean onCommand(CommandSender sender, Command command, String label, String[] args) {
         if (closed) return true;
         if (!sender.hasPermission(PERMISSION)) {
@@ -165,6 +185,9 @@ public final class EquipmentAdminCommand implements TabExecutor, AutoCloseable {
         if (quickstepSettings != null && games.dmg.fantasystick.persistence.QuickstepSettings.keys().contains(args[1])) {
             quickstepConfiguration(sender, args); return;
         }
+        if (secondWindSettings != null && games.dmg.fantasystick.persistence.SecondWindSettings.keys().contains(args[1])) {
+            secondWindConfiguration(sender, args); return;
+        }
         if (frostSettings == null || !games.dmg.fantasystick.persistence.FrostShardSettings.keys().contains(args[1])) {
             configurationUsage(sender); return;
         }
@@ -262,6 +285,37 @@ public final class EquipmentAdminCommand implements TabExecutor, AutoCloseable {
         });
     }
 
+    private void secondWindConfiguration(CommandSender sender, String[] args) {
+        String key = args[1];
+        if (args.length == 2) {
+            sender.sendMessage(key + "=" + secondWindSettings.value(key) + " (applies to future Second Wind casts only)");
+            return;
+        }
+        java.util.concurrent.CompletionStage<games.dmg.fantasystick.persistence.SecondWindSettings.Update> operation;
+        try { operation = secondWindSettings.set(key, args[2]); }
+        catch (IllegalArgumentException invalid) {
+            sender.sendMessage("Second Wind setting is invalid; the effective value is unchanged."); return;
+        }
+        operation.whenComplete((saved, failure) -> {
+            if (failure != null) report(null, "config-" + key, failure);
+            if (closed) return;
+            try {
+                nextTick.accept(() -> {
+                    if (closed) return;
+                    if (failure == null) {
+                        secondWind.configure(saved.settings()); abilities.replace(secondWind.definition());
+                        secondWindSettings.publish(saved);
+                    }
+                    if (!sender.hasPermission(PERMISSION)
+                            || sender instanceof org.bukkit.entity.Player player && !player.isOnline()) return;
+                    sender.sendMessage(failure == null
+                        ? "Saved " + key + "=" + saved.value() + " for future Second Wind casts; active work and deadlines are unchanged."
+                        : "Second Wind configuration save failed; the effective setting is unchanged.");
+                });
+            } catch (RuntimeException rejected) { report(null, "config-response", rejected); }
+        });
+    }
+
     private void adventureConfiguration(CommandSender sender, String[] args) {
         if (args.length == 3 && !args[2].equals("true") && !args[2].equals("false")) {
             sender.sendMessage("Usage: /fantasystick config adventure-mode [true|false]"); return;
@@ -303,6 +357,7 @@ public final class EquipmentAdminCommand implements TabExecutor, AutoCloseable {
             keys.addAll(games.dmg.fantasystick.persistence.FrostShardSettings.keys());
             keys.addAll(games.dmg.fantasystick.persistence.LongbowSettings.keys());
             keys.addAll(games.dmg.fantasystick.persistence.QuickstepSettings.keys());
+            keys.addAll(games.dmg.fantasystick.persistence.SecondWindSettings.keys());
             return matching(keys, args[1]);
         }
         if (args.length == 3 && args[0].equals("config")) {
@@ -322,6 +377,11 @@ public final class EquipmentAdminCommand implements TabExecutor, AutoCloseable {
                 String defaults = games.dmg.fantasystick.persistence.QuickstepSettings.defaultValue(args[1]);
                 return matching(current.equals(defaults) ? List.of(current) : List.of(current, defaults), args[2]);
             }
+            if (secondWindSettings != null && games.dmg.fantasystick.persistence.SecondWindSettings.keys().contains(args[1])) {
+                String current = secondWindSettings.value(args[1]);
+                String defaults = games.dmg.fantasystick.persistence.SecondWindSettings.defaultValue(args[1]);
+                return matching(current.equals(defaults) ? List.of(current) : List.of(current, defaults), args[2]);
+            }
         }
         return List.of();
     }

src/main/resources/config.yml

@@ -51,3 +51,8 @@ longbow-full-projectile-speed-blocks-per-tick: 3
 quickstep-cooldown-seconds: 5
 quickstep-distance-blocks: 4
 quickstep-speed-blocks-per-tick: 1
+
+# Second Wind defaults from the reviewed remaining-development packet.
+# Admin command: /fantasystick config <key> [value]
+second-wind-base-healing: 6
+second-wind-cooldown-seconds: 15

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

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

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

@@ -60,6 +60,10 @@ class DistributionTest {
                     "quickstep-distance-blocks: 4", "quickstep-speed-blocks-per-tick: 1")) {
                 assertTrue(defaults.contains(setting), "Missing packaged Quickstep default: " + setting);
             }
+            for (String setting : java.util.List.of("second-wind-base-healing: 6",
+                    "second-wind-cooldown-seconds: 15")) {
+                assertTrue(defaults.contains(setting), "Missing packaged Second Wind default: " + setting);
+            }
             assertTrue(JavaPlugin.class.isAssignableFrom(FantasyStickPlugin.class));
             var entrypoint = jar.getJarEntry(metadata.getMain().replace('.', '/') + ".class");
             assertNotNull(entrypoint);

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

@@ -0,0 +1,70 @@
+package games.dmg.fantasystick.persistence;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.StandardCopyOption;
+import java.util.LinkedHashMap;
+import java.util.Map;
+import java.util.concurrent.TimeUnit;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.io.TempDir;
+
+class SecondWindSettingsTest {
+    @TempDir Path data;
+
+    @Test void serializesConcurrentWritesPreservesUnrelatedAndPublishesAcknowledgedSnapshots() throws Exception {
+        Files.writeString(data.resolve("config.yml"), "unrelated: retained\n");
+        try (var settings = new SecondWindSettings(data, defaults())) {
+            var healing = settings.set(SecondWindSettings.BASE_HEALING, "9").toCompletableFuture();
+            var cooldown = settings.set(SecondWindSettings.COOLDOWN, "20").toCompletableFuture();
+            var h = healing.get(5, TimeUnit.SECONDS); var c = cooldown.get(5, TimeUnit.SECONDS);
+            assertEquals("6", settings.value(SecondWindSettings.BASE_HEALING)); settings.publish(c); settings.publish(h);
+            assertEquals("9", settings.value(SecondWindSettings.BASE_HEALING));
+            assertEquals(java.time.Duration.ofSeconds(20), settings.settings().cooldown());
+            var saved = (Map<?, ?>) new org.yaml.snakeyaml.Yaml().load(Files.readString(data.resolve("config.yml")));
+            assertEquals("retained", saved.get("unrelated")); assertEquals("9", String.valueOf(saved.get(SecondWindSettings.BASE_HEALING)));
+        }
+    }
+
+    @Test void rejectsInvalidValuesAndFailedReplacementRetainsState() throws Exception {
+        try (var settings = new SecondWindSettings(data, defaults())) {
+            assertThrows(IllegalArgumentException.class, () -> settings.set(SecondWindSettings.BASE_HEALING, "-1"));
+            assertThrows(IllegalArgumentException.class, () -> settings.set(SecondWindSettings.BASE_HEALING, "1.5"));
+            assertThrows(IllegalArgumentException.class, () -> settings.set(SecondWindSettings.COOLDOWN, "-1"));
+            assertThrows(IllegalArgumentException.class, () -> settings.set(SecondWindSettings.COOLDOWN, "0.0000000001"));
+        }
+        var fail = new java.util.concurrent.atomic.AtomicBoolean(true);
+        try (var settings = new SecondWindSettings(data, defaults(), (from, to) -> {
+            if (fail.getAndSet(false)) throw new java.io.IOException("simulated");
+            Files.move(from, to, StandardCopyOption.REPLACE_EXISTING);
+        })) {
+            assertThrows(java.util.concurrent.ExecutionException.class, () ->
+                settings.set(SecondWindSettings.BASE_HEALING, "9").toCompletableFuture().get(5, TimeUnit.SECONDS));
+            assertEquals("6", settings.value(SecondWindSettings.BASE_HEALING));
+        }
+    }
+
+    @Test void rejectsUnsafeFileAndPostCloseWrites() throws Exception {
+        if (!System.getProperty("os.name", "").toLowerCase().contains("win")) {
+            var external = data.resolveSibling(data.getFileName() + "-outside"); Files.writeString(external, "safe\n");
+            Files.createSymbolicLink(data.resolve("config.yml"), external);
+            try (var settings = new SecondWindSettings(data, defaults())) {
+                assertThrows(java.util.concurrent.ExecutionException.class, () ->
+                    settings.set(SecondWindSettings.BASE_HEALING, "9").toCompletableFuture().get(5, TimeUnit.SECONDS));
+                assertEquals("safe\n", Files.readString(external));
+            }
+        }
+        var other = data.resolve("closed"); var settings = new SecondWindSettings(other, defaults()); settings.close();
+        assertThrows(java.util.concurrent.ExecutionException.class, () ->
+            settings.set(SecondWindSettings.BASE_HEALING, "9").toCompletableFuture().get(5, TimeUnit.SECONDS));
+        settings.drained().toCompletableFuture().get(5, TimeUnit.SECONDS);
+    }
+
+    private static Map<String, String> defaults() {
+        var result = new LinkedHashMap<String, String>();
+        for (String key : SecondWindSettings.keys()) result.put(key, SecondWindSettings.defaultValue(key));
+        return result;
+    }
+}