fix(assassin): preserve external potion effects

design/log.md

@@ -6,6 +6,47 @@ description: Chronological record of material decisions affecting the Spigot Tyr
 
 # Spigot Tyrant Design Log
 
+## 2026-08-18 — Preserve ordinary potion effects
+
+- Corrected Assassin effect maintenance so it refreshes active Tyrant abilities without removing invisibility, Speed, or Weakness supplied by potions, commands, or other plugins.
+- Expired or inapplicable Tyrant-managed effects stop refreshing and expire naturally within their short 30-tick maintenance duration, while double-jump flight cleanup remains immediate.
+- Reopened and completed US-005 with regression coverage; verified `./gradlew clean check jar`.
+
+## 2026-08-14 — Opt-out proximity glow completed
+
+- Extended US-011 with a globally visible green outline for opted-out players in the Tyrant's world and configured range while the event is running.
+- A periodic controller removes the glow when eligibility, proximity, world, lifecycle, or player availability changes and clears managed state on logout and shutdown.
+- Scoreboard presentation records and restores each player's previous team and glowing state instead of permanently replacing unrelated presentation.
+- Verified inclusive range behavior, lifecycle and availability gating, green presentation, restoration, and the full Gradle build.
+
+## 2026-08-14 — Opt-out proximity glow started
+
+- US-011 is reopened for a test-first green outline on opted-out players near the Tyrant during a running event, using the existing configurable Tyrant range.
+- Cleanup will cover range, world, participation, lifecycle, availability, shutdown, and restoration of pre-existing scoreboard-team membership.
+
+## 2026-08-14 — Join messaging refinement completed
+
+- Updated US-011 so join output no longer announces running, paused, or unstarted lifecycle state.
+- Eligible unassigned players now see the neutral prompt, `Use /tyrant optout if you do not want to participate in Tyrant events.`
+- Role, class, ability, cooldown, and existing opt-out details remain unchanged.
+- Verified both assigned and unassigned join output with automated tests.
+
+## 2026-08-14 — Join messaging refinement started
+
+- US-011 is reopened to remove lifecycle announcements from join output and make the opt-out prompt refer generally to Tyrant events.
+
+## 2026-08-14 — Opt-out combat protection completed
+
+- Extended US-011 with bidirectional combat isolation between opted-out players and the Tyrant, Assassin, Fixer, or Tamer while the event is running.
+- Direct player attacks and player-fired projectiles are cancelled at highest event priority, and the attacker is told that the target has chosen not to participate in the Tyrant event.
+- Paused, unstarted, and unrelated combat remains ordinary Minecraft gameplay.
+- Verified both attack directions, every Tyrant-side class, projectile attribution, lifecycle gating, and unrelated combat with automated tests.
+
+## 2026-08-14 — Opt-out combat protection started
+
+- US-011 is reopened for test-first running-event combat isolation between opted-out players and the Tyrant or Tyrant-side class holders.
+- Paused and unstarted gameplay remains ordinary Minecraft combat; blocked direct and projectile attackers receive a concise Tyrant event participation message.
+
 ## 2026-08-14 — Tamer completed
 
 - Completed US-007 with the no-cooldown owner-bound Tamer's Lead, server-generated entity snapshots, durable capture IDs, and one bound Captured Mob item per entity.

design/user-stories/us-005-use-assassin-abilities.md

@@ -20,6 +20,13 @@ As the **Assassin**, I want stealth and burst mobility so that I can ambush oppo
 - [x] Grounding and supported movement reset jump availability only after the 60-second cooldown has elapsed.
 - [x] Ability cooldowns use unpaused elapsed time and survive death, logout, and restart.
 - [x] The player can inspect remaining cooldowns and receives clear feedback when an activation is unavailable.
+- [x] Tyrant removes only Assassin potion effects that Tyrant itself applied.
+- [x] Invisibility from potions, commands, or other plugins remains active for Assassins and non-Assassins.
+- [x] Tyrant-managed Assassin effects are still removed when abilities expire, roles change, games stop, or the plugin disables.
+
+## Validation
+
+Automated controller tests verify that inactive Tyrant state does not alter ordinary potion effects, active Assassin invisibility is refreshed, and refresh stops at expiry so the short managed effect expires naturally. The complete `./gradlew clean check jar` lifecycle passes.
 
 ## Related
 

design/user-stories/us-011-inform-and-manage-participation.md

@@ -11,7 +11,8 @@ As a **player**, I want to understand my status and control my eligibility so th
 
 ## Acceptance criteria
 
-- [x] On join, a player is told the game status and their role, class, subclass, abilities, and relevant cooldowns.
+- [x] On join, lifecycle state is omitted while role, class, subclass, ability, and relevant cooldown information remains available when applicable.
+- [x] Eligible players are invited to opt out of Tyrant events without implying that an event is currently running.
 - [x] An unassigned opted-in player is told that they are eligible and shown the opt-out command.
 - [x] An opted-out player is told when they may opt back in.
 - [x] An unassigned player can opt out through a command.
@@ -20,6 +21,15 @@ As a **player**, I want to understand my status and control my eligibility so th
 - [x] A player cannot opt back in until seven days have elapsed by default.
 - [x] The opt-out duration is configurable, uses unpaused elapsed time, and survives restart.
 - [x] Participation commands are idempotent and clearly report current status and remaining time.
+- [x] While the event is running, damage is cancelled when the Tyrant or an Assassin, Fixer, or Tamer attacks an opted-out player.
+- [x] While the event is running, damage is cancelled when an opted-out player attacks the Tyrant or an Assassin, Fixer, or Tamer.
+- [x] Cancelled attackers are told that the target has chosen not to take part in the Tyrant event.
+- [x] Protection covers direct player attacks and player-fired projectiles without changing unrelated combat.
+- [x] Participation combat protection does not apply while the event is paused or not started.
+- [x] While the event is running, an opted-out player in the same world and within the configured Tyrant range has a green glowing outline visible to everyone.
+- [x] The opt-out glow is removed when proximity, participation, player availability, Tyrant availability, or running-event requirements stop being satisfied.
+- [x] Existing scoreboard-team membership is restored after the opt-out glow ends, and plugin shutdown safely clears managed glow state.
+- [x] Opt-out proximity glow does not apply while the event is paused or not started.
 
 ## Related
 

src/main/java/games/dmg/spigottyrant/AssassinEffectController.java

@@ -3,6 +3,7 @@ package games.dmg.spigottyrant;
 import java.time.Clock;
 import java.time.Instant;
 import java.util.HashSet;
+import java.util.Objects;
 import java.util.Set;
 import java.util.UUID;
 import org.bukkit.GameMode;
@@ -17,6 +18,7 @@ public final class AssassinEffectController implements Runnable {
     private final Server server;
     private final PluginSettings settings;
     private final Clock clock;
+    private final EffectApplier effectApplier;
     private final Set<UUID> grantedFlight = new HashSet<>();
 
     public AssassinEffectController(
@@ -25,10 +27,21 @@ public final class AssassinEffectController implements Runnable {
         PluginSettings settings,
         Clock clock
     ) {
-        this.stateManager = stateManager;
-        this.server = server;
-        this.settings = settings;
-        this.clock = clock;
+        this(stateManager, server, settings, clock, new BukkitEffectApplier());
+    }
+
+    AssassinEffectController(
+        TyrantStateManager stateManager,
+        Server server,
+        PluginSettings settings,
+        Clock clock,
+        EffectApplier effectApplier
+    ) {
+        this.stateManager = Objects.requireNonNull(stateManager, "stateManager");
+        this.server = Objects.requireNonNull(server, "server");
+        this.settings = Objects.requireNonNull(settings, "settings");
+        this.clock = Objects.requireNonNull(clock, "clock");
+        this.effectApplier = Objects.requireNonNull(effectApplier, "effectApplier");
     }
 
     @Override
@@ -43,15 +56,15 @@ public final class AssassinEffectController implements Runnable {
             }
             applyWhileActive(
                 player, state, Ability.ASSASSIN_INVISIBILITY_ACTIVE,
-                PotionEffectType.INVISIBILITY, 0, false
+                EffectKind.INVISIBILITY, 0, false
             );
             applyWhileActive(
                 player, state, Ability.ASSASSIN_SPEED_ACTIVE,
-                PotionEffectType.SPEED, 0, true
+                EffectKind.SPEED, 0, true
             );
             applyWhileActive(
                 player, state, Ability.ASSASSIN_WEAKNESS_ACTIVE,
-                PotionEffectType.WEAKNESS, settings.assassinWeaknessLevel() - 1, true
+                EffectKind.WEAKNESS, settings.assassinWeaknessLevel() - 1, true
             );
             boolean jumpReady = !state.cooldownEnds().getOrDefault(
                 Ability.ASSASSIN_DOUBLE_JUMP, Instant.MIN
@@ -71,29 +84,52 @@ public final class AssassinEffectController implements Runnable {
         Player player,
         PlayerState state,
         Ability ability,
-        PotionEffectType type,
+        EffectKind effect,
         int amplifier,
         boolean particles
     ) {
         if (state.cooldownEnds().getOrDefault(ability, Instant.MIN).isAfter(clock.instant())) {
-            player.addPotionEffect(new PotionEffect(
-                type, EFFECT_TICKS, amplifier, false, particles, true
-            ));
-        } else {
-            player.removePotionEffect(type);
+            effectApplier.apply(player, effect, amplifier, particles);
         }
     }
 
     private void clear(Player player) {
-        player.removePotionEffect(PotionEffectType.INVISIBILITY);
-        player.removePotionEffect(PotionEffectType.SPEED);
-        player.removePotionEffect(PotionEffectType.WEAKNESS);
         if (grantedFlight.remove(player.getUniqueId()) && isSurvivalLike(player)) {
             player.setAllowFlight(false);
             player.setFlying(false);
         }
     }
 
+    enum EffectKind {
+        INVISIBILITY,
+        SPEED,
+        WEAKNESS
+    }
+
+    @FunctionalInterface
+    interface EffectApplier {
+        void apply(Player player, EffectKind effect, int amplifier, boolean particles);
+    }
+
+    private static final class BukkitEffectApplier implements EffectApplier {
+        @Override
+        public void apply(
+            Player player,
+            EffectKind effect,
+            int amplifier,
+            boolean particles
+        ) {
+            PotionEffectType type = switch (effect) {
+                case INVISIBILITY -> PotionEffectType.INVISIBILITY;
+                case SPEED -> PotionEffectType.SPEED;
+                case WEAKNESS -> PotionEffectType.WEAKNESS;
+            };
+            player.addPotionEffect(new PotionEffect(
+                type, EFFECT_TICKS, amplifier, false, particles, true
+            ));
+        }
+    }
+
     private static boolean isGrounded(Player player) {
         return !player.getLocation().clone().subtract(0.0, 0.1, 0.0)
             .getBlock().isPassable();

src/main/java/games/dmg/spigottyrant/OptOutGlowController.java

@@ -0,0 +1,127 @@
+package games.dmg.spigottyrant;
+
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.Map;
+import java.util.Objects;
+import java.util.Set;
+import java.util.UUID;
+import org.bukkit.ChatColor;
+import org.bukkit.Server;
+import org.bukkit.entity.Player;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.EventPriority;
+import org.bukkit.event.Listener;
+import org.bukkit.event.player.PlayerQuitEvent;
+import org.bukkit.scoreboard.Scoreboard;
+import org.bukkit.scoreboard.ScoreboardManager;
+import org.bukkit.scoreboard.Team;
+
+public final class OptOutGlowController implements Runnable, Listener {
+    private static final String TEAM_NAME = "tyrant-optout";
+    private final TyrantStateManager stateManager;
+    private final Server server;
+    private final PluginSettings settings;
+    private final Scoreboard scoreboard;
+    private final Team greenTeam;
+    private final Map<UUID, PreviousPresentation> managed = new HashMap<>();
+
+    public OptOutGlowController(
+        TyrantStateManager stateManager,
+        Server server,
+        PluginSettings settings
+    ) {
+        this.stateManager = stateManager;
+        this.server = server;
+        this.settings = settings;
+        ScoreboardManager manager = Objects.requireNonNull(
+            server.getScoreboardManager(), "Scoreboard manager is unavailable"
+        );
+        scoreboard = manager.getMainScoreboard();
+        Team existing = scoreboard.getTeam(TEAM_NAME);
+        greenTeam = existing == null ? scoreboard.registerNewTeam(TEAM_NAME) : existing;
+        greenTeam.setColor(ChatColor.GREEN);
+    }
+
+    @Override
+    public void run() {
+        GameState game = stateManager.game();
+        Player tyrant = game.tyrantId().map(server::getPlayer).orElse(null);
+        boolean tyrantAvailable = tyrant != null && !tyrant.isDead();
+        Set<UUID> online = new HashSet<>();
+        for (Player player : server.getOnlinePlayers()) {
+            online.add(player.getUniqueId());
+            PlayerState state = stateManager.players().get(player.getUniqueId());
+            boolean sameWorld = tyrantAvailable && !player.isDead()
+                && player.getWorld().equals(tyrant.getWorld());
+            double distanceSquared = sameWorld
+                ? player.getLocation().distanceSquared(tyrant.getLocation())
+                : Double.POSITIVE_INFINITY;
+            boolean shouldGlow = state != null && OptOutGlowPolicy.shouldGlow(
+                game, state, tyrantAvailable, sameWorld, distanceSquared,
+                settings.tyrantRangeBlocks()
+            );
+            if (shouldGlow && !managed.containsKey(player.getUniqueId())) {
+                apply(player);
+            } else if (!shouldGlow && managed.containsKey(player.getUniqueId())) {
+                restore(player.getUniqueId(), player);
+            }
+        }
+        for (UUID playerId : Set.copyOf(managed.keySet())) {
+            if (!online.contains(playerId) && server.getPlayer(playerId) == null) {
+                restore(playerId, null);
+            }
+        }
+    }
+
+    @EventHandler(priority = EventPriority.MONITOR)
+    public void onQuit(PlayerQuitEvent event) {
+        if (managed.containsKey(event.getPlayer().getUniqueId())) {
+            restore(event.getPlayer().getUniqueId(), event.getPlayer());
+        }
+    }
+
+    public void clearAll() {
+        for (UUID playerId : Set.copyOf(managed.keySet())) {
+            restore(playerId, server.getPlayer(playerId));
+        }
+    }
+
+    private void apply(Player player) {
+        Team previousTeam = scoreboard.getEntryTeam(player.getName());
+        if (previousTeam == greenTeam) {
+            previousTeam = null;
+        }
+        managed.put(
+            player.getUniqueId(),
+            new PreviousPresentation(player.getName(), previousTeam, player.isGlowing())
+        );
+        greenTeam.addEntry(player.getName());
+        player.setGlowing(true);
+    }
+
+    private void restore(UUID playerId, Player player) {
+        PreviousPresentation previous = managed.remove(playerId);
+        if (previous == null) {
+            return;
+        }
+        greenTeam.removeEntry(previous.playerName());
+        if (previous.team() != null) {
+            try {
+                previous.team().addEntry(previous.playerName());
+            } catch (IllegalStateException ignored) {
+                // The prior team was removed while this plugin managed the entry.
+            }
+        }
+        if (player != null) {
+            player.setGlowing(previous.glowing());
+        }
+    }
+
+    private record PreviousPresentation(
+        String playerName,
+        Team team,
+        boolean glowing
+    ) {
+    }
+}

src/main/java/games/dmg/spigottyrant/OptOutGlowPolicy.java

@@ -0,0 +1,22 @@
+package games.dmg.spigottyrant;
+
+public final class OptOutGlowPolicy {
+    private OptOutGlowPolicy() {
+    }
+
+    public static boolean shouldGlow(
+        GameState game,
+        PlayerState player,
+        boolean tyrantAvailable,
+        boolean playerAvailableInTyrantWorld,
+        double distanceSquared,
+        double rangeBlocks
+    ) {
+        return game.lifecycle() == GameLifecycle.RUNNING
+            && game.tyrantId().isPresent()
+            && player.optedOutUntil().isPresent()
+            && tyrantAvailable
+            && playerAvailableInTyrantWorld
+            && distanceSquared <= rangeBlocks * rangeBlocks;
+    }
+}

src/main/java/games/dmg/spigottyrant/ParticipationCombatListener.java

@@ -0,0 +1,64 @@
+package games.dmg.spigottyrant;
+
+import java.util.Map;
+import java.util.Optional;
+import java.util.UUID;
+import org.bukkit.ChatColor;
+import org.bukkit.entity.Player;
+import org.bukkit.entity.Projectile;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.EventPriority;
+import org.bukkit.event.Listener;
+import org.bukkit.event.entity.EntityDamageByEntityEvent;
+
+public final class ParticipationCombatListener implements Listener {
+    public static final String OPTED_OUT_MESSAGE =
+        "That player has chosen not to take part in the Tyrant event.";
+
+    private final TyrantStateManager stateManager;
+    private final ParticipationCombatService combat;
+
+    public ParticipationCombatListener(
+        TyrantStateManager stateManager,
+        ParticipationCombatService combat
+    ) {
+        this.stateManager = stateManager;
+        this.combat = combat;
+    }
+
+    @EventHandler(priority = EventPriority.HIGHEST, ignoreCancelled = true)
+    public void onDamage(EntityDamageByEntityEvent event) {
+        if (!(event.getEntity() instanceof Player target)) {
+            return;
+        }
+        Optional<Player> attacker = attackingPlayer(event);
+        if (attacker.isEmpty()) {
+            return;
+        }
+        Player source = attacker.orElseThrow();
+        Map<UUID, PlayerState> players = stateManager.players();
+        PlayerState attackerState = players.getOrDefault(
+            source.getUniqueId(),
+            PlayerState.newPlayer(source.getUniqueId(), source.getName())
+        );
+        PlayerState targetState = players.getOrDefault(
+            target.getUniqueId(),
+            PlayerState.newPlayer(target.getUniqueId(), target.getName())
+        );
+        if (combat.blocks(stateManager.game(), attackerState, targetState)) {
+            event.setCancelled(true);
+            source.sendMessage(ChatColor.YELLOW + OPTED_OUT_MESSAGE);
+        }
+    }
+
+    private static Optional<Player> attackingPlayer(EntityDamageByEntityEvent event) {
+        if (event.getDamager() instanceof Player player) {
+            return Optional.of(player);
+        }
+        if (event.getDamager() instanceof Projectile projectile
+                && projectile.getShooter() instanceof Player player) {
+            return Optional.of(player);
+        }
+        return Optional.empty();
+    }
+}

src/main/java/games/dmg/spigottyrant/ParticipationCombatService.java

@@ -0,0 +1,24 @@
+package games.dmg.spigottyrant;
+
+public final class ParticipationCombatService {
+    public boolean blocks(
+        GameState game,
+        PlayerState attacker,
+        PlayerState target
+    ) {
+        if (game.lifecycle() != GameLifecycle.RUNNING) {
+            return false;
+        }
+        boolean attackerOptedOut = attacker.optedOutUntil().isPresent();
+        boolean targetOptedOut = target.optedOutUntil().isPresent();
+        boolean attackerTyrantSide = isTyrantSide(game, attacker);
+        boolean targetTyrantSide = isTyrantSide(game, target);
+        return (attackerTyrantSide && targetOptedOut)
+            || (attackerOptedOut && targetTyrantSide);
+    }
+
+    private static boolean isTyrantSide(GameState game, PlayerState player) {
+        return game.tyrantId().filter(player.playerId()::equals).isPresent()
+            || player.tyrantClass() != TyrantClass.NONE;
+    }
+}

src/main/java/games/dmg/spigottyrant/PlayerStatusMessages.java

@@ -15,7 +15,6 @@ public final class PlayerStatusMessages {
         Instant now
     ) {
         List<String> messages = new ArrayList<>();
-        messages.add("Game: " + game.lifecycle());
         boolean hasRole = false;
         if (game.tyrantId().filter(player.playerId()::equals).isPresent()) {
             messages.add("Role: TYRANT. Level " + game.tyrantLevel() + ", choices "
@@ -45,8 +44,8 @@ public final class PlayerStatusMessages {
             messages.add("Participation: OPTED OUT. You may use /tyrant optin at "
                 + player.optedOutUntil().orElseThrow() + ".");
         } else if (!hasRole) {
-            messages.add("You currently have no role or class. Use /tyrant optout "
-                + "if you do not want to participate.");
+            messages.add("Use /tyrant optout if you do not want to participate "
+                + "in Tyrant events.");
         }
         return List.copyOf(messages);
     }

src/main/java/games/dmg/spigottyrant/SpigotTyrantPlugin.java

@@ -15,6 +15,7 @@ public final class SpigotTyrantPlugin extends JavaPlugin {
     private AssassinEffectController assassinEffects;
     private FixerEffectController fixerEffects;
     private TyrantEffectController tyrantEffects;
+    private OptOutGlowController optOutGlow;
 
     @Override
     public void onEnable() {
@@ -69,6 +70,7 @@ public final class SpigotTyrantPlugin extends JavaPlugin {
         FixerAbilityService fixerAbilities = new FixerAbilityService(readiness, settings);
         fixerEffects = new FixerEffectController(stateManager, getServer(), settings, clock);
         tyrantEffects = new TyrantEffectController(stateManager, getServer(), settings);
+        optOutGlow = new OptOutGlowController(stateManager, getServer(), settings);
         VigilanteCombatTracker combatTracker = new VigilanteCombatTracker();
         vigilanteEffects = new VigilanteEffectController(
             stateManager, getServer(), combatTracker, settings, clock
@@ -122,6 +124,13 @@ public final class SpigotTyrantPlugin extends JavaPlugin {
             ),
             this
         );
+        getServer().getPluginManager().registerEvents(
+            new ParticipationCombatListener(
+                stateManager, new ParticipationCombatService()
+            ),
+            this
+        );
+        getServer().getPluginManager().registerEvents(optOutGlow, this);
         getServer().getPluginManager().registerEvents(
             new VigilanteCombatListener(
                 stateManager, combatTracker, clock, settings.vigilanteCombatDuration()
@@ -170,6 +179,7 @@ public final class SpigotTyrantPlugin extends JavaPlugin {
         getServer().getScheduler().runTaskTimer(this, assassinEffects, 10L, 10L);
         getServer().getScheduler().runTaskTimer(this, fixerEffects, 10L, 10L);
         getServer().getScheduler().runTaskTimer(this, tyrantEffects, 10L, 10L);
+        getServer().getScheduler().runTaskTimer(this, optOutGlow, 10L, 10L);
         getServer().getScheduler().runTaskTimer(
             this,
             new AbilityItemRefreshTask(
@@ -185,6 +195,9 @@ public final class SpigotTyrantPlugin extends JavaPlugin {
 
     @Override
     public void onDisable() {
+        if (optOutGlow != null) {
+            optOutGlow.clearAll();
+        }
         if (tyrantEffects != null) {
             tyrantEffects.clearAll();
         }

src/test/java/games/dmg/spigottyrant/AssassinEffectControllerTest.java

@@ -0,0 +1,145 @@
+package games.dmg.spigottyrant;
+
+import static org.mockito.Mockito.clearInvocations;
+import static org.mockito.Mockito.doReturn;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.verifyNoInteractions;
+import static org.mockito.Mockito.when;
+
+import java.nio.file.Path;
+import java.time.Clock;
+import java.time.Instant;
+import java.time.ZoneOffset;
+import java.util.List;
+import java.util.Map;
+import java.util.Optional;
+import java.util.Set;
+import java.util.UUID;
+import java.util.logging.Logger;
+import org.bukkit.Server;
+import org.bukkit.entity.Player;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.io.TempDir;
+
+final class AssassinEffectControllerTest {
+    private static final Instant NOW = Instant.parse("2026-08-18T12:00:00Z");
+    private static final UUID PLAYER_ID = UUID.fromString(
+        "11111111-1111-1111-1111-111111111111"
+    );
+
+    @TempDir
+    Path temporaryDirectory;
+
+    @Test
+    void doesNotRemovePotionEffectsItDidNotApply() throws Exception {
+        TyrantStateManager stateManager = manager();
+        Player player = player();
+        Server server = server(player);
+        AssassinEffectController.EffectApplier effects = mock(
+            AssassinEffectController.EffectApplier.class
+        );
+        AssassinEffectController controller = controller(stateManager, server, effects);
+
+        controller.run();
+        controller.clearAll();
+
+        verifyNoInteractions(effects);
+    }
+
+    @Test
+    void stopsRefreshingManagedInvisibilityAfterItsDeadline() throws Exception {
+        TyrantStateManager stateManager = manager();
+        stateManager.updateGame(ignored -> runningGame());
+        stateManager.updatePlayer(PLAYER_ID, "Assassin", ignored -> assassin(Map.of(
+            Ability.ASSASSIN_INVISIBILITY_ACTIVE, NOW.plusSeconds(60),
+            Ability.ASSASSIN_DOUBLE_JUMP, NOW.plusSeconds(60)
+        )));
+        Player player = player();
+        Server server = server(player);
+        AssassinEffectController.EffectApplier effects = mock(
+            AssassinEffectController.EffectApplier.class
+        );
+        AssassinEffectController controller = controller(stateManager, server, effects);
+
+        controller.run();
+
+        verify(effects).apply(
+            player,
+            AssassinEffectController.EffectKind.INVISIBILITY,
+            0,
+            false
+        );
+
+        stateManager.updatePlayer(PLAYER_ID, "Assassin", ignored -> assassin(Map.of(
+            Ability.ASSASSIN_DOUBLE_JUMP, NOW.plusSeconds(60)
+        )));
+        clearInvocations(player, effects);
+        controller.run();
+
+        verifyNoInteractions(effects);
+    }
+
+    private TyrantStateManager manager() throws Exception {
+        return new TyrantStateManager(
+            new YamlTyrantStateRepository(temporaryDirectory.resolve("state.yml")),
+            Logger.getLogger("test")
+        );
+    }
+
+    private static AssassinEffectController controller(
+        TyrantStateManager stateManager,
+        Server server,
+        AssassinEffectController.EffectApplier effects
+    ) {
+        return new AssassinEffectController(
+            stateManager,
+            server,
+            PluginSettings.from(Map.of()),
+            Clock.fixed(NOW, ZoneOffset.UTC),
+            effects
+        );
+    }
+
+    private static Server server(Player player) {
+        Server server = mock(Server.class);
+        doReturn(List.of(player)).when(server).getOnlinePlayers();
+        return server;
+    }
+
+    private static Player player() {
+        Player player = mock(Player.class);
+        when(player.getUniqueId()).thenReturn(PLAYER_ID);
+        when(player.getName()).thenReturn("Assassin");
+        return player;
+    }
+
+    private static PlayerState assassin(Map<Ability, Instant> cooldowns) {
+        return new PlayerState(
+            PLAYER_ID,
+            "Assassin",
+            Optional.empty(),
+            Optional.empty(),
+            TyrantClass.ASSASSIN,
+            Optional.empty(),
+            cooldowns,
+            Set.of(),
+            List.of()
+        );
+    }
+
+    private static GameState runningGame() {
+        return new GameState(
+            GameLifecycle.RUNNING,
+            Optional.empty(),
+            Optional.empty(),
+            Optional.empty(),
+            Optional.empty(),
+            Optional.empty(),
+            java.time.Duration.ZERO,
+            0,
+            0,
+            Set.of()
+        );
+    }
+}

src/test/java/games/dmg/spigottyrant/OptOutGlowControllerTest.java

@@ -0,0 +1,97 @@
+package games.dmg.spigottyrant;
+
+import static org.mockito.Mockito.doReturn;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
+import java.time.Duration;
+import java.time.Instant;
+import java.util.Map;
+import java.util.Optional;
+import java.util.Set;
+import java.util.UUID;
+import org.bukkit.ChatColor;
+import org.bukkit.Location;
+import org.bukkit.Server;
+import org.bukkit.World;
+import org.bukkit.entity.Player;
+import org.bukkit.scoreboard.Scoreboard;
+import org.bukkit.scoreboard.ScoreboardManager;
+import org.bukkit.scoreboard.Team;
+import org.junit.jupiter.api.Test;
+
+final class OptOutGlowControllerTest {
+    private static final UUID TYRANT = UUID.fromString(
+        "11111111-1111-1111-1111-111111111111"
+    );
+    private static final UUID OUT = UUID.fromString(
+        "22222222-2222-2222-2222-222222222222"
+    );
+
+    @Test
+    void appliesGreenGlowAndRestoresPreviousTeamAfterLeavingRange() {
+        TyrantStateManager stateManager = mock(TyrantStateManager.class);
+        Server server = mock(Server.class);
+        PluginSettings settings = mock(PluginSettings.class);
+        ScoreboardManager manager = mock(ScoreboardManager.class);
+        Scoreboard scoreboard = mock(Scoreboard.class);
+        Team green = mock(Team.class);
+        Team previous = mock(Team.class);
+        Player tyrant = player(TYRANT, "Tyrant");
+        Player optedOut = player(OUT, "Out");
+        World world = mock(World.class);
+        Location tyrantLocation = mock(Location.class);
+        Location outLocation = mock(Location.class);
+        when(server.getScoreboardManager()).thenReturn(manager);
+        when(manager.getMainScoreboard()).thenReturn(scoreboard);
+        when(scoreboard.getTeam("tyrant-optout")).thenReturn(null);
+        when(scoreboard.registerNewTeam("tyrant-optout")).thenReturn(green);
+        when(scoreboard.getEntryTeam("Out")).thenReturn(previous);
+        when(server.getPlayer(TYRANT)).thenReturn(tyrant);
+        doReturn(Set.of(tyrant, optedOut)).when(server).getOnlinePlayers();
+        when(settings.tyrantRangeBlocks()).thenReturn(50.0);
+        when(tyrant.getWorld()).thenReturn(world);
+        when(optedOut.getWorld()).thenReturn(world);
+        when(tyrant.getLocation()).thenReturn(tyrantLocation);
+        when(optedOut.getLocation()).thenReturn(outLocation);
+        when(outLocation.distanceSquared(tyrantLocation)).thenReturn(25.0, 2601.0);
+        when(stateManager.game()).thenReturn(running());
+        when(stateManager.players()).thenReturn(Map.of(OUT, optedOut()));
+        OptOutGlowController controller = new OptOutGlowController(
+            stateManager, server, settings
+        );
+
+        controller.run();
+        controller.run();
+
+        verify(green).setColor(ChatColor.GREEN);
+        verify(green).addEntry("Out");
+        verify(optedOut).setGlowing(true);
+        verify(green).removeEntry("Out");
+        verify(previous).addEntry("Out");
+        verify(optedOut).setGlowing(false);
+    }
+
+    private static Player player(UUID id, String name) {
+        Player player = mock(Player.class);
+        when(player.getUniqueId()).thenReturn(id);
+        when(player.getName()).thenReturn(name);
+        return player;
+    }
+
+    private static PlayerState optedOut() {
+        return new PlayerState(
+            OUT, "Out", Optional.empty(), Optional.of(Instant.MAX), TyrantClass.NONE,
+            Optional.empty(), Map.of(), Set.of(), java.util.List.of()
+        );
+    }
+
+    private static GameState running() {
+        return new GameState(
+            GameLifecycle.RUNNING, Optional.of(TYRANT), Optional.empty(),
+            Optional.empty(), Optional.empty(), Optional.empty(), Duration.ZERO,
+            0, 0, Set.of()
+        );
+    }
+}

src/test/java/games/dmg/spigottyrant/OptOutGlowPolicyTest.java

@@ -0,0 +1,76 @@
+package games.dmg.spigottyrant;
+
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+import java.time.Duration;
+import java.time.Instant;
+import java.util.Map;
+import java.util.Optional;
+import java.util.Set;
+import java.util.UUID;
+import org.junit.jupiter.api.Test;
+
+final class OptOutGlowPolicyTest {
+    private static final UUID TYRANT = UUID.fromString(
+        "11111111-1111-1111-1111-111111111111"
+    );
+    private static final UUID PLAYER = UUID.fromString(
+        "22222222-2222-2222-2222-222222222222"
+    );
+
+    @Test
+    void optedOutPlayerGlowsWithinInclusiveRunningRange() {
+        assertTrue(OptOutGlowPolicy.shouldGlow(
+            running(), optedOut(), true, true, 2500.0, 50.0
+        ));
+    }
+
+    @Test
+    void requiresRunningEventAvailablePlayersSameWorldAndRange() {
+        assertFalse(OptOutGlowPolicy.shouldGlow(
+            GameState.empty(), optedOut(), true, true, 1.0, 50.0
+        ));
+        assertFalse(OptOutGlowPolicy.shouldGlow(
+            paused(), optedOut(), true, true, 1.0, 50.0
+        ));
+        assertFalse(OptOutGlowPolicy.shouldGlow(
+            running(), optedIn(), true, true, 1.0, 50.0
+        ));
+        assertFalse(OptOutGlowPolicy.shouldGlow(
+            running(), optedOut(), false, true, 1.0, 50.0
+        ));
+        assertFalse(OptOutGlowPolicy.shouldGlow(
+            running(), optedOut(), true, false, 1.0, 50.0
+        ));
+        assertFalse(OptOutGlowPolicy.shouldGlow(
+            running(), optedOut(), true, true, 2500.01, 50.0
+        ));
+    }
+
+    private static PlayerState optedOut() {
+        return new PlayerState(
+            PLAYER, "Player", Optional.empty(), Optional.of(Instant.MAX),
+            TyrantClass.NONE, Optional.empty(), Map.of(), Set.of(), java.util.List.of()
+        );
+    }
+
+    private static PlayerState optedIn() {
+        return PlayerState.newPlayer(PLAYER, "Player");
+    }
+
+    private static GameState running() {
+        return game(GameLifecycle.RUNNING, Optional.empty());
+    }
+
+    private static GameState paused() {
+        return game(GameLifecycle.PAUSED, Optional.of(Instant.EPOCH));
+    }
+
+    private static GameState game(GameLifecycle lifecycle, Optional<Instant> pausedAt) {
+        return new GameState(
+            lifecycle, Optional.of(TYRANT), Optional.empty(), Optional.empty(),
+            Optional.empty(), pausedAt, Duration.ZERO, 0, 0, Set.of()
+        );
+    }
+}

src/test/java/games/dmg/spigottyrant/ParticipationCombatListenerTest.java

@@ -0,0 +1,75 @@
+package games.dmg.spigottyrant;
+
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
+import java.time.Duration;
+import java.time.Instant;
+import java.util.Map;
+import java.util.Optional;
+import java.util.Set;
+import java.util.UUID;
+import org.bukkit.ChatColor;
+import org.bukkit.entity.Player;
+import org.bukkit.entity.Projectile;
+import org.bukkit.event.entity.EntityDamageByEntityEvent;
+import org.junit.jupiter.api.Test;
+
+final class ParticipationCombatListenerTest {
+    private static final UUID TYRANT = UUID.fromString(
+        "11111111-1111-1111-1111-111111111111"
+    );
+    private static final UUID OUT = UUID.fromString(
+        "22222222-2222-2222-2222-222222222222"
+    );
+
+    @Test
+    void cancelsPlayerProjectileAndMessagesTheAttacker() {
+        TyrantStateManager manager = mock(TyrantStateManager.class);
+        Player attacker = player(TYRANT, "Tyrant");
+        Player target = player(OUT, "Out");
+        Projectile projectile = mock(Projectile.class);
+        EntityDamageByEntityEvent event = mock(EntityDamageByEntityEvent.class);
+        when(projectile.getShooter()).thenReturn(attacker);
+        when(event.getDamager()).thenReturn(projectile);
+        when(event.getEntity()).thenReturn(target);
+        when(manager.game()).thenReturn(running());
+        when(manager.players()).thenReturn(Map.of(
+            TYRANT, state(TYRANT, TyrantClass.NONE, false),
+            OUT, state(OUT, TyrantClass.NONE, true)
+        ));
+        ParticipationCombatListener listener = new ParticipationCombatListener(
+            manager, new ParticipationCombatService()
+        );
+
+        listener.onDamage(event);
+
+        verify(event).setCancelled(true);
+        verify(attacker).sendMessage(ChatColor.YELLOW
+            + ParticipationCombatListener.OPTED_OUT_MESSAGE);
+    }
+
+    private static Player player(UUID id, String name) {
+        Player player = mock(Player.class);
+        when(player.getUniqueId()).thenReturn(id);
+        when(player.getName()).thenReturn(name);
+        return player;
+    }
+
+    private static PlayerState state(UUID id, TyrantClass role, boolean optedOut) {
+        return new PlayerState(
+            id, id.toString(), Optional.empty(),
+            optedOut ? Optional.of(Instant.parse("2026-08-21T00:00:00Z")) : Optional.empty(),
+            role, Optional.empty(), Map.of(), Set.of(), java.util.List.of()
+        );
+    }
+
+    private static GameState running() {
+        return new GameState(
+            GameLifecycle.RUNNING, Optional.of(TYRANT), Optional.empty(),
+            Optional.empty(), Optional.empty(), Optional.empty(), Duration.ZERO,
+            0, 0, Set.of()
+        );
+    }
+}

src/test/java/games/dmg/spigottyrant/ParticipationCombatServiceTest.java

@@ -0,0 +1,90 @@
+package games.dmg.spigottyrant;
+
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+import java.time.Duration;
+import java.time.Instant;
+import java.util.Map;
+import java.util.Optional;
+import java.util.Set;
+import java.util.UUID;
+import org.junit.jupiter.api.Test;
+
+final class ParticipationCombatServiceTest {
+    private static final UUID TYRANT = UUID.fromString(
+        "11111111-1111-1111-1111-111111111111"
+    );
+    private static final UUID OUTSIDER = UUID.fromString(
+        "22222222-2222-2222-2222-222222222222"
+    );
+    private static final UUID SUPPORTER = UUID.fromString(
+        "33333333-3333-3333-3333-333333333333"
+    );
+    private final ParticipationCombatService service = new ParticipationCombatService();
+
+    @Test
+    void blocksDamageInBothDirectionsBetweenOptedOutPlayerAndTyrantSide() {
+        PlayerState optedOut = player(OUTSIDER, TyrantClass.NONE, true);
+        PlayerState tyrant = player(TYRANT, TyrantClass.NONE, false);
+        PlayerState supporter = player(SUPPORTER, TyrantClass.ASSASSIN, false);
+
+        assertTrue(service.blocks(running(), tyrant, optedOut));
+        assertTrue(service.blocks(running(), optedOut, tyrant));
+        assertTrue(service.blocks(running(), supporter, optedOut));
+        assertTrue(service.blocks(running(), optedOut, supporter));
+    }
+
+    @Test
+    void recognizesEveryTyrantSideClassAsSupport() {
+        PlayerState optedOut = player(OUTSIDER, TyrantClass.NONE, true);
+
+        assertTrue(service.blocks(
+            running(), player(SUPPORTER, TyrantClass.ASSASSIN, false), optedOut
+        ));
+        assertTrue(service.blocks(
+            running(), player(SUPPORTER, TyrantClass.FIXER, false), optedOut
+        ));
+        assertTrue(service.blocks(
+            running(), player(SUPPORTER, TyrantClass.TAMER, false), optedOut
+        ));
+    }
+
+    @Test
+    void leavesPausedUnstartedAndUnrelatedCombatAlone() {
+        PlayerState optedOut = player(OUTSIDER, TyrantClass.NONE, true);
+        PlayerState tyrant = player(TYRANT, TyrantClass.NONE, false);
+        PlayerState ordinary = player(SUPPORTER, TyrantClass.NONE, false);
+
+        assertFalse(service.blocks(paused(), tyrant, optedOut));
+        assertFalse(service.blocks(GameState.empty(), tyrant, optedOut));
+        assertFalse(service.blocks(running(), tyrant, ordinary));
+        assertFalse(service.blocks(running(), ordinary, optedOut));
+    }
+
+    private static PlayerState player(UUID id, TyrantClass role, boolean optedOut) {
+        return new PlayerState(
+            id, id.toString(), Optional.empty(),
+            optedOut ? Optional.of(Instant.parse("2026-08-21T00:00:00Z")) : Optional.empty(),
+            role, Optional.empty(), Map.of(), Set.of(), java.util.List.of()
+        );
+    }
+
+    private static GameState running() {
+        return game(GameLifecycle.RUNNING, Optional.empty());
+    }
+
+    private static GameState paused() {
+        return game(
+            GameLifecycle.PAUSED,
+            Optional.of(Instant.parse("2026-08-14T00:00:00Z"))
+        );
+    }
+
+    private static GameState game(GameLifecycle lifecycle, Optional<Instant> pausedAt) {
+        return new GameState(
+            lifecycle, Optional.of(TYRANT), Optional.empty(), Optional.empty(),
+            Optional.empty(), pausedAt, Duration.ZERO, 0, 0, Set.of()
+        );
+    }
+}

src/test/java/games/dmg/spigottyrant/PlayerStatusMessagesTest.java

@@ -1,5 +1,6 @@
 package games.dmg.spigottyrant;
 
+import static org.junit.jupiter.api.Assertions.assertFalse;
 import static org.junit.jupiter.api.Assertions.assertTrue;
 
 import java.time.Duration;
@@ -29,7 +30,8 @@ final class PlayerStatusMessagesTest {
 
         List<String> messages = PlayerStatusMessages.forJoin(game, player, NOW);
 
-        assertTrue(messages.stream().anyMatch(message -> message.contains("Game: RUNNING")));
+        assertFalse(messages.stream().anyMatch(message -> message.startsWith("Game:")));
+        assertFalse(messages.stream().anyMatch(message -> message.startsWith("Tyrant event:")));
         assertTrue(messages.stream().anyMatch(message -> message.contains("Role: VIGILANTE")));
         assertTrue(messages.stream().anyMatch(message -> message.contains("Class: ASSASSIN")));
         assertTrue(messages.stream().anyMatch(message -> message.contains("ASSASSIN_INVISIBILITY")
@@ -42,6 +44,8 @@ final class PlayerStatusMessagesTest {
             GameState.empty(), PlayerState.newPlayer(PLAYER, "Player"), NOW
         );
 
-        assertTrue(messages.stream().anyMatch(message -> message.contains("/tyrant optout")));
+        assertTrue(messages.contains(
+            "Use /tyrant optout if you do not want to participate in Tyrant events."
+        ));
     }
 }