From 9950250084ea01ca7a9a6663a9adb8cb533aea3e Mon Sep 17 00:00:00 2001
From: Angel Ramirez <angel-krak@hotmail.com>
Date: Mon, 29 Jun 2026 13:52:00 -0600
Subject: [PATCH 1/3] feat: NPC summon system, K.O. improvements, and bug fixes

---
 .idea/ReanimateMC.iml                         |    1 +
 .idea/jarRepositories.xml                     |   48 +-
 pom.xml                                       |   53 +-
 .../fr/jachou/reanimatemc/ReanimateMC.java    |   40 +-
 .../reanimatemc/api/NPCDismissedEvent.java    |   35 +
 .../reanimatemc/api/NPCSummonedEvent.java     |   33 +
 .../reanimatemc/behavior/GolemBehavior.java   |   86 ++
 .../reanimatemc/behavior/HealerBehavior.java  |  342 ++++++
 .../reanimatemc/behavior/NPCBehavior.java     |   83 ++
 .../behavior/ProtectorBehavior.java           |  131 +++
 .../commands/ReanimateMCCommand.java          |  579 +++++----
 .../fr/jachou/reanimatemc/data/KOData.java    |   30 +-
 .../reanimatemc/data/ReanimatorNPC.java       |  180 ++-
 .../fr/jachou/reanimatemc/gui/ConfigGUI.java  |   58 +-
 .../reanimatemc/hooks/PlaceholderHook.java    |   89 ++
 .../jachou/reanimatemc/hooks/VaultHook.java   |   61 +
 .../listeners/ExecutionListener.java          |   24 +-
 .../reanimatemc/listeners/GolemManager.java   |   53 +-
 .../listeners/KOProtectionListener.java       |   70 ++
 .../listeners/NPCDamageListener.java          |  109 ++
 .../listeners/PlayerDamageListener.java       |   68 +-
 .../listeners/PlayerKOListener.java           |  279 ++++-
 .../listeners/ReanimationListener.java        |   22 +-
 .../reanimatemc/managers/KOManager.java       |  417 ++++++-
 .../managers/NPCPersistenceManager.java       |  139 +++
 .../managers/NPCSummonManager.java            | 1032 ++++++++++++-----
 .../fr/jachou/reanimatemc/utils/Lang.java     |   56 +-
 src/main/resources/config.yml                 |  263 ++++-
 src/main/resources/lang/en.yml                |  108 +-
 src/main/resources/lang/es.yml                |  149 ++-
 src/main/resources/lang/kr.yml                |    3 +-
 src/main/resources/lang/pt.yml                |    3 +-
 src/main/resources/plugin.yml                 |   92 +-
 33 files changed, 3997 insertions(+), 739 deletions(-)
 create mode 100644 src/main/java/fr/jachou/reanimatemc/api/NPCDismissedEvent.java
 create mode 100644 src/main/java/fr/jachou/reanimatemc/api/NPCSummonedEvent.java
 create mode 100644 src/main/java/fr/jachou/reanimatemc/behavior/GolemBehavior.java
 create mode 100644 src/main/java/fr/jachou/reanimatemc/behavior/HealerBehavior.java
 create mode 100644 src/main/java/fr/jachou/reanimatemc/behavior/NPCBehavior.java
 create mode 100644 src/main/java/fr/jachou/reanimatemc/behavior/ProtectorBehavior.java
 create mode 100644 src/main/java/fr/jachou/reanimatemc/hooks/PlaceholderHook.java
 create mode 100644 src/main/java/fr/jachou/reanimatemc/hooks/VaultHook.java
 create mode 100644 src/main/java/fr/jachou/reanimatemc/listeners/KOProtectionListener.java
 create mode 100644 src/main/java/fr/jachou/reanimatemc/listeners/NPCDamageListener.java
 create mode 100644 src/main/java/fr/jachou/reanimatemc/managers/NPCPersistenceManager.java

diff --git a/.idea/ReanimateMC.iml b/.idea/ReanimateMC.iml
index 3cf00db..bbeeb3e 100644
--- a/.idea/ReanimateMC.iml
+++ b/.idea/ReanimateMC.iml
@@ -5,6 +5,7 @@
       <configuration>
         <autoDetectTypes>
           <platformType>PAPER</platformType>
+          <platformType>ADVENTURE</platformType>
         </autoDetectTypes>
         <projectReimportVersion>1</projectReimportVersion>
       </configuration>
diff --git a/.idea/jarRepositories.xml b/.idea/jarRepositories.xml
index dfa4d4a..a264e1a 100644
--- a/.idea/jarRepositories.xml
+++ b/.idea/jarRepositories.xml
@@ -11,35 +11,25 @@
       <option name="name" value="sonatype" />
       <option name="url" value="https://oss.sonatype.org/content/groups/public/" />
     </remote-repository>
-    <remote-repository>
-      <option name="id" value="spigotmc-repo" />
-      <option name="name" value="spigotmc-repo" />
-      <option name="url" value="https://hub.spigotmc.org/nexus/content/repositories/public/" />
-    </remote-repository>
-    <remote-repository>
-      <option name="id" value="spigotmc-repo" />
-      <option name="name" value="spigotmc-repo" />
-      <option name="url" value="https://hub.spigotmc.org/nexus/content/repositories/snapshots/" />
-    </remote-repository>
     <remote-repository>
       <option name="id" value="github" />
       <option name="name" value="github" />
       <option name="url" value="https://maven.pkg.github.com/Weedev-Fr/WeedevAPI-Java" />
     </remote-repository>
     <remote-repository>
-      <option name="id" value="central" />
-      <option name="name" value="Maven Central repository" />
-      <option name="url" value="https://repo1.maven.org/maven2" />
+      <option name="id" value="jitpack" />
+      <option name="name" value="jitpack" />
+      <option name="url" value="https://jitpack.io" />
     </remote-repository>
     <remote-repository>
-      <option name="id" value="jboss.community" />
-      <option name="name" value="JBoss Community repository" />
-      <option name="url" value="https://repository.jboss.org/nexus/content/repositories/public/" />
+      <option name="id" value="placeholderapi" />
+      <option name="name" value="placeholderapi" />
+      <option name="url" value="https://repo.extendedclip.com/content/repositories/placeholderapi/" />
     </remote-repository>
     <remote-repository>
-      <option name="id" value="sonatype" />
-      <option name="name" value="sonatype" />
-      <option name="url" value="https://oss.sonatype.org/content/repositories/snapshots/" />
+      <option name="id" value="central" />
+      <option name="name" value="Maven Central repository" />
+      <option name="url" value="https://repo1.maven.org/maven2" />
     </remote-repository>
     <remote-repository>
       <option name="id" value="minecraft-libraries" />
@@ -56,5 +46,25 @@
       <option name="name" value="papermc" />
       <option name="url" value="https://repo.papermc.io/repository/maven-public/" />
     </remote-repository>
+    <remote-repository>
+      <option name="id" value="spigotmc-repo" />
+      <option name="name" value="spigotmc-repo" />
+      <option name="url" value="https://hub.spigotmc.org/nexus/content/repositories/public/" />
+    </remote-repository>
+    <remote-repository>
+      <option name="id" value="spigotmc-repo" />
+      <option name="name" value="spigotmc-repo" />
+      <option name="url" value="https://hub.spigotmc.org/nexus/content/repositories/snapshots/" />
+    </remote-repository>
+    <remote-repository>
+      <option name="id" value="jboss.community" />
+      <option name="name" value="JBoss Community repository" />
+      <option name="url" value="https://repository.jboss.org/nexus/content/repositories/public/" />
+    </remote-repository>
+    <remote-repository>
+      <option name="id" value="sonatype" />
+      <option name="name" value="sonatype" />
+      <option name="url" value="https://oss.sonatype.org/content/repositories/snapshots/" />
+    </remote-repository>
   </component>
 </project>
\ No newline at end of file
diff --git a/pom.xml b/pom.xml
index 2fa70e5..d037ab2 100644
--- a/pom.xml
+++ b/pom.xml
@@ -6,11 +6,11 @@
 
     <groupId>fr.jachou</groupId>
     <artifactId>ReanimateMC</artifactId>
-    <version>1.2.11</version>
+    <version>1.2.13</version>
     <packaging>jar</packaging>
 
     <properties>
-        <java.version>24</java.version>
+        <java.version>17</java.version>
         <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
     </properties>
 
@@ -19,27 +19,72 @@
             <id>papermc</id>
             <url>https://repo.papermc.io/repository/maven-public/</url>
         </repository>
+        <repository>
+            <id>jitpack</id>
+            <url>https://jitpack.io</url>
+        </repository>
+        <repository>
+            <id>placeholderapi</id>
+            <url>https://repo.extendedclip.com/content/repositories/placeholderapi/</url>
+        </repository>
     </repositories>
 
     <dependencies>
+        <!-- Paper API -->
         <dependency>
             <groupId>io.papermc.paper</groupId>
             <artifactId>paper-api</artifactId>
             <version>1.21.4-R0.1-SNAPSHOT</version>
             <scope>provided</scope>
         </dependency>
+
+        <!-- Vault (economy abstraction) -->
+        <dependency>
+            <groupId>com.github.MilkBowl</groupId>
+            <artifactId>VaultAPI</artifactId>
+            <version>1.7</version>
+            <scope>provided</scope>
+        </dependency>
+
+        <!-- PlaceholderAPI -->
+        <dependency>
+            <groupId>me.clip</groupId>
+            <artifactId>placeholderapi</artifactId>
+            <version>2.11.6</version>
+            <scope>provided</scope>
+        </dependency>
     </dependencies>
 
     <build>
+        <resources>
+            <resource>
+                <directory>src/main/resources</directory>
+                <filtering>true</filtering>
+            </resource>
+        </resources>
         <plugins>
             <plugin>
                 <groupId>org.apache.maven.plugins</groupId>
                 <artifactId>maven-compiler-plugin</artifactId>
-                <version>3.8.1</version>
+                <version>3.13.0</version>
                 <configuration>
                     <release>17</release>
                 </configuration>
             </plugin>
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-shade-plugin</artifactId>
+                <version>3.6.0</version>
+                <executions>
+                    <execution>
+                        <phase>package</phase>
+                        <goals><goal>shade</goal></goals>
+                        <configuration>
+                            <createDependencyReducedPom>false</createDependencyReducedPom>
+                        </configuration>
+                    </execution>
+                </executions>
+            </plugin>
         </plugins>
     </build>
-</project>
\ No newline at end of file
+</project>
diff --git a/src/main/java/fr/jachou/reanimatemc/ReanimateMC.java b/src/main/java/fr/jachou/reanimatemc/ReanimateMC.java
index 9c19418..acd3724 100644
--- a/src/main/java/fr/jachou/reanimatemc/ReanimateMC.java
+++ b/src/main/java/fr/jachou/reanimatemc/ReanimateMC.java
@@ -11,7 +11,10 @@
 import fr.jachou.reanimatemc.commands.ReanimateMCCommand;
 import fr.jachou.reanimatemc.externals.Metrics;
 import fr.jachou.reanimatemc.gui.ConfigGUI;
+import fr.jachou.reanimatemc.hooks.PlaceholderHook;
+import fr.jachou.reanimatemc.hooks.VaultHook;
 import fr.jachou.reanimatemc.listeners.*;
+import fr.jachou.reanimatemc.listeners.NPCDamageListener;
 import fr.jachou.reanimatemc.listeners.SetupReminderListener;
 import fr.jachou.reanimatemc.managers.KOManager;
 import fr.jachou.reanimatemc.managers.NPCSummonManager;
@@ -35,6 +38,7 @@ public final class ReanimateMC extends JavaPlugin {
     private KOManager koManager;
     private StatsManager statsManager;
     private NPCSummonManager npcSummonManager;
+    private VaultHook vault;
     public static Lang lang;
     private ConfigGUI configGui;
     private UpdateNotifier notifier;
@@ -51,6 +55,9 @@ public static ReanimateMC getInstance() {
     public void onEnable() {
         instance = this;
         saveDefaultConfig(); // Création (si nécessaire) du fichier config.yml
+        // Merge any new keys from the bundled config into the existing file on disk
+        getConfig().options().copyDefaults(true);
+        saveConfig();
 
         // Langues
         lang = new Lang(this);
@@ -65,15 +72,26 @@ public void onEnable() {
         // Initialisation du gestionnaire des états K.O.
         koManager = new KOManager(this);
 
+        // Vault hook (soft dependency)
+        vault = new VaultHook(this);
+
         // Initialisation du gestionnaire de NPCs
-        npcSummonManager = new NPCSummonManager(this, koManager);
+        npcSummonManager = new NPCSummonManager(this, koManager, vault);
+
+        // PlaceholderAPI expansion (soft dependency)
+        if (getServer().getPluginManager().getPlugin("PlaceholderAPI") != null) {
+            new PlaceholderHook(this, koManager, npcSummonManager).register();
+            getLogger().info("[ReanimateMC] PlaceholderAPI expansion registered.");
+        }
 
         // Instantiate and register GUI listener
         configGui = new ConfigGUI(this);
         getServer().getPluginManager().registerEvents(configGui, this);
 
         // Enregistrement des écouteurs d’événements
-        getServer().getPluginManager().registerEvents(new PlayerDamageListener(koManager), this);
+        getServer().getPluginManager().registerEvents(new PlayerDamageListener(koManager, npcSummonManager), this);
+        getServer().getPluginManager().registerEvents(new NPCDamageListener(npcSummonManager), this);
+        getServer().getPluginManager().registerEvents(new KOProtectionListener(koManager), this);
         getServer().getPluginManager().registerEvents(new ReanimationListener(koManager), this);
         getServer().getPluginManager().registerEvents(new ExecutionListener(koManager), this);
         getServer().getPluginManager().registerEvents(new LootListener(), this);
@@ -83,8 +101,18 @@ public void onEnable() {
         getServer().getPluginManager().registerEvents(new GolemManager(), this);
 
         // Enregistrement de la commande principale
-        getCommand("reanimatemc").setExecutor(new ReanimateMCCommand(koManager, configGui, npcSummonManager));
-        getCommand("reanimatemc").setTabCompleter(new ReanimateMCCommand(koManager, configGui, npcSummonManager));
+        ReanimateMCCommand commandHandler = new ReanimateMCCommand(koManager, configGui, npcSummonManager);
+        getCommand("reanimatemc").setExecutor(commandHandler);
+        getCommand("reanimatemc").setTabCompleter(commandHandler);
+        // Standalone aliases so /selfrevive and /sr work directly
+        if (getCommand("selfrevive") != null) {
+            getCommand("selfrevive").setExecutor(commandHandler);
+            getCommand("selfrevive").setTabCompleter(commandHandler);
+        }
+        if (getCommand("cancelselfrevive") != null) {
+            getCommand("cancelselfrevive").setExecutor(commandHandler);
+            getCommand("cancelselfrevive").setTabCompleter(commandHandler);
+        }
 
         // Tâche pour vérfier si les joueurs ont l'effet glowing
         new BukkitRunnable() {
@@ -155,4 +183,8 @@ public UpdateNotifier getNotifier() {
     public NPCSummonManager getNpcSummonManager() {
         return npcSummonManager;
     }
+
+    public VaultHook getVault() {
+        return vault;
+    }
 }
diff --git a/src/main/java/fr/jachou/reanimatemc/api/NPCDismissedEvent.java b/src/main/java/fr/jachou/reanimatemc/api/NPCDismissedEvent.java
new file mode 100644
index 0000000..de2439e
--- /dev/null
+++ b/src/main/java/fr/jachou/reanimatemc/api/NPCDismissedEvent.java
@@ -0,0 +1,35 @@
+package fr.jachou.reanimatemc.api;
+
+import fr.jachou.reanimatemc.data.ReanimatorNPC;
+import org.bukkit.entity.Player;
+import org.bukkit.event.Event;
+import org.bukkit.event.HandlerList;
+
+/**
+ * Fired when a reanimator NPC is removed for any reason:
+ * manual dismiss, lifetime expiry, owner offline timeout, or plugin disable.
+ */
+public class NPCDismissedEvent extends Event {
+
+    private static final HandlerList handlers = new HandlerList();
+
+    public enum Reason { MANUAL, EXPIRED, OFFLINE_TIMEOUT, PLUGIN_DISABLE }
+
+    private final Player owner;
+    private final ReanimatorNPC npc;
+    private final Reason reason;
+
+    public NPCDismissedEvent(Player owner, ReanimatorNPC npc, Reason reason) {
+        this.owner  = owner;
+        this.npc    = npc;
+        this.reason = reason;
+    }
+
+    /** May be null if the owner is offline at the time of removal. */
+    public Player getOwner()      { return owner; }
+    public ReanimatorNPC getNpc() { return npc; }
+    public Reason getReason()     { return reason; }
+
+    @Override public HandlerList getHandlers() { return handlers; }
+    public static HandlerList getHandlerList() { return handlers; }
+}
diff --git a/src/main/java/fr/jachou/reanimatemc/api/NPCSummonedEvent.java b/src/main/java/fr/jachou/reanimatemc/api/NPCSummonedEvent.java
new file mode 100644
index 0000000..1bd3b0c
--- /dev/null
+++ b/src/main/java/fr/jachou/reanimatemc/api/NPCSummonedEvent.java
@@ -0,0 +1,33 @@
+package fr.jachou.reanimatemc.api;
+
+import fr.jachou.reanimatemc.data.ReanimatorNPC;
+import org.bukkit.entity.Player;
+import org.bukkit.event.Cancellable;
+import org.bukkit.event.Event;
+import org.bukkit.event.HandlerList;
+
+/**
+ * Fired when a player successfully summons a reanimator NPC.
+ * Cancelling this event prevents the NPC from being registered and spawned.
+ */
+public class NPCSummonedEvent extends Event implements Cancellable {
+
+    private static final HandlerList handlers = new HandlerList();
+
+    private final Player summoner;
+    private final ReanimatorNPC npc;
+    private boolean cancelled = false;
+
+    public NPCSummonedEvent(Player summoner, ReanimatorNPC npc) {
+        this.summoner = summoner;
+        this.npc      = npc;
+    }
+
+    public Player getSummoner()  { return summoner; }
+    public ReanimatorNPC getNpc() { return npc; }
+
+    @Override public boolean isCancelled()              { return cancelled; }
+    @Override public void setCancelled(boolean cancel)  { this.cancelled = cancel; }
+    @Override public HandlerList getHandlers()          { return handlers; }
+    public static HandlerList getHandlerList()          { return handlers; }
+}
diff --git a/src/main/java/fr/jachou/reanimatemc/behavior/GolemBehavior.java b/src/main/java/fr/jachou/reanimatemc/behavior/GolemBehavior.java
new file mode 100644
index 0000000..5ab5a37
--- /dev/null
+++ b/src/main/java/fr/jachou/reanimatemc/behavior/GolemBehavior.java
@@ -0,0 +1,86 @@
+package fr.jachou.reanimatemc.behavior;
+
+import fr.jachou.reanimatemc.ReanimateMC;
+import fr.jachou.reanimatemc.data.ReanimatorNPC;
+import org.bukkit.ChatColor;
+import org.bukkit.Particle;
+import org.bukkit.Sound;
+import org.bukkit.entity.*;
+
+/**
+ * GOLEM — standard reanimator.
+ *
+ * <p>Capabilities:
+ * <ul>
+ *   <li>Follows owner.</li>
+ *   <li>Revives owner when KO.</li>
+ *   <li>Revives explicit targets set via {@code /rmc summon golem <player>}.</li>
+ *   <li>Defends owner: attacks any LivingEntity (players, mobs, etc.) that last
+ *       damaged the owner within {@code golem.combat_radius}.</li>
+ * </ul>
+ *
+ * <p>Does NOT heal HP passively. Does NOT auto-scan for KO'd allies.
+ */
+public class GolemBehavior implements NPCBehavior {
+
+    @Override
+    public void onIdleTick(ReanimatorNPC npc, Mob mob, Player owner) {
+        // Defend owner: target whoever last hurt them, any entity type
+        Entity lastDamager = owner.getLastDamageCause() instanceof org.bukkit.event.entity.EntityDamageByEntityEvent edbe
+                ? edbe.getDamager() : null;
+        double radius = cfg("golem.combat_radius", 12.0);
+        if (lastDamager instanceof LivingEntity le
+                && !le.getUniqueId().equals(mob.getUniqueId())
+                && mob.getLocation().distance(le.getLocation()) <= radius) {
+            mob.setTarget(le);
+            return;
+        }
+        // Fallback: nearest hostile mob
+        owner.getWorld()
+                .getNearbyEntities(mob.getLocation(), radius, radius, radius)
+                .stream()
+                .filter(e -> e instanceof Monster)
+                .filter(e -> e.getLocation().distance(owner.getLocation()) < radius)
+                .map(e -> (LivingEntity) e)
+                .min(java.util.Comparator.comparingDouble(e -> e.getLocation().distance(mob.getLocation())))
+                .ifPresent(mob::setTarget);
+    }
+
+    @Override
+    public void onSpawn(ReanimatorNPC npc, IronGolem golem) { }
+
+    @Override
+    public void onRevive(ReanimatorNPC npc, Player target, Player reviver) {
+        // No post-revive bonus for base Golem
+    }
+
+    @Override public boolean canRevive()       { return true; }
+    @Override public boolean canReviveAllies() { return false; }
+
+    @Override
+    public String buildNameplate(ReanimatorNPC npc, double hp, double maxHp, long remSec) {
+        return ChatColor.GREEN + "✦ " + npc.getType().getDisplayName()
+                + ChatColor.DARK_GRAY + " [" + ChatColor.WHITE + npc.getOwnerName() + ChatColor.DARK_GRAY + "]"
+                + ChatColor.GRAY + " | " + ChatColor.RED + "❤ " + (int) hp
+                + timeSuffix(remSec);
+    }
+
+    @Override public Particle getSpawnParticle() { return Particle.SOUL_FIRE_FLAME; }
+    @Override public Sound    getSpawnSound()    { return Sound.BLOCK_BEACON_ACTIVATE; }
+    @Override public double   getMaxHp()         {
+        return ReanimateMC.getInstance().getConfig().getDouble("npc_summon.golem.max_hp", 100.0);
+    }
+
+    private String timeSuffix(long remSec) {
+        if (remSec == Long.MAX_VALUE || remSec < 0) return "";
+        return ChatColor.GRAY + " | " + ChatColor.YELLOW + "⏱ " + formatTime(remSec);
+    }
+
+    private String formatTime(long s) {
+        return s >= 60 ? (s / 60) + "m" + (s % 60) + "s" : s + "s";
+    }
+
+    private double cfg(String key, double def) {
+        return ReanimateMC.getInstance().getConfig().getDouble("npc_summon." + key, def);
+    }
+}
diff --git a/src/main/java/fr/jachou/reanimatemc/behavior/HealerBehavior.java b/src/main/java/fr/jachou/reanimatemc/behavior/HealerBehavior.java
new file mode 100644
index 0000000..5b04027
--- /dev/null
+++ b/src/main/java/fr/jachou/reanimatemc/behavior/HealerBehavior.java
@@ -0,0 +1,342 @@
+package fr.jachou.reanimatemc.behavior;
+
+import fr.jachou.reanimatemc.ReanimateMC;
+import fr.jachou.reanimatemc.data.ReanimatorNPC;
+import fr.jachou.reanimatemc.managers.KOManager;
+import org.bukkit.*;
+import org.bukkit.attribute.Attribute;
+import org.bukkit.entity.IronGolem;
+import org.bukkit.entity.LivingEntity;
+import org.bukkit.entity.Mob;
+import org.bukkit.entity.Player;
+import org.bukkit.potion.PotionEffect;
+import org.bukkit.potion.PotionEffectType;
+import org.bukkit.scheduler.BukkitRunnable;
+
+import java.util.Comparator;
+import java.util.List;
+import java.util.Objects;
+import java.util.stream.Collectors;
+
+/**
+ * HEALER — support reanimator.
+ *
+ * <p>Behavior priorities (evaluated every behavior tick):
+ * <ol>
+ *   <li>Never attack — target is always cleared.</li>
+ *   <li>If owner or any ally is below {@code low_hp_threshold} HP and healer is
+ *       beyond {@code periodic_heal_range}, move toward the most-injured target
+ *       in range. Otherwise stay near owner.</li>
+ *   <li>Heal tick (throttled by {@code periodic_heal_interval}).</li>
+ *   <li>Continuous visual aura — a rotating HEART ring is shown whenever any
+ *       healable target (owner or ally) is below max HP within
+ *       {@code ally_heal_range}. Runs every behavior tick independently of the
+ *       heal cooldown so the aura is always visible during active healing.</li>
+ * </ol>
+ *
+ * <p>Movement constraint — the healer will not pursue a KO'd ally beyond
+ * {@code max_leash_distance} blocks from the owner. If an ally falls outside
+ * that radius the healer stays near the owner and relies on the KO priority
+ * path in {@link fr.jachou.reanimatemc.managers.NPCSummonManager} to handle
+ * when {@code canReviveAllies()} is true and the ally is set as a target.
+ *
+ * <p>Config keys (all under {@code npc_summon.healer.*}):
+ * <ul>
+ *   <li>{@code max_hp} — golem max HP (default 120)</li>
+ *   <li>{@code max_leash_distance} — max blocks from owner the healer will wander (default 12)</li>
+ *   <li>{@code low_hp_threshold} — HP below which the healer moves toward a target (default 16)</li>
+ *   <li>{@code periodic_heal_interval} — seconds between heal ticks (default 10)</li>
+ *   <li>{@code periodic_heal_amount} — HP healed to owner per tick (default 2)</li>
+ *   <li>{@code periodic_heal_range} — max distance from golem to owner to apply heal (default 8)</li>
+ *   <li>{@code ally_heal_amount} — HP healed to each ally per tick (default 1)</li>
+ *   <li>{@code ally_heal_range} — radius to scan allies (default 12)</li>
+ *   <li>{@code heal_self} — healer restores its own HP (default true)</li>
+ *   <li>{@code self_heal_amount} — HP per tick to self (default 1)</li>
+ *   <li>{@code heal_golems} — healer restores HP to allied golems (default true)</li>
+ *   <li>{@code golem_heal_amount} — HP per tick to each allied golem (default 3)</li>
+ *   <li>{@code aura_hp_threshold} — owner HP below which Regeneration fires (default 6)</li>
+ *   <li>{@code bonus_hp_on_revive} — extra HP granted to revived player (default 4)</li>
+ *   <li>{@code scan_radius} — radius for KO ally auto-scan (default 16)</li>
+ *   <li>{@code aura_particle_enabled} — show circular heal aura (default true)</li>
+ *   <li>{@code aura_particle_radius} — circle radius in blocks (default 3)</li>
+ * </ul>
+ */
+public class HealerBehavior implements NPCBehavior {
+
+    private final KOManager koManager;
+
+    public HealerBehavior(KOManager koManager) {
+        this.koManager = koManager;
+    }
+
+    @Override
+    public void onIdleTick(ReanimatorNPC npc, Mob mob, Player owner) {
+        double scanRadius     = cfg("healer.scan_radius", 16.0);
+        double auraHpThresh   = cfg("healer.aura_hp_threshold", 6.0);
+        double maxLeash       = cfg("healer.max_leash_distance", 12.0);
+        double lowHpThreshold = cfg("healer.low_hp_threshold", 16.0);
+        double allyHealRange  = cfg("healer.ally_heal_range", 12.0);
+
+        // ── 1. Never attack ───────────────────────────────────────────────────
+        mob.setTarget(null);
+
+        // ── 2. KO ally scan — populate targetPlayerId for NPCSummonManager ───
+        // Only set a target if the ally is within leash range from owner.
+        if (npc.getTargetPlayerId() == null) {
+            owner.getWorld()
+                    .getNearbyEntities(mob.getLocation(), scanRadius, scanRadius, scanRadius)
+                    .stream()
+                    .filter(e -> e instanceof Player)
+                    .map(e -> (Player) e)
+                    .filter(p -> !p.getUniqueId().equals(owner.getUniqueId()))
+                    .filter(koManager::isKO)
+                    .filter(p -> p.getLocation().distance(owner.getLocation()) <= maxLeash)
+                    .min(Comparator.comparingDouble(p -> p.getLocation().distance(mob.getLocation())))
+                    .ifPresent(ko -> npc.setTargetPlayerId(ko.getUniqueId()));
+        }
+
+        // ── 3. Move toward most-injured nearby target if they need healing ───
+        // This overrides the default followOwner in NPCSummonManager for
+        // the one tick where someone is injured and within leash range.
+        Player injuredTarget = findMostInjured(mob, owner, allyHealRange);
+        if (injuredTarget != null) {
+            double distToInjured = mob.getLocation().distance(injuredTarget.getLocation());
+            double distToOwner   = mob.getLocation().distance(owner.getLocation());
+            boolean injuredIsLow = injuredTarget.getHealth() < lowHpThreshold;
+
+            // Move toward injured target only if within leash and they are actually low
+            if (injuredIsLow && distToOwner <= maxLeash) {
+                mob.getPathfinder().moveTo(injuredTarget.getLocation());
+            }
+        }
+
+        // ── 4. Regeneration aura on owner when HP critically low ─────────────
+        boolean ownerLow = owner.getHealth() < auraHpThresh;
+        if (ownerLow && !npc.isHealerAuraActive()) {
+            owner.addPotionEffect(new PotionEffect(PotionEffectType.REGENERATION, 60, 0, true, true));
+            npc.setHealerAuraActive(true);
+        } else if (!ownerLow && npc.isHealerAuraActive()) {
+            npc.setHealerAuraActive(false);
+        }
+
+        // ── 5. Continuous visual aura — shown every idle tick when someone ────
+        // has less than max HP within range. Independent of heal cooldown.
+        if (cfgBool("healer.aura_particle_enabled", true)) {
+            boolean anyoneNeedsHeal = anyoneNeedsHeal(mob, owner, allyHealRange);
+            if (anyoneNeedsHeal) {
+                spawnHealAura(mob, (int) cfg("healer.aura_particle_radius", 3));
+            }
+        }
+
+        // ── 6. Periodic heal throttle ─────────────────────────────────────────
+        int interval        = (int) cfg("healer.periodic_heal_interval", 10.0);
+        int idleTicksNeeded = Math.max(1, interval / 3);
+        npc.incrementIdleTick();
+        if (npc.getIdleTick() % idleTicksNeeded != 0) return;
+
+        runHealTick(mob, owner, allyHealRange);
+    }
+
+    // ── Heal tick ─────────────────────────────────────────────────────────────
+
+    private void runHealTick(Mob mob, Player owner, double allyHealRange) {
+        double ownerHealAmount = cfg("healer.periodic_heal_amount", 2.0);
+        double ownerHealRange  = cfg("healer.periodic_heal_range", 8.0);
+        double allyHealAmount  = cfg("healer.ally_heal_amount", 1.0);
+        boolean healSelf       = cfgBool("healer.heal_self", true);
+        double selfHealAmount  = cfg("healer.self_heal_amount", 1.0);
+        boolean healGolems     = cfgBool("healer.heal_golems", true);
+        double golemHealAmount = cfg("healer.golem_heal_amount", 3.0);
+
+        // Owner
+        if (mob.getLocation().distance(owner.getLocation()) <= ownerHealRange) {
+            double ownerMax = Objects.requireNonNull(owner.getAttribute(Attribute.MAX_HEALTH)).getValue();
+            boolean healed = owner.getHealth() < ownerMax;
+            if (healed) {
+                owner.setHealth(Math.min(ownerMax, owner.getHealth() + ownerHealAmount));
+            }
+            // Particles on owner: always shown so the aura range is visible
+            owner.getWorld().spawnParticle(Particle.HEART,
+                    owner.getLocation().add(0, 1.5, 0), 4, 0.3, 0.2, 0.3);
+        }
+
+        // Allies
+        List<Player> allies = mob.getWorld()
+                .getNearbyEntities(mob.getLocation(), allyHealRange, allyHealRange, allyHealRange)
+                .stream()
+                .filter(e -> e instanceof Player)
+                .map(e -> (Player) e)
+                .filter(p -> !p.getUniqueId().equals(owner.getUniqueId()))
+                .filter(p -> !koManager.isKO(p))
+                .collect(Collectors.toList());
+
+        for (Player ally : allies) {
+            double allyMax = Objects.requireNonNull(ally.getAttribute(Attribute.MAX_HEALTH)).getValue();
+            boolean healed = ally.getHealth() < allyMax;
+            if (healed) {
+                ally.setHealth(Math.min(allyMax, ally.getHealth() + allyHealAmount));
+            }
+            // Particles on ally: always shown
+            ally.getWorld().spawnParticle(Particle.HAPPY_VILLAGER,
+                    ally.getLocation().add(0, 1.5, 0), 4, 0.3, 0.2, 0.3);
+        }
+
+        // Self
+        if (healSelf) {
+            LivingEntity self = (LivingEntity) mob;
+            double selfMax = Objects.requireNonNull(self.getAttribute(Attribute.MAX_HEALTH)).getValue();
+            if (self.getHealth() < selfMax) {
+                self.setHealth(Math.min(selfMax, self.getHealth() + selfHealAmount));
+                mob.getWorld().spawnParticle(Particle.HAPPY_VILLAGER,
+                        mob.getLocation().add(0, 2.2, 0), 2, 0.2, 0.1, 0.2);
+            }
+        }
+
+        // Allied golems
+        if (healGolems) {
+            mob.getWorld()
+                    .getNearbyEntities(mob.getLocation(), allyHealRange, allyHealRange, allyHealRange)
+                    .stream()
+                    .filter(e -> e instanceof IronGolem)
+                    .filter(e -> !e.getUniqueId().equals(mob.getUniqueId()))
+                    .map(e -> (IronGolem) e)
+                    .forEach(golem -> {
+                        double gMax = Objects.requireNonNull(
+                                golem.getAttribute(Attribute.MAX_HEALTH)).getValue();
+                        if (golem.getHealth() < gMax) {
+                            golem.setHealth(Math.min(gMax, golem.getHealth() + golemHealAmount));
+                            golem.getWorld().spawnParticle(Particle.HEART,
+                                    golem.getLocation().add(0, 2.5, 0), 2, 0.2, 0.1, 0.2);
+                        }
+                    });
+        }
+    }
+
+    // ── Helpers ───────────────────────────────────────────────────────────────
+
+    /**
+     * Returns the player (owner or ally) with the lowest HP percentage within
+     * {@code range} blocks, or {@code null} if everyone is at max HP.
+     */
+    private Player findMostInjured(Mob mob, Player owner, double range) {
+        double ownerMax = Objects.requireNonNull(owner.getAttribute(Attribute.MAX_HEALTH)).getValue();
+        Player best   = owner.getHealth() < ownerMax ? owner : null;
+        double bestRatio = best != null ? owner.getHealth() / ownerMax : 1.0;
+
+        for (Object e : mob.getWorld().getNearbyEntities(
+                mob.getLocation(), range, range, range)) {
+            if (!(e instanceof Player)) continue;
+            Player p = (Player) e;
+            if (p.getUniqueId().equals(owner.getUniqueId())) continue;
+            if (koManager.isKO(p)) continue;
+            double max   = Objects.requireNonNull(p.getAttribute(Attribute.MAX_HEALTH)).getValue();
+            double ratio = p.getHealth() / max;
+            if (ratio < bestRatio) {
+                bestRatio = ratio;
+                best      = p;
+            }
+        }
+        return best;
+    }
+
+    /**
+     * Returns true if at least one player within {@code range} blocks (owner
+     * included) has HP below max — meaning the heal aura should be visible.
+     */
+    private boolean anyoneNeedsHeal(Mob mob, Player owner, double range) {
+        double ownerMax = Objects.requireNonNull(owner.getAttribute(Attribute.MAX_HEALTH)).getValue();
+        if (owner.getHealth() < ownerMax) return true;
+
+        return mob.getWorld()
+                .getNearbyEntities(mob.getLocation(), range, range, range)
+                .stream()
+                .filter(e -> e instanceof Player)
+                .map(e -> (Player) e)
+                .filter(p -> !koManager.isKO(p))
+                .anyMatch(p -> {
+                    double max = Objects.requireNonNull(
+                            p.getAttribute(Attribute.MAX_HEALTH)).getValue();
+                    return p.getHealth() < max;
+                });
+    }
+
+    /**
+     * Spawns a full rotating circle of HEART + HAPPY_VILLAGER particles around
+     * the golem over 16 ticks (one particle per tick, completing one full ring).
+     * Called every idle tick while someone needs healing, so the aura is
+     * continuous and always visible during active healing sessions.
+     */
+    private void spawnHealAura(Mob mob, int radius) {
+        new BukkitRunnable() {
+            int step      = 0;
+            final int steps = 16;
+            @Override
+            public void run() {
+                if (step >= steps || !mob.isValid()) { cancel(); return; }
+                double angle = 2 * Math.PI * step / steps;
+                double x     = mob.getLocation().getX() + radius * Math.cos(angle);
+                double z     = mob.getLocation().getZ() + radius * Math.sin(angle);
+                double y     = mob.getLocation().getY() + 0.3;
+                World world  = mob.getWorld();
+                world.spawnParticle(Particle.HEART,         x, y,        z, 1, 0, 0, 0, 0);
+                world.spawnParticle(Particle.HAPPY_VILLAGER, x, y + 0.4, z, 1, 0, 0, 0, 0);
+                step++;
+            }
+        }.runTaskTimer(ReanimateMC.getInstance(), 0L, 1L);
+    }
+
+    // ── NPCBehavior contract ──────────────────────────────────────────────────
+
+    @Override
+    public void onSpawn(ReanimatorNPC npc, IronGolem golem) {
+        double maxHp = cfg("healer.max_hp", 120.0);
+        var attr = golem.getAttribute(Attribute.MAX_HEALTH);
+        if (attr != null) {
+            attr.setBaseValue(maxHp);
+            golem.setHealth(maxHp);
+        }
+    }
+
+    @Override
+    public void onRevive(ReanimatorNPC npc, Player target, Player reviver) {
+        double bonus     = cfg("healer.bonus_hp_on_revive", 4.0);
+        double targetMax = Objects.requireNonNull(target.getAttribute(Attribute.MAX_HEALTH)).getValue();
+        target.setHealth(Math.min(targetMax, target.getHealth() + bonus));
+        target.getWorld().spawnParticle(Particle.HAPPY_VILLAGER,
+                target.getLocation().add(0, 1, 0), 8, 0.4, 0.4, 0.4);
+    }
+
+    @Override public boolean canRevive()       { return true; }
+    @Override public boolean canReviveAllies() { return true; }
+
+    @Override
+    public String buildNameplate(ReanimatorNPC npc, double hp, double maxHp, long remSec) {
+        return ChatColor.AQUA + "✚ " + npc.getType().getDisplayName()
+                + ChatColor.DARK_GRAY + " [" + ChatColor.WHITE + npc.getOwnerName() + ChatColor.DARK_GRAY + "]"
+                + ChatColor.GRAY + " | " + ChatColor.RED + "❤ " + (int) hp
+                + timeSuffix(remSec);
+    }
+
+    @Override public Particle getSpawnParticle() { return Particle.HAPPY_VILLAGER; }
+    @Override public Sound    getSpawnSound()    { return Sound.BLOCK_BEACON_ACTIVATE; }
+    @Override public double   getMaxHp() {
+        return ReanimateMC.getInstance().getConfig().getDouble("npc_summon.healer.max_hp", 120.0);
+    }
+
+    private String timeSuffix(long remSec) {
+        if (remSec == Long.MAX_VALUE || remSec < 0) return "";
+        return ChatColor.GRAY + " | " + ChatColor.YELLOW + "⏱ " + formatTime(remSec);
+    }
+
+    private String formatTime(long s) {
+        return s >= 60 ? (s / 60) + "m" + (s % 60) + "s" : s + "s";
+    }
+
+    private double cfg(String key, double def) {
+        return ReanimateMC.getInstance().getConfig().getDouble("npc_summon." + key, def);
+    }
+
+    private boolean cfgBool(String key, boolean def) {
+        return ReanimateMC.getInstance().getConfig().getBoolean("npc_summon." + key, def);
+    }
+}
diff --git a/src/main/java/fr/jachou/reanimatemc/behavior/NPCBehavior.java b/src/main/java/fr/jachou/reanimatemc/behavior/NPCBehavior.java
new file mode 100644
index 0000000..ebafb1d
--- /dev/null
+++ b/src/main/java/fr/jachou/reanimatemc/behavior/NPCBehavior.java
@@ -0,0 +1,83 @@
+package fr.jachou.reanimatemc.behavior;
+
+import fr.jachou.reanimatemc.data.ReanimatorNPC;
+import org.bukkit.Location;
+import org.bukkit.Particle;
+import org.bukkit.Sound;
+import org.bukkit.entity.IronGolem;
+import org.bukkit.entity.Mob;
+import org.bukkit.entity.Player;
+
+/**
+ * Strategy interface defining all type-specific behavior for a reanimator NPC.
+ *
+ * <p>One implementation exists per {@link ReanimatorNPC.ReanimatorType}.
+ * {@code NPCSummonManager} calls these methods at the appropriate points in the
+ * lifecycle; implementations must not manage scheduling themselves.
+ */
+public interface NPCBehavior {
+
+    /**
+     * Called every 3 seconds (3 behavior ticks) when the NPC is idle — i.e. no
+     * KO target is being chased. Handles type-specific scanning, auras, combat, etc.
+     *
+     * @param npc   the NPC data record
+     * @param mob   the underlying Bukkit Mob entity
+     * @param owner the online owner of this NPC
+     */
+    void onIdleTick(ReanimatorNPC npc, Mob mob, Player owner);
+
+    /**
+     * Called once immediately after the golem entity is spawned and configured.
+     * Use for any one-time setup beyond what {@code spawnEntity} already does.
+     */
+    void onSpawn(ReanimatorNPC npc, IronGolem golem);
+
+    /**
+     * Called after a successful revive of {@code target} by this NPC.
+     * Apply type-specific post-revive effects here (bonus HP, knockback, etc.).
+     *
+     * @param npc     the NPC that performed the revive
+     * @param target  the player who was revived
+     * @param reviver the owner of the NPC (credited for the revive)
+     */
+    void onRevive(ReanimatorNPC npc, Player target, Player reviver);
+
+    /**
+     * Returns true if this type is capable of reviving KO'd players.
+     * GOLEM and HEALER return true; PROTECTOR returns false for non-owner targets.
+     */
+    boolean canRevive();
+
+    /**
+     * Returns true if this type revives its own owner when the owner falls KO.
+     * GOLEM and HEALER return true; PROTECTOR returns false.
+     */
+    default boolean canReviveOwner() { return true; }
+
+    /**
+     * Returns true if this type actively scans for and revives KO'd allies nearby
+     * without needing an explicit target set via command.
+     * Only HEALER returns true.
+     */
+    default boolean canReviveAllies() { return false; }
+
+    /**
+     * Builds the nameplate string shown above the golem.
+     *
+     * @param npc    the NPC record (for type and lifetime)
+     * @param hp     current HP
+     * @param maxHp  maximum HP
+     * @param remSec remaining lifetime seconds; {@link Long#MAX_VALUE} = unlimited
+     */
+    String buildNameplate(ReanimatorNPC npc, double hp, double maxHp, long remSec);
+
+    /** Particle used in the spiral spawn animation. */
+    Particle getSpawnParticle();
+
+    /** Sound played when the NPC is summoned. */
+    Sound getSpawnSound();
+
+    /** Maximum HP for this type's entity. */
+    double getMaxHp();
+}
diff --git a/src/main/java/fr/jachou/reanimatemc/behavior/ProtectorBehavior.java b/src/main/java/fr/jachou/reanimatemc/behavior/ProtectorBehavior.java
new file mode 100644
index 0000000..e99e002
--- /dev/null
+++ b/src/main/java/fr/jachou/reanimatemc/behavior/ProtectorBehavior.java
@@ -0,0 +1,131 @@
+package fr.jachou.reanimatemc.behavior;
+
+import fr.jachou.reanimatemc.ReanimateMC;
+import fr.jachou.reanimatemc.data.ReanimatorNPC;
+import org.bukkit.*;
+import org.bukkit.attribute.Attribute;
+import org.bukkit.attribute.AttributeInstance;
+import org.bukkit.entity.*;
+import org.bukkit.util.Vector;
+
+/**
+ * PROTECTOR — tank reanimator.
+ *
+ * <p>Idle-tick extras:
+ * <ul>
+ *   <li>Targets the nearest hostile mob within combat_radius that is also within
+ *       15 blocks of the owner.</li>
+ * </ul>
+ * Post-revive (owner only): knockback burst to nearby entities.
+ * Damage intercept and transfer are handled by NPCSummonManager + PlayerDamageListener.
+ */
+public class ProtectorBehavior implements NPCBehavior {
+
+    @Override
+    public void onIdleTick(ReanimatorNPC npc, Mob mob, Player owner) {
+        double radius = cfg("protector.combat_radius", 12.0);
+
+        // Priority: whoever last damaged the owner, any entity type
+        Entity lastDamager = owner.getLastDamageCause() instanceof org.bukkit.event.entity.EntityDamageByEntityEvent edbe
+                ? edbe.getDamager() : null;
+        if (lastDamager instanceof LivingEntity le
+                && !le.getUniqueId().equals(mob.getUniqueId())
+                && mob.getLocation().distance(le.getLocation()) <= radius) {
+            mob.setTarget(le);
+            return;
+        }
+
+        // Fallback: nearest LivingEntity threatening the owner (any type — players, mobs, etc.)
+        owner.getWorld()
+                .getNearbyEntities(mob.getLocation(), radius, radius, radius)
+                .stream()
+                .filter(e -> e instanceof LivingEntity)
+                .filter(e -> !(e instanceof IronGolem))   // exclude allied golems
+                .filter(e -> !e.getUniqueId().equals(owner.getUniqueId()))
+                .filter(e -> !e.getUniqueId().equals(mob.getUniqueId()))
+                .filter(e -> e.getLocation().distance(owner.getLocation()) < radius)
+                .map(e -> (LivingEntity) e)
+                .min(java.util.Comparator.comparingDouble(e -> e.getLocation().distance(mob.getLocation())))
+                .ifPresent(mob::setTarget);
+    }
+
+    @Override
+    public void onSpawn(ReanimatorNPC npc, IronGolem golem) {
+        double maxHp = cfg("protector.max_hp", 200.0);
+        AttributeInstance attr = golem.getAttribute(Attribute.MAX_HEALTH);
+        if (attr != null) {
+            attr.setBaseValue(maxHp);
+            golem.setHealth(maxHp);
+        }
+    }
+
+    @Override
+    public void onRevive(ReanimatorNPC npc, Player target, Player reviver) {
+        // Knockback burst only when reviving its own owner
+        if (!target.getUniqueId().equals(npc.getOwnerId())) return;
+
+        Location center = npc.getEntity().getLocation();
+        center.getWorld().getNearbyEntities(center, 5, 5, 5).forEach(e -> {
+            if (e instanceof Player && e.getUniqueId().equals(target.getUniqueId())) return;
+            if (!(e instanceof LivingEntity)) return;
+            Vector dir = e.getLocation().toVector().subtract(center.toVector());
+            // Avoid NaN: skip entities at the exact same XZ position as the golem
+            if (dir.getX() == 0 && dir.getZ() == 0) return;
+            dir.setY(0).normalize().multiply(1.5).setY(0.4);
+            e.setVelocity(dir);
+        });
+        center.getWorld().spawnParticle(Particle.EXPLOSION_EMITTER, center, 3, 0.5, 0.2, 0.5);
+        center.getWorld().playSound(center, Sound.ENTITY_IRON_GOLEM_HURT, 1.2f, 0.7f);
+    }
+
+    /**
+     * Returns true only when:
+     * 1. {@code npc_summon.protector.revive_if_no_healer} is true (default true), AND
+     * 2. The owner has no active HEALER NPC.
+     *
+     * This is evaluated lazily in {@link fr.jachou.reanimatemc.managers.NPCSummonManager}
+     * via the {@code canReviveOwner()} check which is called once per behavior tick.
+     * The actual healer check is handled in NPCSummonManager.updateBehavior() before
+     * calling this method — see overrideCanReviveOwner(npc, owner).
+     */
+    @Override
+    public boolean canRevive() {
+        return false;
+    }
+
+    @Override
+    public boolean canReviveOwner() {
+        // Base value from config — actual healer check done in NPCSummonManager
+        return ReanimateMC.getInstance().getConfig()
+                .getBoolean("npc_summon.protector.revive_if_no_healer", true);
+    }
+
+    @Override
+    public String buildNameplate(ReanimatorNPC npc, double hp, double maxHp, long remSec) {
+        ChatColor hpColor = (hp / maxHp) > 0.5 ? ChatColor.GREEN
+                : (hp / maxHp) > 0.25 ? ChatColor.YELLOW : ChatColor.RED;
+        return ChatColor.RED + "⚔ " + npc.getType().getDisplayName()
+                + ChatColor.DARK_GRAY + " [" + ChatColor.WHITE + npc.getOwnerName() + ChatColor.DARK_GRAY + "]"
+                + ChatColor.GRAY + " | " + hpColor + "❤ " + (int) hp + "/" + (int) maxHp
+                + timeSuffix(remSec);
+    }
+
+    @Override public Particle getSpawnParticle() { return Particle.FLAME; }
+    @Override public Sound    getSpawnSound()    { return Sound.ENTITY_IRON_GOLEM_REPAIR; }
+    @Override public double   getMaxHp()         {
+        return ReanimateMC.getInstance().getConfig().getDouble("npc_summon.protector.max_hp", 200.0);
+    }
+
+    private String timeSuffix(long remSec) {
+        if (remSec == Long.MAX_VALUE || remSec < 0) return "";
+        return ChatColor.GRAY + " | " + ChatColor.YELLOW + "⏱ " + formatTime(remSec);
+    }
+
+    private String formatTime(long s) {
+        return s >= 60 ? (s / 60) + "m" + (s % 60) + "s" : s + "s";
+    }
+
+    private double cfg(String key, double def) {
+        return ReanimateMC.getInstance().getConfig().getDouble("npc_summon." + key, def);
+    }
+}
diff --git a/src/main/java/fr/jachou/reanimatemc/commands/ReanimateMCCommand.java b/src/main/java/fr/jachou/reanimatemc/commands/ReanimateMCCommand.java
index ffcc008..3710b21 100644
--- a/src/main/java/fr/jachou/reanimatemc/commands/ReanimateMCCommand.java
+++ b/src/main/java/fr/jachou/reanimatemc/commands/ReanimateMCCommand.java
@@ -18,259 +18,416 @@
 import java.util.stream.Collectors;
 
 public class ReanimateMCCommand implements CommandExecutor, TabCompleter {
-    private final KOManager koManager;
-    private final ConfigGUI configGui;
+
+    private final KOManager       koManager;
+    private final ConfigGUI       configGui;
     private final NPCSummonManager npcSummonManager;
 
     public ReanimateMCCommand(KOManager koManager, ConfigGUI configGui, NPCSummonManager npcSummonManager) {
-        this.koManager = koManager;
-        this.configGui = configGui;
+        this.koManager        = koManager;
+        this.configGui        = configGui;
         this.npcSummonManager = npcSummonManager;
     }
 
+    // ── Permission helpers ────────────────────────────────────────────────────
+
+    /** Op-level: always true for OPs even without a permission plugin. */
+    private boolean hasAdminPerm(CommandSender sender, String node) {
+        if (sender.isOp()) return true;
+        return sender.hasPermission(node);
+    }
+
+    /** Player-level: opLevel=true → isOp() fallback. */
+    private boolean hasPerm(CommandSender sender, String node, boolean opLevel) {
+        if (opLevel && sender.isOp()) return true;
+        return sender.hasPermission(node);
+    }
+
+    // ── Main dispatcher ───────────────────────────────────────────────────────
+
     @Override
     public boolean onCommand(CommandSender sender, Command command, String label, String[] args) {
+
+        // Standalone commands /selfrevive, /sr, /cancelselfrevive, /cancelsr
+        String cmdName = command.getName().toLowerCase();
+        if (cmdName.equals("selfrevive") || cmdName.equals("sr")) {
+            if (!(sender instanceof Player player)) { sender.sendMessage(ChatColor.RED + ReanimateMC.lang.get("command_player_only")); return true; }
+            if (!hasPerm(player, "reanimatemc.selfrevive", false)) { player.sendMessage(ChatColor.RED + ReanimateMC.lang.get("no_permission")); return true; }
+            if (!ReanimateMC.getInstance().getConfig().getBoolean("self_revive.enabled", true)) { player.sendMessage(ChatColor.RED + ReanimateMC.lang.get("selfrevive_disabled")); return true; }
+            if (!koManager.isKO(player)) { player.sendMessage(ChatColor.RED + ReanimateMC.lang.get("not_in_ko")); return true; }
+            koManager.startSelfRevive(player);
+            return true;
+        }
+        if (cmdName.equals("cancelselfrevive") || cmdName.equals("cancelsr")) {
+            if (!(sender instanceof Player player)) { sender.sendMessage(ChatColor.RED + ReanimateMC.lang.get("command_player_only")); return true; }
+            if (!koManager.isChannelingSelfRevive(player)) { player.sendMessage(ChatColor.RED + ReanimateMC.lang.get("selfrevive_not_channeling")); return true; }
+            koManager.cancelSelfRevive(player, true);
+            return true;
+        }
+
         if (args.length < 1) {
-            Bukkit.getScheduler().runTaskAsynchronously(ReanimateMC.getInstance(), () -> ReanimateMC.getInstance().getNotifier().notifySenderIfOutdated(sender));
+            sendPluginInfo(sender);
             return true;
         }
 
-        String subCommand = args[0];
-        if (subCommand.equalsIgnoreCase("reload")) {
-            if (!sender.hasPermission("reanimatemc.admin")) {
-                sender.sendMessage(ChatColor.RED + ReanimateMC.lang.get("no_permission"));
-                return true;
-            }
-            ReanimateMC.getInstance().reloadConfig();
-            ReanimateMC.lang.loadLanguage();
-            sender.sendMessage(ChatColor.GREEN + ReanimateMC.lang.get("config_reloaded"));
-        } else if (subCommand.equalsIgnoreCase("revive")) {
-            if (!sender.hasPermission("reanimatemc.revive")) {
-                sender.sendMessage(ChatColor.RED + ReanimateMC.lang.get("no_permission"));
-                return true;
-            }
-            if (args.length < 2) {
-                sender.sendMessage(ChatColor.YELLOW + ReanimateMC.lang.get("command_revive_usage"));
-                return true;
-            }
-            Player target = Bukkit.getPlayer(args[1]);
-            if (target == null) {
-                sender.sendMessage(ChatColor.RED + ReanimateMC.lang.get("player_not_found"));
-                return true;
-            }
-            if (!koManager.isKO(target)) {
-                sender.sendMessage(ChatColor.RED + ReanimateMC.lang.get("player_not_ko"));
-                return true;
-            }
-            Player player = (Player) sender;
-            koManager.revive(target, player);
-            sender.sendMessage(ChatColor.GREEN + ReanimateMC.lang.get("revived_confirmation", "player", target.getName()));
-        } else if (subCommand.equalsIgnoreCase("knockout")) {
-            if (!sender.hasPermission("reanimatemc.knockout")) {
-                sender.sendMessage(ChatColor.RED + ReanimateMC.lang.get("no_permission"));
-                return true;
-            }
-            if (args.length < 2) {
-                sender.sendMessage(ChatColor.YELLOW + ReanimateMC.lang.get("command_knockout_usage"));
-                return true;
-            }
-            Player target = Bukkit.getPlayer(args[1]);
-            if (target == null) {
-                sender.sendMessage(ChatColor.RED + ReanimateMC.lang.get("player_not_found"));
-                return true;
-            }
-            if (koManager.isKO(target)) {
-                sender.sendMessage(ChatColor.RED + ReanimateMC.lang.get("player_already_ko"));
-                return true;
-            }
-            koManager.setKO(target);
-            sender.sendMessage(ChatColor.GREEN + ReanimateMC.lang.get("knockout_set", "player", target.getName()));
-        } else if (subCommand.equalsIgnoreCase("status")) {
-            if (!sender.hasPermission("reanimatemc.status")) {
-                sender.sendMessage(ChatColor.RED + ReanimateMC.lang.get("no_permission"));
-                return true;
-            }
-            if (args.length < 2) {
-                sender.sendMessage(ChatColor.YELLOW + ReanimateMC.lang.get("command_status_usage"));
-                return true;
-            }
-            Player target = Bukkit.getPlayer(args[1]);
-            if (target == null) {
-                sender.sendMessage(ChatColor.RED + ReanimateMC.lang.get("player_not_found"));
-                return true;
-            }
-            String status = koManager.isKO(target) ? ReanimateMC.lang.get("status_ko") : ReanimateMC.lang.get("status_normal");
-            sender.sendMessage(ChatColor.AQUA + target.getName() + " : " + status);
-        } else if (subCommand.equalsIgnoreCase("crawl")) {
-            if (!(sender instanceof Player)) {
-                sender.sendMessage("This command can only be executed by a player.");
-                return true;
+        switch (args[0].toLowerCase()) {
+
+            // ── Admin ─────────────────────────────────────────────────────────
+
+            case "reload" -> {
+                if (!hasAdminPerm(sender, "reanimatemc.admin")) {
+                    sender.sendMessage(ChatColor.RED + ReanimateMC.lang.get("no_permission"));
+                    return true;
+                }
+                ReanimateMC.getInstance().reloadConfig();
+                ReanimateMC.getInstance().getConfig().options().copyDefaults(true);
+                ReanimateMC.getInstance().saveConfig();
+                ReanimateMC.lang.loadLanguage();
+                sender.sendMessage(ChatColor.GREEN + ReanimateMC.lang.get("config_reloaded"));
             }
-            Player player = (Player) sender;
-            if (!player.hasPermission("reanimatemc.crawl")) {
-                player.sendMessage(ChatColor.RED + ReanimateMC.lang.get("no_permission"));
-                return true;
+
+            case "knockout" -> {
+                if (!hasAdminPerm(sender, "reanimatemc.knockout")) {
+                    sender.sendMessage(ChatColor.RED + ReanimateMC.lang.get("no_permission"));
+                    return true;
+                }
+                if (args.length < 2) {
+                    sender.sendMessage(ChatColor.YELLOW + ReanimateMC.lang.get("command_knockout_usage"));
+                    return true;
+                }
+                Player target = Bukkit.getPlayer(args[1]);
+                if (target == null) { sender.sendMessage(ChatColor.RED + ReanimateMC.lang.get("player_not_found")); return true; }
+                if (koManager.isKO(target)) { sender.sendMessage(ChatColor.RED + ReanimateMC.lang.get("player_already_ko")); return true; }
+                koManager.setKO(target);
+                sender.sendMessage(ChatColor.GREEN + ReanimateMC.lang.get("knockout_set", "player", target.getName()));
             }
-            if (!koManager.isKO(player)) {
-                player.sendMessage(ChatColor.RED + ReanimateMC.lang.get("not_in_ko"));
-                return true;
+
+            case "purge" -> {
+                if (!hasAdminPerm(sender, "reanimatemc.admin")) {
+                    sender.sendMessage(ChatColor.RED + ReanimateMC.lang.get("no_permission"));
+                    return true;
+                }
+                int removed = koManager.purgeOrphanedHolograms();
+                sender.sendMessage(ChatColor.GREEN + ReanimateMC.lang.get("purge_complete", "count", String.valueOf(removed)));
             }
-            if (!ReanimateMC.getInstance().getConfig().getBoolean("prone.allow_crawl", false)) {
-                player.sendMessage(ChatColor.RED + ReanimateMC.lang.get("crawl_not_allowed"));
-                return true;
+
+            case "kolist" -> {
+                if (!hasAdminPerm(sender, "reanimatemc.admin")) {
+                    sender.sendMessage(ChatColor.RED + ReanimateMC.lang.get("no_permission"));
+                    return true;
+                }
+                java.util.Set<java.util.UUID> uuids = koManager.getKOPlayerUUIDs();
+                if (uuids.isEmpty()) {
+                    sender.sendMessage(ChatColor.YELLOW + ReanimateMC.lang.get("kolist_empty"));
+                    return true;
+                }
+                sender.sendMessage(ChatColor.GOLD + "━━━━━ " + ReanimateMC.lang.get("kolist_header") + " ━━━━━");
+                for (java.util.UUID uuid : uuids) {
+                    Player t = Bukkit.getPlayer(uuid);
+                    if (t == null || !t.isOnline()) continue;
+                    long rem = koManager.getRemainingKOSeconds(t);
+                    ChatColor c = rem > 30 ? ChatColor.GREEN : rem > 10 ? ChatColor.YELLOW : ChatColor.RED;
+                    sender.sendMessage(ChatColor.WHITE + t.getName() + ChatColor.GRAY + " - " + c + rem + "s");
+                }
+                sender.sendMessage(ChatColor.GOLD + "━━━━━━━━━━━━━━━━━━━━━━━");
             }
-            koManager.toggleCrawl(player);
-        } else if (subCommand.equalsIgnoreCase("removeGlowingEffect")) {
-            if (!sender.hasPermission("reanimatemc.removeglow")) {
-                sender.sendMessage(ChatColor.RED + ReanimateMC.lang.get("no_permission"));
-                return true;
+
+            case "removeglowingreffect", "removeglow", "removeglowingeffect" -> {
+                if (!hasAdminPerm(sender, "reanimatemc.removeglow")) {
+                    sender.sendMessage(ChatColor.RED + ReanimateMC.lang.get("no_permission"));
+                    return true;
+                }
+                if (args.length < 2) { sender.sendMessage(ChatColor.YELLOW + ReanimateMC.lang.get("command_remove_glowing_usage")); return true; }
+                Player target = Bukkit.getPlayer(args[1]);
+                if (target == null) { sender.sendMessage(ChatColor.RED + ReanimateMC.lang.get("player_not_found")); return true; }
+                target.setGlowing(false);
+                sender.sendMessage(ChatColor.GREEN + ReanimateMC.lang.get("glowing_effect_removed"));
             }
-            if (args.length < 2) {
-                sender.sendMessage(ChatColor.YELLOW + ReanimateMC.lang.get("command_remove_glowing_usage"));
-                return true;
+
+            case "info" -> {
+                sendPluginInfo(sender);
             }
-            Player target = Bukkit.getPlayer(args[1]);
-            if (target == null) {
-                sender.sendMessage(ChatColor.RED + ReanimateMC.lang.get("player_not_found"));
-                return true;
+
+            case "version", "ver" -> {
+                sendVersion(sender);
             }
-            target.setGlowing(false);
-            sender.sendMessage(ChatColor.GREEN + ReanimateMC.lang.get("glowing_effect_removed"));
 
-        } else if (subCommand.equalsIgnoreCase("gui") || subCommand.equalsIgnoreCase("config")) {
-            if (!(sender instanceof Player)) {
-                sender.sendMessage(ChatColor.RED + ReanimateMC.lang.get("command_gui_player_only"));
-                return true;
+            // ── Player-level ──────────────────────────────────────────────────
+
+            case "revive" -> {
+                if (!(sender instanceof Player player)) { sender.sendMessage(ChatColor.RED + ReanimateMC.lang.get("command_player_only")); return true; }
+                if (!hasPerm(player, "reanimatemc.revive", false)) { player.sendMessage(ChatColor.RED + ReanimateMC.lang.get("no_permission")); return true; }
+                if (args.length < 2) { player.sendMessage(ChatColor.YELLOW + ReanimateMC.lang.get("command_revive_usage")); return true; }
+                Player target = Bukkit.getPlayer(args[1]);
+                if (target == null) { player.sendMessage(ChatColor.RED + ReanimateMC.lang.get("player_not_found")); return true; }
+                if (!koManager.isKO(target)) { player.sendMessage(ChatColor.RED + ReanimateMC.lang.get("player_not_ko")); return true; }
+                npcSummonManager.startCommandRevive(player, target);
             }
-            Player player = (Player) sender;
-            if (!player.hasPermission("reanimatemc.admin")) {
-                player.sendMessage(ChatColor.RED + ReanimateMC.lang.get("no_permission"));
-                return true;
+
+            case "status" -> {
+                if (!hasPerm(sender, "reanimatemc.status", false)) { sender.sendMessage(ChatColor.RED + ReanimateMC.lang.get("no_permission")); return true; }
+                if (args.length < 2) { sender.sendMessage(ChatColor.YELLOW + ReanimateMC.lang.get("command_status_usage")); return true; }
+                Player target = Bukkit.getPlayer(args[1]);
+                if (target == null) { sender.sendMessage(ChatColor.RED + ReanimateMC.lang.get("player_not_found")); return true; }
+                String status = koManager.isKO(target) ? ReanimateMC.lang.get("status_ko") : ReanimateMC.lang.get("status_normal");
+                sender.sendMessage(ChatColor.AQUA + target.getName() + " : " + status);
             }
-            configGui.openGUI(player);
-            if (!ReanimateMC.getInstance().getConfig().getBoolean("setup_completed", false)) {
-                ReanimateMC.getInstance().getConfig().set("setup_completed", true);
-                ReanimateMC.getInstance().saveConfig();
-                player.sendMessage(ChatColor.GREEN + ReanimateMC.lang.get("setup_complete"));
+
+            case "distress" -> {
+                if (!(sender instanceof Player player)) { sender.sendMessage(ChatColor.RED + ReanimateMC.lang.get("command_player_only")); return true; }
+                if (!koManager.isKO(player)) { player.sendMessage(ChatColor.RED + ReanimateMC.lang.get("not_in_ko")); return true; }
+                koManager.sendDistress(player);
             }
-        } else if (subCommand.equalsIgnoreCase("summon")) {
-            if (!(sender instanceof Player)) {
-                sender.sendMessage(ChatColor.RED + ReanimateMC.lang.get("command_player_only"));
-                return true;
+
+            case "selfrevive", "sr" -> {
+                if (!(sender instanceof Player player)) { sender.sendMessage(ChatColor.RED + ReanimateMC.lang.get("command_player_only")); return true; }
+                if (!hasPerm(player, "reanimatemc.selfrevive", false)) { player.sendMessage(ChatColor.RED + ReanimateMC.lang.get("no_permission")); return true; }
+                if (!ReanimateMC.getInstance().getConfig().getBoolean("self_revive.enabled", true)) {
+                    player.sendMessage(ChatColor.RED + ReanimateMC.lang.get("selfrevive_disabled")); return true;
+                }
+                if (!koManager.isKO(player)) { player.sendMessage(ChatColor.RED + ReanimateMC.lang.get("not_in_ko")); return true; }
+                koManager.startSelfRevive(player);
             }
-            Player player = (Player) sender;
-            if (!player.hasPermission("reanimate.summon")) {
-                player.sendMessage(ChatColor.RED + ReanimateMC.lang.get("no_permission"));
-                return true;
+
+            case "cancelsr", "cancelselfrevive" -> {
+                if (!(sender instanceof Player player)) { sender.sendMessage(ChatColor.RED + ReanimateMC.lang.get("command_player_only")); return true; }
+                if (!koManager.isChannelingSelfRevive(player)) { player.sendMessage(ChatColor.RED + ReanimateMC.lang.get("selfrevive_not_channeling")); return true; }
+                koManager.cancelSelfRevive(player, true);
             }
-            if (args.length < 2) {
-                player.sendMessage(ChatColor.YELLOW + ReanimateMC.lang.get("command_summon_usage"));
-                return true;
+
+            case "crawl" -> {
+                if (!(sender instanceof Player player)) { sender.sendMessage(ChatColor.RED + ReanimateMC.lang.get("command_player_only")); return true; }
+                if (!hasPerm(player, "reanimatemc.crawl", false)) { player.sendMessage(ChatColor.RED + ReanimateMC.lang.get("no_permission")); return true; }
+                if (!koManager.isKO(player)) { player.sendMessage(ChatColor.RED + ReanimateMC.lang.get("not_in_ko")); return true; }
+                if (!ReanimateMC.getInstance().getConfig().getBoolean("prone.allow_crawl", false)) { player.sendMessage(ChatColor.RED + ReanimateMC.lang.get("crawl_not_allowed")); return true; }
+                koManager.toggleCrawl(player);
             }
-            
-            // Parse NPC type
-            ReanimatorNPC.ReanimatorType type;
-            try {
-                type = ReanimatorNPC.ReanimatorType.valueOf(args[1].toUpperCase());
-            } catch (IllegalArgumentException e) {
-                player.sendMessage(ChatColor.RED + ReanimateMC.lang.get("npc_invalid_type", "type", args[1]));
-                return true;
+
+            case "gui", "config" -> {
+                if (!(sender instanceof Player player)) { sender.sendMessage(ChatColor.RED + ReanimateMC.lang.get("command_gui_player_only")); return true; }
+                if (!hasAdminPerm(player, "reanimatemc.config")) { player.sendMessage(ChatColor.RED + ReanimateMC.lang.get("no_permission")); return true; }
+                configGui.openGUI(player);
+                if (!ReanimateMC.getInstance().getConfig().getBoolean("setup_completed", false)) {
+                    ReanimateMC.getInstance().getConfig().set("setup_completed", true);
+                    ReanimateMC.getInstance().saveConfig();
+                    player.sendMessage(ChatColor.GREEN + ReanimateMC.lang.get("setup_complete"));
+                }
             }
-            
-            // Optional target player
-            Player targetPlayer = null;
-            if (args.length >= 3) {
-                targetPlayer = Bukkit.getPlayer(args[2]);
-                if (targetPlayer == null) {
-                    player.sendMessage(ChatColor.RED + ReanimateMC.lang.get("player_not_found"));
+
+            // ── NPC system ────────────────────────────────────────────────────
+
+            case "summon" -> {
+                if (!(sender instanceof Player player)) { sender.sendMessage(ChatColor.RED + ReanimateMC.lang.get("command_player_only")); return true; }
+                if (!hasPerm(player, "reanimatemc.summon", true)) { player.sendMessage(ChatColor.RED + ReanimateMC.lang.get("no_permission")); return true; }
+                if (args.length < 2) { player.sendMessage(ChatColor.YELLOW + ReanimateMC.lang.get("command_summon_usage")); return true; }
+
+                // /rmc summon team <p1> <p2> ...
+                if (args[1].equalsIgnoreCase("team")) {
+                    if (args.length < 4) { player.sendMessage(ChatColor.YELLOW + ReanimateMC.lang.get("command_summon_team_usage")); return true; }
+                    ReanimatorNPC.ReanimatorType teamType;
+                    try { teamType = ReanimatorNPC.ReanimatorType.valueOf(args[2].toUpperCase()); }
+                    catch (IllegalArgumentException e) { player.sendMessage(ChatColor.RED + ReanimateMC.lang.get("npc_invalid_type", "type", args[2])); return true; }
+                    List<Player> team = new ArrayList<>();
+                    for (int i = 3; i < args.length; i++) {
+                        Player m = Bukkit.getPlayer(args[i]);
+                        if (m == null) { player.sendMessage(ChatColor.RED + ReanimateMC.lang.get("player_not_found") + ": " + args[i]); return true; }
+                        team.add(m);
+                    }
+                    npcSummonManager.summonTeam(player, teamType, team);
                     return true;
                 }
+
+                // /rmc summon <type> [targetPlayer]
+                ReanimatorNPC.ReanimatorType type;
+                try { type = ReanimatorNPC.ReanimatorType.valueOf(args[1].toUpperCase()); }
+                catch (IllegalArgumentException e) { player.sendMessage(ChatColor.RED + ReanimateMC.lang.get("npc_invalid_type", "type", args[1])); return true; }
+                Player targetPlayer = args.length >= 3 ? Bukkit.getPlayer(args[2]) : null;
+                if (args.length >= 3 && targetPlayer == null) { player.sendMessage(ChatColor.RED + ReanimateMC.lang.get("player_not_found")); return true; }
+                npcSummonManager.summon(player, type, targetPlayer);
             }
-            
-            npcSummonManager.summon(player, type, targetPlayer);
-            
-        } else if (subCommand.equalsIgnoreCase("dismiss")) {
-            if (!(sender instanceof Player)) {
-                sender.sendMessage(ChatColor.RED + ReanimateMC.lang.get("command_player_only"));
-                return true;
-            }
-            Player player = (Player) sender;
-            if (!player.hasPermission("reanimate.summon")) {
-                player.sendMessage(ChatColor.RED + ReanimateMC.lang.get("no_permission"));
-                return true;
-            }
-            
-            if (args.length < 2) {
-                player.sendMessage(ChatColor.YELLOW + ReanimateMC.lang.get("command_dismiss_usage"));
-                return true;
-            }
-            
-            if (args[1].equalsIgnoreCase("all")) {
-                npcSummonManager.dismissAll(player);
-            } else {
-                player.sendMessage(ChatColor.RED + ReanimateMC.lang.get("command_dismiss_usage"));
-            }
-            
-        } else if (subCommand.equalsIgnoreCase("npcs") || subCommand.equalsIgnoreCase("npcstatus")) {
-            if (!(sender instanceof Player)) {
-                sender.sendMessage(ChatColor.RED + ReanimateMC.lang.get("command_player_only"));
-                return true;
+
+            case "dismiss" -> {
+                if (!(sender instanceof Player player)) { sender.sendMessage(ChatColor.RED + ReanimateMC.lang.get("command_player_only")); return true; }
+                if (!hasPerm(player, "reanimatemc.summon", true)) { player.sendMessage(ChatColor.RED + ReanimateMC.lang.get("no_permission")); return true; }
+                if (args.length < 2) { player.sendMessage(ChatColor.YELLOW + ReanimateMC.lang.get("command_dismiss_usage")); return true; }
+                if (args[1].equalsIgnoreCase("all")) {
+                    npcSummonManager.dismissAll(player);
+                } else {
+                    ReanimatorNPC.ReanimatorType tf = null;
+                    try { tf = ReanimatorNPC.ReanimatorType.valueOf(args[1].toUpperCase()); } catch (IllegalArgumentException ignored) {}
+                    if (tf != null) {
+                        int c = npcSummonManager.dismissByType(player, tf);
+                        if (c == 0) player.sendMessage(ChatColor.RED + ReanimateMC.lang.get("npc_none_active"));
+                    } else {
+                        player.sendMessage(ChatColor.RED + ReanimateMC.lang.get("command_dismiss_usage"));
+                    }
+                }
             }
-            Player player = (Player) sender;
-            if (!player.hasPermission("reanimate.summon")) {
-                player.sendMessage(ChatColor.RED + ReanimateMC.lang.get("no_permission"));
-                return true;
+
+            case "extend" -> {
+                if (!(sender instanceof Player player)) { sender.sendMessage(ChatColor.RED + ReanimateMC.lang.get("command_player_only")); return true; }
+                if (!hasPerm(player, "reanimatemc.summon", true)) { player.sendMessage(ChatColor.RED + ReanimateMC.lang.get("no_permission")); return true; }
+                if (args.length < 2) { player.sendMessage(ChatColor.YELLOW + ReanimateMC.lang.get("command_extend_usage")); return true; }
+                long secs;
+                try { secs = Long.parseLong(args[1]); if (secs <= 0) throw new NumberFormatException(); }
+                catch (NumberFormatException e) { player.sendMessage(ChatColor.RED + ReanimateMC.lang.get("command_extend_usage")); return true; }
+                boolean free = hasPerm(player, "reanimatemc.summon.overridecost", true);
+                npcSummonManager.extendNpcTime(player, secs, !free);
             }
-            
-            List<ReanimatorNPC> npcs = npcSummonManager.getPlayerSummons(player);
-            if (npcs.isEmpty()) {
-                player.sendMessage(ChatColor.YELLOW + ReanimateMC.lang.get("npc_none_active"));
-            } else {
-                player.sendMessage(ChatColor.GOLD + ReanimateMC.lang.get("npc_status_header"));
-                for (ReanimatorNPC npc : npcs) {
-                    long age = (System.currentTimeMillis() - npc.getSummonTime()) / 1000;
-                    player.sendMessage(ChatColor.AQUA + "- " + npc.getType().getDisplayName() + 
-                        ChatColor.GRAY + " (" + age + "s)");
-                }
+
+            case "npcs", "npcstatus" -> {
+                if (!(sender instanceof Player player)) { sender.sendMessage(ChatColor.RED + ReanimateMC.lang.get("command_player_only")); return true; }
+                if (!hasPerm(player, "reanimatemc.summon", true)) { player.sendMessage(ChatColor.RED + ReanimateMC.lang.get("no_permission")); return true; }
+                List<ReanimatorNPC> npcs = npcSummonManager.getPlayerSummons(player);
+                if (npcs.isEmpty()) { player.sendMessage(ChatColor.YELLOW + ReanimateMC.lang.get("npc_none_active")); }
+                else npcSummonManager.sendNpcStatus(player);
             }
-        } else {
-            sender.sendMessage(ChatColor.YELLOW + ReanimateMC.lang.get("command_unknown"));
+
+            // ── Help ──────────────────────────────────────────────────────────
+
+            case "help", "?" -> sendHelp(sender);
+
+            default -> sender.sendMessage(ChatColor.YELLOW + ReanimateMC.lang.get("command_unknown"));
         }
         return true;
     }
 
+    // ── Help / Version / Info ─────────────────────────────────────────────────
+
+    private void sendHelp(CommandSender sender) {
+        sender.sendMessage(ChatColor.GOLD + "━━━━━ ReanimateMC " + ReanimateMC.lang.get("cmd_help_title") + " ━━━━━");
+        row(sender, "/rmc reload",                               "cmd_help_reload");
+        row(sender, "/rmc revive <" + ReanimateMC.lang.get("cmd_arg_player") + ">",      "cmd_help_revive");
+        row(sender, "/rmc selfrevive",                            "cmd_help_selfrevive");
+        row(sender, "/rmc cancelselfrevive",                      "cmd_help_cancelselfrevive");
+        row(sender, "/rmc knockout <" + ReanimateMC.lang.get("cmd_arg_player") + ">",    "cmd_help_knockout");
+        row(sender, "/rmc status <" + ReanimateMC.lang.get("cmd_arg_player") + ">",      "cmd_help_status");
+        row(sender, "/rmc distress",                              "cmd_help_distress");
+        row(sender, "/rmc crawl",                                 "cmd_help_crawl");
+        row(sender, "/rmc config",                                "cmd_help_config");
+        row(sender, "/rmc summon <golem|healer|protector> [" + ReanimateMC.lang.get("cmd_arg_player") + "]", "cmd_help_summon");
+        row(sender, "/rmc summon team <golem|healer|protector> <p1> <p2...>",             "cmd_help_summon_team");
+        row(sender, "/rmc dismiss <all|golem|healer|protector>",  "cmd_help_dismiss");
+        row(sender, "/rmc extend <" + ReanimateMC.lang.get("cmd_arg_seconds") + ">",     "cmd_help_extend");
+        row(sender, "/rmc npcs",                                  "cmd_help_npcs");
+        row(sender, "/rmc purge",                                 "cmd_help_purge");
+        row(sender, "/rmc kolist",                                "cmd_help_kolist");
+        row(sender, "/rmc info",                                  "cmd_help_info");
+        row(sender, "/rmc version",                               "cmd_help_version");
+        sender.sendMessage(ChatColor.GOLD + "━━━━━━━━━━━━━━━━━━━━━━━━━━━━");
+    }
+
+    private void row(CommandSender s, String cmd, String descKey) {
+        s.sendMessage(ChatColor.YELLOW + cmd + ChatColor.GRAY + " - " + ReanimateMC.lang.get(descKey));
+    }
+
+    private void sendVersion(CommandSender sender) {
+        String version = ReanimateMC.getInstance().getDescription().getVersion();
+        String authors = String.join(", ", ReanimateMC.getInstance().getDescription().getAuthors());
+        String mcVersion = Bukkit.getMinecraftVersion();
+        sender.sendMessage(ChatColor.GOLD + "━━━━━ ReanimateMC ━━━━━");
+        sender.sendMessage(ChatColor.GRAY + ReanimateMC.lang.get("cmd_version_plugin")  + " " + ChatColor.WHITE + "v" + version);
+        sender.sendMessage(ChatColor.GRAY + ReanimateMC.lang.get("cmd_version_author")  + " " + ChatColor.WHITE + authors);
+        sender.sendMessage(ChatColor.GRAY + ReanimateMC.lang.get("cmd_version_mc")      + " " + ChatColor.WHITE + mcVersion);
+        sender.sendMessage(ChatColor.GRAY + ReanimateMC.lang.get("cmd_version_api")     + " " + ChatColor.WHITE + "Paper 1.21.4");
+        sender.sendMessage(ChatColor.GOLD + "━━━━━━━━━━━━━━━━━━━━━━━");
+    }
+
+    private void sendPluginInfo(CommandSender sender) {
+        String version  = ReanimateMC.getInstance().getDescription().getVersion();
+        String authors  = String.join(", ", ReanimateMC.getInstance().getDescription().getAuthors());
+        String mcVersion = Bukkit.getMinecraftVersion();
+        boolean vaultOk = ReanimateMC.getInstance().getVault() != null
+                && ReanimateMC.getInstance().getVault().isEnabled();
+        boolean papiOk  = Bukkit.getPluginManager().getPlugin("PlaceholderAPI") != null;
+        boolean npcOk   = ReanimateMC.getInstance().getConfig().getBoolean("npc_summon.enabled", false);
+        boolean koOk    = ReanimateMC.getInstance().getConfig().getBoolean("knockout.enabled", true);
+        boolean exeOk   = ReanimateMC.getInstance().getConfig().getBoolean("execution.enabled", true);
+        boolean selfRev = ReanimateMC.getInstance().getConfig().getBoolean("self_revive.enabled", true);
+        boolean crawlOk = ReanimateMC.getInstance().getConfig().getBoolean("prone.allow_crawl", false);
+        boolean distress= ReanimateMC.getInstance().getConfig().getBoolean("knockout.distress.enabled", true);
+        int koCount     = koManager.getKOPlayerUUIDs().size();
+        String lang     = ReanimateMC.getInstance().getConfig().getString("language", "en");
+
+        String on  = ChatColor.GREEN  + "✔";
+        String off = ChatColor.RED    + "✘";
+
+        sender.sendMessage(ChatColor.GOLD + "━━━━━━━━━ ReanimateMC ━━━━━━━━━");
+        sender.sendMessage(ChatColor.GRAY + "  Version  " + ChatColor.WHITE + "v" + version
+                + ChatColor.DARK_GRAY + "  |  " + ChatColor.GRAY + "API " + ChatColor.WHITE + mcVersion
+                + ChatColor.DARK_GRAY + "  |  " + ChatColor.GRAY + "Author " + ChatColor.WHITE + authors);
+        sender.sendMessage(ChatColor.GRAY + "  Language " + ChatColor.WHITE + lang);
+        sender.sendMessage(ChatColor.GOLD + " ─── Systems ───────────────────");
+        sender.sendMessage(ChatColor.GRAY + "  K.O. System          " + (koOk   ? on : off));
+        sender.sendMessage(ChatColor.GRAY + "  Execution System      " + (exeOk  ? on : off));
+        sender.sendMessage(ChatColor.GRAY + "  Crawl / Prone         " + (crawlOk? on : off));
+        sender.sendMessage(ChatColor.GRAY + "  Distress Signal       " + (distress?on : off));
+        sender.sendMessage(ChatColor.GRAY + "  Self-Revive           " + (selfRev? on : off));
+        sender.sendMessage(ChatColor.GRAY + "  NPC Reanimators       " + (npcOk  ? on : off));
+        sender.sendMessage(ChatColor.GOLD + " ─── Integrations ──────────────");
+        sender.sendMessage(ChatColor.GRAY + "  Vault Economy         " + (vaultOk? on : off));
+        sender.sendMessage(ChatColor.GRAY + "  PlaceholderAPI        " + (papiOk ? on : off));
+        sender.sendMessage(ChatColor.GOLD + " ─── Live Status ───────────────");
+        sender.sendMessage(ChatColor.GRAY + "  Players currently K.O.: " + ChatColor.WHITE + koCount);
+        sender.sendMessage(ChatColor.YELLOW + "  Type /rmc help for all commands");
+        sender.sendMessage(ChatColor.GOLD + "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━");
+    }
+
+    // ── Tab complete ──────────────────────────────────────────────────────────
+
     @Override
-    public List<String> onTabComplete(CommandSender commandSender, Command command, String s, String[] strings) {
-        // Tout les tab completions
-        if (strings.length == 1) {
-            return List.of("reload", "revive", "knockout", "status", "crawl", "removeGlowingEffect", "config", "summon", "dismiss", "npcs");
-        } else if (strings.length == 2) {
-            // Si le premier argument est "revive", "knockout" ou "status", on affiche les joueurs en ligne
-            if (strings[0].equalsIgnoreCase("revive") || strings[0].equalsIgnoreCase("knockout") || strings[0].equalsIgnoreCase("status") || strings[0].equalsIgnoreCase("removeGlowingEffect")) {
-                return Bukkit.getOnlinePlayers().stream()
-                        .map(Player::getName)
-                        .toList();
-            } else if (strings[0].equalsIgnoreCase("summon")) {
-                // Show NPC types
-                List<String> types = new ArrayList<>();
-                for (ReanimatorNPC.ReanimatorType type : ReanimatorNPC.ReanimatorType.values()) {
-                    types.add(type.name().toLowerCase());
+    public List<String> onTabComplete(CommandSender sender, Command command, String alias, String[] args) {
+        if (args.length == 1) {
+            return filter(List.of("reload", "revive", "selfrevive", "sr", "cancelselfrevive",
+                    "cancelsr", "knockout", "status", "crawl", "distress",
+                    "config", "summon", "dismiss", "extend", "npcs", "purge", "help",
+                    "version", "info", "kolist", "removeGlowingEffect"), args[0]);
+        }
+        if (args.length == 2) {
+            return switch (args[0].toLowerCase()) {
+                case "revive", "knockout", "status", "removeglowingeffect",
+                        "removeglowingreffect", "removeglow" -> onlinePlayers(args[1]);
+                case "summon" -> filter(typeNames("team"), args[1]);
+                case "dismiss" -> filter(typeNames("all"), args[1]);
+                default -> List.of();
+            };
+        }
+        if (args.length == 3) {
+            if (args[0].equalsIgnoreCase("summon")) {
+                if (args[1].equalsIgnoreCase("team")) {
+                    // /rmc summon team <type>
+                    return filter(typeNames(), args[2]);
                 }
-                return types;
-            } else if (strings[0].equalsIgnoreCase("dismiss")) {
-                return List.of("all");
-            }
-        } else if (strings.length == 3) {
-            // For summon command, show player names as optional target
-            if (strings[0].equalsIgnoreCase("summon")) {
-                return Bukkit.getOnlinePlayers().stream()
-                        .map(Player::getName)
-                        .toList();
+                // /rmc summon <type> [player]
+                return onlinePlayers(args[2]);
             }
         }
-
+        // /rmc summon team <type> <p1> <p2>... — keep suggesting players
+        if (args.length >= 4 && args[0].equalsIgnoreCase("summon") && args[1].equalsIgnoreCase("team")) {
+            return onlinePlayers(args[args.length - 1]);
+        }
         return List.of();
     }
-}
 
+    private List<String> onlinePlayers(String prefix) {
+        return Bukkit.getOnlinePlayers().stream()
+                .map(Player::getName)
+                .filter(n -> n.toLowerCase().startsWith(prefix.toLowerCase()))
+                .collect(Collectors.toList());
+    }
+
+    private List<String> typeNames(String... extra) {
+        List<String> list = new ArrayList<>();
+        for (ReanimatorNPC.ReanimatorType t : ReanimatorNPC.ReanimatorType.values()) {
+            list.add(t.name().toLowerCase());
+        }
+        for (String e : extra) list.add(e);
+        return list;
+    }
 
+    private List<String> filter(List<String> source, String prefix) {
+        return source.stream()
+                .filter(s -> s.toLowerCase().startsWith(prefix.toLowerCase()))
+                .collect(Collectors.toList());
+    }
+}
diff --git a/src/main/java/fr/jachou/reanimatemc/data/KOData.java b/src/main/java/fr/jachou/reanimatemc/data/KOData.java
index 6f3db39..6397577 100644
--- a/src/main/java/fr/jachou/reanimatemc/data/KOData.java
+++ b/src/main/java/fr/jachou/reanimatemc/data/KOData.java
@@ -8,7 +8,13 @@ public class KOData {
     private int taskId;
     private boolean crawling;
     private int barTaskId;
-    private int suicideTaskId = -1;
+    private int suicideTaskId      = -1;
+    private int effectEnforcerId   = -1;
+    private long lastDistressTime  = 0L;
+    private long lastSneakTime     = 0L;
+    private long lastDamageTime    = 0L;
+    private int  selfReviveUses    = 0;
+    private int  selfReviveTaskId  = -1;
     private ArmorStand mount;
     private ArmorStand label;
     private ArmorStand helpMarker;
@@ -60,14 +66,28 @@ public void setOriginalJumpStrength(double originalJumpStrength) {
         this.originalJumpStrength = originalJumpStrength;
     }
 
-    public int getSuicideTaskId() {
-        return suicideTaskId;
+    public int getSuicideTaskId()                    { return suicideTaskId; }
+    public void setSuicideTaskId(int id)             { this.suicideTaskId = id; }
+    public int getEffectEnforcerId()                 { return effectEnforcerId; }
+    public void setEffectEnforcerId(int id)          { this.effectEnforcerId = id; }
+
+    public long getLastDistressTime() {
+        return lastDistressTime;
     }
 
-    public void setSuicideTaskId(int suicideTaskId) {
-        this.suicideTaskId = suicideTaskId;
+    public void setLastDistressTime(long lastDistressTime) {
+        this.lastDistressTime = lastDistressTime;
     }
 
+    public long getLastSneakTime()                   { return lastSneakTime; }
+    public void setLastSneakTime(long t)             { this.lastSneakTime = t; }
+    public long getLastDamageTime()                  { return lastDamageTime; }
+    public void setLastDamageTime(long t)            { this.lastDamageTime = t; }
+    public int  getSelfReviveUses()                  { return selfReviveUses; }
+    public void incrementSelfReviveUses()            { this.selfReviveUses++; }
+    public int  getSelfReviveTaskId()                { return selfReviveTaskId; }
+    public void setSelfReviveTaskId(int id)          { this.selfReviveTaskId = id; }
+
     public void setKo(boolean isKo) {
         this.isKo = isKo;
     }
diff --git a/src/main/java/fr/jachou/reanimatemc/data/ReanimatorNPC.java b/src/main/java/fr/jachou/reanimatemc/data/ReanimatorNPC.java
index 65ea40f..7a735ea 100644
--- a/src/main/java/fr/jachou/reanimatemc/data/ReanimatorNPC.java
+++ b/src/main/java/fr/jachou/reanimatemc/data/ReanimatorNPC.java
@@ -8,87 +8,155 @@
 package fr.jachou.reanimatemc.data;
 
 import org.bukkit.entity.Entity;
-import org.bukkit.entity.Player;
 
+import fr.jachou.reanimatemc.ReanimateMC;
 import java.util.UUID;
 
 /**
- * Represents a summoned NPC/Golem reanimator
+ * Represents a summoned NPC/Golem reanimator.
+ *
+ * <p>Each type has distinct behavior driven by NPCSummonManager:
+ * <ul>
+ *   <li>GOLEM      – standard: follows owner, revives KO'd players.</li>
+ *   <li>HEALER     – support: auto-scans for KO'd allies, regeneration aura when
+ *                    owner is low HP, periodic passive heal to owner, bonus HP on revive.</li>
+ *   <li>PROTECTOR  – tank: 200 HP, attacks hostile mobs, transfers a portion of
+ *                    incoming owner damage to itself, knockback burst on owner revive.</li>
+ * </ul>
+ *
+ * <p>All summons have a configurable lifetime. Use {@link #getRemainingSeconds()} to
+ * query remaining time and {@link #extendTime(long)} to add more seconds.
  */
 public class ReanimatorNPC {
+
     private final UUID id;
     private final UUID ownerId;
     private final String ownerName;
     private final Entity entity;
     private final ReanimatorType type;
     private final long summonTime;
+
+    /** Absolute epoch-ms when this NPC expires. -1 = no expiry. */
+    private long expiresAt;
+
     private UUID targetPlayerId;
-    
+
+    /** Tick counter used to throttle per-type periodic actions. */
+    private int behaviorTick = 0;
+
+    /** Counter incremented once per onIdleTick call; used by HealerBehavior for heal throttle. */
+    private int idleTick = 0;
+
+    /** Whether the HEALER regeneration aura is currently active. */
+    private boolean healerAuraActive  = false;
+    /** Whether the PROTECTOR already sent the "can't revive" warning this KO session. */
+    private boolean protectorWarned   = false;
+
+    // ── Stuck detection ───────────────────────────────────────────────────────
+    /** Last recorded location, sampled every behavior tick to detect stuck state. */
+    private org.bukkit.Location lastPosition = null;
+
+    /** Consecutive ticks the NPC hasn't moved while it should be following. */
+    private int stuckTicks = 0;
+
     public enum ReanimatorType {
-        GOLEM("Iron Golem Reanimator"),
-        HEALER("Healing Golem"),
-        PROTECTOR("Protective Golem");
-        
-        private final String displayName;
-        
-        ReanimatorType(String displayName) {
-            this.displayName = displayName;
+        GOLEM("npc_name_golem", "Iron Golem Reanimator"),
+        HEALER("npc_name_healer", "Healing Golem"),
+        PROTECTOR("npc_name_protector", "Protective Golem");
+
+        private final String langKey;
+        private final String fallback;
+
+        ReanimatorType(String langKey, String fallback) {
+            this.langKey  = langKey;
+            this.fallback = fallback;
         }
-        
+
+        /** Returns the localized display name, falling back to the English default. */
         public String getDisplayName() {
-            return displayName;
+            try {
+                String v = ReanimateMC.lang.get(langKey);
+                return (v == null || v.isEmpty() || v.equals(langKey)) ? fallback : v;
+            } catch (Exception e) {
+                return fallback;
+            }
         }
+
+        public String getLangKey() { return langKey; }
     }
-    
-    public ReanimatorNPC(UUID ownerId, String ownerName, Entity entity, ReanimatorType type) {
-        this.id = UUID.randomUUID();
-        this.ownerId = ownerId;
-        this.ownerName = ownerName;
-        this.entity = entity;
-        this.type = type;
-        this.summonTime = System.currentTimeMillis();
-        this.targetPlayerId = null;
-    }
-    
-    public UUID getId() {
-        return id;
-    }
-    
-    public UUID getOwnerId() {
-        return ownerId;
-    }
-    
-    public String getOwnerName() {
-        return ownerName;
-    }
-    
-    public Entity getEntity() {
-        return entity;
-    }
-    
-    public ReanimatorType getType() {
-        return type;
+
+    public ReanimatorNPC(UUID ownerId, String ownerName, Entity entity, ReanimatorType type, long lifetimeSeconds) {
+        this.id          = UUID.randomUUID();
+        this.ownerId     = ownerId;
+        this.ownerName   = ownerName;
+        this.entity      = entity;
+        this.type        = type;
+        this.summonTime  = System.currentTimeMillis();
+        this.expiresAt   = lifetimeSeconds > 0
+                ? this.summonTime + lifetimeSeconds * 1000L
+                : -1L;
     }
-    
-    public long getSummonTime() {
-        return summonTime;
+
+    // ── Getters ───────────────────────────────────────────────────────────────
+
+    public UUID getId()           { return id; }
+    public UUID getOwnerId()      { return ownerId; }
+    public String getOwnerName()  { return ownerName; }
+    public Entity getEntity()     { return entity; }
+    public ReanimatorType getType() { return type; }
+    public long getSummonTime()   { return summonTime; }
+    public long getExpiresAt()    { return expiresAt; }
+
+    public UUID getTargetPlayerId() { return targetPlayerId; }
+    public void setTargetPlayerId(UUID id) { this.targetPlayerId = id; }
+
+    public int getBehaviorTick() { return behaviorTick; }
+    public void incrementBehaviorTick() { this.behaviorTick++; }
+
+    public int getIdleTick() { return idleTick; }
+    public void incrementIdleTick() { this.idleTick++; }
+
+    public boolean isHealerAuraActive()              { return healerAuraActive; }
+    public void setHealerAuraActive(boolean active)  { this.healerAuraActive = active; }
+    public boolean isProtectorWarned()               { return protectorWarned; }
+    public void setProtectorWarned(boolean warned)   { this.protectorWarned = warned; }
+
+    public org.bukkit.Location getLastPosition()                        { return lastPosition; }
+    public void setLastPosition(org.bukkit.Location loc)                { this.lastPosition = loc; }
+    public int getStuckTicks()                                          { return stuckTicks; }
+    public void incrementStuckTicks()                                   { this.stuckTicks++; }
+    public void resetStuckTicks()                                       { this.stuckTicks = 0; }
+
+    // ── Lifetime helpers ──────────────────────────────────────────────────────
+
+    /** Returns true if this NPC has a finite lifetime and it has expired. */
+    public boolean isExpired() {
+        return expiresAt > 0 && System.currentTimeMillis() >= expiresAt;
     }
-    
-    public UUID getTargetPlayerId() {
-        return targetPlayerId;
+
+    /** Remaining seconds until expiry, or {@link Long#MAX_VALUE} if no expiry set. */
+    public long getRemainingSeconds() {
+        if (expiresAt <= 0) return Long.MAX_VALUE;
+        long rem = (expiresAt - System.currentTimeMillis()) / 1000L;
+        return Math.max(0, rem);
     }
-    
-    public void setTargetPlayerId(UUID targetPlayerId) {
-        this.targetPlayerId = targetPlayerId;
+
+    /** Adds {@code seconds} to the expiry time. Creates an expiry if none was set. */
+    public void extendTime(long seconds) {
+        if (expiresAt <= 0) {
+            expiresAt = System.currentTimeMillis() + seconds * 1000L;
+        } else {
+            expiresAt += seconds * 1000L;
+        }
     }
-    
+
+    // ── Entity validity ───────────────────────────────────────────────────────
+
     public boolean isValid() {
         return entity != null && entity.isValid();
     }
-    
+
     public void remove() {
-        if (entity != null && entity.isValid()) {
-            entity.remove();
-        }
+        if (entity != null && entity.isValid()) entity.remove();
     }
 }
diff --git a/src/main/java/fr/jachou/reanimatemc/gui/ConfigGUI.java b/src/main/java/fr/jachou/reanimatemc/gui/ConfigGUI.java
index d3be217..db33ebd 100644
--- a/src/main/java/fr/jachou/reanimatemc/gui/ConfigGUI.java
+++ b/src/main/java/fr/jachou/reanimatemc/gui/ConfigGUI.java
@@ -83,6 +83,26 @@ public class ConfigGUI implements Listener {
                 new GuiOption("option_knockout_fatigue", 24, OptionType.INTEGER));
         GAMEPLAY_OPTIONS.put("execution.message_broadcast",
                 new GuiOption("option_execution_broadcast", 25, OptionType.BOOLEAN));
+        GAMEPLAY_OPTIONS.put("knockout.mobs_attack_ko",
+                new GuiOption("option_mobs_attack_ko", 26, OptionType.BOOLEAN));
+        GAMEPLAY_OPTIONS.put("knockout.knockback_disabled",
+                new GuiOption("option_knockback_disabled", 29, OptionType.BOOLEAN));
+        GAMEPLAY_OPTIONS.put("knockout.surrender_require_still",
+                new GuiOption("option_surrender_require_still", 30, OptionType.BOOLEAN));
+        GAMEPLAY_OPTIONS.put("knockout.crawl_nausea_enabled",
+                new GuiOption("option_crawl_nausea_enabled", 31, OptionType.BOOLEAN));
+        GAMEPLAY_OPTIONS.put("knockout.crawl_nausea_level",
+                new GuiOption("option_crawl_nausea_level", 32, OptionType.INTEGER));
+
+        // NPC options (slots 33-36)
+        GAMEPLAY_OPTIONS.put("npc_summon.enabled",
+                new GuiOption("option_npc_enabled", 33, OptionType.BOOLEAN));
+        GAMEPLAY_OPTIONS.put("npc_summon.invulnerable",
+                new GuiOption("option_npc_invulnerable", 34, OptionType.BOOLEAN));
+        GAMEPLAY_OPTIONS.put("npc_summon.protector.damage_transfer_ratio",
+                new GuiOption("option_npc_damage_transfer", 35, OptionType.DOUBLE));
+        GAMEPLAY_OPTIONS.put("npc_summon.protector.revive_if_no_healer",
+                new GuiOption("option_npc_protector_revive", 36, OptionType.BOOLEAN));
 
         // Interface (Ligne 4: slots 28-29)
         INTERFACE_OPTIONS.put("tablist.enabled",
@@ -115,7 +135,7 @@ public class ConfigGUI implements Listener {
     private static final List<String> LANGS = Arrays.asList("en", "fr", "es", "de", "pt", "it");
 
     private enum OptionType {
-        BOOLEAN, INTEGER, MATERIAL
+        BOOLEAN, INTEGER, DOUBLE, MATERIAL
     }
 
     private static class GuiOption {
@@ -266,6 +286,17 @@ private ItemStack createOptionItem(String path, GuiOption opt) {
                 lore.add(ChatColor.GRAY + ReanimateMC.lang.get("shift_click_increment"));
                 break;
 
+            case DOUBLE:
+                double dval = cfg.getDouble(path, 0.0);
+                item = new ItemStack(Material.COMPARATOR);
+                meta = item.getItemMeta();
+                meta.setDisplayName(ChatColor.YELLOW + name);
+                lore.add(ChatColor.WHITE + ReanimateMC.lang.get("current_value", "value", String.format("%.2f", dval)));
+                lore.add("");
+                lore.add(ChatColor.GRAY + ReanimateMC.lang.get("click_decrease_005"));
+                lore.add(ChatColor.GRAY + ReanimateMC.lang.get("shift_click_increase_005"));
+                break;
+
             case MATERIAL:
                 String materialName = cfg.getString(path, "STONE");
                 Material material;
@@ -611,6 +642,27 @@ private void handleOptionClick(Inventory inv, Player player, int slot, boolean s
                     handleIntegerEdit(player, configPath, option);
                 }
                 break;
+            case DOUBLE:
+                if (shiftClick) {
+                    double curD = cfg.getDouble(configPath, 0.0);
+                    double newD = Math.min(1.0, Math.round((curD + 0.05) * 100.0) / 100.0);
+                    cfg.set(configPath, newD);
+                    ReanimateMC.getInstance().saveConfig();
+                    inv.setItem(option.slot, createOptionItem(configPath, option));
+                    String stateD = String.format("%.2f", newD);
+                    player.sendMessage(ChatColor.GREEN + ReanimateMC.lang.get("message_gui_toggle",
+                            "option", ReanimateMC.lang.get(option.langKey), "state", stateD));
+                } else {
+                    double curD = cfg.getDouble(configPath, 0.0);
+                    double newD = Math.max(0.0, Math.round((curD - 0.05) * 100.0) / 100.0);
+                    cfg.set(configPath, newD);
+                    ReanimateMC.getInstance().saveConfig();
+                    inv.setItem(option.slot, createOptionItem(configPath, option));
+                    String stateD = String.format("%.2f", newD);
+                    player.sendMessage(ChatColor.GREEN + ReanimateMC.lang.get("message_gui_toggle",
+                            "option", ReanimateMC.lang.get(option.langKey), "state", stateD));
+                }
+                break;
             case MATERIAL:
                 handleMaterialEdit(player, configPath, option);
                 break;
@@ -700,6 +752,10 @@ private void resetAllOptions() {
         cfg.set("effects_on_revive.slowness", 10);
         cfg.set("effects_on_revive.resistance", 10);
 
+        cfg.set("knockout.mobs_attack_ko", false);
+        cfg.set("knockout.knockback_disabled", true);
+        cfg.set("knockout.surrender_require_still", true);
+
         plugin.saveConfig();
     }
 }
\ No newline at end of file
diff --git a/src/main/java/fr/jachou/reanimatemc/hooks/PlaceholderHook.java b/src/main/java/fr/jachou/reanimatemc/hooks/PlaceholderHook.java
new file mode 100644
index 0000000..fe348a7
--- /dev/null
+++ b/src/main/java/fr/jachou/reanimatemc/hooks/PlaceholderHook.java
@@ -0,0 +1,89 @@
+package fr.jachou.reanimatemc.hooks;
+
+import fr.jachou.reanimatemc.ReanimateMC;
+import fr.jachou.reanimatemc.data.ReanimatorNPC;
+import fr.jachou.reanimatemc.managers.KOManager;
+import fr.jachou.reanimatemc.managers.NPCSummonManager;
+import me.clip.placeholderapi.expansion.PlaceholderExpansion;
+import org.bukkit.entity.Player;
+import org.jetbrains.annotations.NotNull;
+
+import java.util.List;
+
+/**
+ * PlaceholderAPI expansion for ReanimateMC.
+ *
+ * <p>Available placeholders (prefix: {@code %reanimatemc_<key>%}):
+ * <ul>
+ *   <li>{@code is_ko}              – "true" / "false"</li>
+ *   <li>{@code ko_time_remaining}  – seconds left in KO, or "0"</li>
+ *   <li>{@code npc_count}          – number of active NPCs for this player</li>
+ *   <li>{@code npc_type}           – type of first active NPC, or "none"</li>
+ *   <li>{@code npc_time_remaining} – seconds left on first active NPC, or "0"</li>
+ *   <li>{@code npc_hp}             – HP of first active NPC, or "0"</li>
+ * </ul>
+ */
+public final class PlaceholderHook extends PlaceholderExpansion {
+
+    private final ReanimateMC plugin;
+    private final KOManager koManager;
+    private final NPCSummonManager npcSummonManager;
+
+    public PlaceholderHook(ReanimateMC plugin, KOManager koManager, NPCSummonManager npcSummonManager) {
+        this.plugin          = plugin;
+        this.koManager       = koManager;
+        this.npcSummonManager = npcSummonManager;
+    }
+
+    @Override public @NotNull String getIdentifier() { return "reanimatemc"; }
+    @Override public @NotNull String getAuthor()     { return "Jachou"; }
+    @Override public @NotNull String getVersion()    { return plugin.getDescription().getVersion(); }
+    @Override public boolean persist()               { return true; }
+    @Override public boolean canRegister()           { return true; }
+
+    @Override
+    public String onPlaceholderRequest(Player player, @NotNull String params) {
+        if (player == null) return "";
+
+        switch (params.toLowerCase()) {
+            case "is_ko":
+                return String.valueOf(koManager.isKO(player));
+
+            case "ko_time_remaining": {
+                if (!koManager.isKO(player)) return "0";
+                long rem = koManager.getRemainingKOSeconds(player);
+                return String.valueOf(Math.max(0, rem));
+            }
+
+            case "npc_count": {
+                return String.valueOf(npcSummonManager.getPlayerSummons(player).size());
+            }
+
+            case "npc_type": {
+                List<ReanimatorNPC> npcs = npcSummonManager.getPlayerSummons(player);
+                if (npcs.isEmpty()) return "none";
+                return npcs.get(0).getType().name().toLowerCase();
+            }
+
+            case "npc_time_remaining": {
+                List<ReanimatorNPC> npcs = npcSummonManager.getPlayerSummons(player);
+                if (npcs.isEmpty()) return "0";
+                long rem = npcs.get(0).getRemainingSeconds();
+                return String.valueOf(Math.max(0, rem));
+            }
+
+            case "npc_hp": {
+                List<ReanimatorNPC> npcs = npcSummonManager.getPlayerSummons(player);
+                if (npcs.isEmpty()) return "0";
+                org.bukkit.entity.Entity e = npcs.get(0).getEntity();
+                if (e instanceof org.bukkit.entity.LivingEntity) {
+                    return String.valueOf((int) ((org.bukkit.entity.LivingEntity) e).getHealth());
+                }
+                return "0";
+            }
+
+            default:
+                return null;
+        }
+    }
+}
diff --git a/src/main/java/fr/jachou/reanimatemc/hooks/VaultHook.java b/src/main/java/fr/jachou/reanimatemc/hooks/VaultHook.java
new file mode 100644
index 0000000..c363c2d
--- /dev/null
+++ b/src/main/java/fr/jachou/reanimatemc/hooks/VaultHook.java
@@ -0,0 +1,61 @@
+package fr.jachou.reanimatemc.hooks;
+
+import net.milkbowl.vault.economy.Economy;
+import org.bukkit.entity.Player;
+import org.bukkit.plugin.RegisteredServiceProvider;
+import org.bukkit.plugin.java.JavaPlugin;
+
+/**
+ * Thin wrapper around Vault's Economy API.
+ *
+ * <p>All callers must check {@link #isEnabled()} before calling any economy
+ * method. If Vault or an economy provider is absent, methods are no-ops.
+ */
+public final class VaultHook {
+
+    private Economy economy = null;
+    private boolean enabled = false;
+
+    public VaultHook(JavaPlugin plugin) {
+        if (plugin.getServer().getPluginManager().getPlugin("Vault") == null) return;
+        RegisteredServiceProvider<Economy> rsp =
+                plugin.getServer().getServicesManager().getRegistration(Economy.class);
+        if (rsp == null) return;
+        economy = rsp.getProvider();
+        enabled = true;
+        plugin.getLogger().info("[ReanimateMC] Vault economy hooked: " + economy.getName());
+    }
+
+    public boolean isEnabled() { return enabled; }
+
+    /** Returns the player's current balance, or 0 if unavailable. */
+    public double getBalance(Player player) {
+        if (!enabled) return 0;
+        return economy.getBalance(player);
+    }
+
+    /**
+     * Withdraws {@code amount} from the player.
+     * @return true if the transaction succeeded.
+     */
+    public boolean withdraw(Player player, double amount) {
+        if (!enabled) return false;
+        if (!economy.has(player, amount)) return false;
+        return economy.withdrawPlayer(player, amount).transactionSuccess();
+    }
+
+    /**
+     * Deposits {@code amount} to the player.
+     * @return true if the transaction succeeded.
+     */
+    public boolean deposit(Player player, double amount) {
+        if (!enabled) return false;
+        return economy.depositPlayer(player, amount).transactionSuccess();
+    }
+
+    /** Returns the economy's currency format for the given amount. */
+    public String format(double amount) {
+        if (!enabled) return String.valueOf(amount);
+        return economy.format(amount);
+    }
+}
diff --git a/src/main/java/fr/jachou/reanimatemc/listeners/ExecutionListener.java b/src/main/java/fr/jachou/reanimatemc/listeners/ExecutionListener.java
index e858255..3beb661 100644
--- a/src/main/java/fr/jachou/reanimatemc/listeners/ExecutionListener.java
+++ b/src/main/java/fr/jachou/reanimatemc/listeners/ExecutionListener.java
@@ -8,8 +8,13 @@
 import org.bukkit.event.Listener;
 import org.bukkit.event.entity.EntityDamageByEntityEvent;
 
+import java.util.HashMap;
+import java.util.Map;
+import java.util.UUID;
+
 public class ExecutionListener implements Listener {
-    private KOManager koManager;
+    private final KOManager koManager;
+    private final Map<UUID, UUID> pendingExecutions = new HashMap<>(); // victim -> executioner
 
     public ExecutionListener(KOManager koManager) {
         this.koManager = koManager;
@@ -28,17 +33,22 @@ public void onEntityDamageByEntity(EntityDamageByEntityEvent event) {
         if (!ReanimateMC.getInstance().getConfig().getBoolean("execution.enabled"))
             return;
 
-        // If this hit just caused the KO, don't instantly execute
-        if (victim.getHealth() - event.getFinalDamage() <= 0)
-            return;
-
         event.setCancelled(true);
 
+        // If another player is already executing this victim, block the new attempt
+        UUID currentExecutioner = pendingExecutions.get(victim.getUniqueId());
+        if (currentExecutioner != null && !currentExecutioner.equals(damager.getUniqueId())) {
+            damager.sendMessage(ChatColor.RED + ReanimateMC.lang.get("execution_in_progress"));
+            return;
+        }
+
         damager.sendMessage(ChatColor.RED + ReanimateMC.lang.get("execution_in_progress"));
-        int holdDuration = ReanimateMC.getInstance().getConfig().getInt("execution.hold_duration_ticks");
+        int holdDuration = ReanimateMC.getInstance().getConfig().getInt("execution.hold_duration_ticks", 40);
+
+        pendingExecutions.put(victim.getUniqueId(), damager.getUniqueId());
 
-        // Après le délai, si le joueur est toujours K.O., l'exécution s’effectue
         ReanimateMC.getInstance().getServer().getScheduler().runTaskLater(ReanimateMC.getInstance(), () -> {
+            pendingExecutions.remove(victim.getUniqueId());
             if (koManager.isKO(victim)) {
                 koManager.execute(victim);
             }
diff --git a/src/main/java/fr/jachou/reanimatemc/listeners/GolemManager.java b/src/main/java/fr/jachou/reanimatemc/listeners/GolemManager.java
index 203bc3f..3998742 100644
--- a/src/main/java/fr/jachou/reanimatemc/listeners/GolemManager.java
+++ b/src/main/java/fr/jachou/reanimatemc/listeners/GolemManager.java
@@ -12,8 +12,6 @@
 import org.bukkit.event.player.PlayerInteractEntityEvent;
 import org.bukkit.inventory.ItemStack;
 
-import java.util.Random;
-
 public class GolemManager implements Listener {
 
     @EventHandler
@@ -21,25 +19,19 @@ public void onRightClickGolem(PlayerInteractEntityEvent event) {
         Player p = event.getPlayer();
         Entity e = event.getRightClicked();
 
-
-        // Le joueur doit être accroupi
         if (!p.isSneaking()) {
             return;
         }
 
-        // Vérifie que la fonctionnalité golem est activée
         if (!ReanimateMC.getInstance().getConfig().getBoolean("npc_summon.enabled", false)) {
             return;
         }
 
-        // Vérifie que l'entité est bien un golem de fer
         if (!(e instanceof IronGolem)) {
             return;
         }
 
-        // Récupère le matériau requis depuis la configuration
         String itemName = ReanimateMC.getInstance().getConfig().getString("npc_summon.item_to_summon_golem", "GOLD_INGOT");
-
         Material requiredMaterial = Material.matchMaterial(itemName);
 
         if (requiredMaterial == null) {
@@ -48,31 +40,32 @@ public void onRightClickGolem(PlayerInteractEntityEvent event) {
         }
 
         ItemStack inHand = p.getInventory().getItemInMainHand();
+        if (inHand.getType() != requiredMaterial) {
+            return;
+        }
 
-        if (inHand == null || inHand.getType() != requiredMaterial) {
-            return; // Le joueur n'a pas le bon item
+        int maxSummons = ReanimateMC.getInstance().getConfig().getInt("npc_summon.max_summons_per_player", 1);
+        if (ReanimateMC.getInstance().getNpcSummonManager().getPlayerGolems(p) >= maxSummons) {
+            return;
         }
 
-        if (ReanimateMC.getInstance().getNpcSummonManager().getPlayerGolems(p) >= ReanimateMC.getInstance().getConfig().getInt("npc_summon.max_summons_per_player")) {
+        // Pick the highest-tier type the player has permission for
+        ReanimatorNPC.ReanimatorType type = resolveAllowedType(p);
+        if (type == null) {
+            p.sendMessage(ChatColor.RED + ReanimateMC.lang.get("no_permission"));
             return;
         }
 
-        // Supprime l'entité golem actuelle
         e.remove();
 
-        // Choisit un type de réanimateur aléatoire
-        ReanimatorNPC.ReanimatorType type = getReanimatorType();
-
-        // Vérifie et invoque le PNJ réanimateur
         if (ReanimateMC.getInstance().getNpcSummonManager() != null) {
-            ReanimateMC.getInstance().getNpcSummonManager().summon(p, type, p);
+            ReanimateMC.getInstance().getNpcSummonManager().summon(p, type, null);
         } else {
             p.sendMessage(ChatColor.RED + "Summon manager is not initialized.");
+            return;
         }
 
-        // Consomme un item de la main et met à jour l'inventaire
         int newAmount = inHand.getAmount() - 1;
-
         if (newAmount <= 0) {
             p.getInventory().setItemInMainHand(null);
         } else {
@@ -82,16 +75,20 @@ public void onRightClickGolem(PlayerInteractEntityEvent event) {
         p.updateInventory();
     }
 
-    private static ReanimatorNPC.ReanimatorType getReanimatorType() {
-        Random random = new Random();
-        int level = random.nextInt(3) + 1;
-
-        if (level == 1) {
+    /**
+     * Returns the highest-tier ReanimatorType the player has permission for,
+     * or null if they have no type permission at all.
+     */
+    private ReanimatorNPC.ReanimatorType resolveAllowedType(Player player) {
+        if (player.hasPermission("reanimatemc.summon.use.protector")) {
+            return ReanimatorNPC.ReanimatorType.PROTECTOR;
+        }
+        if (player.hasPermission("reanimatemc.summon.use.healer")) {
             return ReanimatorNPC.ReanimatorType.HEALER;
-        } else if (level == 2) {
+        }
+        if (player.hasPermission("reanimatemc.summon.use.golem")) {
             return ReanimatorNPC.ReanimatorType.GOLEM;
-        } else {
-            return ReanimatorNPC.ReanimatorType.PROTECTOR;
         }
+        return null;
     }
-}
\ No newline at end of file
+}
diff --git a/src/main/java/fr/jachou/reanimatemc/listeners/KOProtectionListener.java b/src/main/java/fr/jachou/reanimatemc/listeners/KOProtectionListener.java
new file mode 100644
index 0000000..665ae64
--- /dev/null
+++ b/src/main/java/fr/jachou/reanimatemc/listeners/KOProtectionListener.java
@@ -0,0 +1,70 @@
+package fr.jachou.reanimatemc.listeners;
+
+import fr.jachou.reanimatemc.ReanimateMC;
+import fr.jachou.reanimatemc.managers.KOManager;
+import io.papermc.paper.event.entity.EntityKnockbackEvent;
+import org.bukkit.entity.Mob;
+import org.bukkit.entity.Player;
+import org.bukkit.entity.Projectile;
+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.EntityTargetEvent;
+import org.bukkit.util.Vector;
+
+public class KOProtectionListener implements Listener {
+
+    private final KOManager koManager;
+
+    public KOProtectionListener(KOManager koManager) {
+        this.koManager = koManager;
+    }
+
+    @EventHandler(priority = EventPriority.HIGH, ignoreCancelled = true)
+    public void onEntityKnockback(EntityKnockbackEvent event) {
+        if (!(event.getEntity() instanceof Player player)) return;
+        if (!koManager.isKO(player)) return;
+        if (!ReanimateMC.getInstance().getConfig().getBoolean("knockout.knockback_disabled", true)) return;
+        event.setKnockback(new Vector(0, 0, 0));
+    }
+
+    /** Prevents new mobs from choosing a KO'd player as a target. */
+    @EventHandler(priority = EventPriority.HIGH, ignoreCancelled = true)
+    public void onEntityTarget(EntityTargetEvent event) {
+        if (!(event.getTarget() instanceof Player player)) return;
+        if (!koManager.isKO(player)) return;
+        if (ReanimateMC.getInstance().getConfig().getBoolean("knockout.mobs_attack_ko", false)) return;
+        if (!(event.getEntity() instanceof Mob)) return;
+        event.setCancelled(true);
+    }
+
+    /**
+     * Cancels damage to KO'd players from mobs.
+     * Covers both direct melee attacks and projectiles (arrows, fireballs, etc.)
+     * shot by a mob. The mob's target is also cleared so it stops pursuing.
+     */
+    @EventHandler(priority = EventPriority.HIGH, ignoreCancelled = true)
+    public void onMobDamageKOPlayer(EntityDamageByEntityEvent event) {
+        if (!(event.getEntity() instanceof Player player)) return;
+        if (!koManager.isKO(player)) return;
+        if (ReanimateMC.getInstance().getConfig().getBoolean("knockout.mobs_attack_ko", false)) return;
+
+        org.bukkit.entity.Entity damager = event.getDamager();
+
+        // Direct melee attack from a mob
+        if (damager instanceof Mob mob) {
+            event.setCancelled(true);
+            mob.setTarget(null);
+            return;
+        }
+
+        // Projectile shot by a mob (arrow, fireball, snowball, etc.)
+        if (damager instanceof Projectile projectile
+                && projectile.getShooter() instanceof Mob mob) {
+            event.setCancelled(true);
+            mob.setTarget(null);
+            projectile.remove();
+        }
+    }
+}
diff --git a/src/main/java/fr/jachou/reanimatemc/listeners/NPCDamageListener.java b/src/main/java/fr/jachou/reanimatemc/listeners/NPCDamageListener.java
new file mode 100644
index 0000000..9fefb2d
--- /dev/null
+++ b/src/main/java/fr/jachou/reanimatemc/listeners/NPCDamageListener.java
@@ -0,0 +1,109 @@
+package fr.jachou.reanimatemc.listeners;
+
+import fr.jachou.reanimatemc.ReanimateMC;
+import fr.jachou.reanimatemc.data.ReanimatorNPC;
+import fr.jachou.reanimatemc.managers.NPCSummonManager;
+import org.bukkit.Bukkit;
+import org.bukkit.ChatColor;
+import org.bukkit.attribute.Attribute;
+import org.bukkit.entity.Entity;
+import org.bukkit.entity.IronGolem;
+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;
+import org.bukkit.event.entity.EntityDeathEvent;
+
+/**
+ * Handles damage and death events for system-owned Iron Golems.
+ *
+ * <p>Self-damage prevention: Iron Golems can damage themselves when trapped
+ * against a wall (stuck pathfinding). Any damage event where the damager is
+ * the golem itself, or another registered allied golem, is cancelled.
+ *
+ * <p>Invulnerability mode ({@code npc_summon.invulnerable}): cancels all
+ * incoming damage to registered golems.
+ *
+ * <p>Low-HP warning: when HP drops below {@code npc_summon.low_hp_threshold}
+ * (default 30%), an action-bar alert is sent to the owner.
+ *
+ * <p>Death cleanup: drops and XP cleared; owner notified; NPC record removed.
+ */
+public class NPCDamageListener implements Listener {
+
+    private final NPCSummonManager npcSummonManager;
+
+    public NPCDamageListener(NPCSummonManager npcSummonManager) {
+        this.npcSummonManager = npcSummonManager;
+    }
+
+    @EventHandler(priority = EventPriority.HIGH, ignoreCancelled = true)
+    public void onEntityDamage(EntityDamageEvent event) {
+        if (!(event.getEntity() instanceof IronGolem)) return;
+        IronGolem golem = (IronGolem) event.getEntity();
+        ReanimatorNPC npc = npcSummonManager.getNPCByEntity(golem);
+        if (npc == null) return;
+
+        // Self-damage and allied-golem friendly-fire prevention
+        if (event instanceof EntityDamageByEntityEvent edbe) {
+            Entity damager = edbe.getDamager();
+            if (damager.getUniqueId().equals(golem.getUniqueId())) {
+                event.setCancelled(true);
+                return;
+            }
+            if (damager instanceof IronGolem
+                    && npcSummonManager.getNPCByEntity(damager) != null) {
+                event.setCancelled(true);
+                return;
+            }
+        }
+
+        // Invulnerability mode
+        if (ReanimateMC.getInstance().getConfig().getBoolean("npc_summon.invulnerable", false)) {
+            event.setCancelled(true);
+            return;
+        }
+
+        // Low-HP warning
+        double damageAfter = golem.getHealth() - event.getFinalDamage();
+        double maxHp = golem.getAttribute(Attribute.MAX_HEALTH).getValue();
+        double threshold = ReanimateMC.getInstance().getConfig()
+                .getDouble("npc_summon.low_hp_threshold", 0.30);
+        if (damageAfter > 0 && (damageAfter / maxHp) <= threshold) {
+            Player owner = Bukkit.getPlayer(npc.getOwnerId());
+            if (owner != null && owner.isOnline()) {
+                String icon = switch (npc.getType()) {
+                    case HEALER    -> "✚";
+                    case PROTECTOR -> "⚔";
+                    default        -> "✦";
+                };
+                owner.sendActionBar(ChatColor.RED + icon + " "
+                        + ReanimateMC.lang.get("npc_low_hp",
+                                "type", npc.getType().getDisplayName(),
+                                "hp", String.valueOf((int) damageAfter)));
+            }
+        }
+    }
+
+    @EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = true)
+    public void onEntityDeath(EntityDeathEvent event) {
+        if (!(event.getEntity() instanceof IronGolem)) return;
+        IronGolem golem = (IronGolem) event.getEntity();
+        ReanimatorNPC npc = npcSummonManager.getNPCByEntity(golem);
+        if (npc == null) return;
+
+        event.getDrops().clear();
+        event.setDroppedExp(0);
+
+        Player owner = Bukkit.getPlayer(npc.getOwnerId());
+        if (owner != null && owner.isOnline()) {
+            owner.sendMessage(ChatColor.RED + ReanimateMC.lang.get("npc_died",
+                    "type", npc.getType().getDisplayName()));
+        }
+
+        Bukkit.getScheduler().runTask(ReanimateMC.getInstance(),
+                () -> npcSummonManager.onNPCDied(npc));
+    }
+}
diff --git a/src/main/java/fr/jachou/reanimatemc/listeners/PlayerDamageListener.java b/src/main/java/fr/jachou/reanimatemc/listeners/PlayerDamageListener.java
index 8c81138..edd7462 100644
--- a/src/main/java/fr/jachou/reanimatemc/listeners/PlayerDamageListener.java
+++ b/src/main/java/fr/jachou/reanimatemc/listeners/PlayerDamageListener.java
@@ -2,42 +2,84 @@
 
 import fr.jachou.reanimatemc.ReanimateMC;
 import fr.jachou.reanimatemc.managers.KOManager;
+import fr.jachou.reanimatemc.managers.NPCSummonManager;
 import fr.jachou.reanimatemc.utils.Utils;
 import org.bukkit.Color;
 import org.bukkit.Material;
 import org.bukkit.Particle;
 import org.bukkit.Sound;
+import org.bukkit.entity.Entity;
+import org.bukkit.entity.IronGolem;
 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;
 
 public class PlayerDamageListener implements Listener {
+
     private final KOManager koManager;
+    private final NPCSummonManager npcSummonManager;
 
-    public PlayerDamageListener(KOManager koManager) {
-        this.koManager = koManager;
+    public PlayerDamageListener(KOManager koManager, NPCSummonManager npcSummonManager) {
+        this.koManager        = koManager;
+        this.npcSummonManager = npcSummonManager;
     }
 
+    /**
+     * PROTECTOR intercept — runs at HIGHEST so damage is reduced before MONITOR reads it.
+     * Only fires on EntityDamageByEntity so we have access to the attacker.
+     * Skips if the attacker is the owner's own Protector golem (friendly fire).
+     */
+    @EventHandler(priority = EventPriority.HIGHEST, ignoreCancelled = true)
+    public void onPlayerDamageByEntity(EntityDamageByEntityEvent event) {
+        if (!(event.getEntity() instanceof Player victim)) return;
+        if (Utils.isNPC(victim)) return;
+        if (koManager.isKO(victim)) return; // already KO, let KO logic handle it
+
+        Entity attacker = event.getDamager();
+
+        // Don't intercept hits coming from the player's own Protector
+        if (attacker instanceof IronGolem) return;
+
+        double ratio = npcSummonManager.getInterceptRatio(victim, attacker);
+        if (ratio <= 0.0) return;
+
+        double originalDamage = event.getDamage();
+        double absorbed = originalDamage * ratio;
+        event.setDamage(originalDamage - absorbed);
+
+        // Transfer absorbed portion as real HP loss to the Protector entity
+        npcSummonManager.applyTransferredDamage(victim, absorbed);
+    }
+
+    /**
+     * KO trigger — runs at MONITOR to see the final resolved damage value after
+     * all other plugins (and the intercept handler above) have processed it.
+     */
     @EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = true)
     public void onPlayerDamage(EntityDamageEvent event) {
-        if (!(event.getEntity() instanceof Player player))
-            return;
+        if (!(event.getEntity() instanceof Player player)) return;
+        if (!ReanimateMC.getInstance().getConfig().getBoolean("knockout.enabled")) return;
+        if (Utils.isNPC(player)) return;
 
-        if (!ReanimateMC.getInstance().getConfig().getBoolean("knockout.enabled"))
-            return;
+        // Track last-damage time for self-revive combat check and cancel-on-damage
+        koManager.trackLastDamage(player);
 
-        if (Utils.isNPC(player)) return;
+        // Cancel self-revive channel if the player takes damage while channeling
+        if (koManager.isChannelingSelfRevive(player)
+                && ReanimateMC.getInstance().getConfig()
+                        .getBoolean("self_revive.cancel_on_damage", true)) {
+            koManager.cancelSelfRevive(player, true);
+        }
 
         double currentHealth = player.getHealth();
-        double finalDamage = event.getFinalDamage();
+        double finalDamage   = event.getFinalDamage();
 
         if (finalDamage >= currentHealth) {
-            // If the player holds a Totem of Undying in either hand, let the
-            // vanilla mechanic handle it (no KO state applied)
-            if (player.getInventory().getItemInMainHand().getType() == Material.TOTEM_OF_UNDYING ||
-                    player.getInventory().getItemInOffHand().getType() == Material.TOTEM_OF_UNDYING) {
+            if (player.getInventory().getItemInMainHand().getType()  == Material.TOTEM_OF_UNDYING ||
+                player.getInventory().getItemInOffHand().getType()   == Material.TOTEM_OF_UNDYING) {
                 return;
             }
 
@@ -46,12 +88,10 @@ public void onPlayerDamage(EntityDamageEvent event) {
                 koManager.setKO(player);
                 player.setHealth(1.0);
 
-                // Particules (ex. particules rouges) si activées
                 if (ReanimateMC.getInstance().getConfig().getBoolean("knockout.use_particles", true)) {
                     player.getWorld().spawnParticle(Particle.DUST, player.getLocation(), 10, 0.5, 0.5, 0.5,
                             new Particle.DustOptions(Color.RED, 1));
                 }
-                // Son de battement de cœur si activé
                 if (ReanimateMC.getInstance().getConfig().getBoolean("knockout.heartbeat_sound", true)) {
                     player.getWorld().playSound(player.getLocation(), Sound.ENTITY_PLAYER_ATTACK_CRIT, 1.0f, 1.0f);
                 }
diff --git a/src/main/java/fr/jachou/reanimatemc/listeners/PlayerKOListener.java b/src/main/java/fr/jachou/reanimatemc/listeners/PlayerKOListener.java
index 91215a8..fe3c590 100644
--- a/src/main/java/fr/jachou/reanimatemc/listeners/PlayerKOListener.java
+++ b/src/main/java/fr/jachou/reanimatemc/listeners/PlayerKOListener.java
@@ -1,79 +1,246 @@
 package fr.jachou.reanimatemc.listeners;
 
 import fr.jachou.reanimatemc.ReanimateMC;
+import fr.jachou.reanimatemc.data.KOData;
 import fr.jachou.reanimatemc.managers.KOManager;
 import org.bukkit.Bukkit;
+import org.bukkit.entity.Entity;
 import org.bukkit.entity.Player;
 import org.bukkit.event.EventHandler;
 import org.bukkit.event.EventPriority;
 import org.bukkit.event.Listener;
-import org.bukkit.event.player.PlayerCommandPreprocessEvent;
-import org.bukkit.event.player.PlayerCommandSendEvent;
-import org.bukkit.event.player.PlayerToggleSneakEvent;
-import org.bukkit.event.player.PlayerSwapHandItemsEvent;
+import org.bukkit.event.block.Action;
+import org.bukkit.event.entity.EntityToggleSwimEvent;
+import org.bukkit.event.player.*;
 
+import java.util.HashMap;
 import java.util.List;
+import java.util.Map;
+import java.util.UUID;
 
 public class PlayerKOListener implements Listener {
 
     private final KOManager koManager;
+
+    // Minimum ms between throttled events (cancel message / distress signal).
+    private static final long CANCEL_THROTTLE_MS = 3000L;
+    private final Map<UUID, Long> lastCancelTime = new HashMap<>();
+
     public PlayerKOListener(KOManager koManager) {
         this.koManager = koManager;
     }
 
-    @EventHandler
-    public void onPlayerShiftClick(PlayerToggleSneakEvent e) {
-        if (koManager.isKO(e.getPlayer())) {
-            e.setCancelled(true);
-            var data = koManager.getKOData(e.getPlayer());
-            if (e.isSneaking()) {
-                if (data.getSuicideTaskId() == -1) {
-                    long seconds = ReanimateMC.getInstance().getConfig().getLong("knockout.suicide_hold_seconds", 3);
-                    long delay = seconds * 20L;
-                    int task = Bukkit.getScheduler().scheduleSyncDelayedTask(ReanimateMC.getInstance(), () -> {
-                        if (koManager.isKO(e.getPlayer())) {
-                            koManager.suicide(e.getPlayer());
-                        }
-                    }, delay);
-                    data.setSuicideTaskId(task);
-                    e.getPlayer().sendMessage(ReanimateMC.lang.get("suicide_start", "time", String.valueOf(seconds)));
-                }
-            } else {
-                if (data.getSuicideTaskId() != -1) {
-                    Bukkit.getScheduler().cancelTask(data.getSuicideTaskId());
-                    data.setSuicideTaskId(-1);
-                    e.getPlayer().sendMessage(ReanimateMC.lang.get("ko_shift_click_cancelled"));
+    // ── Crawl state persistence ───────────────────────────────────────────────
+
+    @EventHandler(priority = EventPriority.HIGH, ignoreCancelled = true)
+    public void onToggleSwim(EntityToggleSwimEvent event) {
+        Entity entity = event.getEntity();
+        if (!(entity instanceof Player)) return;
+        Player player = (Player) entity;
+        if (!koManager.isKO(player)) return;
+        KOData data = koManager.getKOData(player);
+        if (!data.isCrawling()) return;
+        if (!event.isSwimming()) {
+            event.setCancelled(true);
+            Bukkit.getScheduler().runTaskLater(ReanimateMC.getInstance(), () -> {
+                if (koManager.isKO(player) && data.isCrawling()) {
+                    player.setSwimming(true);
                 }
+            }, 1L);
+        }
+    }
+
+    // ── Surrender: sneak-down starts, sneak-up cancels ───────────────────────
+    //
+    // Crawl mode: the swim state generates repeated isSneaking=true events.
+    // Guard: if a surrender task is already running, ignore additional sneak-down
+    // events so the timer is not restarted. Sneak-up always cancels.
+
+    @EventHandler
+    public void onPlayerSneak(PlayerToggleSneakEvent event) {
+        Player player = event.getPlayer();
+        if (!koManager.isKO(player)) return;
+        event.setCancelled(true);
+        KOData data = koManager.getKOData(player);
+
+        if (event.isSneaking()) {
+            // Ignore repeated sneak-down if timer is already running (crawl spam fix)
+            if (data.getSuicideTaskId() != -1) return;
+
+            long seconds = ReanimateMC.getInstance().getConfig()
+                    .getLong("knockout.suicide_hold_seconds", 3);
+            int task = Bukkit.getScheduler().scheduleSyncDelayedTask(
+                    ReanimateMC.getInstance(),
+                    () -> { if (koManager.isKO(player)) koManager.suicide(player); },
+                    seconds * 20L
+            );
+            data.setSuicideTaskId(task);
+            player.sendMessage(ReanimateMC.lang.get("suicide_start", "time", String.valueOf(seconds)));
+
+        } else {
+            // Sneak-up: explicit resistance (Java Edition reliable path)
+            cancelSurrender(player, data, true);
+        }
+    }
+
+    // ── Surrender cancel: Q / drop key (Bedrock primary cancel) ──────────────
+    //
+    // On Bedrock, when seated on the ArmorStand mount (non-crawl KO), the client
+    // stays visually crouched and never fires a sneak-up event. The drop button
+    // (Q) is always accessible and consistently fires PlayerDropItemEvent via
+    // Geyser. We cancel the item drop and use it as the cancel trigger.
+
+    @EventHandler(priority = EventPriority.HIGH, ignoreCancelled = true)
+    public void onDropItem(PlayerDropItemEvent event) {
+        Player player = event.getPlayer();
+        if (!koManager.isKO(player)) return;
+        KOData data = koManager.getKOData(player);
+
+        // Always cancel the drop while KO
+        event.setCancelled(true);
+
+        // If a surrender is active, cancel it (resist)
+        if (data.getSuicideTaskId() != -1) {
+            cancelSurrender(player, data, true);
+        } else {
+            // No active surrender — send distress if drop_key_trigger enabled
+            if (ReanimateMC.getInstance().getConfig()
+                    .getBoolean("knockout.distress.drop_key_trigger", true)) {
+                koManager.sendDistress(player);
             }
         }
     }
 
+    // ── Surrender cancel: RIGHT_CLICK_AIR with empty hand (Bedrock secondary) ─
+
+    @EventHandler(priority = EventPriority.HIGH)
+    public void onInteract(PlayerInteractEvent event) {
+        if (event.getAction() != Action.RIGHT_CLICK_AIR) return;
+        Player player = event.getPlayer();
+        if (!koManager.isKO(player)) return;
+        KOData data = koManager.getKOData(player);
+        if (data.getSuicideTaskId() == -1) return;
+        if (player.getInventory().getItemInMainHand().getType() != org.bukkit.Material.AIR) return;
+        event.setCancelled(true);
+        cancelSurrender(player, data, true);
+    }
+
+    // ── Surrender cancel: arm-swing (Bedrock tertiary fallback) ──────────────
+
+    @EventHandler(priority = EventPriority.HIGH)
+    public void onAnimation(PlayerAnimationEvent event) {
+        if (event.getAnimationType() != PlayerAnimationType.ARM_SWING) return;
+        Player player = event.getPlayer();
+        if (!koManager.isKO(player)) return;
+        KOData data = koManager.getKOData(player);
+        if (data.getSuicideTaskId() == -1) return;
+        // No distress on arm-swing — too easy to trigger accidentally
+        cancelSurrender(player, data, false);
+    }
+
+    // ── Distress: F key (Java Edition) ───────────────────────────────────────
+
     @EventHandler
     public void onSwapHand(PlayerSwapHandItemsEvent event) {
-        if (koManager.isKO(event.getPlayer())) {
-            event.setCancelled(true);
-            koManager.sendDistress(event.getPlayer());
+        if (!koManager.isKO(event.getPlayer())) return;
+        event.setCancelled(true);
+        koManager.sendDistress(event.getPlayer());
+    }
+
+    // ── Movement: cancel surrender on move ───────────────────────────────────
+
+    @EventHandler(priority = EventPriority.LOWEST)
+    public void onPlayerMove(PlayerMoveEvent event) {
+        Player player = event.getPlayer();
+        if (!koManager.isKO(player)) return;
+        KOData data = koManager.getKOData(player);
+
+        org.bukkit.Location from = event.getFrom();
+        org.bukkit.Location to   = event.getTo();
+        if (to == null) return;
+
+        boolean movedH = Math.abs(to.getX() - from.getX()) > 0.001
+                || Math.abs(to.getZ() - from.getZ()) > 0.001;
+        boolean movedY = to.getY() > from.getY() + 0.01;
+
+        boolean movementDisabled = ReanimateMC.getInstance().getConfig()
+                .getBoolean("knockout.movement_disabled", true);
+        boolean crawling = data.isCrawling()
+                && ReanimateMC.getInstance().getConfig().getBoolean("prone.allow_crawl", false);
+        boolean surrenderRequireStill = ReanimateMC.getInstance().getConfig()
+                .getBoolean("knockout.surrender_require_still", true);
+        boolean crawlAllowJump = ReanimateMC.getInstance().getConfig()
+                .getBoolean("prone.crawl_allow_jump", false);
+
+        if (!crawling && movementDisabled) {
+            // Full lock mode — block XZ and Y, preserve rotation
+            if (movedH || movedY) {
+                org.bukkit.Location locked = from.clone();
+                locked.setYaw(to.getYaw());
+                locked.setPitch(to.getPitch());
+                event.setTo(locked);
+            }
+            // Even though movement is blocked server-side, if surrender_require_still
+            // is true we still cancel the surrender when any move attempt is detected
+            if ((movedH || movedY) && surrenderRequireStill) {
+                if (data.getSuicideTaskId() != -1) cancelSurrender(player, data, false);
+                if (koManager.isChannelingSelfRevive(player)
+                        && ReanimateMC.getInstance().getConfig()
+                                .getBoolean("self_revive.cancel_on_move", true)) {
+                    koManager.cancelSelfRevive(player, true);
+                }
+            }
+
+        } else if (!crawling && !movementDisabled) {
+            // Movement allowed — but surrender still cancelled on move if configured
+            if ((movedH || movedY) && surrenderRequireStill) {
+                if (data.getSuicideTaskId() != -1) cancelSurrender(player, data, false);
+            }
+            if (movedH && koManager.isChannelingSelfRevive(player)
+                    && ReanimateMC.getInstance().getConfig()
+                            .getBoolean("self_revive.cancel_on_move", true)) {
+                koManager.cancelSelfRevive(player, true);
+            }
+
+        } else {
+            // Crawl mode — allow XZ; optionally block jump
+            if (movedY && !crawlAllowJump && player.getVelocity().getY() > 0.1) {
+                org.bukkit.Location noJump = to.clone();
+                noJump.setY(from.getY());
+                event.setTo(noJump);
+            }
+            // Cancel surrender on movement while crawling if configured
+            if (movedH && surrenderRequireStill) {
+                if (data.getSuicideTaskId() != -1) cancelSurrender(player, data, false);
+            }
+            if (movedH && koManager.isChannelingSelfRevive(player)
+                    && ReanimateMC.getInstance().getConfig()
+                            .getBoolean("self_revive.cancel_on_move", true)) {
+                koManager.cancelSelfRevive(player, true);
+            }
+            }
         }
     }
 
+    // ── Command whitelist ─────────────────────────────────────────────────────
+
     @EventHandler(priority = EventPriority.HIGHEST, ignoreCancelled = true)
     public void onCommandPreprocess(PlayerCommandPreprocessEvent event) {
         Player player = event.getPlayer();
+        boolean restricted = ReanimateMC.getInstance().getConfig()
+                .getBoolean("knockout.enable_commands_allowed");
+        if (!koManager.isKO(player) || player.isOp() || !restricted) return;
 
-        boolean commandRestrictionsEnabled = ReanimateMC.getInstance().getConfig().getBoolean("knockout.enable_commands_allowed");
-        if (!koManager.isKO(player) || player.isOp() || !commandRestrictionsEnabled) return;
-
-        List<String> allowed = ReanimateMC.getInstance().getConfig().getStringList("knockout.allowed_commands");
-
-        String msg = event.getMessage();
-        String cmd = msg.startsWith("/") ? msg.substring(1) : msg;
+        List<String> allowed = ReanimateMC.getInstance().getConfig()
+                .getStringList("knockout.allowed_commands");
+        String msg   = event.getMessage();
+        String cmd   = msg.startsWith("/") ? msg.substring(1) : msg;
         String label = cmd.split(" ")[0].toLowerCase();
+        String base  = label.contains(":") ? label.substring(label.indexOf(':') + 1) : label;
 
-        String base = label.contains(":") ? label.substring(label.indexOf(':') + 1) : label;
-
-        boolean isAllowed = allowed.stream().map(String::toLowerCase).anyMatch(a ->
-                a.equals(label) || a.equals(base)
-        );
+        boolean isAllowed = allowed.stream()
+                .map(String::toLowerCase)
+                .anyMatch(a -> a.equals(label) || a.equals(base));
 
         if (!isAllowed) {
             event.setCancelled(true);
@@ -81,4 +248,34 @@ public void onCommandPreprocess(PlayerCommandPreprocessEvent event) {
         }
     }
 
+    // ── Helper ────────────────────────────────────────────────────────────────
+
+    /**
+     * Cancels the active surrender task.
+     * The cancel message is always sent (never throttled) so the player always
+     * knows the surrender was cancelled.
+     * The distress signal is throttled to once per CANCEL_THROTTLE_MS to avoid
+     * spam when multiple cancel triggers fire in quick succession.
+     *
+     * @param sendDistress true when the player explicitly resisted
+     *                     (sneak-up, Q, right-click). False for passive cancels.
+     */
+    private void cancelSurrender(Player player, KOData data, boolean sendDistress) {
+        if (data.getSuicideTaskId() == -1) return;
+        Bukkit.getScheduler().cancelTask(data.getSuicideTaskId());
+        data.setSuicideTaskId(-1);
+
+        // Message is always sent so the player knows the surrender was cancelled
+        player.sendMessage(ReanimateMC.lang.get("ko_shift_click_cancelled"));
+
+        if (sendDistress) {
+            // Throttle only the distress signal, not the message
+            long now = System.currentTimeMillis();
+            Long last = lastCancelTime.get(player.getUniqueId());
+            if (last == null || (now - last) >= CANCEL_THROTTLE_MS) {
+                lastCancelTime.put(player.getUniqueId(), now);
+                koManager.sendDistress(player);
+            }
+        }
+    }
 }
diff --git a/src/main/java/fr/jachou/reanimatemc/listeners/ReanimationListener.java b/src/main/java/fr/jachou/reanimatemc/listeners/ReanimationListener.java
index 12b95f7..ea0c482 100644
--- a/src/main/java/fr/jachou/reanimatemc/listeners/ReanimationListener.java
+++ b/src/main/java/fr/jachou/reanimatemc/listeners/ReanimationListener.java
@@ -25,7 +25,8 @@
 public class ReanimationListener implements Listener {
     private KOManager koManager;
     private final Map<UUID, BukkitTask> activeReviveTasks = new HashMap<>();
-    private final Map<UUID, Long> lastInteract = new HashMap<>();
+    private final Map<UUID, Long>       lastInteract      = new HashMap<>();
+    private final Map<UUID, org.bukkit.Location> reviverPositions = new HashMap<>();
 
     public ReanimationListener(KOManager koManager) {
         this.koManager = koManager;
@@ -99,6 +100,7 @@ public void onPlayerInteractEntity(PlayerInteractEntityEvent event) {
 
         // Store so we can cancel if needed
         activeReviveTasks.put(reviver.getUniqueId(), bukkitTask);
+        reviverPositions.put(reviver.getUniqueId(), reviver.getLocation().clone());
         reviver.sendMessage(ChatColor.GREEN + ReanimateMC.lang.get("revive_start"));
     }
 
@@ -139,9 +141,20 @@ public void run() {
                 return;
             }
             if (!reviver.isSneaking()) {
-                cancelRevive("Revival canceled: you stopped sneaking.");
+                cancelRevive(ReanimateMC.lang.get("revive_cancelled_sneak"));
                 return;
             }
+
+            // Reviver must stay still
+            org.bukkit.Location startPos = reviverPositions.get(reviver.getUniqueId());
+            if (startPos != null) {
+                org.bukkit.Location cur = reviver.getLocation();
+                if (Math.abs(cur.getX() - startPos.getX()) > 0.05
+                        || Math.abs(cur.getZ() - startPos.getZ()) > 0.05) {
+                    cancelRevive(ReanimateMC.lang.get("revive_cancelled_moved"));
+                    return;
+                }
+            }
             if (requiredStack != null) {
                 ItemStack current = reviver.getInventory().getItemInMainHand();
                 if (current == null || !current.getType().toString().equalsIgnoreCase(requiredItemName)) {
@@ -192,11 +205,10 @@ public void run() {
         }
 
         private void cancelRevive(String message) {
-            if (reviver.isOnline()) {
-                reviver.sendMessage(ChatColor.RED + message);
-            }
+            if (reviver.isOnline()) reviver.sendMessage(ChatColor.RED + message);
             taskRef.cancel();
             activeReviveTasks.remove(reviver.getUniqueId());
+            reviverPositions.remove(reviver.getUniqueId());
         }
     }
 }
\ No newline at end of file
diff --git a/src/main/java/fr/jachou/reanimatemc/managers/KOManager.java b/src/main/java/fr/jachou/reanimatemc/managers/KOManager.java
index 14f324a..93d1447 100644
--- a/src/main/java/fr/jachou/reanimatemc/managers/KOManager.java
+++ b/src/main/java/fr/jachou/reanimatemc/managers/KOManager.java
@@ -1,6 +1,8 @@
 package fr.jachou.reanimatemc.managers;
 
+import java.util.ArrayList;
 import java.util.HashMap;
+import java.util.List;
 import java.util.Map;
 import java.util.Map.Entry;
 import java.util.UUID;
@@ -15,9 +17,11 @@
 import fr.jachou.reanimatemc.utils.Utils;
 import org.bukkit.Bukkit;
 import org.bukkit.ChatColor;
+import org.bukkit.Material;
 import org.bukkit.entity.ArmorStand;
 import org.bukkit.entity.EntityType;
 import org.bukkit.entity.Player;
+import org.bukkit.inventory.ItemStack;
 import org.bukkit.plugin.java.JavaPlugin;
 import org.bukkit.potion.PotionEffect;
 import org.bukkit.potion.PotionEffectType;
@@ -77,10 +81,16 @@ public void setKO(final Player player, int durationSeconds) {
         data.setEndTimestamp(System.currentTimeMillis() + (durationSeconds * 1000L));
         int taskId = plugin.getServer().getScheduler().scheduleSyncDelayedTask(plugin, () -> {
             if (isKO(player)) {
-                removeMount(player, data);
-                restoreListName(player, data);
-                player.setHealth(0);
+                KOData d = koPlayers.get(player.getUniqueId());
+                plugin.getServer().getScheduler().cancelTask(d.getBarTaskId());
+                ArmorStand lb = d.getLabel();
+                if (lb != null && lb.isValid()) lb.remove();
+                ArmorStand mk = d.getHelpMarker();
+                if (mk != null && mk.isValid()) { mk.remove(); d.setHelpMarker(null); }
+                removeMount(player, d);
+                restoreListName(player, d);
                 koPlayers.remove(player.getUniqueId());
+                player.setHealth(0);
                 player.sendMessage(ChatColor.RED + ReanimateMC.lang.get("death_natural"));
             }
         }, durationSeconds * 20L);
@@ -123,8 +133,48 @@ public void setKO(final Player player, int durationSeconds) {
             player.addPotionEffect(new PotionEffect(PotionEffectType.SLOWNESS, Integer.MAX_VALUE, fatigueLvl - 1, false, false));
         }
 
+        // Nausea — only while crawling and when enabled in config
+        boolean nauseaEnabled = plugin.getConfig().getBoolean("knockout.crawl_nausea_enabled", true);
+        boolean isCrawlingNow = data.isCrawling() && plugin.getConfig().getBoolean("prone.allow_crawl", false);
+        if (nauseaEnabled && isCrawlingNow) {
+            int nauseaLvl = plugin.getConfig().getInt("knockout.crawl_nausea_level", 0);
+            player.addPotionEffect(new PotionEffect(PotionEffectType.NAUSEA, Integer.MAX_VALUE, nauseaLvl, false, false));
+        }
 
-        // Application de la posture prone avec une option de ramper
+        // Persistent enforcer — re-applies slowness and swimming every 20 ticks
+        int enforcerId = Bukkit.getScheduler().scheduleSyncRepeatingTask(plugin, () -> {
+            if (!isKO(player)) return;
+            KOData d = koPlayers.get(player.getUniqueId());
+            if (d == null) return;
+            boolean allowCrawl = plugin.getConfig().getBoolean("prone.allow_crawl", false);
+            boolean crawling = d.isCrawling() && allowCrawl;
+            if (crawling) {
+                int crawlLvl = plugin.getConfig().getInt("prone.crawl_slowness_level", 5);
+                PotionEffect cur = player.getPotionEffect(PotionEffectType.SLOWNESS);
+                if (cur == null || cur.getAmplifier() != crawlLvl) {
+                    player.removePotionEffect(PotionEffectType.SLOWNESS);
+                    player.addPotionEffect(new PotionEffect(PotionEffectType.SLOWNESS, Integer.MAX_VALUE, crawlLvl, false, false));
+                }
+                if (!player.isSwimming()) player.setSwimming(true);
+                // Nausea only while crawling
+                boolean nEnabled = plugin.getConfig().getBoolean("knockout.crawl_nausea_enabled", true);
+                if (nEnabled && !player.hasPotionEffect(PotionEffectType.NAUSEA)) {
+                    int nLvl = plugin.getConfig().getInt("knockout.crawl_nausea_level", 0);
+                    player.addPotionEffect(new PotionEffect(PotionEffectType.NAUSEA, Integer.MAX_VALUE, nLvl, false, false));
+                } else if (!nEnabled) {
+                    player.removePotionEffect(PotionEffectType.NAUSEA);
+                }
+            } else {
+                // Not crawling — full stop, remove nausea
+                PotionEffect cur = player.getPotionEffect(PotionEffectType.SLOWNESS);
+                if (cur == null || cur.getAmplifier() != 255) {
+                    player.removePotionEffect(PotionEffectType.SLOWNESS);
+                    player.addPotionEffect(new PotionEffect(PotionEffectType.SLOWNESS, Integer.MAX_VALUE, 255, false, false));
+                }
+                player.removePotionEffect(PotionEffectType.NAUSEA);
+            }
+        }, 20L, 20L);
+        data.setEffectEnforcerId(enforcerId);
         boolean blind = plugin.getConfig().getBoolean("knockout.blindness", true);
         if (plugin.getConfig().getBoolean("prone.enabled", false)) {
             boolean allowCrawl = plugin.getConfig().getBoolean("prone.allow_crawl", false);
@@ -151,17 +201,16 @@ public void setKO(final Player player, int durationSeconds) {
             }
         }
 
-        // Rendre le joueur KO plus visible pour les autres
+        // Make the KO'd player glow so teammates can spot them
         player.setGlowing(true);
 
-        ArmorStand seat = createMount(player.getLocation());
-        if (!data.isCrawling()) {
-            seat.addPassenger(player);
-            data.setMount(seat);
-        } else {
-            data.setMount(null);
-            seat.remove();
-        }
+        // Force the prone/lying-down animation using the swim pose.
+        // setSwimming(true) renders the player horizontal on both Java and Bedrock
+        // without any mount entity. This is the closest approximation to a
+        // "lying down" animation available in the Paper API.
+        player.setSwimming(true);
+
+        data.setMount(null);
 
         player.sendMessage(ChatColor.RED + ReanimateMC.lang.get("ko_set"));
 
@@ -212,6 +261,14 @@ public KOData getKOData(Player player) {
         return koPlayers.get(player.getUniqueId());
     }
 
+    /** Returns seconds remaining in the KO state, or 0 if not KO or no timestamp set. */
+    public long getRemainingKOSeconds(Player player) {
+        KOData data = koPlayers.get(player.getUniqueId());
+        if (data == null || data.getEndTimestamp() <= 0) return 0;
+        long rem = (data.getEndTimestamp() - System.currentTimeMillis()) / 1000L;
+        return Math.max(0, rem);
+    }
+
     public void revive(final Player player, final Player playerWhoRevive) {
         if (!isKO(player))
             return;
@@ -224,6 +281,8 @@ public void revive(final Player player, final Player playerWhoRevive) {
         plugin.getServer().getScheduler().cancelTask(data.getTaskId());
         if (data.getSuicideTaskId() != -1) {
             plugin.getServer().getScheduler().cancelTask(data.getSuicideTaskId());
+            if (data.getEffectEnforcerId() != -1) plugin.getServer().getScheduler().cancelTask(data.getEffectEnforcerId());
+            if (data.getSelfReviveTaskId() != -1) { plugin.getServer().getScheduler().cancelTask(data.getSelfReviveTaskId()); data.setSelfReviveTaskId(-1); }
             data.setSuicideTaskId(-1);
         }
         removeMount(player, data);
@@ -244,7 +303,7 @@ public void revive(final Player player, final Player playerWhoRevive) {
         player.removePotionEffect(PotionEffectType.SLOWNESS);
         player.removePotionEffect(PotionEffectType.BLINDNESS);
         player.removePotionEffect(PotionEffectType.WEAKNESS);
-        player.removePotionEffect(PotionEffectType.SLOWNESS);
+        player.removePotionEffect(PotionEffectType.NAUSEA);
         // Désactiver l'effet de glow
         player.setGlowing(false);
         player.setSwimming(false);
@@ -272,12 +331,14 @@ public void revive(final Player player, final Player playerWhoRevive) {
     }
 
     public void execute(final Player victim) {
-        if (!isKO(victim))
-            return;
+        if (!isKO(victim)) return;
         KOData data = koPlayers.get(victim.getUniqueId());
         plugin.getServer().getScheduler().cancelTask(data.getTaskId());
+        plugin.getServer().getScheduler().cancelTask(data.getBarTaskId());
         if (data.getSuicideTaskId() != -1) {
             plugin.getServer().getScheduler().cancelTask(data.getSuicideTaskId());
+            if (data.getEffectEnforcerId() != -1) plugin.getServer().getScheduler().cancelTask(data.getEffectEnforcerId());
+            if (data.getSelfReviveTaskId() != -1) { plugin.getServer().getScheduler().cancelTask(data.getSelfReviveTaskId()); data.setSelfReviveTaskId(-1); }
             data.setSuicideTaskId(-1);
         }
         removeMount(victim, data);
@@ -301,6 +362,8 @@ public void suicide(Player player) {
         plugin.getServer().getScheduler().cancelTask(data.getBarTaskId());
         if (data.getSuicideTaskId() != -1) {
             plugin.getServer().getScheduler().cancelTask(data.getSuicideTaskId());
+            if (data.getEffectEnforcerId() != -1) plugin.getServer().getScheduler().cancelTask(data.getEffectEnforcerId());
+            if (data.getSelfReviveTaskId() != -1) { plugin.getServer().getScheduler().cancelTask(data.getSelfReviveTaskId()); data.setSelfReviveTaskId(-1); }
             data.setSuicideTaskId(-1);
         }
         removeMount(player, data);
@@ -315,6 +378,7 @@ public void suicide(Player player) {
         }
         player.removePotionEffect(PotionEffectType.WEAKNESS);
         player.removePotionEffect(PotionEffectType.SLOWNESS);
+        player.removePotionEffect(PotionEffectType.NAUSEA);
         restoreListName(player, data);
         koPlayers.remove(player.getUniqueId());
 
@@ -334,8 +398,8 @@ private void cleanupKOEffects(Player player, KOData data) {
         }
         player.removePotionEffect(PotionEffectType.WEAKNESS);
         player.removePotionEffect(PotionEffectType.SLOWNESS);
-        player.removePotionEffect(PotionEffectType.SLOWNESS);
         player.removePotionEffect(PotionEffectType.BLINDNESS);
+        player.removePotionEffect(PotionEffectType.NAUSEA);
         player.setGlowing(false);
         player.setSwimming(false);
     }
@@ -349,6 +413,9 @@ public void cancelAllTasks() {
             if (data.getSuicideTaskId() != -1) {
                 plugin.getServer().getScheduler().cancelTask(data.getSuicideTaskId());
             }
+            if (data.getEffectEnforcerId() != -1) {
+                plugin.getServer().getScheduler().cancelTask(data.getEffectEnforcerId());
+            }
             ArmorStand seat = data.getMount();
             if (seat != null && seat.isValid()) {
                 seat.remove();
@@ -374,22 +441,22 @@ public void toggleCrawl(Player player) {
         player.removePotionEffect(PotionEffectType.SLOWNESS);
 
         if (data.isCrawling()) {
-            // Mode crawl : appliquer un effet de SLOWNESS de niveau configuré (laisser un minimum de déplacement)
-            int crawlLevel = plugin.getConfig().getInt("prone.crawl_SLOWNESSness_level", 5);
+            int crawlLevel = plugin.getConfig().getInt("prone.crawl_slowness_level", 5);
             player.addPotionEffect(new PotionEffect(PotionEffectType.SLOWNESS, Integer.MAX_VALUE, crawlLevel, false, false));
             removeMount(player, data);
             player.setSwimming(true);
+            // Apply nausea when crawl activates if enabled
+            boolean nauseaEnabled = plugin.getConfig().getBoolean("knockout.crawl_nausea_enabled", true);
+            if (nauseaEnabled) {
+                int nauseaLvl = plugin.getConfig().getInt("knockout.crawl_nausea_level", 0);
+                player.addPotionEffect(new PotionEffect(PotionEffectType.NAUSEA, Integer.MAX_VALUE, nauseaLvl, false, false));
+            }
             player.sendMessage(ChatColor.GREEN + ReanimateMC.lang.get("crawl_enabled"));
         } else {
-            // Retour à l'immobilisation complète (prone non-crawling)
             player.addPotionEffect(new PotionEffect(PotionEffectType.SLOWNESS, Integer.MAX_VALUE, 255, false, false));
-            if (data.getMount() == null || !data.getMount().isValid()) {
-                ArmorStand seat = createMount(player.getLocation());
-                seat.addPassenger(player);
-                data.setMount(seat);
-            } else if (!data.getMount().getPassengers().contains(player)) {
-                data.getMount().addPassenger(player);
-            }
+            // Remove nausea when crawl deactivates
+            player.removePotionEffect(PotionEffectType.NAUSEA);
+            // No mount — see setKO comment
             player.setSwimming(false);
             player.sendMessage(ChatColor.GREEN + ReanimateMC.lang.get("crawl_disabled"));
         }
@@ -409,6 +476,8 @@ public void handleLogout(Player player) {
         plugin.getServer().getScheduler().cancelTask(data.getBarTaskId());
         if (data.getSuicideTaskId() != -1) {
             plugin.getServer().getScheduler().cancelTask(data.getSuicideTaskId());
+            if (data.getEffectEnforcerId() != -1) plugin.getServer().getScheduler().cancelTask(data.getEffectEnforcerId());
+            if (data.getSelfReviveTaskId() != -1) { plugin.getServer().getScheduler().cancelTask(data.getSelfReviveTaskId()); data.setSelfReviveTaskId(-1); }
         }
         ArmorStand seat = data.getMount();
         if (seat != null && seat.isValid()) {
@@ -434,6 +503,60 @@ public void handleLogout(Player player) {
         koPlayers.remove(player.getUniqueId());
     }
 
+    /**
+     * Scans all loaded worlds for orphaned KO ArmorStands — invisible marker stands
+     * whose custom name matches the KO countdown pattern ("KO - Xs") or the HELP!
+     * distress marker — and removes them.
+     *
+     * <p>Also removes any label/helpMarker entities tracked in active KOData records
+     * that are no longer valid, as a secondary safety net.
+     *
+     * @return total number of entities removed
+     */
+    public int purgeOrphanedHolograms() {
+        int removed = 0;
+
+        // Collect UUIDs of currently tracked labels so we don't double-remove them
+        java.util.Set<UUID> trackedIds = new java.util.HashSet<>();
+        for (KOData d : koPlayers.values()) {
+            if (d.getLabel() != null)      trackedIds.add(d.getLabel().getUniqueId());
+            if (d.getHelpMarker() != null) trackedIds.add(d.getHelpMarker().getUniqueId());
+        }
+
+        for (org.bukkit.World world : Bukkit.getWorlds()) {
+            for (org.bukkit.entity.Entity entity : world.getEntitiesByClass(ArmorStand.class)) {
+                ArmorStand stand = (ArmorStand) entity;
+                if (!stand.isMarker() || !stand.isInvisible()) continue;
+
+                String name = stand.getCustomName();
+                if (name == null) continue;
+
+                boolean isKOLabel    = name.matches("(?i).*KO\\s*-\\s*\\d+s?.*");
+                boolean isHelpMarker = name.contains("HELP!");
+
+                if ((isKOLabel || isHelpMarker) && !trackedIds.contains(stand.getUniqueId())) {
+                    stand.remove();
+                    removed++;
+                }
+            }
+        }
+
+        // Also clean up stale tracked entities that are invalid
+        for (KOData d : koPlayers.values()) {
+            ArmorStand lb = d.getLabel();
+            if (lb != null && !lb.isValid()) { d.setLabel(null); removed++; }
+            ArmorStand mk = d.getHelpMarker();
+            if (mk != null && !mk.isValid()) { d.setHelpMarker(null); removed++; }
+        }
+
+        return removed;
+    }
+
+    /** Returns a read-only view of currently KO'd player UUIDs. */
+    public java.util.Set<UUID> getKOPlayerUUIDs() {
+        return java.util.Collections.unmodifiableSet(koPlayers.keySet());
+    }
+
     public long pullOfflineKO(UUID uuid) {
         if (!offlineConfig.contains(uuid.toString())) {
             return -1L;
@@ -458,9 +581,249 @@ public long pullOfflineKO(UUID uuid) {
         return -1L;
     }
 
+    /**
+     * Sends a distress signal on behalf of the player without checking the
+     * per-player cooldown. Used by the PROTECTOR golem so it can always alert
+     * teammates when the owner goes KO, regardless of recent signals.
+     */
+    // ── Self-revive system ────────────────────────────────────────────────────
+
+    /** Called by PlayerDamageListener to track when the player last took damage. */
+    public void trackLastDamage(Player player) {
+        KOData data = koPlayers.get(player.getUniqueId());
+        if (data != null) data.setLastDamageTime(System.currentTimeMillis());
+    }
+
+    /**
+     * Attempts to start a self-revive for the given K.O.'d player.
+     *
+     * <p>Validates: system enabled, player is KO, not already channeling,
+     * max uses not exceeded, cooldown not active, combat check, items present.
+     * On success, starts a timed progress bar. Consuming items and applying
+     * post-revive effects happen on completion.
+     *
+     * @return {@code true} if the channel started, {@code false} with message sent.
+     */
+    public boolean startSelfRevive(Player player) {
+        if (!plugin.getConfig().getBoolean("self_revive.enabled", true)) {
+            player.sendMessage(ChatColor.RED + ReanimateMC.lang.get("selfrevive_disabled"));
+            return false;
+        }
+        if (!isKO(player)) {
+            player.sendMessage(ChatColor.RED + ReanimateMC.lang.get("not_in_ko"));
+            return false;
+        }
+
+        KOData data = koPlayers.get(player.getUniqueId());
+
+        if (data.getSelfReviveTaskId() != -1) {
+            player.sendMessage(ChatColor.RED + ReanimateMC.lang.get("selfrevive_already_channeling"));
+            return false;
+        }
+
+        int maxUses = plugin.getConfig().getInt("self_revive.max_uses_per_ko", 1);
+        if (maxUses > 0 && data.getSelfReviveUses() >= maxUses) {
+            player.sendMessage(ChatColor.RED + ReanimateMC.lang.get("selfrevive_max_uses",
+                    "max", String.valueOf(maxUses)));
+            return false;
+        }
+
+        long cooldownMs = plugin.getConfig().getLong("self_revive.cooldown_seconds", 120) * 1000L;
+        // Per-player cooldown stored in offlineConfig (reuses lastDistressTime slot for simplicity —
+        // we use a dedicated config key to avoid collision with distress)
+        if (cooldownMs > 0 && hasSelfReviveCooldown(player, cooldownMs)) {
+            long remaining = selfReviveCooldownRemaining(player, cooldownMs);
+            player.sendMessage(ChatColor.RED + ReanimateMC.lang.get("selfrevive_cooldown",
+                    "time", String.valueOf(remaining)));
+            return false;
+        }
+
+        int combatBlock = plugin.getConfig().getInt("self_revive.combat_block_seconds", 0);
+        if (combatBlock > 0) {
+            long elapsed = System.currentTimeMillis() - data.getLastDamageTime();
+            if (elapsed < combatBlock * 1000L) {
+                long remaining = combatBlock - (elapsed / 1000L);
+                player.sendMessage(ChatColor.RED + ReanimateMC.lang.get("selfrevive_combat_block",
+                        "time", String.valueOf(remaining)));
+                return false;
+            }
+        }
+
+        // Item check
+        boolean requireItems = plugin.getConfig().getBoolean("self_revive.require_items", true);
+        List<ItemStack> requiredItems = new ArrayList<>();
+        if (requireItems) {
+            List<java.util.Map<?, ?>> itemList = plugin.getConfig()
+                    .getMapList("self_revive.required_items");
+            for (java.util.Map<?, ?> entry : itemList) {
+                String matName = String.valueOf(entry.get("material"));
+                int amount = entry.get("amount") instanceof Number
+                        ? ((Number) entry.get("amount")).intValue() : 1;
+                Material mat = Material.matchMaterial(matName);
+                if (mat == null) continue;
+                requiredItems.add(new ItemStack(mat, amount));
+            }
+            for (ItemStack req : requiredItems) {
+                if (!player.getInventory().containsAtLeast(req, req.getAmount())) {
+                    player.sendMessage(ChatColor.RED + ReanimateMC.lang.get("selfrevive_missing_items",
+                            "item", req.getType().name().replace("_", " ").toLowerCase(),
+                            "amount", String.valueOf(req.getAmount())));
+                    return false;
+                }
+            }
+        }
+
+        // All checks passed — start channel
+        player.sendMessage(ChatColor.GREEN + ReanimateMC.lang.get("selfrevive_start"));
+        int totalTicks = plugin.getConfig().getInt("self_revive.duration_ticks", 200);
+        final int[] elapsed = {0};
+        final List<ItemStack> finalItems = requiredItems;
+        final boolean requireFinal = requireItems;
+
+        int taskId = Bukkit.getScheduler().scheduleSyncRepeatingTask(plugin, () -> {
+            if (!isKO(player)) { cancelSelfRevive(player, false); return; }
+            elapsed[0]++;
+            int pct = (int) ((elapsed[0] / (double) totalTicks) * 100);
+            String bar = buildSelfReviveBar(pct);
+            Utils.sendActionBar(player, ChatColor.YELLOW + ReanimateMC.lang.get(
+                    "selfrevive_progress_bar", "bar", bar, "pct", String.valueOf(pct)));
+
+            if (elapsed[0] >= totalTicks) {
+                completeSelfRevive(player, data, finalItems, requireFinal);
+            }
+        }, 0L, 1L);
+
+        data.setSelfReviveTaskId(taskId);
+        setSelfReviveCooldownStart(player);
+        return true;
+    }
+
+    /**
+     * Cancels an in-progress self-revive channel.
+     *
+     * @param sendMessage whether to notify the player of the cancellation.
+     */
+    public void cancelSelfRevive(Player player, boolean sendMessage) {
+        KOData data = koPlayers.get(player.getUniqueId());
+        if (data == null || data.getSelfReviveTaskId() == -1) return;
+        Bukkit.getScheduler().cancelTask(data.getSelfReviveTaskId());
+        data.setSelfReviveTaskId(-1);
+        if (sendMessage) {
+            player.sendMessage(ChatColor.RED + ReanimateMC.lang.get("selfrevive_cancelled"));
+        }
+    }
+
+    /** Returns true if the player is currently channeling a self-revive. */
+    public boolean isChannelingSelfRevive(Player player) {
+        KOData data = koPlayers.get(player.getUniqueId());
+        return data != null && data.getSelfReviveTaskId() != -1;
+    }
+
+    private void completeSelfRevive(Player player, KOData data,
+                                     List<ItemStack> items, boolean consume) {
+        cancelSelfRevive(player, false);
+        data.incrementSelfReviveUses();
+
+        if (consume) {
+            for (ItemStack req : items) {
+                player.getInventory().removeItem(req);
+            }
+        }
+
+        // Revive the player
+        revive(player, player);
+
+        // Post-revive effects (different from teammate revive — harsher)
+        int nauseaSec  = plugin.getConfig().getInt("self_revive.effects_on_selfrevive.nausea", 10);
+        int slowSec    = plugin.getConfig().getInt("self_revive.effects_on_selfrevive.slowness", 15);
+        int resSec     = plugin.getConfig().getInt("self_revive.effects_on_selfrevive.resistance", 5);
+        if (nauseaSec  > 0) player.addPotionEffect(new PotionEffect(PotionEffectType.NAUSEA,     nauseaSec * 20,  0));
+        if (slowSec    > 0) player.addPotionEffect(new PotionEffect(PotionEffectType.SLOWNESS,   slowSec * 20,    1));
+        if (resSec     > 0) player.addPotionEffect(new PotionEffect(PotionEffectType.RESISTANCE, resSec * 20,     0));
+
+        player.sendMessage(ChatColor.GREEN + ReanimateMC.lang.get("selfrevive_success"));
+    }
+
+    private String buildSelfReviveBar(int pct) {
+        int total  = 10;
+        int filled = (int) Math.round(pct / 10.0);
+        return ChatColor.YELLOW + "█".repeat(filled) + ChatColor.DARK_GRAY + "█".repeat(total - filled);
+    }
+
+    // Cooldown stored per-player using lastDistressTime reuse would conflict;
+    // store as a transient long in KOData via lastDamageTime (separate field).
+    private final Map<UUID, Long> selfReviveCooldownMap = new HashMap<>();
+
+    private void setSelfReviveCooldownStart(Player player) {
+        selfReviveCooldownMap.put(player.getUniqueId(), System.currentTimeMillis());
+    }
+
+    private boolean hasSelfReviveCooldown(Player player, long cooldownMs) {
+        Long start = selfReviveCooldownMap.get(player.getUniqueId());
+        if (start == null) return false;
+        return (System.currentTimeMillis() - start) < cooldownMs;
+    }
+
+    private long selfReviveCooldownRemaining(Player player, long cooldownMs) {
+        Long start = selfReviveCooldownMap.get(player.getUniqueId());
+        if (start == null) return 0;
+        long elapsed = System.currentTimeMillis() - start;
+        return Math.max(0, (cooldownMs - elapsed) / 1000L);
+    }
+
+    public void sendDistressForced(Player player) {
+        if (!isKO(player)) return;
+        if (!ReanimateMC.getInstance().getConfig().getBoolean("knockout.distress.enabled", true)) return;
+
+        KOData data = koPlayers.get(player.getUniqueId());
+        data.setLastDistressTime(System.currentTimeMillis());
+
+        ArmorStand existing = data.getHelpMarker();
+        if (existing != null && existing.isValid()) existing.remove();
+        data.setHelpMarker(null);
+
+        ArmorStand marker = (ArmorStand) player.getWorld().spawnEntity(
+                player.getLocation(), EntityType.ARMOR_STAND);
+        marker.setInvisible(true);
+        marker.setMarker(true);
+        marker.setCustomNameVisible(true);
+        marker.setGravity(false);
+        marker.setGlowing(true);
+        marker.setCustomName(ChatColor.RED + "HELP!");
+        data.setHelpMarker(marker);
+
+        String msg = ReanimateMC.lang.get("distress_broadcast", "player", player.getName(),
+                "x", String.valueOf(player.getLocation().getBlockX()),
+                "y", String.valueOf(player.getLocation().getBlockY()),
+                "z", String.valueOf(player.getLocation().getBlockZ()));
+        Bukkit.broadcastMessage(ChatColor.GOLD + msg);
+        player.sendMessage(ChatColor.GREEN + ReanimateMC.lang.get("distress_sent"));
+    }
+
     public void sendDistress(Player player) {
         if (!isKO(player)) return;
+        if (!ReanimateMC.getInstance().getConfig().getBoolean("knockout.distress.enabled", true)) {
+            player.sendMessage(ChatColor.RED + ReanimateMC.lang.get("distress_disabled"));
+            return;
+        }
+        if (!player.hasPermission("reanimatemc.distress") && !player.isOp()) {
+            player.sendMessage(ChatColor.RED + ReanimateMC.lang.get("no_permission"));
+            return;
+        }
+
         KOData data = koPlayers.get(player.getUniqueId());
+        long cooldownMs = ReanimateMC.getInstance().getConfig()
+                .getLong("knockout.distress.cooldown_seconds", 15) * 1000L;
+        long now = System.currentTimeMillis();
+        long elapsed = now - data.getLastDistressTime();
+        if (elapsed < cooldownMs) {
+            long remaining = (cooldownMs - elapsed) / 1000L;
+            player.sendMessage(ChatColor.RED + ReanimateMC.lang.get("distress_cooldown",
+                    "time", String.valueOf(remaining)));
+            return;
+        }
+        data.setLastDistressTime(now);
+
         ArmorStand existing = data.getHelpMarker();
         if (existing != null && existing.isValid()) {
             existing.remove();
diff --git a/src/main/java/fr/jachou/reanimatemc/managers/NPCPersistenceManager.java b/src/main/java/fr/jachou/reanimatemc/managers/NPCPersistenceManager.java
new file mode 100644
index 0000000..8c03b43
--- /dev/null
+++ b/src/main/java/fr/jachou/reanimatemc/managers/NPCPersistenceManager.java
@@ -0,0 +1,139 @@
+package fr.jachou.reanimatemc.managers;
+
+import fr.jachou.reanimatemc.data.ReanimatorNPC;
+import fr.jachou.reanimatemc.data.ReanimatorNPC.ReanimatorType;
+import org.bukkit.Bukkit;
+import org.bukkit.configuration.file.YamlConfiguration;
+import org.bukkit.entity.Player;
+import org.bukkit.plugin.java.JavaPlugin;
+
+import java.io.File;
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.UUID;
+import java.util.logging.Level;
+
+/**
+ * Serializes active NPCs to {@code npc_data.yml} on server shutdown and
+ * restores them on startup for owners who are online.
+ *
+ * <p>Each entry stores: owner UUID, owner name, NPC type, remaining lifetime
+ * in seconds (0 = unlimited), and the target player UUID if set.
+ *
+ * <p>Entries whose owner is offline at load time are discarded silently.
+ * Entries with 0 remaining seconds (already expired) are also discarded.
+ */
+public class NPCPersistenceManager {
+
+    private static final String FILE_NAME = "npc_data.yml";
+    private static final String KEY_NPCS  = "npcs";
+
+    private final JavaPlugin plugin;
+    private final File dataFile;
+
+    public NPCPersistenceManager(JavaPlugin plugin) {
+        this.plugin   = plugin;
+        this.dataFile = new File(plugin.getDataFolder(), FILE_NAME);
+    }
+
+    // ── Save ──────────────────────────────────────────────────────────────────
+
+    /**
+     * Serializes {@code npcs} to disk. Called from {@code NPCSummonManager.cleanup()}.
+     */
+    public void save(Iterable<ReanimatorNPC> npcs) {
+        YamlConfiguration yaml = new YamlConfiguration();
+        List<Object> entries   = new ArrayList<>();
+        long now = System.currentTimeMillis();
+
+        for (ReanimatorNPC npc : npcs) {
+            if (!npc.isValid()) continue;
+            long expiresAt = npc.getExpiresAt(); // epoch ms, 0 = unlimited
+            if (expiresAt > 0 && (expiresAt - now) < 5000) continue;
+
+            YamlConfiguration entry = new YamlConfiguration();
+            entry.set("owner",     npc.getOwnerId().toString());
+            entry.set("ownerName", npc.getOwnerName());
+            entry.set("type",      npc.getType().name());
+            entry.set("expiresAt", expiresAt); // absolute epoch ms
+            if (npc.getTargetPlayerId() != null) {
+                entry.set("target", npc.getTargetPlayerId().toString());
+            }
+            entries.add(entry);
+        }
+
+        yaml.set(KEY_NPCS, entries);
+        try {
+            yaml.save(dataFile);
+        } catch (IOException e) {
+            plugin.getLogger().log(Level.WARNING, "[ReanimateMC] Failed to save NPC data.", e);
+        }
+    }
+
+    // ── Load ──────────────────────────────────────────────────────────────────
+
+    /**
+     * Reads persisted NPC entries and returns a list of {@link PendingRestore}
+     * records. Caller is responsible for actually summoning them.
+     *
+     * <p>Entries whose owner is offline or whose remaining time has elapsed
+     * are filtered out here.
+     */
+    public List<PendingRestore> load() {
+        List<PendingRestore> result = new ArrayList<>();
+        if (!dataFile.exists()) return result;
+
+        YamlConfiguration yaml = YamlConfiguration.loadConfiguration(dataFile);
+        List<?> raw = yaml.getList(KEY_NPCS);
+        if (raw == null) return result;
+
+        long now = System.currentTimeMillis();
+
+        for (Object obj : raw) {
+            if (!(obj instanceof YamlConfiguration)) continue;
+            YamlConfiguration entry = (YamlConfiguration) obj;
+            try {
+                UUID ownerId    = UUID.fromString(entry.getString("owner", ""));
+                String ownerName= entry.getString("ownerName", "unknown");
+                ReanimatorType type = ReanimatorType.valueOf(entry.getString("type", "GOLEM"));
+                long expiresAt  = entry.getLong("expiresAt", 0L);
+                String targetStr= entry.getString("target");
+                UUID targetId   = targetStr != null ? UUID.fromString(targetStr) : null;
+
+                // Filter entries that expired while the server was down or owner was offline
+                if (expiresAt > 0 && expiresAt <= now) continue;
+
+                // Compute remaining seconds from absolute timestamp
+                long remainingSeconds = expiresAt > 0 ? (expiresAt - now) / 1000L : 0L;
+                if (remainingSeconds == 1) continue; // < 1s left — not worth restoring
+
+                Player owner = Bukkit.getPlayer(ownerId);
+                if (owner == null || !owner.isOnline()) continue;
+
+                result.add(new PendingRestore(owner, type, remainingSeconds, targetId));
+            } catch (IllegalArgumentException ignored) { }
+        }
+
+        // Clear file after successful load
+        try { new YamlConfiguration().save(dataFile); } catch (IOException ignored) { }
+
+        return result;
+    }
+
+    // ── DTO ───────────────────────────────────────────────────────────────────
+
+    public static final class PendingRestore {
+        public final Player owner;
+        public final ReanimatorType type;
+        public final long lifetimeSeconds; // 0 = unlimited
+        public final UUID targetId;
+
+        public PendingRestore(Player owner, ReanimatorType type, long lifetimeSeconds, UUID targetId) {
+            this.owner           = owner;
+            this.type            = type;
+            this.lifetimeSeconds = lifetimeSeconds;
+            this.targetId        = targetId;
+        }
+    }
+}
diff --git a/src/main/java/fr/jachou/reanimatemc/managers/NPCSummonManager.java b/src/main/java/fr/jachou/reanimatemc/managers/NPCSummonManager.java
index e6642a2..0755ac2 100644
--- a/src/main/java/fr/jachou/reanimatemc/managers/NPCSummonManager.java
+++ b/src/main/java/fr/jachou/reanimatemc/managers/NPCSummonManager.java
@@ -8,389 +8,873 @@
 package fr.jachou.reanimatemc.managers;
 
 import fr.jachou.reanimatemc.ReanimateMC;
+import fr.jachou.reanimatemc.api.NPCDismissedEvent;
+import fr.jachou.reanimatemc.api.NPCSummonedEvent;
+import fr.jachou.reanimatemc.behavior.GolemBehavior;
+import fr.jachou.reanimatemc.behavior.HealerBehavior;
+import fr.jachou.reanimatemc.behavior.NPCBehavior;
+import fr.jachou.reanimatemc.behavior.ProtectorBehavior;
 import fr.jachou.reanimatemc.data.ReanimatorNPC;
 import fr.jachou.reanimatemc.data.ReanimatorNPC.ReanimatorType;
+import fr.jachou.reanimatemc.hooks.VaultHook;
 import org.bukkit.*;
 import org.bukkit.attribute.Attribute;
 import org.bukkit.entity.*;
 import org.bukkit.plugin.java.JavaPlugin;
-import org.bukkit.potion.PotionEffect;
-import org.bukkit.potion.PotionEffectType;
 import org.bukkit.scheduler.BukkitRunnable;
 
 import java.util.*;
 import java.util.stream.Collectors;
 
 /**
- * Manager for summoning and managing NPC/Golem reanimators
+ * Manages summoning, behavior, nameplate, lifetime, events, and cleanup of NPC reanimators.
+ *
+ * <p>Type-specific logic is fully delegated to {@link NPCBehavior} implementations.
+ * This class handles orchestration only: scheduling, routing, cooldowns, persistence,
+ * stuck detection, damage intercept, and the public API consumed by commands and listeners.
  */
 public class NPCSummonManager {
+
+    private static final double DEFAULT_FOLLOW_START = 10.0;
+    private static final double DEFAULT_FOLLOW_STOP  = 3.0;
+    private static final double DEFAULT_REVIVE_DIST  = 5.0;
+
     private final JavaPlugin plugin;
     private final KOManager koManager;
-    private final Map<UUID, ReanimatorNPC> activeNPCs;
-    private final Map<UUID, List<UUID>> playerSummons; // Player UUID -> List of NPC IDs
-    private final Map<UUID, Long> summonCooldowns; // Player UUID -> Cooldown end time
-    
-    public NPCSummonManager(JavaPlugin plugin, KOManager koManager) {
-        this.plugin = plugin;
-        this.koManager = koManager;
-        this.activeNPCs = new HashMap<>();
-        this.playerSummons = new HashMap<>();
-        this.summonCooldowns = new HashMap<>();
-        
-        // Start periodic task to manage NPC behavior
-        startNPCBehaviorTask();
-    }
-    
-    /**
-     * Summon a reanimator NPC for a player
-     */
+    private final VaultHook vault;
+    private final NPCPersistenceManager persistence;
+
+    private final Map<UUID, ReanimatorNPC>             activeNPCs          = new HashMap<>();
+    private final Map<UUID, List<UUID>>                playerSummons       = new HashMap<>();
+    private final Map<UUID, Map<ReanimatorType, Long>> typeCooldowns       = new HashMap<>();
+    private final Map<UUID, Set<UUID>>                 interceptedThisTick = new HashMap<>();
+    /** Entity UUID → NPC — O(1) lookup for damage/death listeners. */
+    private final Map<UUID, ReanimatorNPC>             entityIndex         = new HashMap<>();
+    /** Per-type strategy implementations. */
+    private final Map<ReanimatorType, NPCBehavior>     behaviors           = new EnumMap<>(ReanimatorType.class);
+    /** NPC id → target being actively revived (progress in flight). */
+    private final Map<UUID, UUID>    reviveInProgress = new HashMap<>();
+    /** NPC id → BukkitTask id for the running revive progress runnable. */
+    private final Map<UUID, Integer> reviveTasks      = new HashMap<>();
+
+    public NPCSummonManager(JavaPlugin plugin, KOManager koManager, VaultHook vault) {
+        this.plugin      = plugin;
+        this.koManager   = koManager;
+        this.vault       = vault;
+        this.persistence = new NPCPersistenceManager(plugin);
+
+        behaviors.put(ReanimatorType.GOLEM,     new GolemBehavior());
+        behaviors.put(ReanimatorType.HEALER,    new HealerBehavior(koManager));
+        behaviors.put(ReanimatorType.PROTECTOR, new ProtectorBehavior());
+
+        startBehaviorTask();
+        startNameplateTask();
+        startInterceptResetTask();
+        restoreFromDisk();
+    }
+
+    // ═══════════════════════════════════════════════════════════════════════════
+    // Public API
+    // ═══════════════════════════════════════════════════════════════════════════
+
     public boolean summon(Player summoner, ReanimatorType type, Player targetPlayer) {
-        // Check permission
-        if (!summoner.hasPermission("reanimate.summon")) {
+        if (!plugin.getConfig().getBoolean("npc_summon.enabled", false)) {
+            summoner.sendMessage(ChatColor.RED + ReanimateMC.lang.get("npc_summon_disabled"));
+            return false;
+        }
+        if (!summoner.hasPermission("reanimatemc.summon") && !summoner.isOp()) {
             summoner.sendMessage(ChatColor.RED + ReanimateMC.lang.get("no_permission"));
             return false;
         }
-        
-        if (!summoner.hasPermission("reanimate.summon.use." + type.name().toLowerCase())) {
-            summoner.sendMessage(ChatColor.RED + ReanimateMC.lang.get("npc_no_type_permission", "type", type.getDisplayName()));
+        if (!summoner.hasPermission("reanimatemc.summon.use." + type.name().toLowerCase()) && !summoner.isOp()) {
+            summoner.sendMessage(ChatColor.RED + ReanimateMC.lang.get("npc_no_type_permission",
+                    "type", type.getDisplayName()));
             return false;
         }
-        
-        // Check cooldown
-        if (!summoner.hasPermission("reanimate.summon.overridecost")) {
-            long now = System.currentTimeMillis();
-            if (summonCooldowns.containsKey(summoner.getUniqueId())) {
-                long cooldownEnd = summonCooldowns.get(summoner.getUniqueId());
-                if (now < cooldownEnd) {
-                    long remainingSeconds = (cooldownEnd - now) / 1000;
-                    summoner.sendMessage(ChatColor.RED + ReanimateMC.lang.get("npc_summon_cooldown", 
-                        "time", String.valueOf(remainingSeconds)));
-                    return false;
-                }
+
+        boolean bypass = summoner.hasPermission("reanimatemc.summon.overridecost") || summoner.isOp();
+
+        if (!bypass) {
+            Long cooldownEnd = typeCooldowns
+                    .getOrDefault(summoner.getUniqueId(), Collections.emptyMap())
+                    .get(type);
+            if (cooldownEnd != null && System.currentTimeMillis() < cooldownEnd) {
+                long rem = (cooldownEnd - System.currentTimeMillis()) / 1000L;
+                summoner.sendMessage(ChatColor.RED + ReanimateMC.lang.get("npc_summon_cooldown",
+                        "time", String.valueOf(rem)));
+                return false;
             }
         }
-        
-        // Check max summons limit
+
         int maxSummons = plugin.getConfig().getInt("npc_summon.max_summons_per_player", 1);
-        List<UUID> playerNPCs = playerSummons.getOrDefault(summoner.getUniqueId(), new ArrayList<>());
-        if (playerNPCs.size() >= maxSummons && !summoner.hasPermission("reanimate.summon.overridecost")) {
-            summoner.sendMessage(ChatColor.RED + ReanimateMC.lang.get("npc_max_summons", 
-                "max", String.valueOf(maxSummons)));
+        List<UUID> owned = playerSummons.computeIfAbsent(summoner.getUniqueId(), k -> new ArrayList<>());
+        if (!bypass && owned.size() >= maxSummons) {
+            summoner.sendMessage(ChatColor.RED + ReanimateMC.lang.get("npc_max_summons",
+                    "max", String.valueOf(maxSummons)));
             return false;
         }
-        
-        // Spawn the NPC entity
-        Location spawnLoc = summoner.getLocation().add(2, 0, 0);
-        Entity entity = spawnReanimatorEntity(spawnLoc, type);
-        
+
+        // If a target is specified, the NPC belongs to the target, not the summoner.
+        // The summoner is just the caster — they pay the cost and cooldown.
+        Player owner = (targetPlayer != null) ? targetPlayer : summoner;
+
+        long lifetime = resolveLifetime(summoner, type);
+        Location spawnLoc = owner.getLocation().add(2, 0, 0);
+        Entity entity = spawnEntity(spawnLoc, type);
         if (entity == null) {
             summoner.sendMessage(ChatColor.RED + ReanimateMC.lang.get("npc_summon_failed"));
             return false;
         }
-        
-        // Create NPC data
-        ReanimatorNPC npc = new ReanimatorNPC(summoner.getUniqueId(), summoner.getName(), entity, type);
-        if (targetPlayer != null) {
-            npc.setTargetPlayerId(targetPlayer.getUniqueId());
+
+        ReanimatorNPC npc = new ReanimatorNPC(owner.getUniqueId(), owner.getName(),
+                entity, type, lifetime);
+
+        NPCSummonedEvent event = new NPCSummonedEvent(summoner, npc);
+        Bukkit.getPluginManager().callEvent(event);
+        if (event.isCancelled()) {
+            entity.remove();
+            return false;
         }
-        
-        // Store NPC
+
         activeNPCs.put(npc.getId(), npc);
-        playerNPCs.add(npc.getId());
-        playerSummons.put(summoner.getUniqueId(), playerNPCs);
-        
-        // Set cooldown
-        if (!summoner.hasPermission("reanimate.summon.overridecost")) {
-            long cooldownSeconds = plugin.getConfig().getLong("npc_summon.summon_cooldown", 300);
-            summonCooldowns.put(summoner.getUniqueId(), System.currentTimeMillis() + (cooldownSeconds * 1000));
-        }
-        
-        // Visual effects
-        playRitualEffects(spawnLoc);
-        
-        // Notify player
-        summoner.sendMessage(ChatColor.GREEN + ReanimateMC.lang.get("npc_summoned", 
-            "type", type.getDisplayName()));
-        
+        entityIndex.put(entity.getUniqueId(), npc);
+        owned.add(npc.getId());
+
+        if (!bypass) {
+            long cooldownSec = (long) cfg(type.name().toLowerCase() + ".summon_cooldown", 300.0);
+            typeCooldowns
+                    .computeIfAbsent(summoner.getUniqueId(), k -> new EnumMap<>(ReanimatorType.class))
+                    .put(type, System.currentTimeMillis() + cooldownSec * 1000L);
+        }
+
+        playSpawnEffects(spawnLoc, type);
+        String lifetimeMsg = lifetime > 0
+                ? ReanimateMC.lang.get("npc_lifetime_remaining", "time", String.valueOf(lifetime))
+                : "";
+        summoner.sendMessage(ChatColor.GREEN
+                + ReanimateMC.lang.get("npc_summoned", "type", type.getDisplayName())
+                + (lifetimeMsg.isEmpty() ? "" : " " + lifetimeMsg));
+        // If summoner summoned for someone else, notify the recipient
+        if (targetPlayer != null && !targetPlayer.getUniqueId().equals(summoner.getUniqueId())) {
+            targetPlayer.sendMessage(ChatColor.GREEN
+                    + ReanimateMC.lang.get("npc_summoned_for_you",
+                            "type", type.getDisplayName(),
+                            "player", summoner.getName()));
+        }
         return true;
     }
-    
+
     /**
-     * Dismiss a specific NPC
+     * Summons one NPC of the given type for each player in {@code team},
+     * charging the {@code summoner} for each one via Vault.
+     *
+     * <p>Cost: {@code npc_summon.<type>.summon_cost} per player in the team.
+     * If the summoner has {@code reanimatemc.summon.overridecost} or is OP,
+     * no charge is applied.
+     *
+     * @return number of NPCs successfully summoned
      */
+    public int summonTeam(Player summoner, ReanimatorType type, List<Player> team) {
+        if (!plugin.getConfig().getBoolean("npc_summon.enabled", false)) {
+            summoner.sendMessage(ChatColor.RED + ReanimateMC.lang.get("npc_summon_disabled"));
+            return 0;
+        }
+        if (!summoner.hasPermission("reanimatemc.summon") && !summoner.isOp()) {
+            summoner.sendMessage(ChatColor.RED + ReanimateMC.lang.get("no_permission"));
+            return 0;
+        }
+        if (!summoner.hasPermission("reanimatemc.summon.use." + type.name().toLowerCase()) && !summoner.isOp()) {
+            summoner.sendMessage(ChatColor.RED + ReanimateMC.lang.get("npc_no_type_permission",
+                    "type", type.getDisplayName()));
+            return 0;
+        }
+
+        boolean bypass = summoner.hasPermission("reanimatemc.summon.overridecost") || summoner.isOp();
+        double costPerPlayer = plugin.getConfig().getDouble(
+                "npc_summon." + type.name().toLowerCase() + ".summon_cost", 0.0);
+        double totalCost = bypass ? 0.0 : costPerPlayer * team.size();
+
+        if (!bypass && totalCost > 0 && vault != null && vault.isEnabled()) {
+            if (vault.getBalance(summoner) < totalCost) {
+                summoner.sendMessage(ChatColor.RED + ReanimateMC.lang.get(
+                        "npc_team_insufficient_funds",
+                        "cost", vault.format(totalCost),
+                        "count", String.valueOf(team.size())));
+                return 0;
+            }
+            vault.withdraw(summoner, totalCost);
+            summoner.sendMessage(ChatColor.YELLOW + ReanimateMC.lang.get(
+                    "npc_team_charged",
+                    "cost", String.valueOf(totalCost),
+                    "count", String.valueOf(team.size())));
+        }
+
+        int count = 0;
+        for (Player member : team) {
+            if (summon(summoner, type, member)) count++;
+        }
+        summoner.sendMessage(ChatColor.GREEN + ReanimateMC.lang.get(
+                "npc_team_summoned",
+                "count", String.valueOf(count),
+                "type", type.getDisplayName()));
+        return count;
+    }
+
     public boolean dismiss(Player player, UUID npcId) {
         ReanimatorNPC npc = activeNPCs.get(npcId);
         if (npc == null) {
             player.sendMessage(ChatColor.RED + ReanimateMC.lang.get("npc_not_found"));
             return false;
         }
-        
-        // Check ownership
-        if (!npc.getOwnerId().equals(player.getUniqueId()) && !player.hasPermission("reanimate.summon.admin")) {
+        if (!npc.getOwnerId().equals(player.getUniqueId())
+                && !player.hasPermission("reanimatemc.summon.admin") && !player.isOp()) {
             player.sendMessage(ChatColor.RED + ReanimateMC.lang.get("npc_not_owner"));
             return false;
         }
-        
-        // Remove NPC
-        npc.remove();
-        activeNPCs.remove(npcId);
-        
-        List<UUID> playerNPCs = playerSummons.get(npc.getOwnerId());
-        if (playerNPCs != null) {
-            playerNPCs.remove(npcId);
-        }
-        
+        removeNPC(npc, NPCDismissedEvent.Reason.MANUAL);
         player.sendMessage(ChatColor.GREEN + ReanimateMC.lang.get("npc_dismissed"));
         return true;
     }
-    
-    /**
-     * Dismiss all NPCs for a player
-     */
+
     public int dismissAll(Player player) {
-        List<UUID> playerNPCs = playerSummons.get(player.getUniqueId());
-        if (playerNPCs == null || playerNPCs.isEmpty()) {
+        List<UUID> ids = playerSummons.get(player.getUniqueId());
+        if (ids == null || ids.isEmpty()) {
             player.sendMessage(ChatColor.RED + ReanimateMC.lang.get("npc_none_active"));
             return 0;
         }
-        
         int count = 0;
-        List<UUID> toRemove = new ArrayList<>(playerNPCs);
-        for (UUID npcId : toRemove) {
-            ReanimatorNPC npc = activeNPCs.get(npcId);
-            if (npc != null) {
-                npc.remove();
-                activeNPCs.remove(npcId);
-                count++;
-            }
+        for (UUID id : new ArrayList<>(ids)) {
+            ReanimatorNPC npc = activeNPCs.get(id);
+            if (npc != null) { removeNPC(npc, NPCDismissedEvent.Reason.MANUAL); count++; }
         }
-        
-        playerNPCs.clear();
-        player.sendMessage(ChatColor.GREEN + ReanimateMC.lang.get("npc_dismissed_all", "count", String.valueOf(count)));
+        player.sendMessage(ChatColor.GREEN + ReanimateMC.lang.get("npc_dismissed_all",
+                "count", String.valueOf(count)));
         return count;
     }
-    
-    /**
-     * Get status of player's summons
-     */
-    public List<ReanimatorNPC> getPlayerSummons(Player player) {
-        List<UUID> npcIds = playerSummons.getOrDefault(player.getUniqueId(), Collections.emptyList());
-        return npcIds.stream()
-            .map(activeNPCs::get)
-            .filter(Objects::nonNull)
-            .filter(ReanimatorNPC::isValid)
-            .collect(Collectors.toList());
-    }
 
-    public int getPlayerGolems(Player player) {
-        List<UUID> npcIds = playerSummons.getOrDefault(player.getUniqueId(), Collections.emptyList());
+    public int dismissByType(Player player, ReanimatorType type) {
+        List<UUID> ids = playerSummons.get(player.getUniqueId());
+        if (ids == null || ids.isEmpty()) return 0;
         int count = 0;
-        for (UUID id : npcIds) {
+        for (UUID id : new ArrayList<>(ids)) {
             ReanimatorNPC npc = activeNPCs.get(id);
-            if (npc != null && npc.isValid() && npc.getEntity() instanceof IronGolem) {
+            if (npc != null && npc.getType() == type) {
+                removeNPC(npc, NPCDismissedEvent.Reason.MANUAL);
                 count++;
             }
         }
+        if (count > 0) {
+            player.sendMessage(ChatColor.GREEN + ReanimateMC.lang.get("npc_dismissed_all",
+                    "count", String.valueOf(count)));
+        }
         return count;
     }
 
+    public int extendNpcTime(Player player, long seconds, boolean useCost) {
+        List<ReanimatorNPC> npcs = getPlayerSummons(player);
+        if (npcs.isEmpty()) {
+            player.sendMessage(ChatColor.RED + ReanimateMC.lang.get("npc_none_active"));
+            return 0;
+        }
+        if (useCost && vault.isEnabled()) {
+            double costPerMinute = plugin.getConfig().getDouble("npc_summon.extend_cost_per_minute", 100.0);
+            double cost = costPerMinute * (seconds / 60.0);
+            if (!vault.withdraw(player, cost)) {
+                player.sendMessage(ChatColor.RED + ReanimateMC.lang.get("npc_extend_insufficient_funds",
+                        "cost", vault.format(cost)));
+                return -1;
+            }
+            player.sendMessage(ChatColor.YELLOW + ReanimateMC.lang.get("npc_extend_charged",
+                    "cost", vault.format(cost)));
+        }
+        npcs.forEach(n -> n.extendTime(seconds));
+        player.sendMessage(ChatColor.GREEN + ReanimateMC.lang.get("npc_time_extended",
+                "time", String.valueOf(seconds)));
+        return npcs.size();
+    }
+
+    public void sendNpcStatus(Player player) {
+        List<ReanimatorNPC> npcs = getPlayerSummons(player);
+        if (npcs.isEmpty()) {
+            player.sendMessage(ChatColor.YELLOW + ReanimateMC.lang.get("npc_none_active"));
+            return;
+        }
+        player.sendMessage(ChatColor.GOLD + "━━━━━ " + ReanimateMC.lang.get("npc_status_header") + " ━━━━━");
+        for (ReanimatorNPC npc : npcs) {
+            Entity entity = npc.getEntity();
+            double hp    = entity instanceof LivingEntity ? ((LivingEntity) entity).getHealth() : 0;
+            double maxHp = entity instanceof LivingEntity
+                    ? Objects.requireNonNull(((LivingEntity) entity).getAttribute(Attribute.MAX_HEALTH)).getValue()
+                    : behaviors.get(npc.getType()).getMaxHp();
 
-    /**
-     * Spawn the appropriate entity based on type
-     */
-    private Entity spawnReanimatorEntity(Location location, ReanimatorType type) {
-        World world = location.getWorld();
-        if (world == null) return null;
-        
-        Entity entity;
-        switch (type) {
-            case GOLEM:
-            case HEALER:
-            case PROTECTOR:
-                IronGolem golem = (IronGolem) world.spawnEntity(location, EntityType.IRON_GOLEM);
-                golem.setCustomName(ChatColor.GOLD + type.getDisplayName());
-                golem.setCustomNameVisible(true);
-                golem.setPlayerCreated(true);
-                
-                // Make it glow for visibility
-                golem.setGlowing(true);
-                
-                // Increase health for protector
-                if (type == ReanimatorType.PROTECTOR && golem.getAttribute(Attribute.MAX_HEALTH) != null) {
-                    golem.getAttribute(Attribute.MAX_HEALTH).setBaseValue(200.0);
-                    golem.setHealth(200.0);
-                }
-                
-                entity = golem;
-                break;
-            default:
-                entity = null;
+            long remSec  = npc.getRemainingSeconds();
+            String timeStr = remSec == Long.MAX_VALUE ? ChatColor.GRAY + "∞"
+                    : (remSec > 120 ? ChatColor.GREEN : remSec > 30 ? ChatColor.YELLOW : ChatColor.RED)
+                    + formatTime(remSec);
+
+            player.sendMessage(behaviors.get(npc.getType()).buildNameplate(npc, hp, maxHp, remSec));
+            player.sendMessage(ChatColor.GRAY + "  ❤ " + buildHpBar(hp, maxHp)
+                    + ChatColor.GRAY + " " + (int) hp + "/" + (int) maxHp);
+            player.sendMessage(ChatColor.GRAY + "  ⏱ " + timeStr);
+
+            if (npc.getTargetPlayerId() != null) {
+                Player t = Bukkit.getPlayer(npc.getTargetPlayerId());
+                String tName = t != null ? t.getName() : npc.getTargetPlayerId().toString().substring(0, 8);
+                player.sendMessage(ChatColor.GRAY + "  → "
+                        + ReanimateMC.lang.get("npc_status_target", "player", tName));
+            }
+        }
+        player.sendMessage(ChatColor.GOLD + "━━━━━━━━━━━━━━━━━━━━━━━━");
+    }
+
+    public List<ReanimatorNPC> getPlayerSummons(Player player) {
+        return playerSummons.getOrDefault(player.getUniqueId(), Collections.emptyList())
+                .stream().map(activeNPCs::get)
+                .filter(Objects::nonNull).filter(ReanimatorNPC::isValid)
+                .collect(Collectors.toList());
+    }
+
+    public int getPlayerGolems(Player player) {
+        return (int) playerSummons.getOrDefault(player.getUniqueId(), Collections.emptyList())
+                .stream().map(activeNPCs::get)
+                .filter(n -> n != null && n.isValid() && n.getEntity() instanceof IronGolem)
+                .count();
+    }
+
+    /** O(1) lookup for NPCDamageListener. */
+    public ReanimatorNPC getNPCByEntity(org.bukkit.entity.Entity entity) {
+        return entityIndex.get(entity.getUniqueId());
+    }
+
+    /** Called by NPCDamageListener after the golem entity has already died. */
+    public void onNPCDied(ReanimatorNPC npc) {
+        fireNPCDismissedEvent(npc, NPCDismissedEvent.Reason.MANUAL);
+        activeNPCs.remove(npc.getId());
+        entityIndex.remove(npc.getEntity().getUniqueId());
+        cleanupPlayerEntry(npc);
+    }
+
+    public double getInterceptRatio(Player victim, Entity attacker) {
+        for (ReanimatorNPC npc : activeNPCs.values()) {
+            if (npc.getType() != ReanimatorType.PROTECTOR) continue;
+            if (!npc.getOwnerId().equals(victim.getUniqueId())) continue;
+            if (!npc.isValid()) continue;
+            if (npc.getEntity().getLocation().distance(victim.getLocation())
+                    > cfg("protector.intercept_distance", 6.0)) continue;
+            Set<UUID> seen = interceptedThisTick.computeIfAbsent(victim.getUniqueId(), k -> new HashSet<>());
+            if (attacker != null && !seen.add(attacker.getUniqueId())) continue;
+            return cfg("protector.damage_transfer_ratio", 0.75);
+        }
+        return 0.0;
+    }
+
+    public void applyTransferredDamage(Player victim, double absorbed) {
+        for (ReanimatorNPC npc : activeNPCs.values()) {
+            if (npc.getType() != ReanimatorType.PROTECTOR) continue;
+            if (!npc.getOwnerId().equals(victim.getUniqueId())) continue;
+            if (!npc.isValid() || !(npc.getEntity() instanceof LivingEntity)) continue;
+            LivingEntity golem = (LivingEntity) npc.getEntity();
+            // Use damage() so Bukkit processes the death event naturally when HP reaches 0
+            golem.damage(absorbed);
+            golem.getWorld().spawnParticle(Particle.CRIT,
+                    golem.getLocation().add(0, 1, 0), 6, 0.3, 0.3, 0.3);
+            break;
+        }
+    }
+
+    public void cleanup() {
+        persistence.save(activeNPCs.values());
+        for (ReanimatorNPC npc : new ArrayList<>(activeNPCs.values())) {
+            Player owner = Bukkit.getPlayer(npc.getOwnerId());
+            Bukkit.getPluginManager().callEvent(
+                    new NPCDismissedEvent(owner, npc, NPCDismissedEvent.Reason.PLUGIN_DISABLE));
+            npc.remove();
+        }
+        activeNPCs.clear();
+        entityIndex.clear();
+        playerSummons.clear();
+        typeCooldowns.clear();
+    }
+
+    // ═══════════════════════════════════════════════════════════════════════════
+    // Persistence
+    // ═══════════════════════════════════════════════════════════════════════════
+
+    private void restoreFromDisk() {
+        List<NPCPersistenceManager.PendingRestore> pending = persistence.load();
+        for (NPCPersistenceManager.PendingRestore pr : pending) {
+            Player target = pr.targetId != null ? Bukkit.getPlayer(pr.targetId) : null;
+            // Use the saved remaining lifetime, not the config default
+            summonWithLifetime(pr.owner, pr.type, target, pr.lifetimeSeconds);
+        }
+        if (!pending.isEmpty()) {
+            plugin.getLogger().info("[ReanimateMC] Restored " + pending.size() + " NPC(s) from disk.");
         }
-        
-        return entity;
     }
-    
+
     /**
-     * Play visual ritual effects when summoning
+     * Internal summon that overrides the lifetime from config with an explicit
+     * value. Used by persistence restore so golems don't get a fresh lifetime
+     * when the owner reconnects — they keep their remaining time.
+     *
+     * @param lifetimeSeconds remaining seconds (0 = unlimited)
      */
-    private void playRitualEffects(Location location) {
-        World world = location.getWorld();
-        if (world == null) return;
-        
-        // Particle circle
+    private boolean summonWithLifetime(Player summoner, ReanimatorType type,
+                                        Player targetPlayer, long lifetimeSeconds) {
+        Player owner = (targetPlayer != null) ? targetPlayer : summoner;
+        long lifetime = lifetimeSeconds > 0 ? lifetimeSeconds
+                : plugin.getConfig().getLong("npc_summon." + type.name().toLowerCase() + ".lifetime_seconds", 600L);
+
+        Location spawnLoc = owner.getLocation().add(2, 0, 0);
+        Entity entity = spawnEntity(spawnLoc, type);
+        if (entity == null) return false;
+
+        ReanimatorNPC npc = new ReanimatorNPC(owner.getUniqueId(), owner.getName(),
+                entity, type, lifetime);
+        NPCSummonedEvent event = new NPCSummonedEvent(summoner, npc);
+        Bukkit.getPluginManager().callEvent(event);
+        if (event.isCancelled()) { entity.remove(); return false; }
+
+        activeNPCs.put(npc.getId(), npc);
+        entityIndex.put(entity.getUniqueId(), npc);
+        playerSummons.computeIfAbsent(owner.getUniqueId(), k -> new ArrayList<>()).add(npc.getId());
+        behaviors.get(type).onSpawn(npc, (IronGolem) entity);
+        return true;
+    }
+
+    // ═══════════════════════════════════════════════════════════════════════════
+    // Tasks
+    // ═══════════════════════════════════════════════════════════════════════════
+
+    private void startBehaviorTask() {
         new BukkitRunnable() {
-            int ticks = 0;
             @Override
             public void run() {
-                if (ticks >= 20) {
-                    this.cancel();
-                    return;
+                // Snapshot to avoid ConcurrentModificationException:
+                // removeNPC() inside updateBehavior() modifies activeNPCs and playerSummons.
+                List<ReanimatorNPC> snapshot = new ArrayList<>(activeNPCs.values());
+                List<ReanimatorNPC> expired  = new ArrayList<>();
+
+                for (ReanimatorNPC npc : snapshot) {
+                    if (!npc.isValid() || npc.isExpired()) {
+                        expired.add(npc);
+                        continue;
+                    }
+                    npc.incrementBehaviorTick();
+                    updateBehavior(npc);
                 }
-                
-                // Circle of particles
-                for (int i = 0; i < 36; i++) {
-                    double angle = 2 * Math.PI * i / 36;
-                    double x = location.getX() + Math.cos(angle) * 2;
-                    double z = location.getZ() + Math.sin(angle) * 2;
-                    world.spawnParticle(Particle.SOUL_FIRE_FLAME, x, location.getY(), z, 1, 0, 0.5, 0, 0.01);
+
+                for (ReanimatorNPC npc : expired) {
+                    if (!activeNPCs.containsKey(npc.getId())) continue; // already removed
+                    if (npc.isExpired()) notifyExpiry(npc);
+                    fireNPCDismissedEvent(npc, npc.isExpired()
+                            ? NPCDismissedEvent.Reason.EXPIRED : NPCDismissedEvent.Reason.MANUAL);
+                    entityIndex.remove(npc.getEntity().getUniqueId());
+                    npc.remove();
+                    activeNPCs.remove(npc.getId());
+                    cleanupPlayerEntry(npc);
                 }
-                
-                ticks++;
             }
-        }.runTaskTimer(plugin, 0L, 2L);
-        
-        // Sound
-        world.playSound(location, Sound.BLOCK_BEACON_ACTIVATE, 1.0f, 1.0f);
+        }.runTaskTimer(plugin, 20L, 20L);
     }
-    
-    /**
-     * Start the behavior task that manages NPC actions
-     */
-    private void startNPCBehaviorTask() {
+
+    private void startNameplateTask() {
         new BukkitRunnable() {
             @Override
             public void run() {
-                // Clean up invalid NPCs
-                Iterator<Map.Entry<UUID, ReanimatorNPC>> iterator = activeNPCs.entrySet().iterator();
-                while (iterator.hasNext()) {
-                    Map.Entry<UUID, ReanimatorNPC> entry = iterator.next();
-                    ReanimatorNPC npc = entry.getValue();
-                    
-                    if (!npc.isValid()) {
-                        iterator.remove();
-                        List<UUID> playerNPCs = playerSummons.get(npc.getOwnerId());
-                        if (playerNPCs != null) {
-                            playerNPCs.remove(npc.getId());
-                        }
-                        continue;
-                    }
-                    
-                    // Execute NPC behavior
-                    updateNPCBehavior(npc);
+                for (ReanimatorNPC npc : activeNPCs.values()) {
+                    if (!npc.isValid() || !(npc.getEntity() instanceof LivingEntity)) continue;
+                    LivingEntity entity = (LivingEntity) npc.getEntity();
+                    double hp    = entity.getHealth();
+                    double maxHp = Objects.requireNonNull(entity.getAttribute(Attribute.MAX_HEALTH)).getValue();
+                    entity.setCustomName(behaviors.get(npc.getType())
+                            .buildNameplate(npc, hp, maxHp, npc.getRemainingSeconds()));
                 }
             }
-        }.runTaskTimer(plugin, 20L, 20L); // Run every second
+        }.runTaskTimer(plugin, 40L, 40L);
     }
-    
-    /**
-     * Update NPC behavior based on its type and situation
-     */
-    private void updateNPCBehavior(ReanimatorNPC npc) {
+
+    private void startInterceptResetTask() {
+        new BukkitRunnable() {
+            @Override public void run() { interceptedThisTick.clear(); }
+        }.runTaskTimer(plugin, 1L, 1L);
+    }
+
+    // ═══════════════════════════════════════════════════════════════════════════
+    // Behavior dispatch
+    // ═══════════════════════════════════════════════════════════════════════════
+
+    private void updateBehavior(ReanimatorNPC npc) {
         Entity entity = npc.getEntity();
         if (!(entity instanceof Mob)) return;
-        
-        Mob mob = (Mob) entity;
+        Mob mob      = (Mob) entity;
         Player owner = Bukkit.getPlayer(npc.getOwnerId());
-        
-        // If owner is offline, remove NPC after timeout
+
         if (owner == null || !owner.isOnline()) {
-            long timeout = plugin.getConfig().getLong("npc_summon.offline_timeout", 300) * 1000;
+            long timeout = plugin.getConfig().getLong("npc_summon.offline_timeout", 300) * 1000L;
             if (System.currentTimeMillis() - npc.getSummonTime() > timeout) {
-                npc.remove();
+                removeNPC(npc, NPCDismissedEvent.Reason.OFFLINE_TIMEOUT);
             }
             return;
         }
 
-        if (koManager.isKO(owner)) {
+        // Priority 1: owner KO — only types that can revive the owner do so.
+        // For PROTECTOR: only revive if enabled in config AND no HEALER is active.
+        boolean typeCanRevive = behaviors.get(npc.getType()).canReviveOwner();
+        if (typeCanRevive && npc.getType() == ReanimatorType.PROTECTOR) {
+            typeCanRevive = !hasActiveHealer(owner);
+        }
+        if (koManager.isKO(owner) && typeCanRevive) {
             mob.setTarget(null);
             mob.getPathfinder().moveTo(owner.getLocation());
+            if (entity.getLocation().distance(owner.getLocation())
+                    < cfg(npc, "revive_distance", DEFAULT_REVIVE_DIST)) {
+                performRevive(npc, owner, owner);
+            }
+            return;
+        }
+
+        // Protector: when owner goes KO and it cannot revive, warn + forced distress
+        if (koManager.isKO(owner) && !typeCanRevive && npc.getType() == ReanimatorType.PROTECTOR) {
+            if (!npc.isProtectorWarned()) {
+                npc.setProtectorWarned(true);
+                owner.sendMessage(ChatColor.GOLD + ReanimateMC.lang.get("npc_protector_no_revive_warning",
+                        "type", npc.getType().getDisplayName()));
+                koManager.sendDistressForced(owner);
+            }
+        } else if (!koManager.isKO(owner)) {
+            npc.setProtectorWarned(false);
+        }
+
+        // Priority 2: explicit target KO — behavior decides if this type can revive
+        Player target = npc.getTargetPlayerId() != null ? Bukkit.getPlayer(npc.getTargetPlayerId()) : null;
+        if (target != null && koManager.isKO(target) && behaviors.get(npc.getType()).canRevive()) {
+            mob.setTarget(null);
+            mob.getPathfinder().moveTo(target.getLocation());
+            if (entity.getLocation().distance(target.getLocation())
+                    < cfg(npc, "revive_distance", DEFAULT_REVIVE_DIST)) {
+                performRevive(npc, target, owner);
+                npc.setTargetPlayerId(null);
+            }
+            return;
+        }
 
-            if (entity.getLocation().distance(owner.getLocation()) < 5.0) {
-                if (npc.getType() == ReanimatorType.GOLEM || npc.getType() == ReanimatorType.HEALER) {
+        // Priority 3: per-type idle (every 3 seconds)
+        if (npc.getBehaviorTick() % 3 == 0) {
+            behaviors.get(npc.getType()).onIdleTick(npc, mob, owner);
+        }
 
-                    koManager.revive(owner, owner);
+        followOwner(mob, entity, npc, owner);
+    }
 
-                    owner.getWorld().spawnParticle(Particle.HEART, owner.getLocation().add(0, 2, 0), 10, 0.5, 0.5, 0.5);
-                    owner.getWorld().playSound(owner.getLocation(), Sound.BLOCK_ENCHANTMENT_TABLE_USE, 1.0f, 1.5f);
+    // ── Public: command-triggered revive ─────────────────────────────────────
 
-                }
-            }
+    /**
+     * Validates all preconditions for {@code /rmc revive <player>} and starts
+     * the timed revive using the caller's active HEALER.
+     *
+     * <p>Preconditions:
+     * <ul>
+     *   <li>Caller must have an active HEALER NPC.</li>
+     *   <li>Target must be KO'd.</li>
+     *   <li>If {@code reanimation.require_special_item} is enabled, the <b>caller</b>
+     *       must hold the required item in their main hand — it is consumed on
+     *       completion. The target (KO'd player) does not need any item.</li>
+     * </ul>
+     *
+     * @return {@code true} if the revive was started, {@code false} with an error message already sent.
+     */
+    public boolean startCommandRevive(Player caller, Player target) {
+        ReanimatorNPC healer = getActiveHealerNPC(caller);
+        if (healer == null) {
+            caller.sendMessage(ChatColor.RED + ReanimateMC.lang.get("npc_no_healer_active"));
+            return false;
         }
-        
-        // Check if there's a target player to help
-        Player target = null;
-        if (npc.getTargetPlayerId() != null) {
-            target = Bukkit.getPlayer(npc.getTargetPlayerId());
+        if (!koManager.isKO(target)) {
+            caller.sendMessage(ChatColor.RED + ReanimateMC.lang.get("player_not_ko"));
+            return false;
         }
-        
-        // If target exists and is KO, move towards them
-        if (target != null && koManager.isKO(target)) {
-            mob.setTarget(null); // Don't attack anyone
-            mob.getPathfinder().moveTo(target.getLocation());
-            target.sendMessage("Le golem arrive");
-            
-            // Check if close enough to revive
-            if (entity.getLocation().distance(target.getLocation()) < 5.0) {
-                // Perform reanimation based on type
-                target.sendMessage("Le golem arrive est à bonne distance");
-                if (npc.getType() == ReanimatorType.GOLEM || npc.getType() == ReanimatorType.HEALER) {
-                    koManager.revive(target, owner);
-                    
-                    // Visual effect
-                    target.getWorld().spawnParticle(Particle.HEART, target.getLocation().add(0, 2, 0), 10, 0.5, 0.5, 0.5);
-                    target.getWorld().playSound(target.getLocation(), Sound.BLOCK_ENCHANTMENT_TABLE_USE, 1.0f, 1.5f);
-                    
-                    // Clear target
-                    npc.setTargetPlayerId(null);
+        if (reviveInProgress.containsValue(target.getUniqueId())) {
+            caller.sendMessage(ChatColor.RED + ReanimateMC.lang.get("npc_already_reviving"));
+            return false;
+        }
+
+        boolean requireItem = plugin.getConfig().getBoolean("reanimation.require_special_item", true);
+        String requiredItem = plugin.getConfig().getString("reanimation.required_item", "GOLDEN_APPLE");
+        org.bukkit.inventory.ItemStack inHand = caller.getInventory().getItemInMainHand();
+        if (requireItem && (inHand == null || !inHand.getType().toString().equalsIgnoreCase(requiredItem))) {
+            caller.sendMessage(ChatColor.RED + ReanimateMC.lang.get("special_item_required", "item", requiredItem));
+            return false;
+        }
+
+        // Teleport healer to target
+        healer.getEntity().teleport(target.getLocation().add(1.5, 0, 0));
+
+        // Notify target
+        target.sendMessage(ChatColor.GOLD + ReanimateMC.lang.get("npc_reviving_you",
+                "player", caller.getName(), "type", healer.getType().getDisplayName()));
+
+        startTimedRevive(healer, target, caller, requireItem ? inHand : null);
+        caller.sendMessage(ChatColor.GREEN + ReanimateMC.lang.get("revive_start"));
+        return true;
+    }
+
+    /** Returns true if the player has at least one valid HEALER NPC active. */
+    public boolean hasActiveHealer(Player player) {
+        return getActiveHealerNPC(player) != null;
+    }
+
+    private ReanimatorNPC getActiveHealerNPC(Player player) {
+        return playerSummons.getOrDefault(player.getUniqueId(), Collections.emptyList())
+                .stream()
+                .map(activeNPCs::get)
+                .filter(n -> n != null && n.isValid() && n.getType() == ReanimatorType.HEALER)
+                .findFirst()
+                .orElse(null);
+    }
+
+    // ─────────────────────────────────────────────────────────────────────────
+
+    private void performRevive(ReanimatorNPC npc, Player target, Player reviver) {
+        // If already reviving this target, skip
+        if (reviveInProgress.containsKey(npc.getId())) return;
+        startTimedRevive(npc, target, reviver, null);
+    }
+
+    /**
+     * Starts a timed revive countdown for the given NPC → target.
+     * Duration is read from {@code npc_summon.<type>.revive_duration_ticks}.
+     * Shows action-bar progress to both the target and the reviver.
+     * On completion calls {@link KOManager#revive} and fires behavior callback.
+     */
+    private void startTimedRevive(ReanimatorNPC npc, Player target, Player reviver,
+                                   org.bukkit.inventory.ItemStack itemToConsume) {
+        reviveInProgress.put(npc.getId(), target.getUniqueId());
+
+        int totalTicks = (int) cfg(npc, "revive_duration_ticks", 100.0);
+        final int[] elapsed = {0};
+
+        int taskId = Bukkit.getScheduler().scheduleSyncRepeatingTask(plugin, () -> {
+            // Abort conditions
+            if (!npc.isValid() || !target.isOnline() || !koManager.isKO(target)) {
+                cancelReviveTask(npc);
+                return;
+            }
+
+            elapsed[0]++;
+            int pct = (int) ((elapsed[0] / (double) totalTicks) * 100);
+            String bar = buildReviveBar(pct);
+
+            // Action bar on target
+            fr.jachou.reanimatemc.utils.Utils.sendActionBar(target,
+                    ChatColor.GREEN + ReanimateMC.lang.get("npc_being_revived_bar",
+                            "type", npc.getType().getDisplayName(), "bar", bar, "pct", String.valueOf(pct)));
+
+            // Action bar on reviver if online and different from target
+            if (reviver.isOnline() && !reviver.getUniqueId().equals(target.getUniqueId())) {
+                fr.jachou.reanimatemc.utils.Utils.sendActionBar(reviver,
+                        ChatColor.YELLOW + ReanimateMC.lang.get("npc_reviving_bar",
+                                "player", target.getName(), "bar", bar, "pct", String.valueOf(pct)));
+            }
+
+            // Completion
+            if (elapsed[0] >= totalTicks) {
+                cancelReviveTask(npc);
+                if (itemToConsume != null && reviver.isOnline()) {
+                    org.bukkit.inventory.ItemStack current = reviver.getInventory().getItemInMainHand();
+                    if (current != null && current.getType() == itemToConsume.getType()) {
+                        int newAmt = current.getAmount() - 1;
+                        reviver.getInventory().setItemInMainHand(newAmt <= 0 ? null : current);
+                        if (newAmt > 0) current.setAmount(newAmt);
+                    }
                 }
+                koManager.revive(target, reviver);
+                target.getWorld().spawnParticle(Particle.HEART, target.getLocation().add(0, 2, 0), 10, 0.5, 0.5, 0.5);
+                target.getWorld().playSound(target.getLocation(), Sound.BLOCK_ENCHANTMENT_TABLE_USE, 1.0f, 1.5f);
+                behaviors.get(npc.getType()).onRevive(npc, target, reviver);
+                target.sendMessage(ChatColor.GREEN + ReanimateMC.lang.get("revived_by", "player",
+                        npc.getType().getDisplayName()));
+            }
+        }, 0L, 1L);
+
+        reviveTasks.put(npc.getId(), taskId);
+    }
+
+    private void cancelReviveTask(ReanimatorNPC npc) {
+        Integer taskId = reviveTasks.remove(npc.getId());
+        if (taskId != null) Bukkit.getScheduler().cancelTask(taskId);
+        reviveInProgress.remove(npc.getId());
+    }
+
+    private String buildReviveBar(int pct) {
+        int total  = 10;
+        int filled = (int) Math.round(pct / 10.0);
+        return ChatColor.GREEN + "█".repeat(filled) + ChatColor.DARK_GRAY + "█".repeat(total - filled);
+    }
+
+    /**
+     * Follow owner with stuck detection.
+     * If the NPC hasn't moved > 0.5 blocks in {@code stuck_ticks_threshold} ticks
+     * while it should be following, it teleports to the owner.
+     */
+    private void followOwner(Mob mob, Entity entity, ReanimatorNPC npc, Player owner) {
+        double dist = entity.getLocation().distance(owner.getLocation());
+
+        if (dist <= cfg(npc, "follow_stop_distance", DEFAULT_FOLLOW_STOP)) {
+            mob.getPathfinder().stopPathfinding();
+            npc.resetStuckTicks();
+            npc.setLastPosition(entity.getLocation().clone());
+            return;
+        }
+
+        if (dist > cfg(npc, "follow_start_distance", DEFAULT_FOLLOW_START)) {
+            mob.getPathfinder().moveTo(owner.getLocation());
+
+            org.bukkit.Location lastPos = npc.getLastPosition();
+            if (lastPos != null && lastPos.getWorld() != null
+                    && lastPos.getWorld().equals(entity.getWorld())
+                    && entity.getLocation().distanceSquared(lastPos) < 0.25) {
+                npc.incrementStuckTicks();
             } else {
-                // Path to target (using Bukkit pathfinding)
-                mob.getPathfinder().moveTo(target.getLocation());
+                npc.resetStuckTicks();
             }
-        } else {
-            // Follow owner if no target
-            if (entity.getLocation().distance(owner.getLocation()) > 10) {
-                mob.getPathfinder().moveTo(owner.getLocation());
-            } else if (entity.getLocation().distance(owner.getLocation()) < 3) {
-                // Stop if too close
-                mob.getPathfinder().stopPathfinding();
+            npc.setLastPosition(entity.getLocation().clone());
+
+            int threshold = plugin.getConfig().getInt("npc_summon.stuck_ticks_threshold", 5);
+            double teleportThreshold = cfg(npc, "teleport_threshold", 20.0);
+
+            if (npc.getStuckTicks() >= threshold || dist > teleportThreshold) {
+                double angle = Math.random() * Math.PI * 2;
+                Location tp = owner.getLocation().add(Math.cos(angle) * 1.5, 0, Math.sin(angle) * 1.5);
+                entity.teleport(tp);
+                npc.resetStuckTicks();
+                entity.getWorld().spawnParticle(Particle.PORTAL, tp.add(0, 1, 0), 12, 0.3, 0.5, 0.3);
             }
-            
-            // Protector type: attack nearby hostile mobs
-            if (npc.getType() == ReanimatorType.PROTECTOR) {
-                Entity nearbyHostile = owner.getWorld().getNearbyEntities(entity.getLocation(), 10, 10, 10).stream()
-                    .filter(e -> e instanceof Monster)
-                    .filter(e -> e.getLocation().distance(owner.getLocation()) < 15)
-                    .findFirst()
-                    .orElse(null);
-                
-                if (nearbyHostile != null && nearbyHostile instanceof LivingEntity) {
-                    mob.setTarget((LivingEntity) nearbyHostile);
+        }
+    }
+
+    // ═══════════════════════════════════════════════════════════════════════════
+    // Spawn
+    // ═══════════════════════════════════════════════════════════════════════════
+
+    private Entity spawnEntity(Location location, ReanimatorType type) {
+        World world = location.getWorld();
+        if (world == null) return null;
+        NPCBehavior behavior = behaviors.get(type);
+        IronGolem golem = (IronGolem) world.spawnEntity(location, EntityType.IRON_GOLEM);
+        golem.setPlayerCreated(true);
+        golem.setGlowing(true);
+        golem.setCustomNameVisible(true);
+        behavior.onSpawn(null, golem);
+        return golem;
+    }
+
+    private void playSpawnEffects(Location location, ReanimatorType type) {
+        World world = location.getWorld();
+        if (world == null) return;
+        NPCBehavior behavior = behaviors.get(type);
+        final Particle particle = behavior.getSpawnParticle();
+        final Sound sound       = behavior.getSpawnSound();
+        new BukkitRunnable() {
+            int ticks = 0;
+            @Override public void run() {
+                if (ticks >= 20) { cancel(); return; }
+                for (int i = 0; i < 36; i++) {
+                    double a = 2 * Math.PI * i / 36;
+                    world.spawnParticle(particle,
+                            location.getX() + Math.cos(a) * 2, location.getY(),
+                            location.getZ() + Math.sin(a) * 2, 1, 0, 0.3, 0, 0.01);
                 }
+                ticks++;
+            }
+        }.runTaskTimer(plugin, 0L, 2L);
+        world.playSound(location, sound, 1.0f, 1.0f);
+    }
+
+    // ═══════════════════════════════════════════════════════════════════════════
+    // Lifetime
+    // ═══════════════════════════════════════════════════════════════════════════
+
+    private long resolveLifetime(Player player, ReanimatorType type) {
+        long configLifetime = (long) cfg(type.name().toLowerCase() + ".lifetime_seconds", 0.0);
+        long metaLifetime   = 0L;
+        String prefix = "reanimatemc.summon.lifetime." + type.name().toLowerCase() + ".";
+        for (org.bukkit.permissions.PermissionAttachmentInfo pai : player.getEffectivePermissions()) {
+            String perm = pai.getPermission().toLowerCase();
+            if (perm.startsWith(prefix) && pai.getValue()) {
+                try {
+                    long val = Long.parseLong(perm.substring(prefix.length()));
+                    if (val > metaLifetime) metaLifetime = val;
+                } catch (NumberFormatException ignored) { }
             }
         }
+        return metaLifetime > 0 ? metaLifetime : configLifetime;
     }
-    
-    /**
-     * Clean up all NPCs (called on plugin disable)
-     */
-    public void cleanup() {
-        for (ReanimatorNPC npc : activeNPCs.values()) {
-            npc.remove();
+
+    private void notifyExpiry(ReanimatorNPC npc) {
+        Player owner = Bukkit.getPlayer(npc.getOwnerId());
+        if (owner != null && owner.isOnline()) {
+            owner.sendMessage(ChatColor.YELLOW + ReanimateMC.lang.get("npc_expired",
+                    "type", npc.getType().getDisplayName()));
+            if (npc.isValid()) {
+                npc.getEntity().getWorld().spawnParticle(Particle.LARGE_SMOKE,
+                        npc.getEntity().getLocation().add(0, 1, 0), 10, 0.3, 0.5, 0.3);
+                npc.getEntity().getWorld().playSound(npc.getEntity().getLocation(),
+                        Sound.ENTITY_IRON_GOLEM_DEATH, 0.8f, 1.2f);
+            }
         }
-        activeNPCs.clear();
-        playerSummons.clear();
-        summonCooldowns.clear();
+    }
+
+    // ═══════════════════════════════════════════════════════════════════════════
+    // Display
+    // ═══════════════════════════════════════════════════════════════════════════
+
+    private String buildHpBar(double hp, double maxHp) {
+        int total  = 10;
+        int filled = Math.max(0, Math.min(total, (int) Math.round((hp / maxHp) * total)));
+        ChatColor color = hp / maxHp > 0.5 ? ChatColor.GREEN : hp / maxHp > 0.25 ? ChatColor.YELLOW : ChatColor.RED;
+        StringBuilder bar = new StringBuilder();
+        for (int i = 0; i < filled; i++)  bar.append(color).append("❚");
+        for (int i = filled; i < total; i++) bar.append(ChatColor.DARK_GRAY).append("❚");
+        return bar.toString();
+    }
+
+    private String formatTime(long s) {
+        if (s == Long.MAX_VALUE || s < 0) return "∞";
+        return s >= 60 ? (s / 60) + "m" + (s % 60) + "s" : s + "s";
+    }
+
+    // ═══════════════════════════════════════════════════════════════════════════
+    // Config helpers
+    // ═══════════════════════════════════════════════════════════════════════════
+
+    private double cfg(String key, double def) {
+        return plugin.getConfig().getDouble("npc_summon." + key, def);
+    }
+
+    private double cfg(ReanimatorNPC npc, String key, double def) {
+        return cfg(npc.getType().name().toLowerCase() + "." + key, def);
+    }
+
+    // ═══════════════════════════════════════════════════════════════════════════
+    // Cleanup
+    // ═══════════════════════════════════════════════════════════════════════════
+
+    private void removeNPC(ReanimatorNPC npc, NPCDismissedEvent.Reason reason) {
+        fireNPCDismissedEvent(npc, reason);
+        entityIndex.remove(npc.getEntity().getUniqueId());
+        npc.remove();
+        activeNPCs.remove(npc.getId());
+        cleanupPlayerEntry(npc);
+    }
+
+    private void cleanupPlayerEntry(ReanimatorNPC npc) {
+        List<UUID> list = playerSummons.get(npc.getOwnerId());
+        if (list != null) list.remove(npc.getId());
+    }
+
+    private void fireNPCDismissedEvent(ReanimatorNPC npc, NPCDismissedEvent.Reason reason) {
+        Player owner = Bukkit.getPlayer(npc.getOwnerId());
+        Bukkit.getPluginManager().callEvent(new NPCDismissedEvent(owner, npc, reason));
     }
 }
diff --git a/src/main/java/fr/jachou/reanimatemc/utils/Lang.java b/src/main/java/fr/jachou/reanimatemc/utils/Lang.java
index 56dc222..5c44264 100644
--- a/src/main/java/fr/jachou/reanimatemc/utils/Lang.java
+++ b/src/main/java/fr/jachou/reanimatemc/utils/Lang.java
@@ -2,13 +2,18 @@
 
 import org.bukkit.configuration.file.YamlConfiguration;
 import org.bukkit.plugin.java.JavaPlugin;
+
 import java.io.File;
+import java.io.InputStream;
+import java.io.InputStreamReader;
+import java.nio.charset.StandardCharsets;
 import java.util.HashMap;
 import java.util.Map;
 
 public class Lang {
-    private Map<String, String> messages = new HashMap<>();
-    private JavaPlugin plugin;
+
+    private final Map<String, String> messages = new HashMap<>();
+    private final JavaPlugin plugin;
     private String language;
 
     public Lang(JavaPlugin plugin) {
@@ -17,21 +22,43 @@ public Lang(JavaPlugin plugin) {
     }
 
     public void loadLanguage() {
-        // Récupère la langue définie dans la config (par défaut "en")
         language = plugin.getConfig().getString("language", "en");
         File langFolder = new File(plugin.getDataFolder(), "lang");
-        if (!langFolder.exists()) {
-            langFolder.mkdirs();
-        }
+        if (!langFolder.exists()) langFolder.mkdirs();
+
         File langFile = new File(langFolder, language + ".yml");
-        if (!langFile.exists()){
-            // Sauvegarde le fichier de langue par défaut depuis les resources
-            plugin.saveResource("lang/" + language + ".yml", false);
+
+        // Extract from jar if missing on disk
+        if (!langFile.exists()) {
+            String resource = "lang/" + language + ".yml";
+            if (plugin.getResource(resource) != null) {
+                plugin.saveResource(resource, false);
+            } else {
+                // Requested lang not bundled — fall back to English
+                plugin.getLogger().warning("[ReanimateMC] Lang file not found for '" + language + "', falling back to 'en'.");
+                language = "en";
+                langFile = new File(langFolder, "en.yml");
+                if (!langFile.exists()) plugin.saveResource("lang/en.yml", false);
+            }
         }
-        YamlConfiguration config = YamlConfiguration.loadConfiguration(langFile);
+
+        YamlConfiguration disk = YamlConfiguration.loadConfiguration(langFile);
+
+        // Merge any new keys from the bundled lang file without overwriting customizations
+        InputStream bundled = plugin.getResource("lang/" + language + ".yml");
+        if (bundled != null) {
+            YamlConfiguration defaults = YamlConfiguration.loadConfiguration(
+                    new InputStreamReader(bundled, StandardCharsets.UTF_8));
+            disk.setDefaults(defaults);
+            disk.options().copyDefaults(true);
+            try { disk.save(langFile); } catch (Exception e) {
+                plugin.getLogger().warning("[ReanimateMC] Could not save lang file: " + e.getMessage());
+            }
+        }
+
         messages.clear();
-        for (String key: config.getKeys(false)) {
-            messages.put(key, config.getString(key));
+        for (String key : disk.getKeys(false)) {
+            messages.put(key, disk.getString(key));
         }
     }
 
@@ -39,11 +66,10 @@ public String get(String key) {
         return messages.getOrDefault(key, key);
     }
 
-    // Remplace les marqueurs %key% par leur valeur correspondante
     public String get(String key, String... args) {
         String msg = get(key);
-        for (int i = 0; i < args.length; i += 2) {
-            msg = msg.replace("%" + args[i] + "%", args[i+1]);
+        for (int i = 0; i + 1 < args.length; i += 2) {
+            msg = msg.replace("%" + args[i] + "%", args[i + 1]);
         }
         return msg;
     }
diff --git a/src/main/resources/config.yml b/src/main/resources/config.yml
index 9e89000..0679a09 100644
--- a/src/main/resources/config.yml
+++ b/src/main/resources/config.yml
@@ -1,60 +1,321 @@
+# ─────────────────────────────────────────────────────────────────────────────
+# ReanimateMC Configuration
+# Plugin version: ${project.version}
+# ─────────────────────────────────────────────────────────────────────────────
+#
+# QUICK REFERENCE
+#
+# Effect levels (weakness_level, fatigue_level, crawl_slowness_level, etc.)
+#   These are Bukkit amplifier values where 1 = Level I, 2 = Level II, etc.
+#   The amplifier increases the strength of the effect, not its duration.
+#   Example: slowness_level: 1 = Slowness I (slight slow)
+#            slowness_level: 5 = Slowness V (very slow crawl)
+#            slowness_level: 255 = complete immobilization
+#
+# Durations (effects_on_revive, effects_on_selfrevive)
+#   Values are in SECONDS. They are temporary effects applied right after
+#   a player wakes up from K.O. to simulate disorientation and weakness:
+#   - nausea:     screen wobble effect (simulates waking up dazed)
+#   - slowness:   reduced movement speed (simulates injury)
+#   - resistance: brief damage reduction so the player isn't immediately
+#                 knocked out again by the same threat
+#
+# distress block
+#   Controls the signal K.O.'d players send to call for help.
+#   - enabled:              toggle the entire system on/off
+#   - cooldown_seconds:     minimum time between signals (prevents spam)
+#   - drop_key_trigger:     pressing Q (drop key) while K.O. sends the signal
+#   - bedrock_doubletap_ms: double-tap sneak within this window sends the signal
+#                           (0 = disabled). Useful for Bedrock mobile players
+#                           who have limited input options while downed.
+#
+# ─────────────────────────────────────────────────────────────────────────────
+
+# Language for all plugin messages. Available: en, es, fr, de, it, nl, ru, zh, kr, pl, pt
 language: "en"
+
 first_run: true
 setup_completed: false
 
+# ─────────────────────────────────────────────────────────────────────────────
+# REVIVAL SYSTEM
+# Controls how players revive K.O.'d teammates manually (crouching near them).
+# ─────────────────────────────────────────────────────────────────────────────
 reanimation:
+  # Require the reviver to hold a specific item in their main hand.
   require_special_item: true
+  # The item required to revive (Bukkit Material name).
   required_item: GOLDEN_APPLE
+  # How long the reviver must crouch near the target (in ticks, 20 ticks = 1 second).
   duration_ticks: 100
+  # HP restored to the revived player (in half-hearts: 4 = 2 full hearts).
   health_restored: 4
+  # Cooldown (seconds) before the same player can be revived again.
   cooldown: 60
   revive_cooldown: 60
 
+# ─────────────────────────────────────────────────────────────────────────────
+# KNOCKOUT SYSTEM
+# ─────────────────────────────────────────────────────────────────────────────
 knockout:
+  # Enable or disable the entire K.O. system. If false, players die normally.
   enabled: true
+  # How many seconds a player has to be revived before dying from K.O.
   duration_seconds: 30
+  # Prevent all movement while K.O.'d (overridden by prone.allow_crawl).
   movement_disabled: true
+  # Show particle effects around K.O.'d players.
   use_particles: true
+  # Play a heartbeat sound while K.O.'d.
   heartbeat_sound: true
+  # Apply blindness effect while K.O.'d.
   blindness: true
+  # How many seconds the player must hold sneak to surrender (die voluntarily).
   suicide_hold_seconds: 3
+  # Weakness effect level while K.O.'d (1 = Weakness I, 2 = Weakness II, etc.).
   weakness_level: 1
+  # Slowness effect level while K.O.'d and not crawling (1 = fully immobilized).
   fatigue_level: 1
+  # Zero out knockback on K.O.'d players so they stay where they fell.
+  knockback_disabled: true
+  # Allow mobs to continue attacking K.O.'d players. Set to false to make mobs
+  # ignore downed players (recommended for survival servers).
+  mobs_attack_ko: false
+  # Require the player to remain completely still during the surrender countdown.
+  # If they move, the timer resets.
+  surrender_require_still: true
+  # Apply nausea to K.O.'d players while crawl mode is active.
+  crawl_nausea_enabled: true
+  # Nausea amplifier while crawling (1 = Nausea I, 2 = Nausea II, etc.).
+  crawl_nausea_level: 1
+
+  # Restrict which commands K.O.'d players can use.
   enable_commands_allowed: false
   allowed_commands:
     - msg
     - r
     - help
     - reanimatemc:help
+    - rmc distress
+    - reanimatemc distress
+    - rmc selfrevive
+    - reanimatemc selfrevive
+    - rmc sr
+    - reanimatemc sr
+    - rmc cancelselfrevive
+    - rmc cancelsr
+
+  # Distress signal settings (sent when a K.O.'d player calls for help).
+  distress:
+    # Enable the distress signal system entirely.
+    enabled: true
+    # Seconds between distress signals to prevent spam.
+    cooldown_seconds: 15
+    # Allow pressing Q (drop key) while K.O.'d to send a distress signal.
+    drop_key_trigger: true
+    # Time window in ms for double-tap sneak to trigger a distress signal.
+    # Set to 0 to disable. On Bedrock this acts as an additional input method.
+    bedrock_doubletap_ms: 400
 
+# ─────────────────────────────────────────────────────────────────────────────
+# EXECUTION SYSTEM
+# ─────────────────────────────────────────────────────────────────────────────
 execution:
+  # Allow players to permanently execute K.O.'d players by holding left-click.
   enabled: true
+  # How long to hold left-click to execute (in ticks, 40 = 2 seconds).
   hold_duration_ticks: 40
+  # Broadcast a message to all players when someone is executed.
   message_broadcast: true
 
+# ─────────────────────────────────────────────────────────────────────────────
+# EFFECTS AFTER REVIVAL
+# Temporary effects applied to the revived player immediately after waking up.
+# Values are in seconds.
+# ─────────────────────────────────────────────────────────────────────────────
 effects_on_revive:
+  # Nausea duration in seconds (simulates disorientation after waking up).
   nausea: 5
+  # Slowness duration in seconds (simulates weakness from injury).
   slowness: 10
+  # Resistance duration in seconds (brief invulnerability to avoid instant re-K.O.).
   resistance: 10
 
+# ─────────────────────────────────────────────────────────────────────────────
+# PRONE / CRAWL SYSTEM
+# ─────────────────────────────────────────────────────────────────────────────
 prone:
+  # Enable the prone/crawl mechanic while K.O.'d.
   enabled: true
+  # Allow K.O.'d players to toggle crawling with /rmc crawl.
+  # Crawling lets them move slowly rather than being fully immobilized.
   allow_crawl: true
+  # Slowness amplifier while crawling (5 = very slow, 1 = walking pace).
   crawl_slowness_level: 5
+  # Automatically put the player in crawl mode when they enter K.O.
   auto_crawl: false
+  # Allow K.O.'d players to jump while crawling.
+  crawl_allow_jump: false
 
+# ─────────────────────────────────────────────────────────────────────────────
+# LOOTING SYSTEM
+# ─────────────────────────────────────────────────────────────────────────────
 looting:
+  # Allow other players to loot a K.O.'d player's inventory.
   enabled: true
 
+# ─────────────────────────────────────────────────────────────────────────────
+# TAB LIST
+# ─────────────────────────────────────────────────────────────────────────────
 tablist:
+  # Show a [KO] tag next to K.O.'d players in the player list.
   enabled: true
 
+# ─────────────────────────────────────────────────────────────────────────────
+# SELF-REVIVE SYSTEM
+# Allows K.O.'d players to revive themselves using items, at the cost of
+# a longer wait time and more resources than a teammate revive.
+# ─────────────────────────────────────────────────────────────────────────────
+self_revive:
+  # Enable or disable the self-revive system entirely.
+  enabled: true
+  # Require the player to hold specific items in their inventory to self-revive.
+  require_items: true
+  # Items required (Bukkit Material name and amount). All items must be present.
+  # They are consumed only on successful completion.
+  required_items:
+    - material: GOLDEN_APPLE
+      amount: 2
+  # How long the self-revive channel takes (ticks, 20 = 1 second).
+  # Longer than a teammate revive to balance solo play.
+  duration_ticks: 200
+  # HP restored after a successful self-revive (half-hearts).
+  health_restored: 2
+  # Seconds before the same player can use self-revive again.
+  cooldown_seconds: 120
+  # Maximum times a player can self-revive per K.O. session (0 = unlimited).
+  max_uses_per_ko: 1
+  # Cancel the self-revive if the player moves during the channel.
+  cancel_on_move: true
+  # Cancel the self-revive if the player takes any damage during the channel.
+  cancel_on_damage: true
+  # Block self-revive if the player was recently in combat (seconds since last hit).
+  # Set to 0 to disable the combat check.
+  combat_block_seconds: 0
+  # Temporary effects applied after a successful self-revive.
+  effects_on_selfrevive:
+    # Nausea duration in seconds.
+    nausea: 10
+    # Slowness duration in seconds.
+    slowness: 15
+    # Resistance duration in seconds (brief protection after waking up alone).
+    resistance: 5
+
+# ─────────────────────────────────────────────────────────────────────────────
+# NPC REANIMATOR SYSTEM
+# Iron Golem NPCs that follow players and revive / heal / protect them.
+# ─────────────────────────────────────────────────────────────────────────────
 npc_summon:
+  # Enable or disable the entire NPC system.
   enabled: true
+  # Maximum number of active NPCs per player (across all types combined).
   max_summons_per_player: 1
-  summon_cooldown: 300
+  # Seconds before an NPC is dismissed if its owner stays offline.
   offline_timeout: 300
+  # Ticks without movement before the NPC teleports directly to the owner.
+  stuck_ticks_threshold: 5
+  # Make all NPCs fully invulnerable to all damage.
+  invulnerable: false
+  # Require the player to hold an item to summon any NPC.
   require_item: false
   required_item: NETHER_STAR
   item_to_summon_golem: GOLD_INGOT
+  # HP fraction at which the owner receives a low-HP action-bar warning (0.30 = 30%).
+  low_hp_threshold: 0.30
+  # Vault economy cost per 60 seconds when using /rmc extend.
+  extend_cost_per_minute: 100.0
+
+  # ── GOLEM — standard reanimator ──────────────────────────────────────────
+  # Follows the owner, revives them when K.O., and defends against attackers.
+  golem:
+    # Maximum HP of this golem type.
+    max_hp: 80
+    # Seconds before the golem despawns automatically.
+    lifetime_seconds: 600
+    # Seconds before the same player can summon another golem of this type.
+    summon_cooldown: 300
+    # Vault economy cost to summon (0.0 = free).
+    summon_cost: 0.0
+    follow_start_distance: 10.0
+    follow_stop_distance: 3.0
+    revive_distance: 5.0
+    # Duration of the revive progress bar (ticks, 20 ticks = 1 second).
+    revive_duration_ticks: 100
+    teleport_threshold: 20.0
+    # Radius (blocks) to scan for threats when defending the owner.
+    combat_radius: 12.0
+
+  # ── HEALER — support reanimator ──────────────────────────────────────────
+  # Revives, heals, and supports the entire team.
+  healer:
+    max_hp: 120
+    lifetime_seconds: 600
+    summon_cooldown: 300
+    summon_cost: 0.0
+    follow_start_distance: 10.0
+    follow_stop_distance: 3.0
+    revive_distance: 5.0
+    # Healer revives faster than GOLEM (60 ticks = ~3 seconds).
+    revive_duration_ticks: 60
+    teleport_threshold: 20.0
+    # Max distance from the owner the healer will move to heal an ally.
+    max_leash_distance: 12.0
+    # HP below which the healer moves toward an injured player.
+    low_hp_threshold: 16.0
+    # Radius to scan for K.O.'d allies to auto-revive.
+    scan_radius: 16.0
+    # Owner HP below which the healer applies Regeneration.
+    aura_hp_threshold: 6.0
+    # Extra HP granted to the player immediately after being revived.
+    bonus_hp_on_revive: 4.0
+    # Seconds between each heal tick.
+    periodic_heal_interval: 10
+    # HP healed to the owner per heal tick (in half-hearts).
+    periodic_heal_amount: 2.0
+    # Max distance from the healer to the owner for the owner heal to apply.
+    periodic_heal_range: 8.0
+    # HP healed to each nearby ally per tick.
+    ally_heal_amount: 1.0
+    # Radius to scan for allies to heal.
+    ally_heal_range: 12.0
+    # Also restore HP to the healer itself each tick.
+    heal_self: true
+    self_heal_amount: 1.0
+    # Also restore HP to nearby allied golems (Golem and Protector types).
+    heal_golems: true
+    golem_heal_amount: 3.0
+    # Show a rotating circular particle aura on each heal tick.
+    aura_particle_enabled: true
+    # Radius of the circular aura animation (blocks).
+    aura_particle_radius: 3
 
+  # ── PROTECTOR — tank reanimator ──────────────────────────────────────────
+  # High HP, intercepts owner damage, fights attackers. Cannot heal.
+  protector:
+    max_hp: 200
+    lifetime_seconds: 600
+    summon_cooldown: 60
+    summon_cost: 0.0
+    follow_start_distance: 10.0
+    follow_stop_distance: 3.0
+    revive_distance: 5.0
+    # Protector revives slowly — it is not its primary role (160 ticks = ~8 seconds).
+    revive_duration_ticks: 160
+    teleport_threshold: 20.0
+    combat_radius: 12.0
+    intercept_distance: 6.0
+    # Fraction of incoming owner damage absorbed by the protector (0.75 = 75%).
+    damage_transfer_ratio: 0.75
+    # Allow the protector to revive the owner only when no HEALER NPC is active.
+    # Set to false to make the protector never revive anyone.
+    revive_if_no_healer: true
diff --git a/src/main/resources/lang/en.yml b/src/main/resources/lang/en.yml
index c4d0f14..e1aeb52 100644
--- a/src/main/resources/lang/en.yml
+++ b/src/main/resources/lang/en.yml
@@ -12,7 +12,6 @@ special_item_not_set: "The special item is not set in the config or is invalid :
 execution_in_progress: "Execution in progress... Keep left-clicking!"
 command_usage: "Usage: /reanimatemc <reload|revive|knockout|status|config> [player]"
 no_permission: "Permission denied."
-config_reloaded: "Configuration and language reloaded!"
 command_revive_usage: "Usage: /reanimatemc revive <player>"
 player_not_found: "Player not found."
 player_not_ko: "The player is not K.O."
@@ -57,6 +56,10 @@ option_knockout_particles: "KO Particles"
 option_knockout_sound: "KO Heartbeat Sound"
 option_execution_enabled: "Execution System Enabled"
 option_execution_broadcast: "Broadcast Execution"
+option_mobs_attack_ko: "Mobs Attack KO'd Players"
+option_knockback_disabled: "Disable Knockback on KO"
+option_surrender_require_still: "Must Be Still to Surrender"
+revive_cancelled_moved: "Revival cancelled: you moved."
 option_prone_enabled: "Prone Mode Enabled"
 option_prone_crawl: "Allow Crawl Mode"
 option_looting_enabled: "Looting Enabled"
@@ -78,6 +81,14 @@ first_run_message: "Use /reanimatemc config to configure the plugin!"
 setup_complete: "Plugin configured! Thank you."
 distress_sent: "Distress signal sent!"
 distress_broadcast: "%player% needs help at %x%, %y%, %z%!"
+distress_cooldown: "Distress signal on cooldown. %time%s remaining."
+distress_disabled: "Distress signals are disabled on this server."
+npc_no_healer_active: "You need an active Healer Golem to use this command."
+npc_already_reviving: "Someone is already being revived."
+npc_reviving_you: "%player%'s %type% is reviving you..."
+npc_being_revived_bar: "%type% reviving... %bar% %pct%%"
+npc_reviving_bar: "Reviving %player%... %bar% %pct%%"
+npc_protector_no_revive_warning: "Your %type% is focused on defense — it cannot revive you. A distress signal has been sent to your team."
 
 # Categories
 category_reanimation: "Reanimation"
@@ -171,7 +182,102 @@ npc_not_found: "NPC not found."
 npc_not_owner: "You do not own this NPC."
 npc_invalid_type: "Invalid NPC type: %type%. Valid types: golem, healer, protector"
 npc_no_type_permission: "You do not have permission to summon %type%."
+npc_summon_disabled: "The NPC Reanimator System is disabled on this server."
 npc_summon_cooldown: "You must wait %time% seconds before summoning again."
 npc_max_summons: "You have reached the maximum number of summons (%max%)."
 npc_summon_failed: "Failed to summon NPC. Try again."
 npc_status_header: "Active NPCs:"
+npc_status_target: "→ Target: %player%"
+npc_healer_aura_active: "Your Healer is protecting you."
+npc_healer_scanning: "Your Healer detected a KO'd ally nearby."
+npc_protector_intercepted: "Your Protector absorbed incoming damage."
+npc_protector_knockback: "Your Protector repelled nearby threats."
+npc_low_hp: "%type% is critically low! ❤ %hp% HP remaining."
+npc_died: "Your %type% has been defeated."
+npc_expired: "%type% has expired and disappeared."
+npc_lifetime_remaining: "(%time%s remaining)"
+npc_time_extended: "NPC lifetime extended by %time% seconds."
+npc_extend_charged: "Charged %cost% for the extension."
+npc_extend_insufficient_funds: "You need %cost% to extend your NPC's lifetime."
+command_extend_usage: "Usage: /reanimatemc extend <seconds>"
+purge_complete: "Cleanup complete: removed %count% stale K.O. hologram(s) from all worlds."
+kolist_header: "Players in K.O."
+kolist_empty: "No players are currently K.O."
+
+# NPC display names (configurable)
+npc_name_golem: "Iron Golem Reanimator"
+npc_name_healer: "Healing Golem"
+npc_name_protector: "Protective Golem"
+
+# NPC summoned for another player
+npc_summoned_for_you: "%player% summoned a %type% for you!"
+
+# Team summon
+npc_team_summoned: "Summoned %type% for %count% team member(s)."
+npc_team_charged: "Charged %cost% for %count% summon(s)."
+npc_team_insufficient_funds: "You need %cost% to summon for %count% player(s)."
+command_summon_team_usage: "Usage: /rmc summon team <golem|healer|protector> <player1> <player2> ..."
+
+# /rmc help
+cmd_help_title: "Commands"
+cmd_help_reload: "Reload config and language files"
+cmd_help_revive: "Start a timed revive via your Healer NPC"
+cmd_help_knockout: "Force a player into K.O."
+cmd_help_status: "Check a player's K.O. status"
+cmd_help_distress: "Send a distress signal while K.O.'d"
+cmd_help_crawl: "Toggle crawl mode while K.O.'d"
+cmd_help_config: "Open the configuration GUI"
+cmd_help_summon: "Summon a Reanimator NPC (optional: for another player)"
+cmd_help_summon_team: "Summon an NPC for multiple team members"
+cmd_help_dismiss: "Dismiss your active NPC(s)"
+cmd_help_extend: "Extend active NPC lifetime"
+cmd_help_npcs: "Show your active NPCs status"
+cmd_help_purge: "Remove stale K.O. holograms from all worlds"
+cmd_help_kolist: "List K.O.'d players and time remaining"
+cmd_help_info: "Show plugin status and integration info"
+cmd_help_version: "Show plugin version"
+cmd_arg_player: "player"
+cmd_arg_seconds: "seconds"
+
+# /rmc version
+cmd_version_plugin: "Plugin:"
+cmd_version_author: "Author:"
+cmd_version_mc: "Minecraft:"
+cmd_version_api: "API:"
+
+# /rmc info
+cmd_info_version: "Version:"
+cmd_info_active: "active"
+cmd_info_inactive: "inactive"
+cmd_info_enabled: "enabled"
+cmd_info_disabled: "disabled"
+cmd_info_npc: "NPC System:"
+cmd_info_ko_count: "Players K.O.:"
+cmd_info_hint: "Commands:"
+
+# ConfigGUI — DOUBLE type
+click_decrease_005: "Left Click: -0.05"
+shift_click_increase_005: "Shift+Click: +0.05"
+
+# ConfigGUI — new option labels
+option_crawl_nausea_enabled: "Crawl Nausea Effect"
+option_crawl_nausea_level: "Crawl Nausea Level"
+option_npc_enabled: "NPC Reanimator System"
+option_npc_invulnerable: "NPC Invulnerable Mode"
+option_npc_damage_transfer: "Protector Damage Transfer"
+option_npc_protector_revive: "Protector Revives (No Healer)"
+
+# Self-revive system
+selfrevive_disabled: "Self-revive is disabled on this server."
+selfrevive_already_channeling: "You are already reviving yourself."
+selfrevive_max_uses: "You have reached the self-revive limit for this K.O. session (%max% use(s))."
+selfrevive_cooldown: "Self-revive is on cooldown. Try again in %time%s."
+selfrevive_combat_block: "You were hit too recently. Wait %time%s before using self-revive."
+selfrevive_missing_items: "You need %amount%x %item% to self-revive."
+selfrevive_start: "Reviving yourself... Hold still!"
+selfrevive_progress_bar: "Self-reviving %bar% %pct%%"
+selfrevive_cancelled: "Self-revive cancelled."
+selfrevive_success: "You revived yourself. Stay safe."
+selfrevive_not_channeling: "You are not currently reviving yourself."
+cmd_help_selfrevive: "Revive yourself using items (K.O. only)"
+cmd_help_cancelselfrevive: "Cancel a self-revive in progress"
diff --git a/src/main/resources/lang/es.yml b/src/main/resources/lang/es.yml
index aeb36aa..78f0ef3 100644
--- a/src/main/resources/lang/es.yml
+++ b/src/main/resources/lang/es.yml
@@ -10,7 +10,7 @@ not_sneaking: "¡Para revivir a alguien debes estar agachado!"
 special_item_required: "Para revivir, debes tener el objeto especial: %item%!"
 special_item_not_set: "El objeto especial no está configurado o es inválido: %item%!"
 execution_in_progress: "Ejecución en progreso... ¡Sigue haciendo clic izquierdo!"
-command_usage: "Uso: /reanimatemc <reload|revive|knockout|status|config> [jugador]"
+command_usage: "Uso: /reanimatemc <reload|revive|knockout|status|crawl|config|summon|dismiss|extend|npcs> [jugador]"
 no_permission: "Permiso denegado."
 config_reloaded: "¡Configuración e idioma recargados!"
 command_revive_usage: "Uso: /reanimatemc revive <jugador>"
@@ -22,7 +22,7 @@ knockout_set: "%player% ahora está K.O."
 command_status_usage: "Uso: /reanimatemc status <jugador>"
 status_ko: "K.O."
 status_normal: "Vivo/Normal"
-command_unknown: "Comando desconocido. Usa: reload, revive, knockout, status"
+command_unknown: "Comando desconocido. Usa: reload, revive, knockout, status, summon, dismiss, extend, npcs"
 not_in_ko: "No estás K.O."
 crawl_not_allowed: "El modo de arrastre no está habilitado en este servidor."
 crawl_enabled: "Modo de arrastre habilitado. Ahora puedes arrastrarte lentamente."
@@ -57,9 +57,41 @@ option_knockout_particles: "Partículas de K.O."
 option_knockout_sound: "Sonido de latido K.O."
 option_execution_enabled: "Sistema de ejecución habilitado"
 option_execution_broadcast: "Transmitir ejecución"
+option_mobs_attack_ko: "Mobs atacan jugadores K.O."
+option_knockback_disabled: "Desactivar empuje en K.O."
+option_surrender_require_still: "Debe estar quieto para rendirse"
+revive_cancelled_moved: "Reanimación cancelada: te moviste."
 option_prone_enabled: "Modo prono habilitado"
 option_prone_crawl: "Permitir modo de arrastre"
 option_looting_enabled: "Saqueo habilitado"
+option_knockout_blindness: "Ceguera al caer K.O."
+option_tablist_enabled: "Etiqueta K.O. en lista de jugadores"
+
+message_gui_toggle: "%option% ahora está %state%"
+
+# Estadísticas y info del plugin
+stats_title: "Estadísticas"
+stats_ko: "K.O.: %value%"
+stats_revive: "Reanimaciones: %value%"
+plugin_info: "Info del Plugin"
+info_version: "Versión: %value%"
+info_authors: "Autores: %value%"
+change_language: "Cambiar Idioma"
+language_changed: "Idioma cambiado a %lang%"
+first_run_message: "¡Usa /reanimatemc config para configurar el plugin!"
+setup_complete: "¡Plugin configurado! Gracias."
+
+# Señal de socorro
+distress_sent: "¡Señal de socorro enviada!"
+distress_broadcast: "¡%player% necesita ayuda en %x%, %y%, %z%!"
+distress_cooldown: "Señal de socorro en cooldown. Quedan %time%s."
+distress_disabled: "Las señales de socorro están desactivadas en este servidor."
+npc_no_healer_active: "Necesitas un Golem Curador activo para usar este comando."
+npc_already_reviving: "Ya hay alguien siendo reanimado."
+npc_reviving_you: "El %type% de %player% te está reanimando..."
+npc_being_revived_bar: "%type% reanimando... %bar% %pct%%"
+npc_reviving_bar: "Reanimando a %player%... %bar% %pct%%"
+npc_protector_no_revive_warning: "Tu %type% está enfocado en defenderte — no puede reanimarte. Se ha enviado una señal de socorro a tu equipo."
 
 
 # Categorías
@@ -139,4 +171,115 @@ option_effect_resistance: "Duración resistencia"
 update_available: "Nueva versión disponible:"
 update_log: "Nueva versión disponible: %version% -> %url%"
 update_command_available: "Actualización disponible: %version% — %url%"
-update_up_to_date: "Estás actualizado para tu versión de Minecraft."
\ No newline at end of file
+update_up_to_date: "Estás actualizado para tu versión de Minecraft."
+
+# Sistema de invocación de NPCs
+command_summon_usage: "Uso: /reanimatemc summon <golem|healer|protector> [jugador]"
+command_dismiss_usage: "Uso: /reanimatemc dismiss <all>"
+command_extend_usage: "Uso: /reanimatemc extend <segundos>"
+purge_complete: "Limpieza completada: se eliminaron %count% holograma(s) K.O. residual(es) de todos los mundos."
+kolist_header: "Jugadores en K.O."
+kolist_empty: "No hay jugadores en K.O. actualmente."
+command_player_only: "Este comando solo puede ser ejecutado por un jugador."
+npc_summoned: "¡%type% ha sido invocado!"
+npc_dismissed: "NPC despedido correctamente."
+npc_dismissed_all: "%count% NPC(s) despedido(s)."
+npc_none_active: "No tienes NPCs activos."
+npc_not_found: "NPC no encontrado."
+npc_not_owner: "No eres el dueño de este NPC."
+npc_invalid_type: "Tipo de NPC inválido: %type%. Tipos válidos: golem, healer, protector"
+npc_no_type_permission: "No tienes permiso para invocar %type%."
+npc_summon_disabled: "El Sistema de Reanimadores NPC está desactivado en este servidor."
+npc_summon_cooldown: "Debes esperar %time% segundos antes de volver a invocar."
+npc_max_summons: "Has alcanzado el número máximo de invocaciones (%max%)."
+npc_summon_failed: "Error al invocar el NPC. Inténtalo de nuevo."
+npc_status_header: "NPCs activos:"
+npc_status_target: "→ Objetivo: %player%"
+npc_healer_aura_active: "Tu Paramédico te está protegiendo."
+npc_healer_scanning: "Tu Paramédico detectó un aliado K.O. cercano."
+npc_protector_intercepted: "Tu Guardaespaldas absorbió el daño entrante."
+npc_protector_knockback: "Tu Guardaespaldas repelió las amenazas cercanas."
+npc_low_hp: "¡%type% está en estado crítico! ❤ %hp% HP restantes."
+npc_died: "Tu %type% ha sido derrotado."
+npc_expired: "%type% ha expirado y desapareció."
+npc_lifetime_remaining: "(%time%s restantes)"
+npc_time_extended: "Tiempo del NPC extendido en %time% segundos."
+npc_extend_charged: "Se te cobraron %cost% por la extensión."
+npc_extend_insufficient_funds: "Necesitas %cost% para extender el tiempo de tu NPC."
+# Nombres de NPC (configurables)
+npc_name_golem: "Reanimador Golem de Hierro"
+npc_name_healer: "Golem Curador"
+npc_name_protector: "Golem Protector"
+
+# NPC invocado para otro jugador
+npc_summoned_for_you: "¡%player% invocó un %type% para ti!"
+
+# Invocación en equipo
+npc_team_summoned: "Se invocó un %type% para %count% miembro(s) del equipo."
+npc_team_charged: "Se cobró %cost% por %count% invocación(es)."
+npc_team_insufficient_funds: "Necesitas %cost% para invocar para %count% jugador(es)."
+command_summon_team_usage: "Uso: /rmc summon team <golem|healer|protector> <jugador1> <jugador2> ..."
+
+# /rmc help
+cmd_help_title: "Comandos"
+cmd_help_reload: "Recargar config y archivos de idioma"
+cmd_help_revive: "Iniciar reanimación usando tu Golem Curador"
+cmd_help_knockout: "Poner a un jugador en estado K.O."
+cmd_help_status: "Ver estado K.O. de un jugador"
+cmd_help_distress: "Enviar señal de auxilio mientras estás K.O."
+cmd_help_crawl: "Alternar modo gateo mientras estás K.O."
+cmd_help_config: "Abrir la GUI de configuración"
+cmd_help_summon: "Invocar un NPC Reanimador (opcional: para otro jugador)"
+cmd_help_summon_team: "Invocar un NPC para múltiples miembros del equipo"
+cmd_help_dismiss: "Despedir tu(s) NPC(s) activo(s)"
+cmd_help_extend: "Extender el tiempo de vida del NPC activo"
+cmd_help_npcs: "Ver estado de tus NPCs activos"
+cmd_help_purge: "Eliminar hologramas K.O. residuales de todos los mundos"
+cmd_help_kolist: "Ver jugadores K.O. y tiempo restante"
+cmd_help_info: "Ver estado del plugin e integraciones"
+cmd_help_version: "Ver versión del plugin"
+cmd_arg_player: "jugador"
+cmd_arg_seconds: "segundos"
+
+# /rmc version
+cmd_version_plugin: "Plugin:"
+cmd_version_author: "Autor:"
+cmd_version_mc: "Minecraft:"
+cmd_version_api: "API:"
+
+# /rmc info
+cmd_info_version: "Versión:"
+cmd_info_active: "activo"
+cmd_info_inactive: "inactivo"
+cmd_info_enabled: "habilitado"
+cmd_info_disabled: "deshabilitado"
+cmd_info_npc: "Sistema NPC:"
+cmd_info_ko_count: "Jugadores K.O.:"
+cmd_info_hint: "Comandos:"
+
+# ConfigGUI — tipo DOUBLE
+click_decrease_005: "Clic Izquierdo: -0.05"
+shift_click_increase_005: "Shift+Clic: +0.05"
+
+# ConfigGUI — nuevas opciones
+option_crawl_nausea_enabled: "Efecto de Mareo al Gatear"
+option_crawl_nausea_level: "Nivel de Mareo al Gatear"
+option_npc_enabled: "Sistema de NPCs Reanimadores"
+option_npc_invulnerable: "Modo Invulnerable NPC"
+option_npc_damage_transfer: "Transferencia de Daño (Protector)"
+option_npc_protector_revive: "Protector Reanima (Sin Curador)"
+
+# Sistema de auto-reanimación
+selfrevive_disabled: "La auto-reanimación está desactivada en este servidor."
+selfrevive_already_channeling: "Ya te estás reanimando."
+selfrevive_max_uses: "Alcanzaste el límite de auto-reanimaciones para esta sesión K.O. (%max% uso(s))."
+selfrevive_cooldown: "Auto-reanimación en espera. Inténtalo en %time%s."
+selfrevive_combat_block: "Recibiste daño recientemente. Espera %time%s antes de auto-reanimarte."
+selfrevive_missing_items: "Necesitas %amount%x %item% para auto-reanimarte."
+selfrevive_start: "Reanimándote... ¡No te muevas!"
+selfrevive_progress_bar: "Auto-reanimación %bar% %pct%%"
+selfrevive_cancelled: "Auto-reanimación cancelada."
+selfrevive_success: "Te reanimaste. Ten cuidado."
+selfrevive_not_channeling: "No estás reanimándote actualmente."
+cmd_help_selfrevive: "Reanimarte usando ítems (solo en K.O.)"
+cmd_help_cancelselfrevive: "Cancelar una auto-reanimación en curso"
diff --git a/src/main/resources/lang/kr.yml b/src/main/resources/lang/kr.yml
index 50081cd..8c066c0 100644
--- a/src/main/resources/lang/kr.yml
+++ b/src/main/resources/lang/kr.yml
@@ -12,7 +12,6 @@ special_item_not_set: "특별한 아이템이 지정되지 않았거나 존재
 execution_in_progress: "처형중... 좌클릭을 계속 하세요!"
 command_usage: "사용법: /reanimatemc <reload|revive|knockout|status> [대상]"
 no_permission: "권한 거절됨."
-config_reloaded: "설정사항과 언어가 재설정됐습니다!"
 command_revive_usage: "사용법: /reanimatemc revive <대상>"
 player_not_found: "대상을 찾지 못했습니다."
 player_not_ko: "대상이 기절하지 않았습니다."
@@ -155,4 +154,4 @@ option_effect_resistance: "저항 지속시간"
 update_available: "새 버전 사용 가능:"
 update_log: "새 버전 사용 가능: %version% -> %url%"
 update_command_available: "업데이트 사용 가능: %version% — %url%"
-update_up_to_date: "현재 마인크래프트 버전에 대해 최신 상태입니다."
\ No newline at end of file
+update_up_to_date: "현재 마인크래프트 버전에 대해 최신 상태입니다."
diff --git a/src/main/resources/lang/pt.yml b/src/main/resources/lang/pt.yml
index 99502f9..25fc7dd 100644
--- a/src/main/resources/lang/pt.yml
+++ b/src/main/resources/lang/pt.yml
@@ -12,7 +12,6 @@ special_item_not_set: "O item especial não está configurado ou é inválido: %
 execution_in_progress: "Execução em andamento... Continue clicando com o botão esquerdo!"
 command_usage: "Uso: /reanimatemc <reload|revive|knockout|status|config> [jogador]"
 no_permission: "Permissão negada."
-config_reloaded: "Configuração e idioma recarregados!"
 command_revive_usage: "Uso: /reanimatemc revive <jogador>"
 player_not_found: "Jogador não encontrado."
 player_not_ko: "O jogador não está K.O."
@@ -140,4 +139,4 @@ option_effect_resistance: "Duração resistência"
 update_available: "Nova versão disponível:"
 update_log: "Nova versão disponível: %version% -> %url%"
 update_command_available: "Atualização disponível: %version% — %url%"
-update_up_to_date: "Você está atualizado para sua versão do Minecraft."
\ No newline at end of file
+update_up_to_date: "Você está atualizado para sua versão do Minecraft."
diff --git a/src/main/resources/plugin.yml b/src/main/resources/plugin.yml
index e0d662f..ca76fcc 100644
--- a/src/main/resources/plugin.yml
+++ b/src/main/resources/plugin.yml
@@ -1,47 +1,101 @@
 name: ReanimateMC
 main: fr.jachou.reanimatemc.ReanimateMC
 version: ${project.version}
-description: A plugin that allows players to be knocked out and revived.
-api-version: 1.20
+description: A plugin that replaces instant death with a K.O. and reanimation system.
+api-version: 1.21
 authors:
   - Jachou
+softdepend:
+  - Vault
+  - PlaceholderAPI
+  - LuckPerms
 commands:
   reanimatemc:
     description: Main command for ReanimateMC
-    usage: "/<command> <reload|revive|knockout|status|crawl|config|summon|dismiss|npcs> [player]"
+    usage: "/<command> <help|reload|revive|selfrevive|knockout|status|summon|dismiss|extend|npcs|purge|kolist|version|info> [args]"
+    aliases: [rmc]
+  selfrevive:
+    description: Revive yourself while K.O.'d using items
+    usage: "/selfrevive"
+    aliases: [sr]
+  cancelselfrevive:
+    description: Cancel a self-revive in progress
+    usage: "/cancelselfrevive"
+    aliases: [cancelsr]
 
 permissions:
+
+  # ── Public (all players) ────────────────────────────────────────────────────
   reanimatemc.revive:
-    description: Allows reviving a KO’d player
+    description: Allows reviving a KO'd player
     default: true
   reanimatemc.execute:
-    description: Allows executing a KO’d player
+    description: Allows executing a KO'd player
+    default: true
+  reanimatemc.status:
+    description: Allows checking K.O. status
+    default: true
+  reanimatemc.crawl:
+    description: Allows toggling crawl mode while KO'd
     default: true
-  reanimatemc.bypass:
-    description: Bypass KO and die instantly
-    default: op
-  reanimatemc.admin:
-    description: Grants access to admin commands (reload, config, etc.)
-    default: op
-  reanimatemc.loot:
-    description: Allows looting KO’d players’ inventories
-    default: op
 
+  # ── NPC Summon (op only by default — grant explicitly via LuckPerms/permission plugin) ──
   reanimatemc.summon:
-    description: Allows summoning NPC reanimators
+    description: Base permission required for any summon command. Must be combined with a type permission.
     default: false
   reanimatemc.summon.use.golem:
-    description: Allows summoning Iron Golem reanimators
+    description: Allows summoning Iron Golem reanimators (requires reanimatemc.summon)
     default: false
   reanimatemc.summon.use.healer:
-    description: Allows summoning Healing Golem reanimators
+    description: Allows summoning Healing Golem reanimators (requires reanimatemc.summon)
     default: false
   reanimatemc.summon.use.protector:
-    description: Allows summoning Protective Golem reanimators
+    description: Allows summoning Protective Golem reanimators (requires reanimatemc.summon)
     default: false
+
+  # ── Distress signal ──────────────────────────────────────────────────────────
+  reanimatemc.distress:
+    description: Allows sending a distress signal while KO'd via command or key
+    default: true
+  reanimatemc.selfrevive:
+    description: Allows using /rmc selfrevive (alias /sr) to revive yourself while K.O.'d
+    default: true
+
+  # ── Operator ────────────────────────────────────────────────────────────────
+  reanimatemc.knockout:
+    description: Allows force-knocking out a player via command
+    default: op
+  reanimatemc.bypass:
+    description: Bypass KO and die instantly
+    default: op
+  reanimatemc.removeglow:
+    description: Allows removing the glowing effect from KO'd players
+    default: op
+  reanimatemc.config:
+    description: Allows opening the config GUI
+    default: op
+  reanimatemc.admin:
+    description: Grants access to all admin commands (reload, purge, kolist, etc.)
+    default: op
+  reanimatemc.loot:
+    description: Allows looting KO'd players' inventories
+    default: op
   reanimatemc.summon.overridecost:
     description: Bypass summon costs and cooldowns
     default: op
   reanimatemc.summon.admin:
-    description: Admin control over all NPCs
+    description: Admin control over all players' NPCs
     default: op
+
+  # ── LuckPerms lifetime overrides (assign explicitly per group/player) ───────
+  # Highest matching value wins over config default.
+  # Example: /lp group vip permission set reanimatemc.summon.lifetime.golem.600 true
+  reanimatemc.summon.lifetime.golem.600:
+    description: "Golem lifetime override: 10 minutes"
+    default: false
+  reanimatemc.summon.lifetime.healer.900:
+    description: "Healer lifetime override: 15 minutes"
+    default: false
+  reanimatemc.summon.lifetime.protector.1200:
+    description: "Protector lifetime override: 20 minutes"
+    default: false

From bb99fef01575b5aa237ded233f3cbcc2fb763029 Mon Sep 17 00:00:00 2001
From: Angel Ramirez <angel-krak@hotmail.com>
Date: Mon, 29 Jun 2026 13:55:29 -0600
Subject: [PATCH 2/3] chore: update README, docs, translations, and add
 CHANGELOG.md

---
 CHANGELOG.md                   | 423 ++++++++++++++++++
 README.md                      | 787 ++++++++++++++++-----------------
 docs/api.html                  |   2 +-
 docs/commands.html             |   2 +-
 docs/configuration.html        |   2 +-
 docs/de/api.html               |   2 +-
 docs/de/commands.html          |   2 +-
 docs/de/configuration.html     |   2 +-
 docs/de/index.html             |   2 +-
 docs/de/npc-system.html        |   2 +-
 docs/de/permissions.html       |   2 +-
 docs/es/api.html               |   2 +-
 docs/es/commands.html          |   2 +-
 docs/es/configuration.html     |   2 +-
 docs/es/index.html             |   2 +-
 docs/es/npc-system.html        |   2 +-
 docs/es/permissions.html       |   2 +-
 docs/fr/api.html               |   2 +-
 docs/fr/commands.html          |   2 +-
 docs/fr/configuration.html     |   2 +-
 docs/fr/index.html             |   2 +-
 docs/fr/npc-system.html        |   2 +-
 docs/fr/permissions.html       |   2 +-
 docs/index.html                |   2 +-
 docs/it/api.html               |   2 +-
 docs/it/commands.html          |   2 +-
 docs/it/configuration.html     |   2 +-
 docs/it/index.html             |   2 +-
 docs/it/npc-system.html        |   2 +-
 docs/it/permissions.html       |   2 +-
 docs/kr/api.html               |   2 +-
 docs/kr/commands.html          |   2 +-
 docs/kr/configuration.html     |   2 +-
 docs/kr/index.html             |   2 +-
 docs/kr/npc-system.html        |   2 +-
 docs/kr/permissions.html       |   2 +-
 docs/npc-system.html           |   2 +-
 docs/permissions.html          |   2 +-
 docs/pt/api.html               |   2 +-
 docs/pt/commands.html          |   2 +-
 docs/pt/configuration.html     |   2 +-
 docs/pt/index.html             |   2 +-
 docs/pt/npc-system.html        |   2 +-
 docs/pt/permissions.html       |   2 +-
 docs/ru/api.html               |   2 +-
 docs/ru/commands.html          |   2 +-
 docs/ru/configuration.html     |   2 +-
 docs/ru/index.html             |   2 +-
 docs/ru/npc-system.html        |   2 +-
 docs/ru/permissions.html       |   2 +-
 docs/zh/api.html               |   2 +-
 docs/zh/commands.html          |   2 +-
 docs/zh/configuration.html     |   2 +-
 docs/zh/index.html             |   2 +-
 docs/zh/npc-system.html        |   2 +-
 docs/zh/permissions.html       |   2 +-
 src/main/resources/lang/de.yml | 121 ++++-
 src/main/resources/lang/fr.yml |  90 ++++
 src/main/resources/lang/it.yml | 121 ++++-
 src/main/resources/lang/kr.yml | 108 +++++
 src/main/resources/lang/pt.yml | 120 +++++
 src/main/resources/lang/ru.yml | 106 ++++-
 src/main/resources/lang/zh.yml | 106 ++++-
 63 files changed, 1637 insertions(+), 453 deletions(-)
 create mode 100644 CHANGELOG.md

diff --git a/CHANGELOG.md b/CHANGELOG.md
new file mode 100644
index 0000000..b4644bc
--- /dev/null
+++ b/CHANGELOG.md
@@ -0,0 +1,423 @@
+# Changelog
+
+All notable changes to ReanimateMC are documented here.
+Format follows [Keep a Changelog](https://keepachangelog.com/en/1.0.0/).
+
+---
+
+## [1.2.13] — Unreleased
+
+### Bug Fixes
+
+#### Build
+
+- `plugin.yml` used `${project.version}` as a literal string because Maven resource
+  filtering was not enabled. Added `<resources><resource><filtering>true</filtering>`
+  to `pom.xml`; the JAR now shows the real version in all log messages and
+  `/rmc version` output.
+
+#### K.O. System — Movement & Input
+
+- **ArmorStand mount removed.** The previous implementation seated KO'd players
+  on an invisible `ArmorStand` to prevent movement. On Bedrock Edition, any
+  passenger relationship shows the dismount UI and maps the crouch button to
+  "dismount" rather than "crouch", which caused immediate auto-cancellation of
+  every surrender attempt and displayed a ride icon the player never requested.
+  The mount is replaced by `event.setTo()` cancellation in `PlayerMoveEvent`,
+  which blocks horizontal movement and vertical jumps server-side with no
+  client-side side-effects on either platform.
+
+- **Prone animation.** `player.setSwimming(true)` is called on KO entry
+  regardless of crawl state, so the player renders horizontal ("lying down")
+  on both Java Edition and Bedrock Edition.
+
+- **Jump blocking in crawl mode.** When `prone.allow_crawl` is enabled,
+  horizontal movement is permitted but upward velocity is cancelled unless
+  `prone.crawl_allow_jump` is set to `true` (new config key, default `false`).
+
+- **Surrender cancel while crawling.** The surrender timer was not cancelled by
+  movement when crawl mode was active because the movement handler skipped the
+  cancel check in the crawl branch. The check is now present in all three
+  movement branches (full-lock, movement-allowed, crawl).
+
+- **Surrender cancel message always shown.** The 3-second throttle previously
+  covered both the cancel message and the distress signal, so rapid triggers
+  silenced the message. The message is now sent unconditionally on every
+  cancel; only the distress signal is throttled.
+
+- **Repeated sneak-down events in crawl mode.** The swim state generated
+  repeated `PlayerToggleSneakEvent(isSneaking=true)` events while crawling,
+  restarting the surrender timer repeatedly. The handler now ignores sneak-down
+  events when a surrender task is already running.
+
+- **Bedrock surrender cancel.** On Bedrock, `sneak-up` does not fire while
+  the player is in swim-crawl pose because the crouch button is also the
+  "stop crawling" input. Three additional cancel triggers were added:
+    - `PlayerDropItemEvent` (Q / drop button) — primary Bedrock cancel method;
+      always fires reliably via Geyser and is the most natural action for a
+      downed Bedrock player.
+    - `PlayerInteractEvent(RIGHT_CLICK_AIR)` with empty main hand — tap on empty
+      space.
+    - `PlayerAnimationEvent(ARM_SWING)` — any tap gesture; does not send
+      a distress signal to avoid noise.
+
+#### K.O. System — Mob Targeting
+
+- `KOProtectionListener.onEntityTarget` prevented mobs from retargeting a KO'd
+  player but did not stop mobs that already had the player targeted before
+  they went down. Added `EntityDamageByEntityEvent` handler that cancels
+  melee damage from any `Mob` and projectile damage where the shooter is a
+  `Mob`, then clears the mob's target in both cases.
+
+#### NPC System
+
+- **PROTECTOR immortal at 0 HP.** `applyTransferredDamage` floored health at
+  0.5 using `Math.max(0.5, hp - absorbed)`. Changed to `entity.damage(absorbed)`
+  so Bukkit processes the death event normally and `NPCDamageListener` handles
+  cleanup.
+
+- **Self-damage when stuck.** Iron Golems deal ENTITY_ATTACK damage to
+  themselves when pathfinding traps them against a wall. `NPCDamageListener`
+  now cancels any `EntityDamageByEntityEvent` where the damager UUID matches
+  the victim (the golem hitting itself) and cancels friendly-fire between
+  allied golems.
+
+- **`ConcurrentModificationException` in behavior task.** The scheduler task
+  iterated `activeNPCs.entrySet()` directly while `removeNPC()` mutated the
+  map. Replaced with a snapshot copy before the loop; expired entries are
+  collected in a separate list and removed after iteration completes.
+
+- **`IllegalArgumentException: x not finite` in `ProtectorBehavior`.** The
+  knockback burst called `normalize()` on a zero-length vector when an entity
+  occupied the exact same XZ position as the golem. A guard now skips any
+  entity where both X and Z delta are zero.
+
+- **PROTECTOR reviving owner.** `updateBehavior()` applied the owner-KO revive
+  path to all NPC types unconditionally. Added `canReviveOwner()` to
+  `NPCBehavior`; PROTECTOR returns `false`. The path is now gated behind this
+  check and also behind a live check for an active HEALER NPC when
+  `protector.revive_if_no_healer` is enabled.
+
+- **NPC persistence ignoring elapsed offline time.** `NPCPersistenceManager`
+  saved remaining seconds at shutdown time, then restored that same value
+  on startup regardless of how long the server was down. Changed to save
+  absolute expiry timestamps (epoch ms). On load, entries whose timestamp
+  has already passed are discarded; survivors have their remaining seconds
+  computed from the delta between the timestamp and `System.currentTimeMillis()`.
+
+- **HEALER heal timer unreliable.** Heal interval was checked against the raw
+  `behaviorTick` counter (increments every second). If the interval was not
+  a multiple of the idle-tick cadence (3 s), the heal could be skipped
+  indefinitely. Fixed with a dedicated `idleTick` counter incremented only
+  inside `onIdleTick()`.
+
+- **HEALER particles invisible at full HP.** Particles were gated behind
+  `health < max`. Particles now always spawn on each heal tick so players
+  can see the aura range.
+
+- **`EntityKnockbackEvent` wrong package.** Used Bukkit's deprecated
+  `org.bukkit.event.entity.EntityKnockbackEvent` which has no `setKnockback()`.
+  Changed to `io.papermc.paper.event.entity.EntityKnockbackEvent`.
+
+- **`PlayerJumpEvent` does not exist in Paper 1.21.4.** Handler removed;
+  Y-velocity check in `PlayerMoveEvent` covers both Java and Bedrock jump
+  detection.
+
+- **`api-version: 1.20` rejected by Paper 1.21+.** Corrected to `1.21`.
+
+- **`GolemManager` random type and wrong summon target.** Shift-click on a
+  natural Iron Golem picked a random type and passed the owner as the revive
+  target (which was never KO'd). Now resolves the highest-tier type the
+  player is permitted and passes `null` as the explicit target.
+
+- **Permission namespace typo** `reanimate.summon` → `reanimatemc.summon`
+  throughout `NPCSummonManager` and `ReanimateMCCommand`.
+
+- **Duplicate `ReanimateMCCommand` instance.** `setExecutor` and
+  `setTabCompleter` each constructed a new instance. A single shared instance
+  is now registered for both.
+
+- **Config new keys not merged into existing files.** Added
+  `copyDefaults(true)` + `saveConfig()` on startup and `/rmc reload`.
+
+- **Lang new keys not merged into existing translations.** `Lang.java`
+  rewritten to use `setDefaults` + `copyDefaults(true)`; falls back to `en`
+  for any missing key; never overwrites existing translations.
+
+- **Duplicate `config_reloaded` key** in `kr.yml` and `pt.yml`. First
+  duplicate removed.
+
+- **Paper 1.21.4 particle renames.**
+  `VILLAGER_HAPPY` → `HAPPY_VILLAGER`,
+  `SMOKE_LARGE` → `LARGE_SMOKE`,
+  `EXPLOSION_LARGE` → `EXPLOSION_EMITTER`.
+
+- **`reanimatemc.config` and `reanimatemc.removeglow` missing from
+  `plugin.yml`.** Both nodes added.
+
+#### Commands
+
+- **`removeGlowingEffect` command not found.** The switch case matched
+  `removeglowingreffect` (double `r`) but the tab-complete list contained
+  `removeGlowingEffect`, so the command was never routed correctly.
+  All three variants now match in both the switch and the tab-complete list.
+
+- **`/selfrevive` reported as unknown command.** The subcommand was handled
+  inside the `reanimatemc` switch but not registered as a standalone command
+  in `plugin.yml`. Added `selfrevive` and `cancelselfrevive` as first-class
+  commands with `sr` / `cancelsr` aliases; both are registered in
+  `ReanimateMC.java` with the shared `commandHandler`.
+
+### Added
+
+#### NPC Reanimator System
+
+A full autonomous NPC system built on Iron Golems. Three types share a common
+`NPCBehavior` strategy interface so each type is fully isolated.
+
+##### GOLEM — Standard Reanimator
+
+Follows owner, revives on K.O., defends from any attacker (not limited to
+`instanceof Monster`).
+
+Default HP: 80. Default revive time: ~5 s (100 ticks).
+
+##### HEALER — Support Reanimator
+
+All GOLEM capabilities plus: auto-scans for nearby K.O.'d allies within
+`scan_radius` and rushes to the nearest one without manual assignment.
+Periodic HP restoration every `periodic_heal_interval` seconds to the owner,
+nearby allies, itself (`heal_self`), and allied golems (`heal_golems`).
+Circular HEART + HAPPY_VILLAGER particle aura on each heal tick (configurable
+radius and toggle). Regeneration potion when owner HP drops below
+`aura_hp_threshold`. Bonus HP granted on revive.
+
+Default HP: 120. Default revive time: ~3 s (60 ticks — fastest).
+
+##### PROTECTOR — Tank Reanimator
+
+Does not revive or heal. Intercepts 75% of every hit the owner takes
+(`damage_transfer_ratio`, configurable) and applies that damage to the
+golem's own HP via `entity.damage()`. Attacks any `LivingEntity` threatening
+the owner; allied Iron Golems are excluded from targeting. When the owner
+falls K.O., sends a forced distress signal on their behalf and notifies them
+once per session that the PROTECTOR cannot revive. Optionally revives the
+owner when no HEALER is active (`revive_if_no_healer`, default `true`).
+
+Default HP: 200. Default revive time when fallback-reviving: ~8 s (160 ticks).
+
+##### Shared NPC Features
+
+- All HP values configurable per type via `npc_summon.<type>.max_hp`.
+- Per-type summon cost (`summon_cost`) deducted via Vault on summon.
+- Per-type cooldown and lifetime.
+- LuckPerms lifetime overrides via `reanimatemc.summon.lifetime.<type>.<seconds>`.
+- Timed revive with live action-bar progress bar (10-segment, percentage) shown
+  to both the KO'd player and the NPC owner.
+- Nameplate shows owner name: `✦ Healing Golem [PlayerName] | ❤ 87 | ⏱ 8m32s`.
+  Color shifts green → yellow → red by HP percentage.
+- Stuck detection: if the NPC does not move more than 0.5 blocks in
+  `stuck_ticks_threshold` ticks while following, it teleports next to the owner
+  with PORTAL particles.
+- Persistence across restarts via `NPCPersistenceManager` using absolute expiry
+  timestamps.
+- `/rmc summon <type> [player]` — when `[player]` is specified the NPC belongs
+  to that player; the summoner pays the cost and cooldown.
+- `/rmc summon team <type> <p1> <p2> ...` — summons one NPC per team member;
+  total cost = `summon_cost * team.size()`.
+- `/rmc dismiss <all|golem|healer|protector>` — dismiss by type or all at once.
+- `/rmc npcs` — per-NPC action-bar status with HP bar, countdown, and target name.
+- `/rmc extend <seconds>` — extend lifetime; charges Vault economy cost.
+
+#### Self-Revive System (`/rmc selfrevive`, alias `/sr`)
+
+KO'd players can revive themselves at the cost of items and a longer channel
+time. Every aspect is configurable:
+
+- `require_items` — whether items are consumed (default `true`).
+- `required_items` — list of `{material, amount}` entries; all must be present.
+  Default: 2× Golden Apple.
+- `duration_ticks` — channel time (default 200, ~10 s).
+- `health_restored` — HP after self-revive (default 2).
+- `cooldown_seconds` — per-player cooldown (default 120).
+- `max_uses_per_ko` — limit per KO session, 0 = unlimited (default 1).
+- `cancel_on_move` / `cancel_on_damage` — interrupt on movement or incoming hit.
+- `combat_block_seconds` — block use if last damage was within this window.
+- `effects_on_selfrevive` — separate post-revive effect set, harsher than
+  teammate revive defaults.
+
+`/rmc cancelselfrevive` (alias `/cancelsr`) cancels an active channel.
+
+#### Distress Signal Rework
+
+Four independent triggers, all respecting the same per-player cooldown and
+`reanimatemc.distress` permission:
+
+| Trigger | Platform | Config key |
+|---|---|---|
+| F (swap hands) | Java Edition | always active |
+| Q / drop button | Java + Bedrock mobile | `knockout.distress.drop_key_trigger` |
+| Double-tap sneak | Bedrock + Java | `knockout.distress.bedrock_doubletap_ms` |
+| `/rmc distress` | All | `knockout.allowed_commands` (pre-added) |
+
+When the player cancels a surrender by releasing the crouch button, a distress
+signal is automatically sent on their behalf, so teammates are notified whenever
+someone chooses to fight on.
+
+The PROTECTOR NPC sends a forced distress signal (bypassing the player cooldown)
+the first time the owner falls K.O. per session.
+
+#### Command Improvements
+
+`/rmc` with no arguments now shows a structured status panel:
+
+```
+━━━━━━━━━ ReanimateMC ━━━━━━━━━
+  Version  v1.2.13  |  API 1.21.4  |  Author Jachou
+  Language en
+ ─── Systems ───────────────────
+  K.O. System          ✔
+  Execution System      ✔
+  Crawl / Prone         ✔
+  Distress Signal       ✔
+  Self-Revive           ✔
+  NPC Reanimators       ✔
+ ─── Integrations ──────────────
+  Vault Economy         ✘
+  PlaceholderAPI        ✔
+ ─── Live Status ───────────────
+  Players currently K.O.: 0
+  Type /rmc help for all commands
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+```
+
+`/rmc help` reads all descriptions from the active language file; no English
+is hardcoded. `/rmc version` shows plugin version, author, Minecraft version,
+and API target.
+
+#### New Permissions
+
+| Permission | Default | Purpose |
+|---|---|---|
+| `reanimatemc.summon` | false | Base summon permission |
+| `reanimatemc.summon.use.golem` | false | GOLEM type (requires base) |
+| `reanimatemc.summon.use.healer` | false | HEALER type (requires base) |
+| `reanimatemc.summon.use.protector` | false | PROTECTOR type (requires base) |
+| `reanimatemc.distress` | true | Distress signal |
+| `reanimatemc.selfrevive` | true | Self-revive |
+| `reanimatemc.summon.overridecost` | op | Bypass cooldowns and economy costs |
+| `reanimatemc.summon.admin` | op | Manage other players' NPCs |
+
+#### PlaceholderAPI Integration
+
+New expansion prefix `%reanimatemc_*%`:
+
+- `%reanimatemc_is_ko%`
+- `%reanimatemc_ko_time_remaining%`
+- `%reanimatemc_npc_count%`
+- `%reanimatemc_npc_type%`
+- `%reanimatemc_npc_time_remaining%`
+- `%reanimatemc_npc_hp%`
+
+#### ConfigGUI Additions
+
+- Three new K.O. toggles: Mobs Attack KO, Disable Knockback on KO,
+  Must Be Still to Surrender.
+- New `DOUBLE` option type (Comparator icon, left-click −0.05 / shift-click +0.05).
+- New entries: Crawl Nausea Effect, Crawl Nausea Level, NPC System on/off,
+  NPC Invulnerable Mode, Protector Damage Transfer ratio,
+  Protector Revives (No Healer).
+
+#### New Configuration Keys
+
+All keys ship with documented inline comments in `config.yml`. A QUICK
+REFERENCE block at the top of the file explains effect levels, duration
+fields, and the distress subsection.
+
+Highlights:
+
+```yaml
+knockout:
+  crawl_nausea_enabled: true
+  crawl_nausea_level: 1
+
+  distress:
+    enabled: true
+    cooldown_seconds: 15
+    drop_key_trigger: true
+    bedrock_doubletap_ms: 400
+
+prone:
+  crawl_allow_jump: false
+
+self_revive:
+  enabled: true
+  require_items: true
+  required_items:
+    - material: GOLDEN_APPLE
+      amount: 2
+  duration_ticks: 200
+  health_restored: 2
+  cooldown_seconds: 120
+  max_uses_per_ko: 1
+  cancel_on_move: true
+  cancel_on_damage: true
+  combat_block_seconds: 0
+  effects_on_selfrevive:
+    nausea: 10
+    slowness: 15
+    resistance: 5
+
+npc_summon:
+  golem:
+    max_hp: 80
+    revive_duration_ticks: 100
+    combat_radius: 12.0
+    summon_cost: 0.0
+  healer:
+    max_hp: 120
+    revive_duration_ticks: 60
+    heal_self: true
+    heal_golems: true
+    aura_particle_enabled: true
+    aura_particle_radius: 3
+  protector:
+    max_hp: 200
+    revive_duration_ticks: 160
+    damage_transfer_ratio: 0.75
+    revive_if_no_healer: true
+```
+
+#### New Files
+
+| File | Description |
+|---|---|
+| `behavior/NPCBehavior.java` | Strategy interface: `onIdleTick`, `onSpawn`, `onRevive`, `canRevive`, `canReviveOwner` |
+| `behavior/GolemBehavior.java` | GOLEM implementation |
+| `behavior/HealerBehavior.java` | HEALER implementation |
+| `behavior/ProtectorBehavior.java` | PROTECTOR implementation |
+| `api/NPCSummonedEvent.java` | Cancellable summon event |
+| `api/NPCDismissedEvent.java` | Dismissal event with `Reason` enum |
+| `hooks/VaultHook.java` | Vault economy wrapper |
+| `hooks/PlaceholderHook.java` | PlaceholderAPI expansion |
+| `listeners/KOProtectionListener.java` | Knockback zeroing + mob targeting + projectile protection |
+| `listeners/NPCDamageListener.java` | NPC self-damage prevention, low-HP alerts, death cleanup |
+| `managers/NPCPersistenceManager.java` | YAML persistence with absolute expiry timestamps |
+| `data/ReanimatorNPC.java` | NPC state record (LICENSE header) |
+| `managers/NPCSummonManager.java` | NPC orchestration (LICENSE header) |
+| `CLAUDE.md` | Development context document |
+
+### Language Files
+
+`en.yml` and `es.yml` have full translations for all new keys.
+`de.yml`, `fr.yml`, `it.yml`, `ru.yml`, `zh.yml`, `kr.yml`, and `pt.yml`
+have been updated with English fallback strings marked
+`# EN — awaiting translation`. The plugin's `Lang.java` `copyDefaults(true)`
+mechanism ensures existing translations are never overwritten.
+
+---
+
+## [1.2.10] — Previous Release
+
+See the [GitHub releases page](https://github.com/MatisseAD/ReanimateMC/releases)
+for earlier versions.
diff --git a/README.md b/README.md
index 184ae70..c017d7c 100644
--- a/README.md
+++ b/README.md
@@ -1,530 +1,527 @@
 # ReanimateMC
 
-New wiki page : https://matissead.github.io/ReanimateMC/
+New wiki page: https://matissead.github.io/ReanimateMC/
 
-![Version](https://img.shields.io/badge/version-Release_1.2.10-green.svg)
-![Minecraft](https://img.shields.io/badge/Minecraft-1.20.1+-blue.svg)
-![Spigot](https://img.shields.io/badge/Spigot-Compatible-orange.svg)
+![Version](https://img.shields.io/badge/version-1.2.13-green.svg)
+![Minecraft](https://img.shields.io/badge/Minecraft-1.21.4+-blue.svg)
+![Paper](https://img.shields.io/badge/Paper-Required-orange.svg)
 
 ![ReanimateMC Cover](https://i.postimg.cc/3RHh8WJy/reanimate-mc-cover.jpg)
 
 ## Table of Contents
 - [Overview](#overview)
-- [Features](#features)
+- [Requirements](#requirements)
 - [Installation](#installation)
 - [Quick Start](#quick-start)
 - [Configuration](#configuration)
 - [Commands](#commands)
 - [Permissions](#permissions)
-- [Gameplay Mechanics](#gameplay-mechanics)
+- [K.O. System](#ko-system)
+- [NPC Reanimator System](#npc-reanimator-system)
+- [Self-Revive System](#self-revive-system)
+- [Distress Signal](#distress-signal)
 - [API for Developers](#api-for-developers)
 - [Language Support](#language-support)
 - [Compatibility](#compatibility)
 - [Troubleshooting](#troubleshooting)
 - [Contributing](#contributing)
 
+---
+
 ## Overview
 
-ReanimateMC is a revolutionary Minecraft plugin that transforms the conventional death system by introducing a **KO (Knockout) state**. Instead of players dying instantly when their health reaches zero, they enter an intermediary knockout state where they can be revived by teammates or executed by enemies.
+ReanimateMC replaces instant death with a K.O. (Knockout) state. When a player's
+health reaches zero they enter a downed state where teammates can revive them,
+enemies can execute them, or a timer forces death. Version 1.2.13 adds a full
+NPC Reanimator System, a configurable self-revive mechanic, and reworks the
+distress signal for both Java Edition and Bedrock mobile.
 
-This innovative mechanic creates dynamic gameplay opportunities perfect for:
-- **Hardcore Survival servers** - Adding tension and teamwork
-- **Role-play servers** - Creating dramatic rescue scenarios  
-- **PvP servers** - Strategic decisions between mercy and execution
-- **Adventure maps** - Enhanced cooperative gameplay
+---
 
-![Cover help](https://i.postimg.cc/WzLwfL8c/Chat-GPT-Image-12-avr-2025-18-34-14.png)
+## Requirements
 
-## Features
+- **Server:** Paper 1.21.4 or higher (Paper required for NPC pathfinder API and `EntityKnockbackEvent`)
+- **Java:** 17 or higher
+- **Optional:** Vault + economy plugin, PlaceholderAPI, LuckPerms
 
-### Core Mechanics
-- **KO State System** - Players enter knockout instead of dying instantly
-- **Revival System** - Teammates can revive KO'd players with configurable items
-- **Execution System** - Option to permanently eliminate KO'd players
-- **Persistent KO** - KO state maintained across disconnections
-- **Distress Signals** - KO'd players can call for help with beacons
+---
 
-### Gameplay Features
-- **Crawling Mode** - KO'd players can toggle between immobilized and slow crawling
-- **Visual Effects** - Particles, blindness, and glowing effects during KO
-- **Audio Feedback** - Heartbeat sounds and audio cues
-- **Tab List Integration** - Visual KO indicators in player list
-- **Inventory Protection** - Configurable looting system for KO'd players
+## Installation
 
-### Advanced Features
-- **Offline KO Timer** - Countdown continues even when players disconnect
-- **Suicide Prevention** - Configurable hold-to-suicide mechanics
-- **Weakness Effects** - Debuffs applied during KO state
-- **GUI Configuration** - In-game configuration interface
-- **Statistics Tracking** - KO and revival statistics
-- **Multi-language Support** - 10+ language translations
+1. Drop `ReanimateMC.jar` into `plugins/`.
+2. Restart the server.
+3. Edit `plugins/ReanimateMC/config.yml` or use `/rmc config` to open the GUI.
 
-## Installation
+---
 
-### Requirements
-- **Minecraft Server**: 1.20.1 or higher
-- **Server Software**: Spigot, Paper, Bukkit, or compatible forks
-- **Java**: 16 or higher
+## Quick Start
 
-### Installation Steps
+```
+/rmc config               open the in-game configuration GUI
+/rmc reload               reload config and lang files without restart
+/rmc help                 list all commands in the active language
+/rmc summon golem         summon a GOLEM reanimator for yourself
+/rmc summon healer        summon a HEALER reanimator for yourself
+/rmc summon protector     summon a PROTECTOR reanimator for yourself
+/rmc selfrevive           revive yourself while K.O.'d (uses items)
+```
 
-1. **Download** the latest ReanimateMC.jar from the [releases page](https://github.com/MatisseAD/ReanimateMC/releases)
+---
 
-2. **Upload** the JAR file to your server's `plugins/` directory
+## Configuration
 
-3. **Restart** your server (or use a plugin manager to load it)
+All settings live in `plugins/ReanimateMC/config.yml`. A `QUICK REFERENCE`
+block at the top of the file explains effect levels, duration fields, and the
+distress subsection. New keys are automatically merged into existing files on
+startup and `/rmc reload`; your existing values are never overwritten.
 
-4. **Configure** the plugin using the command `/reanimatemc config` or by editing the generated config files
+### Key Sections
 
-### First Setup
+| Section | What it controls |
+|---|---|
+| `language` | Active lang file (`en`, `es`, `de`, `fr`, `it`, `nl`, `ru`, `zh`, `kr`, `pl`, `pt`) |
+| `reanimation` | Item requirement, hold duration, HP restored, cooldown |
+| `knockout` | Duration, movement lock, effects, surrender, mobs, distress |
+| `execution` | Toggle, hold duration, broadcast |
+| `effects_on_revive` | Temporary effects applied after revival (seconds) |
+| `prone` | Crawl toggle, slowness level, auto-crawl, jump blocking |
+| `self_revive` | Item list, channel time, cooldown, cancel conditions |
+| `npc_summon` | Per-type HP, lifetime, cooldown, cost, heal amounts, revive speed |
 
-When you first install the plugin:
+---
 
-1. Operators will receive a setup message on join
-2. Use `/reanimatemc config` to open the GUI configuration
-3. Adjust settings to match your server's gameplay style
-4. Use `/reanimatemc setup` to mark setup as complete
+## Commands
 
-## Quick Start
+All commands run via `/rmc` or `/reanimatemc`.
 
-### Basic Usage
+### Player Commands
 
-1. **When a player's health reaches 0**, they enter KO state instead of dying
-2. **To revive**: Crouch near a KO'd player and hold the required item (default: Golden Apple)
-3. **To execute**: Left-click and hold on a KO'd player
-4. **Distress signal**: KO'd players can press F (swap hands) to send a help signal
+| Command | Permission | Description |
+|---|---|---|
+| `/rmc help` | — | List all commands in the active language |
+| `/rmc status <player>` | `reanimatemc.status` | Check K.O. state |
+| `/rmc crawl` | `reanimatemc.crawl` | Toggle crawl while K.O.'d |
+| `/rmc distress` | `reanimatemc.distress` | Send a distress signal while K.O.'d |
+| `/rmc selfrevive` | `reanimatemc.selfrevive` | Revive yourself using items |
+| `/rmc cancelselfrevive` | `reanimatemc.selfrevive` | Cancel an active self-revive channel |
+| `/rmc revive <player>` | `reanimatemc.revive` | Start a timed revive via your active HEALER NPC |
+| `/rmc summon <type> [player]` | `reanimatemc.summon.use.<type>` | Summon a Reanimator NPC |
+| `/rmc summon team <type> <p1> <p2>...` | `reanimatemc.summon.use.<type>` | Summon one NPC per team member |
+| `/rmc dismiss <all\|golem\|healer\|protector>` | `reanimatemc.summon` | Dismiss NPC(s) |
+| `/rmc extend <seconds>` | `reanimatemc.summon` | Extend active NPC lifetime |
+| `/rmc npcs` | `reanimatemc.summon` | Show HP, countdown, and target for active NPCs |
+
+Aliases: `/sr` = `/rmc selfrevive`, `/cancelsr` = `/rmc cancelselfrevive`.
+
+### Admin Commands
 
-### Essential Commands
+| Command | Permission | Description |
+|---|---|---|
+| `/rmc reload` | `reanimatemc.admin` | Reload config and lang |
+| `/rmc knockout <player>` | `reanimatemc.knockout` | Force K.O. |
+| `/rmc kolist` | `reanimatemc.admin` | List K.O.'d players with time remaining |
+| `/rmc purge` | `reanimatemc.admin` | Remove stale K.O. holograms from all worlds |
+| `/rmc info` | `reanimatemc.admin` | Show plugin status and integration state |
+| `/rmc version` | `reanimatemc.admin` | Show plugin version |
+| `/rmc config` | `reanimatemc.config` | Open configuration GUI |
+| `/rmc removeGlowingEffect <player>` | `reanimatemc.removeglow` | Remove glow from a player |
 
-```
-/reanimatemc config     # Open configuration GUI
-/reanimatemc reload     # Reload plugin configuration
-/reanimatemc status <player>  # Check player's KO status
-```
+---
 
-## Configuration
+## Permissions
 
-The plugin creates several configuration files in `plugins/ReanimateMC/`:
+### Core
 
-### Main Configuration (`config.yml`)
+| Permission | Default | Description |
+|---|---|---|
+| `reanimatemc.revive` | true | Revive K.O.'d players |
+| `reanimatemc.execute` | true | Execute K.O.'d players |
+| `reanimatemc.status` | true | Check K.O. status |
+| `reanimatemc.crawl` | true | Toggle crawl while K.O.'d |
+| `reanimatemc.distress` | true | Send distress signals |
+| `reanimatemc.selfrevive` | true | Self-revive while K.O.'d |
+| `reanimatemc.bypass` | op | Die instantly, bypass K.O. |
+| `reanimatemc.knockout` | op | Force K.O. via command |
+| `reanimatemc.admin` | op | All admin commands |
+
+### NPC Summon
+
+`reanimatemc.summon` and all `summon.use.*` nodes default to `false`. Grant
+explicitly via a permission plugin. OPs always have access.
+
+| Permission | Default |
+|---|---|
+| `reanimatemc.summon` | false |
+| `reanimatemc.summon.use.golem` | false |
+| `reanimatemc.summon.use.healer` | false |
+| `reanimatemc.summon.use.protector` | false |
+| `reanimatemc.summon.overridecost` | op |
+| `reanimatemc.summon.admin` | op |
+
+**Recommended tier setup:**
 
 ```yaml
-# Language settings
-language: "en"
-first_run: true
-setup_completed: false
-
-# Revival system
-reanimation:
-  require_special_item: true
-  required_item: GOLDEN_APPLE
-  duration_ticks: 100        # Time to revive (5 seconds)
-  health_restored: 4         # Hearts restored after revival
-  cooldown: 60              # Cooldown between revivals
-  revive_cooldown: 60       # Personal revive cooldown
-
-# KO system settings
-knockout:
-  enabled: true
-  duration_seconds: 30      # How long KO lasts
-  movement_disabled: true   # Disable movement during KO
-  use_particles: true       # Show particles around KO'd players
-  heartbeat_sound: true     # Play heartbeat sound
-  blindness: true          # Apply blindness effect
-  suicide_hold_seconds: 3   # Hold time to suicide
-  weakness_level: 1        # Weakness effect level
-  fatigue_level: 1         # Mining fatigue level
-
-# Execution system
-execution:
-  enabled: true
-  hold_duration_ticks: 40   # Hold time to execute (2 seconds)
-  message_broadcast: true   # Announce executions
+# VIP
+reanimatemc.summon: true
+reanimatemc.summon.use.golem: true
+
+# Premium
+reanimatemc.summon: true
+reanimatemc.summon.use.golem: true
+reanimatemc.summon.use.healer: true
+
+# Elite
+reanimatemc.summon: true
+reanimatemc.summon.use.golem: true
+reanimatemc.summon.use.healer: true
+reanimatemc.summon.use.protector: true
+```
 
-# Effects applied after revival
-effects_on_revive:
-  nausea: 5                # Nausea duration (seconds)
-  slowness: 10             # Slowness duration (seconds)
-  resistance: 10           # Resistance duration (seconds)
+**LuckPerms lifetime overrides** — grant
+`reanimatemc.summon.lifetime.<type>.<seconds>` to override NPC lifetime per group.
+The highest value across all of a player's permissions wins.
 
-# Crawling/prone mechanics
-prone:
-  enabled: true
-  allow_crawl: true        # Allow crawling movement
-  crawl_slowness_level: 5  # Slowness level when crawling
-  auto_crawl: false        # Auto-enable crawling
+---
 
-# Inventory looting
-looting:
-  enabled: true
+## K.O. System
 
-# Tab list integration
-tablist:
-  enabled: true            # Show [KO] tag in tab list
-```
+When a player's health reaches zero:
 
-### GUI Configuration
+1. Player enters K.O. state; health is set to 1.
+2. Player renders horizontal (prone animation) on both Java and Bedrock.
+3. Movement and jumping are blocked server-side (`movement_disabled: true`).
+4. Countdown begins (`knockout.duration_seconds`).
+5. Player can be revived, execute themselves (surrender), or die when the timer expires.
 
-Use `/reanimatemc config` to access an intuitive GUI for configuring all settings:
+### Revival
 
-- **Categories**: Settings organized by function
-- **Live Preview**: See changes immediately
-- **Easy Toggles**: Click to enable/disable features
-- **Value Editing**: Click to modify numeric values
-- **Material Selection**: Easy item selection interface
+A player reviving a teammate must crouch near them while holding the required
+item (`reanimation.required_item`). A progress bar appears in the action bar.
+Items are consumed on success. Post-revival effects (`effects_on_revive`) apply.
 
-## Commands
+When using `/rmc revive <player>`:
 
-### Administrative Commands
+- The caller must have an active HEALER NPC.
+- The HEALER teleports to the target before the channel begins.
+- If `reanimation.require_special_item` is enabled, the caller must hold the item.
+- The target receives a notification naming the reviver.
 
-| Command | Permission | Description |
-|---------|------------|-------------|
-| `/reanimatemc reload` | `reanimatemc.admin` | Reload configuration and language files |
-| `/reanimatemc config` | `reanimatemc.admin` | Open GUI configuration interface |
-| `/reanimatemc setup` | `reanimatemc.admin` | Mark initial setup as complete |
+### Surrender
 
-### Player Management Commands
+Hold crouch for `knockout.suicide_hold_seconds` (default 3) to surrender.
+Any movement cancels the timer if `surrender_require_still` is enabled.
 
-| Command | Permission | Description |
-|---------|------------|-------------|
-| `/reanimatemc revive <player>` | `reanimatemc.revive` | Forcefully revive a KO'd player |
-| `/reanimatemc knockout <player>` | `reanimatemc.knockout` | Force a player into KO state |
-| `/reanimatemc status <player>` | `reanimatemc.status` | Check a player's current state |
-| `/reanimatemc crawl` | `reanimatemc.crawl` | Toggle crawling mode (KO'd players only) |
+To cancel on Bedrock (where sneak-up may not fire in prone state):
+- Press Q (drop button) — primary method
+- Tap empty space (RIGHT_CLICK_AIR with empty hand)
+- Any arm-swing gesture
 
-### Utility Commands
+Cancelling a surrender automatically sends a distress signal once.
 
-| Command | Permission | Description |
-|---------|------------|-------------|
-| `/reanimatemc removeGlowingEffect <player>` | `reanimatemc.removeGlowingEffect` | Remove glowing effect from a player |
+### Crawl Mode
 
-## Permissions
+Toggle with `/rmc crawl`. Allows slow horizontal movement while K.O.'d.
+Configurable slowness level (`prone.crawl_slowness_level`). Jump blocking
+is separate (`prone.crawl_allow_jump`, default `false`). Nausea applies only
+while crawl is active (`knockout.crawl_nausea_enabled`).
 
-### Core Permissions
+### Mob Protection
 
-| Permission | Default | Description |
-|------------|---------|-------------|
-| `reanimatemc.admin` | `op` | Access to all administrative commands and GUI config |
-| `reanimatemc.revive` | `true` | Ability to revive KO'd players |
-| `reanimatemc.execute` | `true` | Ability to execute KO'd players |
-| `reanimatemc.bypass` | `op` | Bypass KO system (die instantly) |
+When `knockout.mobs_attack_ko: false`, mobs cannot:
 
-### Feature Permissions
+- Select a K.O.'d player as a new target (`EntityTargetEvent`).
+- Deal melee damage to a K.O.'d player.
+- Hit a K.O.'d player with a projectile.
 
-| Permission | Default | Description |
-|------------|---------|-------------|
-| `reanimatemc.knockout` | `op` | Force players into KO state |
-| `reanimatemc.status` | `true` | Check player KO status |
-| `reanimatemc.crawl` | `true` | Toggle crawling mode when KO'd |
-| `reanimatemc.loot` | `op` | Access KO'd player inventories |
-| `reanimatemc.removeGlowingEffect` | `op` | Remove glowing effects |
+Mobs that were already targeting the player before K.O. have their target cleared.
 
-### Permission Groups
+---
+
+## NPC Reanimator System
+
+### Summoning
 
-```yaml
-# Example permission setup for different server roles
-
-# Regular Players
-- reanimatemc.revive
-- reanimatemc.execute
-- reanimatemc.status
-- reanimatemc.crawl
-
-# Moderators (add to above)
-- reanimatemc.knockout
-- reanimatemc.loot
-- reanimatemc.removeGlowingEffect
-
-# Administrators (add to above)
-- reanimatemc.admin
-- reanimatemc.bypass
+```
+/rmc summon golem [player]
+/rmc summon healer [player]
+/rmc summon protector
+/rmc summon team <type> <p1> <p2> ...
 ```
 
-## Gameplay Mechanics
+When `[player]` is specified the NPC belongs to that player; the summoner pays
+the cost and cooldown. Team summon charges `summon_cost * team_size` via Vault.
+
+### Type Comparison
+
+| Feature | GOLEM | HEALER | PROTECTOR |
+|---|:---:|:---:|:---:|
+| Default HP | 80 | 120 | 200 |
+| Revives owner when K.O. | Yes | Yes | When no HEALER active |
+| Revives explicit target | Yes | Yes | No |
+| Auto-revives nearby K.O. allies | No | Yes | No |
+| Heals owner / allies | No | Yes | No |
+| Heals self / allied golems | No | Configurable | No |
+| Circular heal aura particles | No | Yes | No |
+| Defends owner (any attacker type) | Yes | No | Yes |
+| Absorbs owner damage | No | No | 75% (configurable) |
+| Sends distress on owner K.O. | No | No | Yes |
+| Default revive time | ~5 s | ~3 s | ~8 s |
+| Default summon cooldown | 5 min | 5 min | 1 min |
+
+All HP values are configurable via `npc_summon.<type>.max_hp`.
+All revive durations are configurable via `npc_summon.<type>.revive_duration_ticks`.
+
+### GOLEM — Standard Reanimator
+
+Follows the owner, revives them when K.O.'d, and defends against attackers.
+Targets whoever last dealt damage to the owner (any entity type) and falls back
+to the nearest hostile mob within `combat_radius`.
+
+### HEALER — Support Reanimator
+
+All GOLEM capabilities plus:
+
+- Scans `scan_radius` blocks for any K.O.'d ally and rushes to the nearest one
+  without manual assignment.
+- Heals HP every `periodic_heal_interval` seconds to the owner, nearby allies,
+  itself (`heal_self`), and allied Iron Golems (`heal_golems`). All amounts and
+  ranges are configurable.
+- Circular HEART + HAPPY_VILLAGER particle aura on every heal tick, always
+  visible regardless of current HP so players can see the range.
+- Applies Regeneration when the owner HP drops below `aura_hp_threshold`.
+- Grants bonus HP to the revived player (`bonus_hp_on_revive`).
+- The HEALER does not leave the owner more than `max_leash_distance` blocks away
+  even when chasing a K.O.'d ally.
+
+### PROTECTOR — Tank Reanimator
+
+- Cannot revive or heal anyone except as a fallback when no HEALER is active
+  (`revive_if_no_healer: true`).
+- Intercepts `damage_transfer_ratio` (default 75%) of every hit the owner takes
+  and applies it to the golem via `entity.damage()`. CRIT particles fire on impact.
+- Attacks any `LivingEntity` threatening the owner. Allied Iron Golems are
+  excluded from targeting.
+- When the owner falls K.O., sends a forced distress signal and notifies the
+  owner once per K.O. session that it cannot revive them.
+- Dies normally at 0 HP; record is cleaned up by `NPCDamageListener`.
+
+### Revive Progress Bar
 
-### The KO System
+```
+Healing Golem reviving...  ██████░░░░  65%    <- shown to K.O.'d player
+Reviving PlayerName...     ██████░░░░  65%    <- shown to NPC owner
+```
 
-When a player's health reaches zero:
+### Nameplate Format
 
-1. **KO Trigger**: Player enters knockout state instead of dying
-2. **Visual Effects**: Player lies down, optional particles and blindness
-3. **Movement**: Immobilized or limited crawling based on configuration
-4. **Timer**: Countdown begins (configurable duration)
-5. **Options**: Can be revived, executed, or will die when timer expires
+```
+✦ Iron Golem Reanimator [PlayerName] | ❤ 67 | ⏱ 8m32s
+```
 
-### Revival Process
+HP color shifts green (> 50%) → yellow (> 25%) → red.
+Nameplate updates every 2 seconds.
 
-**Requirements:**
-- Another player must crouch near the KO'd player
-- Reviver must hold the required item (default: Golden Apple)
-- Revival takes time (configurable, default 5 seconds)
-- Both players must remain still during revival
+### Persistence
 
-**Revival Effects:**
-- KO'd player regains health
-- Temporary effects applied (nausea, slowness, resistance)
-- Cooldown applied to prevent spam
+`NPCPersistenceManager` saves an absolute expiry timestamp for each active NPC
+on shutdown. On startup, entries whose timestamp has passed are discarded;
+survivors are restored with their correct remaining lifetime. Golems that
+expire while the owner is offline are never restored.
 
-### Execution System
+### Status and Management
 
-**Process:**
-- Any player can execute a KO'd player
-- Hold left-click for configured duration (default 2 seconds)
-- Optional broadcast message announces executions
-- Results in permanent death
+```
+/rmc npcs                      show HP bar, time, and target for all golems
+/rmc dismiss all               dismiss all active NPCs
+/rmc dismiss healer            dismiss only HEALERs
+/rmc extend 300                add 5 minutes (Vault cost if configured)
+```
 
-### Distress Signal System
+---
 
-**Activation:**
-- KO'd players press F (swap hands key)
-- Creates a beacon at their location
-- Broadcasts coordinates to nearby players
-- One-time use per KO
+## Self-Revive System
 
-### Offline KO Management
+KO'd players can revive themselves using items at the cost of a longer channel
+time than a teammate revive.
 
-**When KO'd players disconnect:**
-- KO state is saved to file
-- Timer continues counting down
-- Player dies if timer expires before reconnection
-- State restored when player reconnects
+### Flow
 
-### Crawling Mechanics
+1. Player runs `/rmc selfrevive` (or `/sr`).
+2. All preconditions are validated; failure sends a specific message.
+3. A progress bar appears in the action bar for `duration_ticks` ticks.
+4. On completion: items consumed, `revive()` called, `effects_on_selfrevive` applied.
+5. Any movement or incoming damage cancels the channel (if configured).
 
-**Two Movement States:**
-1. **Immobilized**: Complete movement restriction
-2. **Crawling**: Slow movement with heavy slowness effect
+### Configuration Reference
 
-**Controls:**
-- Use `/reanimatemc crawl` to toggle states
-- Configurable auto-crawl option
-- Separate permission for crawling ability
+```yaml
+self_revive:
+  enabled: true
+  require_items: true
+  required_items:
+    - material: GOLDEN_APPLE
+      amount: 2
+  duration_ticks: 200          # ~10 seconds
+  health_restored: 2
+  cooldown_seconds: 120
+  max_uses_per_ko: 1            # 0 = unlimited
+  cancel_on_move: true
+  cancel_on_damage: true
+  combat_block_seconds: 0       # 0 = disabled
+  effects_on_selfrevive:
+    nausea: 10
+    slowness: 15
+    resistance: 5
+```
 
-## API for Developers
+---
 
-ReanimateMC provides a comprehensive API for other plugins to integrate with the KO system.
+## Distress Signal
 
-### Events
+When sent, broadcasts the player's coordinates to all online players and places
+a glowing marker at their location. Respects `distress.cooldown_seconds` and
+`reanimatemc.distress` permission.
+
+### Triggers
+
+| Method | Platform | Config key |
+|---|---|---|
+| F key (swap hands) | Java | always active |
+| Q / drop button | Java + Bedrock | `distress.drop_key_trigger` |
+| Double-tap sneak | Bedrock + Java | `distress.bedrock_doubletap_ms` |
+| Cancelling surrender | All | automatic |
+| `/rmc distress` | All | pre-added to `allowed_commands` |
+
+The PROTECTOR NPC sends a forced distress signal (bypassing the player cooldown)
+the first time the owner falls K.O. in a session.
+
+---
 
-#### PlayerKOEvent
-Fired when a player enters KO state.
+## API for Developers
+
+### Events
 
 ```java
+// Fired when a player enters K.O. state — cancellable
 @EventHandler
 public void onPlayerKO(PlayerKOEvent event) {
     Player player = event.getPlayer();
-    int duration = event.getDuration();
-    
-    // Cancel the KO event
     event.setCancelled(true);
-    
-    // Custom logic here
 }
-```
 
-#### PlayerReanimatedEvent
-Fired when a player is revived from KO state.
-
-```java
+// Fired when a player is revived
 @EventHandler
-public void onPlayerRevived(PlayerReanimatedEvent event) {
-    Player player = event.getPlayer();
+public void onRevived(PlayerReanimatedEvent event) {
+    Player player     = event.getPlayer();
     Player reanimator = event.getReanimator();
-    boolean successful = event.isSuccessful();
-    long timestamp = event.getTimestamp();
-    
-    // Custom logic here
 }
-```
 
-### API Access
+// Fired when an NPC is summoned — cancellable
+@EventHandler
+public void onNPCSummoned(NPCSummonedEvent event) {
+    ReanimatorNPC npc = event.getNPC();
+    event.setCancelled(true);
+}
+
+// Fired when an NPC is removed
+@EventHandler
+public void onNPCDismissed(NPCDismissedEvent event) {
+    ReanimatorNPC npc            = event.getNPC();
+    NPCDismissedEvent.Reason why = event.getReason(); // MANUAL, EXPIRED, OFFLINE_TIMEOUT, PLUGIN_DISABLE
+}
+```
 
-Get the KOManager instance:
+### Programmatic Access
 
 ```java
-// Get the plugin instance
 ReanimateMC plugin = (ReanimateMC) Bukkit.getPluginManager().getPlugin("ReanimateMC");
 
-// Access the KO manager
-KOManager koManager = plugin.getKoManager();
-
-// Check if player is KO'd
-boolean isKO = koManager.isKO(player);
-
-// Force KO a player
-koManager.setKO(player, 30); // 30 seconds
-
-// Revive a player
-koManager.revive(player, reviverPlayer);
-
-// Execute a player
-koManager.execute(player);
+KOManager ko = plugin.getKoManager();
+ko.isKO(player);
+ko.setKO(player);
+ko.revive(player, reviver);
+ko.sendDistress(player);
+ko.startSelfRevive(player);
+
+NPCSummonManager npc = plugin.getNpcSummonManager();
+npc.summon(player, ReanimatorNPC.ReanimatorType.HEALER, null);
+npc.dismissAll(player);
+npc.getPlayerSummons(player);
 ```
 
-### Dependency Setup
+### PlaceholderAPI
+
+| Placeholder | Returns |
+|---|---|
+| `%reanimatemc_is_ko%` | `true` / `false` |
+| `%reanimatemc_ko_time_remaining%` | seconds remaining |
+| `%reanimatemc_npc_count%` | number of active NPCs |
+| `%reanimatemc_npc_type%` | type name of first active NPC |
+| `%reanimatemc_npc_time_remaining%` | NPC lifetime remaining |
+| `%reanimatemc_npc_hp%` | NPC current HP |
 
-Add ReanimateMC as a dependency in your plugin.yml:
+### Dependency
 
+`plugin.yml`:
 ```yaml
-depend: [ReanimateMC]
-# or
 softdepend: [ReanimateMC]
 ```
 
-Maven dependency:
-```xml
-<dependency>
-    <groupId>fr.jachou</groupId>
-    <artifactId>ReanimateMC</artifactId>
-    <version>1.2.12</version>
-    <scope>provided</scope>
-</dependency>
-```
+---
 
 ## Language Support
 
-ReanimateMC supports multiple languages with complete translations:
-
-### Available Languages
-- **English** (`en`) - Default
-- **French** (`fr`) - Français
-- **Spanish** (`es`) - Español  
-- **German** (`de`) - Deutsch
-- **Italian** (`it`) - Italiano
-- **Dutch** (`nl`) - Nederlands
-- **Russian** (`ru`) - Русский
-- **Chinese** (`zh`) - 中文
-- **Korean** (`kr`) - 한국어
-- **Polish** (`pl`) - Polski
-- **Portuguese** (`pt`) - Português
-
-### Changing Language
-
-1. **Via Config**: Set `language: "fr"` in config.yml
-2. **Via GUI**: Use `/reanimatemc config` and click the language option
-3. **Via Command**: Reload after changing config: `/reanimatemc reload`
+10 languages ship with the plugin. All new keys in v1.2.13 are present in every
+file. `en.yml` and `es.yml` have full translations; other languages have English
+fallback strings marked for community translation.
 
-### Custom Translations
+Change language: set `language: "es"` in `config.yml` and run `/rmc reload`.
+Custom translations: copy `lang/en.yml`, rename, translate, set the file name
+(without extension) as the `language` value.
 
-Language files are stored in `plugins/ReanimateMC/lang/`. You can:
-
-1. Copy an existing language file (e.g., `en.yml`)
-2. Rename it (e.g., `custom.yml`)
-3. Translate all messages
-4. Set `language: "custom"` in config.yml
+---
 
 ## Compatibility
 
-### Server Software
-- ✅ **Spigot** - Fully supported
-- ✅ **Paper** - Fully supported  
-- ✅ **Bukkit** - Supported
-- ✅ **Purpur** - Compatible
-- ⚠️ **Magma** - Limited compatibility
-- ⚠️ **Sponge** - Basic compatibility
-
-### Minecraft Versions
-- **Minimum**: 1.20.1
-- **Recommended**: 1.20.4+
-- **Latest Tested**: 1.21.x
-- **Native Version**: 1.20.1
-
-### Plugin Compatibility
-
-**Known Compatible Plugins:**
-- WorldGuard - Respects region flags
-- EssentialsX - Works with teleportation
-- mcMMO - Integrates with skill systems
-- Citizens - NPCs can be revived
-- MythicMobs - Custom mobs work with KO system
-
-**Potential Conflicts:**
-- Death/respawn modifying plugins
-- Health management plugins
-- Combat logging plugins (may need configuration)
-
-## Troubleshooting
-
-### Common Issues
-
-#### Players die instantly instead of entering KO
-**Solutions:**
-- Check that `knockout.enabled: true` in config.yml
-- Verify players don't have `reanimatemc.bypass` permission
-- Ensure no conflicting death plugins are installed
-
-#### Revival not working
-**Solutions:**
-- Check reviver has `reanimatemc.revive` permission
-- Verify reviver is crouching and holding correct item
-- Check revival cooldowns haven't been triggered
-- Ensure `reanimation.require_special_item` setting matches usage
-
-#### GUI configuration not opening
-**Solutions:**
-- Verify player has `reanimatemc.admin` permission
-- Check console for errors during plugin load
-- Try `/reanimatemc reload` and retry
-
-#### Language files not loading
-**Solutions:**
-- Check language code is correct in config.yml
-- Verify language file exists in `plugins/ReanimateMC/lang/`
-- Use `/reanimatemc reload` after changes
-
-### Debug Information
+| Software | Status |
+|---|---|
+| Paper 1.21.4+ | Full support (recommended) |
+| Spigot 1.21+ | Supported; NPC pathfinding limited |
+| Purpur | Compatible |
 
-Enable debug logging by setting your server's logging level to DEBUG for more detailed error information.
+Paper is required for `io.papermc.paper.event.entity.EntityKnockbackEvent`
+and the Pathfinder API used by NPC navigation.
 
-### Getting Help
+---
 
-1. **Check the console** for error messages
-2. **Verify configuration** using the GUI or config files
-3. **Test permissions** using a permission plugin
-4. **Submit issues** on GitHub with full error logs
+## Troubleshooting
 
-### Performance Tips
+| Symptom | Cause | Fix |
+|---|---|---|
+| Version shows `${project.version}` | Old JAR built without filtering | Rebuild with this PR's `pom.xml` |
+| Mobs still attack K.O.'d players | Mobs targeted player before K.O. | Set `mobs_attack_ko: false`; confirmed to clear existing targets |
+| Bedrock ride icon on K.O. | Old JAR with ArmorStand mount | Upgrade to 1.2.13 |
+| Self-revive says unknown command | Old JAR without `plugin.yml` registration | Upgrade to 1.2.13 |
+| PROTECTOR doesn't die | Old `setHealth(0.5)` floor | Upgrade to 1.2.13 |
+| New config keys missing | Config predates 1.2.13 | Run `/rmc reload`; keys merge automatically |
+| HEALER not healing | Heal aura visible but no HP change? Player is at max HP. Check `periodic_heal_amount` | Increase `periodic_heal_amount` |
+| NPC restored with wrong lifetime | Old persistence format stored relative seconds | Upgrade to 1.2.13; delete `npc_data.yml` once |
 
-- Disable particles if experiencing lag: `knockout.use_particles: false`
-- Reduce heartbeat sound frequency for lower resource usage
-- Consider shorter KO durations on high-population servers
-- Use Paper server software for better performance
+---
 
 ## Contributing
 
-We welcome contributions to ReanimateMC! Here's how you can help:
-
-### Reporting Issues
-- Use the [GitHub Issues](https://github.com/MatisseAD/ReanimateMC/issues) page
-- Include server version, plugin version, and full error logs
-- Describe steps to reproduce the issue
-
-### Feature Requests
-- Submit detailed feature requests with use cases
-- Explain how the feature would benefit gameplay
-- Consider implementation complexity
-
-### Translation Help
-- Help translate the plugin into new languages
-- Improve existing translations
-- Submit language files via pull requests
-
-### Code Contributions
-- Fork the repository
-- Create feature branches
-- Follow existing code style
-- Submit pull requests with clear descriptions
+- Bug reports: [GitHub Issues](https://github.com/MatisseAD/ReanimateMC/issues)
+- Lang improvements: submit updated `lang/<code>.yml` via pull request
+- Code contributions: follow existing package structure; one behavior class per
+  NPC type; no logic in listener classes beyond event routing
 
-## Statistics
-
-<img src="https://bstats.org/signatures/bukkit/ReanimateMC.svg" alt="BStats">
+---
 
 ## Credits
 
-**Author:** Jachou  
-**License:** Proprietary - All rights reserved  
-**Support:** [GitHub Issues](https://github.com/MatisseAD/ReanimateMC/issues)
+**Author:** Jachou
+**License:** Proprietary — all rights reserved
+**Wiki:** https://matissead.github.io/ReanimateMC/
 
----
-
-*ReanimateMC - Transform your server's death system and create unforgettable gameplay moments.*
+<img src="https://bstats.org/signatures/bukkit/ReanimateMC.svg" alt="BStats">
diff --git a/docs/api.html b/docs/api.html
index ce9b9d0..956c115 100644
--- a/docs/api.html
+++ b/docs/api.html
@@ -453,7 +453,7 @@ <h3><i class="fas fa-exclamation-triangle"></i> Common Pitfalls</h3>
             <div class="footer-section">
                 <h4>ReanimateMC</h4>
                 <p>A revolutionary Minecraft plugin by Jachou</p>
-                <p class="version">Version 1.2.11</p>
+                <p class="version">Version 1.2.13</p>
             </div>
             <div class="footer-section">
                 <h4>Links</h4>
diff --git a/docs/commands.html b/docs/commands.html
index 15b5af5..4c0c6ef 100644
--- a/docs/commands.html
+++ b/docs/commands.html
@@ -384,7 +384,7 @@ <h3>NPC Commands</h3>
             <div class="footer-section">
                 <h4>ReanimateMC</h4>
                 <p>A revolutionary Minecraft plugin by Jachou</p>
-                <p class="version">Version 1.2.11</p>
+                <p class="version">Version 1.2.13</p>
             </div>
             <div class="footer-section">
                 <h4>Links</h4>
diff --git a/docs/configuration.html b/docs/configuration.html
index 71e2bbd..f77cde9 100644
--- a/docs/configuration.html
+++ b/docs/configuration.html
@@ -470,7 +470,7 @@ <h3>Balance</h3>
             <div class="footer-section">
                 <h4>ReanimateMC</h4>
                 <p>A revolutionary Minecraft plugin by Jachou</p>
-                <p class="version">Version 1.2.11</p>
+                <p class="version">Version 1.2.13</p>
             </div>
             <div class="footer-section">
                 <h4>Links</h4>
diff --git a/docs/de/api.html b/docs/de/api.html
index 80d70d6..3460d7e 100644
--- a/docs/de/api.html
+++ b/docs/de/api.html
@@ -453,7 +453,7 @@ <h3><i class="fas fa-exclamation-triangle"></i> Common Pitfalls</h3>
             <div class="footer-section">
                 <h4>ReanimateMC</h4>
                 <p>A revolutionary Minecraft plugin by Jachou</p>
-                <p class="version">Version 1.2.11</p>
+                <p class="version">Version 1.2.13</p>
             </div>
             <div class="footer-section">
                 <h4>Links</h4>
diff --git a/docs/de/commands.html b/docs/de/commands.html
index 85e23f4..c087bfa 100644
--- a/docs/de/commands.html
+++ b/docs/de/commands.html
@@ -384,7 +384,7 @@ <h3>NPC Befehle</h3>
             <div class="footer-section">
                 <h4>ReanimateMC</h4>
                 <p>A revolutionary Minecraft plugin by Jachou</p>
-                <p class="version">Version 1.2.11</p>
+                <p class="version">Version 1.2.13</p>
             </div>
             <div class="footer-section">
                 <h4>Links</h4>
diff --git a/docs/de/configuration.html b/docs/de/configuration.html
index 2b9473d..eafbada 100644
--- a/docs/de/configuration.html
+++ b/docs/de/configuration.html
@@ -470,7 +470,7 @@ <h3>Balance</h3>
             <div class="footer-section">
                 <h4>ReanimateMC</h4>
                 <p>A revolutionary Minecraft plugin by Jachou</p>
-                <p class="version">Version 1.2.11</p>
+                <p class="version">Version 1.2.13</p>
             </div>
             <div class="footer-section">
                 <h4>Links</h4>
diff --git a/docs/de/index.html b/docs/de/index.html
index 59def58..5ebe253 100644
--- a/docs/de/index.html
+++ b/docs/de/index.html
@@ -300,7 +300,7 @@ <h3>GitHub</h3>
             <div class="footer-section">
                 <h4>ReanimateMC</h4>
                 <p>Un plugin Minecraft révolutionnaire par Jachou</p>
-                <p class="version">Version 1.2.11</p>
+                <p class="version">Version 1.2.13</p>
             </div>
             <div class="footer-section">
                 <h4>Liens</h4>
diff --git a/docs/de/npc-system.html b/docs/de/npc-system.html
index 318e7b2..792100f 100644
--- a/docs/de/npc-system.html
+++ b/docs/de/npc-system.html
@@ -353,7 +353,7 @@ <h3><i class="fas fa-exclamation-triangle"></i> Limitations</h3>
             <div class="footer-section">
                 <h4>ReanimateMC</h4>
                 <p>A revolutionary Minecraft plugin by Jachou</p>
-                <p class="version">Version 1.2.11</p>
+                <p class="version">Version 1.2.13</p>
             </div>
             <div class="footer-section">
                 <h4>Links</h4>
diff --git a/docs/de/permissions.html b/docs/de/permissions.html
index 93e460c..c1cd84c 100644
--- a/docs/de/permissions.html
+++ b/docs/de/permissions.html
@@ -474,7 +474,7 @@ <h3>Balance</h3>
             <div class="footer-section">
                 <h4>ReanimateMC</h4>
                 <p>A revolutionary Minecraft plugin by Jachou</p>
-                <p class="version">Version 1.2.11</p>
+                <p class="version">Version 1.2.13</p>
             </div>
             <div class="footer-section">
                 <h4>Links</h4>
diff --git a/docs/es/api.html b/docs/es/api.html
index dc914d1..a2c558d 100644
--- a/docs/es/api.html
+++ b/docs/es/api.html
@@ -453,7 +453,7 @@ <h3><i class="fas fa-exclamation-triangle"></i> Common Pitfalls</h3>
             <div class="footer-section">
                 <h4>ReanimateMC</h4>
                 <p>A revolutionary Minecraft plugin by Jachou</p>
-                <p class="version">Version 1.2.11</p>
+                <p class="version">Version 1.2.13</p>
             </div>
             <div class="footer-section">
                 <h4>Links</h4>
diff --git a/docs/es/commands.html b/docs/es/commands.html
index 44e917f..aa4dde0 100644
--- a/docs/es/commands.html
+++ b/docs/es/commands.html
@@ -384,7 +384,7 @@ <h3>NPC Comandos</h3>
             <div class="footer-section">
                 <h4>ReanimateMC</h4>
                 <p>A revolutionary Minecraft plugin by Jachou</p>
-                <p class="version">Version 1.2.11</p>
+                <p class="version">Version 1.2.13</p>
             </div>
             <div class="footer-section">
                 <h4>Links</h4>
diff --git a/docs/es/configuration.html b/docs/es/configuration.html
index e143f86..7d80193 100644
--- a/docs/es/configuration.html
+++ b/docs/es/configuration.html
@@ -470,7 +470,7 @@ <h3>Balance</h3>
             <div class="footer-section">
                 <h4>ReanimateMC</h4>
                 <p>A revolutionary Minecraft plugin by Jachou</p>
-                <p class="version">Version 1.2.11</p>
+                <p class="version">Version 1.2.13</p>
             </div>
             <div class="footer-section">
                 <h4>Links</h4>
diff --git a/docs/es/index.html b/docs/es/index.html
index 3f118ea..cdbd2b4 100644
--- a/docs/es/index.html
+++ b/docs/es/index.html
@@ -300,7 +300,7 @@ <h3>GitHub</h3>
             <div class="footer-section">
                 <h4>ReanimateMC</h4>
                 <p>Un plugin Minecraft révolutionnaire par Jachou</p>
-                <p class="version">Version 1.2.11</p>
+                <p class="version">Version 1.2.13</p>
             </div>
             <div class="footer-section">
                 <h4>Liens</h4>
diff --git a/docs/es/npc-system.html b/docs/es/npc-system.html
index a4aa0b0..5f8d891 100644
--- a/docs/es/npc-system.html
+++ b/docs/es/npc-system.html
@@ -353,7 +353,7 @@ <h3><i class="fas fa-exclamation-triangle"></i> Limitations</h3>
             <div class="footer-section">
                 <h4>ReanimateMC</h4>
                 <p>A revolutionary Minecraft plugin by Jachou</p>
-                <p class="version">Version 1.2.11</p>
+                <p class="version">Version 1.2.13</p>
             </div>
             <div class="footer-section">
                 <h4>Links</h4>
diff --git a/docs/es/permissions.html b/docs/es/permissions.html
index 0e559a3..1184231 100644
--- a/docs/es/permissions.html
+++ b/docs/es/permissions.html
@@ -474,7 +474,7 @@ <h3>Balance</h3>
             <div class="footer-section">
                 <h4>ReanimateMC</h4>
                 <p>A revolutionary Minecraft plugin by Jachou</p>
-                <p class="version">Version 1.2.11</p>
+                <p class="version">Version 1.2.13</p>
             </div>
             <div class="footer-section">
                 <h4>Links</h4>
diff --git a/docs/fr/api.html b/docs/fr/api.html
index be52439..65937cc 100644
--- a/docs/fr/api.html
+++ b/docs/fr/api.html
@@ -453,7 +453,7 @@ <h3><i class="fas fa-exclamation-triangle"></i> Common Pitfalls</h3>
             <div class="footer-section">
                 <h4>ReanimateMC</h4>
                 <p>A revolutionary Minecraft plugin by Jachou</p>
-                <p class="version">Version 1.2.11</p>
+                <p class="version">Version 1.2.13</p>
             </div>
             <div class="footer-section">
                 <h4>Links</h4>
diff --git a/docs/fr/commands.html b/docs/fr/commands.html
index 59482cd..08bb455 100644
--- a/docs/fr/commands.html
+++ b/docs/fr/commands.html
@@ -384,7 +384,7 @@ <h3>NPC Commandes</h3>
             <div class="footer-section">
                 <h4>ReanimateMC</h4>
                 <p>A revolutionary Minecraft plugin by Jachou</p>
-                <p class="version">Version 1.2.11</p>
+                <p class="version">Version 1.2.13</p>
             </div>
             <div class="footer-section">
                 <h4>Links</h4>
diff --git a/docs/fr/configuration.html b/docs/fr/configuration.html
index b21e124..9ee2fae 100644
--- a/docs/fr/configuration.html
+++ b/docs/fr/configuration.html
@@ -470,7 +470,7 @@ <h3>Balance</h3>
             <div class="footer-section">
                 <h4>ReanimateMC</h4>
                 <p>A revolutionary Minecraft plugin by Jachou</p>
-                <p class="version">Version 1.2.11</p>
+                <p class="version">Version 1.2.13</p>
             </div>
             <div class="footer-section">
                 <h4>Links</h4>
diff --git a/docs/fr/index.html b/docs/fr/index.html
index cb0ef37..d8dfbc7 100644
--- a/docs/fr/index.html
+++ b/docs/fr/index.html
@@ -300,7 +300,7 @@ <h3>GitHub</h3>
             <div class="footer-section">
                 <h4>ReanimateMC</h4>
                 <p>Un plugin Minecraft révolutionnaire par Jachou</p>
-                <p class="version">Version 1.2.11</p>
+                <p class="version">Version 1.2.13</p>
             </div>
             <div class="footer-section">
                 <h4>Liens</h4>
diff --git a/docs/fr/npc-system.html b/docs/fr/npc-system.html
index 347a326..ecc8867 100644
--- a/docs/fr/npc-system.html
+++ b/docs/fr/npc-system.html
@@ -353,7 +353,7 @@ <h3><i class="fas fa-exclamation-triangle"></i> Limitations</h3>
             <div class="footer-section">
                 <h4>ReanimateMC</h4>
                 <p>A revolutionary Minecraft plugin by Jachou</p>
-                <p class="version">Version 1.2.11</p>
+                <p class="version">Version 1.2.13</p>
             </div>
             <div class="footer-section">
                 <h4>Links</h4>
diff --git a/docs/fr/permissions.html b/docs/fr/permissions.html
index cf846f0..b56e413 100644
--- a/docs/fr/permissions.html
+++ b/docs/fr/permissions.html
@@ -474,7 +474,7 @@ <h3>Balance</h3>
             <div class="footer-section">
                 <h4>ReanimateMC</h4>
                 <p>A revolutionary Minecraft plugin by Jachou</p>
-                <p class="version">Version 1.2.11</p>
+                <p class="version">Version 1.2.13</p>
             </div>
             <div class="footer-section">
                 <h4>Links</h4>
diff --git a/docs/index.html b/docs/index.html
index 3643e90..c092047 100644
--- a/docs/index.html
+++ b/docs/index.html
@@ -300,7 +300,7 @@ <h3>GitHub</h3>
             <div class="footer-section">
                 <h4>ReanimateMC</h4>
                 <p>A revolutionary Minecraft plugin by Jachou</p>
-                <p class="version">Version 1.2.11</p>
+                <p class="version">Version 1.2.13</p>
             </div>
             <div class="footer-section">
                 <h4>Links</h4>
diff --git a/docs/it/api.html b/docs/it/api.html
index 66176b5..8d64aa5 100644
--- a/docs/it/api.html
+++ b/docs/it/api.html
@@ -453,7 +453,7 @@ <h3><i class="fas fa-exclamation-triangle"></i> Common Pitfalls</h3>
             <div class="footer-section">
                 <h4>ReanimateMC</h4>
                 <p>A revolutionary Minecraft plugin by Jachou</p>
-                <p class="version">Version 1.2.11</p>
+                <p class="version">Version 1.2.13</p>
             </div>
             <div class="footer-section">
                 <h4>Links</h4>
diff --git a/docs/it/commands.html b/docs/it/commands.html
index 5212c64..048a1a8 100644
--- a/docs/it/commands.html
+++ b/docs/it/commands.html
@@ -384,7 +384,7 @@ <h3>NPC Comandi</h3>
             <div class="footer-section">
                 <h4>ReanimateMC</h4>
                 <p>A revolutionary Minecraft plugin by Jachou</p>
-                <p class="version">Version 1.2.11</p>
+                <p class="version">Version 1.2.13</p>
             </div>
             <div class="footer-section">
                 <h4>Links</h4>
diff --git a/docs/it/configuration.html b/docs/it/configuration.html
index 0e2d21f..f7a922e 100644
--- a/docs/it/configuration.html
+++ b/docs/it/configuration.html
@@ -470,7 +470,7 @@ <h3>Balance</h3>
             <div class="footer-section">
                 <h4>ReanimateMC</h4>
                 <p>A revolutionary Minecraft plugin by Jachou</p>
-                <p class="version">Version 1.2.11</p>
+                <p class="version">Version 1.2.13</p>
             </div>
             <div class="footer-section">
                 <h4>Links</h4>
diff --git a/docs/it/index.html b/docs/it/index.html
index c1e486d..49ac363 100644
--- a/docs/it/index.html
+++ b/docs/it/index.html
@@ -300,7 +300,7 @@ <h3>GitHub</h3>
             <div class="footer-section">
                 <h4>ReanimateMC</h4>
                 <p>Un plugin Minecraft révolutionnaire par Jachou</p>
-                <p class="version">Version 1.2.11</p>
+                <p class="version">Version 1.2.13</p>
             </div>
             <div class="footer-section">
                 <h4>Liens</h4>
diff --git a/docs/it/npc-system.html b/docs/it/npc-system.html
index 7473e92..74bfdbc 100644
--- a/docs/it/npc-system.html
+++ b/docs/it/npc-system.html
@@ -353,7 +353,7 @@ <h3><i class="fas fa-exclamation-triangle"></i> Limitations</h3>
             <div class="footer-section">
                 <h4>ReanimateMC</h4>
                 <p>A revolutionary Minecraft plugin by Jachou</p>
-                <p class="version">Version 1.2.11</p>
+                <p class="version">Version 1.2.13</p>
             </div>
             <div class="footer-section">
                 <h4>Links</h4>
diff --git a/docs/it/permissions.html b/docs/it/permissions.html
index 7378503..ae90464 100644
--- a/docs/it/permissions.html
+++ b/docs/it/permissions.html
@@ -474,7 +474,7 @@ <h3>Balance</h3>
             <div class="footer-section">
                 <h4>ReanimateMC</h4>
                 <p>A revolutionary Minecraft plugin by Jachou</p>
-                <p class="version">Version 1.2.11</p>
+                <p class="version">Version 1.2.13</p>
             </div>
             <div class="footer-section">
                 <h4>Links</h4>
diff --git a/docs/kr/api.html b/docs/kr/api.html
index 04f5886..4f427c8 100644
--- a/docs/kr/api.html
+++ b/docs/kr/api.html
@@ -453,7 +453,7 @@ <h3><i class="fas fa-exclamation-triangle"></i> Common Pitfalls</h3>
             <div class="footer-section">
                 <h4>ReanimateMC</h4>
                 <p>A revolutionary Minecraft plugin by Jachou</p>
-                <p class="version">Version 1.2.11</p>
+                <p class="version">Version 1.2.13</p>
             </div>
             <div class="footer-section">
                 <h4>Links</h4>
diff --git a/docs/kr/commands.html b/docs/kr/commands.html
index 51464f2..4b05e3e 100644
--- a/docs/kr/commands.html
+++ b/docs/kr/commands.html
@@ -384,7 +384,7 @@ <h3>NPC 명령어</h3>
             <div class="footer-section">
                 <h4>ReanimateMC</h4>
                 <p>A revolutionary Minecraft plugin by Jachou</p>
-                <p class="version">Version 1.2.11</p>
+                <p class="version">Version 1.2.13</p>
             </div>
             <div class="footer-section">
                 <h4>Links</h4>
diff --git a/docs/kr/configuration.html b/docs/kr/configuration.html
index 635e56c..0be7713 100644
--- a/docs/kr/configuration.html
+++ b/docs/kr/configuration.html
@@ -470,7 +470,7 @@ <h3>Balance</h3>
             <div class="footer-section">
                 <h4>ReanimateMC</h4>
                 <p>A revolutionary Minecraft plugin by Jachou</p>
-                <p class="version">Version 1.2.11</p>
+                <p class="version">Version 1.2.13</p>
             </div>
             <div class="footer-section">
                 <h4>Links</h4>
diff --git a/docs/kr/index.html b/docs/kr/index.html
index eae0b06..4266aad 100644
--- a/docs/kr/index.html
+++ b/docs/kr/index.html
@@ -300,7 +300,7 @@ <h3>GitHub</h3>
             <div class="footer-section">
                 <h4>ReanimateMC</h4>
                 <p>Un plugin Minecraft révolutionnaire par Jachou</p>
-                <p class="version">Version 1.2.11</p>
+                <p class="version">Version 1.2.13</p>
             </div>
             <div class="footer-section">
                 <h4>Liens</h4>
diff --git a/docs/kr/npc-system.html b/docs/kr/npc-system.html
index 87de9ec..2b67a61 100644
--- a/docs/kr/npc-system.html
+++ b/docs/kr/npc-system.html
@@ -353,7 +353,7 @@ <h3><i class="fas fa-exclamation-triangle"></i> Limitations</h3>
             <div class="footer-section">
                 <h4>ReanimateMC</h4>
                 <p>A revolutionary Minecraft plugin by Jachou</p>
-                <p class="version">Version 1.2.11</p>
+                <p class="version">Version 1.2.13</p>
             </div>
             <div class="footer-section">
                 <h4>Links</h4>
diff --git a/docs/kr/permissions.html b/docs/kr/permissions.html
index 21007e8..4d7ccea 100644
--- a/docs/kr/permissions.html
+++ b/docs/kr/permissions.html
@@ -474,7 +474,7 @@ <h3>Balance</h3>
             <div class="footer-section">
                 <h4>ReanimateMC</h4>
                 <p>A revolutionary Minecraft plugin by Jachou</p>
-                <p class="version">Version 1.2.11</p>
+                <p class="version">Version 1.2.13</p>
             </div>
             <div class="footer-section">
                 <h4>Links</h4>
diff --git a/docs/npc-system.html b/docs/npc-system.html
index 610724c..9c06202 100644
--- a/docs/npc-system.html
+++ b/docs/npc-system.html
@@ -353,7 +353,7 @@ <h3><i class="fas fa-exclamation-triangle"></i> Limitations</h3>
             <div class="footer-section">
                 <h4>ReanimateMC</h4>
                 <p>A revolutionary Minecraft plugin by Jachou</p>
-                <p class="version">Version 1.2.11</p>
+                <p class="version">Version 1.2.13</p>
             </div>
             <div class="footer-section">
                 <h4>Links</h4>
diff --git a/docs/permissions.html b/docs/permissions.html
index 8e6937f..6505306 100644
--- a/docs/permissions.html
+++ b/docs/permissions.html
@@ -474,7 +474,7 @@ <h3>Balance</h3>
             <div class="footer-section">
                 <h4>ReanimateMC</h4>
                 <p>A revolutionary Minecraft plugin by Jachou</p>
-                <p class="version">Version 1.2.11</p>
+                <p class="version">Version 1.2.13</p>
             </div>
             <div class="footer-section">
                 <h4>Links</h4>
diff --git a/docs/pt/api.html b/docs/pt/api.html
index 835b0d4..cdbe352 100644
--- a/docs/pt/api.html
+++ b/docs/pt/api.html
@@ -453,7 +453,7 @@ <h3><i class="fas fa-exclamation-triangle"></i> Common Pitfalls</h3>
             <div class="footer-section">
                 <h4>ReanimateMC</h4>
                 <p>A revolutionary Minecraft plugin by Jachou</p>
-                <p class="version">Version 1.2.11</p>
+                <p class="version">Version 1.2.13</p>
             </div>
             <div class="footer-section">
                 <h4>Links</h4>
diff --git a/docs/pt/commands.html b/docs/pt/commands.html
index 5c574ce..344fec3 100644
--- a/docs/pt/commands.html
+++ b/docs/pt/commands.html
@@ -384,7 +384,7 @@ <h3>NPC Comandos</h3>
             <div class="footer-section">
                 <h4>ReanimateMC</h4>
                 <p>A revolutionary Minecraft plugin by Jachou</p>
-                <p class="version">Version 1.2.11</p>
+                <p class="version">Version 1.2.13</p>
             </div>
             <div class="footer-section">
                 <h4>Links</h4>
diff --git a/docs/pt/configuration.html b/docs/pt/configuration.html
index 9746530..2591c20 100644
--- a/docs/pt/configuration.html
+++ b/docs/pt/configuration.html
@@ -470,7 +470,7 @@ <h3>Balance</h3>
             <div class="footer-section">
                 <h4>ReanimateMC</h4>
                 <p>A revolutionary Minecraft plugin by Jachou</p>
-                <p class="version">Version 1.2.11</p>
+                <p class="version">Version 1.2.13</p>
             </div>
             <div class="footer-section">
                 <h4>Links</h4>
diff --git a/docs/pt/index.html b/docs/pt/index.html
index b11f6a8..45192ca 100644
--- a/docs/pt/index.html
+++ b/docs/pt/index.html
@@ -300,7 +300,7 @@ <h3>GitHub</h3>
             <div class="footer-section">
                 <h4>ReanimateMC</h4>
                 <p>Un plugin Minecraft révolutionnaire par Jachou</p>
-                <p class="version">Version 1.2.11</p>
+                <p class="version">Version 1.2.13</p>
             </div>
             <div class="footer-section">
                 <h4>Liens</h4>
diff --git a/docs/pt/npc-system.html b/docs/pt/npc-system.html
index 4ee753e..9d1b70d 100644
--- a/docs/pt/npc-system.html
+++ b/docs/pt/npc-system.html
@@ -353,7 +353,7 @@ <h3><i class="fas fa-exclamation-triangle"></i> Limitations</h3>
             <div class="footer-section">
                 <h4>ReanimateMC</h4>
                 <p>A revolutionary Minecraft plugin by Jachou</p>
-                <p class="version">Version 1.2.11</p>
+                <p class="version">Version 1.2.13</p>
             </div>
             <div class="footer-section">
                 <h4>Links</h4>
diff --git a/docs/pt/permissions.html b/docs/pt/permissions.html
index 368a18e..beda178 100644
--- a/docs/pt/permissions.html
+++ b/docs/pt/permissions.html
@@ -474,7 +474,7 @@ <h3>Balance</h3>
             <div class="footer-section">
                 <h4>ReanimateMC</h4>
                 <p>A revolutionary Minecraft plugin by Jachou</p>
-                <p class="version">Version 1.2.11</p>
+                <p class="version">Version 1.2.13</p>
             </div>
             <div class="footer-section">
                 <h4>Links</h4>
diff --git a/docs/ru/api.html b/docs/ru/api.html
index e6d5997..7ef1f41 100644
--- a/docs/ru/api.html
+++ b/docs/ru/api.html
@@ -453,7 +453,7 @@ <h3><i class="fas fa-exclamation-triangle"></i> Common Pitfalls</h3>
             <div class="footer-section">
                 <h4>ReanimateMC</h4>
                 <p>A revolutionary Minecraft plugin by Jachou</p>
-                <p class="version">Version 1.2.11</p>
+                <p class="version">Version 1.2.13</p>
             </div>
             <div class="footer-section">
                 <h4>Links</h4>
diff --git a/docs/ru/commands.html b/docs/ru/commands.html
index a833e5d..136bdac 100644
--- a/docs/ru/commands.html
+++ b/docs/ru/commands.html
@@ -384,7 +384,7 @@ <h3>NPC Команды</h3>
             <div class="footer-section">
                 <h4>ReanimateMC</h4>
                 <p>A revolutionary Minecraft plugin by Jachou</p>
-                <p class="version">Version 1.2.11</p>
+                <p class="version">Version 1.2.13</p>
             </div>
             <div class="footer-section">
                 <h4>Links</h4>
diff --git a/docs/ru/configuration.html b/docs/ru/configuration.html
index e103c43..bdc1e5b 100644
--- a/docs/ru/configuration.html
+++ b/docs/ru/configuration.html
@@ -470,7 +470,7 @@ <h3>Balance</h3>
             <div class="footer-section">
                 <h4>ReanimateMC</h4>
                 <p>A revolutionary Minecraft plugin by Jachou</p>
-                <p class="version">Version 1.2.11</p>
+                <p class="version">Version 1.2.13</p>
             </div>
             <div class="footer-section">
                 <h4>Links</h4>
diff --git a/docs/ru/index.html b/docs/ru/index.html
index afebbec..3f74e2e 100644
--- a/docs/ru/index.html
+++ b/docs/ru/index.html
@@ -300,7 +300,7 @@ <h3>GitHub</h3>
             <div class="footer-section">
                 <h4>ReanimateMC</h4>
                 <p>Un plugin Minecraft révolutionnaire par Jachou</p>
-                <p class="version">Version 1.2.11</p>
+                <p class="version">Version 1.2.13</p>
             </div>
             <div class="footer-section">
                 <h4>Liens</h4>
diff --git a/docs/ru/npc-system.html b/docs/ru/npc-system.html
index b5f61c6..c3355bb 100644
--- a/docs/ru/npc-system.html
+++ b/docs/ru/npc-system.html
@@ -353,7 +353,7 @@ <h3><i class="fas fa-exclamation-triangle"></i> Limitations</h3>
             <div class="footer-section">
                 <h4>ReanimateMC</h4>
                 <p>A revolutionary Minecraft plugin by Jachou</p>
-                <p class="version">Version 1.2.11</p>
+                <p class="version">Version 1.2.13</p>
             </div>
             <div class="footer-section">
                 <h4>Links</h4>
diff --git a/docs/ru/permissions.html b/docs/ru/permissions.html
index 803bdf8..92eae1f 100644
--- a/docs/ru/permissions.html
+++ b/docs/ru/permissions.html
@@ -474,7 +474,7 @@ <h3>Balance</h3>
             <div class="footer-section">
                 <h4>ReanimateMC</h4>
                 <p>A revolutionary Minecraft plugin by Jachou</p>
-                <p class="version">Version 1.2.11</p>
+                <p class="version">Version 1.2.13</p>
             </div>
             <div class="footer-section">
                 <h4>Links</h4>
diff --git a/docs/zh/api.html b/docs/zh/api.html
index dd75df0..cc4d294 100644
--- a/docs/zh/api.html
+++ b/docs/zh/api.html
@@ -453,7 +453,7 @@ <h3><i class="fas fa-exclamation-triangle"></i> Common Pitfalls</h3>
             <div class="footer-section">
                 <h4>ReanimateMC</h4>
                 <p>A revolutionary Minecraft plugin by Jachou</p>
-                <p class="version">Version 1.2.11</p>
+                <p class="version">Version 1.2.13</p>
             </div>
             <div class="footer-section">
                 <h4>Links</h4>
diff --git a/docs/zh/commands.html b/docs/zh/commands.html
index ef541f1..615527c 100644
--- a/docs/zh/commands.html
+++ b/docs/zh/commands.html
@@ -384,7 +384,7 @@ <h3>NPC 命令</h3>
             <div class="footer-section">
                 <h4>ReanimateMC</h4>
                 <p>A revolutionary Minecraft plugin by Jachou</p>
-                <p class="version">Version 1.2.11</p>
+                <p class="version">Version 1.2.13</p>
             </div>
             <div class="footer-section">
                 <h4>Links</h4>
diff --git a/docs/zh/configuration.html b/docs/zh/configuration.html
index e4d43da..5ca958c 100644
--- a/docs/zh/configuration.html
+++ b/docs/zh/configuration.html
@@ -470,7 +470,7 @@ <h3>Balance</h3>
             <div class="footer-section">
                 <h4>ReanimateMC</h4>
                 <p>A revolutionary Minecraft plugin by Jachou</p>
-                <p class="version">Version 1.2.11</p>
+                <p class="version">Version 1.2.13</p>
             </div>
             <div class="footer-section">
                 <h4>Links</h4>
diff --git a/docs/zh/index.html b/docs/zh/index.html
index 66776d9..a0b48cc 100644
--- a/docs/zh/index.html
+++ b/docs/zh/index.html
@@ -300,7 +300,7 @@ <h3>GitHub</h3>
             <div class="footer-section">
                 <h4>ReanimateMC</h4>
                 <p>Un plugin Minecraft révolutionnaire par Jachou</p>
-                <p class="version">Version 1.2.11</p>
+                <p class="version">Version 1.2.13</p>
             </div>
             <div class="footer-section">
                 <h4>Liens</h4>
diff --git a/docs/zh/npc-system.html b/docs/zh/npc-system.html
index 942dedc..02fbdea 100644
--- a/docs/zh/npc-system.html
+++ b/docs/zh/npc-system.html
@@ -353,7 +353,7 @@ <h3><i class="fas fa-exclamation-triangle"></i> Limitations</h3>
             <div class="footer-section">
                 <h4>ReanimateMC</h4>
                 <p>A revolutionary Minecraft plugin by Jachou</p>
-                <p class="version">Version 1.2.11</p>
+                <p class="version">Version 1.2.13</p>
             </div>
             <div class="footer-section">
                 <h4>Links</h4>
diff --git a/docs/zh/permissions.html b/docs/zh/permissions.html
index 3fe3e08..20eefc6 100644
--- a/docs/zh/permissions.html
+++ b/docs/zh/permissions.html
@@ -474,7 +474,7 @@ <h3>Balance</h3>
             <div class="footer-section">
                 <h4>ReanimateMC</h4>
                 <p>A revolutionary Minecraft plugin by Jachou</p>
-                <p class="version">Version 1.2.11</p>
+                <p class="version">Version 1.2.13</p>
             </div>
             <div class="footer-section">
                 <h4>Links</h4>
diff --git a/src/main/resources/lang/de.yml b/src/main/resources/lang/de.yml
index 470a7e2..a0d8892 100644
--- a/src/main/resources/lang/de.yml
+++ b/src/main/resources/lang/de.yml
@@ -138,4 +138,123 @@ option_effect_resistance: "Resistenz-Dauer"
 update_available: "Neue Version verfügbar:"
 update_log: "Neue Version verfügbar: %version% -> %url%"
 update_command_available: "Update verfügbar: %version% — %url%"
-update_up_to_date: "Sie sind auf dem neuesten Stand für Ihre Minecraft-Version."
\ No newline at end of file
+update_up_to_date: "Sie sind auf dem neuesten Stand für Ihre Minecraft-Version."
+
+# ── Keys added in v1.2.13 (EN fallback — awaiting translation) ──
+option_mobs_attack_ko: "Mobs Attack KO'd Players"
+option_knockback_disabled: "Disable Knockback on KO"
+option_surrender_require_still: "Must Be Still to Surrender"
+revive_cancelled_moved: "Revival cancelled: you moved."
+option_knockout_blindness: "Blindness On KO"
+option_tablist_enabled: "Tablist KO Tag"
+message_gui_toggle: "%option% is now %state%"
+stats_title: "Statistics"
+stats_ko: "KOs: %value%"
+stats_revive: "Revives: %value%"
+plugin_info: "Plugin Info"
+info_version: "Version: %value%"
+info_authors: "Authors: %value%"
+change_language: "Change Language"
+language_changed: "Language changed to %lang%"
+first_run_message: "Use /reanimatemc config to configure the plugin!"
+setup_complete: "Plugin configured! Thank you."
+distress_sent: "Distress signal sent!"
+distress_broadcast: "%player% needs help at %x%, %y%, %z%!"
+distress_cooldown: "Distress signal on cooldown. %time%s remaining."
+distress_disabled: "Distress signals are disabled on this server."
+npc_no_healer_active: "You need an active Healer Golem to use this command."
+npc_already_reviving: "Someone is already being revived."
+npc_reviving_you: "%player%'s %type% is reviving you..."
+npc_being_revived_bar: "%type% reviving... %bar% %pct%%"
+npc_reviving_bar: "Reviving %player%... %bar% %pct%%"
+npc_protector_no_revive_warning: "Your %type% is focused on defense — it cannot revive you. A distress signal has been sent to your team."
+command_summon_usage: "Usage: /reanimatemc summon <golem|healer|protector> [player]"
+command_dismiss_usage: "Usage: /reanimatemc dismiss <all>"
+command_player_only: "This command can only be executed by a player."
+npc_summoned: "%type% has been summoned!"
+npc_dismissed: "NPC dismissed successfully."
+npc_dismissed_all: "Dismissed %count% NPC(s)."
+npc_none_active: "You have no active NPCs."
+npc_not_found: "NPC not found."
+npc_not_owner: "You do not own this NPC."
+npc_invalid_type: "Invalid NPC type: %type%. Valid types: golem, healer, protector"
+npc_no_type_permission: "You do not have permission to summon %type%."
+npc_summon_disabled: "The NPC Reanimator System is disabled on this server."
+npc_summon_cooldown: "You must wait %time% seconds before summoning again."
+npc_max_summons: "You have reached the maximum number of summons (%max%)."
+npc_summon_failed: "Failed to summon NPC. Try again."
+npc_status_header: "Active NPCs:"
+npc_status_target: "→ Target: %player%"
+npc_healer_aura_active: "Your Healer is protecting you."
+npc_healer_scanning: "Your Healer detected a KO'd ally nearby."
+npc_protector_intercepted: "Your Protector absorbed incoming damage."
+npc_protector_knockback: "Your Protector repelled nearby threats."
+npc_low_hp: "%type% is critically low! ❤ %hp% HP remaining."
+npc_died: "Your %type% has been defeated."
+npc_expired: "%type% has expired and disappeared."
+npc_lifetime_remaining: "(%time%s remaining)"
+npc_time_extended: "NPC lifetime extended by %time% seconds."
+npc_extend_charged: "Charged %cost% for the extension."
+npc_extend_insufficient_funds: "You need %cost% to extend your NPC's lifetime."
+command_extend_usage: "Usage: /reanimatemc extend <seconds>"
+purge_complete: "Cleanup complete: removed %count% stale K.O. hologram(s) from all worlds."
+kolist_header: "Players in K.O."
+kolist_empty: "No players are currently K.O."
+npc_name_golem: "Iron Golem Reanimator"
+npc_name_healer: "Healing Golem"
+npc_name_protector: "Protective Golem"
+npc_summoned_for_you: "%player% summoned a %type% for you!"
+npc_team_summoned: "Summoned %type% for %count% team member(s)."
+npc_team_charged: "Charged %cost% for %count% summon(s)."
+npc_team_insufficient_funds: "You need %cost% to summon for %count% player(s)."
+command_summon_team_usage: "Usage: /rmc summon team <golem|healer|protector> <player1> <player2> ..."
+cmd_help_title: "Commands"
+cmd_help_reload: "Reload config and language files"
+cmd_help_revive: "Start a timed revive via your Healer NPC"
+cmd_help_knockout: "Force a player into K.O."
+cmd_help_status: "Check a player's K.O. status"
+cmd_help_distress: "Send a distress signal while K.O.'d"
+cmd_help_crawl: "Toggle crawl mode while K.O.'d"
+cmd_help_config: "Open the configuration GUI"
+cmd_help_summon: "Summon a Reanimator NPC (optional: for another player)"
+cmd_help_summon_team: "Summon an NPC for multiple team members"
+cmd_help_dismiss: "Dismiss your active NPC(s)"
+cmd_help_extend: "Extend active NPC lifetime"
+cmd_help_npcs: "Show your active NPCs status"
+cmd_help_purge: "Remove stale K.O. holograms from all worlds"
+cmd_help_kolist: "List K.O.'d players and time remaining"
+cmd_help_info: "Show plugin status and integration info"
+cmd_help_version: "Show plugin version"
+cmd_arg_player: "player"
+cmd_arg_seconds: "seconds"
+cmd_version_plugin: "Plugin:"
+cmd_version_author: "Author:"
+cmd_version_mc: "Minecraft:"
+cmd_version_api: "API:"
+cmd_info_version: "Version:"
+cmd_info_active: "active"
+cmd_info_inactive: "inactive"
+cmd_info_enabled: "enabled"
+cmd_info_disabled: "disabled"
+cmd_info_npc: "NPC System:"
+cmd_info_ko_count: "Players K.O.:"
+cmd_info_hint: "Commands:"
+option_crawl_nausea_enabled: "Crawl Nausea Effect"
+option_crawl_nausea_level: "Crawl Nausea Level"
+option_npc_enabled: "NPC Reanimator System"
+option_npc_invulnerable: "NPC Invulnerable Mode"
+option_npc_damage_transfer: "Protector Damage Transfer"
+option_npc_protector_revive: "Protector Revives (No Healer)"
+selfrevive_disabled: "Self-revive is disabled on this server."
+selfrevive_already_channeling: "You are already reviving yourself."
+selfrevive_max_uses: "You have reached the self-revive limit for this K.O. session (%max% use(s))."
+selfrevive_cooldown: "Self-revive is on cooldown. Try again in %time%s."
+selfrevive_combat_block: "You were hit too recently. Wait %time%s before using self-revive."
+selfrevive_missing_items: "You need %amount%x %item% to self-revive."
+selfrevive_start: "Reviving yourself... Hold still!"
+selfrevive_progress_bar: "Self-reviving %bar% %pct%%"
+selfrevive_cancelled: "Self-revive cancelled."
+selfrevive_success: "You revived yourself. Stay safe."
+selfrevive_not_channeling: "You are not currently reviving yourself."
+cmd_help_selfrevive: "Revive yourself using items (K.O. only)"
+cmd_help_cancelselfrevive: "Cancel a self-revive in progress"
diff --git a/src/main/resources/lang/fr.yml b/src/main/resources/lang/fr.yml
index c97b076..65f28cc 100644
--- a/src/main/resources/lang/fr.yml
+++ b/src/main/resources/lang/fr.yml
@@ -170,3 +170,93 @@ npc_summon_cooldown: "Vous devez attendre %time% secondes avant d'invoquer à no
 npc_max_summons: "Vous avez atteint le nombre maximum d'invocations (%max%)."
 npc_summon_failed: "Échec de l'invocation du NPC. Réessayez."
 npc_status_header: "NPCs actifs :"
+
+
+# ── Keys added in v1.2.13 (EN fallback — awaiting translation) ──
+option_mobs_attack_ko: "Mobs Attack KO'd Players"
+option_knockback_disabled: "Disable Knockback on KO"
+option_surrender_require_still: "Must Be Still to Surrender"
+revive_cancelled_moved: "Revival cancelled: you moved."
+distress_cooldown: "Distress signal on cooldown. %time%s remaining."
+distress_disabled: "Distress signals are disabled on this server."
+npc_no_healer_active: "You need an active Healer Golem to use this command."
+npc_already_reviving: "Someone is already being revived."
+npc_reviving_you: "%player%'s %type% is reviving you..."
+npc_being_revived_bar: "%type% reviving... %bar% %pct%%"
+npc_reviving_bar: "Reviving %player%... %bar% %pct%%"
+npc_protector_no_revive_warning: "Your %type% is focused on defense — it cannot revive you. A distress signal has been sent to your team."
+npc_summon_disabled: "The NPC Reanimator System is disabled on this server."
+npc_status_target: "→ Target: %player%"
+npc_healer_aura_active: "Your Healer is protecting you."
+npc_healer_scanning: "Your Healer detected a KO'd ally nearby."
+npc_protector_intercepted: "Your Protector absorbed incoming damage."
+npc_protector_knockback: "Your Protector repelled nearby threats."
+npc_low_hp: "%type% is critically low! ❤ %hp% HP remaining."
+npc_died: "Your %type% has been defeated."
+npc_expired: "%type% has expired and disappeared."
+npc_lifetime_remaining: "(%time%s remaining)"
+npc_time_extended: "NPC lifetime extended by %time% seconds."
+npc_extend_charged: "Charged %cost% for the extension."
+npc_extend_insufficient_funds: "You need %cost% to extend your NPC's lifetime."
+command_extend_usage: "Usage: /reanimatemc extend <seconds>"
+purge_complete: "Cleanup complete: removed %count% stale K.O. hologram(s) from all worlds."
+kolist_header: "Players in K.O."
+kolist_empty: "No players are currently K.O."
+npc_name_golem: "Iron Golem Reanimator"
+npc_name_healer: "Healing Golem"
+npc_name_protector: "Protective Golem"
+npc_summoned_for_you: "%player% summoned a %type% for you!"
+npc_team_summoned: "Summoned %type% for %count% team member(s)."
+npc_team_charged: "Charged %cost% for %count% summon(s)."
+npc_team_insufficient_funds: "You need %cost% to summon for %count% player(s)."
+command_summon_team_usage: "Usage: /rmc summon team <golem|healer|protector> <player1> <player2> ..."
+cmd_help_title: "Commands"
+cmd_help_reload: "Reload config and language files"
+cmd_help_revive: "Start a timed revive via your Healer NPC"
+cmd_help_knockout: "Force a player into K.O."
+cmd_help_status: "Check a player's K.O. status"
+cmd_help_distress: "Send a distress signal while K.O.'d"
+cmd_help_crawl: "Toggle crawl mode while K.O.'d"
+cmd_help_config: "Open the configuration GUI"
+cmd_help_summon: "Summon a Reanimator NPC (optional: for another player)"
+cmd_help_summon_team: "Summon an NPC for multiple team members"
+cmd_help_dismiss: "Dismiss your active NPC(s)"
+cmd_help_extend: "Extend active NPC lifetime"
+cmd_help_npcs: "Show your active NPCs status"
+cmd_help_purge: "Remove stale K.O. holograms from all worlds"
+cmd_help_kolist: "List K.O.'d players and time remaining"
+cmd_help_info: "Show plugin status and integration info"
+cmd_help_version: "Show plugin version"
+cmd_arg_player: "player"
+cmd_arg_seconds: "seconds"
+cmd_version_plugin: "Plugin:"
+cmd_version_author: "Author:"
+cmd_version_mc: "Minecraft:"
+cmd_version_api: "API:"
+cmd_info_version: "Version:"
+cmd_info_active: "active"
+cmd_info_inactive: "inactive"
+cmd_info_enabled: "enabled"
+cmd_info_disabled: "disabled"
+cmd_info_npc: "NPC System:"
+cmd_info_ko_count: "Players K.O.:"
+cmd_info_hint: "Commands:"
+option_crawl_nausea_enabled: "Crawl Nausea Effect"
+option_crawl_nausea_level: "Crawl Nausea Level"
+option_npc_enabled: "NPC Reanimator System"
+option_npc_invulnerable: "NPC Invulnerable Mode"
+option_npc_damage_transfer: "Protector Damage Transfer"
+option_npc_protector_revive: "Protector Revives (No Healer)"
+selfrevive_disabled: "Self-revive is disabled on this server."
+selfrevive_already_channeling: "You are already reviving yourself."
+selfrevive_max_uses: "You have reached the self-revive limit for this K.O. session (%max% use(s))."
+selfrevive_cooldown: "Self-revive is on cooldown. Try again in %time%s."
+selfrevive_combat_block: "You were hit too recently. Wait %time%s before using self-revive."
+selfrevive_missing_items: "You need %amount%x %item% to self-revive."
+selfrevive_start: "Reviving yourself... Hold still!"
+selfrevive_progress_bar: "Self-reviving %bar% %pct%%"
+selfrevive_cancelled: "Self-revive cancelled."
+selfrevive_success: "You revived yourself. Stay safe."
+selfrevive_not_channeling: "You are not currently reviving yourself."
+cmd_help_selfrevive: "Revive yourself using items (K.O. only)"
+cmd_help_cancelselfrevive: "Cancel a self-revive in progress"
diff --git a/src/main/resources/lang/it.yml b/src/main/resources/lang/it.yml
index c3bf1ae..5144a27 100644
--- a/src/main/resources/lang/it.yml
+++ b/src/main/resources/lang/it.yml
@@ -139,4 +139,123 @@ option_effect_resistance: "Durata resistenza"
 update_available: "Nuova versione disponibile:"
 update_log: "Nuova versione disponibile: %version% -> %url%"
 update_command_available: "Aggiornamento disponibile: %version% — %url%"
-update_up_to_date: "Sei aggiornato per la tua versione di Minecraft."
\ No newline at end of file
+update_up_to_date: "Sei aggiornato per la tua versione di Minecraft."
+
+# ── Keys added in v1.2.13 (EN fallback — awaiting translation) ──
+option_mobs_attack_ko: "Mobs Attack KO'd Players"
+option_knockback_disabled: "Disable Knockback on KO"
+option_surrender_require_still: "Must Be Still to Surrender"
+revive_cancelled_moved: "Revival cancelled: you moved."
+option_knockout_blindness: "Blindness On KO"
+option_tablist_enabled: "Tablist KO Tag"
+message_gui_toggle: "%option% is now %state%"
+stats_title: "Statistics"
+stats_ko: "KOs: %value%"
+stats_revive: "Revives: %value%"
+plugin_info: "Plugin Info"
+info_version: "Version: %value%"
+info_authors: "Authors: %value%"
+change_language: "Change Language"
+language_changed: "Language changed to %lang%"
+first_run_message: "Use /reanimatemc config to configure the plugin!"
+setup_complete: "Plugin configured! Thank you."
+distress_sent: "Distress signal sent!"
+distress_broadcast: "%player% needs help at %x%, %y%, %z%!"
+distress_cooldown: "Distress signal on cooldown. %time%s remaining."
+distress_disabled: "Distress signals are disabled on this server."
+npc_no_healer_active: "You need an active Healer Golem to use this command."
+npc_already_reviving: "Someone is already being revived."
+npc_reviving_you: "%player%'s %type% is reviving you..."
+npc_being_revived_bar: "%type% reviving... %bar% %pct%%"
+npc_reviving_bar: "Reviving %player%... %bar% %pct%%"
+npc_protector_no_revive_warning: "Your %type% is focused on defense — it cannot revive you. A distress signal has been sent to your team."
+command_summon_usage: "Usage: /reanimatemc summon <golem|healer|protector> [player]"
+command_dismiss_usage: "Usage: /reanimatemc dismiss <all>"
+command_player_only: "This command can only be executed by a player."
+npc_summoned: "%type% has been summoned!"
+npc_dismissed: "NPC dismissed successfully."
+npc_dismissed_all: "Dismissed %count% NPC(s)."
+npc_none_active: "You have no active NPCs."
+npc_not_found: "NPC not found."
+npc_not_owner: "You do not own this NPC."
+npc_invalid_type: "Invalid NPC type: %type%. Valid types: golem, healer, protector"
+npc_no_type_permission: "You do not have permission to summon %type%."
+npc_summon_disabled: "The NPC Reanimator System is disabled on this server."
+npc_summon_cooldown: "You must wait %time% seconds before summoning again."
+npc_max_summons: "You have reached the maximum number of summons (%max%)."
+npc_summon_failed: "Failed to summon NPC. Try again."
+npc_status_header: "Active NPCs:"
+npc_status_target: "→ Target: %player%"
+npc_healer_aura_active: "Your Healer is protecting you."
+npc_healer_scanning: "Your Healer detected a KO'd ally nearby."
+npc_protector_intercepted: "Your Protector absorbed incoming damage."
+npc_protector_knockback: "Your Protector repelled nearby threats."
+npc_low_hp: "%type% is critically low! ❤ %hp% HP remaining."
+npc_died: "Your %type% has been defeated."
+npc_expired: "%type% has expired and disappeared."
+npc_lifetime_remaining: "(%time%s remaining)"
+npc_time_extended: "NPC lifetime extended by %time% seconds."
+npc_extend_charged: "Charged %cost% for the extension."
+npc_extend_insufficient_funds: "You need %cost% to extend your NPC's lifetime."
+command_extend_usage: "Usage: /reanimatemc extend <seconds>"
+purge_complete: "Cleanup complete: removed %count% stale K.O. hologram(s) from all worlds."
+kolist_header: "Players in K.O."
+kolist_empty: "No players are currently K.O."
+npc_name_golem: "Iron Golem Reanimator"
+npc_name_healer: "Healing Golem"
+npc_name_protector: "Protective Golem"
+npc_summoned_for_you: "%player% summoned a %type% for you!"
+npc_team_summoned: "Summoned %type% for %count% team member(s)."
+npc_team_charged: "Charged %cost% for %count% summon(s)."
+npc_team_insufficient_funds: "You need %cost% to summon for %count% player(s)."
+command_summon_team_usage: "Usage: /rmc summon team <golem|healer|protector> <player1> <player2> ..."
+cmd_help_title: "Commands"
+cmd_help_reload: "Reload config and language files"
+cmd_help_revive: "Start a timed revive via your Healer NPC"
+cmd_help_knockout: "Force a player into K.O."
+cmd_help_status: "Check a player's K.O. status"
+cmd_help_distress: "Send a distress signal while K.O.'d"
+cmd_help_crawl: "Toggle crawl mode while K.O.'d"
+cmd_help_config: "Open the configuration GUI"
+cmd_help_summon: "Summon a Reanimator NPC (optional: for another player)"
+cmd_help_summon_team: "Summon an NPC for multiple team members"
+cmd_help_dismiss: "Dismiss your active NPC(s)"
+cmd_help_extend: "Extend active NPC lifetime"
+cmd_help_npcs: "Show your active NPCs status"
+cmd_help_purge: "Remove stale K.O. holograms from all worlds"
+cmd_help_kolist: "List K.O.'d players and time remaining"
+cmd_help_info: "Show plugin status and integration info"
+cmd_help_version: "Show plugin version"
+cmd_arg_player: "player"
+cmd_arg_seconds: "seconds"
+cmd_version_plugin: "Plugin:"
+cmd_version_author: "Author:"
+cmd_version_mc: "Minecraft:"
+cmd_version_api: "API:"
+cmd_info_version: "Version:"
+cmd_info_active: "active"
+cmd_info_inactive: "inactive"
+cmd_info_enabled: "enabled"
+cmd_info_disabled: "disabled"
+cmd_info_npc: "NPC System:"
+cmd_info_ko_count: "Players K.O.:"
+cmd_info_hint: "Commands:"
+option_crawl_nausea_enabled: "Crawl Nausea Effect"
+option_crawl_nausea_level: "Crawl Nausea Level"
+option_npc_enabled: "NPC Reanimator System"
+option_npc_invulnerable: "NPC Invulnerable Mode"
+option_npc_damage_transfer: "Protector Damage Transfer"
+option_npc_protector_revive: "Protector Revives (No Healer)"
+selfrevive_disabled: "Self-revive is disabled on this server."
+selfrevive_already_channeling: "You are already reviving yourself."
+selfrevive_max_uses: "You have reached the self-revive limit for this K.O. session (%max% use(s))."
+selfrevive_cooldown: "Self-revive is on cooldown. Try again in %time%s."
+selfrevive_combat_block: "You were hit too recently. Wait %time%s before using self-revive."
+selfrevive_missing_items: "You need %amount%x %item% to self-revive."
+selfrevive_start: "Reviving yourself... Hold still!"
+selfrevive_progress_bar: "Self-reviving %bar% %pct%%"
+selfrevive_cancelled: "Self-revive cancelled."
+selfrevive_success: "You revived yourself. Stay safe."
+selfrevive_not_channeling: "You are not currently reviving yourself."
+cmd_help_selfrevive: "Revive yourself using items (K.O. only)"
+cmd_help_cancelselfrevive: "Cancel a self-revive in progress"
diff --git a/src/main/resources/lang/kr.yml b/src/main/resources/lang/kr.yml
index 8c066c0..7c55ddd 100644
--- a/src/main/resources/lang/kr.yml
+++ b/src/main/resources/lang/kr.yml
@@ -155,3 +155,111 @@ update_available: "새 버전 사용 가능:"
 update_log: "새 버전 사용 가능: %version% -> %url%"
 update_command_available: "업데이트 사용 가능: %version% — %url%"
 update_up_to_date: "현재 마인크래프트 버전에 대해 최신 상태입니다."
+
+
+# ── Keys added in v1.2.13 (EN fallback — awaiting translation) ──
+option_mobs_attack_ko: "Mobs Attack KO'd Players"
+option_knockback_disabled: "Disable Knockback on KO"
+option_surrender_require_still: "Must Be Still to Surrender"
+revive_cancelled_moved: "Revival cancelled: you moved."
+setup_complete: "Plugin configured! Thank you."
+distress_sent: "Distress signal sent!"
+distress_broadcast: "%player% needs help at %x%, %y%, %z%!"
+distress_cooldown: "Distress signal on cooldown. %time%s remaining."
+distress_disabled: "Distress signals are disabled on this server."
+npc_no_healer_active: "You need an active Healer Golem to use this command."
+npc_already_reviving: "Someone is already being revived."
+npc_reviving_you: "%player%'s %type% is reviving you..."
+npc_being_revived_bar: "%type% reviving... %bar% %pct%%"
+npc_reviving_bar: "Reviving %player%... %bar% %pct%%"
+npc_protector_no_revive_warning: "Your %type% is focused on defense — it cannot revive you. A distress signal has been sent to your team."
+command_summon_usage: "Usage: /reanimatemc summon <golem|healer|protector> [player]"
+command_dismiss_usage: "Usage: /reanimatemc dismiss <all>"
+command_player_only: "This command can only be executed by a player."
+npc_summoned: "%type% has been summoned!"
+npc_dismissed: "NPC dismissed successfully."
+npc_dismissed_all: "Dismissed %count% NPC(s)."
+npc_none_active: "You have no active NPCs."
+npc_not_found: "NPC not found."
+npc_not_owner: "You do not own this NPC."
+npc_invalid_type: "Invalid NPC type: %type%. Valid types: golem, healer, protector"
+npc_no_type_permission: "You do not have permission to summon %type%."
+npc_summon_disabled: "The NPC Reanimator System is disabled on this server."
+npc_summon_cooldown: "You must wait %time% seconds before summoning again."
+npc_max_summons: "You have reached the maximum number of summons (%max%)."
+npc_summon_failed: "Failed to summon NPC. Try again."
+npc_status_header: "Active NPCs:"
+npc_status_target: "→ Target: %player%"
+npc_healer_aura_active: "Your Healer is protecting you."
+npc_healer_scanning: "Your Healer detected a KO'd ally nearby."
+npc_protector_intercepted: "Your Protector absorbed incoming damage."
+npc_protector_knockback: "Your Protector repelled nearby threats."
+npc_low_hp: "%type% is critically low! ❤ %hp% HP remaining."
+npc_died: "Your %type% has been defeated."
+npc_expired: "%type% has expired and disappeared."
+npc_lifetime_remaining: "(%time%s remaining)"
+npc_time_extended: "NPC lifetime extended by %time% seconds."
+npc_extend_charged: "Charged %cost% for the extension."
+npc_extend_insufficient_funds: "You need %cost% to extend your NPC's lifetime."
+command_extend_usage: "Usage: /reanimatemc extend <seconds>"
+purge_complete: "Cleanup complete: removed %count% stale K.O. hologram(s) from all worlds."
+kolist_header: "Players in K.O."
+kolist_empty: "No players are currently K.O."
+npc_name_golem: "Iron Golem Reanimator"
+npc_name_healer: "Healing Golem"
+npc_name_protector: "Protective Golem"
+npc_summoned_for_you: "%player% summoned a %type% for you!"
+npc_team_summoned: "Summoned %type% for %count% team member(s)."
+npc_team_charged: "Charged %cost% for %count% summon(s)."
+npc_team_insufficient_funds: "You need %cost% to summon for %count% player(s)."
+command_summon_team_usage: "Usage: /rmc summon team <golem|healer|protector> <player1> <player2> ..."
+cmd_help_title: "Commands"
+cmd_help_reload: "Reload config and language files"
+cmd_help_revive: "Start a timed revive via your Healer NPC"
+cmd_help_knockout: "Force a player into K.O."
+cmd_help_status: "Check a player's K.O. status"
+cmd_help_distress: "Send a distress signal while K.O.'d"
+cmd_help_crawl: "Toggle crawl mode while K.O.'d"
+cmd_help_config: "Open the configuration GUI"
+cmd_help_summon: "Summon a Reanimator NPC (optional: for another player)"
+cmd_help_summon_team: "Summon an NPC for multiple team members"
+cmd_help_dismiss: "Dismiss your active NPC(s)"
+cmd_help_extend: "Extend active NPC lifetime"
+cmd_help_npcs: "Show your active NPCs status"
+cmd_help_purge: "Remove stale K.O. holograms from all worlds"
+cmd_help_kolist: "List K.O.'d players and time remaining"
+cmd_help_info: "Show plugin status and integration info"
+cmd_help_version: "Show plugin version"
+cmd_arg_player: "player"
+cmd_arg_seconds: "seconds"
+cmd_version_plugin: "Plugin:"
+cmd_version_author: "Author:"
+cmd_version_mc: "Minecraft:"
+cmd_version_api: "API:"
+cmd_info_version: "Version:"
+cmd_info_active: "active"
+cmd_info_inactive: "inactive"
+cmd_info_enabled: "enabled"
+cmd_info_disabled: "disabled"
+cmd_info_npc: "NPC System:"
+cmd_info_ko_count: "Players K.O.:"
+cmd_info_hint: "Commands:"
+option_crawl_nausea_enabled: "Crawl Nausea Effect"
+option_crawl_nausea_level: "Crawl Nausea Level"
+option_npc_enabled: "NPC Reanimator System"
+option_npc_invulnerable: "NPC Invulnerable Mode"
+option_npc_damage_transfer: "Protector Damage Transfer"
+option_npc_protector_revive: "Protector Revives (No Healer)"
+selfrevive_disabled: "Self-revive is disabled on this server."
+selfrevive_already_channeling: "You are already reviving yourself."
+selfrevive_max_uses: "You have reached the self-revive limit for this K.O. session (%max% use(s))."
+selfrevive_cooldown: "Self-revive is on cooldown. Try again in %time%s."
+selfrevive_combat_block: "You were hit too recently. Wait %time%s before using self-revive."
+selfrevive_missing_items: "You need %amount%x %item% to self-revive."
+selfrevive_start: "Reviving yourself... Hold still!"
+selfrevive_progress_bar: "Self-reviving %bar% %pct%%"
+selfrevive_cancelled: "Self-revive cancelled."
+selfrevive_success: "You revived yourself. Stay safe."
+selfrevive_not_channeling: "You are not currently reviving yourself."
+cmd_help_selfrevive: "Revive yourself using items (K.O. only)"
+cmd_help_cancelselfrevive: "Cancel a self-revive in progress"
diff --git a/src/main/resources/lang/pt.yml b/src/main/resources/lang/pt.yml
index 25fc7dd..86bf178 100644
--- a/src/main/resources/lang/pt.yml
+++ b/src/main/resources/lang/pt.yml
@@ -140,3 +140,123 @@ update_available: "Nova versão disponível:"
 update_log: "Nova versão disponível: %version% -> %url%"
 update_command_available: "Atualização disponível: %version% — %url%"
 update_up_to_date: "Você está atualizado para sua versão do Minecraft."
+
+
+# ── Keys added in v1.2.13 (EN fallback — awaiting translation) ──
+option_mobs_attack_ko: "Mobs Attack KO'd Players"
+option_knockback_disabled: "Disable Knockback on KO"
+option_surrender_require_still: "Must Be Still to Surrender"
+revive_cancelled_moved: "Revival cancelled: you moved."
+option_knockout_blindness: "Blindness On KO"
+option_tablist_enabled: "Tablist KO Tag"
+message_gui_toggle: "%option% is now %state%"
+stats_title: "Statistics"
+stats_ko: "KOs: %value%"
+stats_revive: "Revives: %value%"
+plugin_info: "Plugin Info"
+info_version: "Version: %value%"
+info_authors: "Authors: %value%"
+change_language: "Change Language"
+language_changed: "Language changed to %lang%"
+first_run_message: "Use /reanimatemc config to configure the plugin!"
+setup_complete: "Plugin configured! Thank you."
+distress_sent: "Distress signal sent!"
+distress_broadcast: "%player% needs help at %x%, %y%, %z%!"
+distress_cooldown: "Distress signal on cooldown. %time%s remaining."
+distress_disabled: "Distress signals are disabled on this server."
+npc_no_healer_active: "You need an active Healer Golem to use this command."
+npc_already_reviving: "Someone is already being revived."
+npc_reviving_you: "%player%'s %type% is reviving you..."
+npc_being_revived_bar: "%type% reviving... %bar% %pct%%"
+npc_reviving_bar: "Reviving %player%... %bar% %pct%%"
+npc_protector_no_revive_warning: "Your %type% is focused on defense — it cannot revive you. A distress signal has been sent to your team."
+command_summon_usage: "Usage: /reanimatemc summon <golem|healer|protector> [player]"
+command_dismiss_usage: "Usage: /reanimatemc dismiss <all>"
+command_player_only: "This command can only be executed by a player."
+npc_summoned: "%type% has been summoned!"
+npc_dismissed: "NPC dismissed successfully."
+npc_dismissed_all: "Dismissed %count% NPC(s)."
+npc_none_active: "You have no active NPCs."
+npc_not_found: "NPC not found."
+npc_not_owner: "You do not own this NPC."
+npc_invalid_type: "Invalid NPC type: %type%. Valid types: golem, healer, protector"
+npc_no_type_permission: "You do not have permission to summon %type%."
+npc_summon_disabled: "The NPC Reanimator System is disabled on this server."
+npc_summon_cooldown: "You must wait %time% seconds before summoning again."
+npc_max_summons: "You have reached the maximum number of summons (%max%)."
+npc_summon_failed: "Failed to summon NPC. Try again."
+npc_status_header: "Active NPCs:"
+npc_status_target: "→ Target: %player%"
+npc_healer_aura_active: "Your Healer is protecting you."
+npc_healer_scanning: "Your Healer detected a KO'd ally nearby."
+npc_protector_intercepted: "Your Protector absorbed incoming damage."
+npc_protector_knockback: "Your Protector repelled nearby threats."
+npc_low_hp: "%type% is critically low! ❤ %hp% HP remaining."
+npc_died: "Your %type% has been defeated."
+npc_expired: "%type% has expired and disappeared."
+npc_lifetime_remaining: "(%time%s remaining)"
+npc_time_extended: "NPC lifetime extended by %time% seconds."
+npc_extend_charged: "Charged %cost% for the extension."
+npc_extend_insufficient_funds: "You need %cost% to extend your NPC's lifetime."
+command_extend_usage: "Usage: /reanimatemc extend <seconds>"
+purge_complete: "Cleanup complete: removed %count% stale K.O. hologram(s) from all worlds."
+kolist_header: "Players in K.O."
+kolist_empty: "No players are currently K.O."
+npc_name_golem: "Iron Golem Reanimator"
+npc_name_healer: "Healing Golem"
+npc_name_protector: "Protective Golem"
+npc_summoned_for_you: "%player% summoned a %type% for you!"
+npc_team_summoned: "Summoned %type% for %count% team member(s)."
+npc_team_charged: "Charged %cost% for %count% summon(s)."
+npc_team_insufficient_funds: "You need %cost% to summon for %count% player(s)."
+command_summon_team_usage: "Usage: /rmc summon team <golem|healer|protector> <player1> <player2> ..."
+cmd_help_title: "Commands"
+cmd_help_reload: "Reload config and language files"
+cmd_help_revive: "Start a timed revive via your Healer NPC"
+cmd_help_knockout: "Force a player into K.O."
+cmd_help_status: "Check a player's K.O. status"
+cmd_help_distress: "Send a distress signal while K.O.'d"
+cmd_help_crawl: "Toggle crawl mode while K.O.'d"
+cmd_help_config: "Open the configuration GUI"
+cmd_help_summon: "Summon a Reanimator NPC (optional: for another player)"
+cmd_help_summon_team: "Summon an NPC for multiple team members"
+cmd_help_dismiss: "Dismiss your active NPC(s)"
+cmd_help_extend: "Extend active NPC lifetime"
+cmd_help_npcs: "Show your active NPCs status"
+cmd_help_purge: "Remove stale K.O. holograms from all worlds"
+cmd_help_kolist: "List K.O.'d players and time remaining"
+cmd_help_info: "Show plugin status and integration info"
+cmd_help_version: "Show plugin version"
+cmd_arg_player: "player"
+cmd_arg_seconds: "seconds"
+cmd_version_plugin: "Plugin:"
+cmd_version_author: "Author:"
+cmd_version_mc: "Minecraft:"
+cmd_version_api: "API:"
+cmd_info_version: "Version:"
+cmd_info_active: "active"
+cmd_info_inactive: "inactive"
+cmd_info_enabled: "enabled"
+cmd_info_disabled: "disabled"
+cmd_info_npc: "NPC System:"
+cmd_info_ko_count: "Players K.O.:"
+cmd_info_hint: "Commands:"
+option_crawl_nausea_enabled: "Crawl Nausea Effect"
+option_crawl_nausea_level: "Crawl Nausea Level"
+option_npc_enabled: "NPC Reanimator System"
+option_npc_invulnerable: "NPC Invulnerable Mode"
+option_npc_damage_transfer: "Protector Damage Transfer"
+option_npc_protector_revive: "Protector Revives (No Healer)"
+selfrevive_disabled: "Self-revive is disabled on this server."
+selfrevive_already_channeling: "You are already reviving yourself."
+selfrevive_max_uses: "You have reached the self-revive limit for this K.O. session (%max% use(s))."
+selfrevive_cooldown: "Self-revive is on cooldown. Try again in %time%s."
+selfrevive_combat_block: "You were hit too recently. Wait %time%s before using self-revive."
+selfrevive_missing_items: "You need %amount%x %item% to self-revive."
+selfrevive_start: "Reviving yourself... Hold still!"
+selfrevive_progress_bar: "Self-reviving %bar% %pct%%"
+selfrevive_cancelled: "Self-revive cancelled."
+selfrevive_success: "You revived yourself. Stay safe."
+selfrevive_not_channeling: "You are not currently reviving yourself."
+cmd_help_selfrevive: "Revive yourself using items (K.O. only)"
+cmd_help_cancelselfrevive: "Cancel a self-revive in progress"
diff --git a/src/main/resources/lang/ru.yml b/src/main/resources/lang/ru.yml
index 4a11bfa..bd97e91 100644
--- a/src/main/resources/lang/ru.yml
+++ b/src/main/resources/lang/ru.yml
@@ -150,4 +150,108 @@ option_effect_resistance: "Длительность сопротивления"
 update_available: "Доступна новая версия:"
 update_log: "Доступна новая версия: %version% -> %url%"
 update_command_available: "Доступно обновление: %version% — %url%"
-update_up_to_date: "Вы используете актуальную версию для вашей версии Minecraft."
\ No newline at end of file
+update_up_to_date: "Вы используете актуальную версию для вашей версии Minecraft."
+
+# ── Keys added in v1.2.13 (EN fallback — awaiting translation) ──
+option_mobs_attack_ko: "Mobs Attack KO'd Players"
+option_knockback_disabled: "Disable Knockback on KO"
+option_surrender_require_still: "Must Be Still to Surrender"
+revive_cancelled_moved: "Revival cancelled: you moved."
+distress_cooldown: "Distress signal on cooldown. %time%s remaining."
+distress_disabled: "Distress signals are disabled on this server."
+npc_no_healer_active: "You need an active Healer Golem to use this command."
+npc_already_reviving: "Someone is already being revived."
+npc_reviving_you: "%player%'s %type% is reviving you..."
+npc_being_revived_bar: "%type% reviving... %bar% %pct%%"
+npc_reviving_bar: "Reviving %player%... %bar% %pct%%"
+npc_protector_no_revive_warning: "Your %type% is focused on defense — it cannot revive you. A distress signal has been sent to your team."
+command_summon_usage: "Usage: /reanimatemc summon <golem|healer|protector> [player]"
+command_dismiss_usage: "Usage: /reanimatemc dismiss <all>"
+command_player_only: "This command can only be executed by a player."
+npc_summoned: "%type% has been summoned!"
+npc_dismissed: "NPC dismissed successfully."
+npc_dismissed_all: "Dismissed %count% NPC(s)."
+npc_none_active: "You have no active NPCs."
+npc_not_found: "NPC not found."
+npc_not_owner: "You do not own this NPC."
+npc_invalid_type: "Invalid NPC type: %type%. Valid types: golem, healer, protector"
+npc_no_type_permission: "You do not have permission to summon %type%."
+npc_summon_disabled: "The NPC Reanimator System is disabled on this server."
+npc_summon_cooldown: "You must wait %time% seconds before summoning again."
+npc_max_summons: "You have reached the maximum number of summons (%max%)."
+npc_summon_failed: "Failed to summon NPC. Try again."
+npc_status_header: "Active NPCs:"
+npc_status_target: "→ Target: %player%"
+npc_healer_aura_active: "Your Healer is protecting you."
+npc_healer_scanning: "Your Healer detected a KO'd ally nearby."
+npc_protector_intercepted: "Your Protector absorbed incoming damage."
+npc_protector_knockback: "Your Protector repelled nearby threats."
+npc_low_hp: "%type% is critically low! ❤ %hp% HP remaining."
+npc_died: "Your %type% has been defeated."
+npc_expired: "%type% has expired and disappeared."
+npc_lifetime_remaining: "(%time%s remaining)"
+npc_time_extended: "NPC lifetime extended by %time% seconds."
+npc_extend_charged: "Charged %cost% for the extension."
+npc_extend_insufficient_funds: "You need %cost% to extend your NPC's lifetime."
+command_extend_usage: "Usage: /reanimatemc extend <seconds>"
+purge_complete: "Cleanup complete: removed %count% stale K.O. hologram(s) from all worlds."
+kolist_header: "Players in K.O."
+kolist_empty: "No players are currently K.O."
+npc_name_golem: "Iron Golem Reanimator"
+npc_name_healer: "Healing Golem"
+npc_name_protector: "Protective Golem"
+npc_summoned_for_you: "%player% summoned a %type% for you!"
+npc_team_summoned: "Summoned %type% for %count% team member(s)."
+npc_team_charged: "Charged %cost% for %count% summon(s)."
+npc_team_insufficient_funds: "You need %cost% to summon for %count% player(s)."
+command_summon_team_usage: "Usage: /rmc summon team <golem|healer|protector> <player1> <player2> ..."
+cmd_help_title: "Commands"
+cmd_help_reload: "Reload config and language files"
+cmd_help_revive: "Start a timed revive via your Healer NPC"
+cmd_help_knockout: "Force a player into K.O."
+cmd_help_status: "Check a player's K.O. status"
+cmd_help_distress: "Send a distress signal while K.O.'d"
+cmd_help_crawl: "Toggle crawl mode while K.O.'d"
+cmd_help_config: "Open the configuration GUI"
+cmd_help_summon: "Summon a Reanimator NPC (optional: for another player)"
+cmd_help_summon_team: "Summon an NPC for multiple team members"
+cmd_help_dismiss: "Dismiss your active NPC(s)"
+cmd_help_extend: "Extend active NPC lifetime"
+cmd_help_npcs: "Show your active NPCs status"
+cmd_help_purge: "Remove stale K.O. holograms from all worlds"
+cmd_help_kolist: "List K.O.'d players and time remaining"
+cmd_help_info: "Show plugin status and integration info"
+cmd_help_version: "Show plugin version"
+cmd_arg_player: "player"
+cmd_arg_seconds: "seconds"
+cmd_version_plugin: "Plugin:"
+cmd_version_author: "Author:"
+cmd_version_mc: "Minecraft:"
+cmd_version_api: "API:"
+cmd_info_version: "Version:"
+cmd_info_active: "active"
+cmd_info_inactive: "inactive"
+cmd_info_enabled: "enabled"
+cmd_info_disabled: "disabled"
+cmd_info_npc: "NPC System:"
+cmd_info_ko_count: "Players K.O.:"
+cmd_info_hint: "Commands:"
+option_crawl_nausea_enabled: "Crawl Nausea Effect"
+option_crawl_nausea_level: "Crawl Nausea Level"
+option_npc_enabled: "NPC Reanimator System"
+option_npc_invulnerable: "NPC Invulnerable Mode"
+option_npc_damage_transfer: "Protector Damage Transfer"
+option_npc_protector_revive: "Protector Revives (No Healer)"
+selfrevive_disabled: "Self-revive is disabled on this server."
+selfrevive_already_channeling: "You are already reviving yourself."
+selfrevive_max_uses: "You have reached the self-revive limit for this K.O. session (%max% use(s))."
+selfrevive_cooldown: "Self-revive is on cooldown. Try again in %time%s."
+selfrevive_combat_block: "You were hit too recently. Wait %time%s before using self-revive."
+selfrevive_missing_items: "You need %amount%x %item% to self-revive."
+selfrevive_start: "Reviving yourself... Hold still!"
+selfrevive_progress_bar: "Self-reviving %bar% %pct%%"
+selfrevive_cancelled: "Self-revive cancelled."
+selfrevive_success: "You revived yourself. Stay safe."
+selfrevive_not_channeling: "You are not currently reviving yourself."
+cmd_help_selfrevive: "Revive yourself using items (K.O. only)"
+cmd_help_cancelselfrevive: "Cancel a self-revive in progress"
diff --git a/src/main/resources/lang/zh.yml b/src/main/resources/lang/zh.yml
index 51352a1..f4d3eab 100644
--- a/src/main/resources/lang/zh.yml
+++ b/src/main/resources/lang/zh.yml
@@ -150,4 +150,108 @@ option_effect_resistance: "抗性持续时间"
 update_available: "新版本可用："
 update_log: "新版本可用：%version% -> %url%"
 update_command_available: "更新可用：%version% — %url%"
-update_up_to_date: "你的 Minecraft 版本已是最新。"
\ No newline at end of file
+update_up_to_date: "你的 Minecraft 版本已是最新。"
+
+# ── Keys added in v1.2.13 (EN fallback — awaiting translation) ──
+option_mobs_attack_ko: "Mobs Attack KO'd Players"
+option_knockback_disabled: "Disable Knockback on KO"
+option_surrender_require_still: "Must Be Still to Surrender"
+revive_cancelled_moved: "Revival cancelled: you moved."
+distress_cooldown: "Distress signal on cooldown. %time%s remaining."
+distress_disabled: "Distress signals are disabled on this server."
+npc_no_healer_active: "You need an active Healer Golem to use this command."
+npc_already_reviving: "Someone is already being revived."
+npc_reviving_you: "%player%'s %type% is reviving you..."
+npc_being_revived_bar: "%type% reviving... %bar% %pct%%"
+npc_reviving_bar: "Reviving %player%... %bar% %pct%%"
+npc_protector_no_revive_warning: "Your %type% is focused on defense — it cannot revive you. A distress signal has been sent to your team."
+command_summon_usage: "Usage: /reanimatemc summon <golem|healer|protector> [player]"
+command_dismiss_usage: "Usage: /reanimatemc dismiss <all>"
+command_player_only: "This command can only be executed by a player."
+npc_summoned: "%type% has been summoned!"
+npc_dismissed: "NPC dismissed successfully."
+npc_dismissed_all: "Dismissed %count% NPC(s)."
+npc_none_active: "You have no active NPCs."
+npc_not_found: "NPC not found."
+npc_not_owner: "You do not own this NPC."
+npc_invalid_type: "Invalid NPC type: %type%. Valid types: golem, healer, protector"
+npc_no_type_permission: "You do not have permission to summon %type%."
+npc_summon_disabled: "The NPC Reanimator System is disabled on this server."
+npc_summon_cooldown: "You must wait %time% seconds before summoning again."
+npc_max_summons: "You have reached the maximum number of summons (%max%)."
+npc_summon_failed: "Failed to summon NPC. Try again."
+npc_status_header: "Active NPCs:"
+npc_status_target: "→ Target: %player%"
+npc_healer_aura_active: "Your Healer is protecting you."
+npc_healer_scanning: "Your Healer detected a KO'd ally nearby."
+npc_protector_intercepted: "Your Protector absorbed incoming damage."
+npc_protector_knockback: "Your Protector repelled nearby threats."
+npc_low_hp: "%type% is critically low! ❤ %hp% HP remaining."
+npc_died: "Your %type% has been defeated."
+npc_expired: "%type% has expired and disappeared."
+npc_lifetime_remaining: "(%time%s remaining)"
+npc_time_extended: "NPC lifetime extended by %time% seconds."
+npc_extend_charged: "Charged %cost% for the extension."
+npc_extend_insufficient_funds: "You need %cost% to extend your NPC's lifetime."
+command_extend_usage: "Usage: /reanimatemc extend <seconds>"
+purge_complete: "Cleanup complete: removed %count% stale K.O. hologram(s) from all worlds."
+kolist_header: "Players in K.O."
+kolist_empty: "No players are currently K.O."
+npc_name_golem: "Iron Golem Reanimator"
+npc_name_healer: "Healing Golem"
+npc_name_protector: "Protective Golem"
+npc_summoned_for_you: "%player% summoned a %type% for you!"
+npc_team_summoned: "Summoned %type% for %count% team member(s)."
+npc_team_charged: "Charged %cost% for %count% summon(s)."
+npc_team_insufficient_funds: "You need %cost% to summon for %count% player(s)."
+command_summon_team_usage: "Usage: /rmc summon team <golem|healer|protector> <player1> <player2> ..."
+cmd_help_title: "Commands"
+cmd_help_reload: "Reload config and language files"
+cmd_help_revive: "Start a timed revive via your Healer NPC"
+cmd_help_knockout: "Force a player into K.O."
+cmd_help_status: "Check a player's K.O. status"
+cmd_help_distress: "Send a distress signal while K.O.'d"
+cmd_help_crawl: "Toggle crawl mode while K.O.'d"
+cmd_help_config: "Open the configuration GUI"
+cmd_help_summon: "Summon a Reanimator NPC (optional: for another player)"
+cmd_help_summon_team: "Summon an NPC for multiple team members"
+cmd_help_dismiss: "Dismiss your active NPC(s)"
+cmd_help_extend: "Extend active NPC lifetime"
+cmd_help_npcs: "Show your active NPCs status"
+cmd_help_purge: "Remove stale K.O. holograms from all worlds"
+cmd_help_kolist: "List K.O.'d players and time remaining"
+cmd_help_info: "Show plugin status and integration info"
+cmd_help_version: "Show plugin version"
+cmd_arg_player: "player"
+cmd_arg_seconds: "seconds"
+cmd_version_plugin: "Plugin:"
+cmd_version_author: "Author:"
+cmd_version_mc: "Minecraft:"
+cmd_version_api: "API:"
+cmd_info_version: "Version:"
+cmd_info_active: "active"
+cmd_info_inactive: "inactive"
+cmd_info_enabled: "enabled"
+cmd_info_disabled: "disabled"
+cmd_info_npc: "NPC System:"
+cmd_info_ko_count: "Players K.O.:"
+cmd_info_hint: "Commands:"
+option_crawl_nausea_enabled: "Crawl Nausea Effect"
+option_crawl_nausea_level: "Crawl Nausea Level"
+option_npc_enabled: "NPC Reanimator System"
+option_npc_invulnerable: "NPC Invulnerable Mode"
+option_npc_damage_transfer: "Protector Damage Transfer"
+option_npc_protector_revive: "Protector Revives (No Healer)"
+selfrevive_disabled: "Self-revive is disabled on this server."
+selfrevive_already_channeling: "You are already reviving yourself."
+selfrevive_max_uses: "You have reached the self-revive limit for this K.O. session (%max% use(s))."
+selfrevive_cooldown: "Self-revive is on cooldown. Try again in %time%s."
+selfrevive_combat_block: "You were hit too recently. Wait %time%s before using self-revive."
+selfrevive_missing_items: "You need %amount%x %item% to self-revive."
+selfrevive_start: "Reviving yourself... Hold still!"
+selfrevive_progress_bar: "Self-reviving %bar% %pct%%"
+selfrevive_cancelled: "Self-revive cancelled."
+selfrevive_success: "You revived yourself. Stay safe."
+selfrevive_not_channeling: "You are not currently reviving yourself."
+cmd_help_selfrevive: "Revive yourself using items (K.O. only)"
+cmd_help_cancelselfrevive: "Cancel a self-revive in progress"

From 472fcb62e599b8a8f1f922d7d9d412f41ec42e0e Mon Sep 17 00:00:00 2001
From: Angel Ramirez <angel-krak@hotmail.com>
Date: Mon, 29 Jun 2026 14:26:04 -0600
Subject: [PATCH 3/3] fix(PlayerKOListener): remove extra closing brace in
 onPlayerMove else block

---
 .../java/fr/jachou/reanimatemc/listeners/PlayerKOListener.java   | 1 -
 1 file changed, 1 deletion(-)

diff --git a/src/main/java/fr/jachou/reanimatemc/listeners/PlayerKOListener.java b/src/main/java/fr/jachou/reanimatemc/listeners/PlayerKOListener.java
index fe3c590..c3a0e7c 100644
--- a/src/main/java/fr/jachou/reanimatemc/listeners/PlayerKOListener.java
+++ b/src/main/java/fr/jachou/reanimatemc/listeners/PlayerKOListener.java
@@ -218,7 +218,6 @@ public void onPlayerMove(PlayerMoveEvent event) {
                             .getBoolean("self_revive.cancel_on_move", true)) {
                 koManager.cancelSelfRevive(player, true);
             }
-            }
         }
     }