feat(ability): add Stone Skin

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

@@ -57,6 +57,9 @@ public final class FantasyStickPlugin extends JavaPlugin {
     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.CombatMitigation combatMitigation;
+    private games.dmg.fantasystick.ability.StoneSkin stoneSkin;
+    private games.dmg.fantasystick.persistence.StoneSkinSettings stoneSkinSettings;
     private games.dmg.fantasystick.ability.GreatSword greatSword;
     private games.dmg.fantasystick.ability.Revive revive;
     private games.dmg.fantasystick.persistence.RevivalStore revivals;
@@ -96,6 +99,8 @@ public final class FantasyStickPlugin extends JavaPlugin {
             var quickstepInitial = games.dmg.fantasystick.persistence.QuickstepSettings.parse(quickstepConfiguration);
             var secondWindConfiguration = secondWindConfiguration();
             var secondWindInitial = games.dmg.fantasystick.persistence.SecondWindSettings.parse(secondWindConfiguration);
+            var stoneSkinConfiguration = stoneSkinConfiguration();
+            var stoneSkinInitial = games.dmg.fantasystick.persistence.StoneSkinSettings.parse(stoneSkinConfiguration);
             var factory = new CharacterFactory();
             characters = new CharacterStorage(new YamlCharacterRepository(getDataFolder().toPath()), Clock.systemUTC());
             crafting = new ManualCraftingController(characters, () -> factory.create(rules),
@@ -150,6 +155,10 @@ public final class FantasyStickPlugin extends JavaPlugin {
                 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);
+            stoneSkinSettings = new games.dmg.fantasystick.persistence.StoneSkinSettings(
+                getDataFolder().toPath(), stoneSkinConfiguration);
+            combatMitigation = new games.dmg.fantasystick.ability.CombatMitigation();
+            stoneSkin = new games.dmg.fantasystick.ability.StoneSkin(stoneSkinInitial, combatMitigation);
             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,
@@ -160,6 +169,7 @@ public final class FantasyStickPlugin extends JavaPlugin {
             abilityRegistry.register(longbow.definition());
             abilityRegistry.register(quickstep.definition());
             abilityRegistry.register(secondWind.definition());
+            abilityRegistry.register(stoneSkin.definition());
             abilityRegistry.register(greatSword.definition());
             abilityRegistry.register(revive.definition());
             sessions.attachAbilityRegistry(abilityRegistry);
@@ -204,7 +214,8 @@ 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, secondWindSettings, secondWind, abilityRegistry);
+                quickstepSettings, quickstep, secondWindSettings, secondWind,
+                stoneSkinSettings, stoneSkin, abilityRegistry);
             var command = java.util.Objects.requireNonNull(getCommand("fantasystick"), "Missing packaged fantasystick command");
             command.setExecutor(admin);
             command.setTabCompleter(admin);
@@ -222,6 +233,7 @@ public final class FantasyStickPlugin extends JavaPlugin {
             getServer().getPluginManager().registerEvents(frostShard, this);
             getServer().getPluginManager().registerEvents(longbow, this);
             getServer().getPluginManager().registerEvents(quickstep, this);
+            getServer().getPluginManager().registerEvents(combatMitigation, this);
             getServer().getPluginManager().registerEvents(greatSword, this);
             getServer().getPluginManager().registerEvents(revive, this);
             getServer().getPluginManager().registerEvents(localBasicAttack, this);
@@ -274,6 +286,9 @@ public final class FantasyStickPlugin extends JavaPlugin {
         var closingQuickstep = quickstep; quickstep = null;
         var closingQuickstepSettings = quickstepSettings; quickstepSettings = null;
         secondWind = null;
+        var closingStoneSkin = stoneSkin; stoneSkin = null;
+        var closingCombatMitigation = combatMitigation; combatMitigation = null;
+        var closingStoneSkinSettings = stoneSkinSettings; stoneSkinSettings = null;
         var closingSecondWindSettings = secondWindSettings; secondWindSettings = null;
         var closingGreatSword = greatSword; greatSword = null;
         var closingRevive = revive; revive = null;
@@ -289,6 +304,7 @@ public final class FantasyStickPlugin extends JavaPlugin {
         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);
+        if (closingStoneSkinSettings != null) cleanup("Stone Skin configuration", closingStoneSkinSettings::close);
         configurationDrain = java.util.concurrent.CompletableFuture.allOf(
             closingSettings == null ? java.util.concurrent.CompletableFuture.completedFuture(null)
                 : closingSettings.drained().toCompletableFuture(),
@@ -299,7 +315,9 @@ public final class FantasyStickPlugin extends JavaPlugin {
             closingQuickstepSettings == null ? java.util.concurrent.CompletableFuture.completedFuture(null)
                 : closingQuickstepSettings.drained().toCompletableFuture(),
             closingSecondWindSettings == null ? java.util.concurrent.CompletableFuture.completedFuture(null)
-                : closingSecondWindSettings.drained().toCompletableFuture());
+                : closingSecondWindSettings.drained().toCompletableFuture(),
+            closingStoneSkinSettings == null ? java.util.concurrent.CompletableFuture.completedFuture(null)
+                : closingStoneSkinSettings.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);
@@ -307,6 +325,8 @@ public final class FantasyStickPlugin extends JavaPlugin {
         if (closingFrostShard != null) cleanup("Frost Shard", closingFrostShard::close);
         if (closingLongbow != null) cleanup("Longbow", closingLongbow::close);
         if (closingQuickstep != null) cleanup("Quickstep", closingQuickstep::close);
+        if (closingStoneSkin != null) cleanup("Stone Skin", closingStoneSkin::close);
+        if (closingCombatMitigation != null) cleanup("combat mitigation", closingCombatMitigation::close);
         if (closingGreatSword != null) cleanup("Great Sword", closingGreatSword::close);
         if (closingRevive != null) cleanup("Revive", closingRevive::close);
         if (closingAbilityEngine != null) cleanup("ability engine", closingAbilityEngine::close);
@@ -327,6 +347,7 @@ public final class FantasyStickPlugin extends JavaPlugin {
         unregister(closingFrostShard);
         unregister(closingLongbow);
         unregister(closingQuickstep);
+        unregister(closingCombatMitigation);
         unregister(closingGreatSword);
         unregister(closingRevive);
         unregister(closingBasicAttack);
@@ -439,6 +460,16 @@ public final class FantasyStickPlugin extends JavaPlugin {
         return java.util.Map.copyOf(values);
     }
 
+    private java.util.Map<String, String> stoneSkinConfiguration() {
+        var values = new java.util.LinkedHashMap<String, String>();
+        for (String key : games.dmg.fantasystick.persistence.StoneSkinSettings.keys()) {
+            values.put(key, getConfig().getString(key,
+                games.dmg.fantasystick.persistence.StoneSkinSettings.defaultValue(key)));
+        }
+        games.dmg.fantasystick.persistence.StoneSkinSettings.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/CombatMitigation.java

@@ -0,0 +1,77 @@
+package games.dmg.fantasystick.ability;
+
+import java.math.BigDecimal;
+import java.util.ArrayList;
+import java.util.IdentityHashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Objects;
+import java.util.UUID;
+import org.bukkit.entity.Player;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.EventPriority;
+import org.bukkit.event.Listener;
+import org.bukkit.event.entity.EntityDamageByEntityEvent;
+import org.bukkit.event.entity.EntityDamageEvent;
+
+/** Internal strongest-reduction stage shared by Fantasy Stick protection effects. */
+public final class CombatMitigation implements Listener, AutoCloseable {
+    private final class Grant implements AutoCloseable {
+        final AbilityExecution execution; final Player player; final BigDecimal percent; boolean closed;
+        Grant(AbilityExecution execution, Player player, BigDecimal percent) {
+            this.execution = execution; this.player = player; this.percent = percent;
+        }
+        @Override public void close() {
+            if (closed) return; closed = true;
+            var owned = grants.get(player.getUniqueId());
+            if (owned != null) { owned.remove(this); if (owned.isEmpty()) grants.remove(player.getUniqueId()); }
+        }
+    }
+    private record Prevention(Grant grant, BigDecimal amount) { }
+    private final Map<UUID, List<Grant>> grants = new java.util.HashMap<>();
+    private final Map<EntityDamageEvent, Prevention> pending = new IdentityHashMap<>();
+    private boolean closed;
+
+    public AutoCloseable grant(AbilityExecution execution, Player player, BigDecimal percent) {
+        Objects.requireNonNull(execution); Objects.requireNonNull(player); Objects.requireNonNull(percent);
+        if (closed || percent.signum() < 0 || percent.compareTo(BigDecimal.valueOf(100)) > 0)
+            throw new IllegalArgumentException("Invalid combat mitigation grant");
+        var grant = new Grant(execution, player, percent);
+        grants.computeIfAbsent(player.getUniqueId(), ignored -> new ArrayList<>()).add(grant);
+        return grant;
+    }
+
+    @EventHandler(priority = EventPriority.HIGH, ignoreCancelled = true)
+    public void reduce(EntityDamageByEntityEvent event) {
+        if (closed || !(event.getEntity() instanceof Player player)) return;
+        Grant strongest = null;
+        var owned = grants.get(player.getUniqueId());
+        if (owned == null) return;
+        for (var grant : List.copyOf(owned)) {
+            if (grant.closed || grant.player != player || !grant.execution.stillCurrent()) continue;
+            if (strongest == null || grant.percent.compareTo(strongest.percent) > 0) strongest = grant;
+        }
+        double original = event.getDamage();
+        if (strongest == null || !Double.isFinite(original) || original <= 0) return;
+        double reduced = BigDecimal.valueOf(original)
+            .multiply(BigDecimal.ONE.subtract(strongest.percent.movePointLeft(2))).doubleValue();
+        if (!Double.isFinite(reduced) || reduced < 0) return;
+        event.setDamage(reduced);
+        BigDecimal prevented = BigDecimal.valueOf(original - reduced);
+        if (prevented.signum() > 0) pending.put(event, new Prevention(strongest, prevented));
+    }
+
+    @EventHandler(priority = EventPriority.MONITOR)
+    public void accepted(EntityDamageEvent event) {
+        var prevention = pending.remove(event);
+        if (prevention == null || event.isCancelled() || event.getFinalDamage() <= 0
+                || !prevention.grant.execution.stillCurrent()) return;
+        prevention.grant.execution.report(AbilityReport.Type.PREVENTION, event.getEntity(), prevention.amount);
+    }
+
+    @Override public void close() {
+        if (closed) return; closed = true;
+        for (var owned : List.copyOf(grants.values())) for (var grant : List.copyOf(owned)) grant.close();
+        grants.clear(); pending.clear();
+    }
+}

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

@@ -0,0 +1,84 @@
+package games.dmg.fantasystick.ability;
+
+import games.dmg.fantasystick.progression.Stat;
+import games.dmg.fantasystick.session.ControlInput;
+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.UUID;
+import org.bukkit.Material;
+import org.bukkit.entity.Player;
+
+/** Stone Skin's captured, owned grant into the shared strongest-reduction stage. */
+public final class StoneSkin implements AbilityEffect, AutoCloseable {
+    public record Settings(Duration cooldown, Duration duration, BigDecimal reductionPercent) {
+        public Settings {
+            Objects.requireNonNull(cooldown); Objects.requireNonNull(duration); Objects.requireNonNull(reductionPercent);
+            if (cooldown.isNegative() || cooldown.compareTo(Duration.ofDays(365)) > 0
+                    || duration.isNegative() || duration.isZero() || duration.compareTo(Duration.ofDays(1)) > 0
+                    || reductionPercent.signum() < 0 || reductionPercent.compareTo(BigDecimal.valueOf(100)) > 0)
+                throw new IllegalArgumentException("Invalid Stone Skin settings");
+        }
+        public static Settings defaults() {
+            return new Settings(Duration.ofSeconds(14), Duration.ofSeconds(4), BigDecimal.valueOf(25));
+        }
+    }
+
+    private final class State implements AutoCloseable {
+        final AbilityExecution execution; final Player player; final AutoCloseable grant; boolean closed;
+        State(AbilityExecution execution, Player player, AutoCloseable grant) {
+            this.execution = execution; this.player = player; this.grant = grant;
+        }
+        @Override public void close() {
+            if (closed) return; closed = true; protections.remove(player.getUniqueId(), this);
+            try { grant.close(); } catch (Exception impossible) { throw new IllegalStateException(impossible); }
+        }
+    }
+
+    private volatile Settings settings;
+    private final CombatMitigation mitigation;
+    private final Map<UUID, State> protections = new java.util.HashMap<>();
+    private boolean closed;
+
+    public StoneSkin(Settings settings, CombatMitigation mitigation) {
+        this.settings = Objects.requireNonNull(settings); this.mitigation = Objects.requireNonNull(mitigation);
+    }
+    public void configure(Settings settings) { this.settings = Objects.requireNonNull(settings); }
+
+    public AbilityDefinition definition() {
+        var current = settings;
+        return new AbilityDefinition("stone_skin", "Stone Skin", Material.BRICK,
+            List.of("Reduce entity and projectile combat damage by " + decimal(current.reductionPercent()) + "%.",
+                "Lasts " + decimal(BigDecimal.valueOf(current.duration().toMillis()).movePointLeft(3)) + " seconds without stacking."),
+            "Use to protect yourself; environmental damage is unchanged.", Map.of(Stat.CON, BigInteger.valueOf(14)), BigInteger.ONE,
+            AbilityDefinition.Activation.DELAYED, ControlInput.Gesture.USE, current.cooldown(),
+            Map.of("duration-seconds", BigDecimal.valueOf(current.duration().toNanos()).movePointLeft(9),
+                "damage-reduction-percent", current.reductionPercent()), AbilityDefinition.TargetPolicy.SELF, this);
+    }
+
+    @Override public void activate(AbilityExecution execution) {
+        if (closed || !execution.stillCurrent()) return;
+        var current = from(execution.definition()); var player = execution.input().player();
+        var grant = mitigation.grant(execution, player, current.reductionPercent());
+        var state = new State(execution, player, grant);
+        var previous = protections.put(player.getUniqueId(), state);
+        if (previous != null) previous.execution.finish();
+        execution.own(state); execution.later(current.duration(), execution::finish);
+    }
+
+    private static Settings from(AbilityDefinition definition) {
+        return new Settings(definition.cooldown(),
+            Duration.ofNanos(definition.parameters().get("duration-seconds").movePointRight(9).longValueExact()),
+            definition.parameters().get("damage-reduction-percent"));
+    }
+    private static String decimal(BigDecimal value) { return value.stripTrailingZeros().toPlainString(); }
+
+    @Override public void close() {
+        if (closed) return; closed = true;
+        for (var state : List.copyOf(protections.values())) state.execution.finish();
+        protections.clear();
+    }
+}

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

@@ -0,0 +1,188 @@
+package games.dmg.fantasystick.persistence;
+
+import games.dmg.fantasystick.ability.StoneSkin;
+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 Stone Skin settings; publication remains a server-thread caller decision. */
+public final class StoneSkinSettings implements AutoCloseable {
+    private static final int MAX_BYTES = 1_048_576;
+    public static final String COOLDOWN = "stone-skin-cooldown-seconds";
+    public static final String DURATION = "stone-skin-duration-seconds";
+    public static final String REDUCTION = "stone-skin-damage-reduction-percent";
+    private static final List<String> KEYS = List.of(COOLDOWN, DURATION, REDUCTION);
+    private static final Map<String, String> DEFAULTS = Map.of(COOLDOWN, "14", DURATION, "4", REDUCTION, "25");
+
+    @FunctionalInterface interface Replacement { void move(Path from, Path to) throws IOException; }
+    public record Update(String key, String value, StoneSkin.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-stone-skin-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 StoneSkinSettings(Path directory, Map<String, String> initial) {
+        this(directory, initial, (from, to) -> Files.move(from, to,
+            StandardCopyOption.ATOMIC_MOVE, StandardCopyOption.REPLACE_EXISTING));
+    }
+
+    StoneSkinSettings(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 StoneSkin.Settings settings() { return parse(effectiveValues); }
+
+    /** Publish only after the caller returns the durable acknowledgment to the server thread. */
+    public synchronized void publish(Update update) {
+        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("Stone Skin 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 {
+            return new java.math.BigDecimal(raw).stripTrailingZeros().toPlainString();
+        } catch (NumberFormatException invalid) { throw new IllegalArgumentException("Invalid value", invalid); }
+    }
+
+    public static StoneSkin.Settings parse(Map<String, String> values) {
+        try {
+            var cooldown = seconds(values.get(COOLDOWN));
+            var duration = seconds(values.get(DURATION));
+            var reduction = new java.math.BigDecimal(values.get(REDUCTION));
+            return new StoneSkin.Settings(cooldown, duration, reduction);
+        } catch (ArithmeticException | NumberFormatException | NullPointerException invalid) {
+            throw new IllegalArgumentException("Stone Skin 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

@@ -30,6 +30,8 @@ public final class EquipmentAdminCommand implements TabExecutor, AutoCloseable {
     private games.dmg.fantasystick.ability.Quickstep quickstep;
     private games.dmg.fantasystick.persistence.SecondWindSettings secondWindSettings;
     private games.dmg.fantasystick.ability.SecondWind secondWind;
+    private games.dmg.fantasystick.persistence.StoneSkinSettings stoneSkinSettings;
+    private games.dmg.fantasystick.ability.StoneSkin stoneSkin;
 
     public EquipmentAdminCommand(EquipmentSessionStore receipts, EquipmentSessions sessions, Server server,
                                  Consumer<Runnable> nextTick, Consumer<Failure> diagnostics) {
@@ -106,6 +108,26 @@ public final class EquipmentAdminCommand implements TabExecutor, AutoCloseable {
         this.secondWind = Objects.requireNonNull(secondWind);
     }
 
+    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.persistence.StoneSkinSettings stoneSkinSettings,
+                                 games.dmg.fantasystick.ability.StoneSkin stoneSkin,
+                                 games.dmg.fantasystick.ability.AbilityRegistry abilities) {
+        this(receipts, sessions, server, nextTick, diagnostics, settings, frostSettings, frostShard,
+            longbowSettings, longbow, quickstepSettings, quickstep, secondWindSettings, secondWind, abilities);
+        this.stoneSkinSettings = Objects.requireNonNull(stoneSkinSettings);
+        this.stoneSkin = Objects.requireNonNull(stoneSkin);
+    }
+
     @Override public boolean onCommand(CommandSender sender, Command command, String label, String[] args) {
         if (closed) return true;
         if (!sender.hasPermission(PERMISSION)) {
@@ -188,6 +210,9 @@ public final class EquipmentAdminCommand implements TabExecutor, AutoCloseable {
         if (secondWindSettings != null && games.dmg.fantasystick.persistence.SecondWindSettings.keys().contains(args[1])) {
             secondWindConfiguration(sender, args); return;
         }
+        if (stoneSkinSettings != null && games.dmg.fantasystick.persistence.StoneSkinSettings.keys().contains(args[1])) {
+            stoneSkinConfiguration(sender, args); return;
+        }
         if (frostSettings == null || !games.dmg.fantasystick.persistence.FrostShardSettings.keys().contains(args[1])) {
             configurationUsage(sender); return;
         }
@@ -285,6 +310,31 @@ public final class EquipmentAdminCommand implements TabExecutor, AutoCloseable {
         });
     }
 
+    private void stoneSkinConfiguration(CommandSender sender, String[] args) {
+        String key = args[1];
+        if (args.length == 2) {
+            sender.sendMessage(key + "=" + stoneSkinSettings.value(key) + " (applies to future Stone Skin casts only)"); return;
+        }
+        java.util.concurrent.CompletionStage<games.dmg.fantasystick.persistence.StoneSkinSettings.Update> operation;
+        try { operation = stoneSkinSettings.set(key, args[2]); }
+        catch (IllegalArgumentException invalid) { sender.sendMessage("Stone Skin 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) {
+                    stoneSkin.configure(saved.settings()); abilities.replace(stoneSkin.definition()); stoneSkinSettings.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 Stone Skin casts; active effects and deadlines are unchanged."
+                    : "Stone Skin configuration save failed; the effective setting is unchanged.");
+            }); } catch (RuntimeException rejected) { report(null, "config-response", rejected); }
+        });
+    }
+
     private void secondWindConfiguration(CommandSender sender, String[] args) {
         String key = args[1];
         if (args.length == 2) {
@@ -358,6 +408,7 @@ public final class EquipmentAdminCommand implements TabExecutor, AutoCloseable {
             keys.addAll(games.dmg.fantasystick.persistence.LongbowSettings.keys());
             keys.addAll(games.dmg.fantasystick.persistence.QuickstepSettings.keys());
             keys.addAll(games.dmg.fantasystick.persistence.SecondWindSettings.keys());
+            keys.addAll(games.dmg.fantasystick.persistence.StoneSkinSettings.keys());
             return matching(keys, args[1]);
         }
         if (args.length == 3 && args[0].equals("config")) {
@@ -382,6 +433,11 @@ public final class EquipmentAdminCommand implements TabExecutor, AutoCloseable {
                 String defaults = games.dmg.fantasystick.persistence.SecondWindSettings.defaultValue(args[1]);
                 return matching(current.equals(defaults) ? List.of(current) : List.of(current, defaults), args[2]);
             }
+            if (stoneSkinSettings != null && games.dmg.fantasystick.persistence.StoneSkinSettings.keys().contains(args[1])) {
+                String current = stoneSkinSettings.value(args[1]);
+                String defaults = games.dmg.fantasystick.persistence.StoneSkinSettings.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

@@ -56,3 +56,9 @@ quickstep-speed-blocks-per-tick: 1
 # Admin command: /fantasystick config <key> [value]
 second-wind-base-healing: 6
 second-wind-cooldown-seconds: 15
+
+# Stone Skin defaults from the reviewed remaining-development packet.
+# Admin command: /fantasystick config <key> [value]
+stone-skin-cooldown-seconds: 14
+stone-skin-duration-seconds: 4
+stone-skin-damage-reduction-percent: 25

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

@@ -0,0 +1,294 @@
+package games.dmg.fantasystick;
+
+import static org.junit.jupiter.api.Assertions.*;
+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.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.EntityDamageByEntityEvent;
+import org.bukkit.event.entity.EntityDamageEvent;
+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 StoneSkinNativeTest {
+    @TempDir Path data;
+    @BeforeAll static void bootstrap() throws Exception { NativeRuntime.bootstrap(); }
+
+    @Test void bookAcquisitionEquippedUseReducesNativeEntityDamageForFourSeconds() throws Exception {
+        try (var f = new FantasyStickLifecycleNativeTest.Fixture(data)) {
+            f.plugin.setEnabled(true);
+            var a = new FantasyStickLifecycleNativeTest.Actor(data); withStoneSkin(data, a, false);
+            f.players.put(a.core.id, a.player); f.activate(a);
+            a.core.inventory.getInventory().setSelectedSlot(0); PartyBookNativeTest.open(f, a);
+            String text = PartyBookNativeTest.text(a).replaceAll("\\s+", "");
+            assertTrue(text.contains("StoneSkin")); assertTrue(text.contains("CON14"));
+            assertTrue(text.contains("Cost:1")); assertTrue(text.contains("25%")); assertTrue(text.contains("4s"));
+            PartyBookNativeTest.click(f, a, abilityButton(a, "[Learn]", "stone_skin"));
+            PartyBookNativeTest.drain(f); PartyBookNativeTest.drain(f);
+            PartyBookNativeTest.click(f, a, abilityButton(a, "[3]", "stone_skin"));
+            PartyBookNativeTest.drain(f); PartyBookNativeTest.drain(f);
+            var storage = (CharacterStorage) FantasyStickLifecycleNativeTest.Fixture.field(f.plugin, "characters");
+            assertEquals(BigInteger.valueOf(39), storage.find(a.core.record.id()).get().orElseThrow().unspentPoints());
+            use(f, a); PartyBookNativeTest.drain(f); PartyBookNativeTest.drain(f);
+            assertNotNull(storage.find(a.core.record.id()).get().orElseThrow().cooldowns().get("stone_skin"));
+            var attacker = mock(org.bukkit.entity.Zombie.class);
+            var hit = new EntityDamageByEntityEvent(attacker, a.player,
+                EntityDamageEvent.DamageCause.ENTITY_ATTACK, mock(org.bukkit.damage.DamageSource.class), 8);
+            f.dispatcher.accept(hit); assertEquals(6, hit.getDamage(), 1.0e-9);
+            assertEquals(80L, f.delayedTicks.getLast());
+            f.delayed.getLast().run();
+            var expired = new EntityDamageByEntityEvent(attacker, a.player,
+                EntityDamageEvent.DamageCause.ENTITY_ATTACK, mock(org.bukkit.damage.DamageSource.class), 8);
+            f.dispatcher.accept(expired); assertEquals(8, expired.getDamage(), 1.0e-9);
+            var deadline = storage.find(a.core.record.id()).get().orElseThrow().cooldowns().get("stone_skin");
+            a.core.inventory.getInventory().setSelectedSlot(0); PartyBookNativeTest.open(f, a);
+            var unlearn = abilityButton(a, "[Unlearn]", "stone_skin");
+            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(deadline, refunded.cooldowns().get("stone_skin"));
+            a.core.inventory.getInventory().setSelectedSlot(0); PartyBookNativeTest.open(f, a);
+            PartyBookNativeTest.click(f, a, abilityButton(a, "[Learn]", "stone_skin"));
+            PartyBookNativeTest.drain(f); PartyBookNativeTest.drain(f);
+            PartyBookNativeTest.click(f, a, abilityButton(a, "[3]", "stone_skin"));
+            PartyBookNativeTest.drain(f); PartyBookNativeTest.drain(f); use(f, a);
+            assertTrue(a.messages.stream().anyMatch(message -> message.contains("ready in")));
+        }
+    }
+
+    @Test void environmentalAndCancelledDamageRemainUntouchedWhileProjectileCombatIsReduced() throws Exception {
+        try (var f = new FantasyStickLifecycleNativeTest.Fixture(data)) {
+            f.plugin.setEnabled(true);
+            var a = new FantasyStickLifecycleNativeTest.Actor(data); withStoneSkin(data, a, true);
+            f.players.put(a.core.id, a.player); f.activate(a); use(f, a);
+            PartyBookNativeTest.drain(f); PartyBookNativeTest.drain(f);
+            var fall = new EntityDamageEvent(a.player, EntityDamageEvent.DamageCause.FALL,
+                mock(org.bukkit.damage.DamageSource.class), 8);
+            f.dispatcher.accept(fall); assertEquals(8, fall.getDamage(), 1.0e-9);
+            var arrow = mock(org.bukkit.entity.Arrow.class);
+            var projectile = new EntityDamageByEntityEvent(arrow, a.player,
+                EntityDamageEvent.DamageCause.PROJECTILE, mock(org.bukkit.damage.DamageSource.class), 8);
+            f.dispatcher.accept(projectile); assertEquals(6, projectile.getDamage(), 1.0e-9);
+            class Veto implements org.bukkit.event.Listener {
+                @org.bukkit.event.EventHandler(priority = org.bukkit.event.EventPriority.LOWEST)
+                public void veto(EntityDamageByEntityEvent event) { event.setCancelled(true); }
+            }
+            f.dispatcher.register(new Veto(), f.plugin);
+            var cancelled = new EntityDamageByEntityEvent(mock(org.bukkit.entity.Zombie.class), a.player,
+                EntityDamageEvent.DamageCause.ENTITY_ATTACK, mock(org.bukkit.damage.DamageSource.class), 8);
+            f.dispatcher.accept(cancelled); assertTrue(cancelled.isCancelled()); assertEquals(8, cancelled.getDamage(), 1.0e-9);
+        }
+    }
+
+    @Test void replacementExpirySessionExitAndTransferRemoveOnlyOwnedReductionAndRetainDeadline() throws Exception {
+        java.nio.file.Files.writeString(data.resolve("config.yml"),
+            "stone-skin-cooldown-seconds: 0\nstone-skin-duration-seconds: 4\nstone-skin-damage-reduction-percent: 25\n");
+        try (var f = new FantasyStickLifecycleNativeTest.Fixture(data)) {
+            f.plugin.setEnabled(true);
+            var a = new FantasyStickLifecycleNativeTest.Actor(data); withStoneSkin(data, a, true);
+            f.players.put(a.core.id, a.player); f.activate(a); use(f, a); PartyBookNativeTest.drain(f); PartyBookNativeTest.drain(f);
+            use(f, a); PartyBookNativeTest.drain(f); PartyBookNativeTest.drain(f);
+            assertEquals(2, f.delayed.size());
+            f.delayed.getFirst().run();
+            assertEquals(6, hit(f, a, 8).getDamage(), 1.0e-9, "Old expiry cannot remove replacement protection");
+            f.delayed.getLast().run();
+            assertEquals(8, hit(f, a, 8).getDamage(), 1.0e-9);
+            use(f, a); PartyBookNativeTest.drain(f); PartyBookNativeTest.drain(f);
+            var storage = (CharacterStorage) FantasyStickLifecycleNativeTest.Fixture.field(f.plugin, "characters");
+            var deadline = storage.find(a.core.record.id()).get().orElseThrow().cooldowns().get("stone_skin");
+            var sheet = a.core.inventory.getItemInOffHand().clone();
+            a.core.inventory.setItemInOffHand(null); f.changed(a); PartyBookNativeTest.drain(f); f.awaitCharacterAndReceipt(a);
+            assertEquals(8, hit(f, a, 8).getDamage(), 1.0e-9, "Exit clears owned reduction");
+            assertEquals(deadline, storage.find(a.core.record.id()).get().orElseThrow().cooldowns().get("stone_skin"));
+            var b = new FantasyStickLifecycleNativeTest.Actor(data); b.core.inventory.setItemInOffHand(sheet);
+            f.players.put(b.core.id, b.player); f.activate(b);
+            assertEquals(deadline, storage.find(a.core.record.id()).get().orElseThrow().cooldowns().get("stone_skin"));
+        }
+    }
+
+    @Test void acknowledgedConfigurationAffectsFutureCastsWhileActiveProtectionKeepsSnapshot() throws Exception {
+        java.nio.file.Files.writeString(data.resolve("config.yml"),
+            "stone-skin-cooldown-seconds: 0\nstone-skin-duration-seconds: 4\nstone-skin-damage-reduction-percent: 25\n");
+        try (var f = new FantasyStickLifecycleNativeTest.Fixture(data)) {
+            f.plugin.setEnabled(true);
+            var a = new FantasyStickLifecycleNativeTest.Actor(data); withStoneSkin(data, a, true);
+            f.players.put(a.core.id, a.player); f.activate(a); use(f, a); PartyBookNativeTest.drain(f); PartyBookNativeTest.drain(f);
+            var sender = new EquipmentAdminCommandNativeTest.Sender();
+            f.command.execute(sender.port, "fantasystick", new String[]{"config", "stone-skin-duration-seconds", "6"});
+            f.command.execute(sender.port, "fantasystick", new String[]{"config", "stone-skin-damage-reduction-percent", "50"});
+            for (int i = 0; i < 2; i++) { var response = f.tasks.poll(5, java.util.concurrent.TimeUnit.SECONDS); assertNotNull(response); response.run(); }
+            assertEquals(6, hit(f, a, 8).getDamage(), 1.0e-9, "Active cast retains captured 25 percent");
+            assertEquals(80L, f.delayedTicks.getFirst());
+            var b = new FantasyStickLifecycleNativeTest.Actor(data); withStoneSkin(data, b, true);
+            f.players.put(b.core.id, b.player); f.activate(b); use(f, b); PartyBookNativeTest.drain(f); PartyBookNativeTest.drain(f);
+            assertEquals(4, hit(f, b, 8).getDamage(), 1.0e-9); assertEquals(120L, f.delayedTicks.getLast());
+        }
+    }
+
+    @Test void acceptedDamageReportsExactPreventionWhileCancelledDamageReportsNothing() {
+        var mitigation = new games.dmg.fantasystick.ability.CombatMitigation();
+        var stone = new games.dmg.fantasystick.ability.StoneSkin(
+            games.dmg.fantasystick.ability.StoneSkin.Settings.defaults(), mitigation);
+        var execution = mock(games.dmg.fantasystick.ability.AbilityExecution.class);
+        var input = mock(games.dmg.fantasystick.session.ControlInput.class);
+        var player = mock(org.bukkit.entity.Player.class); var id = java.util.UUID.randomUUID();
+        when(player.getUniqueId()).thenReturn(id); when(input.player()).thenReturn(player);
+        when(execution.input()).thenReturn(input); when(execution.definition()).thenReturn(stone.definition());
+        when(execution.stillCurrent()).thenReturn(true);
+        stone.activate(execution);
+        var weaker = mock(games.dmg.fantasystick.ability.AbilityExecution.class);
+        when(weaker.stillCurrent()).thenReturn(true);
+        var unrelated = mitigation.grant(weaker, player, new java.math.BigDecimal("20"));
+        var accepted = new EntityDamageByEntityEvent(mock(org.bukkit.entity.Zombie.class), player,
+            EntityDamageEvent.DamageCause.ENTITY_ATTACK, mock(org.bukkit.damage.DamageSource.class), 8);
+        mitigation.reduce(accepted); mitigation.accepted(accepted);
+        verify(execution).report(games.dmg.fantasystick.ability.AbilityReport.Type.PREVENTION,
+            player, new java.math.BigDecimal("2.0"));
+        var cancelled = new EntityDamageByEntityEvent(mock(org.bukkit.entity.Zombie.class), player,
+            EntityDamageEvent.DamageCause.ENTITY_ATTACK, mock(org.bukkit.damage.DamageSource.class), 8);
+        mitigation.reduce(cancelled); cancelled.setCancelled(true); mitigation.accepted(cancelled);
+        verify(execution, times(1)).report(any(), any(), any());
+        verify(weaker, never()).report(any(), any(), any());
+        try { unrelated.close(); } catch (Exception failure) { fail(failure); }
+        stone.close(); mitigation.close();
+    }
+
+    @Test void failedCooldownPersistenceCreatesNoReduction() {
+        var storage = mock(CharacterStorage.class);
+        var sessions = mock(games.dmg.fantasystick.session.EquipmentSessions.class);
+        var parties = new games.dmg.fantasystick.party.PartyRoster(java.time.Clock.systemUTC(), ignored -> true);
+        var registry = new games.dmg.fantasystick.ability.AbilityRegistry();
+        var mitigation = new games.dmg.fantasystick.ability.CombatMitigation();
+        var stone = new games.dmg.fantasystick.ability.StoneSkin(
+            games.dmg.fantasystick.ability.StoneSkin.Settings.defaults(), mitigation); registry.register(stone.definition());
+        var base = new games.dmg.fantasystick.crafting.CharacterFactory().create(
+            games.dmg.fantasystick.progression.ProgressionRules.defaults());
+        var stats = new EnumMap<>(base.stats()); stats.put(Stat.CON, BigInteger.valueOf(14));
+        var record = new CharacterRecord(base.id(), base.name(), base.revision(), stats, base.level(), base.experience(),
+            base.unspentPoints(), base.health(), java.util.Set.of("stone_skin"),
+            List.of("stone_skin", "", "", "", "", "", ""), base.cooldowns(), base.restrictedKills(), false, null, null);
+        var active = new games.dmg.fantasystick.session.EquipmentSessions.Active(java.util.UUID.randomUUID(),
+            java.util.UUID.randomUUID(), record.id());
+        var player = mock(org.bukkit.entity.Player.class); when(player.getUniqueId()).thenReturn(active.player());
+        when(sessions.current(active)).thenReturn(true); when(sessions.currentRecord(active)).thenReturn(java.util.Optional.of(record));
+        var failed = new java.util.concurrent.CompletableFuture<CharacterStorage.AbilityMutation>();
+        failed.completeExceptionally(new java.io.IOException("simulated cooldown save failure"));
+        when(storage.commitAbilityCooldown(eq(record.id()), eq(record.revision()), eq("stone_skin"), any())).thenReturn(failed);
+        var failures = new java.util.ArrayList<games.dmg.fantasystick.ability.AbilityEngine.Failure>();
+        var engine = new games.dmg.fantasystick.ability.AbilityEngine(registry, storage, sessions, parties,
+            java.time.Clock.systemUTC(), Runnable::run, (delay, action) -> () -> {}, ignored -> {}, failures::add);
+        engine.accept(new games.dmg.fantasystick.session.ControlInput(player, active, 2, "stone_skin",
+            games.dmg.fantasystick.session.ControlInput.Kind.ABILITY,
+            games.dmg.fantasystick.session.ControlInput.Gesture.USE, null, 0, 0, () -> true));
+        var hit = new EntityDamageByEntityEvent(mock(org.bukkit.entity.Zombie.class), player,
+            EntityDamageEvent.DamageCause.ENTITY_ATTACK, mock(org.bukkit.damage.DamageSource.class), 8);
+        mitigation.reduce(hit); assertEquals(8, hit.getDamage(), 1.0e-9);
+        verify(storage).commitAbilityCooldown(eq(record.id()), eq(record.revision()), eq("stone_skin"), any());
+        engine.close(); stone.close(); mitigation.close(); parties.close();
+    }
+
+    @Test void configuredDefinitionAdminRoutesAndStartupValidationCoverEverySetting() throws Exception {
+        java.nio.file.Files.writeString(data.resolve("config.yml"),
+            "stone-skin-cooldown-seconds: 2\nstone-skin-duration-seconds: 6\nstone-skin-damage-reduction-percent: 40\n");
+        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("stone_skin").orElseThrow();
+            assertEquals(java.time.Duration.ofSeconds(2), definition.cooldown());
+            assertEquals(0, new java.math.BigDecimal("6").compareTo(definition.parameters().get("duration-seconds")));
+            assertEquals(0, new java.math.BigDecimal("40").compareTo(definition.parameters().get("damage-reduction-percent")));
+            var sender = new EquipmentAdminCommandNativeTest.Sender(); sender.allowed = false;
+            assertTrue(f.command.tabComplete(sender.port, "fantasystick", new String[]{"config", "stone-skin"}).isEmpty());
+            f.command.execute(sender.port, "fantasystick", new String[]{"config", "stone-skin-duration-seconds", "7"});
+            assertTrue(sender.messages.getLast().contains("Permission denied")); sender.allowed = true;
+            assertEquals(List.of("stone-skin-cooldown-seconds", "stone-skin-damage-reduction-percent", "stone-skin-duration-seconds"),
+                f.command.tabComplete(sender.port, "fantasystick", new String[]{"config", "stone-skin-"}));
+            assertEquals(List.of("4", "6"), f.command.tabComplete(sender.port, "fantasystick",
+                new String[]{"config", "stone-skin-duration-seconds", ""}));
+            f.command.execute(sender.port, "fantasystick", new String[]{"config", "stone-skin-duration-seconds"});
+            assertTrue(sender.messages.getLast().contains("=6"));
+            f.command.execute(sender.port, "fantasystick", new String[]{"config", "stone-skin-duration-seconds", "7"});
+            var response = f.tasks.poll(5, java.util.concurrent.TimeUnit.SECONDS); assertNotNull(response); response.run();
+            assertEquals(0, new java.math.BigDecimal("7").compareTo(
+                registry.find("stone_skin").orElseThrow().parameters().get("duration-seconds")));
+            f.command.execute(sender.port, "fantasystick", new String[]{"config", "stone-skin-duration-seconds", "-1"});
+            assertTrue(sender.messages.getLast().contains("invalid"));
+            f.command.execute(sender.port, "fantasystick", new String[]{"config", "stone-skin-duration-seconds", "7", "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(0, new java.math.BigDecimal("7").compareTo(
+                reloaded.find("stone_skin").orElseThrow().parameters().get("duration-seconds")));
+        }
+        for (String invalid : List.of("stone-skin-cooldown-seconds: -1\n",
+                "stone-skin-duration-seconds: 0\n", "stone-skin-damage-reduction-percent: 101\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 EntityDamageByEntityEvent hit(FantasyStickLifecycleNativeTest.Fixture fixture,
+                                                  FantasyStickLifecycleNativeTest.Actor target, double amount) {
+        var event = new EntityDamageByEntityEvent(mock(org.bukkit.entity.Zombie.class), target.player,
+            EntityDamageEvent.DamageCause.ENTITY_ATTACK, mock(org.bukkit.damage.DamageSource.class), amount);
+        fixture.dispatcher.accept(event); return event;
+    }
+
+    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;
+        }
+        fail("Missing " + label + " for " + ability); return null;
+    }
+    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 withStoneSkin(Path data, FantasyStickLifecycleNativeTest.Actor actor,
+                                      boolean learned) 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(14));
+        repository.replace(new CharacterRecord(old.id(), old.name(), old.revision().add(BigInteger.ONE), stats,
+            old.level(), old.experience(), BigInteger.valueOf(learned ? 39 : 40), old.health(),
+            learned ? java.util.Set.of("stone_skin") : old.learned(),
+            learned ? List.of("stone_skin", "", "", "", "", "", "") : old.loadout(),
+            old.cooldowns(), old.restrictedKills(), false, null, null), old.revision());
+    }
+}

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

@@ -64,6 +64,10 @@ class DistributionTest {
                     "second-wind-cooldown-seconds: 15")) {
                 assertTrue(defaults.contains(setting), "Missing packaged Second Wind default: " + setting);
             }
+            for (String setting : java.util.List.of("stone-skin-cooldown-seconds: 14",
+                    "stone-skin-duration-seconds: 4", "stone-skin-damage-reduction-percent: 25")) {
+                assertTrue(defaults.contains(setting), "Missing packaged Stone Skin 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/StoneSkinSettingsTest.java

@@ -0,0 +1,69 @@
+package games.dmg.fantasystick.persistence;
+
+import static org.junit.jupiter.api.Assertions.*;
+import java.nio.file.*;
+import java.util.*;
+import java.util.concurrent.TimeUnit;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.io.TempDir;
+
+class StoneSkinSettingsTest {
+    @TempDir Path data;
+
+    @Test void serializesConcurrentKeysPreservesUnrelatedAndPublishesAcknowledgedSnapshots() throws Exception {
+        Files.writeString(data.resolve("config.yml"), "unrelated: retained\n");
+        try (var settings = new StoneSkinSettings(data, defaults())) {
+            var duration = settings.set(StoneSkinSettings.DURATION, "6").toCompletableFuture();
+            var reduction = settings.set(StoneSkinSettings.REDUCTION, "40").toCompletableFuture();
+            var d = duration.get(5, TimeUnit.SECONDS); var r = reduction.get(5, TimeUnit.SECONDS);
+            assertEquals(java.time.Duration.ofSeconds(4), settings.settings().duration());
+            settings.publish(r); settings.publish(d);
+            assertEquals(java.time.Duration.ofSeconds(6), settings.settings().duration());
+            assertEquals(0, new java.math.BigDecimal("40").compareTo(settings.settings().reductionPercent()));
+            var saved = (Map<?, ?>) new org.yaml.snakeyaml.Yaml().load(Files.readString(data.resolve("config.yml")));
+            assertEquals("retained", saved.get("unrelated"));
+            assertEquals("6", String.valueOf(saved.get(StoneSkinSettings.DURATION)));
+            assertEquals("40", String.valueOf(saved.get(StoneSkinSettings.REDUCTION)));
+        }
+    }
+
+    @Test void rejectsInvalidValuesAndFailedReplacementRetainsState() throws Exception {
+        try (var settings = new StoneSkinSettings(data, defaults())) {
+            for (var entry : Map.of(StoneSkinSettings.COOLDOWN, "-1", StoneSkinSettings.DURATION, "0",
+                    StoneSkinSettings.REDUCTION, "101").entrySet())
+                assertThrows(IllegalArgumentException.class, () -> settings.set(entry.getKey(), entry.getValue()));
+            assertThrows(IllegalArgumentException.class, () -> settings.set(StoneSkinSettings.DURATION, "0.0000000001"));
+        }
+        var fail = new java.util.concurrent.atomic.AtomicBoolean(true);
+        try (var settings = new StoneSkinSettings(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(StoneSkinSettings.DURATION, "6").toCompletableFuture().get(5, TimeUnit.SECONDS));
+            assertEquals("4", settings.value(StoneSkinSettings.DURATION));
+        }
+    }
+
+    @Test void unsafeFileAndClosedStoreFailSafely() 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 StoneSkinSettings(data, defaults())) {
+                assertThrows(java.util.concurrent.ExecutionException.class, () ->
+                    settings.set(StoneSkinSettings.DURATION, "6").toCompletableFuture().get(5, TimeUnit.SECONDS));
+                assertEquals("safe\n", Files.readString(external));
+            }
+        }
+        var directory = data.resolve("closed"); var settings = new StoneSkinSettings(directory, defaults()); settings.close();
+        assertThrows(java.util.concurrent.ExecutionException.class, () ->
+            settings.set(StoneSkinSettings.DURATION, "6").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 : StoneSkinSettings.keys()) result.put(key, StoneSkinSettings.defaultValue(key));
+        return result;
+    }
+}