From 90c7ecd1d8d698e80337f8a621868bfdddbf8eec Mon Sep 17 00:00:00 2001
From: ez-plugins <ezplugins@outlook.com>
Date: Wed, 8 Jul 2026 06:53:19 +0200
Subject: [PATCH 1/4] fix: dep conflicts

---
 pom.xml | 112 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 112 insertions(+)

diff --git a/pom.xml b/pom.xml
index 9a91610..8093770 100644
--- a/pom.xml
+++ b/pom.xml
@@ -64,6 +64,24 @@
             <artifactId>paper-api</artifactId>
             <version>${paper.version}</version>
             <scope>provided</scope>
+            <exclusions>
+                <exclusion>
+                    <groupId>com.google.code.gson</groupId>
+                    <artifactId>gson</artifactId>
+                </exclusion>
+                <exclusion>
+                    <groupId>org.apache.commons</groupId>
+                    <artifactId>commons-lang3</artifactId>
+                </exclusion>
+                <exclusion>
+                    <groupId>org.slf4j</groupId>
+                    <artifactId>slf4j-api</artifactId>
+                </exclusion>
+                <exclusion>
+                    <groupId>org.jetbrains</groupId>
+                    <artifactId>annotations</artifactId>
+                </exclusion>
+            </exclusions>
         </dependency>
         <!-- Note: `paper-api` is declared with `provided` scope above; do not duplicate it here -->
         <dependency>
@@ -77,6 +95,28 @@
             <artifactId>worldguard-bukkit</artifactId>
             <version>${worldguard.version}</version>
             <scope>provided</scope>
+            <exclusions>
+                <exclusion>
+                    <groupId>it.unimi.dsi</groupId>
+                    <artifactId>fastutil</artifactId>
+                </exclusion>
+                <exclusion>
+                    <groupId>org.yaml</groupId>
+                    <artifactId>snakeyaml</artifactId>
+                </exclusion>
+                <exclusion>
+                    <groupId>com.google.guava</groupId>
+                    <artifactId>guava</artifactId>
+                </exclusion>
+                <exclusion>
+                    <groupId>com.google.code.gson</groupId>
+                    <artifactId>gson</artifactId>
+                </exclusion>
+                <exclusion>
+                    <groupId>org.bstats</groupId>
+                    <artifactId>bstats-bukkit</artifactId>
+                </exclusion>
+            </exclusions>
         </dependency>
         <!-- Kyori Adventure API (MiniMessage) — shaded into the plugin JAR and
              relocated to an internal package so it works on both Paper (which
@@ -137,12 +177,48 @@
             <artifactId>ezcountdown</artifactId>
             <version>2.0.1</version>
             <scope>provided</scope>
+            <exclusions>
+                <exclusion>
+                    <groupId>io.papermc.paper</groupId>
+                    <artifactId>paper-api</artifactId>
+                </exclusion>
+                <exclusion>
+                    <groupId>net.kyori</groupId>
+                    <artifactId>adventure-api</artifactId>
+                </exclusion>
+                <exclusion>
+                    <groupId>net.kyori</groupId>
+                    <artifactId>adventure-key</artifactId>
+                </exclusion>
+                <exclusion>
+                    <groupId>net.kyori</groupId>
+                    <artifactId>adventure-text-minimessage</artifactId>
+                </exclusion>
+                <exclusion>
+                    <groupId>net.kyori</groupId>
+                    <artifactId>adventure-text-serializer-legacy</artifactId>
+                </exclusion>
+                <exclusion>
+                    <groupId>org.bstats</groupId>
+                    <artifactId>bstats-bukkit</artifactId>
+                </exclusion>
+                <exclusion>
+                    <groupId>org.bstats</groupId>
+                    <artifactId>bstats-base</artifactId>
+                </exclusion>
+            </exclusions>
         </dependency>
         <dependency>
             <groupId>com.github.NEZNAMY</groupId>
             <artifactId>TAB-API</artifactId>
             <version>5.5.0</version>
             <scope>provided</scope>
+            <exclusions>
+                <exclusion>
+                    <groupId>org.jetbrains</groupId>
+                    <artifactId>annotations</artifactId>
+                </exclusion>
+            </exclusions>
         </dependency>
         <dependency>
             <groupId>com.github.MilkBowl</groupId>
@@ -155,6 +231,32 @@
             <artifactId>placeholderapi</artifactId>
             <version>2.11.5</version>
             <scope>provided</scope>
+            <exclusions>
+                <exclusion>
+                    <groupId>org.jetbrains</groupId>
+                    <artifactId>annotations</artifactId>
+                </exclusion>
+                <exclusion>
+                    <groupId>org.bstats</groupId>
+                    <artifactId>bstats-bukkit</artifactId>
+                </exclusion>
+                <exclusion>
+                    <groupId>org.bstats</groupId>
+                    <artifactId>bstats-base</artifactId>
+                </exclusion>
+                <exclusion>
+                    <groupId>net.kyori</groupId>
+                    <artifactId>adventure-api</artifactId>
+                </exclusion>
+                <exclusion>
+                    <groupId>net.kyori</groupId>
+                    <artifactId>adventure-text-serializer-legacy</artifactId>
+                </exclusion>
+                <exclusion>
+                    <groupId>net.kyori</groupId>
+                    <artifactId>adventure-text-serializer-gson</artifactId>
+                </exclusion>
+            </exclusions>
         </dependency>
         <dependency>
             <groupId>com.github.EzFramework</groupId>
@@ -167,6 +269,16 @@
             <artifactId>jaker</artifactId>
             <version>1.0.6</version>
             <scope>test</scope>
+            <exclusions>
+                <exclusion>
+                    <groupId>org.yaml</groupId>
+                    <artifactId>snakeyaml</artifactId>
+                </exclusion>
+                <exclusion>
+                    <groupId>org.apache.commons</groupId>
+                    <artifactId>commons-lang3</artifactId>
+                </exclusion>
+            </exclusions>
         </dependency>
         <dependency>
             <groupId>com.github.EzFramework.Jaker</groupId>

From ef1229f1199021477470802765daa55d9ab13691 Mon Sep 17 00:00:00 2001
From: ez-plugins <ezplugins@outlook.com>
Date: Wed, 8 Jul 2026 07:25:14 +0200
Subject: [PATCH 2/4] fix: dep conflicts

---
 pom.xml | 55 +++++++++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 55 insertions(+)

diff --git a/pom.xml b/pom.xml
index 8093770..154be33 100644
--- a/pom.xml
+++ b/pom.xml
@@ -15,6 +15,9 @@
         <paper.version>26.1.2.build.57-stable</paper.version>
         <bstats.version>3.1.0</bstats.version>
         <worldguard.version>7.0.13</worldguard.version>
+        <jetbrains.annotations.version>26.0.2-1</jetbrains.annotations.version>
+        <errorprone.annotations.version>2.41.0</errorprone.annotations.version>
+        <log4j.api.version>2.25.2</log4j.api.version>
         <maven.compiler.plugin.version>3.15.0</maven.compiler.plugin.version>
         <maven.shade.plugin.version>3.6.2</maven.shade.plugin.version>
         <jaloquent.version>1.3.2</jaloquent.version>
@@ -84,6 +87,42 @@
             </exclusions>
         </dependency>
         <!-- Note: `paper-api` is declared with `provided` scope above; do not duplicate it here -->
+        <dependency>
+            <groupId>com.google.code.gson</groupId>
+            <artifactId>gson</artifactId>
+            <version>2.11.0</version>
+            <scope>provided</scope>
+            <exclusions>
+                <exclusion>
+                    <groupId>com.google.errorprone</groupId>
+                    <artifactId>error_prone_annotations</artifactId>
+                </exclusion>
+            </exclusions>
+        </dependency>
+        <dependency>
+            <groupId>com.google.errorprone</groupId>
+            <artifactId>error_prone_annotations</artifactId>
+            <version>${errorprone.annotations.version}</version>
+            <scope>provided</scope>
+        </dependency>
+        <dependency>
+            <groupId>org.jetbrains</groupId>
+            <artifactId>annotations</artifactId>
+            <version>${jetbrains.annotations.version}</version>
+            <scope>provided</scope>
+        </dependency>
+        <dependency>
+            <groupId>org.apache.logging.log4j</groupId>
+            <artifactId>log4j-api</artifactId>
+            <version>${log4j.api.version}</version>
+            <scope>provided</scope>
+        </dependency>
+        <dependency>
+            <groupId>org.slf4j</groupId>
+            <artifactId>slf4j-api</artifactId>
+            <version>2.0.17</version>
+            <scope>provided</scope>
+        </dependency>
         <dependency>
             <groupId>org.bstats</groupId>
             <artifactId>bstats-bukkit</artifactId>
@@ -116,6 +155,10 @@
                     <groupId>org.bstats</groupId>
                     <artifactId>bstats-bukkit</artifactId>
                 </exclusion>
+                <exclusion>
+                    <groupId>org.apache.logging.log4j</groupId>
+                    <artifactId>log4j-api</artifactId>
+                </exclusion>
             </exclusions>
         </dependency>
         <!-- Kyori Adventure API (MiniMessage) — shaded into the plugin JAR and
@@ -148,11 +191,23 @@
             <groupId>net.kyori</groupId>
             <artifactId>examination-api</artifactId>
             <version>1.3.0</version>
+            <exclusions>
+                <exclusion>
+                    <groupId>org.jetbrains</groupId>
+                    <artifactId>annotations</artifactId>
+                </exclusion>
+            </exclusions>
         </dependency>
         <dependency>
             <groupId>net.kyori</groupId>
             <artifactId>examination-string</artifactId>
             <version>1.3.0</version>
+            <exclusions>
+                <exclusion>
+                    <groupId>org.jetbrains</groupId>
+                    <artifactId>annotations</artifactId>
+                </exclusion>
+            </exclusions>
         </dependency>
         <dependency>
             <groupId>javazoom</groupId>

From 6f4eb0293ef0b5832e673c68e27b92db5080e904 Mon Sep 17 00:00:00 2001
From: ez-plugins <ezplugins@outlook.com>
Date: Wed, 8 Jul 2026 10:22:16 +0200
Subject: [PATCH 3/4] ci: upload unit and feature coverage to Codecov

---
 .github/workflows/ci.yml                      |  24 +-
 .mvn/maven.config                             |   1 +
 pom.xml                                       |  20 +-
 .../compatibility/LoreUtilSmokeTest.java      |  94 ++--
 ...rapIntegrationRegistrationFeatureTest.java |  76 ++++
 .../feature/CommandCoverageFeatureTest.java   | 183 ++++++++
 .../CommandPermissionCoverageFeatureTest.java |  79 ++++
 .../GuiAndListenerCoverageFeatureTest.java    | 400 ++++++++++++++++++
 .../GuiInternalCoverageFeatureTest.java       |  94 ++++
 .../MoveListenerInternalCoverageTest.java     | 240 +++++++++++
 .../integration/EconomyIntegrationTest.java   |  84 ++++
 .../integration/IntegrationTestFixtures.java  |  38 ++
 .../integration/MetricsIntegrationTest.java   |  44 ++
 .../PlaceholderApiIntegrationTest.java        |  48 +++
 .../integration/WorldEditIntegrationTest.java |  55 +++
 .../ezafk/manager/IntegrationManagerTest.java | 105 +++++
 .../repository/AfkTimeModelCoreTest.java      |  22 +
 .../StorageFactoryAndSqlBackendsCoreTest.java | 113 +++++
 .../mysql/MySQLStorageTestcontainersTest.java |  74 ++++
 .../yaml/YamlDataStoreCoreTest.java           | 103 +++++
 .../repository/yaml/YamlStorageCoreTest.java  |  83 ++++
 21 files changed, 1941 insertions(+), 39 deletions(-)
 create mode 100644 .mvn/maven.config
 create mode 100644 src/test/java/com/gyvex/ezafk/feature/BootstrapIntegrationRegistrationFeatureTest.java
 create mode 100644 src/test/java/com/gyvex/ezafk/feature/CommandCoverageFeatureTest.java
 create mode 100644 src/test/java/com/gyvex/ezafk/feature/CommandPermissionCoverageFeatureTest.java
 create mode 100644 src/test/java/com/gyvex/ezafk/feature/GuiAndListenerCoverageFeatureTest.java
 create mode 100644 src/test/java/com/gyvex/ezafk/feature/GuiInternalCoverageFeatureTest.java
 create mode 100644 src/test/java/com/gyvex/ezafk/feature/MoveListenerInternalCoverageTest.java
 create mode 100644 src/test/java/com/gyvex/ezafk/integration/EconomyIntegrationTest.java
 create mode 100644 src/test/java/com/gyvex/ezafk/integration/IntegrationTestFixtures.java
 create mode 100644 src/test/java/com/gyvex/ezafk/integration/MetricsIntegrationTest.java
 create mode 100644 src/test/java/com/gyvex/ezafk/integration/PlaceholderApiIntegrationTest.java
 create mode 100644 src/test/java/com/gyvex/ezafk/integration/WorldEditIntegrationTest.java
 create mode 100644 src/test/java/com/gyvex/ezafk/manager/IntegrationManagerTest.java
 create mode 100644 src/test/java/com/gyvex/ezafk/repository/AfkTimeModelCoreTest.java
 create mode 100644 src/test/java/com/gyvex/ezafk/repository/StorageFactoryAndSqlBackendsCoreTest.java
 create mode 100644 src/test/java/com/gyvex/ezafk/repository/mysql/MySQLStorageTestcontainersTest.java
 create mode 100644 src/test/java/com/gyvex/ezafk/repository/yaml/YamlDataStoreCoreTest.java
 create mode 100644 src/test/java/com/gyvex/ezafk/repository/yaml/YamlStorageCoreTest.java

diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index e0bc7d3..1f9b41a 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -4,6 +4,10 @@ on:
   pull_request:
     branches: [ v2.x, v3.x ]
 
+permissions:
+  contents: read
+  id-token: write
+
 jobs:
   unit-tests:
     name: Unit tests
@@ -28,7 +32,15 @@ jobs:
           cd /tmp/MockBukkit && ./gradlew publishToMavenLocal -xtest -xjavadoc
 
       - name: Run unit tests
-        run: mvn -B -ntp -Dmockbukkit.version="$MOCKBUKKIT_VERSION" test
+        run: mvn -B -ntp -Dmockbukkit.version="$MOCKBUKKIT_VERSION" org.jacoco:jacoco-maven-plugin:0.8.14:prepare-agent test org.jacoco:jacoco-maven-plugin:0.8.14:report
+
+      - name: Upload unit test coverage to Codecov
+        uses: codecov/codecov-action@v5
+        with:
+          use_oidc: true
+          files: ./target/site/jacoco/jacoco.xml
+          flags: unit
+          name: unit-tests
 
   feature-tests:
     name: Feature tests
@@ -54,7 +66,15 @@ jobs:
           cd /tmp/MockBukkit && ./gradlew publishToMavenLocal -xtest -xjavadoc
 
       - name: Run feature tests
-        run: mvn -B -ntp -Pfeature-tests -Dtest=*FeatureTest -Dmockbukkit.version="$MOCKBUKKIT_VERSION" test
+        run: mvn -B -ntp -Pfeature-tests -Dtest=*FeatureTest -Dmockbukkit.version="$MOCKBUKKIT_VERSION" org.jacoco:jacoco-maven-plugin:0.8.14:prepare-agent test org.jacoco:jacoco-maven-plugin:0.8.14:report
+
+      - name: Upload feature test coverage to Codecov
+        uses: codecov/codecov-action@v5
+        with:
+          use_oidc: true
+          files: ./target/site/jacoco/jacoco.xml
+          flags: feature
+          name: feature-tests
 
   # ──────────────────────────────────────────────────────────────────────────
   # SMOKE TESTS — verify EzAfk loads without errors on each server platform.
diff --git a/.mvn/maven.config b/.mvn/maven.config
new file mode 100644
index 0000000..4961335
--- /dev/null
+++ b/.mvn/maven.config
@@ -0,0 +1 @@
+-Dmockbukkit.version=4.113.1
diff --git a/pom.xml b/pom.xml
index 154be33..ba8fe37 100644
--- a/pom.xml
+++ b/pom.xml
@@ -442,7 +442,7 @@
                 <version>3.5.5</version>
                 <configuration>
                     <useModulePath>false</useModulePath>
-                    <argLine>-Dnet.bytebuddy.experimental=true</argLine>
+                    <argLine>${argLine} -Dnet.bytebuddy.experimental=true</argLine>
                 </configuration>
             </plugin>
         </plugins>
@@ -481,6 +481,24 @@
                     <version>${mockbukkit.version}</version>
                     <scope>test</scope>
                 </dependency>
+                <dependency>
+                    <groupId>org.testcontainers</groupId>
+                    <artifactId>junit-jupiter</artifactId>
+                    <version>1.20.1</version>
+                    <scope>test</scope>
+                </dependency>
+                <dependency>
+                    <groupId>org.testcontainers</groupId>
+                    <artifactId>mysql</artifactId>
+                    <version>1.20.1</version>
+                    <scope>test</scope>
+                </dependency>
+                <dependency>
+                    <groupId>com.mysql</groupId>
+                    <artifactId>mysql-connector-j</artifactId>
+                    <version>9.0.0</version>
+                    <scope>test</scope>
+                </dependency>
             </dependencies>
         </profile>
     </profiles>
diff --git a/src/test/java/com/gyvex/ezafk/compatibility/LoreUtilSmokeTest.java b/src/test/java/com/gyvex/ezafk/compatibility/LoreUtilSmokeTest.java
index aa3740b..0a79e8d 100644
--- a/src/test/java/com/gyvex/ezafk/compatibility/LoreUtilSmokeTest.java
+++ b/src/test/java/com/gyvex/ezafk/compatibility/LoreUtilSmokeTest.java
@@ -1,13 +1,17 @@
 package com.gyvex.ezafk.compatibility;
 
+import org.bukkit.Material;
+import org.bukkit.inventory.ItemStack;
 import org.bukkit.inventory.meta.ItemMeta;
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
-import org.mockito.ArgumentCaptor;
+import org.mockbukkit.mockbukkit.MockBukkit;
+import org.mockbukkit.mockbukkit.ServerMock;
 
 import java.util.List;
 
 import static org.junit.jupiter.api.Assertions.*;
-import static org.mockito.Mockito.*;
 
 /**
  * Smoke tests for {@link LoreUtil}, verifying that:
@@ -18,27 +22,42 @@
  *   <li>Null / blank inputs are handled gracefully.</li>
  * </ul>
  *
- * These tests run without a live Bukkit server; {@link ItemMeta} is mocked with
- * Mockito and {@link org.bukkit.ChatColor#translateAlternateColorCodes} is pure
- * string manipulation that requires no server instance.
+ * These tests use a MockBukkit server to obtain real {@link ItemMeta} instances,
+ * which avoids JVM agent constraints around inline mocking on newer JDKs.
  */
-@SuppressWarnings("unchecked")
 class LoreUtilSmokeTest {
 
     // §c is the section-sign + 'c' color code for red (U+00A7 + 'c')
     private static final char SECTION = '\u00a7';
 
+    private ServerMock server;
+
+    @BeforeEach
+    void setUp() {
+        server = MockBukkit.mock();
+    }
+
+    @AfterEach
+    void tearDown() {
+        MockBukkit.unmock();
+    }
+
+    private static ItemMeta newMeta() {
+        ItemStack stack = new ItemStack(Material.STONE);
+        ItemMeta meta = stack.getItemMeta();
+        assertNotNull(meta);
+        return meta;
+    }
+
     // ── setLore ──────────────────────────────────────────────────────────────
 
     @Test
     void setLore_translates_legacy_amp_color_codes() {
-        ItemMeta meta = mock(ItemMeta.class);
+        ItemMeta meta = newMeta();
         LoreUtil.setLore(meta, List.of("&cRed line", "&aGreen line"), null, null);
 
-        ArgumentCaptor<List<String>> captor = ArgumentCaptor.forClass(List.class);
-        verify(meta).setLore(captor.capture());
-
-        List<String> lore = captor.getValue();
+        List<String> lore = meta.getLore();
+        assertNotNull(lore);
         assertEquals(2, lore.size());
         assertTrue(lore.get(0).startsWith(SECTION + "c"), "§c prefix expected for &c");
         assertTrue(lore.get(1).startsWith(SECTION + "a"), "§a prefix expected for &a");
@@ -46,76 +65,79 @@ void setLore_translates_legacy_amp_color_codes() {
 
     @Test
     void setLore_parses_minimessage_tags() {
-        ItemMeta meta = mock(ItemMeta.class);
+        ItemMeta meta = newMeta();
         LoreUtil.setLore(meta, List.of("<red>hello</red>"), null, null);
 
-        ArgumentCaptor<List<String>> captor = ArgumentCaptor.forClass(List.class);
-        verify(meta).setLore(captor.capture());
-
-        String line = captor.getValue().get(0);
+        List<String> lore = meta.getLore();
+        assertNotNull(lore);
+        String line = lore.get(0);
         // LegacyComponentSerializer should emit §c for <red>
         assertTrue(line.contains(SECTION + "c"), "expected §c from <red> tag, got: " + line);
     }
 
     @Test
     void setLore_handles_null_lore_list_without_interacting_with_meta() {
-        ItemMeta meta = mock(ItemMeta.class);
+        ItemMeta meta = newMeta();
+        meta.setLore(List.of("existing"));
         LoreUtil.setLore(meta, null, null, null);
-        verifyNoInteractions(meta);
+        assertEquals(List.of("existing"), meta.getLore());
     }
 
     @Test
     void setLore_handles_empty_lore_list_without_interacting_with_meta() {
-        ItemMeta meta = mock(ItemMeta.class);
+        ItemMeta meta = newMeta();
+        meta.setLore(List.of("existing"));
         LoreUtil.setLore(meta, List.of(), null, null);
-        verifyNoInteractions(meta);
+        assertEquals(List.of("existing"), meta.getLore());
     }
 
     @Test
     void setLore_preserves_plain_text_without_color_codes() {
-        ItemMeta meta = mock(ItemMeta.class);
+        ItemMeta meta = newMeta();
         LoreUtil.setLore(meta, List.of("Plain text line"), null, null);
 
-        ArgumentCaptor<List<String>> captor = ArgumentCaptor.forClass(List.class);
-        verify(meta).setLore(captor.capture());
-        assertEquals("Plain text line", captor.getValue().get(0));
+        List<String> lore = meta.getLore();
+        assertNotNull(lore);
+        assertEquals("Plain text line", lore.get(0));
     }
 
     // ── setDisplayName ───────────────────────────────────────────────────────
 
     @Test
     void setDisplayName_translates_legacy_amp_color_codes() {
-        ItemMeta meta = mock(ItemMeta.class);
+        ItemMeta meta = newMeta();
         LoreUtil.setDisplayName(meta, "&6Gold Name", null, null);
 
-        ArgumentCaptor<String> captor = ArgumentCaptor.forClass(String.class);
-        verify(meta).setDisplayName(captor.capture());
-        assertTrue(captor.getValue().startsWith(SECTION + "6"), "§6 prefix expected");
+        String displayName = meta.getDisplayName();
+        assertNotNull(displayName);
+        assertTrue(displayName.startsWith(SECTION + "6"), "§6 prefix expected");
     }
 
     @Test
     void setDisplayName_parses_minimessage_tags() {
-        ItemMeta meta = mock(ItemMeta.class);
+        ItemMeta meta = newMeta();
         LoreUtil.setDisplayName(meta, "<bold>Title</bold>", null, null);
 
-        ArgumentCaptor<String> captor = ArgumentCaptor.forClass(String.class);
-        verify(meta).setDisplayName(captor.capture());
+        String displayName = meta.getDisplayName();
+        assertNotNull(displayName);
         // §l is the bold code
-        assertTrue(captor.getValue().contains(SECTION + "l"), "§l expected for <bold>");
+        assertTrue(displayName.contains(SECTION + "l"), "§l expected for <bold>");
     }
 
     @Test
     void setDisplayName_handles_blank_without_interacting_with_meta() {
-        ItemMeta meta = mock(ItemMeta.class);
+        ItemMeta meta = newMeta();
+        meta.setDisplayName("existing");
         LoreUtil.setDisplayName(meta, "   ", null, null);
-        verifyNoInteractions(meta);
+        assertEquals("existing", meta.getDisplayName());
     }
 
     @Test
     void setDisplayName_handles_null_without_interacting_with_meta() {
-        ItemMeta meta = mock(ItemMeta.class);
+        ItemMeta meta = newMeta();
+        meta.setDisplayName("existing");
         LoreUtil.setDisplayName(meta, null, null, null);
-        verifyNoInteractions(meta);
+        assertEquals("existing", meta.getDisplayName());
     }
 
     // ── validateMiniMessage ──────────────────────────────────────────────────
diff --git a/src/test/java/com/gyvex/ezafk/feature/BootstrapIntegrationRegistrationFeatureTest.java b/src/test/java/com/gyvex/ezafk/feature/BootstrapIntegrationRegistrationFeatureTest.java
new file mode 100644
index 0000000..8059b08
--- /dev/null
+++ b/src/test/java/com/gyvex/ezafk/feature/BootstrapIntegrationRegistrationFeatureTest.java
@@ -0,0 +1,76 @@
+package com.gyvex.ezafk.feature;
+
+import com.gyvex.ezafk.EzAfk;
+import com.gyvex.ezafk.integration.Integration;
+import com.gyvex.ezafk.integration.VoiceChatIntegration;
+import com.gyvex.ezafk.manager.IntegrationManager;
+import com.gyvex.ezafk.integration.IntegrationTestFixtures;
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.mockbukkit.mockbukkit.MockBukkit;
+import org.mockbukkit.mockbukkit.ServerMock;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+class BootstrapIntegrationRegistrationFeatureTest {
+
+    private ServerMock server;
+
+    @BeforeEach
+    void setUp() {
+        IntegrationTestFixtures.clearIntegrationManagerState();
+    }
+
+    @AfterEach
+    void tearDown() {
+        if (MockBukkit.isMocked()) {
+            MockBukkit.unmock();
+        }
+        IntegrationTestFixtures.clearIntegrationManagerState();
+    }
+
+    @Test
+    void bootstrap_registers_core_integrations() {
+        server = MockBukkit.mock();
+        MockBukkit.load(EzAfk.class);
+
+        assertNotNull(IntegrationManager.getIntegration("metrics"));
+        assertNotNull(IntegrationManager.getIntegration("tab"));
+        assertNotNull(IntegrationManager.getIntegration("spigot"));
+        assertNotNull(IntegrationManager.getIntegration("economy"));
+        assertNotNull(IntegrationManager.getIntegration("placeholderapi"));
+    }
+
+    @Test
+    void voicechat_auto_does_not_register_when_plugin_is_absent() {
+        server = MockBukkit.mock();
+        assertNull(server.getPluginManager().getPlugin("voicechat"));
+
+        MockBukkit.load(EzAfk.class);
+
+        assertNull(IntegrationManager.getIntegration("voicechat"));
+    }
+
+    @Test
+    void voicechat_auto_registers_when_plugin_is_present() {
+        server = MockBukkit.mock();
+        MockBukkit.createMockPlugin("voicechat");
+
+        MockBukkit.load(EzAfk.class);
+
+        Integration integration = IntegrationManager.getIntegration("voicechat");
+        assertNotNull(integration);
+        assertInstanceOf(VoiceChatIntegration.class, integration);
+    }
+
+    @Test
+    void worldguard_registration_override_blocks_registration() {
+        IntegrationManager.setRegistrationAllowed("worldguard", false);
+
+        server = MockBukkit.mock();
+        MockBukkit.load(EzAfk.class);
+
+        assertNull(IntegrationManager.getIntegration("worldguard"));
+    }
+}
diff --git a/src/test/java/com/gyvex/ezafk/feature/CommandCoverageFeatureTest.java b/src/test/java/com/gyvex/ezafk/feature/CommandCoverageFeatureTest.java
new file mode 100644
index 0000000..4d19411
--- /dev/null
+++ b/src/test/java/com/gyvex/ezafk/feature/CommandCoverageFeatureTest.java
@@ -0,0 +1,183 @@
+package com.gyvex.ezafk.feature;
+
+import com.gyvex.ezafk.TestHelpers;
+import com.gyvex.ezafk.bootstrap.Registry;
+import com.gyvex.ezafk.command.AfkZoneCommand;
+import com.gyvex.ezafk.command.EzAfkCommand;
+import com.gyvex.ezafk.command.EzAfkTabCompleter;
+import com.gyvex.ezafk.manager.AfkTimeManager;
+import com.gyvex.ezafk.state.AfkState;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+import org.bukkit.plugin.java.JavaPlugin;
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+import static org.junit.jupiter.api.Assertions.assertDoesNotThrow;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+class CommandCoverageFeatureTest {
+
+    private org.mockbukkit.mockbukkit.ServerMock server;
+    private JavaPlugin plugin;
+    private com.gyvex.ezafk.EzAfk ezafk;
+
+    @BeforeEach
+    void setUp() {
+        server = TestHelpers.startServer();
+        plugin = TestHelpers.loadPlugin();
+        ezafk = (com.gyvex.ezafk.EzAfk) plugin;
+    }
+
+    @AfterEach
+    void tearDown() {
+        AfkState.clearBypass();
+        TestHelpers.stopServer();
+    }
+
+    @Test
+    void ezAfkCommand_exercises_error_and_usage_paths() {
+        EzAfkCommand cmd = new EzAfkCommand(ezafk);
+        CommandSender console = server.getConsoleSender();
+        Player player = server.addPlayer("CmdUser");
+
+        assertTrue(cmd.onCommand(console, null, "afk", new String[]{}));
+        assertTrue(cmd.onCommand(player, null, "afk", new String[]{"unknown"}));
+        assertTrue(cmd.onCommand(console, null, "afk", new String[]{"gui"}));
+        assertTrue(cmd.onCommand(player, null, "afk", new String[]{"toggle"}));
+        assertTrue(cmd.onCommand(console, null, "afk", new String[]{"toggle", "NoSuchPlayer"}));
+        assertTrue(cmd.onCommand(console, null, "afk", new String[]{"info"}));
+        assertTrue(cmd.onCommand(console, null, "afk", new String[]{"info", "NoSuchPlayer"}));
+        assertTrue(cmd.onCommand(console, null, "afk", new String[]{"time", "a", "b"}));
+        assertTrue(cmd.onCommand(console, null, "afk", new String[]{"bypass"}));
+        assertTrue(cmd.onCommand(console, null, "afk", new String[]{"zone", "list"}));
+        assertTrue(cmd.onCommand(console, null, "afkzone", new String[]{"list"}));
+    }
+
+    @Test
+    void ezAfkCommand_exercises_main_success_paths() {
+        EzAfkCommand cmd = new EzAfkCommand(ezafk);
+        CommandSender console = server.getConsoleSender();
+        Player target = server.addPlayer("TargetOne");
+        target.setOp(true);
+
+        assertTrue(cmd.onCommand(console, null, "afk", new String[]{"reload"}));
+        assertTrue(cmd.onCommand(target, null, "afk", new String[]{}));
+        assertTrue(cmd.onCommand(console, null, "afk", new String[]{"toggle", "TargetOne"}));
+        assertTrue(cmd.onCommand(console, null, "afk", new String[]{"time", "TargetOne"}));
+        assertTrue(cmd.onCommand(console, null, "afk", new String[]{"time", "reset", "TargetOne"}));
+        assertTrue(cmd.onCommand(console, null, "afk", new String[]{"top"}));
+        assertTrue(cmd.onCommand(console, null, "afktime", new String[]{"TargetOne"}));
+        assertTrue(cmd.onCommand(console, null, "afktop", new String[]{}));
+
+        assertTrue(cmd.onCommand(console, null, "afk", new String[]{"bypass", "whitelist", "add", "TargetOne"}));
+        assertTrue(cmd.onCommand(console, null, "afk", new String[]{"bypass", "whitelist", "list"}));
+        assertTrue(cmd.onCommand(console, null, "afk", new String[]{"bypass", "whitelist", "remove", "TargetOne"}));
+
+        assertTrue(cmd.onCommand(console, null, "afk", new String[]{"bypass", "blacklist", "add", "TargetOne"}));
+        assertTrue(cmd.onCommand(console, null, "afk", new String[]{"bypass", "blacklist", "list"}));
+        assertTrue(cmd.onCommand(console, null, "afk", new String[]{"bypass", "blacklist", "remove", "TargetOne"}));
+
+        assertTrue(cmd.onCommand(console, null, "afk", new String[]{"bypass", "TargetOne"}));
+        assertTrue(cmd.onCommand(console, null, "afk", new String[]{"info", "TargetOne"}));
+
+        // Exercise info AFK-detail path and top non-empty leaderboard path.
+        AfkState.markAfk(ezafk, target, com.gyvex.ezafk.state.AfkReason.MANUAL, "via test", com.gyvex.ezafk.state.AfkActivationMode.STANDARD);
+        AfkTimeManager.recordAfkSession(target.getUniqueId(), System.currentTimeMillis() - 15000L, System.currentTimeMillis());
+        assertTrue(cmd.onCommand(console, null, "afk", new String[]{"info", "TargetOne"}));
+        assertTrue(cmd.onCommand(console, null, "afk", new String[]{"top"}));
+
+        // Self-time path with a player sender.
+        assertTrue(cmd.onCommand(target, null, "afk", new String[]{"time"}));
+    }
+
+    @Test
+    void afkZoneCommand_exercises_main_paths() {
+        AfkZoneCommand cmd = new AfkZoneCommand(ezafk);
+        CommandSender console = server.getConsoleSender();
+        Player admin = server.addPlayer("ZoneAdmin");
+        admin.setOp(true);
+
+        assertDoesNotThrow(() -> cmd.handleAfkZone(console, new String[]{"zone"}));
+        assertDoesNotThrow(() -> cmd.handleAfkZone(console, new String[]{"zone", "list"}));
+
+        // seed a region to exercise list and remove branches
+        Map<String, Object> region = new HashMap<>();
+        region.put("name", "spawn-afk");
+        region.put("world", admin.getWorld().getName());
+        region.put("x1", 0);
+        region.put("y1", 60);
+        region.put("z1", 0);
+        region.put("x2", 10);
+        region.put("y2", 70);
+        region.put("z2", 10);
+        Registry.get().getZonesConfig().set("regions", List.of(region));
+
+        assertDoesNotThrow(() -> cmd.handleAfkZone(console, new String[]{"zone", "list"}));
+        assertDoesNotThrow(() -> cmd.handleAfkZone(console, new String[]{"zone", "players"}));
+
+        // Force non-empty loaded zone path by creating and loading an in-memory region around admin.
+        assertDoesNotThrow(() -> cmd.handleAfkZone(admin, new String[]{"zone", "add", "live-zone", "0", "60", "0", "20", "90", "20"}));
+        admin.teleport(new org.bukkit.Location(admin.getWorld(), 10, 70, 10));
+        assertDoesNotThrow(() -> cmd.handleAfkZone(console, new String[]{"zone", "players"}));
+
+        assertDoesNotThrow(() -> cmd.handleAfkZone(console, new String[]{"zone", "add", "bad"}));
+        assertDoesNotThrow(() -> cmd.handleAfkZone(admin, new String[]{"zone", "add"}));
+        assertDoesNotThrow(() -> cmd.handleAfkZone(admin, new String[]{"zone", "add", "coordsBad", "a", "b", "c", "d", "e", "f"}));
+        assertDoesNotThrow(() -> cmd.handleAfkZone(admin, new String[]{"zone", "add", "coordsOk", "1", "60", "1", "4", "63", "4"}));
+
+        assertDoesNotThrow(() -> cmd.handleAfkZone(admin, new String[]{"zone", "remove"}));
+        assertDoesNotThrow(() -> cmd.handleAfkZone(admin, new String[]{"zone", "remove", "missing"}));
+        assertDoesNotThrow(() -> cmd.handleAfkZone(admin, new String[]{"zone", "remove", "coordsOk"}));
+
+        assertDoesNotThrow(() -> cmd.handleAfkZone(admin, new String[]{"zone", "pos1"}));
+        assertDoesNotThrow(() -> cmd.handleAfkZone(admin, new String[]{"zone", "pos2"}));
+        assertDoesNotThrow(() -> cmd.handleAfkZone(admin, new String[]{"zone", "clearpos"}));
+        assertDoesNotThrow(() -> cmd.handleAfkZone(admin, new String[]{"zone", "clearpos", "ZoneAdmin"}));
+        assertDoesNotThrow(() -> cmd.handleAfkZone(admin, new String[]{"zone", "clearpos", "NoSuchPlayer"}));
+
+        assertDoesNotThrow(() -> cmd.handleAfkZone(admin, new String[]{"zone", "reset"}));
+        assertDoesNotThrow(() -> cmd.handleAfkZone(admin, new String[]{"zone", "reset", "NoSuchPlayer"}));
+        assertDoesNotThrow(() -> cmd.handleAfkZone(admin, new String[]{"zone", "reset", "ZoneAdmin"}));
+        assertDoesNotThrow(() -> cmd.handleAfkZone(admin, new String[]{"zone", "reset", "ZoneAdmin", "spawn-afk"}));
+
+        assertDoesNotThrow(() -> cmd.handleAfkZone(console, new String[]{"zone", "unknown"}));
+    }
+
+    @Test
+    void ezAfkTabCompleter_exercises_all_argument_shapes() {
+        EzAfkTabCompleter completer = new EzAfkTabCompleter();
+        Player p = server.addPlayer("CompleterUser");
+        p.setOp(true);
+        server.addPlayer("Beta");
+
+        // zone name suggestions for remove
+        Map<String, Object> region = new HashMap<>();
+        region.put("name", "alpha-zone");
+        Registry.get().getZonesConfig().set("regions", List.of(region));
+
+        assertNotNull(completer.onTabComplete(p, null, "afk", new String[]{"g"}));
+        assertNotNull(completer.onTabComplete(p, null, "afkzone", new String[]{"l"}));
+        assertNotNull(completer.onTabComplete(p, null, "afk", new String[]{"toggle", "B"}));
+        assertNotNull(completer.onTabComplete(p, null, "afk", new String[]{"info", "B"}));
+        assertNotNull(completer.onTabComplete(p, null, "afk", new String[]{"time", "B"}));
+        assertNotNull(completer.onTabComplete(p, null, "afk", new String[]{"reset", "B"}));
+        assertNotNull(completer.onTabComplete(p, null, "afk", new String[]{"remove", "a"}));
+        assertNotNull(completer.onTabComplete(p, null, "afk", new String[]{"bypass", "w"}));
+        assertNotNull(completer.onTabComplete(p, null, "afk", new String[]{"bypass", "whitelist", "a"}));
+        assertNotNull(completer.onTabComplete(p, null, "afk", new String[]{"bypass", "whitelist", "add", "B"}));
+
+        // no-permission path for /afk time <player> suggestions
+        p.setOp(false);
+        assertTrue(completer.onTabComplete(p, null, "afk", new String[]{"time", "B"}).isEmpty());
+
+        assertFalse(completer.onTabComplete(p, null, "afk", new String[]{"bypass", "B"}).isEmpty());
+    }
+}
diff --git a/src/test/java/com/gyvex/ezafk/feature/CommandPermissionCoverageFeatureTest.java b/src/test/java/com/gyvex/ezafk/feature/CommandPermissionCoverageFeatureTest.java
new file mode 100644
index 0000000..3a19366
--- /dev/null
+++ b/src/test/java/com/gyvex/ezafk/feature/CommandPermissionCoverageFeatureTest.java
@@ -0,0 +1,79 @@
+package com.gyvex.ezafk.feature;
+
+import com.gyvex.ezafk.TestHelpers;
+import com.gyvex.ezafk.command.AfkZoneCommand;
+import com.gyvex.ezafk.command.EzAfkCommand;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+import org.bukkit.plugin.java.JavaPlugin;
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.assertDoesNotThrow;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+class CommandPermissionCoverageFeatureTest {
+
+    private org.mockbukkit.mockbukkit.ServerMock server;
+    private JavaPlugin plugin;
+    private com.gyvex.ezafk.EzAfk ezafk;
+
+    @BeforeEach
+    void setUp() {
+        server = TestHelpers.startServer();
+        plugin = TestHelpers.loadPlugin();
+        ezafk = (com.gyvex.ezafk.EzAfk) plugin;
+    }
+
+    @AfterEach
+    void tearDown() {
+        TestHelpers.stopServer();
+    }
+
+    @Test
+    void ezAfkCommand_permission_denied_paths() {
+        EzAfkCommand cmd = new EzAfkCommand(ezafk);
+        Player user = server.addPlayer("NoPermUser");
+        org.bukkit.command.CommandSender console = server.getConsoleSender();
+
+        assertTrue(cmd.onCommand(user, null, "afk", new String[]{"reload"}));
+        assertTrue(cmd.onCommand(user, null, "afk", new String[]{"gui"}));
+        assertTrue(cmd.onCommand(user, null, "afk", new String[]{"toggle"}));
+        assertTrue(cmd.onCommand(user, null, "afk", new String[]{"bypass", "NoPermUser"}));
+        assertTrue(cmd.onCommand(user, null, "afk", new String[]{"info", "NoPermUser"}));
+        assertTrue(cmd.onCommand(user, null, "afk", new String[]{"time", "OtherUser"}));
+        assertTrue(cmd.onCommand(user, null, "afk", new String[]{"time", "reset", "OtherUser"}));
+        assertTrue(cmd.onCommand(user, null, "afk", new String[]{"top"}));
+        assertTrue(cmd.onCommand(user, null, "afktime", new String[]{}));
+
+        // afktime players-only branch and unknown-player fallback path.
+        assertTrue(cmd.onCommand(console, null, "afktime", new String[]{}));
+        assertTrue(cmd.onCommand(console, null, "afktime", new String[]{"DefinitelyUnknownPlayer"}));
+
+        // Self-initiated toggle path.
+        user.setOp(true);
+        assertTrue(cmd.onCommand(user, null, "afk", new String[]{"toggle"}));
+        assertTrue(cmd.onCommand(user, null, "afk", new String[]{"toggle", user.getName()}));
+        assertTrue(cmd.onCommand(user, null, "afk", new String[]{"toggle", user.getName()}));
+        assertTrue(cmd.onCommand(user, null, "afk", new String[]{"bypass", "DefinitelyUnknown"}));
+        assertTrue(cmd.onCommand(user, null, "afk", new String[]{"bypass", "whitelist"}));
+        assertTrue(cmd.onCommand(user, null, "afk", new String[]{"bypass", "whitelist", "add"}));
+        assertTrue(cmd.onCommand(user, null, "afk", new String[]{"bypass", "whitelist", "noop", user.getName()}));
+        assertTrue(cmd.onCommand(user, null, "afk", new String[]{"info", "DefinitelyUnknown"}));
+    }
+
+    @Test
+    void afkZoneCommand_permission_and_player_only_paths() {
+        AfkZoneCommand cmd = new AfkZoneCommand(ezafk);
+        Player user = server.addPlayer("NoZonePerm");
+        CommandSender console = server.getConsoleSender();
+
+        assertDoesNotThrow(() -> cmd.handleAfkZone(user, new String[]{"zone", "list"}));
+        assertDoesNotThrow(() -> cmd.handleAfkZone(user, new String[]{"zone", "players"}));
+        assertDoesNotThrow(() -> cmd.handleAfkZone(user, new String[]{"zone", "add", "z1"}));
+        assertDoesNotThrow(() -> cmd.handleAfkZone(console, new String[]{"zone", "pos1"}));
+        assertDoesNotThrow(() -> cmd.handleAfkZone(console, new String[]{"zone", "pos2"}));
+        assertDoesNotThrow(() -> cmd.handleAfkZone(console, new String[]{"zone", "clearpos"}));
+    }
+}
diff --git a/src/test/java/com/gyvex/ezafk/feature/GuiAndListenerCoverageFeatureTest.java b/src/test/java/com/gyvex/ezafk/feature/GuiAndListenerCoverageFeatureTest.java
new file mode 100644
index 0000000..02f8978
--- /dev/null
+++ b/src/test/java/com/gyvex/ezafk/feature/GuiAndListenerCoverageFeatureTest.java
@@ -0,0 +1,400 @@
+package com.gyvex.ezafk.feature;
+
+import com.gyvex.ezafk.TestHelpers;
+import com.gyvex.ezafk.event.PlayerAfkStatusChangeEvent;
+import com.gyvex.ezafk.integration.EconomyIntegration;
+import com.gyvex.ezafk.listener.AfkPlayerActionsGUI;
+import com.gyvex.ezafk.listener.AfkPlayerOverviewGUI;
+import com.gyvex.ezafk.listener.EconomyServiceListener;
+import com.gyvex.ezafk.listener.PlayerActivityListener;
+import com.gyvex.ezafk.listener.SimpleVoiceChatAfkListener;
+import com.gyvex.ezafk.manager.IntegrationManager;
+import com.gyvex.ezafk.state.AfkActivationMode;
+import com.gyvex.ezafk.state.AfkReason;
+import com.gyvex.ezafk.state.AfkState;
+import com.gyvex.ezafk.state.LastActiveState;
+import com.gyvex.ezafk.command.AfkZoneCommand;
+import com.gyvex.ezafk.compatibility.item.HeadCompat;
+import com.gyvex.ezafk.compatibility.item.ItemMetaCompat;
+import net.milkbowl.vault.economy.Economy;
+import org.bukkit.Bukkit;
+import org.bukkit.ChatColor;
+import org.bukkit.Material;
+import org.bukkit.entity.Player;
+import org.bukkit.event.inventory.InventoryClickEvent;
+import org.bukkit.event.server.ServiceRegisterEvent;
+import org.bukkit.event.server.ServiceUnregisterEvent;
+import org.bukkit.inventory.Inventory;
+import org.bukkit.inventory.ItemStack;
+import org.bukkit.inventory.meta.ItemMeta;
+import org.bukkit.plugin.RegisteredServiceProvider;
+import org.bukkit.plugin.ServicePriority;
+import org.bukkit.plugin.java.JavaPlugin;
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.mockito.Mockito;
+import org.mockbukkit.mockbukkit.entity.PlayerMock;
+
+import java.lang.reflect.Field;
+import java.util.HashSet;
+import java.util.UUID;
+
+import static org.junit.jupiter.api.Assertions.assertDoesNotThrow;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+class GuiAndListenerCoverageFeatureTest {
+
+    private org.mockbukkit.mockbukkit.ServerMock server;
+    private JavaPlugin plugin;
+    private com.gyvex.ezafk.EzAfk ezafk;
+
+    @BeforeEach
+    void setUp() {
+        server = TestHelpers.startServer();
+        plugin = TestHelpers.loadPlugin();
+        ezafk = (com.gyvex.ezafk.EzAfk) plugin;
+    }
+
+    @AfterEach
+    void tearDown() {
+        LastActiveState.lastActive.clear();
+        AfkState.afkPlayers.clear();
+        AfkState.clearBypass();
+        TestHelpers.stopServer();
+    }
+
+    @Test
+    void overview_and_actions_gui_open_and_click_paths() {
+        PlayerMock admin = (PlayerMock) server.addPlayer("GuiAdmin2");
+        admin.setOp(true);
+        Player target = server.addPlayer("GuiTarget");
+
+        AfkState.markAfk(ezafk, target, AfkReason.MANUAL, null, AfkActivationMode.STANDARD);
+
+        AfkPlayerActionsGUI actionsGUI = new AfkPlayerActionsGUI();
+        server.getPluginManager().registerEvents(actionsGUI, plugin);
+
+        AfkPlayerOverviewGUI overviewGUI = new AfkPlayerOverviewGUI();
+        server.getPluginManager().registerEvents(overviewGUI, plugin);
+
+        overviewGUI.openGUI(admin, 1, AfkPlayerOverviewGUI.PlayerListType.AFK);
+        assertNotNull(admin.getOpenInventory());
+
+        // Click first slot (likely AFK player head)
+        InventoryClickEvent firstClick = admin.simulateInventoryClick(0);
+        assertNotNull(firstClick);
+
+        // If actions GUI opened, click any arrow slot (back button) to exercise back path.
+        int arrowSlot = -1;
+        for (int i = 0; i < admin.getOpenInventory().getTopInventory().getSize(); i++) {
+            if (admin.getOpenInventory().getTopInventory().getItem(i) != null
+                    && admin.getOpenInventory().getTopInventory().getItem(i).getType() == Material.ARROW) {
+                arrowSlot = i;
+                break;
+            }
+        }
+        if (arrowSlot >= 0) {
+            InventoryClickEvent backClick = admin.simulateInventoryClick(arrowSlot);
+            assertNotNull(backClick);
+        }
+
+        // Re-open overview and click list toggle slot to switch list type.
+        overviewGUI.openGUI(admin, 1, AfkPlayerOverviewGUI.PlayerListType.AFK);
+        InventoryClickEvent toggleClick = admin.simulateInventoryClick(49);
+        assertNotNull(toggleClick);
+
+        // Re-open overview and click a non-functional empty slot path.
+        overviewGUI.openGUI(admin, 1, AfkPlayerOverviewGUI.PlayerListType.ACTIVE);
+        InventoryClickEvent emptyClick = admin.simulateInventoryClick(52);
+        assertNotNull(emptyClick);
+    }
+
+    @Test
+    void playerActivityListener_updates_on_inventory_click_path() {
+        PlayerActivityListener listener = new PlayerActivityListener();
+        server.getPluginManager().registerEvents(listener, plugin);
+
+        PlayerMock p = (PlayerMock) server.addPlayer("InvActive");
+        LastActiveState.lastActive.put(p.getUniqueId(), 0L);
+
+        org.bukkit.inventory.Inventory inv = Bukkit.createInventory(null, 9, "Test");
+        inv.setItem(0, new org.bukkit.inventory.ItemStack(Material.STONE));
+        p.openInventory(inv);
+
+        InventoryClickEvent click = p.simulateInventoryClick(0);
+        assertNotNull(click);
+        assertTrue(LastActiveState.getLastActive(p.getUniqueId()) > 0L);
+
+        // chat and command events still update
+        server.getPluginManager().callEvent(new org.bukkit.event.player.AsyncPlayerChatEvent(false, p, "hello", new HashSet<>()));
+        server.getPluginManager().callEvent(new org.bukkit.event.player.PlayerCommandPreprocessEvent(p, "/afk"));
+        assertTrue(LastActiveState.getLastActive(p.getUniqueId()) > 0L);
+    }
+
+    @Test
+    void economyServiceListener_register_and_unregister_paths() {
+        EconomyServiceListener listener = new EconomyServiceListener();
+
+        class FakeEconomyIntegration extends EconomyIntegration {
+            boolean loaded;
+            boolean unloaded;
+
+            @Override
+            public void load() {
+                loaded = true;
+                this.isSetup = true;
+            }
+
+            @Override
+            public void unload() {
+                unloaded = true;
+                this.isSetup = false;
+            }
+        }
+
+        FakeEconomyIntegration fake = new FakeEconomyIntegration();
+        IntegrationManager.addIntegration("economy", fake);
+
+        Economy econProvider = Mockito.mock(Economy.class);
+        RegisteredServiceProvider<Economy> provider = new RegisteredServiceProvider<>(
+            Economy.class,
+            econProvider,
+            ServicePriority.Normal,
+            plugin);
+
+        ServiceRegisterEvent registerEvent = new ServiceRegisterEvent(provider);
+        ServiceUnregisterEvent unregisterEvent = new ServiceUnregisterEvent(provider);
+
+        listener.onServiceRegister(registerEvent);
+        assertTrue(fake.loaded);
+
+        listener.onServiceUnregister(unregisterEvent);
+        assertTrue(fake.unloaded);
+
+        // non-economy path should short-circuit without exception
+        RegisteredServiceProvider<Object> other = new RegisteredServiceProvider<>(
+            Object.class,
+            new Object(),
+            ServicePriority.Normal,
+            plugin);
+        assertDoesNotThrow(() -> listener.onServiceRegister(new ServiceRegisterEvent(other)));
+        assertDoesNotThrow(() -> listener.onServiceUnregister(new ServiceUnregisterEvent(other)));
+    }
+
+    @Test
+    void simpleVoiceChatListener_handles_afk_and_return_events() {
+        SimpleVoiceChatAfkListener listener = new SimpleVoiceChatAfkListener(ezafk);
+        Player p = server.addPlayer("VoiceUser");
+
+        assertDoesNotThrow(() -> listener.onAfkStatusChange(
+                new PlayerAfkStatusChangeEvent(p, true, AfkReason.MANUAL, "test")));
+        assertDoesNotThrow(() -> listener.onAfkStatusChange(
+                new PlayerAfkStatusChangeEvent(p, false, AfkReason.MANUAL, "test")));
+    }
+
+    @Test
+    void moveListener_additional_branches_world_change_and_no_to_location() {
+        com.gyvex.ezafk.listener.MoveListener listener = new com.gyvex.ezafk.listener.MoveListener(ezafk);
+        server.getPluginManager().registerEvents(listener, plugin);
+
+        PlayerMock p = (PlayerMock) server.addPlayer("MoveBranch");
+        AfkState.markAfk(ezafk, p, AfkReason.MANUAL, null, AfkActivationMode.STANDARD);
+
+        // null 'to' location path
+        server.getPluginManager().callEvent(new org.bukkit.event.player.PlayerMoveEvent(p, p.getLocation().clone(), null));
+        assertTrue(AfkState.isAfk(p.getUniqueId()));
+
+        // world change path clears AFK
+        org.bukkit.World secondWorld = server.addSimpleWorld("world2");
+        org.bukkit.Location from = p.getLocation().clone();
+        org.bukkit.Location to = new org.bukkit.Location(secondWorld, from.getX(), from.getY(), from.getZ());
+        server.getPluginManager().callEvent(new org.bukkit.event.player.PlayerMoveEvent(p, from, to));
+        assertFalse(AfkState.isAfk(p.getUniqueId()));
+
+        // Bubble-column environment setup should be harmless in move handling.
+        UUID id = p.getUniqueId();
+        assertNotNull(id);
+        p.teleport(new org.bukkit.Location(secondWorld, 5, 65, 5));
+        secondWorld.getBlockAt(5, 65, 5).setType(Material.BUBBLE_COLUMN);
+        assertDoesNotThrow(() -> server.getPluginManager().callEvent(
+            new org.bukkit.event.player.PlayerMoveEvent(p, p.getLocation().clone(), p.getLocation().clone().add(1, 0, 0))));
+    }
+
+    @Test
+    void overview_gui_click_edge_cases_and_pagination_paths() throws Exception {
+        AfkPlayerOverviewGUI overviewGUI = new AfkPlayerOverviewGUI();
+        server.getPluginManager().registerEvents(overviewGUI, plugin);
+
+        PlayerMock player = (PlayerMock) server.addPlayer("OverviewCases");
+        player.setOp(false);
+
+        Inventory inv = Bukkit.createInventory(null, 54, ChatColor.DARK_GRAY + "AFK Players - Page 2");
+
+        ItemStack invalidToggle = new ItemStack(Material.NETHER_STAR);
+        ItemMeta invalidToggleMeta = invalidToggle.getItemMeta();
+        assertNotNull(invalidToggleMeta);
+        ItemMetaCompat.setItemMetadata(invalidToggleMeta, "afk_overview_list_toggle", "NOT_A_REAL_TYPE");
+        invalidToggle.setItemMeta(invalidToggleMeta);
+        inv.setItem(0, invalidToggle);
+
+        ItemStack activeToggle = new ItemStack(Material.NETHER_STAR);
+        ItemMeta activeToggleMeta = activeToggle.getItemMeta();
+        assertNotNull(activeToggleMeta);
+        ItemMetaCompat.setItemMetadata(activeToggleMeta, "afk_overview_list_toggle", "ACTIVE");
+        activeToggle.setItemMeta(activeToggleMeta);
+        inv.setItem(1, activeToggle);
+
+        ItemStack headNoUuid = HeadCompat.createPlayerHead();
+        inv.setItem(2, headNoUuid);
+
+        ItemStack headBadUuid = HeadCompat.createPlayerHead();
+        ItemMeta headBadUuidMeta = headBadUuid.getItemMeta();
+        assertNotNull(headBadUuidMeta);
+        ItemMetaCompat.setItemMetadata(headBadUuidMeta, "afk_overview_uuid", "not-a-uuid");
+        headBadUuid.setItemMeta(headBadUuidMeta);
+        inv.setItem(3, headBadUuid);
+
+        ItemStack prev = new ItemStack(Material.ARROW);
+        ItemMeta prevMeta = prev.getItemMeta();
+        assertNotNull(prevMeta);
+        prevMeta.setDisplayName(ChatColor.GREEN + "Previous Page");
+        prev.setItemMeta(prevMeta);
+        inv.setItem(4, prev);
+
+        ItemStack next = new ItemStack(Material.ARROW);
+        ItemMeta nextMeta = next.getItemMeta();
+        assertNotNull(nextMeta);
+        nextMeta.setDisplayName(ChatColor.GREEN + "Next Page");
+        next.setItemMeta(nextMeta);
+        inv.setItem(5, next);
+
+        // Force actions GUI singleton to null to hit null-guard branch.
+        Field instanceField = AfkPlayerActionsGUI.class.getDeclaredField("instance");
+        instanceField.setAccessible(true);
+        instanceField.set(null, null);
+
+        player.openInventory(inv);
+
+        assertNotNull(player.simulateInventoryClick(0));
+        assertNotNull(player.simulateInventoryClick(1));
+        // Head click without actions permission.
+        assertNotNull(player.simulateInventoryClick(2));
+
+        player.setOp(true);
+        assertNotNull(player.simulateInventoryClick(2));
+        assertNotNull(player.simulateInventoryClick(3));
+
+        ItemStack headValidUuid = HeadCompat.createPlayerHead();
+        ItemMeta headValidUuidMeta = headValidUuid.getItemMeta();
+        assertNotNull(headValidUuidMeta);
+        ItemMetaCompat.setItemMetadata(headValidUuidMeta, "afk_overview_uuid", player.getUniqueId().toString());
+        headValidUuid.setItemMeta(headValidUuidMeta);
+        inv.setItem(6, headValidUuid);
+        player.openInventory(inv);
+        assertNotNull(player.simulateInventoryClick(6));
+
+        // Exercise previous and next page button handlers separately (click changes inventory view).
+        player.openInventory(inv);
+        assertNotNull(player.simulateInventoryClick(4));
+        player.openInventory(inv);
+        assertNotNull(player.simulateInventoryClick(5));
+    }
+
+    @Test
+    void actions_gui_permission_empty_null_target_and_action_paths() throws Exception {
+        AfkPlayerActionsGUI actionsGUI = new AfkPlayerActionsGUI();
+        server.getPluginManager().registerEvents(actionsGUI, plugin);
+
+        PlayerMock noPerm = (PlayerMock) server.addPlayer("ActionNoPerm");
+        actionsGUI.openGUI(noPerm, null, 1, AfkPlayerOverviewGUI.PlayerListType.AFK);
+        assertNotNull(noPerm.simulateInventoryClick(0));
+
+        PlayerMock op = (PlayerMock) server.addPlayer("ActionOp");
+        op.setOp(true);
+
+        // Empty item branch.
+        Inventory emptyInventory = Bukkit.createInventory(null, 9, ChatColor.DARK_GRAY + "Player Actions");
+        op.openInventory(emptyInventory);
+        assertNotNull(op.simulateInventoryClick(0));
+
+        // Determine configured action slot and exercise null-target action execution.
+        Field actionsField = AfkPlayerActionsGUI.class.getDeclaredField("actions");
+        actionsField.setAccessible(true);
+        @SuppressWarnings("unchecked")
+        java.util.Map<Integer, ?> actionMap = (java.util.Map<Integer, ?>) actionsField.get(actionsGUI);
+        assertFalse(actionMap.isEmpty());
+        int actionSlot = actionMap.keySet().iterator().next();
+
+        actionsGUI.openGUI(op, null, 1, AfkPlayerOverviewGUI.PlayerListType.AFK);
+        assertNotNull(op.simulateInventoryClick(actionSlot));
+
+        Player target = server.addPlayer("ActionTarget");
+        actionsGUI.openGUI(op, target, 1, AfkPlayerOverviewGUI.PlayerListType.AFK);
+        assertNotNull(op.simulateInventoryClick(actionSlot));
+
+        // Click a non-action filler slot to hit action-null path.
+        actionsGUI.openGUI(op, target, 1, AfkPlayerOverviewGUI.PlayerListType.AFK);
+        int nullActionSlot = -1;
+        for (int i = 0; i < op.getOpenInventory().getTopInventory().getSize(); i++) {
+            if (!actionMap.containsKey(i)) {
+                nullActionSlot = i;
+                break;
+            }
+        }
+        assertTrue(nullActionSlot >= 0);
+        assertNotNull(op.simulateInventoryClick(nullActionSlot));
+    }
+
+    @Test
+    void move_listener_anti_vehicle_water_and_zone_transition_paths() {
+        com.gyvex.ezafk.listener.MoveListener listener = new com.gyvex.ezafk.listener.MoveListener(ezafk);
+        server.getPluginManager().registerEvents(listener, plugin);
+
+        PlayerMock p = (PlayerMock) server.addPlayer("MoveDeep");
+        PlayerMock vehicle = (PlayerMock) server.addPlayer("MoveVehicle");
+
+        ezafk.getConfig().set("afk.anti.infinite-vehicle", true);
+        ezafk.getConfig().set("afk.anti.infinite-waterflow", false);
+        ezafk.getConfig().set("afk.anti.bubble-column", false);
+
+        // Anti-vehicle + flag-only true.
+        ezafk.getConfig().set("afk.anti.flag-only", true);
+        vehicle.addPassenger(p);
+        server.getPluginManager().callEvent(new org.bukkit.event.player.PlayerMoveEvent(p, p.getLocation().clone(), p.getLocation().clone().add(1, 0, 0)));
+
+        // Anti-vehicle + flag-only false (leave vehicle path).
+        ezafk.getConfig().set("afk.anti.flag-only", false);
+        vehicle.addPassenger(p);
+        server.getPluginManager().callEvent(new org.bukkit.event.player.PlayerMoveEvent(p, p.getLocation().clone(), p.getLocation().clone().add(1, 0, 0)));
+
+        // Anti-water flow path (flag-only true/false).
+        ezafk.getConfig().set("afk.anti.infinite-vehicle", false);
+        ezafk.getConfig().set("afk.anti.infinite-waterflow", true);
+        p.teleport(new org.bukkit.Location(p.getWorld(), 30, 70, 30));
+        p.getWorld().getBlockAt(30, 70, 30).setType(Material.WATER);
+        p.getWorld().getBlockAt(30, 70, 30).setBlockData(Bukkit.createBlockData("minecraft:water[level=8]"));
+        p.getWorld().getBlockAt(30, 69, 30).setType(Material.AIR);
+
+        ezafk.getConfig().set("afk.anti.flag-only", true);
+        server.getPluginManager().callEvent(new org.bukkit.event.player.PlayerMoveEvent(p, p.getLocation().clone(), p.getLocation().clone().add(1, 0, 0)));
+
+        ezafk.getConfig().set("afk.anti.flag-only", false);
+        server.getPluginManager().callEvent(new org.bukkit.event.player.PlayerMoveEvent(p, p.getLocation().clone(), p.getLocation().clone().add(1, 0, 0)));
+
+        // Zone transition: enter, same zone, exit.
+        ezafk.getConfig().set("afk.anti.infinite-waterflow", false);
+        AfkZoneCommand zoneCommand = new AfkZoneCommand(ezafk);
+        p.setOp(true);
+        zoneCommand.handleAfkZone(p, new String[]{"zone", "add", "move-zone", "100", "60", "100", "120", "80", "120"});
+
+        p.teleport(new org.bukkit.Location(p.getWorld(), 110, 70, 110));
+        server.getPluginManager().callEvent(new org.bukkit.event.player.PlayerMoveEvent(p, p.getLocation().clone().add(-1, 0, 0), p.getLocation().clone()));
+        server.getPluginManager().callEvent(new org.bukkit.event.player.PlayerMoveEvent(p, p.getLocation().clone(), p.getLocation().clone().add(1, 0, 0)));
+
+        p.teleport(new org.bukkit.Location(p.getWorld(), 140, 70, 140));
+        server.getPluginManager().callEvent(new org.bukkit.event.player.PlayerMoveEvent(p, p.getLocation().clone().add(-1, 0, 0), p.getLocation().clone()));
+    }
+}
diff --git a/src/test/java/com/gyvex/ezafk/feature/GuiInternalCoverageFeatureTest.java b/src/test/java/com/gyvex/ezafk/feature/GuiInternalCoverageFeatureTest.java
new file mode 100644
index 0000000..afa4c6f
--- /dev/null
+++ b/src/test/java/com/gyvex/ezafk/feature/GuiInternalCoverageFeatureTest.java
@@ -0,0 +1,94 @@
+package com.gyvex.ezafk.feature;
+
+import com.gyvex.ezafk.TestHelpers;
+import com.gyvex.ezafk.listener.AfkPlayerActionsGUI;
+import com.gyvex.ezafk.listener.AfkPlayerOverviewGUI;
+import org.bukkit.Bukkit;
+import org.bukkit.Material;
+import org.bukkit.OfflinePlayer;
+import org.bukkit.entity.Player;
+import org.bukkit.inventory.ItemStack;
+import org.bukkit.plugin.java.JavaPlugin;
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.mockbukkit.mockbukkit.entity.PlayerMock;
+
+import java.lang.reflect.Method;
+import java.util.UUID;
+
+import static org.junit.jupiter.api.Assertions.assertDoesNotThrow;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+
+class GuiInternalCoverageFeatureTest {
+
+    private org.mockbukkit.mockbukkit.ServerMock server;
+    private JavaPlugin plugin;
+
+    @BeforeEach
+    void setUp() {
+        server = TestHelpers.startServer();
+        plugin = TestHelpers.loadPlugin();
+    }
+
+    @AfterEach
+    void tearDown() {
+        TestHelpers.stopServer();
+    }
+
+    @Test
+    void actionsGui_private_helpers_are_invokable() throws Exception {
+        AfkPlayerActionsGUI gui = new AfkPlayerActionsGUI();
+
+        Method normalize = AfkPlayerActionsGUI.class.getDeclaredMethod("normalizeInventorySize", int.class);
+        normalize.setAccessible(true);
+        normalize.invoke(gui, 1);
+        normalize.invoke(gui, 999);
+        normalize.invoke(gui, 10);
+
+        Method createBack = AfkPlayerActionsGUI.class.getDeclaredMethod("createBackButtonItem");
+        createBack.setAccessible(true);
+        Object back = createBack.invoke(gui);
+        assertNotNull(back);
+
+        Method ensureBack = AfkPlayerActionsGUI.class.getDeclaredMethod("ensureBackButtonSlot");
+        ensureBack.setAccessible(true);
+        ensureBack.invoke(gui);
+
+        PlayerMock p = (PlayerMock) server.addPlayer("ActionsOpen");
+        Player target = server.addPlayer("ActionsTarget");
+        gui.openGUI(p, target, 1, AfkPlayerOverviewGUI.PlayerListType.AFK);
+        assertNotNull(p.getOpenInventory());
+    }
+
+    @Test
+    void overviewGui_private_helpers_are_invokable() throws Exception {
+        AfkPlayerOverviewGUI gui = new AfkPlayerOverviewGUI();
+
+        Method createButton = AfkPlayerOverviewGUI.class.getDeclaredMethod("createButtonItem", String.class, Material.class);
+        createButton.setAccessible(true);
+        ItemStack button = (ItemStack) createButton.invoke(gui, "Name", Material.ARROW);
+        assertNotNull(button);
+
+        Method createToggle = AfkPlayerOverviewGUI.class.getDeclaredMethod("createToggleItem", AfkPlayerOverviewGUI.PlayerListType.class);
+        createToggle.setAccessible(true);
+        Object toggle = createToggle.invoke(gui, AfkPlayerOverviewGUI.PlayerListType.AFK);
+        assertNotNull(toggle);
+
+        Method buildLore = AfkPlayerOverviewGUI.class.getDeclaredMethod("buildPlayerLore", OfflinePlayer.class);
+        buildLore.setAccessible(true);
+        OfflinePlayer offline = Bukkit.getOfflinePlayer(UUID.randomUUID());
+        buildLore.invoke(gui, offline);
+
+        Method createHead = AfkPlayerOverviewGUI.class.getDeclaredMethod("createPlayerHead", OfflinePlayer.class);
+        createHead.setAccessible(true);
+        Object head = createHead.invoke(gui, offline);
+        assertNotNull(head);
+
+        PlayerMock p = (PlayerMock) server.addPlayer("OverviewOpen");
+        gui.openGUI(p, 1, AfkPlayerOverviewGUI.PlayerListType.ACTIVE);
+        assertDoesNotThrow(() -> p.simulateInventoryClick(45));
+        assertDoesNotThrow(() -> p.simulateInventoryClick(53));
+        assertDoesNotThrow(() -> p.simulateInventoryClick(49));
+    }
+}
diff --git a/src/test/java/com/gyvex/ezafk/feature/MoveListenerInternalCoverageTest.java b/src/test/java/com/gyvex/ezafk/feature/MoveListenerInternalCoverageTest.java
new file mode 100644
index 0000000..51d53e9
--- /dev/null
+++ b/src/test/java/com/gyvex/ezafk/feature/MoveListenerInternalCoverageTest.java
@@ -0,0 +1,240 @@
+package com.gyvex.ezafk.feature;
+
+import com.gyvex.ezafk.TestHelpers;
+import com.gyvex.ezafk.command.AfkZoneCommand;
+import com.gyvex.ezafk.listener.MoveListener;
+import com.gyvex.ezafk.manager.AfkZoneManager;
+import org.bukkit.Bukkit;
+import org.bukkit.Location;
+import org.bukkit.Material;
+import org.bukkit.block.Block;
+import org.bukkit.entity.Player;
+import org.bukkit.event.player.PlayerMoveEvent;
+import org.bukkit.plugin.java.JavaPlugin;
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+
+import java.lang.reflect.Method;
+import java.lang.reflect.Field;
+import java.util.List;
+import java.util.Map;
+import java.util.UUID;
+
+import static org.junit.jupiter.api.Assertions.assertDoesNotThrow;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+class MoveListenerInternalCoverageTest {
+
+    private org.mockbukkit.mockbukkit.ServerMock server;
+    private JavaPlugin plugin;
+    private com.gyvex.ezafk.EzAfk ezafk;
+
+    @BeforeEach
+    void setUp() {
+        server = TestHelpers.startServer();
+        plugin = TestHelpers.loadPlugin();
+        ezafk = (com.gyvex.ezafk.EzAfk) plugin;
+    }
+
+    @AfterEach
+    void tearDown() {
+        TestHelpers.stopServer();
+    }
+
+    @Test
+    void private_helpers_cover_flowing_water_and_distance_logic() throws Exception {
+        MoveListener listener = new MoveListener(ezafk);
+
+        Method formatLocation = MoveListener.class.getDeclaredMethod("formatLocation", Location.class);
+        formatLocation.setAccessible(true);
+        String s1 = (String) formatLocation.invoke(listener, new Location(null, 1, 2, 3));
+        assertNotNull(s1);
+
+        Method meaningful = MoveListener.class.getDeclaredMethod("hasMeaningfulPositionChange", PlayerMoveEvent.class);
+        meaningful.setAccessible(true);
+
+        Player p = server.addPlayer("MoveInternals");
+        Location from = p.getLocation().clone();
+        Location toSame = from.clone();
+        Location toMove = from.clone().add(1, 0, 0);
+
+        assertFalse((boolean) meaningful.invoke(listener, new PlayerMoveEvent(p, from, null)));
+        assertFalse((boolean) meaningful.invoke(listener, new PlayerMoveEvent(p, from, toSame)));
+        assertTrue((boolean) meaningful.invoke(listener, new PlayerMoveEvent(p, from, toMove)));
+
+        Method flow = MoveListener.class.getDeclaredMethod("isFlowingWaterThatPushes", Block.class);
+        flow.setAccessible(true);
+
+        org.bukkit.World world = server.getWorlds().get(0);
+        Block water = world.getBlockAt(10, 65, 10);
+        water.setType(Material.WATER);
+
+        // Source water should not count as pushing flow.
+        water.setBlockData(Bukkit.createBlockData("minecraft:water[level=0]"));
+        assertFalse((boolean) flow.invoke(listener, water));
+
+        // Falling/high level water with passable block below should count.
+        water.setBlockData(Bukkit.createBlockData("minecraft:water[level=8]"));
+        world.getBlockAt(10, 64, 10).setType(Material.AIR);
+        assertTrue((boolean) flow.invoke(listener, water));
+
+        // Mid-level flowing water with side opening should also count.
+        water.setBlockData(Bukkit.createBlockData("minecraft:water[level=3]"));
+        world.getBlockAt(11, 65, 10).setType(Material.AIR);
+        assertTrue((boolean) flow.invoke(listener, water));
+    }
+
+    @Test
+    void onMove_tolerates_multiple_anti_configurations() {
+        MoveListener listener = new MoveListener(ezafk);
+        server.getPluginManager().registerEvents(listener, plugin);
+
+        Player p = server.addPlayer("MoveConfig");
+        Location from = p.getLocation().clone();
+        Location to = from.clone().add(1, 0, 0);
+
+        ezafk.getConfig().set("afk.anti.infinite-vehicle", false);
+        ezafk.getConfig().set("afk.anti.flag-only", false);
+        ezafk.getConfig().set("afk.anti.infinite-waterflow", false);
+        ezafk.getConfig().set("afk.anti.bubble-column", false);
+
+        assertDoesNotThrow(() -> server.getPluginManager().callEvent(new PlayerMoveEvent(p, from, to)));
+
+        // Bubble-column branch setup
+        p.getWorld().getBlockAt(from.getBlockX(), from.getBlockY(), from.getBlockZ()).setType(Material.BUBBLE_COLUMN);
+        ezafk.getConfig().set("afk.anti.bubble-column", true);
+        ezafk.getConfig().set("afk.anti.flag-only", true);
+        assertDoesNotThrow(() -> server.getPluginManager().callEvent(new PlayerMoveEvent(p, from, to)));
+
+        // Ensure a zone exists for transition checks in move handling.
+        ((org.mockbukkit.mockbukkit.entity.PlayerMock) p).setOp(true);
+        AfkZoneCommand zoneCommand = new AfkZoneCommand(ezafk);
+        zoneCommand.handleAfkZone(p, new String[]{"zone", "add", "move-internal-zone", "200", "60", "200", "220", "80", "220"});
+        List<com.gyvex.ezafk.zone.Zone> zones = AfkZoneManager.getZones();
+        assertFalse(zones.isEmpty());
+
+        p.teleport(new Location(p.getWorld(), 210, 70, 210));
+        assertDoesNotThrow(() -> server.getPluginManager().callEvent(new PlayerMoveEvent(p, p.getLocation().clone().add(-1, 0, 0), p.getLocation().clone())));
+        p.teleport(new Location(p.getWorld(), 240, 70, 240));
+        assertDoesNotThrow(() -> server.getPluginManager().callEvent(new PlayerMoveEvent(p, p.getLocation().clone().add(-1, 0, 0), p.getLocation().clone())));
+    }
+
+    @Test
+    void private_helpers_cover_infinite_water_and_bubble_body_below() throws Exception {
+        MoveListener listener = new MoveListener(ezafk);
+        Player p = server.addPlayer("MoveHelperBranches");
+
+        Method infiniteFlow = MoveListener.class.getDeclaredMethod("isInInfiniteWaterFlow", Player.class);
+        infiniteFlow.setAccessible(true);
+
+        p.teleport(new Location(p.getWorld(), 300, 70, 300));
+        p.getWorld().getBlockAt(300, 70, 300).setType(Material.WATER);
+        p.getWorld().getBlockAt(300, 70, 300).setBlockData(Bukkit.createBlockData("minecraft:water[level=8]"));
+        p.getWorld().getBlockAt(300, 69, 300).setType(Material.AIR);
+        assertTrue((boolean) infiniteFlow.invoke(listener, p));
+
+        p.teleport(new Location(p.getWorld(), 305, 70, 305));
+        p.getWorld().getBlockAt(305, 70, 305).setType(Material.STONE);
+        assertFalse((boolean) infiniteFlow.invoke(listener, p));
+
+        Method bubble = MoveListener.class.getDeclaredMethod("isInBubbleColumn", Player.class);
+        bubble.setAccessible(true);
+
+        p.teleport(new Location(p.getWorld(), 310, 70, 310));
+        p.getWorld().getBlockAt(310, 70, 310).setType(Material.AIR);
+        p.getWorld().getBlockAt(310, 71, 310).setType(Material.BUBBLE_COLUMN);
+        p.getWorld().getBlockAt(310, 69, 310).setType(Material.AIR);
+        assertTrue((boolean) bubble.invoke(listener, p));
+
+        p.getWorld().getBlockAt(310, 71, 310).setType(Material.AIR);
+        p.getWorld().getBlockAt(310, 69, 310).setType(Material.BUBBLE_COLUMN);
+        assertTrue((boolean) bubble.invoke(listener, p));
+
+        Method flow = MoveListener.class.getDeclaredMethod("isFlowingWaterThatPushes", Block.class);
+        flow.setAccessible(true);
+
+        Block nonWater = p.getWorld().getBlockAt(315, 70, 315);
+        nonWater.setType(Material.STONE);
+        assertFalse((boolean) flow.invoke(listener, nonWater));
+
+        Block bubbleBelow = p.getWorld().getBlockAt(316, 70, 316);
+        bubbleBelow.setType(Material.WATER);
+        bubbleBelow.setBlockData(Bukkit.createBlockData("minecraft:water[level=8]"));
+        p.getWorld().getBlockAt(316, 69, 316).setType(Material.BUBBLE_COLUMN);
+        assertFalse((boolean) flow.invoke(listener, bubbleBelow));
+
+        Block maxLevel = p.getWorld().getBlockAt(317, 70, 317);
+        maxLevel.setType(Material.WATER);
+        maxLevel.setBlockData(Bukkit.createBlockData("minecraft:water[level=8]"));
+        p.getWorld().getBlockAt(317, 69, 317).setType(Material.AIR);
+        assertTrue((boolean) flow.invoke(listener, maxLevel));
+
+        Block adjacentHigher = p.getWorld().getBlockAt(318, 70, 318);
+        adjacentHigher.setType(Material.WATER);
+        adjacentHigher.setBlockData(Bukkit.createBlockData("minecraft:water[level=2]"));
+        p.getWorld().getBlockAt(319, 70, 318).setType(Material.WATER);
+        p.getWorld().getBlockAt(319, 70, 318).setBlockData(Bukkit.createBlockData("minecraft:water[level=5]"));
+        assertTrue((boolean) flow.invoke(listener, adjacentHigher));
+    }
+
+    @Test
+    void onMove_anti_infinite_water_and_zone_cache_branches() throws Exception {
+        MoveListener listener = new MoveListener(ezafk);
+        server.getPluginManager().registerEvents(listener, plugin);
+        Player p = server.addPlayer("MoveOnMoveBranches");
+
+        ezafk.getConfig().set("afk.anti.infinite-vehicle", false);
+        ezafk.getConfig().set("afk.anti.bubble-column", false);
+        ezafk.getConfig().set("afk.anti.infinite-waterflow", true);
+
+        p.teleport(new Location(p.getWorld(), 330, 70, 330));
+        p.getWorld().getBlockAt(330, 70, 330).setType(Material.WATER);
+        p.getWorld().getBlockAt(330, 70, 330).setBlockData(Bukkit.createBlockData("minecraft:water[level=8]"));
+        p.getWorld().getBlockAt(330, 69, 330).setType(Material.AIR);
+
+        Method infiniteFlow = MoveListener.class.getDeclaredMethod("isInInfiniteWaterFlow", Player.class);
+        infiniteFlow.setAccessible(true);
+        assertTrue((boolean) infiniteFlow.invoke(listener, p));
+
+        ezafk.getConfig().set("afk.anti.flag-only", true);
+        server.getPluginManager().callEvent(new PlayerMoveEvent(p, p.getLocation().clone(), p.getLocation().clone().add(1, 0, 0)));
+
+        // Use another player so handled-set branches execute as fresh adds in non-flag mode.
+        Player p2 = server.addPlayer("MoveOnMoveBranches2");
+        p2.teleport(new Location(p2.getWorld(), 331, 70, 331));
+        p2.getWorld().getBlockAt(331, 70, 331).setType(Material.WATER);
+        p2.getWorld().getBlockAt(331, 70, 331).setBlockData(Bukkit.createBlockData("minecraft:water[level=8]"));
+        p2.getWorld().getBlockAt(331, 69, 331).setType(Material.AIR);
+
+        ezafk.getConfig().set("afk.anti.flag-only", false);
+        server.getPluginManager().callEvent(new PlayerMoveEvent(p2, p2.getLocation().clone(), p2.getLocation().clone().add(1, 0, 0)));
+
+        // Deterministic zone transition coverage by injecting one zone and driving enter/same/exit states.
+        Field zonesField = AfkZoneManager.class.getDeclaredField("zones");
+        zonesField.setAccessible(true);
+        @SuppressWarnings("unchecked")
+        List<com.gyvex.ezafk.zone.Zone> zones = (List<com.gyvex.ezafk.zone.Zone>) zonesField.get(null);
+        zones.clear();
+        zones.add(new com.gyvex.ezafk.zone.Zone("Injected", p.getWorld().getName(), 340, 60, 340, 350, 80, 350,
+                false, 0L, 0, 0D, "economy", null, null, 1, 0, 0L, false, List.of(), "", 0));
+
+        Field cacheField = MoveListener.class.getDeclaredField("playerZoneCache");
+        cacheField.setAccessible(true);
+        @SuppressWarnings("unchecked")
+        Map<UUID, String> zoneCache = (Map<UUID, String>) cacheField.get(null);
+        zoneCache.clear();
+
+        Method checkTransition = MoveListener.class.getDeclaredMethod("checkZoneTransition", Player.class);
+        checkTransition.setAccessible(true);
+
+        p.teleport(new Location(p.getWorld(), 345, 70, 345));
+        checkTransition.invoke(listener, p); // enter
+        checkTransition.invoke(listener, p); // same-zone
+
+        p.teleport(new Location(p.getWorld(), 360, 70, 360));
+        checkTransition.invoke(listener, p); // exit
+    }
+}
diff --git a/src/test/java/com/gyvex/ezafk/integration/EconomyIntegrationTest.java b/src/test/java/com/gyvex/ezafk/integration/EconomyIntegrationTest.java
new file mode 100644
index 0000000..e4aa78a
--- /dev/null
+++ b/src/test/java/com/gyvex/ezafk/integration/EconomyIntegrationTest.java
@@ -0,0 +1,84 @@
+package com.gyvex.ezafk.integration;
+
+import com.gyvex.ezafk.EzAfk;
+import com.gyvex.ezafk.TestHelpers;
+import net.milkbowl.vault.economy.Economy;
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.mockbukkit.mockbukkit.ServerMock;
+
+import static org.junit.jupiter.api.Assertions.*;
+import static org.mockito.Mockito.*;
+
+class EconomyIntegrationTest {
+
+    private ServerMock server;
+    private EzAfk plugin;
+
+    @BeforeEach
+    void setUp() {
+        IntegrationTestFixtures.clearIntegrationManagerState();
+        server = TestHelpers.startServer();
+        plugin = (EzAfk) TestHelpers.loadPlugin();
+    }
+
+    @AfterEach
+    void tearDown() {
+        TestHelpers.stopServer();
+        IntegrationTestFixtures.clearIntegrationManagerState();
+    }
+
+    @Test
+    void load_keeps_integration_disabled_when_economy_is_off_in_config() {
+        plugin.getConfig().set("economy.enabled", false);
+
+        EconomyIntegration integration = new EconomyIntegration();
+        integration.load();
+
+        assertFalse(integration.isSetup);
+        assertNull(integration.getEconomy());
+    }
+
+    @Test
+    void load_keeps_integration_disabled_when_vault_is_not_enabled() {
+        plugin.getConfig().set("economy.enabled", true);
+        assertFalse(server.getPluginManager().isPluginEnabled("Vault"));
+
+        EconomyIntegration integration = new EconomyIntegration();
+        integration.load();
+
+        assertFalse(integration.isSetup);
+        assertNull(integration.getEconomy());
+    }
+
+    @Test
+    void unload_is_safe_after_failed_load() {
+        plugin.getConfig().set("economy.enabled", true);
+
+        EconomyIntegration integration = new EconomyIntegration();
+        integration.load();
+
+        assertDoesNotThrow(integration::unload);
+        assertFalse(integration.isSetup);
+        assertNull(integration.getEconomy());
+    }
+
+    @Test
+    void load_enables_integration_when_vault_provider_is_registered() {
+        plugin.getConfig().set("economy.enabled", true);
+        Economy economyProvider = mock(Economy.class);
+        when(economyProvider.getName()).thenReturn("MockEconomy");
+        IntegrationTestFixtures.registerVaultProvider(economyProvider);
+
+        EconomyIntegration integration = new EconomyIntegration();
+        integration.load();
+
+        assertTrue(integration.isSetup);
+        assertSame(economyProvider, integration.getEconomy());
+
+        integration.unload();
+        assertFalse(integration.isSetup);
+        assertNull(integration.getEconomy());
+    }
+}
diff --git a/src/test/java/com/gyvex/ezafk/integration/IntegrationTestFixtures.java b/src/test/java/com/gyvex/ezafk/integration/IntegrationTestFixtures.java
new file mode 100644
index 0000000..a6e2811
--- /dev/null
+++ b/src/test/java/com/gyvex/ezafk/integration/IntegrationTestFixtures.java
@@ -0,0 +1,38 @@
+package com.gyvex.ezafk.integration;
+
+import com.gyvex.ezafk.manager.IntegrationManager;
+import net.milkbowl.vault.economy.Economy;
+import org.bukkit.Bukkit;
+import org.bukkit.plugin.Plugin;
+import org.bukkit.plugin.ServicePriority;
+import org.mockbukkit.mockbukkit.MockBukkit;
+
+import java.lang.reflect.Field;
+import java.util.Map;
+
+public final class IntegrationTestFixtures {
+
+    private IntegrationTestFixtures() {
+    }
+
+    public static Plugin registerVaultProvider(Economy economyProvider) {
+        Plugin vault = MockBukkit.createMockPlugin("Vault");
+        Bukkit.getServicesManager().register(Economy.class, economyProvider, vault, ServicePriority.Normal);
+        return vault;
+    }
+
+    @SuppressWarnings("unchecked")
+    public static void clearIntegrationManagerState() {
+        try {
+            Field integrationsField = IntegrationManager.class.getDeclaredField("integrations");
+            integrationsField.setAccessible(true);
+            ((Map<String, com.gyvex.ezafk.integration.Integration>) integrationsField.get(null)).clear();
+
+            Field overridesField = IntegrationManager.class.getDeclaredField("registrationAllowedOverrides");
+            overridesField.setAccessible(true);
+            ((Map<String, Boolean>) overridesField.get(null)).clear();
+        } catch (ReflectiveOperationException ex) {
+            throw new RuntimeException("Failed to reset IntegrationManager test state", ex);
+        }
+    }
+}
diff --git a/src/test/java/com/gyvex/ezafk/integration/MetricsIntegrationTest.java b/src/test/java/com/gyvex/ezafk/integration/MetricsIntegrationTest.java
new file mode 100644
index 0000000..d233502
--- /dev/null
+++ b/src/test/java/com/gyvex/ezafk/integration/MetricsIntegrationTest.java
@@ -0,0 +1,44 @@
+package com.gyvex.ezafk.integration;
+
+import com.gyvex.ezafk.EzAfk;
+import com.gyvex.ezafk.TestHelpers;
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+class MetricsIntegrationTest {
+
+    @BeforeEach
+    void setUp() {
+        IntegrationTestFixtures.clearIntegrationManagerState();
+        TestHelpers.startServer();
+        TestHelpers.loadPlugin(EzAfk.class);
+    }
+
+    @AfterEach
+    void tearDown() {
+        TestHelpers.stopServer();
+        IntegrationTestFixtures.clearIntegrationManagerState();
+    }
+
+    @Test
+    void load_is_guarded_in_test_environment() {
+        MetricsIntegration integration = new MetricsIntegration();
+
+        assertDoesNotThrow(integration::load);
+
+        // In this CI/test environment bStats setup is expected to be unavailable.
+        assertFalse(integration.isSetup);
+        assertNull(integration.getMetrics());
+    }
+
+    @Test
+    void unload_is_safe_after_guarded_load() {
+        MetricsIntegration integration = new MetricsIntegration();
+        integration.load();
+
+        assertDoesNotThrow(integration::unload);
+    }
+}
diff --git a/src/test/java/com/gyvex/ezafk/integration/PlaceholderApiIntegrationTest.java b/src/test/java/com/gyvex/ezafk/integration/PlaceholderApiIntegrationTest.java
new file mode 100644
index 0000000..df775ba
--- /dev/null
+++ b/src/test/java/com/gyvex/ezafk/integration/PlaceholderApiIntegrationTest.java
@@ -0,0 +1,48 @@
+package com.gyvex.ezafk.integration;
+
+import com.gyvex.ezafk.EzAfk;
+import com.gyvex.ezafk.TestHelpers;
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.mockbukkit.mockbukkit.ServerMock;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+class PlaceholderApiIntegrationTest {
+
+    private ServerMock server;
+
+    @BeforeEach
+    void setUp() {
+        IntegrationTestFixtures.clearIntegrationManagerState();
+        server = TestHelpers.startServer();
+        TestHelpers.loadPlugin(EzAfk.class);
+    }
+
+    @AfterEach
+    void tearDown() {
+        TestHelpers.stopServer();
+        IntegrationTestFixtures.clearIntegrationManagerState();
+    }
+
+    @Test
+    void load_skips_setup_when_placeholderapi_plugin_is_absent() {
+        assertNull(server.getPluginManager().getPlugin("PlaceholderAPI"));
+
+        PlaceholderApiIntegration integration = new PlaceholderApiIntegration();
+        integration.load();
+
+        assertFalse(integration.isSetup);
+    }
+
+    @Test
+    void unload_is_safe_when_nothing_was_registered() {
+        PlaceholderApiIntegration integration = new PlaceholderApiIntegration();
+
+        integration.load();
+
+        assertDoesNotThrow(integration::unload);
+        assertFalse(integration.isSetup);
+    }
+}
diff --git a/src/test/java/com/gyvex/ezafk/integration/WorldEditIntegrationTest.java b/src/test/java/com/gyvex/ezafk/integration/WorldEditIntegrationTest.java
new file mode 100644
index 0000000..943f7ad
--- /dev/null
+++ b/src/test/java/com/gyvex/ezafk/integration/WorldEditIntegrationTest.java
@@ -0,0 +1,55 @@
+package com.gyvex.ezafk.integration;
+
+import com.gyvex.ezafk.EzAfk;
+import com.gyvex.ezafk.TestHelpers;
+import org.bukkit.entity.Player;
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.mockbukkit.mockbukkit.ServerMock;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+class WorldEditIntegrationTest {
+
+    private ServerMock server;
+    private EzAfk plugin;
+
+    @BeforeEach
+    void setUp() {
+        server = TestHelpers.startServer();
+        plugin = (EzAfk) TestHelpers.loadPlugin();
+    }
+
+    @AfterEach
+    void tearDown() {
+        TestHelpers.stopServer();
+    }
+
+    @Test
+    void load_can_mark_setup_when_worldedit_classes_are_on_classpath() {
+        assertNull(server.getPluginManager().getPlugin("WorldEdit"));
+
+        WorldEditIntegration integration = new WorldEditIntegration();
+        integration.load();
+
+        assertTrue(integration.isSetup);
+    }
+
+    @Test
+    void unload_resets_setup_state() {
+        WorldEditIntegration integration = new WorldEditIntegration();
+        integration.isSetup = true;
+
+        integration.unload();
+
+        assertFalse(integration.isSetup);
+    }
+
+    @Test
+    void getSelectionLocations_returns_null_when_no_helper_can_resolve_selection() {
+        Player player = server.addPlayer("NoSelectionPlayer");
+
+        assertNull(WorldEditIntegration.getSelectionLocations(plugin, player));
+    }
+}
diff --git a/src/test/java/com/gyvex/ezafk/manager/IntegrationManagerTest.java b/src/test/java/com/gyvex/ezafk/manager/IntegrationManagerTest.java
new file mode 100644
index 0000000..863d032
--- /dev/null
+++ b/src/test/java/com/gyvex/ezafk/manager/IntegrationManagerTest.java
@@ -0,0 +1,105 @@
+package com.gyvex.ezafk.manager;
+
+import com.gyvex.ezafk.integration.Integration;
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+
+import java.lang.reflect.Field;
+import java.util.Map;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+class IntegrationManagerTest {
+
+    private static class CountingIntegration extends Integration {
+        int loadCalls;
+        int unloadCalls;
+
+        @Override
+        public void load() {
+            loadCalls++;
+            isSetup = true;
+        }
+
+        @Override
+        public void unload() {
+            unloadCalls++;
+            isSetup = false;
+        }
+    }
+
+    @BeforeEach
+    void setUp() throws Exception {
+        clearManagerState();
+    }
+
+    @AfterEach
+    void tearDown() throws Exception {
+        clearManagerState();
+    }
+
+    @Test
+    void add_and_get_integration_round_trip() {
+        CountingIntegration integration = new CountingIntegration();
+
+        IntegrationManager.addIntegration("test", integration);
+
+        assertSame(integration, IntegrationManager.getIntegration("test"));
+    }
+
+    @Test
+    void hasIntegration_returns_true_only_when_setup_and_not_blocked() {
+        CountingIntegration integration = new CountingIntegration();
+        IntegrationManager.addIntegration("economy", integration);
+
+        integration.isSetup = false;
+        assertFalse(IntegrationManager.hasIntegration("economy"));
+
+        integration.isSetup = true;
+        assertTrue(IntegrationManager.hasIntegration("economy"));
+
+        IntegrationManager.setRegistrationAllowed("economy", false);
+        assertFalse(IntegrationManager.hasIntegration("economy"));
+
+        IntegrationManager.clearRegistrationOverride("economy");
+        assertTrue(IntegrationManager.hasIntegration("economy"));
+    }
+
+    @Test
+    void hasIntegration_returns_false_for_unknown_id() {
+        assertFalse(IntegrationManager.hasIntegration("missing"));
+    }
+
+    @Test
+    void load_and_unload_call_each_registered_integration() {
+        CountingIntegration one = new CountingIntegration();
+        CountingIntegration two = new CountingIntegration();
+
+        IntegrationManager.addIntegration("one", one);
+        IntegrationManager.addIntegration("two", two);
+
+        IntegrationManager.load();
+        assertEquals(1, one.loadCalls);
+        assertEquals(1, two.loadCalls);
+        assertTrue(one.isSetup);
+        assertTrue(two.isSetup);
+
+        IntegrationManager.unload();
+        assertEquals(1, one.unloadCalls);
+        assertEquals(1, two.unloadCalls);
+        assertFalse(one.isSetup);
+        assertFalse(two.isSetup);
+    }
+
+    @SuppressWarnings("unchecked")
+    private static void clearManagerState() throws Exception {
+        Field integrationsField = IntegrationManager.class.getDeclaredField("integrations");
+        integrationsField.setAccessible(true);
+        ((Map<String, Integration>) integrationsField.get(null)).clear();
+
+        Field overridesField = IntegrationManager.class.getDeclaredField("registrationAllowedOverrides");
+        overridesField.setAccessible(true);
+        ((Map<String, Boolean>) overridesField.get(null)).clear();
+    }
+}
diff --git a/src/test/java/com/gyvex/ezafk/repository/AfkTimeModelCoreTest.java b/src/test/java/com/gyvex/ezafk/repository/AfkTimeModelCoreTest.java
new file mode 100644
index 0000000..72cfbdf
--- /dev/null
+++ b/src/test/java/com/gyvex/ezafk/repository/AfkTimeModelCoreTest.java
@@ -0,0 +1,22 @@
+package com.gyvex.ezafk.repository;
+
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+
+class AfkTimeModelCoreTest {
+
+    @Test
+    void model_exposes_prefix_factory_and_seconds_accessors() {
+        AfkTimeModel model = new AfkTimeModel("player-id");
+
+        assertEquals("afk_times", AfkTimeModel.TABLE_PREFIX);
+        assertNotNull(AfkTimeModel.FACTORY);
+        assertNotNull(AfkTimeModel.factory());
+
+        assertEquals(0L, model.getSeconds());
+        model.setSeconds(123L);
+        assertEquals(123L, model.getSeconds());
+    }
+}
diff --git a/src/test/java/com/gyvex/ezafk/repository/StorageFactoryAndSqlBackendsCoreTest.java b/src/test/java/com/gyvex/ezafk/repository/StorageFactoryAndSqlBackendsCoreTest.java
new file mode 100644
index 0000000..62cec6b
--- /dev/null
+++ b/src/test/java/com/gyvex/ezafk/repository/StorageFactoryAndSqlBackendsCoreTest.java
@@ -0,0 +1,113 @@
+package com.gyvex.ezafk.repository;
+
+import com.gyvex.ezafk.TestHelpers;
+import com.gyvex.ezafk.bootstrap.Registry;
+import com.gyvex.ezafk.repository.mysql.MySQLStorage;
+import com.gyvex.ezafk.repository.sqlite.SQLiteStorage;
+import com.gyvex.ezafk.repository.yaml.YamlStorage;
+import org.bukkit.plugin.java.JavaPlugin;
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+
+import java.util.Map;
+import java.util.UUID;
+
+import static org.junit.jupiter.api.Assertions.assertDoesNotThrow;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertInstanceOf;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+class StorageFactoryAndSqlBackendsCoreTest {
+
+    private org.mockbukkit.mockbukkit.ServerMock server;
+    private JavaPlugin plugin;
+
+    @BeforeEach
+    void setUp() {
+        server = TestHelpers.startServer();
+        plugin = TestHelpers.loadPlugin();
+    }
+
+    @AfterEach
+    void tearDown() {
+        TestHelpers.stopServer();
+    }
+
+    @Test
+    void storage_factory_returns_expected_backends_by_config_type() {
+        plugin.getConfig().set("storage.type", "yaml");
+        assertInstanceOf(YamlStorage.class, StorageFactory.create());
+
+        plugin.getConfig().set("storage.type", "sqlite");
+        assertInstanceOf(SQLiteStorage.class, StorageFactory.create());
+
+        plugin.getConfig().set("storage.type", "mysql");
+        assertInstanceOf(MySQLStorage.class, StorageFactory.create());
+
+        plugin.getConfig().set("storage.type", "unsupported-type");
+        assertInstanceOf(YamlStorage.class, StorageFactory.create());
+
+        plugin.getConfig().set("storage.type", null);
+        assertInstanceOf(YamlStorage.class, StorageFactory.create());
+    }
+
+    @Test
+    void sql_backends_handle_core_guard_paths_without_init() {
+        SQLiteStorage sqlite = new SQLiteStorage();
+        MySQLStorage mysql = new MySQLStorage();
+
+        UUID id = UUID.randomUUID();
+
+        Map<UUID, Long> sqliteLoaded = sqlite.loadAll();
+        assertTrue(sqliteLoaded.isEmpty());
+        assertDoesNotThrow(() -> sqlite.savePlayerAfkTime(null, 1L));
+        assertDoesNotThrow(() -> sqlite.deletePlayer(null));
+        assertEquals(0L, sqlite.getPlayerAfkTime(null));
+        assertDoesNotThrow(sqlite::saveAll);
+        assertDoesNotThrow(sqlite::shutdown);
+
+        Map<UUID, Long> mysqlLoaded = mysql.loadAll();
+        assertTrue(mysqlLoaded.isEmpty());
+        assertDoesNotThrow(() -> mysql.savePlayerAfkTime(null, 1L));
+        assertDoesNotThrow(() -> mysql.savePlayerAfkTime(id, 1L));
+        assertDoesNotThrow(() -> mysql.deletePlayer(null));
+        assertEquals(0L, mysql.getPlayerAfkTime(null));
+        assertEquals(0L, mysql.getPlayerAfkTime(id));
+        assertDoesNotThrow(mysql::saveAll);
+        assertDoesNotThrow(mysql::shutdown);
+    }
+
+    @Test
+    void sqlite_storage_init_failure_path_is_handled() {
+        SQLiteStorage sqlite = new SQLiteStorage();
+        assertThrows(Exception.class, sqlite::init);
+
+        UUID playerId = UUID.randomUUID();
+        assertTrue(sqlite.loadAll().isEmpty());
+        sqlite.savePlayerAfkTime(playerId, 123L);
+        sqlite.deletePlayer(playerId);
+        assertEquals(0L, sqlite.getPlayerAfkTime(playerId));
+
+        sqlite.saveAll();
+        sqlite.shutdown();
+    }
+
+    @Test
+    void mysql_storage_init_failure_path_is_handled() {
+        // Force a fast connection failure to cover init error handling path.
+        Registry.get().getConfigManager().getMysqlConfig().set("host", "127.0.0.1");
+        Registry.get().getConfigManager().getMysqlConfig().set("port", 1);
+        Registry.get().getConfigManager().getMysqlConfig().set("database", "ezafk_test");
+        Registry.get().getConfigManager().getMysqlConfig().set("username", "nouser");
+        Registry.get().getConfigManager().getMysqlConfig().set("password", "nopass");
+
+        MySQLStorage mysql = new MySQLStorage();
+        assertThrows(Exception.class, mysql::init);
+
+        assertTrue(mysql.loadAll().isEmpty());
+        assertFalse(mysql.loadAll().containsKey(UUID.randomUUID()));
+    }
+}
diff --git a/src/test/java/com/gyvex/ezafk/repository/mysql/MySQLStorageTestcontainersTest.java b/src/test/java/com/gyvex/ezafk/repository/mysql/MySQLStorageTestcontainersTest.java
new file mode 100644
index 0000000..38a1b42
--- /dev/null
+++ b/src/test/java/com/gyvex/ezafk/repository/mysql/MySQLStorageTestcontainersTest.java
@@ -0,0 +1,74 @@
+package com.gyvex.ezafk.repository.mysql;
+
+import com.gyvex.ezafk.TestHelpers;
+import com.gyvex.ezafk.bootstrap.Registry;
+import org.bukkit.plugin.java.JavaPlugin;
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.Assumptions;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.testcontainers.DockerClientFactory;
+import org.testcontainers.containers.MySQLContainer;
+
+import java.time.Duration;
+import java.util.Map;
+import java.util.UUID;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+class MySQLStorageTestcontainersTest {
+
+    private org.mockbukkit.mockbukkit.ServerMock server;
+    private JavaPlugin plugin;
+
+    @BeforeEach
+    void setUp() {
+        server = TestHelpers.startServer();
+        plugin = TestHelpers.loadPlugin();
+    }
+
+    @AfterEach
+    void tearDown() {
+        TestHelpers.stopServer();
+    }
+
+    @Test
+    void mysql_storage_init_and_crud_with_testcontainers() throws Exception {
+        Assumptions.assumeTrue(
+                DockerClientFactory.instance().isDockerAvailable(),
+                "Docker is not available; skipping Testcontainers MySQL test"
+        );
+
+        try (MySQLContainer<?> mysql = new MySQLContainer<>("mysql:8.4.0")
+                .withDatabaseName("ezafk_test")
+                .withUsername("ezafk")
+                .withPassword("ezafk")
+                .withStartupTimeout(Duration.ofMinutes(2))) {
+            mysql.start();
+
+            Registry.get().getConfigManager().getMysqlConfig().set("host", mysql.getHost());
+            Registry.get().getConfigManager().getMysqlConfig().set("port", mysql.getFirstMappedPort());
+            Registry.get().getConfigManager().getMysqlConfig().set("database", mysql.getDatabaseName());
+            Registry.get().getConfigManager().getMysqlConfig().set("username", mysql.getUsername());
+            Registry.get().getConfigManager().getMysqlConfig().set("password", mysql.getPassword());
+
+            MySQLStorage storage = new MySQLStorage();
+            storage.init();
+
+            UUID playerId = UUID.randomUUID();
+            storage.savePlayerAfkTime(playerId, 321L);
+            assertEquals(321L, storage.getPlayerAfkTime(playerId));
+
+            Map<UUID, Long> loaded = storage.loadAll();
+            assertTrue(loaded.containsKey(playerId));
+            assertEquals(321L, loaded.get(playerId));
+
+            storage.deletePlayer(playerId);
+            assertEquals(0L, storage.getPlayerAfkTime(playerId));
+
+            storage.saveAll();
+            storage.shutdown();
+        }
+    }
+}
diff --git a/src/test/java/com/gyvex/ezafk/repository/yaml/YamlDataStoreCoreTest.java b/src/test/java/com/gyvex/ezafk/repository/yaml/YamlDataStoreCoreTest.java
new file mode 100644
index 0000000..56e84eb
--- /dev/null
+++ b/src/test/java/com/gyvex/ezafk/repository/yaml/YamlDataStoreCoreTest.java
@@ -0,0 +1,103 @@
+package com.gyvex.ezafk.repository.yaml;
+
+import com.github.ezframework.javaquerybuilder.query.Query;
+import com.github.ezframework.javaquerybuilder.query.condition.Condition;
+import com.github.ezframework.javaquerybuilder.query.condition.ConditionEntry;
+import com.github.ezframework.javaquerybuilder.query.condition.Connector;
+import com.github.ezframework.javaquerybuilder.query.condition.Operator;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.io.TempDir;
+
+import java.io.File;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Optional;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+class YamlDataStoreCoreTest {
+
+    @TempDir
+    File tempDir;
+
+    @Test
+    void datastore_save_load_exists_delete_and_flush_reload_work() throws Exception {
+        File file = new File(tempDir, "afk_times.yml");
+        YamlDataStore store = new YamlDataStore(file);
+
+        Map<String, Object> data = new LinkedHashMap<>();
+        data.put("seconds", 42L);
+
+        store.save("afk_times/id-1", data);
+        assertTrue(store.exists("afk_times/id-1"));
+
+        Optional<Map<String, Object>> loaded = store.load("afk_times/id-1");
+        assertTrue(loaded.isPresent());
+        assertEquals(42L, ((Number) loaded.get().get("seconds")).longValue());
+
+        store.flush();
+
+        YamlDataStore reloaded = new YamlDataStore(file);
+        Optional<Map<String, Object>> loadedAfterReload = reloaded.load("afk_times/id-1");
+        assertTrue(loadedAfterReload.isPresent());
+        assertEquals(42L, ((Number) loadedAfterReload.get().get("seconds")).longValue());
+
+        reloaded.delete("afk_times/id-1");
+        assertFalse(reloaded.exists("afk_times/id-1"));
+    }
+
+    @Test
+    void datastore_query_supports_limit_and_and_or_conditions() throws Exception {
+        File file = new File(tempDir, "query.yml");
+        YamlDataStore store = new YamlDataStore(file);
+
+        Map<String, Object> one = new LinkedHashMap<>();
+        one.put("seconds", 10L);
+        one.put("status", "afk");
+
+        Map<String, Object> two = new LinkedHashMap<>();
+        two.put("seconds", 200L);
+        two.put("status", "active");
+
+        Map<String, Object> three = new LinkedHashMap<>();
+        three.put("seconds", 300L);
+        three.put("status", "afk");
+
+        store.save("afk_times/id-1", one);
+        store.save("afk_times/id-2", two);
+        store.save("afk_times/id-3", three);
+
+        Query all = new Query();
+        all.setLimit(-1);
+        List<String> allIds = store.query(all);
+        assertEquals(3, allIds.size());
+
+        Query limited = new Query();
+        limited.setLimit(2);
+        List<String> limitedIds = store.query(limited);
+        assertEquals(2, limitedIds.size());
+
+        Query andQuery = new Query();
+        andQuery.setLimit(-1);
+        andQuery.setConditions(List.of(
+                new ConditionEntry("status", new Condition(Operator.EQ, "afk"), Connector.AND),
+            new ConditionEntry("status", new Condition(Operator.NEQ, "active"), Connector.AND)
+        ));
+        List<String> andIds = store.query(andQuery);
+        assertEquals(2, andIds.size());
+        assertTrue(andIds.contains("id-1"));
+        assertTrue(andIds.contains("id-3"));
+
+        Query orQuery = new Query();
+        orQuery.setLimit(-1);
+        orQuery.setConditions(List.of(
+                new ConditionEntry("status", new Condition(Operator.EQ, "active"), Connector.AND),
+            new ConditionEntry("status", new Condition(Operator.EQ, "afk"), Connector.OR)
+        ));
+        List<String> orIds = store.query(orQuery);
+        assertEquals(3, orIds.size());
+    }
+}
diff --git a/src/test/java/com/gyvex/ezafk/repository/yaml/YamlStorageCoreTest.java b/src/test/java/com/gyvex/ezafk/repository/yaml/YamlStorageCoreTest.java
new file mode 100644
index 0000000..aa7b8bb
--- /dev/null
+++ b/src/test/java/com/gyvex/ezafk/repository/yaml/YamlStorageCoreTest.java
@@ -0,0 +1,83 @@
+package com.gyvex.ezafk.repository.yaml;
+
+import com.gyvex.ezafk.TestHelpers;
+import com.gyvex.ezafk.bootstrap.Registry;
+import org.bukkit.configuration.file.YamlConfiguration;
+import org.bukkit.plugin.java.JavaPlugin;
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+
+import java.io.File;
+import java.util.Map;
+import java.util.UUID;
+
+import static org.junit.jupiter.api.Assertions.assertDoesNotThrow;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+class YamlStorageCoreTest {
+
+    private org.mockbukkit.mockbukkit.ServerMock server;
+    private JavaPlugin plugin;
+
+    @BeforeEach
+    void setUp() {
+        server = TestHelpers.startServer();
+        plugin = TestHelpers.loadPlugin();
+    }
+
+    @AfterEach
+    void tearDown() {
+        TestHelpers.stopServer();
+    }
+
+    @Test
+    void yaml_storage_crud_loadAll_and_persistence_paths() throws Exception {
+        YamlStorage storage = new YamlStorage();
+        storage.init();
+
+        UUID playerId = UUID.randomUUID();
+
+        storage.savePlayerAfkTime(playerId, 99L);
+        assertEquals(99L, storage.getPlayerAfkTime(playerId));
+
+        Map<UUID, Long> loaded = storage.loadAll();
+        assertTrue(loaded.containsKey(playerId));
+        assertEquals(99L, loaded.get(playerId));
+
+        storage.deletePlayer(playerId);
+        assertEquals(0L, storage.getPlayerAfkTime(playerId));
+
+        // Null guards should be no-op paths.
+        assertDoesNotThrow(() -> storage.savePlayerAfkTime(null, 10L));
+        assertDoesNotThrow(() -> storage.deletePlayer(null));
+        assertEquals(0L, storage.getPlayerAfkTime(null));
+
+        // saveAll and shutdown both flush datastore.
+        UUID persistentId = UUID.randomUUID();
+        storage.savePlayerAfkTime(persistentId, 15L);
+        storage.saveAll();
+        storage.shutdown();
+
+        File file = new File(Registry.get().getPlugin().getDataFolder(), "afk_times.yml");
+        YamlConfiguration cfg = YamlConfiguration.loadConfiguration(file);
+        Object persistedSeconds = cfg.get("afk_times." + persistentId + ".seconds");
+        assertEquals(15L, ((Number) persistedSeconds).longValue());
+    }
+
+    @Test
+    void yaml_storage_loadAll_ignores_invalid_uuid_keys() throws Exception {
+        File file = new File(Registry.get().getPlugin().getDataFolder(), "afk_times.yml");
+        YamlConfiguration cfg = YamlConfiguration.loadConfiguration(file);
+        cfg.set("afk_times.not-a-uuid.seconds", 77L);
+        cfg.save(file);
+
+        YamlStorage storage = new YamlStorage();
+        storage.init();
+
+        Map<UUID, Long> loaded = storage.loadAll();
+        assertFalse(loaded.containsValue(77L));
+    }
+}

From 45421ed036f88e72812b83c2f3fcd081de992285 Mon Sep 17 00:00:00 2001
From: ez-plugins <ezplugins@outlook.com>
Date: Wed, 8 Jul 2026 12:24:13 +0200
Subject: [PATCH 4/4] ci: prevent smoke test server shutdown hangs

---
 .github/workflows/ci.yml | 30 ++++++++++++++++++++++++++++++
 1 file changed, 30 insertions(+)

diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index 1f9b41a..a42299c 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -163,6 +163,16 @@ jobs:
             fi
           done
           kill $SERVER_PID 2>/dev/null || true
+          for _ in $(seq 1 15); do
+            if ! kill -0 $SERVER_PID 2>/dev/null; then
+              break
+            fi
+            sleep 1
+          done
+          if kill -0 $SERVER_PID 2>/dev/null; then
+            echo "Server did not stop after SIGTERM; forcing shutdown"
+            kill -9 $SERVER_PID 2>/dev/null || true
+          fi
           wait $SERVER_PID 2>/dev/null || true
 
       - name: Assert no EzAfk errors
@@ -255,6 +265,16 @@ jobs:
             fi
           done
           kill $SERVER_PID 2>/dev/null || true
+          for _ in $(seq 1 15); do
+            if ! kill -0 $SERVER_PID 2>/dev/null; then
+              break
+            fi
+            sleep 1
+          done
+          if kill -0 $SERVER_PID 2>/dev/null; then
+            echo "Server did not stop after SIGTERM; forcing shutdown"
+            kill -9 $SERVER_PID 2>/dev/null || true
+          fi
           wait $SERVER_PID 2>/dev/null || true
 
       - name: Assert no EzAfk errors
@@ -347,6 +367,16 @@ jobs:
             fi
           done
           kill $SERVER_PID 2>/dev/null || true
+          for _ in $(seq 1 15); do
+            if ! kill -0 $SERVER_PID 2>/dev/null; then
+              break
+            fi
+            sleep 1
+          done
+          if kill -0 $SERVER_PID 2>/dev/null; then
+            echo "Server did not stop after SIGTERM; forcing shutdown"
+            kill -9 $SERVER_PID 2>/dev/null || true
+          fi
           wait $SERVER_PID 2>/dev/null || true
 
       - name: Assert no EzAfk errors