feat(commands): add contextual completion and unlock listing

src/main/java/games/dmg/spigotstealth/KnownPlayerResolver.java

@@ -21,6 +21,17 @@ public final class KnownPlayerResolver {
         this.onlinePlayers = Objects.requireNonNull(onlinePlayers, "onlinePlayers");
     }
 
+    public java.util.List<String> completeNames(String prefix) {
+        String normalized = prefix == null ? "" : prefix.toLowerCase(Locale.ROOT);
+        return knownPlayers().values().stream()
+                .map(KnownPlayer::name)
+                .filter(Objects::nonNull)
+                .distinct()
+                .filter(name -> name.toLowerCase(Locale.ROOT).startsWith(normalized))
+                .sorted(String.CASE_INSENSITIVE_ORDER)
+                .toList();
+    }
+
     public Resolution resolve(String query) {
         if (query == null || query.isBlank()) {
             return new Resolution(Status.UNKNOWN, null);

src/main/java/games/dmg/spigotstealth/SpigotStealthPlugin.java

@@ -79,18 +79,24 @@ public final class SpigotStealthPlugin extends JavaPlugin {
                 new InvisibilityEffectListener(progression, Clock.systemUTC()), this);
         getServer().getPluginManager().registerEvents(
                 new StealthSessionListener(sessions, identityPresentation, settings.concealedMessage()), this);
-        Objects.requireNonNull(getCommand("stealth"), "stealth command")
-                .setExecutor(new StealthCommand(manager, progression, settings));
+        org.bukkit.command.PluginCommand stealthPluginCommand =
+                Objects.requireNonNull(getCommand("stealth"), "stealth command");
+        StealthCommand stealthCommand = new StealthCommand(manager, progression, settings);
+        stealthPluginCommand.setExecutor(stealthCommand);
+        stealthPluginCommand.setTabCompleter(stealthCommand);
         StealthAdministrationService administration = new StealthAdministrationService(
                 manager, progression, identityPresentation, notifier, getServer()::getOnlinePlayers);
         KnownPlayerResolver resolver = new KnownPlayerResolver(manager::snapshot, getServer()::getOnlinePlayers);
-        Objects.requireNonNull(getCommand("stealthadmin"), "stealthadmin command")
-                .setExecutor(new StealthAdminCommand(
-                        administration,
-                        resolver,
-                        mainThread,
-                        getLogger()::info,
-                        settings.unlockThreshold()));
+        org.bukkit.command.PluginCommand stealthAdminPluginCommand =
+                Objects.requireNonNull(getCommand("stealthadmin"), "stealthadmin command");
+        StealthAdminCommand stealthAdminCommand = new StealthAdminCommand(
+                administration,
+                resolver,
+                mainThread,
+                getLogger()::info,
+                settings.unlockThreshold());
+        stealthAdminPluginCommand.setExecutor(stealthAdminCommand);
+        stealthAdminPluginCommand.setTabCompleter(stealthAdminCommand);
         getServer().getScheduler().runTaskTimer(this, ignored -> {
             for (java.util.UUID playerId : progression.activePlayerIds()) {
                 logSaveFailure(progression.checkpoint(playerId));

src/main/java/games/dmg/spigotstealth/StealthAdminCommand.java

@@ -9,10 +9,12 @@ import java.util.function.Consumer;
 import org.bukkit.command.Command;
 import org.bukkit.command.CommandExecutor;
 import org.bukkit.command.CommandSender;
+import org.bukkit.command.TabCompleter;
 
 /** Permission-gated administrative command for online and known offline players. */
-public final class StealthAdminCommand implements CommandExecutor {
+public final class StealthAdminCommand implements CommandExecutor, TabCompleter {
     private static final String PERMISSION = "spigotstealth.admin";
+    private static final List<String> OPERATIONS = List.of("status", "grant", "reset", "list");
     private final StealthAdministrationService administration;
     private final KnownPlayerResolver resolver;
     private final Consumer<Runnable> mainThread;
@@ -32,17 +34,57 @@ public final class StealthAdminCommand implements CommandExecutor {
         this.unlockThreshold = Objects.requireNonNull(unlockThreshold, "unlockThreshold");
     }
 
+    @Override
+    public List<String> onTabComplete(
+            CommandSender sender, Command command, String label, String[] arguments) {
+        if (!sender.hasPermission(PERMISSION)) {
+            return List.of();
+        }
+        if (arguments.length == 1) {
+            return matching(OPERATIONS, arguments[0]);
+        }
+        String operation = arguments[0].toLowerCase(Locale.ROOT);
+        if (arguments.length == 2) {
+            if (List.of("status", "grant", "reset").contains(operation)) {
+                return resolver.completeNames(arguments[1]);
+            }
+            if ("list".equals(operation)) {
+                return matching(List.of("unlocked"), arguments[1]);
+            }
+        }
+        if (arguments.length == 3 && "reset".equals(operation)) {
+            return matching(List.of("confirm"), arguments[2]);
+        }
+        return List.of();
+    }
+
+    private static List<String> matching(List<String> candidates, String prefix) {
+        String normalized = prefix.toLowerCase(Locale.ROOT);
+        return candidates.stream().filter(candidate -> candidate.startsWith(normalized)).toList();
+    }
+
     @Override
     public boolean onCommand(CommandSender sender, Command command, String label, String[] arguments) {
         if (!sender.hasPermission(PERMISSION)) {
             sender.sendMessage("You do not have permission to administer Spigot Stealth.");
             return true;
         }
-        if (arguments.length == 1 && "list".equalsIgnoreCase(arguments[0])) {
-            List<String> names = administration.concealedOnlineNames();
-            sender.sendMessage(names.isEmpty()
-                    ? "No players are currently concealed."
-                    : "Currently concealed: " + String.join(", ", names));
+        if (arguments.length > 0 && "list".equalsIgnoreCase(arguments[0])) {
+            if (arguments.length == 1) {
+                List<String> names = administration.concealedOnlineNames();
+                sender.sendMessage(names.isEmpty()
+                        ? "No players are currently concealed."
+                        : "Currently concealed: " + String.join(", ", names));
+                return true;
+            }
+            if (arguments.length == 2 && "unlocked".equalsIgnoreCase(arguments[1])) {
+                List<String> names = administration.unlockedPlayerNames();
+                sender.sendMessage(names.isEmpty()
+                        ? "No players have unlocked stealth."
+                        : "Stealth unlocked: " + String.join(", ", names));
+                return true;
+            }
+            sendUsage(sender, label);
             return true;
         }
         if (arguments.length < 2) {
@@ -121,7 +163,7 @@ public final class StealthAdminCommand implements CommandExecutor {
     }
 
     private static void sendUsage(CommandSender sender, String label) {
-        sender.sendMessage("Usage: /" + label + " <status <player|uuid>|grant <player|uuid>|reset <player|uuid> confirm|list>");
+        sender.sendMessage("Usage: /" + label + " <status <player|uuid>|grant <player|uuid>|reset <player|uuid> confirm|list [unlocked]>");
     }
 
     private static String displayName(KnownPlayerResolver.KnownPlayer player) {

src/main/java/games/dmg/spigotstealth/StealthAdministrationService.java

@@ -73,6 +73,17 @@ public final class StealthAdministrationService {
         return CompletableFuture.allOf(stopped, reset);
     }
 
+    public List<String> unlockedPlayerNames() {
+        return stateManager.snapshot().players().entrySet().stream()
+                .filter(entry -> entry.getValue().unlocked())
+                .map(entry -> {
+                    String name = entry.getValue().lastKnownName();
+                    return name == null || name.isBlank() ? entry.getKey().toString() : name;
+                })
+                .sorted(String.CASE_INSENSITIVE_ORDER)
+                .toList();
+    }
+
     public List<String> concealedOnlineNames() {
         return onlinePlayers.get().stream()
                 .filter(player -> stateManager.snapshot().player(player.getUniqueId()).concealed())

src/main/java/games/dmg/spigotstealth/StealthCommand.java

@@ -1,14 +1,16 @@
 package games.dmg.spigotstealth;
 
+import java.util.List;
 import java.util.Locale;
 import java.util.Objects;
 import org.bukkit.command.Command;
 import org.bukkit.command.CommandExecutor;
 import org.bukkit.command.CommandSender;
+import org.bukkit.command.TabCompleter;
 import org.bukkit.entity.Player;
 
 /** Player-facing progress command. */
-public final class StealthCommand implements CommandExecutor {
+public final class StealthCommand implements CommandExecutor, TabCompleter {
     private final StealthStateManager stateManager;
     private final QualifyingInvisibilityService progression;
     private final StealthSettings settings;
@@ -22,6 +24,15 @@ public final class StealthCommand implements CommandExecutor {
         this.settings = Objects.requireNonNull(settings, "settings");
     }
 
+    @Override
+    public List<String> onTabComplete(
+            CommandSender sender, Command command, String label, String[] arguments) {
+        if (arguments.length == 1 && "progress".startsWith(arguments[0].toLowerCase(Locale.ROOT))) {
+            return List.of("progress");
+        }
+        return List.of();
+    }
+
     @Override
     public boolean onCommand(CommandSender sender, Command command, String label, String[] arguments) {
         if (!(sender instanceof Player player)) {