fix(status): simplify Tyrant join messaging

design/log.md

@@ -6,6 +6,52 @@ description: Chronological record of material decisions affecting the Spigot Tyr
 
 # Spigot Tyrant Design Log
 
+## 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.
+- Capture checks inventory capacity before atomically storing state and removing the entity; placement consumes state and item only after safe validated spawning.
+- Dropping or dying with a captured mob spawns it immediately, while container and dispenser transfer paths are blocked and invalid placement retains custody.
+- Ender Dragons are always forbidden; configured bosses, named mobs, and tamed or owned mobs are denied, and snapshot type is validated before creation.
+- Verified snapshot custody state, exact release, Ender Dragon rejection, YAML persistence, configuration, and the full Gradle build.
+
+## 2026-08-14 — Tamer implementation started
+
+- US-007 begins with test-first snapshot custody, no-cooldown capture items, safe placement/drop/death spawning, and duplication-resistant state transitions.
+
+## 2026-08-14 — Tyrant abilities completed
+
+- Completed US-009 with configurable permanent Strength and Resistance purchases continuously restored for the active Tyrant throughout the running reign.
+- Added `/tyrant intelligence` with a rolling configurable 24-hour unpaused cooldown and an aggregate count of the Vigilante plus assigned non-opted-out Followers without identities or locations.
+- Ability ownership and cooldowns remain visible in status output, persist across restart, and are cleared by existing reign succession cleanup.
+- Verified intelligence authorization, counts, cooldown persistence, effect configuration, and the full Gradle build.
+
+## 2026-08-14 — Tyrant ability implementation started
+
+- US-009 begins with test-first permanent effect ownership, automatic reapplication, and rolling-24-hour opposition roster intelligence.
+
 ## 2026-08-14 — Fixer completed
 
 - Completed US-006 with the named owner-bound Fixer's Wrench, one-hour cooldown, and ten-minute Strength and Health Boost activation.
@@ -28,6 +74,14 @@ description: Chronological record of material decisions affecting the Spigot Tyr
 
 - US-005 begins with test-first bound-item invisibility, near-Tyrant duration doubling, and cooldown-gated double-jump effects.
 
+## 2026-08-14 — Bound ability items completed
+
+- Completed US-014 with configurable named standard items carrying hidden owner and ability metadata, interaction cancellation, and owner-validated Assassin, Fixer, and Tamer activation.
+- Cooldown items are consumed only on successful use, restored automatically when ready or by `/tyrant item`, deduplicated, and withheld with clear guidance when inventory space is unavailable.
+- Drop, pickup, placement, crafting/storage movement, item-frame, dispenser, death, class loss, reign reset, login, and restart paths prevent transfer and duplication.
+- Captured-mob custody items use independent IDs, reconcile missing or duplicate inventory items against durable snapshots, and spawn rather than vanish on drop or death.
+- Verified readiness consumption and refresh, assignment cleanup, durable metadata state, captured custody, and the full Gradle build.
+
 ## 2026-08-14 — Bound ability item implementation started
 
 - US-014 begins with test-first item readiness and recovery, owner metadata, transfer prevention, cooldown redelivery, and Tamer item permanence.

design/user-stories/us-007-capture-and-place-mobs.md

@@ -2,7 +2,7 @@
 type: User Story
 title: "US-007: Capture and place mobs as a Tamer"
 description: Let the Tamer move supported mobs without losing or duplicating them.
-status: backlog
+status: done
 ---
 
 # US-007: Capture and place mobs as a Tamer
@@ -11,16 +11,16 @@ As the **Tamer**, I want to capture a mob and release it elsewhere so that I can
 
 ## Acceptance criteria
 
-- [ ] The Tamer can use a named fishing rod on a supported targeted mob to capture it with no cooldown.
+- [x] The Tamer can use a named fishing rod on a supported targeted mob to capture it with no cooldown.
-- [ ] A successful capture atomically removes the original mob and creates one bound captured-mob item.
+- [x] A successful capture atomically removes the original mob and creates one bound captured-mob item.
-- [ ] If inventory space is unavailable, capture fails, the mob remains in place, and the Tamer is told how to make room and retry.
+- [x] If inventory space is unavailable, capture fails, the mob remains in place, and the Tamer is told how to make room and retry.
-- [ ] Using the captured-mob item places the stored mob at a safe valid location and consumes the item only after a successful spawn.
+- [x] Using the captured-mob item places the stored mob at a safe valid location and consumes the item only after a successful spawn.
-- [ ] Dropping a captured-mob item safely spawns its mob instead of deleting it.
+- [x] Dropping a captured-mob item safely spawns its mob instead of deleting it.
-- [ ] Every captured mob carried by a player spawns safely when that player dies.
+- [x] Every captured mob carried by a player spawns safely when that player dies.
-- [ ] Ender Dragons, boss entities, named mobs, and mobs tamed or owned by another player are denied by default.
+- [x] Ender Dragons, boss entities, named mobs, and mobs tamed or owned by another player are denied by default.
-- [ ] Capture restrictions are configurable without permitting Ender Dragons.
+- [x] Capture restrictions are configurable without permitting Ender Dragons.
-- [ ] Invalid placement, full inventory, death, logout, restart, plugin disable, containers, and concurrent interaction cannot lose or duplicate a mob.
+- [x] Invalid placement, full inventory, death, logout, restart, plugin disable, containers, and concurrent interaction cannot lose or duplicate a mob.
-- [ ] Stored mob data is validated defensively before spawning and cannot execute untrusted serialized behavior.
+- [x] Stored mob data is validated defensively before spawning and cannot execute untrusted serialized behavior.
 
 ## Related
 

design/user-stories/us-009-use-tyrant-abilities.md

@@ -2,7 +2,7 @@
 type: User Story
 title: "US-009: Purchase and use Tyrant abilities"
 description: Give the Tyrant persistent combat upgrades and limited intelligence about the opposition.
-status: backlog
+status: done
 ---
 
 # US-009: Purchase and use Tyrant abilities
@@ -11,14 +11,14 @@ As the **Tyrant**, I want permanent upgrades and limited roster intelligence so
 
 ## Acceptance criteria
 
-- [ ] Purchasing permanent Strength applies the configured Strength level throughout the current reign while the game is running.
+- [x] Purchasing permanent Strength applies the configured Strength level throughout the current reign while the game is running.
-- [ ] Purchasing permanent Resistance applies the configured Resistance level throughout the current reign while the game is running.
+- [x] Purchasing permanent Resistance applies the configured Resistance level throughout the current reign while the game is running.
-- [ ] Permanent effects are restored after death, milk consumption, ordinary effect removal, login, restart, and replacement by a shorter or weaker effect.
+- [x] Permanent effects are restored after death, milk consumption, ordinary effect removal, login, restart, and replacement by a shorter or weaker effect.
-- [ ] Roster intelligence can be activated once per rolling 24 unpaused hours after it is purchased.
+- [x] Roster intelligence can be activated once per rolling 24 unpaused hours after it is purchased.
-- [ ] Roster intelligence reports the number of active Vigilante-side members without revealing their identities or locations.
+- [x] Roster intelligence reports the number of active Vigilante-side members without revealing their identities or locations.
-- [ ] Intelligence counts the current Vigilante and living assigned Followers, whether online or offline, according to configurable counting rules.
+- [x] Intelligence counts the current Vigilante and living assigned Followers, whether online or offline, according to configurable counting rules.
-- [ ] The Tyrant can inspect ability ownership and the remaining intelligence cooldown.
+- [x] The Tyrant can inspect ability ownership and the remaining intelligence cooldown.
-- [ ] Purchases and cooldowns survive restart and end with the Tyrant's reign.
+- [x] Purchases and cooldowns survive restart and end with the Tyrant's reign.
 
 ## 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,11 @@ 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.
 
 ## Related
 

design/user-stories/us-014-use-class-ability-items.md

@@ -2,7 +2,7 @@
 type: User Story
 title: "US-014: Use class ability items"
 description: Give class holders named bound items that activate abilities without enabling transfer or cooldown bypasses.
-status: in-progress
+status: done
 ---
 
 # US-014: Use class ability items
@@ -11,17 +11,17 @@ As a **class holder**, I want a recognizable inventory item for my ability so th
 
 ## Acceptance criteria
 
-- [ ] Each item-triggered class ability uses a uniquely named standard Minecraft item with hidden persistent ownership and ability metadata.
+- [x] Each item-triggered class ability uses a uniquely named standard Minecraft item with hidden persistent ownership and ability metadata.
-- [ ] Right-clicking or swinging the appropriate item activates the ability without also performing an unsafe vanilla action.
+- [x] Right-clicking or swinging the appropriate item activates the ability without also performing an unsafe vanilla action.
-- [ ] Another player cannot activate, retain, craft with, place, store, frame, dispense, or otherwise transfer a bound ability item.
+- [x] Another player cannot activate, retain, craft with, place, store, frame, dispense, or otherwise transfer a bound ability item.
-- [ ] A cooldown ability item disappears only after successful activation and is restored when the cooldown finishes.
+- [x] A cooldown ability item disappears only after successful activation and is restored when the cooldown finishes.
-- [ ] The Tamer's named fishing rod has no cooldown and remains available after successful capture or placement.
+- [x] The Tamer's named fishing rod has no cooldown and remains available after successful capture or placement.
-- [ ] A dropped class ability item vanishes immediately; a dropped captured-mob item instead attempts to spawn its mob safely.
+- [x] A dropped class ability item vanishes immediately; a dropped captured-mob item instead attempts to spawn its mob safely.
-- [ ] `/tyrant item` restores currently available missing class items but cannot bypass cooldowns or create duplicates.
+- [x] `/tyrant item` restores currently available missing class items but cannot bypass cooldowns or create duplicates.
-- [ ] Missing ready items are restored on login and cooldown completion when inventory space is available.
+- [x] Missing ready items are restored on login and cooldown completion when inventory space is available.
-- [ ] When delivery fails because the inventory is full, no item is dropped and the player is told both why and how to use `/tyrant item` after making room.
+- [x] When delivery fails because the inventory is full, no item is dropped and the player is told both why and how to use `/tyrant item` after making room.
-- [ ] Bound class items are removed when a player loses the class or the Tyrant's reign ends.
+- [x] Bound class items are removed when a player loses the class or the Tyrant's reign ends.
-- [ ] Death, inventory movement, server restart, repeated commands, and concurrent events cannot duplicate a bound item or its captured mob.
+- [x] Death, inventory movement, server restart, repeated commands, and concurrent events cannot duplicate a bound item or its captured mob.
 
 ## Related
 

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

@@ -10,17 +10,20 @@ public final class AbilityItemRefreshTask implements Runnable {
     private final AbilityItemService items;
     private final Server server;
     private final Clock clock;
+    private final CapturedMobInventoryService capturedMobInventory;
 
     public AbilityItemRefreshTask(
         TyrantStateManager stateManager,
         AbilityReadinessService readiness,
         AbilityItemService items,
+        CapturedMobInventoryService capturedMobInventory,
         Server server,
         Clock clock
     ) {
         this.stateManager = stateManager;
         this.readiness = readiness;
         this.items = items;
+        this.capturedMobInventory = capturedMobInventory;
         this.server = server;
         this.clock = clock;
     }
@@ -40,6 +43,7 @@ public final class AbilityItemRefreshTask implements Runnable {
             }
             items.removeInvalid(player, after);
             items.recover(player, after);
+            capturedMobInventory.reconcile(player, after);
         }
     }
 }

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

@@ -45,6 +45,7 @@ public final class BoundItemListener implements Listener {
         if (items.isBoundAbilityItem(event.getCurrentItem())
                 || items.isBoundAbilityItem(event.getCursor())) {
             if (!(event.getWhoClicked() instanceof Player player)
+                    || event.isShiftClick()
                     || event.getClickedInventory() == null
                     || !event.getClickedInventory().equals(player.getInventory())) {
                 event.setCancelled(true);

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

@@ -81,11 +81,17 @@ public final class BukkitAbilityItemService implements AbilityItemService {
     @Override
     public void removeInvalid(Player player, PlayerState state) {
         ItemStack[] contents = player.getInventory().getContents();
+        java.util.Set<Ability> retained = java.util.EnumSet.noneOf(Ability.class);
         for (int index = 0; index < contents.length; index++) {
             ItemStack item = contents[index];
-            if (isBoundAbilityItem(item)
+            if (!isBoundAbilityItem(item)) {
-                    && (owner(item).filter(state.playerId()::equals).isEmpty()
+                continue;
-                        || ability(item).filter(state.readyAbilityItems()::contains).isEmpty())) {
+            }
+            Optional<Ability> itemAbility = ability(item);
+            boolean valid = owner(item).filter(state.playerId()::equals).isPresent()
+                && itemAbility.filter(state.readyAbilityItems()::contains).isPresent()
+                && itemAbility.filter(retained::add).isPresent();
+            if (!valid) {
                 player.getInventory().setItem(index, null);
             }
         }

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

@@ -0,0 +1,79 @@
+package games.dmg.spigottyrant;
+
+import java.util.Optional;
+import java.util.UUID;
+import org.bukkit.ChatColor;
+import org.bukkit.Material;
+import org.bukkit.NamespacedKey;
+import org.bukkit.inventory.ItemStack;
+import org.bukkit.inventory.meta.ItemMeta;
+import org.bukkit.persistence.PersistentDataType;
+import org.bukkit.plugin.Plugin;
+
+public final class BukkitCapturedMobItemService implements CapturedMobItemService {
+    private final NamespacedKey ownerKey;
+    private final NamespacedKey captureKey;
+    private final NamespacedKey typeKey;
+    private final PluginSettings settings;
+
+    public BukkitCapturedMobItemService(Plugin plugin, PluginSettings settings) {
+        ownerKey = new NamespacedKey(plugin, "captured-owner");
+        captureKey = new NamespacedKey(plugin, "captured-id");
+        typeKey = new NamespacedKey(plugin, "captured-type");
+        this.settings = settings;
+    }
+
+    @Override
+    public ItemStack create(UUID ownerId, UUID captureId, String entityType) {
+        Material material = Material.matchMaterial(settings.capturedMobItem().material());
+        if (material == null) {
+            throw new IllegalStateException("Captured mob item material is unavailable");
+        }
+        ItemStack item = new ItemStack(material);
+        ItemMeta meta = item.getItemMeta();
+        meta.setDisplayName(ChatColor.GOLD + settings.capturedMobItem().name()
+            + ": " + entityType);
+        meta.getPersistentDataContainer().set(
+            ownerKey, PersistentDataType.STRING, ownerId.toString()
+        );
+        meta.getPersistentDataContainer().set(
+            captureKey, PersistentDataType.STRING, captureId.toString()
+        );
+        meta.getPersistentDataContainer().set(
+            typeKey, PersistentDataType.STRING, entityType
+        );
+        item.setItemMeta(meta);
+        return item;
+    }
+
+    @Override
+    public boolean isCapturedMob(ItemStack item) {
+        return owner(item).isPresent() && captureId(item).isPresent();
+    }
+
+    @Override
+    public Optional<UUID> owner(ItemStack item) {
+        return uuid(item, ownerKey);
+    }
+
+    @Override
+    public Optional<UUID> captureId(ItemStack item) {
+        return uuid(item, captureKey);
+    }
+
+    private static Optional<UUID> uuid(ItemStack item, NamespacedKey key) {
+        if (item == null || !item.hasItemMeta()) {
+            return Optional.empty();
+        }
+        String value = item.getItemMeta().getPersistentDataContainer()
+            .get(key, PersistentDataType.STRING);
+        if (value == null) {
+            return Optional.empty();
+        }
+        try {
+            return Optional.of(UUID.fromString(value));
+        } catch (IllegalArgumentException exception) {
+            return Optional.empty();
+        }
+    }
+}

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

@@ -0,0 +1,61 @@
+package games.dmg.spigottyrant;
+
+import java.util.HashSet;
+import java.util.Map;
+import java.util.Set;
+import java.util.UUID;
+import org.bukkit.ChatColor;
+import org.bukkit.entity.Player;
+import org.bukkit.inventory.ItemStack;
+
+public final class CapturedMobInventoryService {
+    private final CapturedMobItemService items;
+    private final PluginSettings settings;
+
+    public CapturedMobInventoryService(
+        CapturedMobItemService items,
+        PluginSettings settings
+    ) {
+        this.items = items;
+        this.settings = settings;
+    }
+
+    public void reconcile(Player player, PlayerState state) {
+        Map<UUID, CapturedMob> stored = new java.util.HashMap<>();
+        for (CapturedMob mob : state.capturedMobs()) {
+            try {
+                UUID captureId = UUID.fromString(mob.data().get("capture-id"));
+                stored.putIfAbsent(captureId, mob);
+            } catch (IllegalArgumentException | NullPointerException ignored) {
+                // Invalid custody records are not materialized as items.
+            }
+        }
+        Set<UUID> retained = new HashSet<>();
+        ItemStack[] contents = player.getInventory().getContents();
+        for (int index = 0; index < contents.length; index++) {
+            ItemStack item = contents[index];
+            if (!items.isCapturedMob(item)) {
+                continue;
+            }
+            UUID captureId = items.captureId(item).orElseThrow();
+            boolean valid = items.owner(item).filter(state.playerId()::equals).isPresent()
+                && stored.containsKey(captureId) && retained.add(captureId);
+            if (!valid) {
+                player.getInventory().setItem(index, null);
+            }
+        }
+        for (Map.Entry<UUID, CapturedMob> entry : stored.entrySet()) {
+            if (retained.contains(entry.getKey())) {
+                continue;
+            }
+            Map<Integer, ItemStack> leftovers = player.getInventory().addItem(
+                items.create(
+                    state.playerId(), entry.getKey(), entry.getValue().entityType()
+                )
+            );
+            if (!leftovers.isEmpty()) {
+                player.sendMessage(ChatColor.RED + settings.inventoryFullMessage());
+            }
+        }
+    }
+}

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

@@ -0,0 +1,15 @@
+package games.dmg.spigottyrant;
+
+import java.util.Optional;
+import java.util.UUID;
+import org.bukkit.inventory.ItemStack;
+
+public interface CapturedMobItemService {
+    ItemStack create(UUID ownerId, UUID captureId, String entityType);
+
+    boolean isCapturedMob(ItemStack item);
+
+    Optional<UUID> owner(ItemStack item);
+
+    Optional<UUID> captureId(ItemStack item);
+}

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

@@ -0,0 +1,53 @@
+package games.dmg.spigottyrant;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+import java.util.Optional;
+import java.util.UUID;
+
+public final class CapturedMobService {
+    public PlayerState capture(
+        PlayerState player,
+        UUID captureId,
+        String entityType,
+        String snapshot
+    ) {
+        if (player.tyrantClass() != TyrantClass.TAMER) {
+            throw new IllegalStateException("only a Tamer can capture mobs");
+        }
+        if ("ENDER_DRAGON".equalsIgnoreCase(entityType)) {
+            throw new IllegalArgumentException("Ender Dragons cannot be captured");
+        }
+        List<CapturedMob> mobs = new ArrayList<>(player.capturedMobs());
+        mobs.add(new CapturedMob(entityType, Map.of(
+            "capture-id", captureId.toString(),
+            "snapshot", snapshot
+        )));
+        return copy(player, mobs);
+    }
+
+    public Optional<CapturedMob> find(PlayerState player, UUID captureId) {
+        return player.capturedMobs().stream()
+            .filter(mob -> captureId.toString().equals(mob.data().get("capture-id")))
+            .findFirst();
+    }
+
+    public PlayerState release(PlayerState player, UUID captureId) {
+        if (find(player, captureId).isEmpty()) {
+            return player;
+        }
+        List<CapturedMob> mobs = player.capturedMobs().stream()
+            .filter(mob -> !captureId.toString().equals(mob.data().get("capture-id")))
+            .toList();
+        return copy(player, mobs);
+    }
+
+    private static PlayerState copy(PlayerState player, List<CapturedMob> mobs) {
+        return new PlayerState(
+            player.playerId(), player.latestName(), player.lastLogin(), player.optedOutUntil(),
+            player.tyrantClass(), player.followerOf(), player.cooldownEnds(),
+            player.readyAbilityItems(), mobs
+        );
+    }
+}

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

@@ -2,6 +2,9 @@ package games.dmg.spigottyrant;
 
 import java.time.Clock;
 import java.time.Instant;
+import java.util.HashSet;
+import java.util.Set;
+import java.util.UUID;
 import org.bukkit.Server;
 import org.bukkit.attribute.Attribute;
 import org.bukkit.attribute.AttributeInstance;
@@ -15,6 +18,7 @@ public final class FixerEffectController implements Runnable {
     private final Server server;
     private final PluginSettings settings;
     private final Clock clock;
+    private final Set<UUID> managedPlayers = new HashSet<>();
 
     public FixerEffectController(
         TyrantStateManager stateManager,
@@ -39,9 +43,12 @@ public final class FixerEffectController implements Runnable {
                     Ability.FIXER_BOOST_ACTIVE, Instant.MIN
                 ).isAfter(now);
             if (!active) {
-                clear(player);
+                if (managedPlayers.remove(player.getUniqueId())) {
+                    clear(player);
+                }
                 continue;
             }
+            managedPlayers.add(player.getUniqueId());
             boolean nearTier = state.cooldownEnds().getOrDefault(
                 Ability.FIXER_NEAR_TYRANT_ACTIVE, Instant.MIN
             ).isAfter(now);
@@ -60,7 +67,13 @@ public final class FixerEffectController implements Runnable {
     }
 
     public void clearAll() {
-        server.getOnlinePlayers().forEach(FixerEffectController::clear);
+        for (UUID playerId : Set.copyOf(managedPlayers)) {
+            Player player = server.getPlayer(playerId);
+            if (player != null) {
+                clear(player);
+            }
+        }
+        managedPlayers.clear();
     }
 
     private static void clear(Player player) {

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

@@ -0,0 +1,8 @@
+package games.dmg.spigottyrant;
+
+public record IntelligenceResult(
+    PlayerState tyrant,
+    AbilityUseStatus status,
+    int memberCount
+) {
+}

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 "
+            messages.add("Use /tyrant optout if you do not want to participate "
-                + "if you do not want to participate.");
+                + "in Tyrant events.");
         }
         return List.copyOf(messages);
     }

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

@@ -38,6 +38,7 @@ public record PluginSettings(
     AbilityItemSettings assassinItem,
     AbilityItemSettings fixerItem,
     AbilityItemSettings tamerItem,
+    AbilityItemSettings capturedMobItem,
     String recoveryCommand,
     String inventoryFullMessage,
     boolean freezeTimersWhilePaused
@@ -76,6 +77,7 @@ public record PluginSettings(
         assassinItem = Objects.requireNonNull(assassinItem, "assassinItem");
         fixerItem = Objects.requireNonNull(fixerItem, "fixerItem");
         tamerItem = Objects.requireNonNull(tamerItem, "tamerItem");
+        capturedMobItem = Objects.requireNonNull(capturedMobItem, "capturedMobItem");
         recoveryCommand = requireText(recoveryCommand, "recovery-command");
         inventoryFullMessage = requireText(inventoryFullMessage, "inventory-full-message");
     }
@@ -111,6 +113,7 @@ public record PluginSettings(
             item(values, "assassin-item", new AbilityItemSettings("STICK", "Assassin Cloak")),
             item(values, "fixer-item", new AbilityItemSettings("STICK", "Fixer's Wrench")),
             item(values, "tamer-item", new AbilityItemSettings("FISHING_ROD", "Tamer's Lead")),
+            item(values, "captured-mob-item", new AbilityItemSettings("PAPER", "Captured Mob")),
             string(values, "recovery-command", "/tyrant item"),
             string(
                 values,

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

@@ -11,6 +11,7 @@ public final class PluginSettingsValidator {
         validateItem(settings.assassinItem(), "assassin-item");
         validateItem(settings.fixerItem(), "fixer-item");
         validateItem(settings.tamerItem(), "tamer-item");
+        validateItem(settings.capturedMobItem(), "captured-mob-item");
         for (String entityType : settings.deniedMobTypes()) {
             try {
                 EntityType.valueOf(entityType);

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

@@ -14,6 +14,7 @@ public final class SpigotTyrantPlugin extends JavaPlugin {
     private VigilanteEffectController vigilanteEffects;
     private AssassinEffectController assassinEffects;
     private FixerEffectController fixerEffects;
+    private TyrantEffectController tyrantEffects;
 
     @Override
     public void onEnable() {
@@ -52,6 +53,13 @@ public final class SpigotTyrantPlugin extends JavaPlugin {
         FollowerService followers = new FollowerService();
         AbilityReadinessService readiness = new AbilityReadinessService();
         AbilityItemService abilityItems = new BukkitAbilityItemService(this, settings);
+        CapturedMobItemService capturedMobItems = new BukkitCapturedMobItemService(
+            this, settings
+        );
+        CapturedMobService capturedMobs = new CapturedMobService();
+        CapturedMobInventoryService capturedMobInventory = new CapturedMobInventoryService(
+            capturedMobItems, settings
+        );
         AssassinAbilityService assassinAbilities = new AssassinAbilityService(
             readiness, settings
         );
@@ -60,6 +68,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);
         VigilanteCombatTracker combatTracker = new VigilanteCombatTracker();
         vigilanteEffects = new VigilanteEffectController(
             stateManager, getServer(), combatTracker, settings, clock
@@ -79,7 +88,8 @@ public final class SpigotTyrantPlugin extends JavaPlugin {
                 new ParticipationService(settings.optOutDuration()),
                 new RoleRelinquishmentService(succession, maintenance),
                 tyrantPresentation,
-                abilityItems
+                abilityItems,
+                new TyrantAbilityService(settings.rosterIntelligenceCooldown())
             ));
         Objects.requireNonNull(getCommand("vigilante"), "Missing vigilante metadata")
             .setExecutor(new VigilanteCommand(stateManager, followers, onlinePlayers));
@@ -112,6 +122,12 @@ public final class SpigotTyrantPlugin extends JavaPlugin {
             ),
             this
         );
+        getServer().getPluginManager().registerEvents(
+            new ParticipationCombatListener(
+                stateManager, new ParticipationCombatService()
+            ),
+            this
+        );
         getServer().getPluginManager().registerEvents(
             new VigilanteCombatListener(
                 stateManager, combatTracker, clock, settings.vigilanteCombatDuration()
@@ -122,6 +138,13 @@ public final class SpigotTyrantPlugin extends JavaPlugin {
             new BoundItemListener(abilityItems),
             this
         );
+        getServer().getPluginManager().registerEvents(
+            new TamerListener(
+                stateManager, abilityItems, capturedMobItems, capturedMobs,
+                settings, getServer()
+            ),
+            this
+        );
         getServer().getPluginManager().registerEvents(
             new AssassinItemListener(
                 stateManager, abilityItems, assassinAbilities, settings, clock
@@ -152,10 +175,12 @@ public final class SpigotTyrantPlugin extends JavaPlugin {
         getServer().getScheduler().runTaskTimer(this, vigilanteEffects, 10L, 10L);
         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,
             new AbilityItemRefreshTask(
-                stateManager, readiness, abilityItems, getServer(), clock
+                stateManager, readiness, abilityItems, capturedMobInventory,
+                getServer(), clock
             ),
             20L,
             20L
@@ -166,6 +191,9 @@ public final class SpigotTyrantPlugin extends JavaPlugin {
 
     @Override
     public void onDisable() {
+        if (tyrantEffects != null) {
+            tyrantEffects.clearAll();
+        }
         if (fixerEffects != null) {
             fixerEffects.clearAll();
         }

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

@@ -0,0 +1,249 @@
+package games.dmg.spigottyrant;
+
+import java.util.Iterator;
+import java.util.Map;
+import java.util.Optional;
+import java.util.UUID;
+import org.bukkit.ChatColor;
+import org.bukkit.Location;
+import org.bukkit.Server;
+import org.bukkit.entity.Entity;
+import org.bukkit.entity.EntitySnapshot;
+import org.bukkit.entity.ItemFrame;
+import org.bukkit.entity.LivingEntity;
+import org.bukkit.entity.Player;
+import org.bukkit.entity.Tameable;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.EventPriority;
+import org.bukkit.event.Listener;
+import org.bukkit.event.block.Action;
+import org.bukkit.event.block.BlockDispenseEvent;
+import org.bukkit.event.entity.EntityPickupItemEvent;
+import org.bukkit.event.entity.PlayerDeathEvent;
+import org.bukkit.event.inventory.InventoryClickEvent;
+import org.bukkit.event.player.PlayerDropItemEvent;
+import org.bukkit.event.player.PlayerInteractEntityEvent;
+import org.bukkit.event.player.PlayerInteractEvent;
+import org.bukkit.inventory.ItemStack;
+
+public final class TamerListener implements Listener {
+    private final TyrantStateManager stateManager;
+    private final AbilityItemService abilityItems;
+    private final CapturedMobItemService capturedItems;
+    private final CapturedMobService capturedMobs;
+    private final PluginSettings settings;
+    private final Server server;
+
+    public TamerListener(
+        TyrantStateManager stateManager,
+        AbilityItemService abilityItems,
+        CapturedMobItemService capturedItems,
+        CapturedMobService capturedMobs,
+        PluginSettings settings,
+        Server server
+    ) {
+        this.stateManager = stateManager;
+        this.abilityItems = abilityItems;
+        this.capturedItems = capturedItems;
+        this.capturedMobs = capturedMobs;
+        this.settings = settings;
+        this.server = server;
+    }
+
+    @EventHandler(priority = EventPriority.HIGH)
+    public void onCapture(PlayerInteractEntityEvent event) {
+        ItemStack held = event.getPlayer().getInventory().getItem(event.getHand());
+        if (abilityItems.ability(held).filter(Ability.TAMER_CAPTURE::equals).isEmpty()) {
+            return;
+        }
+        event.setCancelled(true);
+        Player player = event.getPlayer();
+        if (abilityItems.owner(held).filter(player.getUniqueId()::equals).isEmpty()) {
+            player.getInventory().setItem(event.getHand(), null);
+            return;
+        }
+        PlayerState state = stateManager.player(player.getUniqueId(), player.getName());
+        Entity target = event.getRightClicked();
+        if (!canCapture(state, target)) {
+            player.sendMessage(ChatColor.RED + "That mob cannot be captured.");
+            return;
+        }
+        EntitySnapshot snapshot = target.createSnapshot();
+        if (snapshot == null) {
+            player.sendMessage(ChatColor.RED + "That mob could not be captured safely.");
+            return;
+        }
+        UUID captureId = UUID.randomUUID();
+        ItemStack capturedItem = capturedItems.create(
+            player.getUniqueId(), captureId, target.getType().name()
+        );
+        Map<Integer, ItemStack> leftovers = player.getInventory().addItem(capturedItem);
+        if (!leftovers.isEmpty()) {
+            player.sendMessage(ChatColor.RED + settings.inventoryFullMessage());
+            return;
+        }
+        PlayerState updated = capturedMobs.capture(
+            state, captureId, target.getType().name(), snapshot.getAsString()
+        );
+        stateManager.updatePlayer(
+            player.getUniqueId(), player.getName(), current -> updated
+        );
+        stateManager.saveIfDirty();
+        target.remove();
+        player.sendMessage(ChatColor.GREEN + "Captured " + target.getType().name() + ".");
+    }
+
+    @EventHandler(priority = EventPriority.HIGH)
+    public void onPlace(PlayerInteractEvent event) {
+        Action action = event.getAction();
+        if (action != Action.RIGHT_CLICK_AIR && action != Action.RIGHT_CLICK_BLOCK) {
+            return;
+        }
+        if (!capturedItems.isCapturedMob(event.getItem())) {
+            return;
+        }
+        event.setCancelled(true);
+        UUID captureId = capturedItems.captureId(event.getItem()).orElseThrow();
+        if (capturedItems.owner(event.getItem())
+                .filter(event.getPlayer().getUniqueId()::equals).isEmpty()) {
+            event.getPlayer().getInventory().setItem(event.getHand(), null);
+            return;
+        }
+        Location location = event.getClickedBlock() == null
+            ? event.getPlayer().getLocation().add(
+                event.getPlayer().getLocation().getDirection().normalize().multiply(2.0)
+            )
+            : event.getClickedBlock().getRelative(event.getBlockFace())
+                .getLocation().add(0.5, 0.0, 0.5);
+        if (spawnAndRelease(event.getPlayer(), captureId, location)) {
+            event.getPlayer().getInventory().setItem(event.getHand(), null);
+        } else {
+            event.getPlayer().sendMessage(ChatColor.RED
+                + "The mob cannot be placed safely there.");
+        }
+    }
+
+    @EventHandler(priority = EventPriority.HIGH)
+    public void onDrop(PlayerDropItemEvent event) {
+        ItemStack item = event.getItemDrop().getItemStack();
+        if (!capturedItems.isCapturedMob(item)) {
+            return;
+        }
+        UUID captureId = capturedItems.captureId(item).orElseThrow();
+        if (capturedItems.owner(item).filter(event.getPlayer().getUniqueId()::equals).isEmpty()
+                || !spawnAndRelease(
+                    event.getPlayer(), captureId, event.getItemDrop().getLocation()
+                )) {
+            event.setCancelled(true);
+            return;
+        }
+        event.getItemDrop().remove();
+    }
+
+    @EventHandler(priority = EventPriority.HIGH)
+    public void onDeath(PlayerDeathEvent event) {
+        Iterator<ItemStack> drops = event.getDrops().iterator();
+        while (drops.hasNext()) {
+            ItemStack item = drops.next();
+            if (!capturedItems.isCapturedMob(item)) {
+                continue;
+            }
+            UUID captureId = capturedItems.captureId(item).orElseThrow();
+            if (spawnAndRelease(event.getEntity(), captureId, event.getEntity().getLocation())) {
+                drops.remove();
+            }
+        }
+    }
+
+    @EventHandler
+    public void onInventoryClick(InventoryClickEvent event) {
+        if (capturedItems.isCapturedMob(event.getCurrentItem())
+                || capturedItems.isCapturedMob(event.getCursor())) {
+            if (!(event.getWhoClicked() instanceof Player player)
+                    || event.isShiftClick()
+                    || event.getClickedInventory() == null
+                    || !event.getClickedInventory().equals(player.getInventory())) {
+                event.setCancelled(true);
+            }
+        }
+    }
+
+    @EventHandler
+    public void onFrame(PlayerInteractEntityEvent event) {
+        if (event.getRightClicked() instanceof ItemFrame
+                && capturedItems.isCapturedMob(
+                    event.getPlayer().getInventory().getItem(event.getHand())
+                )) {
+            event.setCancelled(true);
+        }
+    }
+
+    @EventHandler
+    public void onDispense(BlockDispenseEvent event) {
+        if (capturedItems.isCapturedMob(event.getItem())) {
+            event.setCancelled(true);
+        }
+    }
+
+    @EventHandler
+    public void onPickup(EntityPickupItemEvent event) {
+        if (!(event.getEntity() instanceof Player player)
+                || !capturedItems.isCapturedMob(event.getItem().getItemStack())) {
+            return;
+        }
+        if (capturedItems.owner(event.getItem().getItemStack())
+                .filter(player.getUniqueId()::equals).isEmpty()) {
+            event.setCancelled(true);
+        }
+    }
+
+    private boolean canCapture(PlayerState player, Entity target) {
+        if (stateManager.game().lifecycle() != GameLifecycle.RUNNING
+                || player.tyrantClass() != TyrantClass.TAMER
+                || !(target instanceof LivingEntity)
+                || target instanceof Player
+                || target.getType().name().equals("ENDER_DRAGON")
+                || settings.deniedMobTypes().contains(target.getType().name())
+                || target.getCustomName() != null) {
+            return false;
+        }
+        return !(target instanceof Tameable tameable) || !tameable.isTamed();
+    }
+
+    private boolean spawnAndRelease(Player player, UUID captureId, Location location) {
+        PlayerState state = stateManager.player(player.getUniqueId(), player.getName());
+        Optional<CapturedMob> stored = capturedMobs.find(state, captureId);
+        if (stored.isEmpty() || !safe(location)) {
+            return false;
+        }
+        CapturedMob mob = stored.orElseThrow();
+        if ("ENDER_DRAGON".equals(mob.entityType())
+                || settings.deniedMobTypes().contains(mob.entityType())) {
+            return false;
+        }
+        try {
+            EntitySnapshot snapshot = server.getEntityFactory().createEntitySnapshot(
+                mob.data().get("snapshot")
+            );
+            if (!snapshot.getEntityType().name().equals(mob.entityType())) {
+                return false;
+            }
+            snapshot.createEntity(location);
+        } catch (IllegalArgumentException | IllegalStateException exception) {
+            return false;
+        }
+        PlayerState released = capturedMobs.release(state, captureId);
+        stateManager.updatePlayer(
+            player.getUniqueId(), player.getName(), current -> released
+        );
+        stateManager.saveIfDirty();
+        return true;
+    }
+
+    private static boolean safe(Location location) {
+        return location.getWorld() != null
+            && location.getBlock().isPassable()
+            && location.clone().add(0.0, 1.0, 0.0).getBlock().isPassable()
+            && location.getWorld().getWorldBorder().isInside(location);
+    }
+}

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

@@ -0,0 +1,53 @@
+package games.dmg.spigottyrant;
+
+import java.time.Duration;
+import java.time.Instant;
+import java.util.EnumMap;
+import java.util.Map;
+
+public final class TyrantAbilityService {
+    private final Duration intelligenceCooldown;
+
+    public TyrantAbilityService(Duration intelligenceCooldown) {
+        this.intelligenceCooldown = intelligenceCooldown;
+    }
+
+    public IntelligenceResult useIntelligence(
+        GameState game,
+        PlayerState tyrant,
+        Map<java.util.UUID, PlayerState> players,
+        Instant now
+    ) {
+        if (game.lifecycle() != GameLifecycle.RUNNING) {
+            return new IntelligenceResult(tyrant, AbilityUseStatus.GAME_NOT_RUNNING, 0);
+        }
+        if (game.tyrantId().filter(tyrant.playerId()::equals).isEmpty()) {
+            return new IntelligenceResult(tyrant, AbilityUseStatus.WRONG_OWNER, 0);
+        }
+        if (!game.purchases().contains(TyrantUnlock.ROSTER_INTELLIGENCE)) {
+            return new IntelligenceResult(tyrant, AbilityUseStatus.NOT_READY, 0);
+        }
+        if (tyrant.cooldownEnds().getOrDefault(
+                Ability.ROSTER_INTELLIGENCE, Instant.MIN
+            ).isAfter(now)) {
+            return new IntelligenceResult(tyrant, AbilityUseStatus.COOLDOWN, 0);
+        }
+        int count = game.vigilanteId().isPresent() ? 1 : 0;
+        if (game.vigilanteId().isPresent()) {
+            java.util.UUID vigilante = game.vigilanteId().orElseThrow();
+            count += (int) players.values().stream()
+                .filter(player -> player.followerOf().filter(vigilante::equals).isPresent())
+                .filter(player -> player.optedOutUntil().isEmpty())
+                .count();
+        }
+        Map<Ability, Instant> cooldowns = new EnumMap<>(Ability.class);
+        cooldowns.putAll(tyrant.cooldownEnds());
+        cooldowns.put(Ability.ROSTER_INTELLIGENCE, now.plus(intelligenceCooldown));
+        PlayerState updated = new PlayerState(
+            tyrant.playerId(), tyrant.latestName(), tyrant.lastLogin(),
+            tyrant.optedOutUntil(), tyrant.tyrantClass(), tyrant.followerOf(), cooldowns,
+            tyrant.readyAbilityItems(), tyrant.capturedMobs()
+        );
+        return new IntelligenceResult(updated, AbilityUseStatus.ACTIVATED, count);
+    }
+}

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

@@ -19,6 +19,7 @@ public final class TyrantCommand implements CommandExecutor {
     private final RoleRelinquishmentService relinquishment;
     private final TyrantPresentation presentation;
     private final AbilityItemService abilityItems;
+    private final TyrantAbilityService tyrantAbilities;
 
     public TyrantCommand(
         TyrantStateManager stateManager,
@@ -42,7 +43,8 @@ public final class TyrantCommand implements CommandExecutor {
     ) {
         this(
             stateManager, progression, assignments, onlinePlayers, clock,
-            new ParticipationService(Duration.ofDays(7)), null, null, null
+            new ParticipationService(Duration.ofDays(7)), null, null, null,
+            new TyrantAbilityService(Duration.ofHours(24))
         );
     }
 
@@ -55,7 +57,8 @@ public final class TyrantCommand implements CommandExecutor {
         ParticipationService participation,
         RoleRelinquishmentService relinquishment,
         TyrantPresentation presentation,
-        AbilityItemService abilityItems
+        AbilityItemService abilityItems,
+        TyrantAbilityService tyrantAbilities
     ) {
         this.stateManager = stateManager;
         this.progression = progression;
@@ -66,6 +69,7 @@ public final class TyrantCommand implements CommandExecutor {
         this.relinquishment = relinquishment;
         this.presentation = presentation;
         this.abilityItems = abilityItems;
+        this.tyrantAbilities = tyrantAbilities;
     }
 
     @Override
@@ -111,9 +115,13 @@ public final class TyrantCommand implements CommandExecutor {
             recoverItems(player);
             return true;
         }
+        if (arguments.length == 1 && arguments[0].equalsIgnoreCase("intelligence")) {
+            useIntelligence(player);
+            return true;
+        }
         player.sendMessage(
             ChatColor.YELLOW
-                + "Usage: /tyrant <status|choices|buy|assign|item|optout|optin|"
+                + "Usage: /tyrant <status|choices|buy|assign|item|intelligence|optout|optin|"
                 + "relinquish confirm>"
         );
         return true;
@@ -241,6 +249,24 @@ public final class TyrantCommand implements CommandExecutor {
             + readable(result[0].status()) + ".");
     }
 
+    private void useIntelligence(Player player) {
+        PlayerState state = stateManager.player(player.getUniqueId(), player.getName());
+        IntelligenceResult result = tyrantAbilities.useIntelligence(
+            stateManager.game(), state, stateManager.players(), clock.instant()
+        );
+        if (result.status() == AbilityUseStatus.ACTIVATED) {
+            stateManager.updatePlayer(
+                player.getUniqueId(), player.getName(), current -> result.tyrant()
+            );
+            stateManager.saveIfDirty();
+            player.sendMessage(ChatColor.YELLOW + "Vigilante-side members: "
+                + result.memberCount() + ".");
+        } else {
+            player.sendMessage(ChatColor.RED + "Intelligence unavailable: "
+                + readable(result.status()) + ".");
+        }
+    }
+
     private void recoverItems(Player player) {
         if (abilityItems == null) {
             player.sendMessage(ChatColor.RED + "Ability item recovery is unavailable.");

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

@@ -0,0 +1,77 @@
+package games.dmg.spigottyrant;
+
+import java.util.Optional;
+import java.util.UUID;
+import org.bukkit.Server;
+import org.bukkit.entity.Player;
+import org.bukkit.potion.PotionEffect;
+import org.bukkit.potion.PotionEffectType;
+
+public final class TyrantEffectController implements Runnable {
+    private static final int EFFECT_TICKS = 30;
+    private final TyrantStateManager stateManager;
+    private final Server server;
+    private final PluginSettings settings;
+    private Optional<UUID> previousTyrant = Optional.empty();
+
+    public TyrantEffectController(
+        TyrantStateManager stateManager,
+        Server server,
+        PluginSettings settings
+    ) {
+        this.stateManager = stateManager;
+        this.server = server;
+        this.settings = settings;
+    }
+
+    @Override
+    public void run() {
+        GameState game = stateManager.game();
+        if (!previousTyrant.equals(game.tyrantId())) {
+            previousTyrant.map(server::getPlayer).ifPresent(TyrantEffectController::clear);
+            previousTyrant = game.tyrantId();
+        }
+        Player tyrant = game.tyrantId().map(server::getPlayer).orElse(null);
+        if (tyrant == null || game.lifecycle() != GameLifecycle.RUNNING) {
+            if (tyrant != null) {
+                clear(tyrant);
+            }
+            return;
+        }
+        apply(
+            tyrant, PotionEffectType.STRENGTH,
+            game.purchases().contains(TyrantUnlock.STRENGTH),
+            settings.tyrantStrengthLevel()
+        );
+        apply(
+            tyrant, PotionEffectType.RESISTANCE,
+            game.purchases().contains(TyrantUnlock.RESISTANCE),
+            settings.tyrantResistanceLevel()
+        );
+    }
+
+    public void clearAll() {
+        previousTyrant.map(server::getPlayer).ifPresent(TyrantEffectController::clear);
+        previousTyrant = Optional.empty();
+    }
+
+    private static void apply(
+        Player player,
+        PotionEffectType type,
+        boolean purchased,
+        int level
+    ) {
+        if (purchased) {
+            player.addPotionEffect(new PotionEffect(
+                type, EFFECT_TICKS, level - 1, false, true, true
+            ));
+        } else {
+            player.removePotionEffect(type);
+        }
+    }
+
+    private static void clear(Player player) {
+        player.removePotionEffect(PotionEffectType.STRENGTH);
+        player.removePotionEffect(PotionEffectType.RESISTANCE);
+    }
+}

src/main/resources/config.yml

@@ -35,6 +35,9 @@ fixer-item:
 tamer-item:
   material: FISHING_ROD
   name: Tamer's Lead
+captured-mob-item:
+  material: PAPER
+  name: Captured Mob
 denied-mob-types:
   - ENDER_DRAGON
   - WITHER

src/main/resources/plugin.yml

@@ -7,7 +7,7 @@ author: dmg.games
 commands:
   tyrant:
     description: View and use Spigot Tyrant game features.
-    usage: /tyrant <status|choices|buy|assign|optout|optin|relinquish confirm>
+    usage: /tyrant <status|choices|buy|assign|item|intelligence|optout|optin|relinquish confirm>
   vigilante:
     description: Manage Vigilante Followers.
     usage: /vigilante <invite <player>|accept|dismiss <player>|leave>

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

@@ -0,0 +1,46 @@
+package games.dmg.spigottyrant;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+
+import java.util.Map;
+import java.util.Optional;
+import java.util.Set;
+import java.util.UUID;
+import org.junit.jupiter.api.Test;
+
+final class CapturedMobServiceTest {
+    private final CapturedMobService service = new CapturedMobService();
+
+    @Test
+    void captureAddsSnapshotAndSuccessfulReleaseRemovesExactlyThatMob() {
+        UUID captureId = UUID.fromString("aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaaaaaa");
+        PlayerState tamer = tamer();
+
+        PlayerState captured = service.capture(
+            tamer, captureId, "ZOMBIE", "{id:\"minecraft:zombie\"}"
+        );
+        CapturedMob mob = service.find(captured, captureId).orElseThrow();
+        PlayerState released = service.release(captured, captureId);
+
+        assertEquals("ZOMBIE", mob.entityType());
+        assertEquals("{id:\"minecraft:zombie\"}", mob.data().get("snapshot"));
+        assertEquals(java.util.List.of(), released.capturedMobs());
+    }
+
+    @Test
+    void enderDragonCanNeverBeCapturedAndMissingReleaseDoesNotMutate() {
+        assertThrows(IllegalArgumentException.class, () -> service.capture(
+            tamer(), UUID.randomUUID(), "ENDER_DRAGON", "snapshot"
+        ));
+        assertEquals(tamer(), service.release(tamer(), UUID.randomUUID()));
+    }
+
+    private static PlayerState tamer() {
+        return new PlayerState(
+            UUID.fromString("11111111-1111-1111-1111-111111111111"), "Tamer",
+            Optional.empty(), Optional.empty(), TyrantClass.TAMER, Optional.empty(),
+            Map.of(), Set.of(Ability.TAMER_CAPTURE), java.util.List.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."
+        ));
     }
 }

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

@@ -0,0 +1,49 @@
+package games.dmg.spigottyrant;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+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 TyrantAbilityServiceTest {
+    private static final UUID TYRANT = UUID.fromString("11111111-1111-1111-1111-111111111111");
+    private static final UUID VIGILANTE = UUID.fromString("22222222-2222-2222-2222-222222222222");
+    private static final UUID FOLLOWER = UUID.fromString("33333333-3333-3333-3333-333333333333");
+    private static final Instant NOW = Instant.parse("2026-08-14T12:00:00Z");
+    private final TyrantAbilityService service = new TyrantAbilityService(
+        Duration.ofHours(24)
+    );
+
+    @Test
+    void intelligenceCountsVigilanteSideWithoutIdentitiesAndStartsCooldown() {
+        GameState game = new GameState(
+            GameLifecycle.RUNNING, Optional.of(TYRANT), Optional.of(VIGILANTE),
+            Optional.empty(), Optional.empty(), Optional.empty(), Duration.ZERO,
+            1, 0, Set.of(TyrantUnlock.ROSTER_INTELLIGENCE)
+        );
+        PlayerState tyrant = PlayerState.newPlayer(TYRANT, "Tyrant");
+        PlayerState follower = new PlayerState(
+            FOLLOWER, "Follower", Optional.empty(), Optional.empty(), TyrantClass.NONE,
+            Optional.of(VIGILANTE), Map.of(), Set.of(), java.util.List.of()
+        );
+
+        IntelligenceResult used = service.useIntelligence(
+            game, tyrant, Map.of(TYRANT, tyrant, FOLLOWER, follower), NOW
+        );
+        IntelligenceResult blocked = service.useIntelligence(
+            game, used.tyrant(), Map.of(TYRANT, used.tyrant(), FOLLOWER, follower),
+            NOW.plusSeconds(1)
+        );
+
+        assertEquals(AbilityUseStatus.ACTIVATED, used.status());
+        assertEquals(2, used.memberCount());
+        assertEquals(NOW.plus(Duration.ofHours(24)), used.tyrant().cooldownEnds()
+            .get(Ability.ROSTER_INTELLIGENCE));
+        assertEquals(AbilityUseStatus.COOLDOWN, blocked.status());
+    }
+}