feat(vigilante): add arena boss succession

design/concepts/game-state-machine.md

@@ -16,20 +16,23 @@ Pausing freezes gameplay progression, role inactivity checks, pending-selection
 
 When a player directly kills the Tyrant, that killer becomes the new Tyrant. When no player is credited with the death, an eligible opted-in player active during the preceding 24 hours is selected randomly. The former Tyrant is excluded when another candidate exists.
 
-Every Tyrant death ends the reign, clears all role-side assignments, resets the former Tyrant's reign progression, and requires a new Vigilante. The new Tyrant receives one starting unlock choice.
+Every Tyrant death ends the reign, clears all role-side assignments, resets the former Tyrant's reign progression, and leaves the Vigilante role open for the arena challenge. The new Tyrant receives one starting unlock choice.
 
 ## Vigilante succession
 
-Every Vigilante death ends that assignment regardless of cause. A replacement is selected randomly from eligible opted-in players active during the preceding 24 hours. The Tyrant is never eligible. The previous Vigilante is excluded when another eligible non-Tyrant exists and may be selected again only as a fallback. Followers are cleared rather than transferred.
+Every Vigilante death ends that assignment regardless of cause. Vigilante inactivity and relinquishment also end the assignment, and every new Tyrant reign clears the previous assignment. Followers are cleared rather than transferred.
 
-A Tyrant earns progression from the death only when the Tyrant personally killed the Vigilante.
+While the game is running with an active Tyrant and no Vigilante, an administrator-configured arena opens. One eligible opted-in non-Tyrant player at a time may challenge the arena boss. Defeating it assigns that player as Vigilante. Leaving, disconnecting, or dying resets the fight without preventing an immediate retry. Without an active Tyrant or configured arena, the role remains vacant and no boss exists.
+
+A Tyrant earns progression from a Vigilante death only when the Tyrant personally killed the Vigilante.
 
 ## Pending selections
 
-An offline random selectee has 24 hours of unpaused time to log in and confirm the assignment. Failure causes another selection. When no eligible candidate exists, the position remains vacant and selection retries periodically without assigning the Tyrant to both roles.
+An offline randomly selected Tyrant has 24 hours of unpaused time to log in and confirm the assignment. Failure causes another Tyrant selection. When no eligible Tyrant candidate exists, the position remains vacant and selection retries periodically. Vigilante vacancies use the arena rather than pending random selection.
 
 ## Related stories
 
 - [Start, pause, and administer the game](../user-stories/us-001-start-pause-and-administer.md)
 - [Transfer and reset the Tyrant role](../user-stories/us-002-transfer-and-reset-tyrant.md)
 - [Handle inactivity and pending selections](../user-stories/us-010-handle-inactivity-and-selection.md)
+- [Claim the Vigilante role in the arena](../user-stories/us-019-claim-vigilante-in-arena.md)

design/concepts/persistence-model.md

@@ -6,7 +6,7 @@ description: Defines the durable state and timekeeping needed to restore a Tyran
 
 # Persistence Model
 
-State is keyed by player UUID while retaining the latest known player name for display. Durable global state includes lifecycle status, current and pending role holders, selection deadlines, paused durations, and the current Tyrant reign.
+State is keyed by player UUID while retaining the latest known player name for display. Durable global state includes lifecycle status, current and pending role holders, selection deadlines, paused durations, the current Tyrant reign, and the administrator-configured Vigilante arena center. Active boss and challenger entities are transient and are reconstructed or reset from authoritative role and arena state after restart.
 
 Durable player state includes participation status, opt-out deadline, login history, role or class, Tyrant level, purchased unlocks, unspent choices, Follower relationship, ability cooldowns, daily intelligence use, bound-item delivery state, and captured mobs.
 
@@ -17,3 +17,4 @@ Elapsed-time rules use UTC instants. Paused time is excluded from timers. Saves
 - [Inform players and manage participation](../user-stories/us-011-inform-and-manage-participation.md)
 - [Configure and persist game state](../user-stories/us-012-configure-and-persist-state.md)
 - [Use class ability items](../user-stories/us-014-use-class-ability-items.md)
+- [Claim the Vigilante role in the arena](../user-stories/us-019-claim-vigilante-in-arena.md)

design/concepts/role-and-class-model.md

@@ -8,7 +8,7 @@ description: Defines Tyrant-side classes, Vigilante-side membership, progression
 
 ## Roles and affiliations
 
-A running game has one Tyrant and, when an eligible player is available, one Vigilante. The Vigilante may recruit Followers through invitations that require acceptance. The Tyrant may assign the Assassin, Fixer, and Tamer classes after unlocking them.
+A running game has one active or pending Tyrant. It has at most one Vigilante, and a vacant Vigilante role remains open until an eligible player wins the configured arena challenge. The Vigilante may recruit Followers through invitations that require acceptance. The Tyrant may assign the Assassin, Fixer, and Tamer classes after unlocking them.
 
 Role alignment and Tyrant-side class are independent. A Vigilante or Follower may simultaneously hold one Tyrant-side class, allowing divided loyalties. A player cannot simultaneously be the Tyrant, Vigilante, and/or a Follower, and cannot hold more than one Tyrant-side class. Each Tyrant-side class may be assigned to only one player at a time. Opted-out players are ineligible for every assignment.
 
@@ -36,3 +36,4 @@ Vigilante Follower scaling is capped by default at Strength V and Resistance IV,
 - [Progress and purchase Tyrant unlocks](../user-stories/us-003-progress-and-purchase-unlocks.md)
 - [Assign unlocked classes](../user-stories/us-004-assign-unlocked-classes.md)
 - [Support the Vigilante and Followers](../user-stories/us-008-support-vigilante-and-followers.md)
+- [Claim the Vigilante role in the arena](../user-stories/us-019-claim-vigilante-in-arena.md)

design/index.md

@@ -12,6 +12,7 @@ This bundle documents the asymmetric Tyrant game, its role succession, class abi
 ## Explore
 
 - [User stories](user-stories/index.md)
+- [Vigilante arena challenge](user-stories/us-019-claim-vigilante-in-arena.md)
 - [Game state machine](concepts/game-state-machine.md)
 - [Role and class model](concepts/role-and-class-model.md)
 - [Persistence model](concepts/persistence-model.md)

design/log.md

@@ -6,6 +6,89 @@ description: Chronological record of material decisions affecting the Spigot Tyr
 
 # Spigot Tyrant Design Log
 
+## 2026-08-23 — Vigilante arena succession completed
+
+- Completed US-019 and reopened related administration, Vigilante, inactivity, participation, persistence, control-panel, and completion stories to replace automatic Vigilante selection with an earned arena challenge.
+- Vigilante vacancies caused by death, inactivity, relinquishment, initial startup, or a new Tyrant reign now open a configured one-player enhanced-zombie fight only while a Tyrant is active.
+- Added a persistent administrator-set arena center, continuous particle boundary, temporary safe `BARRIER` wall, entrant and respawn containment, mob exclusion, sunlight-safe boss behavior, full fight reset, and boss-victory assignment.
+- Opted-in players receive vacancy coordinates when the challenge opens or they join; opted-out players are excluded from notices and entry.
+- Verified arena policy, geometry, succession, configuration persistence and validation, barrier restoration, command handling and completion, compiler warnings, 109 automated tests, and packaging with `./gradlew clean check jar`.
+
+## 2026-08-21 — Contextual command completion completed
+
+- Completed US-018 with registered completers for `/tyrant`, `/vigilante`, and `/tyrantadmin`, replacing Bukkit's unconditional online-player fallback.
+- Suggestions now follow argument position, filter case-insensitively, expose eligible assignment and recruitment targets, identify current Followers for dismissal, and gate administration by permission.
+- Administrative completion remains available to permitted console senders, while player-only commands return no console suggestions.
+- Verified syntax, eligibility, membership, permissions, prefix filtering, compiler warnings, tests, and packaging with `./gradlew clean check jar`.
+
+## 2026-08-21 — Contextual command completion started
+
+- US-018 begins a test-first replacement of Bukkit's player-name fallback with syntax-aware Tyrant, Vigilante, and administrative command suggestions.
+- Player arguments will be filtered by the applicable assignment or membership rules, while administrative suggestions remain permission-gated.
+
+## 2026-08-21 — Single-mob Tamer custody completed
+
+- Completed US-007 with an authoritative one-mob custody limit that rejects a second capture before inventory, entity, or state mutation and tells the Tamer to release the held mob first.
+- Releasing or dropping custody permits another capture immediately, while durable state preserves the limit across logout, restart, recovery, and repeated interaction.
+- Legacy excess custody retains the oldest mob and safely releases extras; offline or failed releases remain durable for periodic retry.
+- Verified domain rejection, listener ordering, legacy reconciliation, compiler warnings, tests, and packaging with `./gradlew clean check jar`.
+
+## 2026-08-21 — Single-mob Tamer custody started
+
+- US-007 begins a test-first one-mob custody limit for active Tamers.
+- New captures will be rejected before mutation while custody exists, and legacy excess custody will be released safely with failed releases retained for retry.
+
+## 2026-08-21 — Former Tamer automatic release completed
+
+- Completed US-004 and US-007 so every captured mob is released automatically after its holder loses the Tamer class, regardless of the class-removal path.
+- Online former Tamers release at a validated safe location; offline, dead, unsafe, malformed, or otherwise unspawnable custody remains durable and retries periodically after login or movement.
+- Custody records and captured-mob items are removed only for successful spawns, while ordinary inventory remains untouched.
+- Verified former-Tamer filtering, offline deferral, partial success, custody preservation, compiler warnings, tests, and packaging with `./gradlew clean check jar`.
+
+## 2026-08-21 — Former Tamer automatic release started
+
+- US-004 and US-007 begin a test-first implementation that automatically releases captured mobs when a player loses the Tamer class.
+- Release will preserve ordinary inventory, remove custody only after successful spawning, and defer safely for offline players or unsafe locations before retrying.
+
+## 2026-08-21 — Bound role control items completed
+
+- Completed US-017 and the reopened US-015 and US-016 criteria with configurable owner-bound Tyrant and Vigilante control items that open their respective panels.
+- Role items are reconciled on login and periodically after role transitions, deduplicated, removed after role loss, and recoverable through `/tyrant item` or `/vigilante item` without dropping overflow.
+- Drop, pickup, container, drag, hopper, placement, dispenser, item-frame, death, stale-owner, and stale-role paths prevent transfer or remove invalid items.
+- Added default `Tyrant Control` Nether Star and `Vigilante Control` Compass settings and validation.
+- Verified role policy, delayed reconciliation, panel interaction, command recovery, settings defaults, compiler warnings, tests, and packaging with `./gradlew clean check jar`.
+
+## 2026-08-21 — Bound role control item implementation started
+
+- US-015, US-016, and US-017 begin a test-first implementation of configurable owner-bound Tyrant and Vigilante control items.
+- Delivery, command recovery, interaction, role validation, transfer prevention, role-loss cleanup, and duplicate resistance will build on the existing bound-item patterns.
+
+## 2026-08-21 — Bound role control items planned
+
+- Added US-017 for secure owner-bound Tyrant and Vigilante inventory items that open the corresponding control panels.
+- The Tyrant item defaults to a Nether Star named `Tyrant Control`, and the Vigilante item defaults to a Compass named `Vigilante Control`; both material and name are configurable.
+- Planned automatic role-assignment and login delivery, command recovery, full transfer prevention, removal on role loss or inventory departure, and duplicate resistance.
+- Reopened US-015 and US-016 in the backlog to track control-panel access through the new role items.
+
+## 2026-08-21 — Vigilante control panel completed
+
+- Completed US-016 and the reopened US-008 criteria with resistance overview, recruitment, Follower management, and confirmed role-relinquishment screens.
+- `/vigilante` and `/vigilante menu` open the panel, while existing invitation, acceptance, dismissal, leave, and relinquishment commands remain available.
+- Added a 100-tick login delay with online, lifecycle, role, and already-opened session checks so only the current Vigilante receives one automatic panel per login.
+- Pending invitations are visible and idempotent, existing Followers cannot be reinvited, and all menu mutations delegate to authoritative command and domain rules.
+- Verified command routing, authorization, overview state, invitation rules, delayed opening safeguards, compiler warnings, tests, and packaging with `./gradlew clean check jar`.
+
+## 2026-08-21 — Vigilante control panel implementation started
+
+- US-008 and US-016 begin a test-first implementation of the Vigilante control panel, delayed login opening, resistance overview, recruitment, dismissal, and role relinquishment.
+- The panel will reuse authoritative Follower and relinquishment rules while preserving all existing command alternatives.
+
+## 2026-08-21 — Vigilante control panel planned
+
+- Added US-016 for a graphical Vigilante control panel covering resistance overview, recruitment, Follower management, and confirmed role relinquishment while preserving command alternatives.
+- Planned automatic control-panel opening five seconds after the active Vigilante joins a running event, with lifecycle, role, disconnect, and duplicate-opening safeguards.
+- Reopened US-008 in the backlog to track the approved control-panel interactions and nearby-Follower combat contribution display.
+
 ## 2026-08-21 — Tyrant control panel completed
 
 - Completed US-015 and the reopened US-003, US-004, and US-009 control-panel criteria with overview, unlock purchase confirmation, class assignment, and ability screens.

design/user-stories/index.md

@@ -15,3 +15,7 @@
 13. [US-013: Build, test, and release the plugin](us-013-build-test-and-release.md)
 14. [US-014: Use class ability items](us-014-use-class-ability-items.md)
 15. [US-015: Manage a reign through the Tyrant control panel](us-015-manage-tyrant-control-panel.md)
+16. [US-016: Manage Followers through the Vigilante control panel](us-016-manage-vigilante-control-panel.md)
+17. [US-017: Use bound role control items](us-017-use-bound-role-control-items.md)
+18. [US-018: Complete Tyrant commands contextually](us-018-complete-commands-contextually.md)
+19. [US-019: Claim the Vigilante role in the arena](us-019-claim-vigilante-in-arena.md)

design/user-stories/us-001-start-pause-and-administer.md

@@ -12,15 +12,16 @@ As a **server operator**, I want to start, pause, resume, and inspect the game s
 ## Acceptance criteria
 
 - [x] An administrator can start the first game by assigning the initial Tyrant.
-- [x] The administrator may assign the first Vigilante or allow random selection from eligible recently active players.
+- [x] The administrator may assign the first Vigilante or leave the role vacant for the configured Vigilante arena challenge.
 - [x] An administrator can pause and resume the game without deleting game state.
 - [x] Pausing freezes progression, cooldowns, daily-use timers, inactivity checks, and pending-selection deadlines.
 - [x] Role and class effects are suppressed while paused and restored when play resumes.
 - [x] Administrative commands require the `spigottyrant.admin` permission, granted to server operators by default.
-- [x] Administrators can inspect lifecycle state, roles, classes, Followers, purchases, levels, cooldowns, participation, and pending selections.
+- [x] Administrators can inspect lifecycle state, roles, classes, Followers, purchases, levels, cooldowns, participation, pending selections, and the configured Vigilante arena location.
 - [x] Destructive administrative operations require explicit confirmation.
 
 ## Related
 
 - [Tyrant game state machine](../concepts/game-state-machine.md)
 - [Configure and persist game state](us-012-configure-and-persist-state.md)
+- [Claim the Vigilante role in the arena](us-019-claim-vigilante-in-arena.md)

design/user-stories/us-004-assign-unlocked-classes.md

@@ -22,6 +22,7 @@ As the **Tyrant**, I want to assign unlocked specialist classes so that I can bu
 - [x] The Tyrant can assign and reassign purchased classes through the Tyrant control panel.
 - [x] The control panel's player selector communicates eligibility and identifies the current class holder before confirmation.
 - [x] Control-panel and command-based assignments enforce identical rules.
+- [x] Removing or reassigning the Tamer class automatically releases the former holder's captured mobs while leaving ordinary inventory untouched.
 
 ## Related
 

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

@@ -21,6 +21,23 @@ As the **Tamer**, I want to capture a mob and release it elsewhere so that I can
 - [x] Capture restrictions are configurable without permitting Ender Dragons.
 - [x] Invalid placement, full inventory, death, logout, restart, plugin disable, containers, and concurrent interaction cannot lose or duplicate a mob.
 - [x] Stored mob data is validated defensively before spawning and cannot execute untrusted serialized behavior.
+- [x] When a player loses the Tamer class, every captured mob in their custody is automatically released at the former Tamer's location.
+- [x] Ordinary inventory items are not dropped or changed during automatic release.
+- [x] Each captured-mob item and custody record is removed only after its mob spawns successfully.
+- [x] Multiple captured mobs are released without duplicating entities or custody records.
+- [x] If the former Tamer is offline or no safe release location is available, release is deferred without losing the captured mob.
+- [x] A deferred release is retried when the former Tamer next logs in or reaches a safe location.
+- [x] Tyrant death, class reassignment, opt-out, administration, and other Tamer-removal paths use the same release behavior.
+- [x] A Tamer can hold custody of at most one captured mob at a time.
+- [x] Attempting to capture another mob while one is held is rejected before changing either mob.
+- [x] The Tamer is told to release the currently captured mob before capturing another.
+- [x] Releasing or dropping the held mob immediately allows another capture.
+- [x] The one-mob limit survives logout, restart, item recovery, and repeated or concurrent interaction.
+- [x] If legacy state contains multiple captured mobs, extras are safely released when possible; custody is retained until release succeeds so no mob is lost.
+
+## Validation
+
+Automated tests verify that only former Tamers are processed, offline custody remains deferred, successful releases remove only their corresponding custody records, and failed releases remain available for retry. Additional tests verify pre-mutation rejection of a second capture, clear player guidance, and safe reduction of legacy excess custody. The complete `./gradlew clean check jar` lifecycle passes.
 
 ## Related
 

design/user-stories/us-008-support-vigilante-and-followers.md

@@ -11,7 +11,7 @@ As the **Vigilante**, I want nearby living Followers to strengthen me against th
 
 ## Acceptance criteria
 
-- [x] Exactly one active Vigilante exists while the game is running whenever an eligible player is available.
+- [x] A running game has at most one active Vigilante; a vacancy remains open until an eligible player defeats the arena boss.
 - [x] The Vigilante can invite eligible opted-in players to become Followers, and recruitment requires acceptance.
 - [x] The Vigilante can dismiss Followers and Followers can leave voluntarily.
 - [x] While actively fighting the Tyrant, the Vigilante gains one potion level each of Strength and Resistance per living Follower in the same world within 50 blocks.
@@ -19,12 +19,18 @@ As the **Vigilante**, I want nearby living Followers to strengthen me against th
 - [x] A Vigilante or Follower may simultaneously hold one Tyrant-side class without losing Vigilante-side membership.
 - [x] Effect levels update promptly as combat starts or ends and as Followers move, die, respawn, disconnect, or change assignment.
 - [x] Scaling is capped by validated configuration, defaulting to Strength V and Resistance IV.
-- [x] Every Vigilante death ends the assignment and triggers random replacement regardless of cause.
-- [x] The deceased Vigilante is excluded when another eligible non-Tyrant candidate exists and is reused only when no such candidate exists.
+- [x] Every Vigilante death ends the assignment and opens the one-player arena challenge while a Tyrant is active.
+- [x] The deceased Vigilante may immediately compete again under the same arena eligibility and reset rules as every other participant.
 - [x] Followers are cleared rather than transferred when their Vigilante dies or loses the position.
 - [x] The Tyrant is never eligible to be selected as Vigilante.
+- [x] The Vigilante can review, invite, and dismiss Followers through the Vigilante control panel.
+- [x] Control-panel and command-based Follower actions enforce identical eligibility and membership rules.
+- [x] The control panel communicates the current nearby-Follower combat contribution and configured effect caps.
+- [x] Relinquishing through the control panel clears Followers and opens the Vigilante arena challenge.
 
 ## Related
 
 - [Role and class model](../concepts/role-and-class-model.md)
 - [Handle inactivity and pending selections](us-010-handle-inactivity-and-selection.md)
+- [Manage Followers through the Vigilante control panel](us-016-manage-vigilante-control-panel.md)
+- [Claim the Vigilante role in the arena](us-019-claim-vigilante-in-arena.md)

design/user-stories/us-010-handle-inactivity-and-selection.md

@@ -15,14 +15,15 @@ As a **participant**, I want inactive central roles to be replaced fairly so tha
 - [x] Random candidates are drawn from eligible opted-in players who logged in during the preceding 24 hours.
 - [x] The Tyrant is always excluded from Vigilante selection.
 - [x] A previous role holder is excluded when another eligible candidate exists and may be reused only as a fallback.
-- [x] Tyrant inactivity ends the reign, clears all assignments, and invokes normal random Tyrant succession followed by Vigilante selection.
-- [x] Vigilante inactivity clears Followers and rerolls only the Vigilante position.
+- [x] Tyrant inactivity ends the reign, clears all assignments, invokes normal random Tyrant succession, and opens the Vigilante arena challenge once a Tyrant is active.
+- [x] Vigilante inactivity clears Followers and opens the Vigilante arena challenge without changing the Tyrant.
 - [x] An offline randomly selected candidate must log in within 24 unpaused hours to confirm the assignment.
-- [x] An unconfirmed selection expires and rerolls automatically under the same eligibility rules.
-- [x] Selection remains vacant and retries periodically when no valid candidate exists.
+- [x] An unconfirmed Tyrant selection expires and rerolls automatically under the same eligibility rules.
+- [x] Tyrant selection remains vacant and retries periodically when no valid candidate exists.
 - [x] Candidate selection cannot assign conflicting roles or choose an opted-out player, including during concurrent joins and deaths.
 
 ## Related
 
 - [Tyrant game state machine](../concepts/game-state-machine.md)
 - [Inform players and manage participation](us-011-inform-and-manage-participation.md)
+- [Claim the Vigilante role in the arena](us-019-claim-vigilante-in-arena.md)

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

@@ -15,6 +15,7 @@ As a **player**, I want to understand my status and control my eligibility so th
 - [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] Opted-in players are told the Vigilante arena world and coordinates when its role opens and when they join during an open challenge; opted-out players receive no such notice.
 - [x] An unassigned player can opt out through a command.
 - [x] Opting out removes an ordinary class or Follower assignment immediately; the Tyrant and Vigilante must relinquish through a safe role command before opting out.
 - [x] Opted-out players cannot be randomly selected, recruited, or assigned a class.
@@ -35,3 +36,4 @@ As a **player**, I want to understand my status and control my eligibility so th
 
 - [Handle inactivity and pending selections](us-010-handle-inactivity-and-selection.md)
 - [Persistence model](../concepts/persistence-model.md)
+- [Claim the Vigilante role in the arena](us-019-claim-vigilante-in-arena.md)

design/user-stories/us-012-configure-and-persist-state.md

@@ -11,10 +11,10 @@ As a **server operator**, I want configurable and durable game behavior so that
 
 ## Acceptance criteria
 
-- [x] Configuration covers ranges, durations, cooldowns, inactivity periods, candidate windows, retry intervals, effect levels and caps, mob restrictions, item materials and names, messages, and timer behavior.
+- [x] Configuration covers ranges, durations, cooldowns, inactivity periods, candidate windows, retry intervals, effect levels and caps, mob restrictions, item materials and names, messages, timer behavior, and Vigilante arena boss balance.
 - [x] Defaults match the approved user stories, including a 50-block Tyrant range and Follower range, seven-day opt-out, 48-hour inactivity, and 24-hour candidate windows.
 - [x] Invalid required configuration prevents partial plugin initialization and produces a clear server log message.
-- [x] UUID-keyed state stores lifecycle, current and pending roles, assignments, login history, participation, reign progression, purchases, choices, cooldowns, paused time, item delivery, and captured mobs.
+- [x] UUID-keyed state stores lifecycle, current and pending roles, assignments, login history, participation, reign progression, purchases, choices, cooldowns, paused time, item delivery, and captured mobs; the administrator-set arena center is durable across restarts.
 - [x] Cooldowns and deadlines use UTC instants and exclude administratively paused time.
 - [x] State is saved using atomic replacement where supported so failed writes do not replace valid state with partial data.
 - [x] Corrupt, unknown, or invalid records cannot silently grant progression, roles, powers, items, or duplicated mobs.
@@ -25,3 +25,4 @@ As a **server operator**, I want configurable and durable game behavior so that
 
 - [Persistence model](../concepts/persistence-model.md)
 - [Build, test, and release the plugin](us-013-build-test-and-release.md)
+- [Claim the Vigilante role in the arena](us-019-claim-vigilante-in-arena.md)

design/user-stories/us-015-manage-tyrant-control-panel.md

@@ -31,6 +31,7 @@ As the **Tyrant**, I want a control panel for my reign so that I can inspect pro
 - [x] Stale, repeated, or concurrent panel interactions cannot duplicate purchases, bypass cooldowns, or create conflicting assignments.
 - [x] Panel actions become unavailable immediately if the game pauses, the reign ends, or the player is no longer the Tyrant.
 - [x] Existing `/tyrant choices`, `/tyrant buy`, `/tyrant assign`, and `/tyrant intelligence` commands remain available as alternatives.
+- [x] The active Tyrant can open the control panel by using the bound Tyrant control item.
 
 ## Validation
 
@@ -42,3 +43,4 @@ Automated tests verify command entry points, active-Tyrant authorization, author
 - [Assign unlocked classes](us-004-assign-unlocked-classes.md)
 - [Purchase and use Tyrant abilities](us-009-use-tyrant-abilities.md)
 - [Inform players and manage participation](us-011-inform-and-manage-participation.md)
+- [Use bound role control items](us-017-use-bound-role-control-items.md)

design/user-stories/us-016-manage-vigilante-control-panel.md

@@ -0,0 +1,49 @@
+---
+type: User Story
+title: "US-016: Manage Followers through the Vigilante control panel"
+description: Give the active Vigilante a graphical control panel for reviewing and managing the resistance.
+status: done
+---
+
+# US-016: Manage Followers through the Vigilante control panel
+
+As the **Vigilante**, I want a control panel for managing Followers so that I can coordinate the resistance without memorizing commands.
+
+## Acceptance criteria
+
+- [x] The active Vigilante can open the control panel with `/vigilante menu`, and `/vigilante` with no arguments opens the same panel.
+- [x] A player who is not the active Vigilante cannot open or operate the control panel.
+- [x] The control panel opens automatically five seconds after the active Vigilante joins a running event.
+- [x] Automatic opening is cancelled if the player disconnects, loses the Vigilante role, or the event pauses or stops during the five-second delay.
+- [x] Pending Vigilante candidates and other players do not receive the automatically opened control panel.
+- [x] Manually opening the control panel during the delay prevents a duplicate automatic opening.
+- [x] Closing the automatically opened control panel does not cause it to reopen during the same login session.
+- [x] The overview shows current Followers, pending invitations, and the number of nearby Followers currently eligible to contribute combat effects.
+- [x] Each Follower's online, living, same-world, proximity, and participation status is communicated without exposing information unavailable to the Vigilante.
+- [x] The control panel shows the current Strength and Resistance contribution and configured caps.
+- [x] The Vigilante can navigate between overview, recruitment, Follower-management, and role-control screens.
+- [x] The recruitment screen lists eligible online players and explains why opted-out, Tyrant, Vigilante, or otherwise ineligible players cannot be invited.
+- [x] The Vigilante can invite an eligible player after confirmation.
+- [x] Pending outgoing invitations are identified and cannot be duplicated through repeated or concurrent interaction.
+- [x] Invited players receive the existing invitation notice and may continue using `/vigilante accept`.
+- [x] The Follower-management screen identifies current Followers and requires confirmation before dismissal.
+- [x] Successful invitations and dismissals refresh the control panel from authoritative current state and notify affected players.
+- [x] The role-control screen allows the Vigilante to relinquish the role only after explicit confirmation.
+- [x] Relinquishing through the control panel clears Followers, opens the Vigilante arena challenge, and communicates that outcome accurately.
+- [x] Every action revalidates the running lifecycle and active Vigilante before changing state.
+- [x] Stale or repeated control-panel interactions cannot invite an ineligible player, duplicate an invitation, or dismiss the wrong Follower.
+- [x] Existing `/vigilante invite`, `/vigilante accept`, `/vigilante dismiss`, `/vigilante leave`, and `/tyrant relinquish confirm` commands remain available.
+- [x] The active Vigilante can open the control panel by using the bound Vigilante control item.
+
+## Validation
+
+Automated tests verify default and explicit command entry points, active-Vigilante authorization, overview state, invitation deduplication and eligibility, the exact 100-tick login delay, lifecycle cancellation, and duplicate-opening prevention. The complete `./gradlew clean check jar` lifecycle passes.
+
+## Related
+
+- [Support the Vigilante and Followers](us-008-support-vigilante-and-followers.md)
+- [Handle inactivity and pending selections](us-010-handle-inactivity-and-selection.md)
+- [Manage a reign through the Tyrant control panel](us-015-manage-tyrant-control-panel.md)
+- [Role and class model](../concepts/role-and-class-model.md)
+- [Use bound role control items](us-017-use-bound-role-control-items.md)
+- [Claim the Vigilante role in the arena](us-019-claim-vigilante-in-arena.md)

design/user-stories/us-017-use-bound-role-control-items.md

@@ -0,0 +1,43 @@
+---
+type: User Story
+title: "US-017: Use bound role control items"
+description: Give the active Tyrant and Vigilante secure inventory items that open their control panels.
+status: done
+---
+
+# US-017: Use bound role control items
+
+As a **Tyrant or Vigilante**, I want a bound role item that opens my control panel so that I can access role controls without typing a command.
+
+## Acceptance criteria
+
+- [x] A player receives the appropriate control item when becoming the active Tyrant or Vigilante.
+- [x] The Tyrant control item opens the Tyrant control panel when used.
+- [x] The Vigilante control item opens the Vigilante control panel when used.
+- [x] The Tyrant control item defaults to a Nether Star named `Tyrant Control`.
+- [x] The Vigilante control item defaults to a Compass named `Vigilante Control`.
+- [x] Each item's material and name are configurable, and hidden metadata identifies its owner, associated role, and the plugin.
+- [x] Only the current role holder identified by the item's metadata can use the item.
+- [x] A former role holder or another player cannot use or retain the item.
+- [x] `/tyrant item` restores a missing Tyrant control item in addition to existing eligible class items.
+- [x] `/vigilante item` restores a missing Vigilante control item.
+- [x] Recovery commands cannot create duplicate control items.
+- [x] Using a recovery command while the inventory is full does not drop the item and explains how to retry.
+- [x] A role control item cannot be placed, crafted with, stored, framed, dispensed, transferred, or moved into another inventory.
+- [x] Dropping a role control item removes it immediately rather than creating a transferable dropped item.
+- [x] If a role control item leaves its owner's inventory during death or another inventory event, it is removed and may be recovered after respawn.
+- [x] A missing role control item is restored automatically on login or role assignment when inventory space is available.
+- [x] Every copy is removed immediately when the player loses the associated role.
+- [x] Repeated commands, role transitions, death, logout, restart, and concurrent inventory events cannot duplicate role control items.
+- [x] Existing `/tyrant`, `/tyrant menu`, `/vigilante`, and `/vigilante menu` control-panel access remains available.
+
+## Validation
+
+Automated tests verify role eligibility, paused-role retention, reconciliation and recovery, panel activation, role-specific commands, and configuration defaults. Inventory listeners cover transfer and departure paths, and the complete `./gradlew clean check jar` lifecycle passes.
+
+## Related
+
+- [Manage a reign through the Tyrant control panel](us-015-manage-tyrant-control-panel.md)
+- [Manage Followers through the Vigilante control panel](us-016-manage-vigilante-control-panel.md)
+- [Use class ability items](us-014-use-class-ability-items.md)
+- [Configure and persist game state](us-012-configure-and-persist-state.md)

design/user-stories/us-018-complete-commands-contextually.md

@@ -0,0 +1,41 @@
+---
+type: User Story
+title: "US-018: Complete Tyrant commands contextually"
+description: Replace Bukkit's player-name fallback with valid context-aware command suggestions.
+status: done
+---
+
+# US-018: Complete Tyrant commands contextually
+
+As a **player or administrator**, I want contextual command suggestions so that I can discover valid Tyrant commands and arguments.
+
+## Acceptance criteria
+
+- [x] `/tyrant` suggests its available subcommands instead of arbitrary player names.
+- [x] `/tyrant buy` suggests Tyrant unlock names.
+- [x] `/tyrant assign` suggests `assassin`, `fixer`, and `tamer`, followed by eligible online players.
+- [x] `/tyrant relinquish` suggests `confirm`.
+- [x] `/vigilante` suggests its available subcommands.
+- [x] `/vigilante invite` suggests eligible online recruitment candidates.
+- [x] `/vigilante dismiss` suggests current online Followers.
+- [x] `/tyrantadmin` suggestions are visible only to senders with `spigottyrant.admin`.
+- [x] `/tyrantadmin start` suggests online Tyrant and Vigilante candidates.
+- [x] `/tyrantadmin reset` suggests `confirm`.
+- [x] `/tyrantadmin arena` suggests `set` and `status`.
+- [x] Suggestions are filtered case-insensitively by the partially typed argument.
+- [x] Suggestions never include syntactically invalid options for the current argument position.
+- [x] Console completion works for administrative commands without exposing player-only commands as executable console actions.
+- [x] Existing command execution behavior remains unchanged.
+
+## Validation
+
+Automated tests verify root syntax, unlocks, classes, confirmations, eligible recruits, current Followers, permission gating, online administrative candidates, argument positions, and case-insensitive prefix filtering. The complete `./gradlew clean check jar` lifecycle passes.
+
+## Related
+
+- [Start, pause, and administer the game](us-001-start-pause-and-administer.md)
+- [Assign unlocked classes](us-004-assign-unlocked-classes.md)
+- [Support the Vigilante and Followers](us-008-support-vigilante-and-followers.md)
+- [Manage a reign through the Tyrant control panel](us-015-manage-tyrant-control-panel.md)
+- [Claim the Vigilante role in the arena](us-019-claim-vigilante-in-arena.md)
+- [Manage Followers through the Vigilante control panel](us-016-manage-vigilante-control-panel.md)

design/user-stories/us-019-claim-vigilante-in-arena.md

@@ -0,0 +1,35 @@
+---
+type: User Story
+title: "US-019: Claim the Vigilante role in the arena"
+description: Let one eligible player at a time defeat a protected arena boss to claim a vacant Vigilante role.
+status: done
+---
+
+# US-019: Claim the Vigilante role in the arena
+
+As an **opted-in participant**, I want a visible one-player boss challenge for a vacant Vigilante role so that succession is earned through an open contest.
+
+## Acceptance criteria
+
+- [x] An administrator can set and inspect a durable arena center, and configuration validates the arena radius and boss strength.
+- [x] The configured arena has a continuously visible particle boundary, including when no fight is active.
+- [x] A vacant Vigilante role opens the challenge after death, inactivity, relinquishment, or a new Tyrant reign, but a boss exists only while a Tyrant is active and the game is running.
+- [x] The challenge boss defaults to an armored, 80-health enhanced zombie, does not burn in sunlight, and remains within a default 10-block-radius arena.
+- [x] All online opted-in players are told when the role opens and receive the arena world and coordinates; opted-in players receive the same notice when they log in while it remains open, and opted-out players do not.
+- [x] Exactly one eligible opted-in non-Tyrant player may enter as challenger, including when entry is attempted by walking or teleportation.
+- [x] Starting a fight replaces the passive particle boundary with temporary actual `BARRIER` blocks that are removed safely without permanently changing existing blocks.
+- [x] Any non-challenger who enters or respawns inside the arena is moved safely outside it.
+- [x] Existing mobs in the arena and mobs that spawn or enter it are removed while preserving the arena boss.
+- [x] The boss attacks only the active challenger, and only that challenger can damage the boss.
+- [x] Challenger death, disconnect, or leaving by any mechanism ends the fight and resets the boss to full health at its spawn; death counts as leaving and the same player may retry immediately.
+- [x] Killing the boss assigns the challenger as Vigilante, removes the boss and barriers, and restores the passive particle boundary.
+- [x] Pausing, resetting, restarting, reloading, and repeated or concurrent events cannot duplicate the boss, barriers, challenger, or Vigilante assignment.
+- [x] If the arena is not configured when a challenge should open, the Vigilante remains vacant and administrators receive a clear warning.
+
+## Related
+
+- [Start, pause, and administer the game](us-001-start-pause-and-administer.md)
+- [Support the Vigilante and Followers](us-008-support-vigilante-and-followers.md)
+- [Handle inactivity and pending selections](us-010-handle-inactivity-and-selection.md)
+- [Configure and persist game state](us-012-configure-and-persist-state.md)
+- [Tyrant game state machine](../concepts/game-state-machine.md)

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

@@ -0,0 +1,45 @@
+package games.dmg.spigottyrant;
+
+public final class ArenaGeometry {
+    private ArenaGeometry() {
+    }
+
+    public static boolean contains(
+        ArenaLocation center,
+        double radius,
+        String worldName,
+        double x,
+        double y,
+        double z
+    ) {
+        if (!center.worldName().equals(worldName)) {
+            return false;
+        }
+        double deltaX = x - center.x();
+        double deltaZ = z - center.z();
+        return deltaX * deltaX + deltaZ * deltaZ <= radius * radius;
+    }
+
+    public static ArenaPoint outside(
+        ArenaLocation center,
+        double radius,
+        double x,
+        double y,
+        double z
+    ) {
+        double deltaX = x - center.x();
+        double deltaZ = z - center.z();
+        double length = Math.hypot(deltaX, deltaZ);
+        if (length < 0.0001) {
+            deltaX = 1.0;
+            deltaZ = 0.0;
+            length = 1.0;
+        }
+        double distance = radius + 1.0;
+        return new ArenaPoint(
+            center.x() + deltaX / length * distance,
+            y,
+            center.z() + deltaZ / length * distance
+        );
+    }
+}

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

@@ -0,0 +1,26 @@
+package games.dmg.spigottyrant;
+
+public record ArenaLocation(
+    String worldName,
+    double x,
+    double y,
+    double z,
+    float yaw,
+    float pitch
+) {
+    public ArenaLocation {
+        if (worldName == null || worldName.isBlank()) {
+            throw new IllegalArgumentException("arena world must not be blank");
+        }
+        worldName = worldName.trim();
+        if (!Double.isFinite(x) || !Double.isFinite(y) || !Double.isFinite(z)
+                || !Float.isFinite(yaw) || !Float.isFinite(pitch)) {
+            throw new IllegalArgumentException("arena coordinates must be finite");
+        }
+    }
+
+    public String display() {
+        return worldName + " at " + Math.round(x) + ", " + Math.round(y) + ", "
+            + Math.round(z);
+    }
+}

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

@@ -0,0 +1,23 @@
+package games.dmg.spigottyrant;
+
+import java.util.Optional;
+
+public interface ArenaLocationStore {
+    Optional<ArenaLocation> location();
+
+    void set(ArenaLocation location);
+
+    static ArenaLocationStore unavailable() {
+        return new ArenaLocationStore() {
+            @Override
+            public Optional<ArenaLocation> location() {
+                return Optional.empty();
+            }
+
+            @Override
+            public void set(ArenaLocation location) {
+                throw new IllegalStateException("arena location storage is unavailable");
+            }
+        };
+    }
+}

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

@@ -0,0 +1,4 @@
+package games.dmg.spigottyrant;
+
+public record ArenaPoint(double x, double y, double z) {
+}

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

@@ -0,0 +1,47 @@
+package games.dmg.spigottyrant;
+
+import org.bukkit.Location;
+import org.bukkit.Server;
+import org.bukkit.entity.EntitySnapshot;
+import org.bukkit.entity.Player;
+
+public final class BukkitCapturedMobSpawner implements CapturedMobSpawner {
+    private final Server server;
+    private final PluginSettings settings;
+
+    public BukkitCapturedMobSpawner(Server server, PluginSettings settings) {
+        this.server = server;
+        this.settings = settings;
+    }
+
+    @Override
+    public boolean spawn(Player player, CapturedMob mob) {
+        Location location = player.getLocation();
+        if (!safe(location)
+                || "ENDER_DRAGON".equals(mob.entityType())
+                || settings.deniedMobTypes().contains(mob.entityType())) {
+            return false;
+        }
+        String serialized = mob.data().get("snapshot");
+        if (serialized == null || serialized.isBlank()) {
+            return false;
+        }
+        try {
+            EntitySnapshot snapshot = server.getEntityFactory().createEntitySnapshot(serialized);
+            if (!snapshot.getEntityType().name().equals(mob.entityType())) {
+                return false;
+            }
+            snapshot.createEntity(location);
+            return true;
+        } catch (IllegalArgumentException | IllegalStateException exception) {
+            return false;
+        }
+    }
+
+    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/BukkitConfigArenaLocationStore.java

@@ -0,0 +1,55 @@
+package games.dmg.spigottyrant;
+
+import java.util.Optional;
+import org.bukkit.configuration.file.FileConfiguration;
+import org.bukkit.plugin.java.JavaPlugin;
+
+public final class BukkitConfigArenaLocationStore implements ArenaLocationStore {
+    private static final String PATH = "vigilante-arena-location";
+    private final JavaPlugin plugin;
+
+    public BukkitConfigArenaLocationStore(JavaPlugin plugin) {
+        this.plugin = plugin;
+    }
+
+    @Override
+    public Optional<ArenaLocation> location() {
+        FileConfiguration config = plugin.getConfig();
+        if (!config.isConfigurationSection(PATH)) {
+            return Optional.empty();
+        }
+        String world = config.getString(PATH + ".world");
+        if (world == null) {
+            throw new IllegalArgumentException(PATH + ".world must be configured");
+        }
+        return Optional.of(new ArenaLocation(
+            world,
+            finite(config, "x"),
+            finite(config, "y"),
+            finite(config, "z"),
+            (float) finite(config, "yaw"),
+            (float) finite(config, "pitch")
+        ));
+    }
+
+    @Override
+    public void set(ArenaLocation location) {
+        FileConfiguration config = plugin.getConfig();
+        config.set(PATH + ".world", location.worldName());
+        config.set(PATH + ".x", location.x());
+        config.set(PATH + ".y", location.y());
+        config.set(PATH + ".z", location.z());
+        config.set(PATH + ".yaw", location.yaw());
+        config.set(PATH + ".pitch", location.pitch());
+        plugin.saveConfig();
+    }
+
+    private double finite(FileConfiguration config, String key) {
+        String path = PATH + "." + key;
+        if (!config.isSet(path) || !(config.get(path) instanceof Number number)
+                || !Double.isFinite(number.doubleValue())) {
+            throw new IllegalArgumentException(path + " must be finite and numeric");
+        }
+        return number.doubleValue();
+    }
+}

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

@@ -0,0 +1,38 @@
+package games.dmg.spigottyrant;
+
+import java.util.HashMap;
+import java.util.Map;
+import java.util.UUID;
+import org.bukkit.Server;
+import org.bukkit.entity.Player;
+
+public final class BukkitFollowerPresenceProvider implements FollowerPresenceProvider {
+    private final Server server;
+    private final double rangeSquared;
+
+    public BukkitFollowerPresenceProvider(Server server, double rangeBlocks) {
+        this.server = server;
+        this.rangeSquared = rangeBlocks * rangeBlocks;
+    }
+
+    @Override
+    public Map<UUID, FollowerPresence> inspect(
+        Player vigilante,
+        Map<UUID, PlayerState> players
+    ) {
+        Map<UUID, FollowerPresence> result = new HashMap<>();
+        for (PlayerState state : players.values()) {
+            Player follower = server.getPlayer(state.playerId());
+            boolean online = follower != null && follower.isOnline();
+            boolean living = online && !follower.isDead();
+            boolean sameWorld = living && follower.getWorld().equals(vigilante.getWorld());
+            boolean withinRange = sameWorld && follower.getLocation()
+                .distanceSquared(vigilante.getLocation()) <= rangeSquared;
+            result.put(
+                state.playerId(),
+                new FollowerPresence(online, living, sameWorld, withinRange)
+            );
+        }
+        return Map.copyOf(result);
+    }
+}

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

@@ -0,0 +1,146 @@
+package games.dmg.spigottyrant;
+
+import java.util.Map;
+import java.util.Optional;
+import java.util.UUID;
+import org.bukkit.ChatColor;
+import org.bukkit.Material;
+import org.bukkit.NamespacedKey;
+import org.bukkit.entity.Player;
+import org.bukkit.inventory.ItemStack;
+import org.bukkit.inventory.meta.ItemMeta;
+import org.bukkit.persistence.PersistentDataType;
+import org.bukkit.plugin.Plugin;
+
+public final class BukkitRoleControlItemService implements RoleControlItemService {
+    private final NamespacedKey roleKey;
+    private final NamespacedKey ownerKey;
+    private final PluginSettings settings;
+
+    public BukkitRoleControlItemService(Plugin plugin, PluginSettings settings) {
+        roleKey = new NamespacedKey(plugin, "role-control");
+        ownerKey = new NamespacedKey(plugin, "role-control-owner");
+        this.settings = settings;
+    }
+
+    @Override
+    public void recover(Player player, GameState game) {
+        Optional<RoleControl> required = RoleControlItemPolicy.requiredRole(
+            game, player.getUniqueId()
+        );
+        if (required.isEmpty() || contains(player, required.orElseThrow())) {
+            return;
+        }
+        Map<Integer, ItemStack> leftovers = player.getInventory().addItem(
+            create(player.getUniqueId(), required.orElseThrow())
+        );
+        if (!leftovers.isEmpty()) {
+            String command = required.orElseThrow() == RoleControl.TYRANT
+                ? "/tyrant item" : "/vigilante item";
+            player.sendMessage(ChatColor.RED
+                + "Your inventory is full. Make room and use " + command + ".");
+        }
+    }
+
+    @Override
+    public boolean isBoundRoleControlItem(ItemStack item) {
+        return role(item).isPresent() && owner(item).isPresent();
+    }
+
+    @Override
+    public Optional<RoleControl> role(ItemStack item) {
+        String value = metadata(item, roleKey);
+        if (value == null) {
+            return Optional.empty();
+        }
+        try {
+            return Optional.of(RoleControl.valueOf(value));
+        } catch (IllegalArgumentException exception) {
+            return Optional.empty();
+        }
+    }
+
+    @Override
+    public Optional<UUID> owner(ItemStack item) {
+        String value = metadata(item, ownerKey);
+        if (value == null) {
+            return Optional.empty();
+        }
+        try {
+            return Optional.of(UUID.fromString(value));
+        } catch (IllegalArgumentException exception) {
+            return Optional.empty();
+        }
+    }
+
+    @Override
+    public void removeInvalid(Player player, GameState game) {
+        Optional<RoleControl> required = RoleControlItemPolicy.requiredRole(
+            game, player.getUniqueId()
+        );
+        boolean retained = false;
+        ItemStack[] contents = player.getInventory().getContents();
+        for (int index = 0; index < contents.length; index++) {
+            ItemStack item = contents[index];
+            if (!isBoundRoleControlItem(item)) {
+                continue;
+            }
+            boolean valid = !retained
+                && owner(item).filter(player.getUniqueId()::equals).isPresent()
+                && role(item).equals(required);
+            if (valid) {
+                retained = true;
+            } else {
+                player.getInventory().setItem(index, null);
+            }
+        }
+    }
+
+    @Override
+    public void removeAll(Player player) {
+        ItemStack[] contents = player.getInventory().getContents();
+        for (int index = 0; index < contents.length; index++) {
+            if (isBoundRoleControlItem(contents[index])) {
+                player.getInventory().setItem(index, null);
+            }
+        }
+    }
+
+    private ItemStack create(UUID ownerId, RoleControl role) {
+        PluginSettings.AbilityItemSettings configured = role == RoleControl.TYRANT
+            ? settings.tyrantControlItem() : settings.vigilanteControlItem();
+        Material material = Material.matchMaterial(configured.material());
+        if (material == null) {
+            throw new IllegalStateException("Configured role control material is unavailable");
+        }
+        ItemStack item = new ItemStack(material);
+        ItemMeta meta = item.getItemMeta();
+        meta.setDisplayName(ChatColor.GOLD + configured.name());
+        meta.getPersistentDataContainer().set(
+            roleKey, PersistentDataType.STRING, role.name()
+        );
+        meta.getPersistentDataContainer().set(
+            ownerKey, PersistentDataType.STRING, ownerId.toString()
+        );
+        item.setItemMeta(meta);
+        return item;
+    }
+
+    private boolean contains(Player player, RoleControl role) {
+        for (ItemStack item : player.getInventory().getContents()) {
+            if (owner(item).filter(player.getUniqueId()::equals).isPresent()
+                    && role(item).filter(role::equals).isPresent()) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    private static String metadata(ItemStack item, NamespacedKey key) {
+        if (item == null || !item.hasItemMeta()) {
+            return null;
+        }
+        return item.getItemMeta().getPersistentDataContainer()
+            .get(key, PersistentDataType.STRING);
+    }
+}

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

@@ -255,7 +255,9 @@ public final class BukkitTyrantControlPanelRenderer
             return;
         }
         try {
-            openAssignmentConfirmation(player, tyrantClass, UUID.fromString(lore.get(1)));
+            openAssignmentConfirmation(
+                player, tyrantClass, UUID.fromString(ChatColor.stripColor(lore.get(1)))
+            );
         } catch (IllegalArgumentException ignored) {
             player.sendMessage(ChatColor.RED + "That player selection is no longer valid.");
         }

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

@@ -0,0 +1,409 @@
+package games.dmg.spigottyrant;
+
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.UUID;
+import org.bukkit.ChatColor;
+import org.bukkit.Material;
+import org.bukkit.Server;
+import org.bukkit.entity.Player;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.Listener;
+import org.bukkit.event.inventory.InventoryClickEvent;
+import org.bukkit.inventory.Inventory;
+import org.bukkit.inventory.InventoryHolder;
+import org.bukkit.inventory.ItemStack;
+import org.bukkit.inventory.meta.ItemMeta;
+
+public final class BukkitVigilanteControlPanelRenderer
+        implements VigilanteControlPanelRenderer, Listener {
+    private static final String TITLE = ChatColor.DARK_BLUE + "Vigilante Control Panel";
+    private final Server server;
+    private final TyrantStateManager stateManager;
+    private final FollowerService followers;
+    private final FollowerPresenceProvider presenceProvider;
+    private final int strengthCap;
+    private final int resistanceCap;
+
+    public BukkitVigilanteControlPanelRenderer(
+        Server server,
+        TyrantStateManager stateManager,
+        FollowerService followers,
+        FollowerPresenceProvider presenceProvider,
+        int strengthCap,
+        int resistanceCap
+    ) {
+        this.server = server;
+        this.stateManager = stateManager;
+        this.followers = followers;
+        this.presenceProvider = presenceProvider;
+        this.strengthCap = strengthCap;
+        this.resistanceCap = resistanceCap;
+    }
+
+    @Override
+    public void openOverview(Player player, VigilanteControlPanelModel model) {
+        MenuHolder holder = new MenuHolder(MenuView.OVERVIEW, null);
+        Inventory inventory = create(holder, 27, TITLE);
+        inventory.setItem(10, item(Material.SHIELD, ChatColor.BLUE + "Resistance Overview",
+            List.of(
+                "Followers: " + model.followers().size(),
+                "Pending invitations: " + model.pendingInvitations().size(),
+                "Nearby contributors: " + model.nearbyEligibleFollowers(),
+                "Strength: " + model.strengthLevel() + "/" + model.strengthCap(),
+                "Resistance: " + model.resistanceLevel() + "/" + model.resistanceCap()
+            )));
+        inventory.setItem(12, item(Material.WRITABLE_BOOK, ChatColor.GREEN + "Recruitment",
+            List.of("Invite eligible online players.")));
+        inventory.setItem(14, item(Material.PLAYER_HEAD, ChatColor.AQUA + "Manage Followers",
+            followerSummary(model)));
+        inventory.setItem(16, item(Material.REDSTONE_TORCH, ChatColor.RED + "Role Control",
+            List.of("Relinquish the Vigilante role.")));
+        player.openInventory(inventory);
+    }
+
+    @EventHandler
+    public void onClick(InventoryClickEvent event) {
+        if (!(event.getWhoClicked() instanceof Player player)
+                || !(event.getView().getTopInventory().getHolder() instanceof MenuHolder holder)) {
+            return;
+        }
+        event.setCancelled(true);
+        if (event.getRawSlot() < 0
+                || event.getRawSlot() >= event.getView().getTopInventory().getSize()) {
+            return;
+        }
+        if (!isActiveVigilante(player)) {
+            player.closeInventory();
+            player.sendMessage(ChatColor.RED
+                + "This Vigilante control panel is no longer active.");
+            return;
+        }
+        switch (holder.view()) {
+            case OVERVIEW -> clickOverview(player, event.getRawSlot());
+            case RECRUITMENT -> clickRecruitment(player, event.getRawSlot());
+            case INVITE_CONFIRMATION -> clickInviteConfirmation(
+                player, event.getRawSlot(), holder.targetId()
+            );
+            case FOLLOWERS -> clickFollowers(player, event.getRawSlot());
+            case DISMISS_CONFIRMATION -> clickDismissConfirmation(
+                player, event.getRawSlot(), holder.targetId()
+            );
+            case ROLE -> clickRole(player, event.getRawSlot());
+            case RELINQUISH_CONFIRMATION -> clickRelinquishConfirmation(
+                player, event.getRawSlot()
+            );
+        }
+    }
+
+    private void clickOverview(Player player, int slot) {
+        if (slot == 12) {
+            openRecruitment(player);
+        } else if (slot == 14) {
+            openFollowers(player);
+        } else if (slot == 16) {
+            openRole(player);
+        }
+    }
+
+    private void openRecruitment(Player player) {
+        MenuHolder holder = new MenuHolder(MenuView.RECRUITMENT, null);
+        Inventory inventory = create(holder, 54, TITLE + " — Recruitment");
+        Set<UUID> pending = followers.invitedPlayerIds(player.getUniqueId());
+        int slot = 0;
+        for (Player candidate : server.getOnlinePlayers()) {
+            if (slot >= 45 || candidate.getUniqueId().equals(player.getUniqueId())) {
+                continue;
+            }
+            PlayerState state = stateManager.player(candidate.getUniqueId(), candidate.getName());
+            String eligibility = recruitmentEligibility(candidate.getUniqueId(), state, pending);
+            inventory.setItem(slot, playerItem(candidate.getName(), candidate.getUniqueId(),
+                eligibility));
+            slot++;
+        }
+        inventory.setItem(49, backItem());
+        player.openInventory(inventory);
+    }
+
+    private String recruitmentEligibility(
+        UUID candidateId,
+        PlayerState state,
+        Set<UUID> pending
+    ) {
+        GameState game = stateManager.game();
+        if (pending.contains(candidateId)) {
+            return ChatColor.YELLOW + "Pending invitation";
+        }
+        if (state.optedOutUntil().isPresent()) {
+            return ChatColor.RED + "Ineligible: opted out";
+        }
+        if (game.tyrantId().filter(candidateId::equals).isPresent()) {
+            return ChatColor.RED + "Ineligible: Tyrant";
+        }
+        if (game.vigilanteId().filter(candidateId::equals).isPresent()) {
+            return ChatColor.RED + "Ineligible: Vigilante";
+        }
+        if (state.followerOf().isPresent()) {
+            return ChatColor.RED + "Ineligible: already a Follower";
+        }
+        return ChatColor.GREEN + "Eligible";
+    }
+
+    private void clickRecruitment(Player player, int slot) {
+        if (slot == 49) {
+            refresh(player);
+            return;
+        }
+        selectedPlayer(player, slot, "Eligible")
+            .ifPresent(targetId -> openInviteConfirmation(player, targetId));
+    }
+
+    private void openInviteConfirmation(Player player, UUID targetId) {
+        Player target = server.getPlayer(targetId);
+        if (target == null) {
+            player.sendMessage(ChatColor.RED + "That player is no longer online.");
+            openRecruitment(player);
+            return;
+        }
+        MenuHolder holder = new MenuHolder(MenuView.INVITE_CONFIRMATION, targetId);
+        Inventory inventory = create(holder, 27, TITLE + " — Confirm Invitation");
+        inventory.setItem(11, cancelItem());
+        inventory.setItem(13, item(Material.WRITABLE_BOOK, ChatColor.YELLOW + target.getName(),
+            List.of("Invite this player to become a Follower?")));
+        inventory.setItem(15, confirmItem());
+        player.openInventory(inventory);
+    }
+
+    private void clickInviteConfirmation(Player player, int slot, UUID targetId) {
+        if (slot == 11) {
+            openRecruitment(player);
+        } else if (slot == 15 && targetId != null) {
+            Player target = server.getPlayer(targetId);
+            if (target == null) {
+                player.sendMessage(ChatColor.RED + "That player is no longer online.");
+            } else {
+                player.performCommand("vigilante invite " + target.getName());
+            }
+            openRecruitment(player);
+        }
+    }
+
+    private void openFollowers(Player player) {
+        VigilanteControlPanelModel model = model(player);
+        MenuHolder holder = new MenuHolder(MenuView.FOLLOWERS, null);
+        Inventory inventory = create(holder, 54, TITLE + " — Followers");
+        int slot = 0;
+        for (VigilanteFollowerView follower : model.followers()) {
+            if (slot >= 45) {
+                break;
+            }
+            FollowerPresence presence = follower.presence();
+            List<String> status = List.of(
+                presence.online() ? "Online" : "Offline",
+                presence.living() ? "Living" : "Dead or unavailable",
+                presence.sameWorld() ? "Same world" : "Different world or unavailable",
+                presence.withinRange() ? "Within range" : "Outside range or unavailable",
+                follower.optedOut() ? "Opted out" : "Participating",
+                presence.online() ? ChatColor.GREEN + "Click to dismiss."
+                    : ChatColor.RED + "Must be online to dismiss."
+            );
+            inventory.setItem(slot, playerItem(
+                follower.name(), follower.playerId(), status.toString()
+            ));
+            slot++;
+        }
+        inventory.setItem(49, backItem());
+        player.openInventory(inventory);
+    }
+
+    private void clickFollowers(Player player, int slot) {
+        if (slot == 49) {
+            refresh(player);
+            return;
+        }
+        selectedPlayer(player, slot, "Online")
+            .filter(targetId -> server.getPlayer(targetId) != null)
+            .ifPresent(targetId -> openDismissConfirmation(player, targetId));
+    }
+
+    private void openDismissConfirmation(Player player, UUID targetId) {
+        Player target = server.getPlayer(targetId);
+        if (target == null) {
+            player.sendMessage(ChatColor.RED + "That Follower is no longer online.");
+            openFollowers(player);
+            return;
+        }
+        MenuHolder holder = new MenuHolder(MenuView.DISMISS_CONFIRMATION, targetId);
+        Inventory inventory = create(holder, 27, TITLE + " — Confirm Dismissal");
+        inventory.setItem(11, cancelItem());
+        inventory.setItem(13, item(Material.PLAYER_HEAD, ChatColor.YELLOW + target.getName(),
+            List.of("Dismiss this Follower?")));
+        inventory.setItem(15, confirmItem());
+        player.openInventory(inventory);
+    }
+
+    private void clickDismissConfirmation(Player player, int slot, UUID targetId) {
+        if (slot == 11) {
+            openFollowers(player);
+        } else if (slot == 15 && targetId != null) {
+            Player target = server.getPlayer(targetId);
+            if (target == null) {
+                player.sendMessage(ChatColor.RED + "That Follower is no longer online.");
+            } else {
+                player.performCommand("vigilante dismiss " + target.getName());
+            }
+            openFollowers(player);
+        }
+    }
+
+    private void openRole(Player player) {
+        MenuHolder holder = new MenuHolder(MenuView.ROLE, null);
+        Inventory inventory = create(holder, 27, TITLE + " — Role Control");
+        inventory.setItem(13, item(Material.REDSTONE_TORCH,
+            ChatColor.RED + "Relinquish Vigilante Role",
+            List.of("Followers will be cleared and the arena will open.",
+                "Click to review confirmation.")));
+        inventory.setItem(22, backItem());
+        player.openInventory(inventory);
+    }
+
+    private void clickRole(Player player, int slot) {
+        if (slot == 22) {
+            refresh(player);
+        } else if (slot == 13) {
+            MenuHolder holder = new MenuHolder(MenuView.RELINQUISH_CONFIRMATION, null);
+            Inventory inventory = create(holder, 27, TITLE + " — Confirm Relinquishment");
+            inventory.setItem(11, cancelItem());
+            inventory.setItem(13, item(Material.BARRIER, ChatColor.RED + "Relinquish Role",
+                List.of("This clears all Followers and opens the arena challenge.")));
+            inventory.setItem(15, confirmItem());
+            player.openInventory(inventory);
+        }
+    }
+
+    private void clickRelinquishConfirmation(Player player, int slot) {
+        if (slot == 11) {
+            openRole(player);
+        } else if (slot == 15) {
+            player.closeInventory();
+            player.performCommand("tyrant relinquish confirm");
+        }
+    }
+
+    private java.util.Optional<UUID> selectedPlayer(
+        Player player,
+        int slot,
+        String requiredStatus
+    ) {
+        ItemStack clicked = player.getOpenInventory().getTopInventory().getItem(slot);
+        if (clicked == null || clicked.getType() != Material.PLAYER_HEAD) {
+            return java.util.Optional.empty();
+        }
+        List<String> lore = clicked.getItemMeta().getLore();
+        if (lore == null || lore.size() < 2
+                || !ChatColor.stripColor(lore.get(0)).contains(requiredStatus)) {
+            return java.util.Optional.empty();
+        }
+        try {
+            return java.util.Optional.of(UUID.fromString(
+                ChatColor.stripColor(lore.get(lore.size() - 1))
+            ));
+        } catch (IllegalArgumentException ignored) {
+            player.sendMessage(ChatColor.RED + "That player selection is no longer valid.");
+            return java.util.Optional.empty();
+        }
+    }
+
+    private boolean isActiveVigilante(Player player) {
+        GameState game = stateManager.game();
+        return game.lifecycle() == GameLifecycle.RUNNING
+            && game.vigilanteId().filter(player.getUniqueId()::equals).isPresent();
+    }
+
+    private VigilanteControlPanelModel model(Player player) {
+        Map<UUID, PlayerState> players = stateManager.players();
+        return VigilanteControlPanelModel.create(
+            stateManager.game(), players, followers.invitedPlayerIds(player.getUniqueId()),
+            presenceProvider.inspect(player, players), strengthCap, resistanceCap
+        );
+    }
+
+    private void refresh(Player player) {
+        openOverview(player, model(player));
+    }
+
+    private Inventory create(MenuHolder holder, int size, String title) {
+        Inventory inventory = server.createInventory(holder, size, title);
+        holder.inventory = inventory;
+        return inventory;
+    }
+
+    private static ItemStack playerItem(String name, UUID playerId, String status) {
+        return item(Material.PLAYER_HEAD, name, List.of(status, playerId.toString()));
+    }
+
+    private static ItemStack item(Material material, String name, List<String> lore) {
+        ItemStack item = new ItemStack(material);
+        ItemMeta meta = item.getItemMeta();
+        meta.setDisplayName(name);
+        meta.setLore(lore.stream().map(line -> ChatColor.GRAY + line).toList());
+        item.setItemMeta(meta);
+        return item;
+    }
+
+    private static ItemStack backItem() {
+        return item(Material.ARROW, ChatColor.YELLOW + "Back", List.of());
+    }
+
+    private static ItemStack cancelItem() {
+        return item(Material.RED_WOOL, ChatColor.RED + "Cancel", List.of());
+    }
+
+    private static ItemStack confirmItem() {
+        return item(Material.LIME_WOOL, ChatColor.GREEN + "Confirm", List.of());
+    }
+
+    private static List<String> followerSummary(VigilanteControlPanelModel model) {
+        if (model.followers().isEmpty()) {
+            return List.of("No Followers assigned.");
+        }
+        return model.followers().stream()
+            .map(follower -> follower.name() + (follower.contributes() ? " — contributing" : ""))
+            .toList();
+    }
+
+    private enum MenuView {
+        OVERVIEW,
+        RECRUITMENT,
+        INVITE_CONFIRMATION,
+        FOLLOWERS,
+        DISMISS_CONFIRMATION,
+        ROLE,
+        RELINQUISH_CONFIRMATION
+    }
+
+    private static final class MenuHolder implements InventoryHolder {
+        private final MenuView view;
+        private final UUID targetId;
+        private Inventory inventory;
+
+        private MenuHolder(MenuView view, UUID targetId) {
+            this.view = view;
+            this.targetId = targetId;
+        }
+
+        private MenuView view() {
+            return view;
+        }
+
+        private UUID targetId() {
+            return targetId;
+        }
+
+        @Override
+        public Inventory getInventory() {
+            return inventory;
+        }
+    }
+}

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

@@ -0,0 +1,9 @@
+package games.dmg.spigottyrant;
+
+import org.bukkit.entity.Player;
+
+public interface CapturedMobCustodyRelease {
+    PlayerState releaseAll(Player player, PlayerState state);
+
+    PlayerState releaseExcess(Player player, PlayerState state, int custodyLimit);
+}

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

@@ -16,6 +16,11 @@ public final class CapturedMobService {
         if (player.tyrantClass() != TyrantClass.TAMER) {
             throw new IllegalStateException("only a Tamer can capture mobs");
         }
+        if (!player.capturedMobs().isEmpty()) {
+            throw new IllegalStateException(
+                "release the currently captured mob before capturing another"
+            );
+        }
         if ("ENDER_DRAGON".equalsIgnoreCase(entityType)) {
             throw new IllegalArgumentException("Ender Dragons cannot be captured");
         }

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

@@ -0,0 +1,8 @@
+package games.dmg.spigottyrant;
+
+import org.bukkit.entity.Player;
+
+@FunctionalInterface
+public interface CapturedMobSpawner {
+    boolean spawn(Player player, CapturedMob mob);
+}

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

@@ -0,0 +1,45 @@
+package games.dmg.spigottyrant;
+
+import java.util.ArrayList;
+import java.util.List;
+import org.bukkit.entity.Player;
+
+public final class DefaultCapturedMobCustodyRelease implements CapturedMobCustodyRelease {
+    private final CapturedMobSpawner spawner;
+
+    public DefaultCapturedMobCustodyRelease(CapturedMobSpawner spawner) {
+        this.spawner = spawner;
+    }
+
+    @Override
+    public PlayerState releaseAll(Player player, PlayerState state) {
+        return releaseExcess(player, state, 0);
+    }
+
+    @Override
+    public PlayerState releaseExcess(
+        Player player,
+        PlayerState state,
+        int custodyLimit
+    ) {
+        if (custodyLimit < 0) {
+            throw new IllegalArgumentException("custodyLimit must not be negative");
+        }
+        List<CapturedMob> retained = new ArrayList<>();
+        List<CapturedMob> custody = state.capturedMobs();
+        for (int index = 0; index < custody.size(); index++) {
+            CapturedMob mob = custody.get(index);
+            if (index < custodyLimit || !spawner.spawn(player, mob)) {
+                retained.add(mob);
+            }
+        }
+        if (retained.equals(custody)) {
+            return state;
+        }
+        return new PlayerState(
+            state.playerId(), state.latestName(), state.lastLogin(), state.optedOutUntil(),
+            state.tyrantClass(), state.followerOf(), state.cooldownEnds(),
+            state.readyAbilityItems(), retained
+        );
+    }
+}

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

@@ -0,0 +1,73 @@
+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;
+
+public final class DefaultVigilanteControlPanel implements VigilanteControlPanel {
+    private final TyrantStateManager stateManager;
+    private final FollowerService followers;
+    private final VigilanteControlPanelRenderer renderer;
+    private final FollowerPresenceProvider presenceProvider;
+    private final int strengthCap;
+    private final int resistanceCap;
+    private final Set<UUID> openedSessions = new HashSet<>();
+
+    public DefaultVigilanteControlPanel(
+        TyrantStateManager stateManager,
+        FollowerService followers,
+        VigilanteControlPanelRenderer renderer,
+        FollowerPresenceProvider presenceProvider,
+        int strengthCap,
+        int resistanceCap
+    ) {
+        this.stateManager = stateManager;
+        this.followers = followers;
+        this.renderer = renderer;
+        this.presenceProvider = presenceProvider;
+        this.strengthCap = strengthCap;
+        this.resistanceCap = resistanceCap;
+    }
+
+    @Override
+    public void open(Player player) {
+        GameState game = stateManager.game();
+        if (game.lifecycle() != GameLifecycle.RUNNING
+                || game.vigilanteId().filter(player.getUniqueId()::equals).isEmpty()) {
+            player.sendMessage(ChatColor.RED
+                + "Only the active Vigilante can open the control panel while the event is running.");
+            return;
+        }
+        Map<UUID, PlayerState> players = stateManager.players();
+        renderer.openOverview(
+            player,
+            VigilanteControlPanelModel.create(
+                game,
+                players,
+                followers.invitedPlayerIds(player.getUniqueId()),
+                presenceProvider.inspect(player, players),
+                strengthCap,
+                resistanceCap
+            )
+        );
+        openedSessions.add(player.getUniqueId());
+    }
+
+    @Override
+    public void beginSession(UUID playerId) {
+        openedSessions.remove(playerId);
+    }
+
+    @Override
+    public void endSession(UUID playerId) {
+        openedSessions.remove(playerId);
+    }
+
+    @Override
+    public boolean openedThisSession(UUID playerId) {
+        return openedSessions.contains(playerId);
+    }
+}

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

@@ -0,0 +1,12 @@
+package games.dmg.spigottyrant;
+
+public record FollowerPresence(
+    boolean online,
+    boolean living,
+    boolean sameWorld,
+    boolean withinRange
+) {
+    public boolean contributes() {
+        return online && living && sameWorld && withinRange;
+    }
+}

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

@@ -0,0 +1,10 @@
+package games.dmg.spigottyrant;
+
+import java.util.Map;
+import java.util.UUID;
+import org.bukkit.entity.Player;
+
+@FunctionalInterface
+public interface FollowerPresenceProvider {
+    Map<UUID, FollowerPresence> inspect(Player vigilante, Map<UUID, PlayerState> players);
+}

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

@@ -22,10 +22,14 @@ public final class FollowerService {
         }
         PlayerState target = players.get(targetId);
         if (target == null || target.optedOutUntil().isPresent()
+                || target.followerOf().isPresent()
                 || game.tyrantId().filter(targetId::equals).isPresent()
                 || game.vigilanteId().filter(targetId::equals).isPresent()) {
             return result(players, FollowerStatus.INELIGIBLE);
         }
+        if (vigilanteId.equals(invitations.get(targetId))) {
+            return result(players, FollowerStatus.ALREADY_INVITED);
+        }
         invitations.put(targetId, vigilanteId);
         return result(players, FollowerStatus.INVITED);
     }
@@ -77,6 +81,13 @@ public final class FollowerService {
         return updated(players, withFollower(target, Optional.empty()), FollowerStatus.LEFT);
     }
 
+    public java.util.Set<UUID> invitedPlayerIds(UUID vigilanteId) {
+        return invitations.entrySet().stream()
+            .filter(entry -> entry.getValue().equals(vigilanteId))
+            .map(Map.Entry::getKey)
+            .collect(java.util.stream.Collectors.toUnmodifiableSet());
+    }
+
     public void clearInvitations() {
         invitations.clear();
     }

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

@@ -2,6 +2,7 @@ package games.dmg.spigottyrant;
 
 public enum FollowerStatus {
     INVITED,
+    ALREADY_INVITED,
     JOINED,
     DISMISSED,
     LEFT,

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

@@ -0,0 +1,64 @@
+package games.dmg.spigottyrant;
+
+import java.util.Map;
+import java.util.UUID;
+import java.util.stream.Collectors;
+import org.bukkit.Server;
+import org.bukkit.entity.Player;
+
+public final class FormerTamerReleaseTask implements Runnable {
+    private final TyrantStateManager stateManager;
+    private final Server server;
+    private final CapturedMobCustodyRelease release;
+    private final CapturedMobInventoryService inventory;
+
+    public FormerTamerReleaseTask(
+        TyrantStateManager stateManager,
+        Server server,
+        CapturedMobCustodyRelease release
+    ) {
+        this(stateManager, server, release, null);
+    }
+
+    public FormerTamerReleaseTask(
+        TyrantStateManager stateManager,
+        Server server,
+        CapturedMobCustodyRelease release,
+        CapturedMobInventoryService inventory
+    ) {
+        this.stateManager = stateManager;
+        this.server = server;
+        this.release = release;
+        this.inventory = inventory;
+    }
+
+    @Override
+    public void run() {
+        Map<UUID, Player> online = server.getOnlinePlayers().stream()
+            .collect(Collectors.toMap(Player::getUniqueId, player -> player));
+        for (PlayerState state : stateManager.players().values()) {
+            if (state.capturedMobs().isEmpty()
+                    || state.tyrantClass() == TyrantClass.TAMER
+                        && state.capturedMobs().size() == 1) {
+                continue;
+            }
+            Player player = online.get(state.playerId());
+            if (player == null || player.isDead()) {
+                continue;
+            }
+            PlayerState released = state.tyrantClass() == TyrantClass.TAMER
+                ? release.releaseExcess(player, state, 1)
+                : release.releaseAll(player, state);
+            if (released.equals(state)) {
+                continue;
+            }
+            stateManager.updatePlayer(
+                state.playerId(), state.latestName(), current -> released
+            );
+            stateManager.saveIfDirty();
+            if (inventory != null) {
+                inventory.reconcile(player, released);
+            }
+        }
+    }
+}

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

@@ -12,6 +12,10 @@ import org.bukkit.configuration.ConfigurationSection;
 public record PluginSettings(
     double tyrantRangeBlocks,
     double followerRangeBlocks,
+    double vigilanteArenaRadiusBlocks,
+    double vigilanteBossHealth,
+    double vigilanteBossDamage,
+    double vigilanteBossArmor,
     Duration optOutDuration,
     Duration roleInactivity,
     Duration candidateActivityWindow,
@@ -39,6 +43,8 @@ public record PluginSettings(
     AbilityItemSettings fixerItem,
     AbilityItemSettings tamerItem,
     AbilityItemSettings capturedMobItem,
+    AbilityItemSettings tyrantControlItem,
+    AbilityItemSettings vigilanteControlItem,
     String recoveryCommand,
     String inventoryFullMessage,
     boolean freezeTimersWhilePaused
@@ -46,6 +52,12 @@ public record PluginSettings(
     public PluginSettings {
         requirePositiveFinite(tyrantRangeBlocks, "tyrant-range-blocks");
         requirePositiveFinite(followerRangeBlocks, "follower-range-blocks");
+        requireFiniteRange(
+            vigilanteArenaRadiusBlocks, 1.0, 512.0, "vigilante-arena-radius-blocks"
+        );
+        requireFiniteRange(vigilanteBossHealth, 1.0, 1024.0, "vigilante-boss-health");
+        requireFiniteRange(vigilanteBossDamage, 0.1, 2048.0, "vigilante-boss-damage");
+        requireFiniteRange(vigilanteBossArmor, 0.0, 30.0, "vigilante-boss-armor");
         requirePositive(optOutDuration, "opt-out-seconds");
         requirePositive(roleInactivity, "role-inactivity-seconds");
         requirePositive(candidateActivityWindow, "candidate-activity-window-seconds");
@@ -78,6 +90,10 @@ public record PluginSettings(
         fixerItem = Objects.requireNonNull(fixerItem, "fixerItem");
         tamerItem = Objects.requireNonNull(tamerItem, "tamerItem");
         capturedMobItem = Objects.requireNonNull(capturedMobItem, "capturedMobItem");
+        tyrantControlItem = Objects.requireNonNull(tyrantControlItem, "tyrantControlItem");
+        vigilanteControlItem = Objects.requireNonNull(
+            vigilanteControlItem, "vigilanteControlItem"
+        );
         recoveryCommand = requireText(recoveryCommand, "recovery-command");
         inventoryFullMessage = requireText(inventoryFullMessage, "inventory-full-message");
     }
@@ -87,6 +103,10 @@ public record PluginSettings(
         return new PluginSettings(
             decimal(values, "tyrant-range-blocks", 50.0),
             decimal(values, "follower-range-blocks", 50.0),
+            decimal(values, "vigilante-arena-radius-blocks", 10.0),
+            decimal(values, "vigilante-boss-health", 80.0),
+            decimal(values, "vigilante-boss-damage", 8.0),
+            decimal(values, "vigilante-boss-armor", 10.0),
             duration(values, "opt-out-seconds", Duration.ofDays(7)),
             duration(values, "role-inactivity-seconds", Duration.ofHours(48)),
             duration(values, "candidate-activity-window-seconds", Duration.ofHours(24)),
@@ -114,6 +134,14 @@ public record PluginSettings(
             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")),
+            item(
+                values, "tyrant-control-item",
+                new AbilityItemSettings("NETHER_STAR", "Tyrant Control")
+            ),
+            item(
+                values, "vigilante-control-item",
+                new AbilityItemSettings("COMPASS", "Vigilante Control")
+            ),
             string(values, "recovery-command", "/tyrant item"),
             string(
                 values,
@@ -213,6 +241,19 @@ public record PluginSettings(
         }
     }
 
+    private static void requireFiniteRange(
+        double value,
+        double minimum,
+        double maximum,
+        String key
+    ) {
+        if (!Double.isFinite(value) || value < minimum || value > maximum) {
+            throw new IllegalArgumentException(
+                key + " must be between " + minimum + " and " + maximum
+            );
+        }
+    }
+
     private static void requirePositive(Duration value, String key) {
         Objects.requireNonNull(value, key);
         if (value.isZero() || value.isNegative()) {

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

@@ -12,6 +12,8 @@ public final class PluginSettingsValidator {
         validateItem(settings.fixerItem(), "fixer-item");
         validateItem(settings.tamerItem(), "tamer-item");
         validateItem(settings.capturedMobItem(), "captured-mob-item");
+        validateItem(settings.tyrantControlItem(), "tyrant-control-item");
+        validateItem(settings.vigilanteControlItem(), "vigilante-control-item");
         for (String entityType : settings.deniedMobTypes()) {
             try {
                 EntityType.valueOf(entityType);

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

@@ -0,0 +1,6 @@
+package games.dmg.spigottyrant;
+
+public enum RoleControl {
+    TYRANT,
+    VIGILANTE
+}

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

@@ -0,0 +1,146 @@
+package games.dmg.spigottyrant;
+
+import org.bukkit.entity.ItemFrame;
+import org.bukkit.entity.Player;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.Listener;
+import org.bukkit.event.block.Action;
+import org.bukkit.event.block.BlockDispenseEvent;
+import org.bukkit.event.block.BlockPlaceEvent;
+import org.bukkit.event.entity.EntityPickupItemEvent;
+import org.bukkit.event.entity.PlayerDeathEvent;
+import org.bukkit.event.inventory.InventoryClickEvent;
+import org.bukkit.event.inventory.InventoryDragEvent;
+import org.bukkit.event.inventory.InventoryMoveItemEvent;
+import org.bukkit.event.player.PlayerDropItemEvent;
+import org.bukkit.event.player.PlayerInteractEntityEvent;
+import org.bukkit.event.player.PlayerInteractEvent;
+import org.bukkit.event.player.PlayerJoinEvent;
+import org.bukkit.inventory.ItemStack;
+
+public final class RoleControlItemListener implements Listener {
+    private final TyrantStateManager stateManager;
+    private final RoleControlItemService items;
+    private final TyrantControlPanel tyrantPanel;
+    private final VigilanteControlPanel vigilantePanel;
+
+    public RoleControlItemListener(
+        TyrantStateManager stateManager,
+        RoleControlItemService items,
+        TyrantControlPanel tyrantPanel,
+        VigilanteControlPanel vigilantePanel
+    ) {
+        this.stateManager = stateManager;
+        this.items = items;
+        this.tyrantPanel = tyrantPanel;
+        this.vigilantePanel = vigilantePanel;
+    }
+
+    @EventHandler
+    public void onInteract(PlayerInteractEvent event) {
+        ItemStack item = event.getItem();
+        if (!items.isBoundRoleControlItem(item)
+                || event.getAction() != Action.RIGHT_CLICK_AIR
+                    && event.getAction() != Action.RIGHT_CLICK_BLOCK) {
+            return;
+        }
+        event.setCancelled(true);
+        Player player = event.getPlayer();
+        GameState game = stateManager.game();
+        java.util.Optional<RoleControl> required = RoleControlItemPolicy.requiredRole(
+            game, player.getUniqueId()
+        );
+        boolean valid = items.owner(item).filter(player.getUniqueId()::equals).isPresent()
+            && items.role(item).equals(required)
+            && game.lifecycle() == GameLifecycle.RUNNING;
+        if (!valid) {
+            items.removeInvalid(player, game);
+            player.sendMessage(org.bukkit.ChatColor.RED
+                + "That role control item is no longer valid.");
+            return;
+        }
+        if (required.orElseThrow() == RoleControl.TYRANT) {
+            tyrantPanel.open(player);
+        } else {
+            vigilantePanel.open(player);
+        }
+    }
+
+    @EventHandler
+    public void onJoin(PlayerJoinEvent event) {
+        items.removeInvalid(event.getPlayer(), stateManager.game());
+        items.recover(event.getPlayer(), stateManager.game());
+    }
+
+    @EventHandler
+    public void onDrop(PlayerDropItemEvent event) {
+        if (items.isBoundRoleControlItem(event.getItemDrop().getItemStack())) {
+            event.getItemDrop().remove();
+        }
+    }
+
+    @EventHandler
+    public void onPickup(EntityPickupItemEvent event) {
+        if (items.isBoundRoleControlItem(event.getItem().getItemStack())) {
+            event.setCancelled(true);
+            event.getItem().remove();
+        }
+    }
+
+    @EventHandler
+    public void onInventoryClick(InventoryClickEvent event) {
+        if (items.isBoundRoleControlItem(event.getCurrentItem())
+                || items.isBoundRoleControlItem(event.getCursor())) {
+            if (!(event.getWhoClicked() instanceof Player player)
+                    || event.isShiftClick()
+                    || event.getClickedInventory() == null
+                    || !event.getClickedInventory().equals(player.getInventory())) {
+                event.setCancelled(true);
+            }
+        }
+    }
+
+    @EventHandler
+    public void onInventoryDrag(InventoryDragEvent event) {
+        if (items.isBoundRoleControlItem(event.getOldCursor())
+                || event.getNewItems().values().stream()
+                    .anyMatch(items::isBoundRoleControlItem)) {
+            event.setCancelled(true);
+        }
+    }
+
+    @EventHandler
+    public void onInventoryMove(InventoryMoveItemEvent event) {
+        if (items.isBoundRoleControlItem(event.getItem())) {
+            event.setCancelled(true);
+        }
+    }
+
+    @EventHandler
+    public void onPlace(BlockPlaceEvent event) {
+        if (items.isBoundRoleControlItem(event.getItemInHand())) {
+            event.setCancelled(true);
+        }
+    }
+
+    @EventHandler
+    public void onDispense(BlockDispenseEvent event) {
+        if (items.isBoundRoleControlItem(event.getItem())) {
+            event.setCancelled(true);
+        }
+    }
+
+    @EventHandler
+    public void onFrame(PlayerInteractEntityEvent event) {
+        if (event.getRightClicked() instanceof ItemFrame
+                && items.isBoundRoleControlItem(event.getPlayer().getInventory()
+                    .getItem(event.getHand()))) {
+            event.setCancelled(true);
+        }
+    }
+
+    @EventHandler
+    public void onDeath(PlayerDeathEvent event) {
+        event.getDrops().removeIf(items::isBoundRoleControlItem);
+    }
+}

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

@@ -0,0 +1,19 @@
+package games.dmg.spigottyrant;
+
+import java.util.Optional;
+import java.util.UUID;
+
+public final class RoleControlItemPolicy {
+    private RoleControlItemPolicy() {
+    }
+
+    public static Optional<RoleControl> requiredRole(GameState game, UUID playerId) {
+        if (game.tyrantId().filter(playerId::equals).isPresent()) {
+            return Optional.of(RoleControl.TYRANT);
+        }
+        if (game.vigilanteId().filter(playerId::equals).isPresent()) {
+            return Optional.of(RoleControl.VIGILANTE);
+        }
+        return Optional.empty();
+    }
+}

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

@@ -0,0 +1,31 @@
+package games.dmg.spigottyrant;
+
+import org.bukkit.Server;
+import org.bukkit.entity.Player;
+
+public final class RoleControlItemRefreshTask implements Runnable {
+    private final TyrantStateManager stateManager;
+    private final RoleControlItemService items;
+    private final Server server;
+
+    public RoleControlItemRefreshTask(
+        TyrantStateManager stateManager,
+        RoleControlItemService items,
+        Server server
+    ) {
+        this.stateManager = stateManager;
+        this.items = items;
+        this.server = server;
+    }
+
+    @Override
+    public void run() {
+        GameState game = stateManager.game();
+        for (Player player : server.getOnlinePlayers()) {
+            items.removeInvalid(player, game);
+            if (!player.isDead()) {
+                items.recover(player, game);
+            }
+        }
+    }
+}

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

@@ -0,0 +1,20 @@
+package games.dmg.spigottyrant;
+
+import java.util.Optional;
+import java.util.UUID;
+import org.bukkit.entity.Player;
+import org.bukkit.inventory.ItemStack;
+
+public interface RoleControlItemService {
+    void recover(Player player, GameState game);
+
+    boolean isBoundRoleControlItem(ItemStack item);
+
+    Optional<RoleControl> role(ItemStack item);
+
+    Optional<UUID> owner(ItemStack item);
+
+    void removeInvalid(Player player, GameState game);
+
+    void removeAll(Player player);
+}

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

@@ -53,17 +53,9 @@ public final class RoleMaintenanceService {
             );
         }
         current = rerollExpiredTyrant(current, onlinePlayerIds, now);
-        current = rerollExpiredVigilante(current, onlinePlayerIds, now);
         if (current.game().tyrantId().isEmpty() && current.game().pendingTyrant().isEmpty()) {
             current = selectTyrant(current, Optional.empty(), onlinePlayerIds, now);
         }
-        if (current.game().tyrantId().isPresent()
-                && current.game().vigilanteId().isEmpty()
-                && current.game().pendingVigilante().isEmpty()) {
-            current = rerollVigilante(
-                current.asPersistentState(), Optional.empty(), onlinePlayerIds, now
-            );
-        }
         return current;
     }
 
@@ -74,17 +66,9 @@ public final class RoleMaintenanceService {
         Instant now
     ) {
         Map<UUID, PlayerState> players = clearFollowers(state.players(), previousVigilante);
-        Set<UUID> excluded = state.game().tyrantId().map(Set::of).orElseGet(Set::of);
-        Optional<UUID> selected = candidates.select(
-            players, excluded, previousVigilante, now, activityWindow, random
-        );
-        Optional<UUID> active = selected.filter(onlinePlayerIds::contains);
-        Optional<PendingSelection> pending = selected
-            .filter(playerId -> active.isEmpty())
-            .map(playerId -> new PendingSelection(playerId, now.plus(pendingTimeout)));
         GameState game = copyRoles(
-            state.game(), state.game().tyrantId(), active,
-            state.game().pendingTyrant(), pending
+            state.game(), state.game().tyrantId(), Optional.empty(),
+            state.game().pendingTyrant(), Optional.empty()
         );
         return new LifecycleState(game, players);
     }
@@ -109,16 +93,8 @@ public final class RoleMaintenanceService {
                 pendingTyrant = Optional.empty();
             }
         }
-        if (pendingVigilante.isPresent()) {
-            PendingSelection pending = pendingVigilante.orElseThrow();
-            if (!now.isAfter(pending.expiresAt())
-                    && onlinePlayerIds.contains(pending.candidateId())
-                    && eligibleAtConfirmation(state.players().get(pending.candidateId()), now)
-                    && tyrant.filter(pending.candidateId()::equals).isEmpty()) {
-                vigilante = Optional.of(pending.candidateId());
-                pendingVigilante = Optional.empty();
-            }
-        }
+        // Legacy pending Vigilante selections become arena vacancies.
+        pendingVigilante = Optional.empty();
         return new LifecycleState(
             copyRoles(game, tyrant, vigilante, pendingTyrant, pendingVigilante),
             state.players()
@@ -163,23 +139,6 @@ public final class RoleMaintenanceService {
         return new LifecycleState(game, state.players());
     }
 
-    private LifecycleState rerollExpiredVigilante(
-        LifecycleState state,
-        Set<UUID> onlinePlayerIds,
-        Instant now
-    ) {
-        Optional<PendingSelection> pending = state.game().pendingVigilante();
-        if (pending.isEmpty() || !now.isAfter(pending.orElseThrow().expiresAt())) {
-            return state;
-        }
-        return rerollVigilante(
-            state.asPersistentState(),
-            Optional.of(pending.orElseThrow().candidateId()),
-            onlinePlayerIds,
-            now
-        );
-    }
-
     private boolean isInactive(
         Optional<UUID> roleHolder,
         Map<UUID, PlayerState> players,

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

@@ -16,6 +16,7 @@ public final class SpigotTyrantPlugin extends JavaPlugin {
     private FixerEffectController fixerEffects;
     private TyrantEffectController tyrantEffects;
     private OptOutGlowController optOutGlow;
+    private VigilanteArenaController vigilanteArena;
 
     @Override
     public void onEnable() {
@@ -33,6 +34,14 @@ public final class SpigotTyrantPlugin extends JavaPlugin {
             return;
         }
 
+        ArenaLocationStore arenaLocations = new BukkitConfigArenaLocationStore(this);
+        try {
+            arenaLocations.location();
+        } catch (IllegalArgumentException exception) {
+            getLogger().log(Level.SEVERE, "Invalid Vigilante arena location", exception);
+            getServer().getPluginManager().disablePlugin(this);
+            return;
+        }
         Clock clock = Clock.systemUTC();
         RoleCandidateSelector candidateSelector = new RoleCandidateSelector();
         java.util.random.RandomGenerator random = java.util.random.RandomGenerator.getDefault();
@@ -54,6 +63,9 @@ public final class SpigotTyrantPlugin extends JavaPlugin {
         FollowerService followers = new FollowerService();
         AbilityReadinessService readiness = new AbilityReadinessService();
         AbilityItemService abilityItems = new BukkitAbilityItemService(this, settings);
+        RoleControlItemService roleControlItems = new BukkitRoleControlItemService(
+            this, settings
+        );
         CapturedMobItemService capturedMobItems = new BukkitCapturedMobItemService(
             this, settings
         );
@@ -61,6 +73,10 @@ public final class SpigotTyrantPlugin extends JavaPlugin {
         CapturedMobInventoryService capturedMobInventory = new CapturedMobInventoryService(
             capturedMobItems, settings
         );
+        CapturedMobCustodyRelease formerTamerRelease =
+            new DefaultCapturedMobCustodyRelease(
+                new BukkitCapturedMobSpawner(getServer(), settings)
+            );
         AssassinAbilityService assassinAbilities = new AssassinAbilityService(
             readiness, settings
         );
@@ -85,6 +101,18 @@ public final class SpigotTyrantPlugin extends JavaPlugin {
         TyrantControlPanel controlPanel = new DefaultTyrantControlPanel(
             stateManager, controlPanelRenderer, clock
         );
+        FollowerPresenceProvider followerPresence = new BukkitFollowerPresenceProvider(
+            getServer(), settings.followerRangeBlocks()
+        );
+        BukkitVigilanteControlPanelRenderer vigilanteControlPanelRenderer =
+            new BukkitVigilanteControlPanelRenderer(
+                getServer(), stateManager, followers, followerPresence,
+                settings.followerStrengthCap(), settings.followerResistanceCap()
+            );
+        VigilanteControlPanel vigilanteControlPanel = new DefaultVigilanteControlPanel(
+            stateManager, followers, vigilanteControlPanelRenderer, followerPresence,
+            settings.followerStrengthCap(), settings.followerResistanceCap()
+        );
         Objects.requireNonNull(getCommand("tyrant"), "Missing tyrant command metadata")
             .setExecutor(new TyrantCommand(
                 stateManager,
@@ -97,10 +125,14 @@ public final class SpigotTyrantPlugin extends JavaPlugin {
                 tyrantPresentation,
                 abilityItems,
                 new TyrantAbilityService(settings.rosterIntelligenceCooldown()),
-                controlPanel
+                controlPanel,
+                roleControlItems
             ));
         Objects.requireNonNull(getCommand("vigilante"), "Missing vigilante metadata")
-            .setExecutor(new VigilanteCommand(stateManager, followers, onlinePlayers));
+            .setExecutor(new VigilanteCommand(
+                stateManager, followers, onlinePlayers, vigilanteControlPanel,
+                roleControlItems
+            ));
         Objects.requireNonNull(getCommand("tyrantadmin"), "Missing tyrantadmin metadata")
             .setExecutor(new TyrantAdminCommand(
                 stateManager,
@@ -108,16 +140,26 @@ public final class SpigotTyrantPlugin extends JavaPlugin {
                 onlinePlayers,
                 managedEffects,
                 clock,
-                candidateSelector,
-                settings.candidateActivityWindow(),
-                settings.pendingSelectionTimeout(),
-                random
+                arenaLocations
             ));
+        Objects.requireNonNull(getCommand("tyrant"), "Missing tyrant command metadata")
+            .setTabCompleter(new TyrantTabCompleter(stateManager, onlinePlayers));
+        Objects.requireNonNull(getCommand("vigilante"), "Missing vigilante metadata")
+            .setTabCompleter(new VigilanteTabCompleter(
+                stateManager, followers, onlinePlayers
+            ));
+        Objects.requireNonNull(getCommand("tyrantadmin"), "Missing tyrantadmin metadata")
+            .setTabCompleter(new TyrantAdminTabCompleter(onlinePlayers));
         getServer().getPluginManager().registerEvents(
             new PlayerJoinListener(stateManager, clock, tyrantPresentation),
             this
         );
+        vigilanteArena = new VigilanteArenaController(
+            stateManager, getServer(), arenaLocations, settings
+        );
+        getServer().getPluginManager().registerEvents(vigilanteArena, this);
         getServer().getPluginManager().registerEvents(controlPanelRenderer, this);
+        getServer().getPluginManager().registerEvents(vigilanteControlPanelRenderer, this);
         getServer().getPluginManager().registerEvents(
             new TyrantControlPanelJoinListener(
                 stateManager,
@@ -127,6 +169,15 @@ public final class SpigotTyrantPlugin extends JavaPlugin {
             ),
             this
         );
+        getServer().getPluginManager().registerEvents(
+            new VigilanteControlPanelJoinListener(
+                stateManager,
+                vigilanteControlPanel,
+                (task, delayTicks) -> getServer().getScheduler()
+                    .runTaskLater(this, task, delayTicks)
+            ),
+            this
+        );
         getServer().getPluginManager().registerEvents(
             new TyrantDeathListener(
                 stateManager, succession, tyrantPresentation, getServer(), clock
@@ -157,6 +208,12 @@ public final class SpigotTyrantPlugin extends JavaPlugin {
             new BoundItemListener(abilityItems),
             this
         );
+        getServer().getPluginManager().registerEvents(
+            new RoleControlItemListener(
+                stateManager, roleControlItems, controlPanel, vigilanteControlPanel
+            ),
+            this
+        );
         getServer().getPluginManager().registerEvents(
             new TamerListener(
                 stateManager, abilityItems, capturedMobItems, capturedMobs,
@@ -196,6 +253,7 @@ public final class SpigotTyrantPlugin extends JavaPlugin {
         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, vigilanteArena, 1L, 10L);
         getServer().getScheduler().runTaskTimer(
             this,
             new AbilityItemRefreshTask(
@@ -205,12 +263,29 @@ public final class SpigotTyrantPlugin extends JavaPlugin {
             20L,
             20L
         );
+        getServer().getScheduler().runTaskTimer(
+            this,
+            new RoleControlItemRefreshTask(stateManager, roleControlItems, getServer()),
+            1L,
+            10L
+        );
+        getServer().getScheduler().runTaskTimer(
+            this,
+            new FormerTamerReleaseTask(
+                stateManager, getServer(), formerTamerRelease, capturedMobInventory
+            ),
+            1L,
+            10L
+        );
         getServer().getScheduler().runTaskTimer(this, stateManager::saveIfDirty, 600L, 600L);
         getLogger().info("Spigot Tyrant enabled.");
     }
 
     @Override
     public void onDisable() {
+        if (vigilanteArena != null) {
+            vigilanteArena.close();
+        }
         if (optOutGlow != null) {
             optOutGlow.clearAll();
         }

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

@@ -0,0 +1,19 @@
+package games.dmg.spigottyrant;
+
+import java.util.Collection;
+import java.util.List;
+import java.util.Locale;
+
+public final class TabSuggestions {
+    private TabSuggestions() {
+    }
+
+    public static List<String> matching(String prefix, Collection<String> candidates) {
+        String normalized = prefix == null ? "" : prefix.toLowerCase(Locale.ROOT);
+        return candidates.stream()
+            .filter(candidate -> candidate.toLowerCase(Locale.ROOT).startsWith(normalized))
+            .distinct()
+            .sorted(String.CASE_INSENSITIVE_ORDER)
+            .toList();
+    }
+}

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

@@ -63,6 +63,11 @@ public final class TamerListener implements Listener {
             return;
         }
         PlayerState state = stateManager.player(player.getUniqueId(), player.getName());
+        if (!state.capturedMobs().isEmpty()) {
+            player.sendMessage(ChatColor.RED
+                + "Release the currently captured mob before capturing another.");
+            return;
+        }
         Entity target = event.getRightClicked();
         if (!canCapture(state, target)) {
             player.sendMessage(ChatColor.RED + "That mob cannot be captured.");

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

@@ -1,12 +1,8 @@
 package games.dmg.spigottyrant;
 
 import java.time.Clock;
-import java.time.Duration;
 import java.util.Locale;
 import java.util.Optional;
-import java.util.Set;
-import java.util.UUID;
-import java.util.random.RandomGenerator;
 import org.bukkit.ChatColor;
 import org.bukkit.command.Command;
 import org.bukkit.command.CommandExecutor;
@@ -20,10 +16,7 @@ public final class TyrantAdminCommand implements CommandExecutor {
     private final OnlinePlayerDirectory onlinePlayers;
     private final ManagedRoleEffects effects;
     private final Clock clock;
-    private final RoleCandidateSelector candidateSelector;
-    private final Duration activityWindow;
-    private final Duration pendingTimeout;
-    private final RandomGenerator random;
+    private final ArenaLocationStore arenaLocations;
 
     public TyrantAdminCommand(
         TyrantStateManager stateManager,
@@ -34,8 +27,7 @@ public final class TyrantAdminCommand implements CommandExecutor {
     ) {
         this(
             stateManager, lifecycle, onlinePlayers, effects, clock,
-            new RoleCandidateSelector(), Duration.ofHours(24), Duration.ofHours(24),
-            RandomGenerator.getDefault()
+            ArenaLocationStore.unavailable()
         );
     }
 
@@ -45,20 +37,14 @@ public final class TyrantAdminCommand implements CommandExecutor {
         OnlinePlayerDirectory onlinePlayers,
         ManagedRoleEffects effects,
         Clock clock,
-        RoleCandidateSelector candidateSelector,
-        Duration activityWindow,
-        Duration pendingTimeout,
-        RandomGenerator random
+        ArenaLocationStore arenaLocations
     ) {
         this.stateManager = stateManager;
         this.lifecycle = lifecycle;
         this.onlinePlayers = onlinePlayers;
         this.effects = effects;
         this.clock = clock;
-        this.candidateSelector = candidateSelector;
-        this.activityWindow = activityWindow;
-        this.pendingTimeout = pendingTimeout;
-        this.random = random;
+        this.arenaLocations = arenaLocations;
     }
 
     @Override
@@ -82,6 +68,7 @@ public final class TyrantAdminCommand implements CommandExecutor {
                 case "pause" -> pause(sender);
                 case "resume" -> resume(sender);
                 case "reset" -> reset(sender, arguments);
+                case "arena" -> arena(sender, arguments);
                 default -> usage(sender);
             }
         } catch (IllegalArgumentException | IllegalStateException exception) {
@@ -112,38 +99,17 @@ public final class TyrantAdminCommand implements CommandExecutor {
         stateManager.player(tyrant.getUniqueId(), tyrant.getName());
         vigilante.ifPresent(player -> stateManager.player(player.getUniqueId(), player.getName()));
         InstantHolder now = new InstantHolder(clock.instant());
-        Optional<UUID> randomCandidate = vigilante.isEmpty()
-            ? candidateSelector.select(
-                stateManager.players(), Set.of(tyrant.getUniqueId()), Optional.empty(),
-                now.value(), activityWindow, random
-            )
-            : Optional.empty();
-        Optional<UUID> activeVigilante = vigilante.map(Player::getUniqueId);
-        if (activeVigilante.isEmpty() && randomCandidate.isPresent()
-                && onlinePlayers.findById(randomCandidate.orElseThrow()) != null) {
-            activeVigilante = randomCandidate;
-        }
         LifecycleState started = lifecycle.start(
-            stateManager.snapshot(), tyrant.getUniqueId(), activeVigilante, now.value()
+            stateManager.snapshot(), tyrant.getUniqueId(),
+            vigilante.map(Player::getUniqueId), now.value()
         );
-        if (activeVigilante.isEmpty() && randomCandidate.isPresent()) {
-            GameState game = started.game();
-            started = new LifecycleState(new GameState(
-                game.lifecycle(), game.tyrantId(), game.vigilanteId(), game.pendingTyrant(),
-                Optional.of(new PendingSelection(
-                    randomCandidate.orElseThrow(), now.value().plus(pendingTimeout)
-                )),
-                game.pausedAt(), game.accumulatedPausedTime(), game.tyrantLevel(),
-                game.unspentChoices(), game.purchases()
-            ), started.players());
-        }
         stateManager.replaceState(started);
         stateManager.saveIfDirty();
         effects.restoreAll();
         sender.sendMessage(ChatColor.GREEN + "Tyrant game started.");
         if (vigilante.isEmpty()) {
             sender.sendMessage(ChatColor.YELLOW
-                + "An eligible recently active Vigilante will be selected automatically.");
+                + "The Vigilante arena challenge is open.");
         }
     }
 
@@ -175,6 +141,30 @@ public final class TyrantAdminCommand implements CommandExecutor {
         sender.sendMessage(ChatColor.GREEN + "Tyrant game reset.");
     }
 
+    private void arena(CommandSender sender, String[] arguments) {
+        if (arguments.length == 1 || arguments[1].equalsIgnoreCase("status")) {
+            sender.sendMessage("Vigilante arena: " + arenaLocations.location()
+                .map(ArenaLocation::display).orElse("not configured"));
+            return;
+        }
+        if (arguments.length != 2 || !arguments[1].equalsIgnoreCase("set")) {
+            sender.sendMessage(ChatColor.YELLOW
+                + "Usage: /tyrantadmin arena <set|status>");
+            return;
+        }
+        if (!(sender instanceof Player player)) {
+            sender.sendMessage(ChatColor.RED + "Only a player can set the arena location.");
+            return;
+        }
+        org.bukkit.Location location = player.getLocation();
+        ArenaLocation arena = new ArenaLocation(
+            location.getWorld().getName(), location.getX(), location.getY(), location.getZ(),
+            location.getYaw(), location.getPitch()
+        );
+        arenaLocations.set(arena);
+        sender.sendMessage(ChatColor.GREEN + "Vigilante arena set to " + arena.display() + ".");
+    }
+
     private void showStatus(CommandSender sender) {
         GameState game = stateManager.game();
         sender.sendMessage(ChatColor.GOLD + "Lifecycle: " + game.lifecycle());
@@ -186,6 +176,8 @@ public final class TyrantAdminCommand implements CommandExecutor {
             + ", purchases: " + game.purchases());
         sender.sendMessage("Pending Tyrant: " + game.pendingTyrant());
         sender.sendMessage("Pending Vigilante: " + game.pendingVigilante());
+        sender.sendMessage("Vigilante arena: " + arenaLocations.location()
+            .map(ArenaLocation::display).orElse("not configured"));
         for (PlayerState player : stateManager.players().values()) {
             boolean optedOut = player.optedOutUntil().isPresent();
             sender.sendMessage(
@@ -202,6 +194,6 @@ public final class TyrantAdminCommand implements CommandExecutor {
 
     private static void usage(CommandSender sender) {
         sender.sendMessage(ChatColor.YELLOW
-            + "Usage: /tyrantadmin <status|start|pause|resume|reset confirm>");
+            + "Usage: /tyrantadmin <status|start|pause|resume|reset confirm|arena set>");
     }
 }

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

@@ -0,0 +1,63 @@
+package games.dmg.spigottyrant;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.UUID;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandSender;
+import org.bukkit.command.TabCompleter;
+import org.bukkit.entity.Player;
+
+public final class TyrantAdminTabCompleter implements TabCompleter {
+    private static final String PERMISSION = "spigottyrant.admin";
+    private static final List<String> SUBCOMMANDS = List.of(
+        "status", "start", "pause", "resume", "reset", "arena"
+    );
+    private final OnlinePlayerDirectory onlinePlayers;
+
+    public TyrantAdminTabCompleter(OnlinePlayerDirectory onlinePlayers) {
+        this.onlinePlayers = onlinePlayers;
+    }
+
+    @Override
+    public List<String> onTabComplete(
+        CommandSender sender,
+        Command command,
+        String alias,
+        String[] arguments
+    ) {
+        if (!sender.hasPermission(PERMISSION) || arguments.length == 0) {
+            return List.of();
+        }
+        if (arguments.length == 1) {
+            return TabSuggestions.matching(arguments[0], SUBCOMMANDS);
+        }
+        String subcommand = arguments[0].toLowerCase(java.util.Locale.ROOT);
+        if (arguments.length == 2) {
+            return switch (subcommand) {
+                case "start" -> TabSuggestions.matching(arguments[1], onlineNames(null));
+                case "reset" -> TabSuggestions.matching(arguments[1], List.of("confirm"));
+                case "arena" -> TabSuggestions.matching(
+                    arguments[1], List.of("set", "status")
+                );
+                default -> List.of();
+            };
+        }
+        if (arguments.length == 3 && subcommand.equals("start")) {
+            return TabSuggestions.matching(arguments[2], onlineNames(arguments[1]));
+        }
+        return List.of();
+    }
+
+    private List<String> onlineNames(String excludedName) {
+        List<String> names = new ArrayList<>();
+        for (UUID playerId : onlinePlayers.onlinePlayerIds()) {
+            Player player = onlinePlayers.findById(playerId);
+            if (player != null && (excludedName == null
+                    || !player.getName().equalsIgnoreCase(excludedName))) {
+                names.add(player.getName());
+            }
+        }
+        return List.copyOf(names);
+    }
+}

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

@@ -21,6 +21,7 @@ public final class TyrantCommand implements CommandExecutor {
     private final AbilityItemService abilityItems;
     private final TyrantAbilityService tyrantAbilities;
     private final TyrantControlPanel controlPanel;
+    private final RoleControlItemService roleControlItems;
 
     public TyrantCommand(
         TyrantStateManager stateManager,
@@ -44,7 +45,21 @@ public final class TyrantCommand implements CommandExecutor {
             stateManager, progression, new ClassAssignmentService(),
             new BukkitOnlinePlayerDirectory(), Clock.systemUTC(),
             new ParticipationService(Duration.ofDays(7)), null, null, null,
-            new TyrantAbilityService(Duration.ofHours(24)), controlPanel
+            new TyrantAbilityService(Duration.ofHours(24)), controlPanel, null
+        );
+    }
+
+    public TyrantCommand(
+        TyrantStateManager stateManager,
+        TyrantProgressionService progression,
+        TyrantControlPanel controlPanel,
+        RoleControlItemService roleControlItems
+    ) {
+        this(
+            stateManager, progression, new ClassAssignmentService(),
+            new BukkitOnlinePlayerDirectory(), Clock.systemUTC(),
+            new ParticipationService(Duration.ofDays(7)), null, null, null,
+            new TyrantAbilityService(Duration.ofHours(24)), controlPanel, roleControlItems
         );
     }
 
@@ -58,7 +73,8 @@ public final class TyrantCommand implements CommandExecutor {
         this(
             stateManager, progression, assignments, onlinePlayers, clock,
             new ParticipationService(Duration.ofDays(7)), null, null, null,
-            new TyrantAbilityService(Duration.ofHours(24)), TyrantCommand::unavailablePanel
+            new TyrantAbilityService(Duration.ofHours(24)), TyrantCommand::unavailablePanel,
+            null
         );
     }
 
@@ -77,7 +93,7 @@ public final class TyrantCommand implements CommandExecutor {
         this(
             stateManager, progression, assignments, onlinePlayers, clock, participation,
             relinquishment, presentation, abilityItems, tyrantAbilities,
-            TyrantCommand::unavailablePanel
+            TyrantCommand::unavailablePanel, null
         );
     }
 
@@ -93,6 +109,26 @@ public final class TyrantCommand implements CommandExecutor {
         AbilityItemService abilityItems,
         TyrantAbilityService tyrantAbilities,
         TyrantControlPanel controlPanel
+    ) {
+        this(
+            stateManager, progression, assignments, onlinePlayers, clock, participation,
+            relinquishment, presentation, abilityItems, tyrantAbilities, controlPanel, null
+        );
+    }
+
+    public TyrantCommand(
+        TyrantStateManager stateManager,
+        TyrantProgressionService progression,
+        ClassAssignmentService assignments,
+        OnlinePlayerDirectory onlinePlayers,
+        Clock clock,
+        ParticipationService participation,
+        RoleRelinquishmentService relinquishment,
+        TyrantPresentation presentation,
+        AbilityItemService abilityItems,
+        TyrantAbilityService tyrantAbilities,
+        TyrantControlPanel controlPanel,
+        RoleControlItemService roleControlItems
     ) {
         this.stateManager = stateManager;
         this.progression = progression;
@@ -105,6 +141,7 @@ public final class TyrantCommand implements CommandExecutor {
         this.abilityItems = abilityItems;
         this.tyrantAbilities = tyrantAbilities;
         this.controlPanel = controlPanel;
+        this.roleControlItems = roleControlItems;
     }
 
     @Override
@@ -308,20 +345,27 @@ public final class TyrantCommand implements CommandExecutor {
     }
 
     private void recoverItems(Player player) {
-        if (abilityItems == null) {
-            player.sendMessage(ChatColor.RED + "Ability item recovery is unavailable.");
+        if (abilityItems == null && roleControlItems == null) {
+            player.sendMessage(ChatColor.RED + "Item recovery is unavailable.");
             return;
         }
-        PlayerState state = stateManager.player(player.getUniqueId(), player.getName());
-        abilityItems.recover(player, state);
+        if (abilityItems != null) {
+            PlayerState state = stateManager.player(player.getUniqueId(), player.getName());
+            abilityItems.recover(player, state);
+        }
+        GameState game = stateManager.game();
+        if (roleControlItems != null
+                && game.tyrantId().filter(player.getUniqueId()::equals).isPresent()) {
+            roleControlItems.recover(player, game);
+        }
         player.sendMessage(ChatColor.YELLOW
-            + "Recovered every currently ready missing class item that could fit.");
+            + "Recovered every currently available missing Tyrant item that could fit.");
     }
 
     private void relinquish(Player player, String[] arguments) {
         if (arguments.length != 2 || !arguments[1].equalsIgnoreCase("confirm")) {
             player.sendMessage(ChatColor.RED
-                + "Relinquishing rerolls your role. Use /tyrant relinquish confirm.");
+                + "Relinquishing ends your role. Use /tyrant relinquish confirm.");
             return;
         }
         if (relinquishment == null) {

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

@@ -38,7 +38,6 @@ public final class TyrantSuccessionService {
             throw new IllegalStateException("a running Tyrant reign is required");
         }
         UUID formerTyrant = state.game().tyrantId().orElseThrow();
-        Optional<UUID> formerVigilante = state.game().vigilanteId();
         Map<UUID, PlayerState> clearedPlayers = clearAssignments(state.players());
         Optional<UUID> selectedTyrant = killerId.isPresent()
             ? killerId
@@ -56,28 +55,12 @@ public final class TyrantSuccessionService {
             .filter(playerId -> activeTyrant.isEmpty())
             .map(playerId -> new PendingSelection(playerId, now.plus(pendingTimeout)));
 
-        Optional<UUID> selectedVigilante = activeTyrant.flatMap(tyrantId ->
-            candidates.select(
-                clearedPlayers,
-                Set.of(tyrantId),
-                formerVigilante,
-                now,
-                activityWindow,
-                random
-            )
-        );
-        Optional<UUID> activeVigilante = selectedVigilante
-            .filter(onlinePlayerIds::contains);
-        Optional<PendingSelection> pendingVigilante = selectedVigilante
-            .filter(playerId -> activeVigilante.isEmpty())
-            .map(playerId -> new PendingSelection(playerId, now.plus(pendingTimeout)));
-
         GameState game = new GameState(
             GameLifecycle.RUNNING,
             activeTyrant,
-            activeVigilante,
+            Optional.empty(),
             pendingTyrant,
-            pendingVigilante,
+            Optional.empty(),
             Optional.empty(),
             state.game().accumulatedPausedTime(),
             0,

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

@@ -0,0 +1,84 @@
+package games.dmg.spigottyrant;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.UUID;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandSender;
+import org.bukkit.command.TabCompleter;
+import org.bukkit.entity.Player;
+
+public final class TyrantTabCompleter implements TabCompleter {
+    private static final List<String> SUBCOMMANDS = List.of(
+        "menu", "status", "choices", "buy", "assign", "item", "intelligence",
+        "optout", "optin", "relinquish"
+    );
+    private static final List<String> UNLOCKS = java.util.Arrays.stream(TyrantUnlock.values())
+        .map(value -> value.name().toLowerCase(java.util.Locale.ROOT))
+        .toList();
+    private static final List<String> CLASSES = List.of("assassin", "fixer", "tamer");
+    private final TyrantStateManager stateManager;
+    private final OnlinePlayerDirectory onlinePlayers;
+
+    public TyrantTabCompleter(
+        TyrantStateManager stateManager,
+        OnlinePlayerDirectory onlinePlayers
+    ) {
+        this.stateManager = stateManager;
+        this.onlinePlayers = onlinePlayers;
+    }
+
+    @Override
+    public List<String> onTabComplete(
+        CommandSender sender,
+        Command command,
+        String alias,
+        String[] arguments
+    ) {
+        if (!(sender instanceof Player player) || arguments.length == 0) {
+            return List.of();
+        }
+        if (arguments.length == 1) {
+            return TabSuggestions.matching(arguments[0], SUBCOMMANDS);
+        }
+        String subcommand = arguments[0].toLowerCase(java.util.Locale.ROOT);
+        if (arguments.length == 2) {
+            return switch (subcommand) {
+                case "buy" -> TabSuggestions.matching(arguments[1], UNLOCKS);
+                case "assign" -> TabSuggestions.matching(arguments[1], CLASSES);
+                case "relinquish" -> TabSuggestions.matching(
+                    arguments[1], List.of("confirm")
+                );
+                default -> List.of();
+            };
+        }
+        if (arguments.length == 3 && subcommand.equals("assign")) {
+            return TabSuggestions.matching(arguments[2], eligibleAssignees(player));
+        }
+        return List.of();
+    }
+
+    private List<String> eligibleAssignees(Player tyrant) {
+        Map<UUID, PlayerState> states = stateManager.players();
+        GameState game = stateManager.game();
+        Set<UUID> online = onlinePlayers.onlinePlayerIds();
+        List<String> names = new ArrayList<>();
+        for (UUID playerId : online) {
+            if (playerId.equals(tyrant.getUniqueId())
+                    || game != null && game.tyrantId().filter(playerId::equals).isPresent()) {
+                continue;
+            }
+            PlayerState state = states.get(playerId);
+            if (state != null && state.optedOutUntil().isPresent()) {
+                continue;
+            }
+            Player candidate = onlinePlayers.findById(playerId);
+            if (candidate != null) {
+                names.add(candidate.getName());
+            }
+        }
+        return List.copyOf(names);
+    }
+}

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

@@ -0,0 +1,59 @@
+package games.dmg.spigottyrant;
+
+import java.util.LinkedHashMap;
+import java.util.Map;
+import org.bukkit.Location;
+import org.bukkit.Material;
+import org.bukkit.World;
+import org.bukkit.block.Block;
+import org.bukkit.block.data.BlockData;
+
+final class VigilanteArenaBarrier {
+    private final Map<Location, BlockData> replaced = new LinkedHashMap<>();
+    private boolean built;
+
+    void build(World world, ArenaLocation center, double radius) {
+        if (built) {
+            return;
+        }
+        built = true;
+        int samples = Math.max(64, (int) Math.ceil(2.0 * Math.PI * radius * 2.0));
+        int baseY = (int) Math.floor(center.y());
+        for (int index = 0; index < samples; index++) {
+            double angle = 2.0 * Math.PI * index / samples;
+            int x = (int) Math.floor(center.x() + Math.cos(angle) * radius);
+            int z = (int) Math.floor(center.z() + Math.sin(angle) * radius);
+            for (int y = baseY; y < baseY + 3; y++) {
+                Block block = world.getBlockAt(x, y, z);
+                Location location = block.getLocation();
+                if (replaced.containsKey(location) || !isAir(block.getType())) {
+                    continue;
+                }
+                replaced.put(location, block.getBlockData().clone());
+                block.setType(Material.BARRIER, false);
+            }
+        }
+    }
+
+    void clear() {
+        for (Map.Entry<Location, BlockData> entry : replaced.entrySet()) {
+            Location location = entry.getKey();
+            World world = location.getWorld();
+            if (world != null) {
+                world.getBlockAt(location).setBlockData(entry.getValue(), false);
+            }
+        }
+        replaced.clear();
+        built = false;
+    }
+
+    boolean active() {
+        return built;
+    }
+
+    private static boolean isAir(Material material) {
+        return material == Material.AIR
+            || material == Material.CAVE_AIR
+            || material == Material.VOID_AIR;
+    }
+}

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

@@ -0,0 +1,505 @@
+package games.dmg.spigottyrant;
+
+import java.util.HashSet;
+import java.util.Optional;
+import java.util.Set;
+import java.util.UUID;
+import org.bukkit.ChatColor;
+import org.bukkit.Location;
+import org.bukkit.Particle;
+import org.bukkit.Server;
+import org.bukkit.World;
+import org.bukkit.attribute.Attribute;
+import org.bukkit.entity.Entity;
+import org.bukkit.entity.LivingEntity;
+import org.bukkit.entity.Mob;
+import org.bukkit.entity.Player;
+import org.bukkit.entity.Projectile;
+import org.bukkit.entity.Zombie;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.EventPriority;
+import org.bukkit.event.Listener;
+import org.bukkit.event.entity.CreatureSpawnEvent;
+import org.bukkit.event.entity.EntityCombustEvent;
+import org.bukkit.event.entity.EntityDamageByEntityEvent;
+import org.bukkit.event.entity.EntityDeathEvent;
+import org.bukkit.event.entity.EntityTargetLivingEntityEvent;
+import org.bukkit.event.entity.PlayerDeathEvent;
+import org.bukkit.event.player.PlayerJoinEvent;
+import org.bukkit.event.player.PlayerMoveEvent;
+import org.bukkit.event.player.PlayerQuitEvent;
+import org.bukkit.event.player.PlayerRespawnEvent;
+import org.bukkit.event.player.PlayerTeleportEvent;
+
+public final class VigilanteArenaController implements Listener, Runnable {
+    private static final String BOSS_TAG = "spigottyrant-vigilante-boss";
+    private final TyrantStateManager stateManager;
+    private final Server server;
+    private final ArenaLocationStore locations;
+    private final PluginSettings settings;
+    private final VigilanteArenaSuccessionService succession =
+        new VigilanteArenaSuccessionService();
+    private final VigilanteArenaBarrier barrier = new VigilanteArenaBarrier();
+    private final Set<UUID> relocating = new HashSet<>();
+    private UUID bossId;
+    private UUID challengerId;
+    private boolean spawningBoss;
+    private boolean wasOpen;
+    private boolean warnedMissingLocation;
+    private ArenaLocation observedLocation;
+
+    public VigilanteArenaController(
+        TyrantStateManager stateManager,
+        Server server,
+        ArenaLocationStore locations,
+        PluginSettings settings
+    ) {
+        this.stateManager = stateManager;
+        this.server = server;
+        this.locations = locations;
+        this.settings = settings;
+    }
+
+    @Override
+    public void run() {
+        Optional<ArenaLocation> configured = locations.location();
+        if (configured.isEmpty()) {
+            closeFight();
+            observedLocation = null;
+            warnIfOpenWithoutLocation();
+            wasOpen = false;
+            return;
+        }
+        ArenaLocation arena = configured.orElseThrow();
+        if (observedLocation != null && !observedLocation.equals(arena)) {
+            closeFight();
+        }
+        observedLocation = arena;
+        World world = server.getWorld(arena.worldName());
+        if (world == null) {
+            closeFight();
+            warnIfOpenWithoutLocation();
+            wasOpen = false;
+            return;
+        }
+
+        warnedMissingLocation = false;
+        drawBoundary(world, arena);
+        removeOtherMobs(world, arena);
+        boolean open = VigilanteArenaPolicy.isOpen(stateManager.game());
+        if (open && !wasOpen) {
+            announceVacancy(arena);
+        }
+        wasOpen = open;
+        if (!open) {
+            closeFight();
+            return;
+        }
+
+        Zombie boss = boss(world);
+        if (boss == null) {
+            boss = spawnBoss(world, arena);
+        }
+        boss.setFireTicks(0);
+        if (!contains(arena, boss.getLocation())) {
+            boss.teleport(toBukkit(world, arena));
+        }
+        Player challenger = challengerId == null ? null : server.getPlayer(challengerId);
+        if (challenger == null || challenger.isDead()
+                || !contains(arena, challenger.getLocation())
+                || !VigilanteArenaPolicy.isEligible(
+                    stateManager.game(), playerState(challenger)
+                )) {
+            if (challengerId != null) {
+                resetFight();
+            }
+            boss.setTarget(null);
+        } else {
+            boss.setTarget(challenger);
+        }
+        for (Player player : world.getPlayers()) {
+            enforcePosition(player, null, player.getLocation());
+        }
+    }
+
+    @EventHandler(priority = EventPriority.HIGHEST, ignoreCancelled = true)
+    public void onMove(PlayerMoveEvent event) {
+        if (event.getTo() != null && movedHorizontally(event.getFrom(), event.getTo())
+                && enforcePosition(event.getPlayer(), event.getFrom(), event.getTo())) {
+            event.setCancelled(true);
+        }
+    }
+
+    @EventHandler(priority = EventPriority.HIGHEST, ignoreCancelled = true)
+    public void onTeleport(PlayerTeleportEvent event) {
+        if (event.getTo() != null
+                && enforcePosition(event.getPlayer(), event.getFrom(), event.getTo())) {
+            event.setCancelled(true);
+        }
+    }
+
+    @EventHandler(priority = EventPriority.HIGHEST)
+    public void onRespawn(PlayerRespawnEvent event) {
+        Optional<ArenaLocation> configured = locations.location();
+        if (configured.isPresent() && contains(
+                configured.orElseThrow(), event.getRespawnLocation())) {
+            event.setRespawnLocation(outside(configured.orElseThrow(), event.getRespawnLocation()));
+        }
+    }
+
+    @EventHandler(priority = EventPriority.MONITOR)
+    public void onPlayerDeath(PlayerDeathEvent event) {
+        if (event.getEntity().getUniqueId().equals(challengerId)) {
+            resetFight();
+        }
+    }
+
+    @EventHandler(priority = EventPriority.MONITOR)
+    public void onQuit(PlayerQuitEvent event) {
+        if (event.getPlayer().getUniqueId().equals(challengerId)) {
+            resetFight();
+        }
+    }
+
+    @EventHandler(priority = EventPriority.MONITOR)
+    public void onJoin(PlayerJoinEvent event) {
+        if (!VigilanteArenaPolicy.isOpen(stateManager.game())) {
+            return;
+        }
+        PlayerState state = playerState(event.getPlayer());
+        locations.location().filter(location -> VigilanteArenaPolicy.isEligible(
+            stateManager.game(), state
+        )).ifPresent(location -> event.getPlayer().sendMessage(vacancyMessage(location)));
+    }
+
+    @EventHandler(priority = EventPriority.HIGHEST, ignoreCancelled = true)
+    public void onCreatureSpawn(CreatureSpawnEvent event) {
+        Optional<ArenaLocation> configured = locations.location();
+        if (!spawningBoss && configured.isPresent()
+                && contains(configured.orElseThrow(), event.getLocation())) {
+            event.setCancelled(true);
+        }
+    }
+
+    @EventHandler(priority = EventPriority.HIGHEST, ignoreCancelled = true)
+    public void onCombust(EntityCombustEvent event) {
+        if (event.getEntity().getUniqueId().equals(bossId)) {
+            event.setCancelled(true);
+        }
+    }
+
+    @EventHandler(priority = EventPriority.HIGHEST, ignoreCancelled = true)
+    public void onTarget(EntityTargetLivingEntityEvent event) {
+        if (!event.getEntity().getUniqueId().equals(bossId)) {
+            return;
+        }
+        Entity target = event.getTarget();
+        if (target != null && (challengerId == null
+                || !target.getUniqueId().equals(challengerId))) {
+            event.setCancelled(true);
+        }
+    }
+
+    @EventHandler(priority = EventPriority.HIGHEST, ignoreCancelled = true)
+    public void onDamage(EntityDamageByEntityEvent event) {
+        if (!event.getEntity().getUniqueId().equals(bossId)) {
+            return;
+        }
+        Player attacker = attackingPlayer(event.getDamager());
+        if (attacker == null || challengerId == null
+                || !attacker.getUniqueId().equals(challengerId)) {
+            event.setCancelled(true);
+        }
+    }
+
+    @EventHandler(priority = EventPriority.MONITOR)
+    public void onBossDeath(EntityDeathEvent event) {
+        if (!event.getEntity().getUniqueId().equals(bossId)) {
+            return;
+        }
+        UUID defeatedBoss = bossId;
+        bossId = null;
+        Player killer = event.getEntity().getKiller();
+        if (killer != null && challengerId != null
+                && killer.getUniqueId().equals(challengerId)
+                && VigilanteArenaPolicy.isEligible(
+                    stateManager.game(), playerState(killer)
+                )) {
+            assignVigilante(challengerId);
+            return;
+        }
+        bossId = defeatedBoss;
+        resetFight();
+    }
+
+    public void close() {
+        closeFight();
+    }
+
+    private boolean enforcePosition(Player player, Location from, Location to) {
+        Optional<ArenaLocation> configured = locations.location();
+        if (configured.isEmpty() || relocating.contains(player.getUniqueId())) {
+            return false;
+        }
+        ArenaLocation arena = configured.orElseThrow();
+        boolean inside = contains(arena, to);
+        if (player.getUniqueId().equals(challengerId)) {
+            if (!inside) {
+                resetFight();
+            }
+            return false;
+        }
+        if (!inside) {
+            return false;
+        }
+        PlayerState state = playerState(player);
+        if (challengerId == null && bossId != null
+                && VigilanteArenaPolicy.isEligible(stateManager.game(), state)) {
+            challengerId = player.getUniqueId();
+            World world = server.getWorld(arena.worldName());
+            if (world != null) {
+                barrier.build(world, arena, settings.vigilanteArenaRadiusBlocks());
+                Zombie boss = boss(world);
+                if (boss != null) {
+                    boss.setHealth(settings.vigilanteBossHealth());
+                    boss.teleport(toBukkit(world, arena));
+                    boss.setTarget(player);
+                }
+            }
+            player.sendMessage(ChatColor.GOLD + "Defeat the arena boss to become Vigilante!");
+            return false;
+        }
+        bounce(player, from, to, arena);
+        return true;
+    }
+
+    private void bounce(Player player, Location from, Location attempted, ArenaLocation arena) {
+        Location destination = from != null && !contains(arena, from)
+            ? from.clone() : outside(arena, attempted);
+        relocating.add(player.getUniqueId());
+        try {
+            player.teleport(destination, PlayerTeleportEvent.TeleportCause.PLUGIN);
+        } finally {
+            relocating.remove(player.getUniqueId());
+        }
+        player.sendMessage(ChatColor.RED + "Only the active challenger may enter the arena.");
+    }
+
+    private void resetFight() {
+        challengerId = null;
+        barrier.clear();
+        Optional<ArenaLocation> configured = locations.location();
+        if (configured.isEmpty()) {
+            return;
+        }
+        World world = server.getWorld(configured.orElseThrow().worldName());
+        Zombie boss = world == null ? null : boss(world);
+        if (boss != null && !boss.isDead()) {
+            boss.setHealth(settings.vigilanteBossHealth());
+            boss.teleport(toBukkit(world, configured.orElseThrow()));
+            boss.setTarget(null);
+        } else {
+            bossId = null;
+        }
+    }
+
+    private void closeFight() {
+        challengerId = null;
+        barrier.clear();
+        if (bossId != null) {
+            Entity entity = server.getEntity(bossId);
+            if (entity != null) {
+                entity.remove();
+            }
+            bossId = null;
+        }
+    }
+
+    private Zombie spawnBoss(World world, ArenaLocation arena) {
+        for (Entity entity : world.getEntities()) {
+            if (entity.getScoreboardTags().contains(BOSS_TAG)) {
+                entity.remove();
+            }
+        }
+        spawningBoss = true;
+        try {
+            Zombie boss = world.spawn(toBukkit(world, arena), Zombie.class, zombie -> {
+                zombie.setAdult();
+                zombie.setCustomName(ChatColor.DARK_RED + "Vigilante's Trial");
+                zombie.setCustomNameVisible(true);
+                zombie.setRemoveWhenFarAway(false);
+                zombie.setCanPickupItems(false);
+                zombie.addScoreboardTag(BOSS_TAG);
+                setAttribute(zombie, Attribute.MAX_HEALTH, settings.vigilanteBossHealth());
+                setAttribute(zombie, Attribute.ATTACK_DAMAGE, settings.vigilanteBossDamage());
+                setAttribute(zombie, Attribute.ARMOR, settings.vigilanteBossArmor());
+                zombie.setHealth(settings.vigilanteBossHealth());
+            });
+            bossId = boss.getUniqueId();
+            return boss;
+        } finally {
+            spawningBoss = false;
+        }
+    }
+
+    private Zombie boss(World world) {
+        if (bossId == null) {
+            return null;
+        }
+        Entity entity = server.getEntity(bossId);
+        return entity instanceof Zombie zombie && entity.getWorld().equals(world)
+            && !zombie.isDead() ? zombie : null;
+    }
+
+    private void assignVigilante(UUID playerId) {
+        LifecycleState assigned;
+        try {
+            assigned = succession.claim(stateManager.snapshot(), playerId);
+        } catch (IllegalStateException exception) {
+            resetFight();
+            return;
+        }
+        stateManager.replaceState(assigned);
+        stateManager.saveIfDirty();
+        challengerId = null;
+        barrier.clear();
+        String name = Optional.ofNullable(server.getPlayer(playerId))
+            .map(Player::getName).orElse(playerId.toString());
+        String message = ChatColor.YELLOW + name + " defeated the arena boss and is the Vigilante!";
+        server.getOnlinePlayers().forEach(player -> player.sendMessage(message));
+    }
+
+    private void announceVacancy(ArenaLocation arena) {
+        String message = vacancyMessage(arena);
+        for (Player player : server.getOnlinePlayers()) {
+            PlayerState state = playerState(player);
+            if (VigilanteArenaPolicy.isEligible(stateManager.game(), state)) {
+                player.sendMessage(message);
+            }
+        }
+    }
+
+    private void warnIfOpenWithoutLocation() {
+        if (!VigilanteArenaPolicy.isOpen(stateManager.game()) || warnedMissingLocation) {
+            return;
+        }
+        warnedMissingLocation = true;
+        server.getConsoleSender().sendMessage(ChatColor.RED
+            + "The Vigilante role is vacant, but no valid arena location is configured. "
+            + "Use /tyrantadmin arena set.");
+        for (Player player : server.getOnlinePlayers()) {
+            if (player.hasPermission("spigottyrant.admin")) {
+                player.sendMessage(ChatColor.RED
+                    + "The Vigilante arena location is not configured.");
+            }
+        }
+    }
+
+    private String vacancyMessage(ArenaLocation arena) {
+        return ChatColor.YELLOW + "The Vigilante position is open! Challenge the boss in "
+            + arena.display() + ".";
+    }
+
+    private void removeOtherMobs(World world, ArenaLocation arena) {
+        Location center = toBukkit(world, arena);
+        double radius = settings.vigilanteArenaRadiusBlocks();
+        for (Entity entity : world.getNearbyEntities(center, radius, world.getMaxHeight(), radius)) {
+            if (entity instanceof Mob && !entity.getUniqueId().equals(bossId)
+                    && contains(arena, entity.getLocation())) {
+                entity.remove();
+            }
+        }
+    }
+
+    private void drawBoundary(World world, ArenaLocation arena) {
+        if (barrier.active()) {
+            return;
+        }
+        double radius = settings.vigilanteArenaRadiusBlocks();
+        for (int index = 0; index < 48; index++) {
+            double angle = 2.0 * Math.PI * index / 48.0;
+            Location point = new Location(
+                world,
+                arena.x() + Math.cos(angle) * radius,
+                arena.y() + 1.0,
+                arena.z() + Math.sin(angle) * radius
+            );
+            world.spawnParticle(Particle.END_ROD, point, 1, 0.0, 0.0, 0.0, 0.0);
+        }
+    }
+
+    private boolean contains(ArenaLocation arena, Location location) {
+        World world = location.getWorld();
+        return world != null && ArenaGeometry.contains(
+            arena, settings.vigilanteArenaRadiusBlocks(), world.getName(),
+            location.getX(), location.getY(), location.getZ()
+        );
+    }
+
+    private Location outside(ArenaLocation arena, Location attempted) {
+        ArenaPoint point = ArenaGeometry.outside(
+            arena, settings.vigilanteArenaRadiusBlocks(), attempted.getX(),
+            attempted.getY(), attempted.getZ()
+        );
+        World world = server.getWorld(arena.worldName());
+        if (world == null) {
+            return attempted;
+        }
+        int x = (int) Math.floor(point.x());
+        int z = (int) Math.floor(point.z());
+        int preferredY = (int) Math.floor(point.y());
+        for (int offset = 0; offset <= 8; offset++) {
+            int[] candidates = offset == 0
+                ? new int[] {preferredY} : new int[] {preferredY + offset, preferredY - offset};
+            for (int y : candidates) {
+                if (y > world.getMinHeight() && y + 1 < world.getMaxHeight()
+                        && world.getBlockAt(x, y, z).isPassable()
+                        && world.getBlockAt(x, y + 1, z).isPassable()
+                        && !world.getBlockAt(x, y - 1, z).isPassable()) {
+                    return new Location(world, x + 0.5, y, z + 0.5,
+                        attempted.getYaw(), attempted.getPitch());
+                }
+            }
+        }
+        int surfaceY = Math.min(
+            world.getMaxHeight() - 2,
+            Math.max(world.getMinHeight() + 1, world.getHighestBlockYAt(x, z) + 1)
+        );
+        return new Location(world, x + 0.5, surfaceY, z + 0.5,
+            attempted.getYaw(), attempted.getPitch());
+    }
+
+    private PlayerState playerState(Player player) {
+        PlayerState existing = stateManager.players().get(player.getUniqueId());
+        return existing == null
+            ? stateManager.player(player.getUniqueId(), player.getName()) : existing;
+    }
+
+    private static Location toBukkit(World world, ArenaLocation arena) {
+        return new Location(
+            world, arena.x(), arena.y(), arena.z(), arena.yaw(), arena.pitch()
+        );
+    }
+
+    private static Player attackingPlayer(Entity damager) {
+        if (damager instanceof Player player) {
+            return player;
+        }
+        if (damager instanceof Projectile projectile
+                && projectile.getShooter() instanceof Player player) {
+            return player;
+        }
+        return null;
+    }
+
+    private static void setAttribute(Zombie zombie, Attribute attribute, double value) {
+        if (zombie.getAttribute(attribute) != null) {
+            zombie.getAttribute(attribute).setBaseValue(value);
+        }
+    }
+
+    private static boolean movedHorizontally(Location from, Location to) {
+        return from.getWorld() != to.getWorld()
+            || from.getX() != to.getX() || from.getZ() != to.getZ();
+    }
+}

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

@@ -0,0 +1,19 @@
+package games.dmg.spigottyrant;
+
+public final class VigilanteArenaPolicy {
+    private VigilanteArenaPolicy() {
+    }
+
+    public static boolean isOpen(GameState game) {
+        return game.lifecycle() == GameLifecycle.RUNNING
+            && game.tyrantId().isPresent()
+            && game.vigilanteId().isEmpty();
+    }
+
+    public static boolean isEligible(GameState game, PlayerState player) {
+        return player != null
+            && isOpen(game)
+            && player.optedOutUntil().isEmpty()
+            && game.tyrantId().filter(player.playerId()::equals).isEmpty();
+    }
+}

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

@@ -0,0 +1,20 @@
+package games.dmg.spigottyrant;
+
+import java.util.Optional;
+import java.util.UUID;
+
+public final class VigilanteArenaSuccessionService {
+    public LifecycleState claim(PersistentState state, UUID winnerId) {
+        PlayerState winner = state.players().get(winnerId);
+        if (!VigilanteArenaPolicy.isEligible(state.game(), winner)) {
+            throw new IllegalStateException("player is not eligible to claim the Vigilante role");
+        }
+        GameState game = state.game();
+        GameState assigned = new GameState(
+            game.lifecycle(), game.tyrantId(), Optional.of(winnerId), game.pendingTyrant(),
+            Optional.empty(), game.pausedAt(), game.accumulatedPausedTime(),
+            game.tyrantLevel(), game.unspentChoices(), game.purchases()
+        );
+        return new LifecycleState(assigned, state.players());
+    }
+}

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

@@ -11,15 +11,43 @@ public final class VigilanteCommand implements CommandExecutor {
     private final TyrantStateManager stateManager;
     private final FollowerService followers;
     private final OnlinePlayerDirectory onlinePlayers;
+    private final VigilanteControlPanel controlPanel;
+    private final RoleControlItemService roleControlItems;
 
     public VigilanteCommand(
         TyrantStateManager stateManager,
         FollowerService followers,
         OnlinePlayerDirectory onlinePlayers
+    ) {
+        this(
+            stateManager, followers, onlinePlayers,
+            player -> player.sendMessage(ChatColor.RED
+                + "The Vigilante control panel is unavailable."),
+            null
+        );
+    }
+
+    public VigilanteCommand(
+        TyrantStateManager stateManager,
+        FollowerService followers,
+        OnlinePlayerDirectory onlinePlayers,
+        VigilanteControlPanel controlPanel
+    ) {
+        this(stateManager, followers, onlinePlayers, controlPanel, null);
+    }
+
+    public VigilanteCommand(
+        TyrantStateManager stateManager,
+        FollowerService followers,
+        OnlinePlayerDirectory onlinePlayers,
+        VigilanteControlPanel controlPanel,
+        RoleControlItemService roleControlItems
     ) {
         this.stateManager = stateManager;
         this.followers = followers;
         this.onlinePlayers = onlinePlayers;
+        this.controlPanel = controlPanel;
+        this.roleControlItems = roleControlItems;
     }
 
     @Override
@@ -33,6 +61,21 @@ public final class VigilanteCommand implements CommandExecutor {
             sender.sendMessage("This command must be used by a player.");
             return true;
         }
+        if (arguments.length == 0
+                || arguments.length == 1 && arguments[0].equalsIgnoreCase("menu")) {
+            controlPanel.open(player);
+            return true;
+        }
+        if (arguments.length == 1 && arguments[0].equalsIgnoreCase("item")) {
+            if (roleControlItems == null) {
+                player.sendMessage(ChatColor.RED + "Role item recovery is unavailable.");
+            } else {
+                roleControlItems.recover(player, stateManager.game());
+                player.sendMessage(ChatColor.YELLOW
+                    + "Recovered the missing Vigilante control item if it could fit.");
+            }
+            return true;
+        }
         FollowerResult result;
         Player target = null;
         if (arguments.length == 1 && arguments[0].equalsIgnoreCase("accept")) {
@@ -61,7 +104,7 @@ public final class VigilanteCommand implements CommandExecutor {
                 );
         } else {
             player.sendMessage(ChatColor.YELLOW
-                + "Usage: /vigilante <invite <player>|accept|dismiss <player>|leave>");
+                + "Usage: /vigilante <menu|item|invite <player>|accept|dismiss <player>|leave>");
             return true;
         }
         if (result.status() == FollowerStatus.JOINED

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

@@ -0,0 +1,19 @@
+package games.dmg.spigottyrant;
+
+import java.util.UUID;
+import org.bukkit.entity.Player;
+
+@FunctionalInterface
+public interface VigilanteControlPanel {
+    void open(Player player);
+
+    default void beginSession(UUID playerId) {
+    }
+
+    default void endSession(UUID playerId) {
+    }
+
+    default boolean openedThisSession(UUID playerId) {
+        return false;
+    }
+}

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

@@ -0,0 +1,48 @@
+package games.dmg.spigottyrant;
+
+import java.util.UUID;
+import org.bukkit.entity.Player;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.Listener;
+import org.bukkit.event.player.PlayerJoinEvent;
+import org.bukkit.event.player.PlayerQuitEvent;
+
+public final class VigilanteControlPanelJoinListener implements Listener {
+    private static final long OPEN_DELAY_TICKS = 100L;
+    private final TyrantStateManager stateManager;
+    private final VigilanteControlPanel controlPanel;
+    private final DelayedTaskScheduler scheduler;
+
+    public VigilanteControlPanelJoinListener(
+        TyrantStateManager stateManager,
+        VigilanteControlPanel controlPanel,
+        DelayedTaskScheduler scheduler
+    ) {
+        this.stateManager = stateManager;
+        this.controlPanel = controlPanel;
+        this.scheduler = scheduler;
+    }
+
+    @EventHandler
+    public void onJoin(PlayerJoinEvent event) {
+        Player player = event.getPlayer();
+        UUID playerId = player.getUniqueId();
+        controlPanel.beginSession(playerId);
+        scheduler.schedule(() -> openIfStillVigilante(player), OPEN_DELAY_TICKS);
+    }
+
+    @EventHandler
+    public void onQuit(PlayerQuitEvent event) {
+        controlPanel.endSession(event.getPlayer().getUniqueId());
+    }
+
+    private void openIfStillVigilante(Player player) {
+        GameState game = stateManager.game();
+        if (player.isOnline()
+                && game.lifecycle() == GameLifecycle.RUNNING
+                && game.vigilanteId().filter(player.getUniqueId()::equals).isPresent()
+                && !controlPanel.openedThisSession(player.getUniqueId())) {
+            controlPanel.open(player);
+        }
+    }
+}

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

@@ -0,0 +1,59 @@
+package games.dmg.spigottyrant;
+
+import java.util.Comparator;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.UUID;
+import java.util.stream.Collectors;
+
+public record VigilanteControlPanelModel(
+    List<VigilanteFollowerView> followers,
+    Set<String> pendingInvitations,
+    int nearbyEligibleFollowers,
+    int strengthLevel,
+    int resistanceLevel,
+    int strengthCap,
+    int resistanceCap
+) {
+    public VigilanteControlPanelModel {
+        followers = List.copyOf(followers);
+        pendingInvitations = Set.copyOf(pendingInvitations);
+    }
+
+    public static VigilanteControlPanelModel create(
+        GameState game,
+        Map<UUID, PlayerState> players,
+        Set<UUID> pendingInvitationIds,
+        Map<UUID, FollowerPresence> presence,
+        int strengthCap,
+        int resistanceCap
+    ) {
+        UUID vigilanteId = game.vigilanteId().orElseThrow();
+        List<VigilanteFollowerView> followers = players.values().stream()
+            .filter(player -> player.followerOf().filter(vigilanteId::equals).isPresent())
+            .map(player -> new VigilanteFollowerView(
+                player.playerId(), player.latestName(), player.optedOutUntil().isPresent(),
+                presence.getOrDefault(
+                    player.playerId(), new FollowerPresence(false, false, false, false)
+                )
+            ))
+            .sorted(Comparator.comparing(VigilanteFollowerView::name))
+            .toList();
+        Set<String> pending = pendingInvitationIds.stream()
+            .map(players::get)
+            .filter(java.util.Objects::nonNull)
+            .map(PlayerState::latestName)
+            .collect(Collectors.toUnmodifiableSet());
+        int nearby = (int) followers.stream()
+            .filter(VigilanteFollowerView::contributes)
+            .count();
+        VigilantePower.Levels levels = VigilantePower.forFollowers(
+            nearby, strengthCap, resistanceCap
+        );
+        return new VigilanteControlPanelModel(
+            followers, pending, nearby, levels.strength(), levels.resistance(),
+            strengthCap, resistanceCap
+        );
+    }
+}

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

@@ -0,0 +1,8 @@
+package games.dmg.spigottyrant;
+
+import org.bukkit.entity.Player;
+
+@FunctionalInterface
+public interface VigilanteControlPanelRenderer {
+    void openOverview(Player player, VigilanteControlPanelModel model);
+}

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

@@ -55,8 +55,8 @@ public final class VigilanteDeathListener implements Listener {
         );
         stateManager.replaceState(rerolled);
         stateManager.saveIfDirty();
-        String message = ChatColor.YELLOW + "The Vigilante died; a replacement "
-            + (rerolled.game().vigilanteId().isPresent() ? "has been selected." : "is pending.");
+        String message = ChatColor.YELLOW
+            + "The Vigilante died; the arena challenge is now open.";
         server.getOnlinePlayers().forEach(player -> player.sendMessage(message));
     }
 }

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

@@ -0,0 +1,14 @@
+package games.dmg.spigottyrant;
+
+import java.util.UUID;
+
+public record VigilanteFollowerView(
+    UUID playerId,
+    String name,
+    boolean optedOut,
+    FollowerPresence presence
+) {
+    public boolean contributes() {
+        return !optedOut && presence.contributes();
+    }
+}

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

@@ -0,0 +1,96 @@
+package games.dmg.spigottyrant;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.UUID;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandSender;
+import org.bukkit.command.TabCompleter;
+import org.bukkit.entity.Player;
+
+public final class VigilanteTabCompleter implements TabCompleter {
+    private static final List<String> SUBCOMMANDS = List.of(
+        "menu", "item", "invite", "accept", "dismiss", "leave"
+    );
+    private final TyrantStateManager stateManager;
+    private final FollowerService followers;
+    private final OnlinePlayerDirectory onlinePlayers;
+
+    public VigilanteTabCompleter(
+        TyrantStateManager stateManager,
+        FollowerService followers,
+        OnlinePlayerDirectory onlinePlayers
+    ) {
+        this.stateManager = stateManager;
+        this.followers = followers;
+        this.onlinePlayers = onlinePlayers;
+    }
+
+    @Override
+    public List<String> onTabComplete(
+        CommandSender sender,
+        Command command,
+        String alias,
+        String[] arguments
+    ) {
+        if (!(sender instanceof Player player) || arguments.length == 0) {
+            return List.of();
+        }
+        if (arguments.length == 1) {
+            return TabSuggestions.matching(arguments[0], SUBCOMMANDS);
+        }
+        if (arguments.length != 2) {
+            return List.of();
+        }
+        return switch (arguments[0].toLowerCase(java.util.Locale.ROOT)) {
+            case "invite" -> TabSuggestions.matching(
+                arguments[1], eligibleInvitees(player)
+            );
+            case "dismiss" -> TabSuggestions.matching(
+                arguments[1], currentFollowers(player)
+            );
+            default -> List.of();
+        };
+    }
+
+    private List<String> eligibleInvitees(Player vigilante) {
+        GameState game = stateManager.game();
+        Map<UUID, PlayerState> states = stateManager.players();
+        Set<UUID> pending = followers.invitedPlayerIds(vigilante.getUniqueId());
+        List<String> names = new ArrayList<>();
+        for (UUID playerId : onlinePlayers.onlinePlayerIds()) {
+            PlayerState state = states.get(playerId);
+            boolean assignedRole = game.tyrantId().filter(playerId::equals).isPresent()
+                || game.vigilanteId().filter(playerId::equals).isPresent();
+            boolean ineligibleState = state != null
+                && (state.optedOutUntil().isPresent() || state.followerOf().isPresent());
+            if (assignedRole || ineligibleState || pending.contains(playerId)) {
+                continue;
+            }
+            Player candidate = onlinePlayers.findById(playerId);
+            if (candidate != null) {
+                names.add(candidate.getName());
+            }
+        }
+        return List.copyOf(names);
+    }
+
+    private List<String> currentFollowers(Player vigilante) {
+        Map<UUID, PlayerState> states = stateManager.players();
+        List<String> names = new ArrayList<>();
+        for (UUID playerId : onlinePlayers.onlinePlayerIds()) {
+            PlayerState state = states.get(playerId);
+            if (state == null
+                    || state.followerOf().filter(vigilante.getUniqueId()::equals).isEmpty()) {
+                continue;
+            }
+            Player candidate = onlinePlayers.findById(playerId);
+            if (candidate != null) {
+                names.add(candidate.getName());
+            }
+        }
+        return List.copyOf(names);
+    }
+}

src/main/resources/config.yml

@@ -2,6 +2,13 @@
 tyrant-range-blocks: 50
 follower-range-blocks: 50
 
+# Vigilante arena and boss
+vigilante-arena-radius-blocks: 10
+vigilante-boss-health: 80
+vigilante-boss-damage: 8
+vigilante-boss-armor: 10
+# Set with /tyrantadmin arena set
+
 # Participation, inactivity, and selection
 opt-out-seconds: 604800
 role-inactivity-seconds: 172800
@@ -50,6 +57,14 @@ tyrant-resistance-level: 1
 follower-strength-cap: 5
 follower-resistance-cap: 4
 
+# Role control items
+tyrant-control-item:
+  material: NETHER_STAR
+  name: Tyrant Control
+vigilante-control-item:
+  material: COMPASS
+  name: Vigilante Control
+
 # Bound item recovery and delivery messages
 recovery-command: /tyrant item
 inventory-full-message: Your inventory is full. Make room and use /tyrant item.

src/main/resources/plugin.yml

@@ -10,10 +10,10 @@ commands:
     usage: /tyrant <menu|status|choices|buy|assign|item|intelligence|optout|optin|relinquish confirm>
   vigilante:
     description: Manage Vigilante Followers.
-    usage: /vigilante <invite <player>|accept|dismiss <player>|leave>
+    usage: /vigilante <menu|item|invite <player>|accept|dismiss <player>|leave>
   tyrantadmin:
     description: Administer the Spigot Tyrant game.
-    usage: /tyrantadmin <status|start|pause|resume|reset confirm>
+    usage: /tyrantadmin <status|start|pause|resume|reset confirm|arena <set|status>>
     permission: spigottyrant.admin
 permissions:
   spigottyrant.admin:

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

@@ -0,0 +1,27 @@
+package games.dmg.spigottyrant;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+import org.junit.jupiter.api.Test;
+
+final class ArenaGeometryTest {
+    private final ArenaLocation center = new ArenaLocation("world", 10.0, 64.0, -5.0, 0.0F, 0.0F);
+
+    @Test
+    void circleUsesHorizontalDistanceAndWorld() {
+        assertTrue(ArenaGeometry.contains(center, 10.0, "world", 16.0, 100.0, 3.0));
+        assertFalse(ArenaGeometry.contains(center, 10.0, "world", 21.0, 64.0, -5.0));
+        assertFalse(ArenaGeometry.contains(center, 10.0, "nether", 10.0, 64.0, -5.0));
+    }
+
+    @Test
+    void outsidePointProjectsBeyondNearestBoundary() {
+        ArenaPoint point = ArenaGeometry.outside(center, 10.0, 10.0, 64.0, -5.0);
+
+        assertEquals(21.0, point.x(), 0.001);
+        assertEquals(64.0, point.y(), 0.001);
+        assertEquals(-5.0, point.z(), 0.001);
+    }
+}

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

@@ -0,0 +1,28 @@
+package games.dmg.spigottyrant;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
+import org.bukkit.configuration.file.YamlConfiguration;
+import org.bukkit.plugin.java.JavaPlugin;
+import org.junit.jupiter.api.Test;
+
+final class BukkitConfigArenaLocationStoreTest {
+    @Test
+    void arenaLocationRoundTripsThroughPluginConfiguration() {
+        JavaPlugin plugin = mock(JavaPlugin.class);
+        YamlConfiguration config = new YamlConfiguration();
+        when(plugin.getConfig()).thenReturn(config);
+        BukkitConfigArenaLocationStore store = new BukkitConfigArenaLocationStore(plugin);
+        ArenaLocation expected = new ArenaLocation(
+            "arena_world", 12.5, 70.0, -4.5, 90.0F, 5.0F
+        );
+
+        store.set(expected);
+
+        assertEquals(expected, store.location().orElseThrow());
+        verify(plugin).saveConfig();
+    }
+}

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

@@ -28,6 +28,21 @@ final class CapturedMobServiceTest {
         assertEquals(java.util.List.of(), released.capturedMobs());
     }
 
+    @Test
+    void tamerMustReleaseHeldMobBeforeCapturingAnother() {
+        PlayerState holding = service.capture(
+            tamer(), UUID.randomUUID(), "COW", "cow-snapshot"
+        );
+
+        IllegalStateException exception = assertThrows(IllegalStateException.class, () ->
+            service.capture(holding, UUID.randomUUID(), "SHEEP", "sheep-snapshot")
+        );
+
+        assertEquals("release the currently captured mob before capturing another",
+            exception.getMessage());
+        assertEquals(1, holding.capturedMobs().size());
+    }
+
     @Test
     void enderDragonCanNeverBeCapturedAndMissingReleaseDoesNotMutate() {
         assertThrows(IllegalArgumentException.class, () -> service.capture(

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

@@ -0,0 +1,63 @@
+package games.dmg.spigottyrant;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
+
+import java.util.List;
+import java.util.Map;
+import java.util.Optional;
+import java.util.UUID;
+import org.bukkit.entity.Player;
+import org.junit.jupiter.api.Test;
+
+final class DefaultCapturedMobCustodyReleaseTest {
+    @Test
+    void legacyExcessReleaseRetainsOneAndAnyFailedExtra() {
+        UUID playerId = UUID.fromString("33333333-3333-3333-3333-333333333333");
+        CapturedMob retained = mob("COW");
+        CapturedMob releasedExtra = mob("SHEEP");
+        CapturedMob deferredExtra = mob("PIG");
+        PlayerState state = new PlayerState(
+            playerId, "Tamer", Optional.empty(), Optional.empty(), TyrantClass.TAMER,
+            Optional.empty(), Map.of(), java.util.Set.of(),
+            List.of(retained, releasedExtra, deferredExtra)
+        );
+        CapturedMobSpawner spawner = mock(CapturedMobSpawner.class);
+        Player player = mock(Player.class);
+        when(spawner.spawn(player, releasedExtra)).thenReturn(true);
+        when(spawner.spawn(player, deferredExtra)).thenReturn(false);
+        DefaultCapturedMobCustodyRelease service = new DefaultCapturedMobCustodyRelease(spawner);
+
+        PlayerState result = service.releaseExcess(player, state, 1);
+
+        assertEquals(List.of(retained, deferredExtra), result.capturedMobs());
+    }
+
+    @Test
+    void removesOnlyCustodyThatSpawnedSuccessfully() {
+        UUID playerId = UUID.fromString("33333333-3333-3333-3333-333333333333");
+        CapturedMob released = mob("COW");
+        CapturedMob deferred = mob("SHEEP");
+        PlayerState state = new PlayerState(
+            playerId, "Former", Optional.empty(), Optional.empty(), TyrantClass.NONE,
+            Optional.empty(), Map.of(), java.util.Set.of(), List.of(released, deferred)
+        );
+        CapturedMobSpawner spawner = mock(CapturedMobSpawner.class);
+        Player player = mock(Player.class);
+        when(spawner.spawn(player, released)).thenReturn(true);
+        when(spawner.spawn(player, deferred)).thenReturn(false);
+        DefaultCapturedMobCustodyRelease service = new DefaultCapturedMobCustodyRelease(spawner);
+
+        PlayerState result = service.releaseAll(player, state);
+
+        assertEquals(List.of(deferred), result.capturedMobs());
+        assertEquals(TyrantClass.NONE, result.tyrantClass());
+    }
+
+    private static CapturedMob mob(String type) {
+        return new CapturedMob(type, Map.of(
+            "capture-id", UUID.randomUUID().toString(), "snapshot", "snapshot-" + type
+        ));
+    }
+}

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

@@ -0,0 +1,67 @@
+package games.dmg.spigottyrant;
+
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.never;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
+import java.time.Duration;
+import java.util.Map;
+import java.util.Optional;
+import java.util.Set;
+import java.util.UUID;
+import org.bukkit.entity.Player;
+import org.junit.jupiter.api.Test;
+
+final class DefaultVigilanteControlPanelTest {
+    @Test
+    void activeVigilanteOpensAuthoritativeOverview() {
+        UUID tyrantId = UUID.fromString("11111111-1111-1111-1111-111111111111");
+        UUID vigilanteId = UUID.fromString("22222222-2222-2222-2222-222222222222");
+        GameState game = game(tyrantId, vigilanteId);
+        PlayerState vigilanteState = PlayerState.newPlayer(vigilanteId, "Vigilante");
+        TyrantStateManager manager = mock(TyrantStateManager.class);
+        when(manager.game()).thenReturn(game);
+        when(manager.players()).thenReturn(Map.of(vigilanteId, vigilanteState));
+        Player vigilante = mock(Player.class);
+        when(vigilante.getUniqueId()).thenReturn(vigilanteId);
+        VigilanteControlPanelRenderer renderer = mock(VigilanteControlPanelRenderer.class);
+        FollowerPresenceProvider presence = mock(FollowerPresenceProvider.class);
+        when(presence.inspect(any(), any())).thenReturn(Map.of());
+        DefaultVigilanteControlPanel panel = new DefaultVigilanteControlPanel(
+            manager, new FollowerService(), renderer, presence, 5, 4
+        );
+
+        panel.open(vigilante);
+
+        verify(renderer).openOverview(org.mockito.ArgumentMatchers.eq(vigilante), any());
+    }
+
+    @Test
+    void nonVigilanteCannotRenderControlPanel() {
+        UUID tyrantId = UUID.fromString("11111111-1111-1111-1111-111111111111");
+        UUID vigilanteId = UUID.fromString("22222222-2222-2222-2222-222222222222");
+        Player other = mock(Player.class);
+        when(other.getUniqueId()).thenReturn(UUID.randomUUID());
+        TyrantStateManager manager = mock(TyrantStateManager.class);
+        when(manager.game()).thenReturn(game(tyrantId, vigilanteId));
+        VigilanteControlPanelRenderer renderer = mock(VigilanteControlPanelRenderer.class);
+        DefaultVigilanteControlPanel panel = new DefaultVigilanteControlPanel(
+            manager, new FollowerService(), renderer, mock(FollowerPresenceProvider.class), 5, 4
+        );
+
+        panel.open(other);
+
+        verify(renderer, never()).openOverview(any(), any());
+        verify(other).sendMessage(org.mockito.ArgumentMatchers.contains("active Vigilante"));
+    }
+
+    private static GameState game(UUID tyrantId, UUID vigilanteId) {
+        return new GameState(
+            GameLifecycle.RUNNING, Optional.of(tyrantId), Optional.of(vigilanteId),
+            Optional.empty(), Optional.empty(), Optional.empty(), Duration.ZERO,
+            0, 0, Set.of()
+        );
+    }
+}

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

@@ -1,6 +1,7 @@
 package games.dmg.spigottyrant;
 
 import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertTrue;
 
 import java.time.Duration;
 import java.util.Map;
@@ -34,6 +35,32 @@ final class FollowerServiceTest {
         assertEquals(TyrantClass.FIXER, accepted.players().get(FOLLOWER).tyrantClass());
     }
 
+    @Test
+    void repeatedInvitationIsRejectedAndPendingInvitationCanBeInspected() {
+        GameState game = game();
+        PlayerState target = PlayerState.newPlayer(FOLLOWER, "Follower");
+        Map<UUID, PlayerState> players = Map.of(FOLLOWER, target);
+
+        FollowerResult first = service.invite(game, players, VIGILANTE, FOLLOWER);
+        FollowerResult repeated = service.invite(game, players, VIGILANTE, FOLLOWER);
+
+        assertEquals(FollowerStatus.INVITED, first.status());
+        assertEquals(FollowerStatus.ALREADY_INVITED, repeated.status());
+        assertTrue(service.invitedPlayerIds(VIGILANTE).contains(FOLLOWER));
+    }
+
+    @Test
+    void existingFollowerCannotReceiveAnotherInvitation() {
+        GameState game = game();
+        PlayerState follower = withFollower(PlayerState.newPlayer(FOLLOWER, "Follower"));
+
+        FollowerResult result = service.invite(
+            game, Map.of(FOLLOWER, follower), VIGILANTE, FOLLOWER
+        );
+
+        assertEquals(FollowerStatus.INELIGIBLE, result.status());
+    }
+
     @Test
     void vigilanteCanDismissAndFollowerCanLeave() {
         GameState game = game();

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

@@ -0,0 +1,102 @@
+package games.dmg.spigottyrant;
+
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.Mockito.doReturn;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.never;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
+import java.util.Map;
+import java.util.Optional;
+import java.util.Set;
+import java.util.UUID;
+import org.bukkit.Server;
+import org.bukkit.entity.Player;
+import org.junit.jupiter.api.Test;
+
+final class FormerTamerReleaseTaskTest {
+    @Test
+    void offlineFormerTamerCustodyRemainsDeferred() {
+        UUID formerId = UUID.fromString("33333333-3333-3333-3333-333333333333");
+        PlayerState former = withMob(PlayerState.newPlayer(formerId, "Former"));
+        TyrantStateManager manager = mock(TyrantStateManager.class);
+        when(manager.players()).thenReturn(Map.of(formerId, former));
+        Server server = mock(Server.class);
+        doReturn(Set.of()).when(server).getOnlinePlayers();
+        CapturedMobCustodyRelease release = mock(CapturedMobCustodyRelease.class);
+
+        new FormerTamerReleaseTask(manager, server, release).run();
+
+        verify(release, never()).releaseAll(any(), any());
+    }
+
+    @Test
+    void safelyReleasesLegacyCustodyAboveOneForActiveTamer() {
+        UUID tamerId = UUID.fromString("44444444-4444-4444-4444-444444444444");
+        PlayerState once = withMob(withClass(
+            PlayerState.newPlayer(tamerId, "Tamer"), TyrantClass.TAMER
+        ));
+        PlayerState legacy = withMob(once);
+        TyrantStateManager manager = mock(TyrantStateManager.class);
+        when(manager.players()).thenReturn(Map.of(tamerId, legacy));
+        Player tamer = mock(Player.class);
+        when(tamer.getUniqueId()).thenReturn(tamerId);
+        Server server = mock(Server.class);
+        doReturn(Set.of(tamer)).when(server).getOnlinePlayers();
+        CapturedMobCustodyRelease release = mock(CapturedMobCustodyRelease.class);
+        when(release.releaseExcess(tamer, legacy, 1)).thenReturn(legacy);
+
+        new FormerTamerReleaseTask(manager, server, release).run();
+
+        verify(release).releaseExcess(tamer, legacy, 1);
+        verify(release, never()).releaseAll(any(), any());
+    }
+
+    @Test
+    void releasesCustodyOnlyAfterPlayerLosesTamerClass() {
+        UUID formerId = UUID.fromString("33333333-3333-3333-3333-333333333333");
+        UUID tamerId = UUID.fromString("44444444-4444-4444-4444-444444444444");
+        PlayerState former = withMob(PlayerState.newPlayer(formerId, "Former"));
+        PlayerState tamer = withMob(withClass(
+            PlayerState.newPlayer(tamerId, "Tamer"), TyrantClass.TAMER
+        ));
+        TyrantStateManager manager = mock(TyrantStateManager.class);
+        when(manager.players()).thenReturn(Map.of(formerId, former, tamerId, tamer));
+        Player formerPlayer = mock(Player.class);
+        when(formerPlayer.getUniqueId()).thenReturn(formerId);
+        Player tamerPlayer = mock(Player.class);
+        when(tamerPlayer.getUniqueId()).thenReturn(tamerId);
+        Server server = mock(Server.class);
+        doReturn(Set.of(formerPlayer, tamerPlayer)).when(server).getOnlinePlayers();
+        CapturedMobCustodyRelease release = mock(CapturedMobCustodyRelease.class);
+        when(release.releaseAll(formerPlayer, former)).thenReturn(former);
+        FormerTamerReleaseTask task = new FormerTamerReleaseTask(manager, server, release);
+
+        task.run();
+
+        verify(release).releaseAll(formerPlayer, former);
+        verify(release, never()).releaseAll(tamerPlayer, tamer);
+    }
+
+    private static PlayerState withMob(PlayerState player) {
+        CapturedMob mob = new CapturedMob("COW", Map.of(
+            "capture-id", UUID.randomUUID().toString(), "snapshot", "snapshot"
+        ));
+        java.util.List<CapturedMob> custody = new java.util.ArrayList<>(player.capturedMobs());
+        custody.add(mob);
+        return new PlayerState(
+            player.playerId(), player.latestName(), player.lastLogin(), player.optedOutUntil(),
+            player.tyrantClass(), player.followerOf(), player.cooldownEnds(),
+            player.readyAbilityItems(), custody
+        );
+    }
+
+    private static PlayerState withClass(PlayerState player, TyrantClass tyrantClass) {
+        return new PlayerState(
+            player.playerId(), player.latestName(), player.lastLogin(), player.optedOutUntil(),
+            tyrantClass, player.followerOf(), player.cooldownEnds(),
+            player.readyAbilityItems(), player.capturedMobs()
+        );
+    }
+}

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

@@ -24,6 +24,10 @@ final class PluginSettingsTest {
         assertEquals(Duration.ofHours(1), settings.fixerCooldown());
         assertEquals(Duration.ofMinutes(10), settings.fixerEffectDuration());
         assertEquals(Duration.ofHours(24), settings.rosterIntelligenceCooldown());
+        assertEquals(10.0, settings.vigilanteArenaRadiusBlocks());
+        assertEquals(80.0, settings.vigilanteBossHealth());
+        assertEquals(8.0, settings.vigilanteBossDamage());
+        assertEquals(10.0, settings.vigilanteBossArmor());
     }
 
     @Test
@@ -43,6 +47,10 @@ final class PluginSettingsTest {
         assertEquals("STICK", settings.assassinItem().material());
         assertEquals("Assassin Cloak", settings.assassinItem().name());
         assertEquals("FISHING_ROD", settings.tamerItem().material());
+        assertEquals("NETHER_STAR", settings.tyrantControlItem().material());
+        assertEquals("Tyrant Control", settings.tyrantControlItem().name());
+        assertEquals("COMPASS", settings.vigilanteControlItem().material());
+        assertEquals("Vigilante Control", settings.vigilanteControlItem().name());
         assertEquals("/tyrant item", settings.recoveryCommand());
         assertEquals("Your inventory is full. Make room and use /tyrant item.",
             settings.inventoryFullMessage());
@@ -63,5 +71,17 @@ final class PluginSettingsTest {
             IllegalArgumentException.class,
             () -> PluginSettings.from(Map.of("role-inactivity-seconds", -1))
         );
+        assertThrows(
+            IllegalArgumentException.class,
+            () -> PluginSettings.from(Map.of("vigilante-arena-radius-blocks", 0))
+        );
+        assertThrows(
+            IllegalArgumentException.class,
+            () -> PluginSettings.from(Map.of("vigilante-boss-health", Double.NaN))
+        );
+        assertThrows(
+            IllegalArgumentException.class,
+            () -> PluginSettings.from(Map.of("vigilante-boss-armor", 31))
+        );
     }
 }

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

@@ -0,0 +1,89 @@
+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.util.Optional;
+import java.util.Set;
+import java.util.UUID;
+import org.bukkit.entity.Item;
+import org.bukkit.entity.Player;
+import org.bukkit.event.block.Action;
+import org.bukkit.event.inventory.InventoryMoveItemEvent;
+import org.bukkit.event.player.PlayerDropItemEvent;
+import org.bukkit.event.player.PlayerInteractEvent;
+import org.bukkit.inventory.ItemStack;
+import org.junit.jupiter.api.Test;
+
+final class RoleControlItemListenerTest {
+    @Test
+    void droppedRoleControlItemVanishes() {
+        ItemStack item = mock(ItemStack.class);
+        Item dropped = mock(Item.class);
+        when(dropped.getItemStack()).thenReturn(item);
+        PlayerDropItemEvent event = mock(PlayerDropItemEvent.class);
+        when(event.getItemDrop()).thenReturn(dropped);
+        RoleControlItemService items = mock(RoleControlItemService.class);
+        when(items.isBoundRoleControlItem(item)).thenReturn(true);
+        RoleControlItemListener listener = listener(items);
+
+        listener.onDrop(event);
+
+        verify(dropped).remove();
+    }
+
+    @Test
+    void automatedInventoryTransferIsBlocked() {
+        ItemStack item = mock(ItemStack.class);
+        InventoryMoveItemEvent event = mock(InventoryMoveItemEvent.class);
+        when(event.getItem()).thenReturn(item);
+        RoleControlItemService items = mock(RoleControlItemService.class);
+        when(items.isBoundRoleControlItem(item)).thenReturn(true);
+        RoleControlItemListener listener = listener(items);
+
+        listener.onInventoryMove(event);
+
+        verify(event).setCancelled(true);
+    }
+
+    @Test
+    void currentTyrantUsesBoundItemToOpenControlPanel() {
+        UUID tyrantId = UUID.fromString("11111111-1111-1111-1111-111111111111");
+        GameState game = new GameState(
+            GameLifecycle.RUNNING, Optional.of(tyrantId), Optional.empty(),
+            Optional.empty(), Optional.empty(), Optional.empty(), Duration.ZERO,
+            0, 0, Set.of()
+        );
+        TyrantStateManager manager = mock(TyrantStateManager.class);
+        when(manager.game()).thenReturn(game);
+        Player tyrant = mock(Player.class);
+        when(tyrant.getUniqueId()).thenReturn(tyrantId);
+        ItemStack item = mock(ItemStack.class);
+        PlayerInteractEvent event = mock(PlayerInteractEvent.class);
+        when(event.getPlayer()).thenReturn(tyrant);
+        when(event.getItem()).thenReturn(item);
+        when(event.getAction()).thenReturn(Action.RIGHT_CLICK_AIR);
+        RoleControlItemService items = mock(RoleControlItemService.class);
+        when(items.isBoundRoleControlItem(item)).thenReturn(true);
+        when(items.owner(item)).thenReturn(Optional.of(tyrantId));
+        when(items.role(item)).thenReturn(Optional.of(RoleControl.TYRANT));
+        TyrantControlPanel tyrantPanel = mock(TyrantControlPanel.class);
+        RoleControlItemListener listener = new RoleControlItemListener(
+            manager, items, tyrantPanel, mock(VigilanteControlPanel.class)
+        );
+
+        listener.onInteract(event);
+
+        verify(event).setCancelled(true);
+        verify(tyrantPanel).open(tyrant);
+    }
+
+    private static RoleControlItemListener listener(RoleControlItemService items) {
+        return new RoleControlItemListener(
+            mock(TyrantStateManager.class), items, mock(TyrantControlPanel.class),
+            mock(VigilanteControlPanel.class)
+        );
+    }
+}

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

@@ -0,0 +1,41 @@
+package games.dmg.spigottyrant;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+import java.time.Duration;
+import java.util.Optional;
+import java.util.Set;
+import java.util.UUID;
+import org.junit.jupiter.api.Test;
+
+final class RoleControlItemPolicyTest {
+    @Test
+    void runningRoleHoldersRequireOnlyTheirOwnControlItem() {
+        UUID tyrantId = UUID.fromString("11111111-1111-1111-1111-111111111111");
+        UUID vigilanteId = UUID.fromString("22222222-2222-2222-2222-222222222222");
+        GameState game = new GameState(
+            GameLifecycle.RUNNING, Optional.of(tyrantId), Optional.of(vigilanteId),
+            Optional.empty(), Optional.empty(), Optional.empty(), Duration.ZERO,
+            0, 0, Set.of()
+        );
+
+        assertEquals(Optional.of(RoleControl.TYRANT),
+            RoleControlItemPolicy.requiredRole(game, tyrantId));
+        assertEquals(Optional.of(RoleControl.VIGILANTE),
+            RoleControlItemPolicy.requiredRole(game, vigilanteId));
+        assertEquals(Optional.empty(), RoleControlItemPolicy.requiredRole(game, UUID.randomUUID()));
+    }
+
+    @Test
+    void pausedRoleHolderRetainsControlItem() {
+        UUID tyrantId = UUID.fromString("11111111-1111-1111-1111-111111111111");
+        GameState game = new GameState(
+            GameLifecycle.PAUSED, Optional.of(tyrantId), Optional.empty(),
+            Optional.empty(), Optional.empty(), Optional.of(java.time.Instant.EPOCH),
+            Duration.ZERO, 0, 0, Set.of()
+        );
+
+        assertEquals(Optional.of(RoleControl.TYRANT),
+            RoleControlItemPolicy.requiredRole(game, tyrantId));
+    }
+}

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

@@ -0,0 +1,37 @@
+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.util.Optional;
+import java.util.Set;
+import java.util.UUID;
+import org.bukkit.Server;
+import org.bukkit.entity.Player;
+import org.junit.jupiter.api.Test;
+
+final class RoleControlItemRefreshTaskTest {
+    @Test
+    void reconciliationRemovesInvalidCopiesAndRecoversRequiredRoleItem() {
+        UUID tyrantId = UUID.fromString("11111111-1111-1111-1111-111111111111");
+        GameState game = new GameState(
+            GameLifecycle.RUNNING, Optional.of(tyrantId), Optional.empty(),
+            Optional.empty(), Optional.empty(), Optional.empty(), Duration.ZERO,
+            0, 0, Set.of()
+        );
+        TyrantStateManager manager = mock(TyrantStateManager.class);
+        when(manager.game()).thenReturn(game);
+        Player tyrant = mock(Player.class);
+        Server server = mock(Server.class);
+        doReturn(Set.of(tyrant)).when(server).getOnlinePlayers();
+        RoleControlItemService items = mock(RoleControlItemService.class);
+
+        new RoleControlItemRefreshTask(manager, items, server).run();
+
+        verify(items).removeInvalid(tyrant, game);
+        verify(items).recover(tyrant, game);
+    }
+}

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

@@ -32,7 +32,7 @@ final class RoleMaintenanceServiceTest {
     );
 
     @Test
-    void onlinePendingVigilanteConfirmsWithoutConflictingWithTyrant() {
+    void legacyPendingVigilanteIsClearedForArenaSuccession() {
         GameState game = game(
             Optional.of(TYRANT), Optional.empty(), Optional.empty(),
             Optional.of(new PendingSelection(CANDIDATE, NOW.plusSeconds(60)))
@@ -43,12 +43,12 @@ final class RoleMaintenanceServiceTest {
 
         LifecycleState maintained = service.maintain(state, Set.of(TYRANT, CANDIDATE), NOW);
 
-        assertEquals(Optional.of(CANDIDATE), maintained.game().vigilanteId());
+        assertEquals(Optional.empty(), maintained.game().vigilanteId());
         assertEquals(Optional.empty(), maintained.game().pendingVigilante());
     }
 
     @Test
-    void expiredPendingSelectionRerollsAwayFromPreviousCandidate() {
+    void expiredLegacyPendingVigilanteOpensArenaInsteadOfRerolling() {
         GameState game = game(
             Optional.of(TYRANT), Optional.empty(), Optional.empty(),
             Optional.of(new PendingSelection(CANDIDATE, NOW.minusSeconds(1)))
@@ -59,12 +59,12 @@ final class RoleMaintenanceServiceTest {
 
         LifecycleState maintained = service.maintain(state, Set.of(TYRANT), NOW);
 
-        assertEquals(OTHER,
-            maintained.game().pendingVigilante().orElseThrow().candidateId());
+        assertEquals(Optional.empty(), maintained.game().vigilanteId());
+        assertEquals(Optional.empty(), maintained.game().pendingVigilante());
     }
 
     @Test
-    void inactiveVigilanteIsRerolledAndFollowersAreCleared() {
+    void inactiveVigilanteOpensArenaAndFollowersAreCleared() {
         PlayerState follower = withFollower(
             withLogin(active(FOLLOWER), NOW.minus(Duration.ofHours(25))),
             VIGILANTE
@@ -80,7 +80,7 @@ final class RoleMaintenanceServiceTest {
 
         LifecycleState maintained = service.maintain(state, Set.of(TYRANT, OTHER), NOW);
 
-        assertEquals(Optional.of(OTHER), maintained.game().vigilanteId());
+        assertEquals(Optional.empty(), maintained.game().vigilanteId());
         assertEquals(Optional.empty(), maintained.players().get(FOLLOWER).followerOf());
         assertEquals(Optional.of(TYRANT), maintained.game().tyrantId());
     }

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

@@ -13,7 +13,7 @@ import org.junit.jupiter.api.Test;
 
 final class RoleRelinquishmentServiceTest {
     @Test
-    void vigilanteCanRelinquishAndTriggerNormalReroll() {
+    void vigilanteCanRelinquishAndOpenArenaChallenge() {
         UUID tyrant = UUID.fromString("11111111-1111-1111-1111-111111111111");
         UUID vigilante = UUID.fromString("22222222-2222-2222-2222-222222222222");
         UUID candidate = UUID.fromString("33333333-3333-3333-3333-333333333333");
@@ -49,7 +49,8 @@ final class RoleRelinquishmentServiceTest {
         );
 
         assertEquals(RelinquishmentStatus.RELINQUISHED, result.status());
-        assertEquals(Optional.of(candidate), result.state().game().vigilanteId());
+        assertEquals(Optional.empty(), result.state().game().vigilanteId());
+        assertEquals(Optional.empty(), result.state().game().pendingVigilante());
     }
 
     private static PlayerState active(UUID id, Instant now) {

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

@@ -0,0 +1,66 @@
+package games.dmg.spigottyrant;
+
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.never;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
+import java.util.Map;
+import java.util.Optional;
+import java.util.Set;
+import java.util.UUID;
+import org.bukkit.Server;
+import org.bukkit.entity.Entity;
+import org.bukkit.entity.Player;
+import org.bukkit.event.player.PlayerInteractEntityEvent;
+import org.bukkit.inventory.ItemStack;
+import org.bukkit.inventory.PlayerInventory;
+import org.junit.jupiter.api.Test;
+
+final class TamerListenerTest {
+    @Test
+    void heldMobRejectsAnotherCaptureBeforeTargetOrInventoryChanges() {
+        UUID playerId = UUID.fromString("33333333-3333-3333-3333-333333333333");
+        CapturedMob heldMob = new CapturedMob("COW", Map.of(
+            "capture-id", UUID.randomUUID().toString(), "snapshot", "cow"
+        ));
+        PlayerState state = new PlayerState(
+            playerId, "Tamer", Optional.empty(), Optional.empty(), TyrantClass.TAMER,
+            Optional.empty(), Map.of(), Set.of(Ability.TAMER_CAPTURE),
+            java.util.List.of(heldMob)
+        );
+        Player player = mock(Player.class);
+        when(player.getUniqueId()).thenReturn(playerId);
+        when(player.getName()).thenReturn("Tamer");
+        PlayerInventory inventory = mock(PlayerInventory.class);
+        when(player.getInventory()).thenReturn(inventory);
+        ItemStack lead = mock(ItemStack.class);
+        when(inventory.getItem(org.bukkit.inventory.EquipmentSlot.HAND)).thenReturn(lead);
+        Entity target = mock(Entity.class);
+        PlayerInteractEntityEvent event = mock(PlayerInteractEntityEvent.class);
+        when(event.getPlayer()).thenReturn(player);
+        when(event.getHand()).thenReturn(org.bukkit.inventory.EquipmentSlot.HAND);
+        when(event.getRightClicked()).thenReturn(target);
+        AbilityItemService abilityItems = mock(AbilityItemService.class);
+        when(abilityItems.ability(lead)).thenReturn(Optional.of(Ability.TAMER_CAPTURE));
+        when(abilityItems.owner(lead)).thenReturn(Optional.of(playerId));
+        TyrantStateManager manager = mock(TyrantStateManager.class);
+        when(manager.player(playerId, "Tamer")).thenReturn(state);
+        CapturedMobItemService capturedItems = mock(CapturedMobItemService.class);
+        TamerListener listener = new TamerListener(
+            manager, abilityItems, capturedItems, new CapturedMobService(),
+            PluginSettings.from(Map.of()), mock(Server.class)
+        );
+
+        listener.onCapture(event);
+
+        verify(player).sendMessage(org.mockito.ArgumentMatchers.contains(
+            "Release the currently captured mob"
+        ));
+        verify(target, never()).createSnapshot();
+        verify(capturedItems, never()).create(
+            org.mockito.ArgumentMatchers.any(), org.mockito.ArgumentMatchers.any(),
+            org.mockito.ArgumentMatchers.anyString()
+        );
+    }
+}

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

@@ -14,8 +14,11 @@ import java.util.Map;
 import java.util.Optional;
 import java.util.Set;
 import java.util.UUID;
+import org.bukkit.Location;
+import org.bukkit.World;
 import org.bukkit.command.Command;
 import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
 import org.junit.jupiter.api.Test;
 
 final class TyrantAdminCommandTest {
@@ -59,6 +62,30 @@ final class TyrantAdminCommandTest {
         verify(effects).suppressAll();
     }
 
+    @Test
+    void playerCanPersistArenaAtCurrentLocation() {
+        TyrantStateManager manager = mock(TyrantStateManager.class);
+        Player sender = mock(Player.class);
+        World world = mock(World.class);
+        when(sender.hasPermission("spigottyrant.admin")).thenReturn(true);
+        when(world.getName()).thenReturn("arena_world");
+        when(sender.getLocation()).thenReturn(new Location(world, 12.5, 70.0, -4.5, 90.0F, 0.0F));
+        ArenaLocationStore store = mock(ArenaLocationStore.class);
+        TyrantAdminCommand command = new TyrantAdminCommand(
+            manager, new GameLifecycleService(), mock(OnlinePlayerDirectory.class),
+            mock(ManagedRoleEffects.class),
+            Clock.fixed(Instant.parse("2026-08-14T12:00:00Z"), ZoneOffset.UTC), store
+        );
+
+        command.onCommand(sender, mock(Command.class), "tyrantadmin", new String[] {"arena", "set"});
+
+        verify(store).set(org.mockito.ArgumentMatchers.argThat(location ->
+            location.worldName().equals("arena_world")
+                && location.x() == 12.5 && location.y() == 70.0 && location.z() == -4.5
+        ));
+        verify(sender).sendMessage(contains("Vigilante arena set"));
+    }
+
     @Test
     void resetRequiresExplicitConfirmation() {
         TyrantStateManager manager = mock(TyrantStateManager.class);

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

@@ -0,0 +1,60 @@
+package games.dmg.spigottyrant;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
+
+import java.util.Set;
+import java.util.UUID;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+import org.junit.jupiter.api.Test;
+
+final class TyrantAdminTabCompleterTest {
+    @Test
+    void permissionGatesAdministrativeSyntaxAndOnlineCandidates() {
+        UUID alphaId = UUID.fromString("11111111-1111-1111-1111-111111111111");
+        UUID betaId = UUID.fromString("22222222-2222-2222-2222-222222222222");
+        Player alpha = player(alphaId, "Alpha");
+        Player beta = player(betaId, "Beta");
+        OnlinePlayerDirectory directory = mock(OnlinePlayerDirectory.class);
+        when(directory.onlinePlayerIds()).thenReturn(Set.of(alphaId, betaId));
+        when(directory.findById(alphaId)).thenReturn(alpha);
+        when(directory.findById(betaId)).thenReturn(beta);
+        TyrantAdminTabCompleter completer = new TyrantAdminTabCompleter(directory);
+        Command command = mock(Command.class);
+        CommandSender denied = mock(CommandSender.class);
+        CommandSender admin = mock(CommandSender.class);
+        when(admin.hasPermission("spigottyrant.admin")).thenReturn(true);
+
+        assertEquals(java.util.List.of(), completer.onTabComplete(
+            denied, command, "tyrantadmin", new String[] {""}
+        ));
+        assertTrue(completer.onTabComplete(
+            admin, command, "tyrantadmin", new String[] {""}
+        ).containsAll(java.util.List.of(
+            "status", "start", "pause", "resume", "reset", "arena"
+        )));
+        assertEquals(java.util.List.of("Alpha", "Beta"), completer.onTabComplete(
+            admin, command, "tyrantadmin", new String[] {"start", ""}
+        ));
+        assertEquals(java.util.List.of("Beta"), completer.onTabComplete(
+            admin, command, "tyrantadmin", new String[] {"start", "Alpha", ""}
+        ));
+        assertEquals(java.util.List.of("confirm"), completer.onTabComplete(
+            admin, command, "tyrantadmin", new String[] {"reset", "c"}
+        ));
+        assertEquals(java.util.List.of("set", "status"), completer.onTabComplete(
+            admin, command, "tyrantadmin", new String[] {"arena", "s"}
+        ));
+    }
+
+    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;
+    }
+}

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

@@ -43,6 +43,28 @@ final class TyrantCommandTest {
         verify(controlPanel, org.mockito.Mockito.times(2)).open(tyrant);
     }
 
+    @Test
+    void itemCommandRecoversTyrantRoleControlItem() {
+        UUID tyrantId = UUID.fromString("11111111-1111-1111-1111-111111111111");
+        GameState game = new GameState(
+            GameLifecycle.RUNNING, Optional.of(tyrantId), Optional.empty(),
+            Optional.empty(), Optional.empty(), Optional.empty(), Duration.ZERO,
+            0, 0, Set.of()
+        );
+        TyrantStateManager manager = mock(TyrantStateManager.class);
+        when(manager.game()).thenReturn(game);
+        Player tyrant = mock(Player.class);
+        when(tyrant.getUniqueId()).thenReturn(tyrantId);
+        RoleControlItemService roleItems = mock(RoleControlItemService.class);
+        TyrantCommand command = new TyrantCommand(
+            manager, new TyrantProgressionService(), mock(TyrantControlPanel.class), roleItems
+        );
+
+        command.onCommand(tyrant, mock(Command.class), "tyrant", new String[] {"item"});
+
+        verify(roleItems).recover(tyrant, game);
+    }
+
     @Test
     void choicesClearlyIdentifyPurchasedAvailableAndUnavailableUnlocks() {
         UUID tyrantId = UUID.fromString("11111111-1111-1111-1111-111111111111");

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

@@ -37,7 +37,8 @@ final class TyrantSuccessionServiceTest {
         assertEquals(0, after.game().tyrantLevel());
         assertEquals(1, after.game().unspentChoices());
         assertEquals(Set.of(), after.game().purchases());
-        assertNotEquals(after.game().tyrantId(), after.game().vigilanteId());
+        assertEquals(Optional.empty(), after.game().vigilanteId());
+        assertEquals(Optional.empty(), after.game().pendingVigilante());
         for (PlayerState player : after.players().values()) {
             assertEquals(TyrantClass.NONE, player.tyrantClass());
             assertEquals(Optional.empty(), player.followerOf());

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

@@ -0,0 +1,41 @@
+package games.dmg.spigottyrant;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+import static org.mockito.Mockito.mock;
+
+import java.util.List;
+import org.bukkit.command.Command;
+import org.bukkit.entity.Player;
+import org.junit.jupiter.api.Test;
+
+final class TyrantTabCompleterTest {
+    @Test
+    void rootBuyAssignAndConfirmationSuggestionsFollowSyntaxAndPrefix() {
+        TyrantTabCompleter completer = new TyrantTabCompleter(
+            mock(TyrantStateManager.class), mock(OnlinePlayerDirectory.class)
+        );
+        Player player = mock(Player.class);
+        Command command = mock(Command.class);
+
+        List<String> root = completer.onTabComplete(
+            player, command, "tyrant", new String[] {""}
+        );
+        List<String> buy = completer.onTabComplete(
+            player, command, "tyrant", new String[] {"buy", "ro"}
+        );
+        List<String> assign = completer.onTabComplete(
+            player, command, "tyrant", new String[] {"assign", "f"}
+        );
+        List<String> confirm = completer.onTabComplete(
+            player, command, "tyrant", new String[] {"relinquish", "c"}
+        );
+
+        assertTrue(root.containsAll(List.of("menu", "status", "buy", "assign", "item")));
+        assertFalse(root.contains("SomePlayer"));
+        assertEquals(List.of("roster_intelligence"), buy);
+        assertEquals(List.of("fixer"), assign);
+        assertEquals(List.of("confirm"), confirm);
+    }
+}

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

@@ -0,0 +1,56 @@
+package games.dmg.spigottyrant;
+
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.anyInt;
+import static org.mockito.Mockito.atLeastOnce;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.never;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
+import org.bukkit.Location;
+import org.bukkit.Material;
+import org.bukkit.World;
+import org.bukkit.block.Block;
+import org.bukkit.block.data.BlockData;
+import org.junit.jupiter.api.Test;
+
+final class VigilanteArenaBarrierTest {
+    private static final ArenaLocation CENTER = new ArenaLocation(
+        "world", 0.0, 64.0, 0.0, 0.0F, 0.0F
+    );
+
+    @Test
+    void doesNotReplaceExistingNonAirBlocks() {
+        World world = mock(World.class);
+        Block solid = mock(Block.class);
+        when(world.getBlockAt(anyInt(), anyInt(), anyInt())).thenReturn(solid);
+        when(solid.getLocation()).thenReturn(new Location(world, 1.0, 64.0, 0.0));
+        when(solid.getType()).thenReturn(Material.CHEST);
+
+        new VigilanteArenaBarrier().build(world, CENTER, 10.0);
+
+        verify(solid, never()).setType(Material.BARRIER, false);
+    }
+
+    @Test
+    void restoresAirReplacedByTemporaryBarrier() {
+        World world = mock(World.class);
+        Block air = mock(Block.class);
+        BlockData original = mock(BlockData.class);
+        BlockData snapshot = mock(BlockData.class);
+        when(world.getBlockAt(anyInt(), anyInt(), anyInt())).thenReturn(air);
+        when(world.getBlockAt(any(Location.class))).thenReturn(air);
+        when(air.getLocation()).thenReturn(new Location(world, 1.0, 64.0, 0.0));
+        when(air.getType()).thenReturn(Material.AIR);
+        when(air.getBlockData()).thenReturn(original);
+        when(original.clone()).thenReturn(snapshot);
+        VigilanteArenaBarrier barrier = new VigilanteArenaBarrier();
+
+        barrier.build(world, CENTER, 10.0);
+        barrier.clear();
+
+        verify(air, atLeastOnce()).setType(Material.BARRIER, false);
+        verify(air).setBlockData(snapshot, false);
+    }
+}

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

@@ -0,0 +1,80 @@
+package games.dmg.spigottyrant;
+
+import static org.mockito.ArgumentMatchers.contains;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.never;
+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.Server;
+import org.bukkit.entity.Player;
+import org.bukkit.event.player.PlayerJoinEvent;
+import org.junit.jupiter.api.Test;
+
+final class VigilanteArenaControllerTest {
+    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 optedInPlayerJoiningDuringVacancyReceivesArenaCoordinates() {
+        Player player = mock(Player.class);
+        when(player.getUniqueId()).thenReturn(PLAYER);
+        TyrantStateManager manager = mock(TyrantStateManager.class);
+        when(manager.game()).thenReturn(openGame());
+        when(manager.players()).thenReturn(Map.of(PLAYER, PlayerState.newPlayer(PLAYER, "Player")));
+        ArenaLocationStore locations = mock(ArenaLocationStore.class);
+        when(locations.location()).thenReturn(Optional.of(
+            new ArenaLocation("world", 10.0, 64.0, -5.0, 0.0F, 0.0F)
+        ));
+        VigilanteArenaController controller = new VigilanteArenaController(
+            manager, mock(Server.class), locations, PluginSettings.from(Map.of())
+        );
+
+        controller.onJoin(mockJoin(player));
+
+        verify(player).sendMessage(contains("world at 10, 64, -5"));
+    }
+
+    @Test
+    void optedOutPlayerDoesNotReceiveVacancyNotice() {
+        Player player = mock(Player.class);
+        when(player.getUniqueId()).thenReturn(PLAYER);
+        PlayerState optedOut = new PlayerState(
+            PLAYER, "Player", Optional.empty(), Optional.of(Instant.parse("2026-08-24T00:00:00Z")),
+            TyrantClass.NONE, Optional.empty(), Map.of(), Set.of(), java.util.List.of()
+        );
+        TyrantStateManager manager = mock(TyrantStateManager.class);
+        when(manager.game()).thenReturn(openGame());
+        when(manager.players()).thenReturn(Map.of(PLAYER, optedOut));
+        ArenaLocationStore locations = mock(ArenaLocationStore.class);
+        when(locations.location()).thenReturn(Optional.of(
+            new ArenaLocation("world", 10.0, 64.0, -5.0, 0.0F, 0.0F)
+        ));
+        VigilanteArenaController controller = new VigilanteArenaController(
+            manager, mock(Server.class), locations, PluginSettings.from(Map.of())
+        );
+
+        controller.onJoin(mockJoin(player));
+
+        verify(player, never()).sendMessage(org.mockito.ArgumentMatchers.anyString());
+    }
+
+    private static PlayerJoinEvent mockJoin(Player player) {
+        PlayerJoinEvent event = mock(PlayerJoinEvent.class);
+        when(event.getPlayer()).thenReturn(player);
+        return event;
+    }
+
+    private static GameState openGame() {
+        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/VigilanteArenaPolicyTest.java

@@ -0,0 +1,61 @@
+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 VigilanteArenaPolicyTest {
+    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 opensOnlyForRunningGameWithTyrantAndVacantVigilante() {
+        assertTrue(VigilanteArenaPolicy.isOpen(game(
+            GameLifecycle.RUNNING, Optional.of(TYRANT), Optional.empty()
+        )));
+        assertFalse(VigilanteArenaPolicy.isOpen(game(
+            GameLifecycle.PAUSED, Optional.of(TYRANT), Optional.empty()
+        )));
+        assertFalse(VigilanteArenaPolicy.isOpen(game(
+            GameLifecycle.RUNNING, Optional.empty(), Optional.empty()
+        )));
+        assertFalse(VigilanteArenaPolicy.isOpen(game(
+            GameLifecycle.RUNNING, Optional.of(TYRANT), Optional.of(PLAYER)
+        )));
+    }
+
+    @Test
+    void onlyOptedInNonTyrantMayChallenge() {
+        GameState game = game(GameLifecycle.RUNNING, Optional.of(TYRANT), Optional.empty());
+        PlayerState eligible = PlayerState.newPlayer(PLAYER, "Player");
+        PlayerState optedOut = new PlayerState(
+            PLAYER, "Player", Optional.empty(), Optional.of(Instant.parse("2026-08-24T12:00:00Z")),
+            TyrantClass.NONE, Optional.empty(), Map.of(), Set.of(), java.util.List.of()
+        );
+
+        assertTrue(VigilanteArenaPolicy.isEligible(game, eligible));
+        assertFalse(VigilanteArenaPolicy.isEligible(game, optedOut));
+        assertFalse(VigilanteArenaPolicy.isEligible(game,
+            PlayerState.newPlayer(TYRANT, "Tyrant")));
+    }
+
+    private static GameState game(
+        GameLifecycle lifecycle,
+        Optional<UUID> tyrant,
+        Optional<UUID> vigilante
+    ) {
+        return new GameState(
+            lifecycle, tyrant, vigilante, Optional.empty(), Optional.empty(),
+            lifecycle == GameLifecycle.PAUSED
+                ? Optional.of(Instant.parse("2026-08-23T12:00:00Z")) : Optional.empty(),
+            Duration.ZERO, 0, 0, Set.of()
+        );
+    }
+}

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

@@ -0,0 +1,30 @@
+package games.dmg.spigottyrant;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+import java.time.Duration;
+import java.util.Map;
+import java.util.Optional;
+import java.util.Set;
+import java.util.UUID;
+import org.junit.jupiter.api.Test;
+
+final class VigilanteArenaSuccessionServiceTest {
+    @Test
+    void eligibleBossWinnerClaimsVacantVigilanteRole() {
+        UUID tyrant = UUID.fromString("11111111-1111-1111-1111-111111111111");
+        UUID winner = UUID.fromString("22222222-2222-2222-2222-222222222222");
+        GameState game = new GameState(
+            GameLifecycle.RUNNING, Optional.of(tyrant), Optional.empty(), Optional.empty(),
+            Optional.empty(), Optional.empty(), Duration.ZERO, 0, 0, Set.of()
+        );
+        PersistentState before = new PersistentState(
+            game, Map.of(winner, PlayerState.newPlayer(winner, "Winner"))
+        );
+
+        LifecycleState claimed = new VigilanteArenaSuccessionService().claim(before, winner);
+
+        assertEquals(Optional.of(winner), claimed.game().vigilanteId());
+        assertEquals(Optional.empty(), claimed.game().pendingVigilante());
+    }
+}

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

@@ -0,0 +1,59 @@
+package games.dmg.spigottyrant;
+
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.times;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
+import java.time.Duration;
+import java.util.Optional;
+import java.util.Set;
+import java.util.UUID;
+import org.bukkit.command.Command;
+import org.bukkit.entity.Player;
+import org.junit.jupiter.api.Test;
+
+final class VigilanteCommandTest {
+    @Test
+    void itemCommandRecoversVigilanteRoleControlItem() {
+        UUID vigilanteId = UUID.fromString("22222222-2222-2222-2222-222222222222");
+        GameState game = new GameState(
+            GameLifecycle.RUNNING,
+            Optional.of(UUID.fromString("11111111-1111-1111-1111-111111111111")),
+            Optional.of(vigilanteId), Optional.empty(), Optional.empty(), Optional.empty(),
+            Duration.ZERO, 0, 0, Set.of()
+        );
+        TyrantStateManager manager = mock(TyrantStateManager.class);
+        when(manager.game()).thenReturn(game);
+        Player vigilante = mock(Player.class);
+        when(vigilante.getUniqueId()).thenReturn(vigilanteId);
+        RoleControlItemService roleItems = mock(RoleControlItemService.class);
+        VigilanteCommand command = new VigilanteCommand(
+            manager, new FollowerService(), mock(OnlinePlayerDirectory.class),
+            mock(VigilanteControlPanel.class), roleItems
+        );
+
+        command.onCommand(vigilante, mock(Command.class), "vigilante", new String[] {"item"});
+
+        verify(roleItems).recover(vigilante, game);
+    }
+
+    @Test
+    void playerCanOpenControlPanelWithNoArgumentsOrMenuSubcommand() {
+        UUID playerId = UUID.fromString("22222222-2222-2222-2222-222222222222");
+        Player player = mock(Player.class);
+        when(player.getUniqueId()).thenReturn(playerId);
+        VigilanteControlPanel controlPanel = mock(VigilanteControlPanel.class);
+        VigilanteCommand command = new VigilanteCommand(
+            mock(TyrantStateManager.class),
+            new FollowerService(),
+            mock(OnlinePlayerDirectory.class),
+            controlPanel
+        );
+
+        command.onCommand(player, mock(Command.class), "vigilante", new String[0]);
+        command.onCommand(player, mock(Command.class), "vigilante", new String[] {"menu"});
+
+        verify(controlPanel, times(2)).open(player);
+    }
+}

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

@@ -0,0 +1,80 @@
+package games.dmg.spigottyrant;
+
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.never;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
+import java.time.Duration;
+import java.util.Optional;
+import java.util.Set;
+import java.util.UUID;
+import org.bukkit.entity.Player;
+import org.bukkit.event.player.PlayerJoinEvent;
+import org.junit.jupiter.api.Test;
+import org.mockito.ArgumentCaptor;
+
+final class VigilanteControlPanelJoinListenerTest {
+    @Test
+    void opensPanelOneHundredTicksAfterActiveVigilanteJoins() {
+        UUID vigilanteId = UUID.fromString("22222222-2222-2222-2222-222222222222");
+        TyrantStateManager manager = mock(TyrantStateManager.class);
+        when(manager.game()).thenReturn(game(GameLifecycle.RUNNING, vigilanteId));
+        Player vigilante = player(vigilanteId);
+        PlayerJoinEvent event = mock(PlayerJoinEvent.class);
+        when(event.getPlayer()).thenReturn(vigilante);
+        DelayedTaskScheduler scheduler = mock(DelayedTaskScheduler.class);
+        VigilanteControlPanel panel = mock(VigilanteControlPanel.class);
+        VigilanteControlPanelJoinListener listener = new VigilanteControlPanelJoinListener(
+            manager, panel, scheduler
+        );
+
+        listener.onJoin(event);
+
+        ArgumentCaptor<Runnable> task = ArgumentCaptor.forClass(Runnable.class);
+        verify(scheduler).schedule(task.capture(), org.mockito.ArgumentMatchers.eq(100L));
+        task.getValue().run();
+        verify(panel).open(vigilante);
+    }
+
+    @Test
+    void doesNotOpenAfterPauseOrWhenAlreadyOpenedManually() {
+        UUID vigilanteId = UUID.fromString("22222222-2222-2222-2222-222222222222");
+        Player vigilante = player(vigilanteId);
+        PlayerJoinEvent event = mock(PlayerJoinEvent.class);
+        when(event.getPlayer()).thenReturn(vigilante);
+        DelayedTaskScheduler scheduler = mock(DelayedTaskScheduler.class);
+        VigilanteControlPanel panel = mock(VigilanteControlPanel.class);
+        when(panel.openedThisSession(vigilanteId)).thenReturn(true);
+        TyrantStateManager manager = mock(TyrantStateManager.class);
+        when(manager.game()).thenReturn(game(GameLifecycle.PAUSED, vigilanteId));
+        VigilanteControlPanelJoinListener listener = new VigilanteControlPanelJoinListener(
+            manager, panel, scheduler
+        );
+
+        listener.onJoin(event);
+        ArgumentCaptor<Runnable> task = ArgumentCaptor.forClass(Runnable.class);
+        verify(scheduler).schedule(task.capture(), org.mockito.ArgumentMatchers.eq(100L));
+        task.getValue().run();
+
+        verify(panel, never()).open(vigilante);
+    }
+
+    private static Player player(UUID id) {
+        Player player = mock(Player.class);
+        when(player.getUniqueId()).thenReturn(id);
+        when(player.isOnline()).thenReturn(true);
+        return player;
+    }
+
+    private static GameState game(GameLifecycle lifecycle, UUID vigilanteId) {
+        return new GameState(
+            lifecycle,
+            Optional.of(UUID.fromString("11111111-1111-1111-1111-111111111111")),
+            Optional.of(vigilanteId), Optional.empty(), Optional.empty(),
+            lifecycle == GameLifecycle.PAUSED
+                ? Optional.of(java.time.Instant.EPOCH) : Optional.empty(),
+            Duration.ZERO, 0, 0, Set.of()
+        );
+    }
+}

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

@@ -0,0 +1,58 @@
+package games.dmg.spigottyrant;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+import java.time.Duration;
+import java.util.Map;
+import java.util.Optional;
+import java.util.Set;
+import java.util.UUID;
+import org.junit.jupiter.api.Test;
+
+final class VigilanteControlPanelModelTest {
+    @Test
+    void overviewReportsFollowersInvitationsAndCappedNearbyPower() {
+        UUID tyrantId = UUID.fromString("11111111-1111-1111-1111-111111111111");
+        UUID vigilanteId = UUID.fromString("22222222-2222-2222-2222-222222222222");
+        UUID nearbyId = UUID.fromString("33333333-3333-3333-3333-333333333333");
+        UUID offlineId = UUID.fromString("44444444-4444-4444-4444-444444444444");
+        UUID invitedId = UUID.fromString("55555555-5555-5555-5555-555555555555");
+        GameState game = new GameState(
+            GameLifecycle.RUNNING, Optional.of(tyrantId), Optional.of(vigilanteId),
+            Optional.empty(), Optional.empty(), Optional.empty(), Duration.ZERO,
+            0, 0, Set.of()
+        );
+        PlayerState nearby = follower(nearbyId, "Nearby", vigilanteId);
+        PlayerState offline = follower(offlineId, "Offline", vigilanteId);
+        PlayerState invited = PlayerState.newPlayer(invitedId, "Invited");
+
+        VigilanteControlPanelModel model = VigilanteControlPanelModel.create(
+            game,
+            Map.of(nearbyId, nearby, offlineId, offline, invitedId, invited),
+            Set.of(invitedId),
+            Map.of(
+                nearbyId, new FollowerPresence(true, true, true, true),
+                offlineId, new FollowerPresence(false, false, false, false)
+            ),
+            5,
+            4
+        );
+
+        assertEquals(2, model.followers().size());
+        assertEquals(Set.of("Invited"), model.pendingInvitations());
+        assertEquals(1, model.nearbyEligibleFollowers());
+        assertEquals(1, model.strengthLevel());
+        assertEquals(1, model.resistanceLevel());
+        assertEquals(5, model.strengthCap());
+        assertEquals(4, model.resistanceCap());
+    }
+
+    private static PlayerState follower(UUID id, String name, UUID vigilanteId) {
+        PlayerState player = PlayerState.newPlayer(id, name);
+        return new PlayerState(
+            player.playerId(), player.latestName(), player.lastLogin(), player.optedOutUntil(),
+            player.tyrantClass(), Optional.of(vigilanteId), player.cooldownEnds(),
+            player.readyAbilityItems(), player.capturedMobs()
+        );
+    }
+}

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

@@ -0,0 +1,73 @@
+package games.dmg.spigottyrant;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
+
+import java.time.Duration;
+import java.util.Map;
+import java.util.Optional;
+import java.util.Set;
+import java.util.UUID;
+import org.bukkit.command.Command;
+import org.bukkit.entity.Player;
+import org.junit.jupiter.api.Test;
+
+final class VigilanteTabCompleterTest {
+    @Test
+    void rootAndPlayerArgumentsUseMembershipEligibility() {
+        UUID tyrantId = UUID.fromString("11111111-1111-1111-1111-111111111111");
+        UUID vigilanteId = UUID.fromString("22222222-2222-2222-2222-222222222222");
+        UUID eligibleId = UUID.fromString("33333333-3333-3333-3333-333333333333");
+        UUID followerId = UUID.fromString("44444444-4444-4444-4444-444444444444");
+        PlayerState eligible = PlayerState.newPlayer(eligibleId, "Eligible");
+        PlayerState follower = follower(followerId, "Follower", vigilanteId);
+        TyrantStateManager manager = mock(TyrantStateManager.class);
+        when(manager.game()).thenReturn(new GameState(
+            GameLifecycle.RUNNING, Optional.of(tyrantId), Optional.of(vigilanteId),
+            Optional.empty(), Optional.empty(), Optional.empty(), Duration.ZERO,
+            0, 0, Set.of()
+        ));
+        when(manager.players()).thenReturn(Map.of(eligibleId, eligible, followerId, follower));
+        OnlinePlayerDirectory directory = mock(OnlinePlayerDirectory.class);
+        when(directory.onlinePlayerIds()).thenReturn(Set.of(eligibleId, followerId, tyrantId));
+        Player eligiblePlayer = player(eligibleId, "Eligible");
+        Player followerPlayer = player(followerId, "Follower");
+        Player tyrantPlayer = player(tyrantId, "Tyrant");
+        when(directory.findById(eligibleId)).thenReturn(eligiblePlayer);
+        when(directory.findById(followerId)).thenReturn(followerPlayer);
+        when(directory.findById(tyrantId)).thenReturn(tyrantPlayer);
+        VigilanteTabCompleter completer = new VigilanteTabCompleter(
+            manager, new FollowerService(), directory
+        );
+        Player vigilante = player(vigilanteId, "Vigilante");
+        Command command = mock(Command.class);
+
+        assertTrue(completer.onTabComplete(
+            vigilante, command, "vigilante", new String[] {""}
+        ).containsAll(java.util.List.of("menu", "item", "invite", "dismiss")));
+        assertEquals(java.util.List.of("Eligible"), completer.onTabComplete(
+            vigilante, command, "vigilante", new String[] {"invite", ""}
+        ));
+        assertEquals(java.util.List.of("Follower"), completer.onTabComplete(
+            vigilante, command, "vigilante", new String[] {"dismiss", ""}
+        ));
+    }
+
+    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 follower(UUID id, String name, UUID vigilanteId) {
+        PlayerState state = PlayerState.newPlayer(id, name);
+        return new PlayerState(
+            id, name, state.lastLogin(), state.optedOutUntil(), state.tyrantClass(),
+            Optional.of(vigilanteId), state.cooldownEnds(), state.readyAbilityItems(),
+            state.capturedMobs()
+        );
+    }
+}