diff --git a/.github/workflows/release.yml b/.github/workflows/release.yml
index dca880a..f388ab7 100644
--- a/.github/workflows/release.yml
+++ b/.github/workflows/release.yml
@@ -39,11 +39,16 @@ jobs:
           path: build/libs/async-anticheat-${{ steps.version.outputs.version }}.jar
           if-no-files-found: error
 
+      - name: Copy JAR with stable name
+        run: cp build/libs/async-anticheat-${{ steps.version.outputs.version }}.jar build/libs/async-anticheat.jar
+
       - name: Upload JAR to Release
         if: github.event_name == 'release'
         uses: softprops/action-gh-release@v2
         with:
-          files: build/libs/async-anticheat-${{ steps.version.outputs.version }}.jar
+          files: |
+            build/libs/async-anticheat-${{ steps.version.outputs.version }}.jar
+            build/libs/async-anticheat.jar
         env:
           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
 
diff --git a/asyncanticheat-bukkit/src/main/java/md/thomas/asyncanticheat/bukkit/AsyncAnticheatBukkitPlugin.java b/asyncanticheat-bukkit/src/main/java/md/thomas/asyncanticheat/bukkit/AsyncAnticheatBukkitPlugin.java
index 274a452..ebc9b46 100644
--- a/asyncanticheat-bukkit/src/main/java/md/thomas/asyncanticheat/bukkit/AsyncAnticheatBukkitPlugin.java
+++ b/asyncanticheat-bukkit/src/main/java/md/thomas/asyncanticheat/bukkit/AsyncAnticheatBukkitPlugin.java
@@ -15,7 +15,7 @@
 public final class AsyncAnticheatBukkitPlugin extends JavaPlugin {
 
     private AsyncAnticheatService service;
-    private BukkitDevModeManager devMode;
+    private RecordingManager recordingManager;
     private BukkitPlayerExemptionTracker exemptionTracker;
     private SchedulerUtil.ScheduledTask stateTask;
     private boolean packetEventsInitialized = false;
@@ -56,26 +56,25 @@ public void onEnable() {
             }
         }
 
-        devMode = new BukkitDevModeManager(this, service);
-        // Ensure dev sessions are stopped immediately on logout (no orphaned repeating tasks)
+        // Initialize recording manager for in-game cheat recording
+        recordingManager = new RecordingManager(this, service.getConfig(), service.getServerId());
+        
+        // Ensure recordings are stopped immediately on logout
         getServer().getPluginManager().registerEvents(new Listener() {
             @EventHandler
             public void onQuit(PlayerQuitEvent event) {
-                if (devMode != null) {
-                    devMode.stopSilent(event.getPlayer().getUniqueId());
+                if (recordingManager != null) {
+                    recordingManager.handlePlayerQuit(event.getPlayer().getUniqueId());
                 }
             }
         }, this);
-        final PluginCommand cmd = getCommand("aacdev");
-        if (cmd != null) {
-            final BukkitDevModeCommand executor = new BukkitDevModeCommand(devMode, service);
-            cmd.setExecutor(executor);
-            cmd.setTabCompleter(executor);
-        }
 
-        final PluginCommand linkCmd = getCommand("aac");
-        if (linkCmd != null) {
-            linkCmd.setExecutor(new BukkitLinkCommand(service));
+        // Register main /aac command with subcommands
+        final PluginCommand aacCmd = getCommand("aac");
+        if (aacCmd != null) {
+            final BukkitMainCommand mainCmd = new BukkitMainCommand(service, recordingManager);
+            aacCmd.setExecutor(mainCmd);
+            aacCmd.setTabCompleter(mainCmd);
         }
 
         service.start();
@@ -113,12 +112,10 @@ public void onDisable() {
             stateTask.cancel();
             stateTask = null;
         }
-        // IMPORTANT: devMode.stopAll() enqueues DEV_MARKER stop events via service.tryEnqueue(...).
-        // service.stop() triggers a best-effort final flush/upload on a daemon thread.
-        // Therefore, stopAll MUST run before stop() so stop markers are included in the final upload.
-        if (devMode != null) {
-            devMode.stopAll("plugin_disable");
-            devMode = null;
+        // Stop all active recordings and submit them
+        if (recordingManager != null) {
+            recordingManager.stopAll();
+            recordingManager = null;
         }
         if (service != null) {
             service.stop();
diff --git a/asyncanticheat-bukkit/src/main/java/md/thomas/asyncanticheat/bukkit/BukkitDevModeCommand.java b/asyncanticheat-bukkit/src/main/java/md/thomas/asyncanticheat/bukkit/BukkitDevModeCommand.java
deleted file mode 100644
index 07b24d9..0000000
--- a/asyncanticheat-bukkit/src/main/java/md/thomas/asyncanticheat/bukkit/BukkitDevModeCommand.java
+++ /dev/null
@@ -1,105 +0,0 @@
-package md.thomas.asyncanticheat.bukkit;
-
-import md.thomas.asyncanticheat.core.AsyncAnticheatService;
-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;
-import org.jetbrains.annotations.NotNull;
-import org.jetbrains.annotations.Nullable;
-
-import java.util.ArrayList;
-import java.util.List;
-
-final class BukkitDevModeCommand implements CommandExecutor, TabCompleter {
-
-    private final BukkitDevModeManager dev;
-    private final AsyncAnticheatService service;
-
-    BukkitDevModeCommand(@NotNull BukkitDevModeManager dev, @NotNull AsyncAnticheatService service) {
-        this.dev = dev;
-        this.service = service;
-    }
-
-    @Override
-    public boolean onCommand(@NotNull CommandSender sender, @NotNull Command command, @NotNull String label, @NotNull String[] args) {
-        if (!(sender instanceof Player player)) {
-            sender.sendMessage("[AsyncAnticheat] This command must be run by a player.");
-            return true;
-        }
-        if (!service.getConfig().isDevModeEnabled()) {
-            sender.sendMessage("[AsyncAnticheat] Dev mode is disabled. Enable it in config.yml: dev.enabled: true");
-            return true;
-        }
-        if (!sender.hasPermission("asyncanticheat.dev")) {
-            sender.sendMessage("[AsyncAnticheat] Missing permission: asyncanticheat.dev");
-            return true;
-        }
-
-        if (args.length == 0) {
-            return help(sender);
-        }
-
-        final String sub = args[0].toLowerCase();
-        switch (sub) {
-            case "start" -> {
-                if (args.length < 3) return help(sender);
-                int duration = parseInt(args[1], service.getConfig().getDevDefaultDurationSeconds());
-                String cheatLabel = args[2];
-                int warmup = args.length >= 4 ? parseInt(args[3], service.getConfig().getDevDefaultWarmupSeconds()) : service.getConfig().getDevDefaultWarmupSeconds();
-                int toggle = args.length >= 5 ? parseInt(args[4], service.getConfig().getDevDefaultToggleSeconds()) : service.getConfig().getDevDefaultToggleSeconds();
-                dev.start(player, cheatLabel, duration, warmup, toggle);
-                return true;
-            }
-            case "stop" -> {
-                dev.stop(player, "manual");
-                return true;
-            }
-            case "status" -> {
-                final BukkitDevModeManager.Session s = dev.getSession(player.getUniqueId());
-                if (s == null) {
-                    sender.sendMessage("[AsyncAnticheat Dev] No active session.");
-                } else {
-                    sender.sendMessage("[AsyncAnticheat Dev] Active: label=" + s.label + " state=" + s.cheatState +
-                            " elapsed=" + s.elapsedSeconds + "s/" + s.durationSeconds + "s toggle=" + s.toggleSeconds + "s warmup=" + s.warmupSeconds + "s");
-                }
-                return true;
-            }
-            default -> {
-                return help(sender);
-            }
-        }
-    }
-
-    private static int parseInt(@NotNull String s, int def) {
-        try {
-            return Integer.parseInt(s);
-        } catch (Exception ignored) {
-            return def;
-        }
-    }
-
-    private static boolean help(@NotNull CommandSender sender) {
-        sender.sendMessage("AsyncAnticheat dev mode (labeled recording)");
-        sender.sendMessage("/aacdev start <durationSeconds> <label> [warmupSeconds] [toggleSeconds]");
-        sender.sendMessage("/aacdev stop");
-        sender.sendMessage("/aacdev status");
-        sender.sendMessage("Markers are injected as DEV_MARKER events with dev_state=on/off so you can train detectors.");
-        return true;
-    }
-
-    @Override
-    public @Nullable List<String> onTabComplete(@NotNull CommandSender sender, @NotNull Command command, @NotNull String alias, @NotNull String[] args) {
-        final List<String> out = new ArrayList<>();
-        if (args.length == 1) {
-            out.add("start");
-            out.add("stop");
-            out.add("status");
-            return out;
-        }
-        return out;
-    }
-}
-
-
diff --git a/asyncanticheat-bukkit/src/main/java/md/thomas/asyncanticheat/bukkit/BukkitDevModeManager.java b/asyncanticheat-bukkit/src/main/java/md/thomas/asyncanticheat/bukkit/BukkitDevModeManager.java
deleted file mode 100644
index a38c873..0000000
--- a/asyncanticheat-bukkit/src/main/java/md/thomas/asyncanticheat/bukkit/BukkitDevModeManager.java
+++ /dev/null
@@ -1,229 +0,0 @@
-package md.thomas.asyncanticheat.bukkit;
-
-import md.thomas.asyncanticheat.core.AsyncAnticheatService;
-import md.thomas.asyncanticheat.core.PacketRecord;
-import org.bukkit.Bukkit;
-import org.bukkit.entity.Player;
-import org.bukkit.plugin.Plugin;
-import org.jetbrains.annotations.NotNull;
-import org.jetbrains.annotations.Nullable;
-
-import java.util.HashMap;
-import java.util.Map;
-import java.util.UUID;
-import java.util.concurrent.ConcurrentHashMap;
-
-/**
- * Dev mode: create labeled segments inside the same packet stream by injecting "DEV_*" marker records.
- */
-final class BukkitDevModeManager {
-
-    private final Plugin plugin;
-    private final AsyncAnticheatService service;
-
-    private final Map<UUID, Session> sessions = new ConcurrentHashMap<>();
-
-    BukkitDevModeManager(@NotNull Plugin plugin, @NotNull AsyncAnticheatService service) {
-        this.plugin = plugin;
-        this.service = service;
-    }
-
-    boolean start(
-            @NotNull Player player,
-            @NotNull String label,
-            int durationSeconds,
-            int warmupSeconds,
-            int toggleSeconds
-    ) {
-        stop(player, "restart");
-
-        durationSeconds = Math.max(5, durationSeconds);
-        warmupSeconds = Math.max(0, warmupSeconds);
-        toggleSeconds = Math.max(2, toggleSeconds);
-
-        final String devSessionId = UUID.randomUUID().toString();
-        final Session s = new Session(player.getUniqueId(), devSessionId, label, durationSeconds, warmupSeconds, toggleSeconds);
-        sessions.put(player.getUniqueId(), s);
-
-        // Start in "OFF" state so the first label segment is clean.
-        sendStartNotice(player, label, durationSeconds, warmupSeconds, toggleSeconds);
-        enqueueMarker(player, devSessionId, label, "start", "off", Map.of(
-                "duration_s", durationSeconds,
-                "warmup_s", warmupSeconds,
-                "toggle_s", toggleSeconds
-        ));
-
-        final UUID playerId = player.getUniqueId();
-        // Use SchedulerUtil for Folia compatibility.
-        // On Folia, dev mode uses a global timer since it only reads player state via tryEnqueue
-        // and sends messages/titles which are thread-safe operations.
-        s.scheduledTask = SchedulerUtil.runTaskTimer(plugin, 20L, 20L, () -> tick(playerId));
-        return true;
-    }
-
-    void stop(@NotNull Player player, @NotNull String reason) {
-        final Session s = sessions.remove(player.getUniqueId());
-        if (s == null) return;
-        if (s.scheduledTask != null) {
-            s.scheduledTask.cancel();
-        }
-        sendStopNotice(player, s.label, reason);
-        enqueueMarker(player, s.devSessionId, s.label, "stop", s.cheatState, Map.of("reason", reason));
-    }
-
-    void stopAll(@NotNull String reason) {
-        for (UUID id : sessions.keySet().toArray(new UUID[0])) {
-            final Player p = Bukkit.getPlayer(id);
-            if (p != null && p.isOnline()) {
-                stop(p, reason);
-            } else {
-                stopSilent(id);
-            }
-        }
-    }
-
-    @Nullable
-    Session getSession(@NotNull UUID playerId) {
-        return sessions.get(playerId);
-    }
-
-    void stopSilent(@NotNull UUID playerId) {
-        final Session s = sessions.remove(playerId);
-        if (s == null) return;
-        if (s.scheduledTask != null) {
-            s.scheduledTask.cancel();
-        }
-    }
-
-    private void tick(@NotNull UUID playerId) {
-        final Session s = sessions.get(playerId);
-        if (s == null) return;
-        final Player player = Bukkit.getPlayer(playerId);
-        if (player == null || !player.isOnline()) {
-            // Player disconnected - cancel repeating task and remove session without emitting markers/messages.
-            stopSilent(playerId);
-            return;
-        }
-
-        s.elapsedSeconds++;
-        if (s.elapsedSeconds >= s.durationSeconds) {
-            stop(player, "finished");
-            return;
-        }
-
-        // Wait warmup period before first toggle ON.
-        if (!s.startedToggles) {
-            if (s.elapsedSeconds >= s.warmupSeconds) {
-                s.startedToggles = true;
-                s.nextToggleAt = s.elapsedSeconds; // toggle immediately after warmup
-            } else {
-                return;
-            }
-        }
-
-        if (s.elapsedSeconds < s.nextToggleAt) return;
-
-        // Toggle state
-        s.cycleIndex++;
-        if ("off".equalsIgnoreCase(s.cheatState)) {
-            s.cheatState = "on";
-            send(player, "[AsyncAnticheat Dev] TOGGLE CHEAT ON now.");
-            enqueueMarker(player, s.devSessionId, s.label, "toggle", "on", Map.of("cycle", s.cycleIndex));
-        } else {
-            s.cheatState = "off";
-            send(player, "[AsyncAnticheat Dev] TOGGLE CHEAT OFF now.");
-            enqueueMarker(player, s.devSessionId, s.label, "toggle", "off", Map.of("cycle", s.cycleIndex));
-        }
-        s.nextToggleAt = s.elapsedSeconds + s.toggleSeconds;
-    }
-
-    private void enqueueMarker(
-            @NotNull Player player,
-            @NotNull String devSessionId,
-            @NotNull String label,
-            @NotNull String phase,
-            @NotNull String cheatState,
-            @NotNull Map<String, Object> extra
-    ) {
-        final Map<String, Object> fields = new HashMap<>();
-        fields.put("dev_session_id", devSessionId);
-        fields.put("dev_label", label);
-        fields.put("dev_phase", phase); // start|toggle|stop
-        fields.put("dev_state", cheatState); // on|off
-        fields.putAll(extra);
-        service.tryEnqueue(new PacketRecord(
-                System.currentTimeMillis(),
-                "dev",
-                "DEV_MARKER",
-                player.getUniqueId().toString(),
-                player.getName(),
-                fields
-        ));
-    }
-
-    private static void send(@NotNull Player player, @NotNull String msg) {
-        player.sendMessage(msg);
-    }
-
-    private static void sendStartNotice(
-            @NotNull Player player,
-            @NotNull String label,
-            int durationSeconds,
-            int warmupSeconds,
-            int toggleSeconds
-    ) {
-        // Chat (always visible in logs / for players without title support).
-        send(player, "[AsyncAnticheat Dev] RECORDING STARTED: label=" + label
-                + " duration=" + durationSeconds + "s warmup=" + warmupSeconds + "s toggle=" + toggleSeconds + "s"
-                + " (start with CHEAT OFF)");
-        // Title (more visible to the player).
-        try {
-            player.sendTitle(
-                    "AsyncAnticheat DEV",
-                    "Recording started: " + label + " (CHEAT OFF)",
-                    10, 60, 10
-            );
-        } catch (Throwable ignored) {
-            // Some servers/platforms may not support titles; chat message is enough.
-        }
-    }
-
-    private static void sendStopNotice(@NotNull Player player, @NotNull String label, @NotNull String reason) {
-        send(player, "[AsyncAnticheat Dev] RECORDING STOPPED: label=" + label + " reason=" + reason);
-        try {
-            player.sendTitle(
-                    "AsyncAnticheat DEV",
-                    "Recording stopped: " + label,
-                    10, 60, 10
-            );
-        } catch (Throwable ignored) {
-        }
-    }
-
-    static final class Session {
-        final UUID playerId;
-        final String devSessionId;
-        final String label;
-        final int durationSeconds;
-        final int warmupSeconds;
-        final int toggleSeconds;
-
-        SchedulerUtil.ScheduledTask scheduledTask = null;
-        int elapsedSeconds = 0;
-        boolean startedToggles = false;
-        int nextToggleAt = 0;
-        int cycleIndex = 0;
-        String cheatState = "off";
-
-        Session(UUID playerId, String devSessionId, String label, int durationSeconds, int warmupSeconds, int toggleSeconds) {
-            this.playerId = playerId;
-            this.devSessionId = devSessionId;
-            this.label = label;
-            this.durationSeconds = durationSeconds;
-            this.warmupSeconds = warmupSeconds;
-            this.toggleSeconds = toggleSeconds;
-        }
-    }
-}
-
-
diff --git a/asyncanticheat-bukkit/src/main/java/md/thomas/asyncanticheat/bukkit/BukkitLinkCommand.java b/asyncanticheat-bukkit/src/main/java/md/thomas/asyncanticheat/bukkit/BukkitLinkCommand.java
deleted file mode 100644
index 870601e..0000000
--- a/asyncanticheat-bukkit/src/main/java/md/thomas/asyncanticheat/bukkit/BukkitLinkCommand.java
+++ /dev/null
@@ -1,30 +0,0 @@
-package md.thomas.asyncanticheat.bukkit;
-
-import md.thomas.asyncanticheat.core.AsyncAnticheatService;
-import org.bukkit.command.Command;
-import org.bukkit.command.CommandExecutor;
-import org.bukkit.command.CommandSender;
-import org.jetbrains.annotations.NotNull;
-
-final class BukkitLinkCommand implements CommandExecutor {
-
-    private final AsyncAnticheatService service;
-
-    BukkitLinkCommand(@NotNull AsyncAnticheatService service) {
-        this.service = service;
-    }
-
-    @Override
-    public boolean onCommand(@NotNull CommandSender sender, @NotNull Command command, @NotNull String label, @NotNull String[] args) {
-        if (service.isDashboardRegistered()) {
-            sender.sendMessage("[AsyncAnticheat] Dashboard: registered");
-            return true;
-        }
-
-        sender.sendMessage("[AsyncAnticheat] Dashboard: not configured yet.");
-        sender.sendMessage("[AsyncAnticheat] Link this server by opening:");
-        sender.sendMessage(service.getClaimUrl());
-        return true;
-    }
-}
-
diff --git a/asyncanticheat-bukkit/src/main/java/md/thomas/asyncanticheat/bukkit/BukkitMainCommand.java b/asyncanticheat-bukkit/src/main/java/md/thomas/asyncanticheat/bukkit/BukkitMainCommand.java
new file mode 100644
index 0000000..e4ff5c4
--- /dev/null
+++ b/asyncanticheat-bukkit/src/main/java/md/thomas/asyncanticheat/bukkit/BukkitMainCommand.java
@@ -0,0 +1,264 @@
+package md.thomas.asyncanticheat.bukkit;
+
+import md.thomas.asyncanticheat.core.AsyncAnticheatService;
+import org.bukkit.Bukkit;
+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;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+import java.time.Duration;
+import java.time.Instant;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+import java.util.Map;
+import java.util.UUID;
+import java.util.stream.Collectors;
+
+/**
+ * Main /aac command handler with subcommands:
+ * - /aac link - Show dashboard link status
+ * - /aac record <player> <type> [label] - Start recording
+ * - /aac record stop [player] - Stop recording
+ * - /aac record status - Show active recordings
+ */
+final class BukkitMainCommand implements CommandExecutor, TabCompleter {
+
+    private static final List<String> CHEAT_TYPES = Arrays.asList(
+            "killaura", "speed", "fly", "reach", "autoclicker",
+            "aimbot", "xray", "scaffold", "bhop", "nofall",
+            "antiknockback", "other"
+    );
+
+    private final AsyncAnticheatService service;
+    private final RecordingManager recordingManager;
+
+    BukkitMainCommand(@NotNull AsyncAnticheatService service, @NotNull RecordingManager recordingManager) {
+        this.service = service;
+        this.recordingManager = recordingManager;
+    }
+
+    @Override
+    public boolean onCommand(@NotNull CommandSender sender, @NotNull Command command, @NotNull String label, @NotNull String[] args) {
+        if (args.length == 0) {
+            return showStatus(sender);
+        }
+
+        final String sub = args[0].toLowerCase();
+        switch (sub) {
+            case "link", "status" -> {
+                return showStatus(sender);
+            }
+            case "record", "rec" -> {
+                return handleRecord(sender, Arrays.copyOfRange(args, 1, args.length));
+            }
+            default -> {
+                return showHelp(sender);
+            }
+        }
+    }
+
+    private boolean showStatus(@NotNull CommandSender sender) {
+        if (service.isDashboardRegistered()) {
+            sender.sendMessage("§a[AsyncAnticheat] §fDashboard: §aregistered");
+        } else if (service.isWaitingForDashboardRegistration()) {
+            sender.sendMessage("§a[AsyncAnticheat] §fDashboard: §ewaiting for registration");
+            sender.sendMessage("§7Link this server: §f" + service.getClaimUrl());
+        } else {
+            sender.sendMessage("§a[AsyncAnticheat] §fDashboard: §cnot configured");
+            sender.sendMessage("§7Link this server: §f" + service.getClaimUrl());
+        }
+        return true;
+    }
+
+    private boolean handleRecord(@NotNull CommandSender sender, @NotNull String[] args) {
+        if (!(sender instanceof Player player)) {
+            sender.sendMessage("§c[AsyncAnticheat] This command must be run by a player.");
+            return true;
+        }
+
+        if (!player.hasPermission("asyncanticheat.record")) {
+            sender.sendMessage("§c[AsyncAnticheat] Missing permission: asyncanticheat.record");
+            return true;
+        }
+
+        if (args.length == 0) {
+            return showRecordHelp(sender);
+        }
+
+        final String sub = args[0].toLowerCase();
+        switch (sub) {
+            case "stop" -> {
+                return handleRecordStop(player, Arrays.copyOfRange(args, 1, args.length));
+            }
+            case "status", "list" -> {
+                return handleRecordStatus(player);
+            }
+            default -> {
+                // args[0] is the player name, args[1] is cheat type
+                return handleRecordStart(player, args);
+            }
+        }
+    }
+
+    private boolean handleRecordStart(@NotNull Player recorder, @NotNull String[] args) {
+        if (args.length < 2) {
+            return showRecordHelp(recorder);
+        }
+
+        final String targetName = args[0];
+        final Player target = Bukkit.getPlayer(targetName);
+        if (target == null) {
+            recorder.sendMessage("§c[AsyncAnticheat] Player not found: " + targetName);
+            return true;
+        }
+
+        final String cheatType = args[1].toLowerCase();
+        final String label = args.length > 2 ? String.join(" ", Arrays.copyOfRange(args, 2, args.length)) : null;
+
+        if (recordingManager.startRecording(target, recorder, cheatType, label)) {
+            // Success message is sent by RecordingManager
+        } else {
+            recorder.sendMessage("§c[AsyncAnticheat] Already recording " + target.getName() +
+                    ". Use §f/aac record stop " + target.getName() + " §cfirst.");
+        }
+        return true;
+    }
+
+    private boolean handleRecordStop(@NotNull Player recorder, @NotNull String[] args) {
+        if (args.length == 0) {
+            // Stop all recordings by this recorder
+            final Map<UUID, RecordingManager.Recording> active = recordingManager.getActiveRecordings();
+            int stopped = 0;
+            for (Map.Entry<UUID, RecordingManager.Recording> entry : active.entrySet()) {
+                if (entry.getValue().recorderUuid.equals(recorder.getUniqueId())) {
+                    final Player target = Bukkit.getPlayer(entry.getKey());
+                    if (target != null) {
+                        recordingManager.stopRecording(target, recorder);
+                        stopped++;
+                    }
+                }
+            }
+            if (stopped == 0) {
+                recorder.sendMessage("§c[AsyncAnticheat] No active recordings to stop.");
+            } else {
+                recorder.sendMessage("§a[AsyncAnticheat] §fStopped " + stopped + " recording(s).");
+            }
+            return true;
+        }
+
+        final String targetName = args[0];
+        final Player target = Bukkit.getPlayer(targetName);
+        if (target == null) {
+            recorder.sendMessage("§c[AsyncAnticheat] Player not found: " + targetName);
+            return true;
+        }
+
+        if (recordingManager.stopRecording(target, recorder)) {
+            // Success message is sent by RecordingManager
+        } else {
+            recorder.sendMessage("§c[AsyncAnticheat] Not currently recording " + target.getName());
+        }
+        return true;
+    }
+
+    private boolean handleRecordStatus(@NotNull Player player) {
+        final Map<UUID, RecordingManager.Recording> active = recordingManager.getActiveRecordings();
+        if (active.isEmpty()) {
+            player.sendMessage("§a[AsyncAnticheat] §fNo active recordings.");
+            return true;
+        }
+
+        player.sendMessage("§a[AsyncAnticheat] §fActive recordings:");
+        for (RecordingManager.Recording recording : active.values()) {
+            final Duration elapsed = Duration.between(recording.startedAt, Instant.now());
+            final String elapsedStr = formatDuration(elapsed);
+            player.sendMessage(String.format("  §e%s §7- §c%s §7by §f%s §7(%s)",
+                    recording.playerName,
+                    recording.cheatType,
+                    recording.recorderName,
+                    elapsedStr
+            ));
+        }
+        return true;
+    }
+
+    private static String formatDuration(Duration duration) {
+        final long seconds = duration.getSeconds();
+        if (seconds < 60) {
+            return seconds + "s";
+        } else if (seconds < 3600) {
+            return (seconds / 60) + "m " + (seconds % 60) + "s";
+        } else {
+            return (seconds / 3600) + "h " + ((seconds % 3600) / 60) + "m";
+        }
+    }
+
+    private boolean showRecordHelp(@NotNull CommandSender sender) {
+        sender.sendMessage("§a[AsyncAnticheat] §fRecording commands:");
+        sender.sendMessage("  §f/aac record <player> <type> [label] §7- Start recording");
+        sender.sendMessage("  §f/aac record stop [player] §7- Stop recording");
+        sender.sendMessage("  §f/aac record status §7- Show active recordings");
+        sender.sendMessage("§7Cheat types: " + String.join(", ", CHEAT_TYPES));
+        return true;
+    }
+
+    private boolean showHelp(@NotNull CommandSender sender) {
+        sender.sendMessage("§a[AsyncAnticheat] §fCommands:");
+        sender.sendMessage("  §f/aac §7- Show dashboard status");
+        sender.sendMessage("  §f/aac record <player> <type> [label] §7- Start recording");
+        sender.sendMessage("  §f/aac record stop [player] §7- Stop recording");
+        sender.sendMessage("  §f/aac record status §7- Show active recordings");
+        return true;
+    }
+
+    @Override
+    public @Nullable List<String> onTabComplete(@NotNull CommandSender sender, @NotNull Command command,
+                                                 @NotNull String alias, @NotNull String[] args) {
+        final List<String> completions = new ArrayList<>();
+
+        if (args.length == 1) {
+            completions.addAll(Arrays.asList("link", "record", "status"));
+            return filter(completions, args[0]);
+        }
+
+        if (args.length >= 2 && args[0].equalsIgnoreCase("record")) {
+            if (args.length == 2) {
+                // /aac record <tab>
+                completions.add("stop");
+                completions.add("status");
+                // Add online player names
+                completions.addAll(Bukkit.getOnlinePlayers().stream()
+                        .map(Player::getName)
+                        .collect(Collectors.toList()));
+                return filter(completions, args[1]);
+            }
+
+            if (args.length == 3) {
+                if (args[1].equalsIgnoreCase("stop")) {
+                    // /aac record stop <tab> - show players being recorded
+                    completions.addAll(recordingManager.getActiveRecordings().values().stream()
+                            .map(r -> r.playerName)
+                            .collect(Collectors.toList()));
+                } else {
+                    // /aac record <player> <tab> - show cheat types
+                    completions.addAll(CHEAT_TYPES);
+                }
+                return filter(completions, args[2]);
+            }
+        }
+
+        return completions;
+    }
+
+    private static List<String> filter(List<String> options, String prefix) {
+        return options.stream()
+                .filter(s -> s.toLowerCase().startsWith(prefix.toLowerCase()))
+                .collect(Collectors.toList());
+    }
+}
+
diff --git a/asyncanticheat-bukkit/src/main/java/md/thomas/asyncanticheat/bukkit/RecordingManager.java b/asyncanticheat-bukkit/src/main/java/md/thomas/asyncanticheat/bukkit/RecordingManager.java
new file mode 100644
index 0000000..bad41ae
--- /dev/null
+++ b/asyncanticheat-bukkit/src/main/java/md/thomas/asyncanticheat/bukkit/RecordingManager.java
@@ -0,0 +1,265 @@
+package md.thomas.asyncanticheat.bukkit;
+
+import com.google.gson.Gson;
+import com.google.gson.GsonBuilder;
+import md.thomas.asyncanticheat.core.AsyncAnticheatConfig;
+import org.bukkit.Bukkit;
+import org.bukkit.entity.Player;
+import org.bukkit.plugin.Plugin;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+import java.net.URI;
+import java.net.http.HttpClient;
+import java.net.http.HttpRequest;
+import java.net.http.HttpResponse;
+import java.time.Duration;
+import java.time.Instant;
+import java.time.format.DateTimeFormatter;
+import java.util.Map;
+import java.util.UUID;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+
+/**
+ * Manages in-game cheat recordings that are submitted to the API.
+ * Simplified replacement for the old dev mode system.
+ */
+final class RecordingManager {
+
+    private final Plugin plugin;
+    private final AsyncAnticheatConfig config;
+    private final String serverId;
+
+    private final Map<UUID, Recording> activeRecordings = new ConcurrentHashMap<>();
+    private final HttpClient httpClient;
+    private final Gson gson = new GsonBuilder().disableHtmlEscaping().create();
+    private final ExecutorService executor = Executors.newSingleThreadExecutor(r -> {
+        Thread t = new Thread(r, "AsyncAnticheat-Recording");
+        t.setDaemon(true);
+        return t;
+    });
+
+    RecordingManager(@NotNull Plugin plugin, @NotNull AsyncAnticheatConfig config, @NotNull String serverId) {
+        this.plugin = plugin;
+        this.config = config;
+        this.serverId = serverId;
+        this.httpClient = HttpClient.newBuilder()
+                .connectTimeout(Duration.ofSeconds(config.getTimeoutSeconds()))
+                .build();
+    }
+
+    /**
+     * Start recording a player for a specific cheat type.
+     *
+     * @param target   The player being recorded
+     * @param recorder The staff member making the recording
+     * @param cheatType The type of cheat (killaura, speed, fly, etc.)
+     * @param label    Optional custom label/description
+     * @return true if recording started, false if already recording this player
+     */
+    boolean startRecording(
+            @NotNull Player target,
+            @NotNull Player recorder,
+            @NotNull String cheatType,
+            @Nullable String label
+    ) {
+        final UUID targetId = target.getUniqueId();
+        if (activeRecordings.containsKey(targetId)) {
+            return false; // Already recording
+        }
+
+        final Recording recording = new Recording(
+                target.getUniqueId(),
+                target.getName(),
+                recorder.getUniqueId(),
+                recorder.getName(),
+                cheatType,
+                label,
+                Instant.now()
+        );
+        activeRecordings.put(targetId, recording);
+
+        sendStartNotice(recorder, target, cheatType, label);
+        return true;
+    }
+
+    /**
+     * Stop recording a player and submit to the API.
+     *
+     * @param target   The player being recorded
+     * @param recorder The staff member (for messaging)
+     * @return true if recording was stopped, false if not recording
+     */
+    boolean stopRecording(@NotNull Player target, @Nullable Player recorder) {
+        final UUID targetId = target.getUniqueId();
+        final Recording recording = activeRecordings.remove(targetId);
+        if (recording == null) {
+            return false; // Not recording
+        }
+
+        final Instant endedAt = Instant.now();
+        submitRecording(recording, endedAt);
+
+        if (recorder != null) {
+            sendStopNotice(recorder, target, recording.cheatType);
+        }
+        return true;
+    }
+
+    /**
+     * Stop recording by target UUID (used when player disconnects).
+     */
+    void stopRecordingByUuid(@NotNull UUID targetId) {
+        final Recording recording = activeRecordings.remove(targetId);
+        if (recording == null) return;
+
+        submitRecording(recording, Instant.now());
+        plugin.getLogger().info("[Recording] Auto-stopped recording for " + recording.playerName + " (disconnected)");
+    }
+
+    /**
+     * Get the active recording for a player.
+     */
+    @Nullable
+    Recording getRecording(@NotNull UUID playerId) {
+        return activeRecordings.get(playerId);
+    }
+
+    /**
+     * Get all active recordings.
+     */
+    @NotNull
+    Map<UUID, Recording> getActiveRecordings() {
+        return Map.copyOf(activeRecordings);
+    }
+
+    /**
+     * Stop all active recordings (on plugin disable).
+     */
+    void stopAll() {
+        for (UUID targetId : activeRecordings.keySet().toArray(new UUID[0])) {
+            final Recording recording = activeRecordings.remove(targetId);
+            if (recording != null) {
+                submitRecording(recording, Instant.now());
+            }
+        }
+        executor.shutdown();
+    }
+
+    /**
+     * Called when a player quits - auto-stop their recording if active.
+     */
+    void handlePlayerQuit(@NotNull UUID playerId) {
+        if (activeRecordings.containsKey(playerId)) {
+            stopRecordingByUuid(playerId);
+        }
+    }
+
+    private void submitRecording(@NotNull Recording recording, @NotNull Instant endedAt) {
+        executor.execute(() -> {
+            try {
+                final String token = config.getApiToken();
+                if (token == null || token.isBlank()) {
+                    plugin.getLogger().warning("[Recording] Cannot submit: api.token not configured");
+                    return;
+                }
+
+                final String url = normalizeBaseUrl(config.getApiUrl()) + "/observations";
+                final Map<String, Object> body = Map.of(
+                        "observation_type", "recording",
+                        "player_uuid", recording.playerUuid.toString(),
+                        "player_name", recording.playerName,
+                        "cheat_type", recording.cheatType,
+                        "label", recording.label != null ? recording.label : "",
+                        "started_at", DateTimeFormatter.ISO_INSTANT.format(recording.startedAt),
+                        "ended_at", DateTimeFormatter.ISO_INSTANT.format(endedAt),
+                        "recorded_by_uuid", recording.recorderUuid.toString(),
+                        "recorded_by_name", recording.recorderName,
+                        "session_id", "" // Could add session tracking if needed
+                );
+
+                final HttpRequest req = HttpRequest.newBuilder()
+                        .uri(URI.create(url))
+                        .timeout(Duration.ofSeconds(config.getTimeoutSeconds()))
+                        .header("Authorization", "Bearer " + token)
+                        .header("Content-Type", "application/json")
+                        .header("X-Server-Id", serverId)
+                        .POST(HttpRequest.BodyPublishers.ofString(gson.toJson(body)))
+                        .build();
+
+                final HttpResponse<String> resp = httpClient.send(req, HttpResponse.BodyHandlers.ofString());
+                if (resp.statusCode() >= 200 && resp.statusCode() < 300) {
+                    plugin.getLogger().info("[Recording] Submitted recording for " + recording.playerName +
+                            " (" + recording.cheatType + ")");
+                } else {
+                    plugin.getLogger().warning("[Recording] Failed to submit: " + resp.statusCode() +
+                            " - " + resp.body());
+                }
+            } catch (Exception e) {
+                plugin.getLogger().warning("[Recording] Failed to submit recording: " + e.getMessage());
+            }
+        });
+    }
+
+    @NotNull
+    private static String normalizeBaseUrl(@NotNull String baseUrl) {
+        String b = baseUrl.trim();
+        while (b.endsWith("/")) b = b.substring(0, b.length() - 1);
+        return b;
+    }
+
+    private static void sendStartNotice(@NotNull Player recorder, @NotNull Player target,
+                                         @NotNull String cheatType, @Nullable String label) {
+        final String labelText = label != null && !label.isBlank() ? " (" + label + ")" : "";
+        recorder.sendMessage("§a[AsyncAnticheat] §fStarted recording §e" + target.getName() +
+                " §ffor §c" + cheatType + labelText);
+        try {
+            recorder.sendTitle(
+                    "§aRecording Started",
+                    "§f" + target.getName() + " §7- §c" + cheatType,
+                    10, 40, 10
+            );
+        } catch (Throwable ignored) {
+        }
+    }
+
+    private static void sendStopNotice(@NotNull Player recorder, @NotNull Player target, @NotNull String cheatType) {
+        recorder.sendMessage("§a[AsyncAnticheat] §fStopped recording §e" + target.getName() +
+                " §ffor §c" + cheatType + " §7(submitted to dashboard)");
+        try {
+            recorder.sendTitle(
+                    "§cRecording Stopped",
+                    "§f" + target.getName() + " §7- submitted",
+                    10, 40, 10
+            );
+        } catch (Throwable ignored) {
+        }
+    }
+
+    /**
+     * Represents an active recording session.
+     */
+    static final class Recording {
+        final UUID playerUuid;
+        final String playerName;
+        final UUID recorderUuid;
+        final String recorderName;
+        final String cheatType;
+        final String label;
+        final Instant startedAt;
+
+        Recording(UUID playerUuid, String playerName, UUID recorderUuid, String recorderName,
+                  String cheatType, String label, Instant startedAt) {
+            this.playerUuid = playerUuid;
+            this.playerName = playerName;
+            this.recorderUuid = recorderUuid;
+            this.recorderName = recorderName;
+            this.cheatType = cheatType;
+            this.label = label;
+            this.startedAt = startedAt;
+        }
+    }
+}
+
diff --git a/asyncanticheat-bukkit/src/main/resources/plugin.yml b/asyncanticheat-bukkit/src/main/resources/plugin.yml
index cbb8718..363d535 100644
--- a/asyncanticheat-bukkit/src/main/resources/plugin.yml
+++ b/asyncanticheat-bukkit/src/main/resources/plugin.yml
@@ -15,18 +15,14 @@ softdepend:
   - Geyser-Spigot
 
 commands:
-  aacdev:
-    description: AsyncAnticheat dev mode (labeled packet recording)
-    usage: /aacdev <start|stop|status> ...
-    permission: asyncanticheat.dev
   aac:
-    description: AsyncAnticheat dashboard linking / status
-    usage: /aac
+    description: AsyncAnticheat main command - dashboard status and recording
+    usage: /aac [record|status]
     aliases: [asyncanticheat]
 
 permissions:
-  asyncanticheat.dev:
-    description: Allows using AsyncAnticheat dev mode for labeled data recording
+  asyncanticheat.record:
+    description: Allows using AsyncAnticheat in-game recording (/aac record)
     default: op
 
 
diff --git a/asyncanticheat-core/src/main/java/md/thomas/asyncanticheat/core/AsyncAnticheatService.java b/asyncanticheat-core/src/main/java/md/thomas/asyncanticheat/core/AsyncAnticheatService.java
index 17b01f4..38c2dae 100644
--- a/asyncanticheat-core/src/main/java/md/thomas/asyncanticheat/core/AsyncAnticheatService.java
+++ b/asyncanticheat-core/src/main/java/md/thomas/asyncanticheat/core/AsyncAnticheatService.java
@@ -2,11 +2,17 @@
 
 import com.google.gson.Gson;
 import com.google.gson.GsonBuilder;
+import com.google.gson.TypeAdapter;
+import com.google.gson.stream.JsonReader;
+import com.google.gson.stream.JsonToken;
+import com.google.gson.stream.JsonWriter;
 import org.jetbrains.annotations.NotNull;
 
 import java.io.File;
+import java.io.IOException;
 import java.util.ArrayList;
 import java.util.List;
+import java.util.Optional;
 import java.util.UUID;
 import java.util.concurrent.ArrayBlockingQueue;
 import java.util.concurrent.ScheduledExecutorService;
@@ -39,7 +45,49 @@ public final class AsyncAnticheatService {
     // overlap.
     private final AtomicBoolean flushRunning = new AtomicBoolean(false);
 
-    private final Gson gson = new GsonBuilder().disableHtmlEscaping().create();
+    private final Gson gson = new GsonBuilder()
+            .disableHtmlEscaping()
+            .registerTypeAdapter(Optional.class, new OptionalTypeAdapter())
+            .create();
+
+    /**
+     * TypeAdapter for java.util.Optional to avoid reflection issues on Java 9+.
+     * Serializes Optional.empty() as null, Optional.of(x) as x.
+     */
+    @SuppressWarnings("rawtypes")
+    private static class OptionalTypeAdapter extends TypeAdapter<Optional> {
+        @Override
+        public void write(JsonWriter out, Optional value) throws IOException {
+            if (value == null || value.isEmpty()) {
+                out.nullValue();
+            } else {
+                // Write the contained value directly (Gson will handle it)
+                Object inner = value.get();
+                if (inner == null) {
+                    out.nullValue();
+                } else if (inner instanceof String s) {
+                    out.value(s);
+                } else if (inner instanceof Number n) {
+                    out.value(n);
+                } else if (inner instanceof Boolean b) {
+                    out.value(b);
+                } else {
+                    // Fallback: convert to string
+                    out.value(inner.toString());
+                }
+            }
+        }
+
+        @Override
+        public Optional read(JsonReader in) throws IOException {
+            if (in.peek() == JsonToken.NULL) {
+                in.nextNull();
+                return Optional.empty();
+            }
+            // Read as string for simplicity
+            return Optional.of(in.nextString());
+        }
+    }
     private final DiskSpool spool;
     private final HttpUploader uploader;
 
@@ -170,4 +218,12 @@ public boolean isDashboardRegistered() {
     public boolean isWaitingForDashboardRegistration() {
         return uploader.getRegistrationState() == HttpUploader.REG_WAITING;
     }
+
+    /**
+     * Returns the unique server ID used for API authentication.
+     */
+    @NotNull
+    public String getServerId() {
+        return serverIdentity.getServerId();
+    }
 }