feat(admin): issue new character sheets

src/main/java/games/dmg/fantasystick/FantasyStickPlugin.java

@@ -247,6 +247,10 @@ public final class FantasyStickPlugin extends JavaPlugin {
                 quickstepSettings, quickstep, secondWindSettings, secondWind,
                 stoneSkinSettings, stoneSkin, shieldBashSettings, shieldBash, hexSettings, hex,
                 inspireSettings, inspire, abilityRegistry);
+            admin.attachCharacterIssuer(new games.dmg.fantasystick.session.AdminCharacterIssuer(characters,
+                () -> factory.create(rules), nextTick, problem -> getLogger().log(Level.WARNING,
+                    "Admin character issue " + problem.operation() + " for player " + problem.player()
+                        + "; character " + problem.character(), problem.cause())));
             var command = java.util.Objects.requireNonNull(getCommand("fantasystick"), "Missing packaged fantasystick command");
             command.setExecutor(admin);
             command.setTabCompleter(admin);

src/main/java/games/dmg/fantasystick/session/AdminCharacterIssuer.java

@@ -0,0 +1,121 @@
+package games.dmg.fantasystick.session;
+
+import games.dmg.fantasystick.items.CharacterSheets;
+import games.dmg.fantasystick.persistence.CharacterRecord;
+import games.dmg.fantasystick.persistence.CharacterStorage;
+import java.util.List;
+import java.util.Objects;
+import java.util.UUID;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.function.Consumer;
+import java.util.function.Supplier;
+import org.bukkit.entity.Player;
+
+/** Persists one fresh character before handing its authentic sheet to a still-valid native inventory slot. */
+public final class AdminCharacterIssuer implements AutoCloseable {
+    public enum Outcome { DELIVERED, FULL, BUSY, STALE, SAVE_FAILED, RETAINED }
+    public record Failure(UUID player, UUID character, String operation, Throwable cause) { }
+
+    private final CharacterStorage storage;
+    private final Supplier<CharacterRecord> allocate;
+    private final Consumer<Runnable> nextTick;
+    private final Consumer<Failure> failures;
+    private final ConcurrentHashMap<UUID, Attempt> pending = new ConcurrentHashMap<>();
+    private volatile boolean closed;
+
+    public AdminCharacterIssuer(CharacterStorage storage, Supplier<CharacterRecord> allocate,
+                                Consumer<Runnable> nextTick, Consumer<Failure> failures) {
+        this.storage = Objects.requireNonNull(storage);
+        this.allocate = Objects.requireNonNull(allocate);
+        this.nextTick = Objects.requireNonNull(nextTick);
+        this.failures = Objects.requireNonNull(failures);
+    }
+
+    /** Must be entered on the server thread. Completion is delivered on that thread. */
+    public void issue(Player player, Consumer<Outcome> response) {
+        Objects.requireNonNull(player); Objects.requireNonNull(response);
+        if (closed || !player.isOnline()) { response.accept(Outcome.STALE); return; }
+        int slot = player.getInventory().firstEmpty();
+        if (slot < 0) { response.accept(Outcome.FULL); return; }
+        var attempt = new Attempt(player, slot, response);
+        if (pending.putIfAbsent(attempt.playerId, attempt) != null) { response.accept(Outcome.BUSY); return; }
+        try {
+            attempt.record = allocate.get();
+            attempt.preparation = storage.prepareCraft(List.of(attempt.record));
+            attempt.preparation.ready().whenComplete((batch, failure) -> schedule(attempt, batch, failure));
+        } catch (RuntimeException failure) {
+            pending.remove(attempt.playerId, attempt);
+            abandon(attempt);
+            report(attempt, "prepare", failure);
+            response.accept(Outcome.SAVE_FAILED);
+        }
+    }
+
+    private void schedule(Attempt attempt, CharacterStorage.CraftBatch batch, Throwable failure) {
+        if (closed || pending.get(attempt.playerId) != attempt) { abandon(attempt); return; }
+        try { nextTick.accept(() -> complete(attempt, batch, failure)); }
+        catch (RuntimeException rejected) {
+            pending.remove(attempt.playerId, attempt); abandon(attempt); report(attempt, "schedule", rejected);
+        }
+    }
+
+    private void complete(Attempt attempt, CharacterStorage.CraftBatch batch, Throwable failure) {
+        if (closed || !pending.remove(attempt.playerId, attempt)) { abandon(attempt); return; }
+        if (failure != null) {
+            abandon(attempt); report(attempt, "save", failure); respond(attempt, Outcome.SAVE_FAILED); return;
+        }
+        var occupying = attempt.player.getInventory().getItem(attempt.slot);
+        if (!attempt.player.isOnline() || attempt.slot < 0 || attempt.slot >= 36
+                || occupying != null && !occupying.getType().isAir()) {
+            abandon(attempt); respond(attempt, Outcome.STALE); return;
+        }
+        var claimed = batch.claimForDelivery();
+        if (claimed.isEmpty() || claimed.orElseThrow().size() != 1
+                || !claimed.orElseThrow().getFirst().id().equals(attempt.record.id())) {
+            abandon(attempt); respond(attempt, Outcome.RETAINED); return;
+        }
+        try {
+            var sheet = new CharacterSheets().create(attempt.record);
+            attempt.player.getInventory().setItem(attempt.slot, sheet);
+            attempt.delivered = true;
+        } catch (RuntimeException uncertain) {
+            report(attempt, "delivery", uncertain);
+            respond(attempt, Outcome.RETAINED);
+            return;
+        }
+        try { attempt.player.updateInventory(); }
+        catch (RuntimeException syncFailure) { report(attempt, "sync", syncFailure); }
+        respond(attempt, Outcome.DELIVERED);
+    }
+
+    private void respond(Attempt attempt, Outcome outcome) {
+        try { attempt.response.accept(outcome); }
+        catch (RuntimeException failure) { report(attempt, "response", failure); }
+    }
+
+    private void abandon(Attempt attempt) {
+        if (attempt.preparation == null || attempt.delivered || !attempt.abandoned.compareAndSet(false, true)) return;
+        attempt.preparation.abandon().thenAccept(cleanup -> {
+            if (!cleanup.retained().isEmpty()) report(attempt, "cleanup-retained", null);
+        });
+    }
+
+    private void report(Attempt attempt, String operation, Throwable cause) {
+        try { failures.accept(new Failure(attempt.playerId, attempt.record == null ? null : attempt.record.id(), operation, cause)); }
+        catch (RuntimeException ignored) { }
+    }
+
+    @Override public void close() {
+        closed = true;
+        for (var attempt : List.copyOf(pending.values())) {
+            if (pending.remove(attempt.playerId, attempt)) abandon(attempt);
+        }
+    }
+
+    private static final class Attempt {
+        final Player player; final UUID playerId; final int slot; final Consumer<Outcome> response;
+        final java.util.concurrent.atomic.AtomicBoolean abandoned = new java.util.concurrent.atomic.AtomicBoolean();
+        CharacterRecord record; CharacterStorage.CraftPreparation preparation; volatile boolean delivered;
+        Attempt(Player player, int slot, Consumer<Outcome> response) { this.player=player; this.playerId=player.getUniqueId(); this.slot=slot; this.response=response; }
+    }
+}

src/main/java/games/dmg/fantasystick/session/EquipmentAdminCommand.java

@@ -38,6 +38,7 @@ public final class EquipmentAdminCommand implements TabExecutor, AutoCloseable {
     private games.dmg.fantasystick.ability.Hex hex;
     private games.dmg.fantasystick.persistence.InspireSettings inspireSettings;
     private games.dmg.fantasystick.ability.Inspire inspire;
+    private AdminCharacterIssuer characterIssuer;
 
     public EquipmentAdminCommand(EquipmentSessionStore receipts, EquipmentSessions sessions, Server server,
                                  Consumer<Runnable> nextTick, Consumer<Failure> diagnostics) {
@@ -207,6 +208,11 @@ public final class EquipmentAdminCommand implements TabExecutor, AutoCloseable {
         this.inspireSettings=Objects.requireNonNull(inspireSettings);this.inspire=Objects.requireNonNull(inspire);
     }
 
+    public void attachCharacterIssuer(AdminCharacterIssuer issuer) {
+        if (closed || characterIssuer != null) throw new IllegalStateException("Character issuer already attached or command closed");
+        characterIssuer = Objects.requireNonNull(issuer);
+    }
+
     @Override public boolean onCommand(CommandSender sender, Command command, String label, String[] args) {
         if (closed) return true;
         if (!sender.hasPermission(PERMISSION)) {
@@ -217,6 +223,10 @@ public final class EquipmentAdminCommand implements TabExecutor, AutoCloseable {
             configuration(sender, args);
             return true;
         }
+        if (args.length > 0 && args[0].equals("give")) {
+            give(sender, args);
+            return true;
+        }
         UUID owner;
         try {
             if (args.length != 2 || !(args[0].equals("inspect") || args[0].equals("recover"))) {
@@ -277,6 +287,30 @@ public final class EquipmentAdminCommand implements TabExecutor, AutoCloseable {
         return true;
     }
 
+    private void give(CommandSender sender, String[] args) {
+        if (args.length != 2 || args[1].isBlank() || characterIssuer == null) {
+            sender.sendMessage("Usage: /fantasystick give <online-player>"); return;
+        }
+        var matches = server.getOnlinePlayers().stream().filter(player -> player.isOnline()
+            && player.getName().equalsIgnoreCase(args[1])).toList();
+        if (matches.size() != 1) {
+            sender.sendMessage("Character issue refused: target must name one online player. No character or item was created."); return;
+        }
+        var target = matches.getFirst();
+        characterIssuer.issue(target, outcome -> {
+            if (closed || !sender.hasPermission(PERMISSION)
+                    || sender instanceof org.bukkit.entity.Player player && !player.isOnline()) return;
+            sender.sendMessage(switch (outcome) {
+                case DELIVERED -> "Issued one new character sheet to " + target.getName() + ".";
+                case FULL -> "Character issue refused: " + target.getName() + " has no inventory space. No character was created.";
+                case BUSY -> "Character issue refused: another delivery to " + target.getName() + " is pending.";
+                case STALE -> "Character issue refused: target disconnected or the reserved inventory slot changed. No sheet was delivered.";
+                case SAVE_FAILED -> "Character issue failed before delivery; no sheet was delivered. See server diagnostics.";
+                case RETAINED -> "Character issue has ambiguous retained state; no retry was performed. See server diagnostics.";
+            });
+        });
+    }
+
     private void configuration(CommandSender sender, String[] args) {
         if (args.length < 2 || args.length > 3) { configurationUsage(sender); return; }
         if (args[1].equals("adventure-mode")) { adventureConfiguration(sender, args); return; }
@@ -522,10 +556,12 @@ public final class EquipmentAdminCommand implements TabExecutor, AutoCloseable {
         catch (RuntimeException ignored) { /* Diagnostics cannot authorize recovery. */ }
     }
 
-    // Never fall back to Bukkit's online-player-name suggestions for a UUID-only admin interface.
+    // Return only explicit implemented routes; never fall back to Bukkit's broad default suggestions.
     @Override public List<String> onTabComplete(CommandSender sender, Command command, String alias, String[] args) {
         if (closed || !sender.hasPermission(PERMISSION)) return List.of();
-        if (args.length == 1) return matching(List.of("config", "inspect", "recover"), args[0]);
+        if (args.length == 1) return matching(List.of("config", "give", "inspect", "recover"), args[0]);
+        if (args.length == 2 && args[0].equals("give")) return matching(server.getOnlinePlayers().stream()
+            .filter(org.bukkit.entity.Player::isOnline).map(org.bukkit.entity.Player::getName).toList(), args[1]);
         if (args.length == 2 && args[0].equals("config")) {
             var keys = new java.util.ArrayList<String>(); keys.add("adventure-mode");
             keys.addAll(games.dmg.fantasystick.persistence.FrostShardSettings.keys());
@@ -582,5 +618,5 @@ public final class EquipmentAdminCommand implements TabExecutor, AutoCloseable {
     private static List<String> matching(java.util.Collection<String> values, String prefix) {
         return values.stream().filter(value -> value.startsWith(prefix)).distinct().sorted().toList();
     }
-    @Override public void close() { closed = true; }
+    @Override public void close() { closed = true; if (characterIssuer != null) characterIssuer.close(); }
 }

src/main/resources/plugin.yml

@@ -7,10 +7,10 @@ description: Transferable characters, native fantasy health, recoverable equipme
 author: dmg.games
 commands:
   fantasystick:
-    description: Inspect/recover equipment sessions or configure Fantasy Stick.
-    usage: /fantasystick <inspect|recover> <player-uuid> | config <setting> [value]
+    description: Issue character sheets, inspect/recover equipment sessions or configure Fantasy Stick.
+    usage: /fantasystick give <online-player> | <inspect|recover> <player-uuid> | config <setting> [value]
     permission: fantasystick.admin
 permissions:
   fantasystick.admin:
-    description: Inspect/recover equipment sessions and configure fantasy mode.
+    description: Issue sheets, inspect/recover equipment sessions and configure fantasy mode.
     default: op

src/nativeTest/java/games/dmg/fantasystick/EquipmentAdminCommandNativeTest.java

@@ -17,6 +17,73 @@ class EquipmentAdminCommandNativeTest {
     @TempDir Path data;
     @BeforeAll static void bootstrap() throws Exception { NativeRuntime.bootstrap(); }
 
+    @Test void registeredGivePersistsOneFreshSheetThenDeliversActivatesAndReloads() throws Exception {
+        try (var f = new FantasyStickLifecycleNativeTest.Fixture(data)) {
+            f.plugin.setEnabled(true);
+            var target = new FantasyStickLifecycleNativeTest.Actor(data); f.players.put(target.core.id, target.player);
+            var before = target.core.snapshot(); var sender = new Sender();
+            assertTrue(f.command.execute(sender.port, "fantasystick", new String[]{"give", "Account"}));
+            assertTrue(sender.messages.isEmpty(), "Queued persistence is not successful delivery");
+            ((games.dmg.fantasystick.persistence.CharacterStorage) FantasyStickLifecycleNativeTest.Fixture.field(f.plugin, "characters"))
+                .find(java.util.UUID.randomUUID()).get(5, java.util.concurrent.TimeUnit.SECONDS);
+            var callback = f.tasks.poll(5, java.util.concurrent.TimeUnit.SECONDS); assertNotNull(callback); callback.run(); callback.run();
+            assertTrue(sender.messages.getLast().contains("Issued one new character sheet"));
+            assertFalse(java.util.Arrays.equals(before, target.core.snapshot()));
+            var sheets = new games.dmg.fantasystick.items.CharacterSheets();
+            var delivered = java.util.stream.IntStream.range(0, 36).mapToObj(target.core.inventory::getItem)
+                .filter(item -> sheets.identify(item).isPresent()).filter(item -> !sheets.identify(item).orElseThrow().equals(target.core.record.id())).toList();
+            assertEquals(1, delivered.size(), "Repeated callback must not duplicate delivery");
+            assertEquals(target.core.record.id(),sheets.identify(target.core.inventory.getItemInOffHand()).orElseThrow());
+            assertTrue(((games.dmg.fantasystick.session.EquipmentSessions) FantasyStickLifecycleNativeTest.Fixture.field(f.plugin,"sessions")).active(target.core.id).isEmpty());
+            var id = sheets.identify(delivered.getFirst()).orElseThrow();
+            var storage = (games.dmg.fantasystick.persistence.CharacterStorage) FantasyStickLifecycleNativeTest.Fixture.field(f.plugin, "characters");
+            var record = storage.find(id).get(5, java.util.concurrent.TimeUnit.SECONDS).orElseThrow();
+            assertEquals(java.math.BigInteger.valueOf(40), record.unspentPoints()); assertEquals(1, record.level());
+            assertEquals(java.math.BigInteger.ZERO, record.experience()); assertFalse(record.dead()); assertTrue(record.learned().isEmpty());
+            assertTrue(record.stats().values().stream().allMatch(java.math.BigInteger.ZERO::equals));assertEquals(new java.math.BigDecimal("10"),record.health());
+            assertEquals(java.util.Collections.nCopies(7,""),record.loadout());assertTrue(record.cooldowns().isEmpty());assertFalse(record.name().isBlank());
+            target.core.inventory.remove(delivered.getFirst()); target.core.inventory.setItemInOffHand(delivered.getFirst());
+            f.activate(target); assertEquals(id, ((games.dmg.fantasystick.session.EquipmentSessions) FantasyStickLifecycleNativeTest.Fixture.field(f.plugin, "sessions")).active(target.core.id).orElseThrow().character());
+            f.plugin.setEnabled(false); f.plugin.setEnabled(true);
+            assertEquals(record, ((games.dmg.fantasystick.persistence.CharacterStorage) FantasyStickLifecycleNativeTest.Fixture.field(f.plugin, "characters")).find(id).get(5, java.util.concurrent.TimeUnit.SECONDS).orElseThrow());
+        }
+    }
+
+    @Test void giveCompletionAndRejectedExecutionArePermissionAwareStrictAndReadOnly() throws Exception {
+        try (var f = new FantasyStickLifecycleNativeTest.Fixture(data)) {
+            f.plugin.setEnabled(true); var target = new FantasyStickLifecycleNativeTest.Actor(data); f.players.put(target.core.id,target.player);
+            var sender=new Sender();
+            assertEquals(List.of("config","give","inspect","recover"),f.command.tabComplete(sender.port,"fantasystick",new String[]{""}));
+            assertEquals(List.of("give"),f.command.tabComplete(sender.port,"fantasystick",new String[]{"g"}));
+            assertEquals(List.of("Account"),f.command.tabComplete(sender.port,"fantasystick",new String[]{"give",""}));
+            assertEquals(List.of("Account"),f.command.tabComplete(sender.port,"fantasystick",new String[]{"give","Acc"}));
+            assertTrue(f.command.tabComplete(sender.port,"fantasystick",new String[]{"give","Account",""}).isEmpty());
+            sender.allowed=false;assertTrue(f.command.tabComplete(sender.port,"fantasystick",new String[]{"give",""}).isEmpty());
+            var original=target.core.snapshot();f.command.getExecutor().onCommand(sender.port,f.command,"fantasystick",new String[]{"give","Account"});
+            sender.allowed=true;for(String[] args:List.of(new String[]{"give"},new String[]{"give","Missing"},new String[]{"give","Account","extra"}))f.command.execute(sender.port,"fantasystick",args);
+            assertArrayEquals(original,target.core.snapshot());assertTrue(f.tasks.isEmpty());
+            assertEquals(1,java.nio.file.Files.list(data.resolve("characters")).filter(path->path.toString().endsWith(".yml")).count());
+            for(int slot=0;slot<36;slot++)target.core.inventory.setItem(slot,new org.bukkit.inventory.ItemStack(org.bukkit.Material.STONE));
+            var full=target.core.snapshot();f.command.execute(sender.port,"fantasystick",new String[]{"give","Account"});assertTrue(sender.messages.getLast().contains("no inventory space"));
+            assertArrayEquals(full,target.core.snapshot());assertTrue(f.tasks.isEmpty());assertEquals(1,java.nio.file.Files.list(data.resolve("characters")).filter(path->path.toString().endsWith(".yml")).count());
+        }
+    }
+
+    @Test void giveSaveFailureDisconnectSlotRaceAndLifecycleInterruptionNeverDuplicateOrOverwrite() throws Exception {
+        for(String route:List.of("save","disconnect","slot","close")){var dir=data.resolve(route);java.nio.file.Files.createDirectories(dir);try(var f=new FantasyStickLifecycleNativeTest.Fixture(dir)){
+            f.plugin.setEnabled(true);var target=new FantasyStickLifecycleNativeTest.Actor(dir);f.players.put(target.core.id,target.player);var sender=new Sender();var original=target.core.snapshot();
+            var storage=(games.dmg.fantasystick.persistence.CharacterStorage)FantasyStickLifecycleNativeTest.Fixture.field(f.plugin,"characters");
+            var worker=(java.util.concurrent.ExecutorService)FantasyStickLifecycleNativeTest.Fixture.field(storage,"worker");var entered=new java.util.concurrent.CountDownLatch(1);var release=new java.util.concurrent.CountDownLatch(1);worker.execute(()->{entered.countDown();try{release.await(5,java.util.concurrent.TimeUnit.SECONDS);}catch(InterruptedException e){Thread.currentThread().interrupt();}});assertTrue(entered.await(5,java.util.concurrent.TimeUnit.SECONDS));
+            f.command.execute(sender.port,"fantasystick",new String[]{"give","Account"});
+            if(route.equals("save")){var issuer=FantasyStickLifecycleNativeTest.Fixture.field(f.command.getExecutor(),"characterIssuer");var pending=(java.util.Map<?,?>)FantasyStickLifecycleNativeTest.Fixture.field(issuer,"pending");var attempt=pending.values().iterator().next();var record=(games.dmg.fantasystick.persistence.CharacterRecord)FantasyStickLifecycleNativeTest.Fixture.field(attempt,"record");java.nio.file.Files.createDirectory(dir.resolve("characters").resolve(record.id()+".yml"));}
+            release.countDown();storage.find(java.util.UUID.randomUUID()).get(5,java.util.concurrent.TimeUnit.SECONDS);var callback=f.tasks.poll(5,java.util.concurrent.TimeUnit.SECONDS);assertNotNull(callback);
+            if(route.equals("disconnect"))target.core.online=false;if(route.equals("slot"))target.core.inventory.setItem(1,new org.bukkit.inventory.ItemStack(org.bukkit.Material.DIAMOND));if(route.equals("close"))f.plugin.setEnabled(false);callback.run();
+            if(!route.equals("close"))storage.find(java.util.UUID.randomUUID()).get(5,java.util.concurrent.TimeUnit.SECONDS);
+            assertFalse(sender.messages.stream().anyMatch(message->message.startsWith("Issued one")));assertEquals(route.equals("slot")?org.bukkit.Material.DIAMOND:original[1]==null?null:original[1].getType(),target.core.inventory.getItem(1)==null?null:target.core.inventory.getItem(1).getType());
+            if(!route.equals("save"))assertEquals(1,java.nio.file.Files.list(dir.resolve("characters")).filter(path->path.toString().endsWith(".yml")).count());
+            release.countDown();}}
+    }
+
     @Test void adventureConfigurationCommandReadsValidatesPersistsAndReopensWithoutTouchingPlayers() throws Exception {
         try (var f = new FantasyStickLifecycleNativeTest.Fixture(data)) {
             f.plugin.setEnabled(true);

src/nativeTest/java/games/dmg/fantasystick/LongbowNativeTest.java

@@ -348,7 +348,7 @@ class LongbowNativeTest {
             assertThrows(AssertionError.class, () -> abilityButton(unavailable, "[Learn]", "longbow"));
 
             var sender = new EquipmentAdminCommandNativeTest.Sender();
-            assertEquals(java.util.List.of("config", "inspect", "recover"),
+            assertEquals(java.util.List.of("config", "give", "inspect", "recover"),
                 f.command.tabComplete(sender.port, "fantasystick", new String[]{""}));
             assertEquals(java.util.List.of("config"), f.command.tabComplete(sender.port, "fantasystick", new String[]{"c"}));
             assertTrue(f.command.tabComplete(sender.port, "fantasystick", new String[]{"unknown"}).isEmpty());

src/nativeTest/java/games/dmg/fantasystick/QuickstepNativeTest.java

@@ -202,7 +202,7 @@ class QuickstepNativeTest {
             assertEquals(0, new java.math.BigDecimal("6").compareTo(definition.parameters().get("distance")));
             assertEquals(0, new java.math.BigDecimal("1.5").compareTo(definition.parameters().get("speed")));
             var sender = new EquipmentAdminCommandNativeTest.Sender();
-            assertEquals(List.of("config", "inspect", "recover"),
+            assertEquals(List.of("config", "give", "inspect", "recover"),
                 f.command.tabComplete(sender.port, "fantasystick", new String[]{""}));
             assertEquals(List.of("config"), f.command.tabComplete(sender.port, "fantasystick", new String[]{"co"}));
             assertTrue(f.command.tabComplete(sender.port, "fantasystick", new String[]{"unsupported"}).isEmpty());

src/nativeTest/java/games/dmg/fantasystick/SecondWindNativeTest.java

@@ -130,7 +130,7 @@ class SecondWindNativeTest {
             assertEquals(BigInteger.TEN.pow(500).subtract(BigInteger.TEN).divide(BigInteger.TWO).add(BigInteger.valueOf(6)),
                 games.dmg.fantasystick.ability.SecondWind.healing(BigInteger.TEN.pow(500)));
             var sender = new EquipmentAdminCommandNativeTest.Sender();
-            assertEquals(List.of("config", "inspect", "recover"),
+            assertEquals(List.of("config", "give", "inspect", "recover"),
                 f.command.tabComplete(sender.port, "fantasystick", new String[]{""}));
             sender.allowed = false;
             assertTrue(f.command.tabComplete(sender.port, "fantasystick", new String[]{"config", "second"}).isEmpty());