Refactor MusicAccess permission checks

Reordered admin check in `MusicAccess` for efficiency by prioritizing it before role-related logic. This improves readability and minimizes unnecessary role lookups for admin users.

.env.example

@@ -1,26 +1,31 @@
 NETNEUTRALITY_TAG=latest
-
 NETNEUTRALITY_BOT_ENV=dev
 NETNEUTRALITY_BOT_TOKEN=
 NETNEUTRALITY_BOT_PREFIX=$
 NETNEUTRALITY_BOT_OWNER=
 NETNEUTRALITY_BOT_INVITE=
 NETNEUTRALITY_API_PORT=9000
+NETNEUTRALITY_API_KEY=
 
 MYSQL_HOST=127.0.0.1
 MYSQL_PORT=3306
 MYSQL_USER=java
 MYSQL_PASSWORD=password
 MYSQL_DATABASE=netneutrality
-MYSQL_ROOT_PASSWORD=password
-MARIADB_AUTO_UPGRADE=1
 
+NETNEUTRALITY_LAVALINK_URI=ws://lavalink:2333
+NETNEUTRALITY_LAVALINK_PASSWORD=youshallnotpass
+NETNEUTRALITY_LAVALINK_NAME=dev-player
 NETNEUTRALITY_PO_TOKEN=
 NETNEUTRALITY_VISITOR_DATA=
-NETNEUTRALITY_CIPHER_URL=http://localhost:8001
+NETNEUTRALITY_OAUTH_TOKEN=
+NETNEUTRALITY_CIPHER_URL=http://ejs-api:8001
 NETNEUTRALITY_CIPHER_PASSWORD=
+NETNEUTRALITY_WEBPO_URL=http://webpo:8080
+NETNEUTRALITY_WEBPO_PASSWORD=
 
 NETNEUTRALITY_SENTRY_DSN=
-GITLAB_HOST=
+GITEA_HOST=
-GITLAB_TOKEN=
+GITEA_TOKEN=
-GITLAB_PROJECT_ID=
+GITEA_OWNER=
+GITEA_REPO=

.github/workflows/ci.yml

@@ -129,5 +129,5 @@ jobs:
           file: ./Dockerfile
           push: true
           tags: ${{ steps.meta.outputs.tags }}
-          cache-from: type=registry,ref=${{ secrets.REGISTRY_URL }}/${{ secrets.REGISTRY_USER }}/netneutrality:buildcache
+          cache-from: type=gha
-          cache-to: type=registry,ref=${{ secrets.REGISTRY_URL }}/${{ secrets.REGISTRY_USER }}/netneutrality:buildcache,mode=max
+          cache-to: type=gha,mode=max

.gitignore

@@ -33,12 +33,12 @@ hs_err_pid*
 .idea/
 *.iml
 *.iws
+.junie/plans
 
 # Mac
 .DS_Store
 
 # Maven
-log/
 target/
 
 #log4j

bot.properties.example

@@ -20,7 +20,12 @@ NETNEUTRALITY_VISITOR_DATA=
 NETNEUTRALITY_CIPHER_URL=http://localhost:8001
 NETNEUTRALITY_CIPHER_PASSWORD=
 
+NETNEUTRALITY_LAVALINK_URI=ws://lavalink:2333
+NETNEUTRALITY_LAVALINK_PASSWORD=youshallnotpass
+NETNEUTRALITY_LAVALINK_NAME=main
+
 NETNEUTRALITY_SENTRY_DSN=
-GITLAB_HOST=
+GITEA_HOST=
-GITLAB_TOKEN=
+GITEA_TOKEN=
-GITLAB_PROJECT_ID=
+GITEA_OWNER=
+GITEA_REPO=

docker-compose.yml

@@ -23,14 +23,39 @@ services:
       - netneutrality
     depends_on:
       - netneutrality-db
+      - lavalink
     volumes:
       - ./logs:/app/logs
     environment:
-      MYSQL_HOST: netneutrality-db
+      - MYSQL_HOST=${MYSQL_HOST:-netneutrality-db}
-      MYSQL_PORT: 3306
+      - MYSQL_PORT=${MYSQL_PORT:-3306}
-      MYSQL_USER: java
+      - MYSQL_USER=${MYSQL_USER:-java}
-      MYSQL_PASSWORD: password
+      - MYSQL_PASSWORD=${MYSQL_PASSWORD:-password}
-      MYSQL_DATABASE: netneutrality
+      - MYSQL_DATABASE=${MYSQL_DATABASE:-netneutrality}
+      - API_PORT=${NETNEUTRALITY_API_PORT:-9000}
+
+  # Lavalink >= 4.2.0 is required: the node handles DAVE end-to-end encryption,
+  # so the bot no longer ships native encoders.
+  lavalink:
+    image: ghcr.io/lavalink-devs/lavalink:4.2
+    container_name: lavalink
+    restart: unless-stopped
+    networks:
+      - netneutrality
+    depends_on:
+      - ejs-api
+      - webpo
+    volumes:
+      - ./lavalink/application.yml:/opt/Lavalink/application.yml:ro
+    environment:
+      - SERVER_PASSWORD=${NETNEUTRALITY_LAVALINK_PASSWORD:-youshallnotpass}
+      - NETNEUTRALITY_CIPHER_URL=${NETNEUTRALITY_CIPHER_URL:-http://ejs-api:8001}
+      - NETNEUTRALITY_CIPHER_PASSWORD=${NETNEUTRALITY_CIPHER_PASSWORD:-}
+      - NETNEUTRALITY_OAUTH_TOKEN=${NETNEUTRALITY_OAUTH_TOKEN:-}
+      - NETNEUTRALITY_POT_URL=${NETNEUTRALITY_POT_URL:-http://webpo:8080}
+      - NETNEUTRALITY_PO_TOKEN=${NETNEUTRALITY_PO_TOKEN:-}
+      - NETNEUTRALITY_VISITOR_DATA=${NETNEUTRALITY_VISITOR_DATA:-}
+
   ejs-api:
     image: ghcr.io/kikkia/yt-cipher:master@sha256:4c5ec381ff57336cfc24822d2b526a5ad7cd0171f61065a1bbc87bb736842449
     container_name: ejs_signature_api
@@ -39,8 +64,25 @@ services:
       - netneutrality
     # environment: # UNCOMMENT THIS LINE AND API_TOKEN TO ADD A PASSWORD
     #   - API_TOKEN=test
+
+  webpo:
+    image: ghcr.io/ashton045/webpo-generator
+    container_name: webpo-generator
+    environment:
+      - HOST=${HOST:-::}
+      - PORT=${PORT:-8080}
+      - WORKERS=${WORKERS:-1}
+      - QUEUE_SIZE=${QUEUE_SIZE:-32}
+      - MAX_PENDING_REQUESTS=${MAX_PENDING_REQUESTS:-256}
+      - REQUEST_TIMEOUT=${REQUEST_TIMEOUT:-30000}
+      - CACHE_SIZE=${CACHE_SIZE:-100}
+      - CACHE_TTL=${CACHE_TTL:-300000}
+      - VISITOR_TTL=${VISITOR_TTL:-600000}
+      - API_TOKEN=
+    restart: unless-stopped
 volumes:
   netneutrality-db: null
+  netneutrality-lavalink-plugins: null
 
 networks:
   netneutrality: null

docs/README.md

@@ -0,0 +1,37 @@
+# Net Neutrality — Technical Documentation
+
+This directory contains detailed technical documentation for the **Net Neutrality** Discord bot
+(`me.bobert:netneutrality`, version `3.0.0`).
+
+It is intended for developers working on the codebase. It documents every major system and
+subsystem, how they fit together, and the end-to-end flows that tie them.
+
+## Table of contents
+
+| Document | Subsystem |
+|---|---|
+| [architecture.md](architecture.md) | High-level architecture, startup/shutdown lifecycle, tech stack |
+| [events.md](events.md) | Event handling & routing (`EventsHandler`) |
+| [contexts.md](contexts.md) | Contexts — the abstraction over Discord events |
+| [commands.md](commands.md) | Commands — message & slash commands, dispatch, options |
+| [tasks.md](tasks.md) | Tasks — button/emoji/modal/step/built-in/persistable/scheduled tasks |
+| [persistence.md](persistence.md) | Database — Hibernate/JPA, Flyway, entities, repositories, services |
+| [music.md](music.md) | Music — Lavalink node & client, queue, event dispatch |
+| [web-api.md](web-api.md) | HTTP Web API — internal control & introspection server |
+| [threading.md](threading.md) | Threading & scheduling infrastructure |
+| [utilities-and-bootstrap.md](utilities-and-bootstrap.md) | Utilities, configuration, logging, exceptions |
+
+## How to read this documentation
+
+Start with [architecture.md](architecture.md) for the big picture and the startup sequence.
+Then read [events.md](events.md) and [contexts.md](contexts.md), because almost everything else
+is triggered through a **Context** produced by the **EventsHandler**. From there, the two primary
+execution paths are [commands.md](commands.md) and [tasks.md](tasks.md).
+
+## Conventions
+
+- Class names are given fully qualified on first mention, then by simple name.
+- Database entity classes are prefixed with `O` (e.g. `OGuild`), and are documented in
+  [persistence.md](persistence.md).
+- Environment variables / configuration keys use the `NETNEUTRALITY_*` and `MYSQL_*` prefixes and
+  are documented in [utilities-and-bootstrap.md](utilities-and-bootstrap.md).

docs/architecture.md

@@ -0,0 +1,161 @@
+# Architecture Overview
+
+Net Neutrality is a Java 25 Discord bot built on top of [JDA](https://github.com/discord-jda/JDA).
+It is packaged as a single fat JAR (via the Maven Shade plugin) whose entry point is
+`me.bobert.netneutrality.App`.
+
+## Big picture
+
+Discord sends **events** over the gateway. A single JDA `EventListener`
+(`me.bobert.netneutrality.hooks.EventsHandler`) receives every event and turns it into a
+**Context** — a high-level abstraction over that event. Each context is then routed to one of three
+execution paths:
+
+```
+                              ┌──────────────────────────────┐
+     Discord Gateway  ───────▶│        EventsHandler         │
+        (JDA events)          │  event class → Context factory│
+                              └───────────────┬──────────────┘
+                                              │ builds a Context
+                    ┌─────────────────────────┼───────────────────────────┐
+                    ▼                          ▼                           ▼
+            CommandContext              TaskContext                (no Context)
+                    │                          │                    lambda /
+                    ▼                          ▼                    consumer runs
+            CommandProcessor            TaskManager.handle()        directly
+            .dispatch()                 (lookup task by id)          (e.g. GuildJoin)
+                    │                          │
+                    ▼                          ▼
+             Command.execute()          Task.execute()
+```
+
+1. **Command flow** — the context is a `CommandContext`; it is handed to `CommandProcessor` which
+   resolves and runs a `Command`. See [commands.md](commands.md).
+2. **Task flow** — the context is a `TaskContext`; it is handed to `TaskManager` which looks up a
+   `Task` by its **id** and runs it. See [tasks.md](tasks.md).
+3. **Lambda flow** — for simple events (e.g. `GuildJoinEvent`, `GuildLeaveEvent`) a consumer runs
+   directly and no context is routed onward. See [events.md](events.md).
+
+Around this core are the supporting subsystems: [persistence](persistence.md) (Hibernate + Flyway),
+[music](music.md) (a remote Lavalink node), the [web API](web-api.md), and the [threading/scheduling](threading.md)
+infrastructure.
+
+## Technology stack
+
+| Concern | Library | Version |
+|---|---|---|
+| Discord API | `net.dv8tion:JDA` | 6.4.1 |
+| Audio engine | Lavalink v4 node (`ghcr.io/lavalink-devs/lavalink`) | 4.2 |
+| Audio client | `dev.arbjerg:lavalink-client` | 3.4.0 |
+| ORM | `org.hibernate.orm:hibernate-core` | 7.1.9.Final |
+| Connection pool | `hibernate-hikaricp` (HikariCP) | 7.1.9.Final |
+| JDBC driver | `com.mysql:mysql-connector-j` | 9.7.0 |
+| DB migrations | `org.flywaydb:flyway-core` / `flyway-mysql` | 11.20.3 |
+| Error tracking | `io.sentry:sentry` | 8.41.0 |
+| HTTP client | `com.squareup.okhttp3:okhttp-jvm` | 5.3.2 |
+| JSON | `org.json:json` + `com.google.code.gson:gson` | — |
+| Classpath scanning | `org.reflections:reflections` | 0.10.2 |
+| Emoji parsing | `net.fellbaum:jemoji` | 1.7.6 |
+| Logging | Log4j2 + `log4j-slf4j2-impl` | 2.26.0 |
+| Testing | JUnit Jupiter 6 + Mockito 5 | — |
+
+The HTTP **server** for the internal API uses the JDK built-in
+`com.sun.net.httpserver.HttpServer` (no external framework); see [web-api.md](web-api.md).
+
+## Startup lifecycle
+
+The entry point is `App.main()` followed by the `App()` constructor which calls
+`startup()`. Bootstrap is driven by a hand-rolled
+[`ApplicationContext`](utilities-and-bootstrap.md#applicationcontext--lifecycle) that owns wired
+instances and starts every [`Lifecycle`](utilities-and-bootstrap.md#applicationcontext--lifecycle)
+component in ascending priority order.
+
+1. **Print banner / read env** — reads `NETNEUTRALITY_BOT_ENV` (default `dev`) via the early-bootstrap
+   `Settings.getInstance()` singleton (the only remaining process-wide settings access point; it is
+   also registered into the context as `SettingsProvider` for constructor injection).
+2. **Sentry** — if `NETNEUTRALITY_SENTRY_DSN` is set, initialize the Sentry SDK
+   (environment, release = `VERSION`, traces sample rate 1.0).
+3. **Log levels** — in `dev`, raise JDA and Lavalink client logging to `DEBUG`.
+4. `startup()`:
+   1. Validate `NETNEUTRALITY_BOT_TOKEN` is present (throws if missing).
+   2. `buildContext()` — register domain services and lifecycle adapters (see priorities below).
+   3. `context.start()` — start every `Lifecycle` component in ascending priority order.
+   4. Register a JVM shutdown hook calling `shutdown()` → `context.stop()`.
+
+### Lifecycle priorities (startup order)
+
+| Priority | Component | What `start()` does |
+|---|---|---|
+| 10 | `SessionManager` (`SessionProvider`) | Build Hibernate `SessionFactory` + run Flyway migrations. Binds itself into `JpaUtils`. |
+| 20 | `ThreadManager` (`ExecutorProvider`) | No-op start (executors are lazy). Bound into `ChannelMessagePurger`. |
+| 30 | `CommandManager` (`CommandRegistry`) | Reflectively discover/register `Command` implementations with context-aware constructor injection. |
+| 30 | `TaskManagerImpl` (`TaskManager`) | Reflectively load built-in & scheduled tasks (DI) and reload persistable tasks from the DB. |
+| 40 | `MusicServiceImpl` (`MusicService`) | Create the shared `LavalinkClient`, register the node and subscribe to its events. |
+| 55 | `ScheduledTaskManager` | No-op start (tasks are scheduled by `TaskManager` during its own start). |
+| 60 | JDA adapter | Build `JDA` with gateway intents and await ready. |
+| 65 | Post-JDA adapter | Register slash commands, attach `EventsHandler` (injected providers), set presence. |
+| 70 | `WebApi` | Start the internal HTTP server (`NETNEUTRALITY_API_PORT`, default 9000). |
+
+Commands and tasks that need shared services declare them as constructor parameters
+(`MusicService`, `TaskManager`, `GuildServiceProvider`, `SettingsProvider`, `CommandRegistry`, …).
+`ReflectionHelper` picks the richest public constructor whose parameter types all resolve from the
+context (falling back to a no-arg constructor when none match).
+
+### Gateway intents
+
+`initJDA()` enables: `GUILD_MEMBERS`, `GUILD_MESSAGE_REACTIONS`, `GUILD_VOICE_STATES`,
+`MESSAGE_CONTENT`. It also installs `new JDAVoiceUpdateListener(music.getClient())` as the voice
+dispatch interceptor, so voice server/state updates are forwarded to Lavalink instead of JDA's own
+audio stack. DAVE (end-to-end encrypted voice) is handled by the node, which is why the bot no
+longer ships native audio encoders.
+
+## Shutdown lifecycle
+
+`App.shutdown()` (invoked by the JVM shutdown hook, `ShutdownCommand`, or the HTTP
+`/actions/shutdown` endpoint) calls `context.stop()`, which stops every registered `Lifecycle`
+component in the **exact reverse** of start order. Failures in one component are logged and do not
+block the others. Effectively this means:
+
+1. `WebApi.stop()` — stop the HTTP server and its executor.
+2. Post-JDA adapter — no-op.
+3. JDA adapter — `jda.shutdown()`.
+4. `ScheduledTaskManager.stop()` — cancel all scheduled tasks.
+5. `MusicServiceImpl.stop()` — dispose the event subscriptions, destroy the players and close the Lavalink client.
+6. `CommandManager` / `TaskManagerImpl` — no-op stop today.
+7. `ThreadManager.stop()` — shut down the shared executors.
+8. `SessionManager.stop()` — release the Hibernate registry / connection pool.
+
+## Configuration & build
+
+- **Config sources** — `Settings` loads `bot.properties` and overlays environment variables (env
+  vars win). See [utilities-and-bootstrap.md](utilities-and-bootstrap.md#settings). An example file
+  lives at `bot.properties.example`.
+- **Build** — `./mvnw package` produces `target/netneutrality.jar` (Shade fat JAR, main class
+  `me.bobert.netneutrality.App`). Checkstyle (`checkstyle.xml`) runs in the `test` phase
+  and fails the build on violations.
+- **Run** — the preferred method is Docker Compose (`docker compose build && docker compose up -d`),
+  which also provisions the MariaDB database. See `README.md` and `docker-compose.yml`.
+
+## Package map
+
+| Package                                           | Contents                                                                                                |
+|---------------------------------------------------|---------------------------------------------------------------------------------------------------------|
+| `me.bobert.netneutrality`                         | Entry point (`App`)                                                                                     |
+| `…bootstrap`                                      | `ApplicationContext`, `Lifecycle`, `BotState`, `ReflectionHelper`                                       |
+| `…core.command`                                   | Command engine (registry, processor, manager, options, impl bases)                                      |
+| `…core.context`                                   | Context interfaces, abstract bases (`CommandContext`, `TaskContext`, etc.)                              |
+| `…core.tasks`                                     | Task engine (manager, subtypes, traits, persistence, generic buttons)                                   |
+| `…core.thread`                                    | Executors & scheduling (`ThreadManager`, `ScheduledTaskManager`, `BaseThreadFactory`)                   |
+| `…core`                                           | `LogHandler`                                                                                            |
+| `…command.*`                                      | Concrete command implementations (`admin`, `basic`, `bot`, `crypto`, `custom`, `git`, `music`, `react`) |
+| `…context.command` / `…context.tasks`             | Concrete context implementations (slash, message, button, modal, emoji, etc.)                           |
+| `…context`                                        | `MusicChannelContext`                                                                                   |
+| `…tasks.*`                                        | Concrete task implementations (`git`, `help`, `music`, `reaction`)                                      |
+| `…db`                                             | Session/migration, `Repository`, `JpaUtils`, `GSettings`                                                |
+| `…db.entities` / `…db.repository` / `…db.service` | Persistence model, repositories, services                                                               |
+| `…hooks`                                          | `EventsHandler`                                                                                         |
+| `…http`                                           | Internal web API and HTTP client module                                                                 |
+| `…music`                                          | Music domain (service, manager, queue, scheduler, track loading)                                        |
+| `…utils`                                          | `Settings` / `SettingsProvider`, `ChannelMessagePurger`, `MusicUtils`                                   |
+| `…shared.util`                                    | Cross-cutting helpers                                                                                   |
+| `…exceptions`                                     | Custom exception hierarchy                                                                              |

docs/commands.md

@@ -0,0 +1,169 @@
+# Commands
+
+**Packages:** `me.bobert.netneutrality.framework.command` (framework),
+`me.bobert.netneutrality.feature.*.command` (concrete commands)
+
+A **Command** is what a user executes on Discord. It receives a
+[`CommandContext`](contexts.md#commandcontext) and runs logic based on it. There are two primary
+kinds:
+
+- **Slash commands** — first-class Discord application commands. Their structure (options,
+  subcommands, groups) has rules defined by Discord and must be configured **procedurally** via
+  `CommandOptionsBuilder`.
+- **Message (prefix) commands** — a plain message beginning with the configured prefix
+  (`NETNEUTRALITY_BOT_PREFIX`, default `$`).
+
+A core goal of the framework is that **both kinds are authored the same way**: a command declares its
+metadata and options once, and the framework adapts it to either interaction style. Most of that
+adaptation logic lives in `CommandProcessor`.
+
+## The `Command` contract
+
+`Command` (interface) defines:
+
+- Metadata — `getCommandName()`, `getDescription()`, `getCategory()`
+  ([`CommandCategory`](#commandcategory)).
+- Type — `getType()` (`SLASH` by default).
+- Permissions — `needAdmin()`, `canBeExecutedBy(...)`, guild-only / slash-only constraints.
+- Option declaration — `registerCommandOptions(CommandOptionsBuilder)` (procedural option setup).
+- Execution — `execute(CommandContext) : CommandExecutionResult`.
+
+### Base implementations (`core.command.impl`)
+
+| Class | Adds |
+|---|---|
+| `AbstractCommand` | Default `Command` implementation; type defaults to `SLASH`; basic permission logic. |
+| `AdminCommand` | Sets `needAdmin() = true` and category `ADMINISTRATION`. |
+| `MusicCommand` | Guild-only; verifies the guild's music role and music channel before execution. |
+| `MessageMenuCommand` | Discord **message** context-menu command; skips option registration; wraps the target `Message`. |
+| `UserMenuCommand` | Discord **user** context-menu command; skips option registration; wraps the target `User`. |
+
+## Unified options
+
+To let one command definition serve both slash and message input, values are read through a wrapper
+interface:
+
+- `CommandOption` (interface) — uniform accessors: `getAsString()`, `getAsInt()`, `getAsMember()`,
+  `getAsBoolean()`, … .
+- `SlashCommandOption` — wraps JDA's `OptionMapping` (Discord already parsed the value).
+- `MessageCommandOption` — wraps a value parsed manually from the message text.
+
+### Procedural option configuration — `CommandOptionsBuilder`
+
+`CommandOptionsBuilder` implements JDA's `SlashCommandData` and acts as a proxy over JDA's internal
+`CommandDataImpl`. A command builds its argument surface in `registerCommandOptions(builder)` by
+adding options, subcommands, and subcommand groups. The same declaration is used both to:
+
+1. register the slash command with Discord (see [registration](#registration-lifecycle)), and
+2. drive the message-command parser (which tries to match tokens in the message against the declared
+   `OptionData`).
+
+## Command management
+
+### `CommandManager`
+
+Responsible for **discovery** and **registration**.
+
+- **Discovery** — at `init()`, uses [`ReflectionHelper`](utilities-and-bootstrap.md#reflectionhelper)
+  to scan for `Command` implementations and instantiate them.
+- **Storage** — commands are kept in a `ConcurrentHashMap<String, CommandContainer>` keyed by command
+  name.
+- **Slash registration** — `registerSlashCommands(JDA)` converts each command's declaration into JDA
+  `SlashCommandData` and pushes it to Discord's API.
+
+### `CommandContainer`
+
+Wraps a `Command` instance together with its JDA metadata (`CommandDataImpl`). It also builds the
+"usage" string shown by the help command.
+
+### `CommandCategory`
+
+Enum grouping commands for help/display purposes (e.g. `ADMINISTRATION`, `UTILITY`, `MUSIC`,
+`CRYPTO`, and an unlisted/hidden group for owner/debug commands).
+
+### `CommandExecutionResult`
+
+The value returned by `execute(...)`. It encodes the outcome and any response payload:
+
+- `success(...)` — normal success (optionally with a message/embed to send).
+- `error(...)` / `warning(...)` — failure/advisory outcomes with a message.
+- `none()` — nothing to send synchronously (the command handles its own async response, e.g. music).
+- May also carry a follow-up **`Task`** so a command can install an interactive
+  [task](tasks.md) (e.g. buttons) as part of its result.
+
+## The dispatch flow — `CommandProcessor`
+
+`CommandProcessor` is constructed with the `CommandContext` and driven by `dispatch()`:
+
+1. **Resolution** — match the invoked name against a `CommandContainer` in `CommandManager`.
+2. **Validation**
+   - command enabled?
+   - guild-only / slash-only constraints satisfied?
+   - **permissions** — `canBeExecutedBy(...)` and, for admin commands, `needAdmin()` verified against
+     the bot owner (`NETNEUTRALITY_BOT_OWNER`) and the member's guild-admin status.
+3. **Usage parsing (`checkUsage`)** — detect whether a subcommand or subcommand group is being
+   invoked and record the active subcommand on the context.
+4. **Option parsing**
+   - **Slash** — Discord already parsed the arguments; map each `OptionMapping` to a
+     `SlashCommandOption`.
+   - **Message** — `MessageCommandContext` tokenizes the message and matches tokens against the
+     declared `OptionData` (resolving mentions to members/roles, parsing integers/booleans, etc.).
+5. **Execution** — call `command.execute(context)`.
+6. **Result handling** — act on the returned `CommandExecutionResult`: send success/error/warning
+   responses, or, if a `Task` was returned, register it with the [`TaskManager`](tasks.md).
+
+Errors are surfaced through the exception hierarchy
+([`CommandExecutionException`](utilities-and-bootstrap.md#exceptions), and
+`GracefulContextError` for user-facing, non-logged failures).
+
+## Registration lifecycle
+
+```
+App.startup()
+   ├─ CommandManager.init()               // reflective discovery → ConcurrentHashMap
+   └─ CommandManager.registerSlashCommands(jda)  // push SlashCommandData to Discord
+```
+
+At runtime, an incoming command event becomes a `CommandContext` in the
+[`EventsHandler`](events.md), which calls `new CommandProcessor(context).dispatch()`.
+
+## Command catalog
+
+Concrete commands live under `me.bobert.netneutrality.feature.*.command`, grouped by feature package:
+
+| Command | Package | Type | Description |
+|---|---|---|---|
+| `BlacklistCommand` | `admin` | Slash | Manage the server's word blacklist. |
+| `ReactionCommand` | `admin` | Slash | Manage emoji-reaction roles on the server. |
+| `HelpCommand` | `basic` | Slash | List every command with its usage. |
+| `PingCommand` | `basic` | Slash | Reply with the gateway ping. |
+| `ConfigureCommand` | `bot` | Slash | Configure the bot for the server (subcommands). |
+| `CryptoPriceCommand` | `crypto` | Slash | Fetch cryptocurrency prices. |
+| `ReportIssueCommand` | `git` | Slash | Report a bug (opens the Gitea report flow). |
+| `PlayCommand` | `music` | Slash | Search/queue and start playback. |
+| `QueueCommand` / `ViewQueueCommand` | `music` | Slash | View/manage the queue. |
+| `SkipCommand` / `VoteSkipCommand` | `music` | Slash | Skip (or vote-skip) the current track. |
+| `ClearQueueCommand` / `ShuffleCommand` | `music` | Slash | Clear / shuffle the queue. |
+| `JoinCommand` / `LeaveCommand` | `music` | Slash | Join / leave the voice channel. |
+| `CurrentlyPlayingCommand` | `music` | Slash | Show the currently playing track. |
+| `ResumeCommand` / `StopCommand` / `VolumeCommand` | `music` | Slash | Playback controls. |
+| `BitconnectCommand` | `music` | Slash | Novelty music command. |
+| `CreateEmojiReaction` / `ModifyEmojiReaction` | `react` | Message menu | Create/modify emoji-role mappings from a message. |
+| `DatabaseCommand`, `PurgeCommand`, `ShutdownCommand`, `JoinClanCommand`, `TestCommand`, `SlashCommandTest`, `TrackStuckTest` | `custom` | Mixed | Owner/debug and personal utilities (the `custom` package is gitignored per-deployment). |
+
+### Representative commands
+
+**`PingCommand` (simplest slash command)** — extends `AbstractCommand`, overrides `execute` to return
+`CommandExecutionResult.success(...)` containing the JDA gateway ping. It illustrates the minimal
+execution path (no options, synchronous response).
+
+**`ConfigureCommand` (complex slash command)** — uses `registerCommandOptions` to declare several
+`SubcommandData` (e.g. music-volume, error-logging). In `execute`, it switches on
+`context.getSubcommand()` and reads typed values via `context.getOption(name, resolver)`, then
+persists them through the [guild settings service](persistence.md#service-layer).
+
+**`PlayCommand` (music)** — extends `MusicCommand` (so it enforces guild-only + music role/channel).
+It declares a single required `STRING` query option, delegates loading to
+[`MusicManager`](music.md), and returns `CommandExecutionResult.none()` because the audio subsystem
+produces the user-facing response asynchronously (often installing a
+[`LoadPlaylistTask`](tasks.md#concrete-task-catalog) with choice buttons).

docs/contexts.md

@@ -0,0 +1,154 @@
+# Contexts
+
+**Packages:** `me.bobert.netneutrality.framework.context` (framework),
+`me.bobert.netneutrality.framework.context` (concrete implementations)
+
+A **Context** is a high-level abstraction over a Discord event. It hides the differences between the
+many JDA event types (slash command, message, button, modal, reaction, …) behind a single, uniform
+API for reading who/where the event came from and for replying to it.
+
+Contexts are created either by the [`EventsHandler`](events.md) when Discord triggers an event, or by
+another context further down a flow (for example, a reply produces an [`AsyncContext`](#asynccontext)
+that can be edited later). A context can be handled by one of three flows depending on its type and
+the event it wraps: the [command processor](commands.md), the [task manager](tasks.md), or a simple
+lambda. **The id of a context only matters for tasks** — the task manager uses `getId()` to locate
+the `Task` that should run (see [tasks.md](tasks.md)).
+
+## Type hierarchy
+
+```
+Context (interface)
+├── InteractionContext (interface)   ── reply/defer/ack via IReplyCallback + InteractionHook
+├── NoMessageContext (interface)     ── defaults for events without a triggering message
+│   └── MessageContext (interface)   ── adds a triggering Message (prefix commands, replies)
+│
+└── AbstractContext (abstract, implements Context)   ── stores JDA/Guild/Channel/Member/User
+    ├── CommandContext (abstract)    ── command flow; holds CommandOptions + subcommand metadata
+    │   ├── SlashCommandContext
+    │   ├── MessageCommandContext
+    │   ├── MessageMenuContext
+    │   └── UserMenuContext
+    ├── TaskContext (abstract)       ── task flow; abstract getId(); contextData state map
+    │   ├── ButtonTaskContext
+    │   ├── EmojiTaskContext
+    │   ├── MessageTaskContext
+    │   └── ModalTaskContext
+    ├── AsyncContext                 ── wraps the result of a previous reply (edit/follow-up)
+    └── MusicChannelContext          ── synthetic context targeting a guild's music channel
+```
+
+## Core framework types
+
+### `Context` (interface)
+
+The root contract for every context. Notable methods:
+
+- `getJDA()`, `getGuild()`, `getChannel()`, `getGuildUser()` (`Member`), `getDiscordUser()` (`User`)
+- `reply(...)` — unified send; overloads support plain text, embeds, message components, an
+  `ephemeral` flag, and an async callback that receives an [`AsyncContext`](#asynccontext) for
+  follow-up edits.
+- `defer(ephemeral, consumer)` — signals "thinking…" and later completes the response.
+- `ack(ephemeral)` — minimal acknowledgement of the event.
+- `getInteractionHook()` — the JDA `InteractionHook` when the underlying event is an interaction.
+
+### `AbstractContext` (abstract class)
+
+Base implementation that stores the common JDA entities (`JDA`, `Guild`, `MessageChannel`, `Member`,
+`User`) and exposes them via the `Context` getters. Its constructor also sets the **Sentry user**
+(id + effective name) so any error captured while handling this context is attributed to the right
+Discord user:
+
+```java
+if (user != null) {
+    io.sentry.protocol.User sentryUser = new io.sentry.protocol.User();
+    sentryUser.setId(user.getId());
+    sentryUser.setUsername(user.getEffectiveName());
+    Sentry.setUser(sentryUser);
+}
+```
+
+### `InteractionContext` (interface)
+
+Behavioral mix-in for events that are JDA `Interaction`s (slash commands, buttons, modals, context
+menus). It implements `reply`/`defer`/`ack` in terms of `IReplyCallback` and `InteractionHook`, so
+these contexts can reply ephemerally, defer, and edit the original response.
+
+### `NoMessageContext` / `MessageContext` (interfaces)
+
+- `NoMessageContext` — provides sensible defaults for events that have **no** triggering message
+  (e.g. reactions, interactions).
+- `MessageContext extends NoMessageContext` — adds access to a triggering `Message`, used by prefix
+  commands and by replies that drive step tasks.
+
+## Command contexts
+
+### `CommandContext`
+
+Abstract base for the [command flow](commands.md). It carries the parsed
+[`CommandOption`s](commands.md#unified-options) and the active subcommand / subcommand-group metadata,
+and exposes type-safe option access, e.g. `getOption(name, resolver)`. Concrete subclasses adapt a
+specific JDA event to this API.
+
+| Class                   | Wraps                            | Notes                                                                                                                                            |
+|-------------------------|----------------------------------|--------------------------------------------------------------------------------------------------------------------------------------------------|
+| `SlashCommandContext`   | `SlashCommandInteractionEvent`   | Options already parsed by Discord; maps `OptionMapping` → `SlashCommandOption`. Interaction-based replies.                                       |
+| `MessageCommandContext` | `MessageReceivedEvent` (prefix)  | Contains the **manual parser** that turns the raw message string into `CommandOption`s (mentions, integers, booleans, …). Message-based replies. |
+| `MessageMenuContext`    | `MessageContextInteractionEvent` | "Apps → …" action on a message; exposes the target `Message`.                                                                                    |
+| `UserMenuContext`       | `UserContextInteractionEvent`    | "Apps → …" action on a user; exposes the target `User`.                                                                                          |
+
+## Task contexts
+
+### `TaskContext`
+
+Abstract base for the [task flow](tasks.md). Two things distinguish it:
+
+- **`getId()` (abstract)** — the id used by `TaskManager` to find the matching `Task`. How the id is
+  derived depends on the concrete subtype (see the table below and [tasks.md](tasks.md#the-task-id)).
+- **`contextData` map** — a small state bag used to carry values between steps of a multi-step flow.
+
+| Class                | Wraps                              | `getId()` derived from                                     |
+|----------------------|------------------------------------|------------------------------------------------------------|
+| `ButtonTaskContext`  | `ButtonInteractionEvent`           | `getComponentId()` of the clicked button                   |
+| `ModalTaskContext`   | `ModalInteractionEvent`            | modal `customId`                                           |
+| `EmojiTaskContext`   | `MessageReactionAddEvent`          | composite `guildId:messageId`                              |
+| `MessageTaskContext` | `MessageReceivedEvent` (no prefix) | the id of the message being replied to (drives step tasks) |
+
+## Reply mechanism & `AsyncContext`
+
+### `AsyncContext`
+
+`me.bobert.netneutrality.framework.context.AsyncContext` wraps the **result** of a previous reply — either an
+`InteractionHook` (for interactions) or a `Message` (for message replies) — so follow-up actions are
+expressed the same way regardless of the original trigger:
+
+```java
+context.reply("Initial response", async -> {
+    // 'async' is an AsyncContext for the message just sent
+    async.edit("Updated response");
+});
+```
+
+Under the hood:
+
+- **Interactions** — edits/follow-ups go through `hook.editOriginal()` / `hook.sendMessage()`.
+- **Messages** — edits/follow-ups go through `message.editMessage()` / `message.reply()`.
+
+This is what makes the command and task code path-agnostic: authors write against `Context` /
+`AsyncContext` and never branch on "was this a slash command or a text message?".
+
+### `MusicChannelContext`
+
+A synthetic `AbstractContext` that targets a guild's configured **music channel** rather than the
+channel an event came from. The music subsystem uses it to post now-playing / queue messages into the
+correct channel even when playback state changes without a fresh user interaction. See
+[music.md](music.md).
+
+## End-to-end summary
+
+| Event                           | Context                 | Flow    | Async result wraps |
+|---------------------------------|-------------------------|---------|--------------------|
+| `SlashCommandInteractionEvent`  | `SlashCommandContext`   | Command | `InteractionHook`  |
+| `MessageReceivedEvent` (prefix) | `MessageCommandContext` | Command | `Message`          |
+| `ButtonInteractionEvent`        | `ButtonTaskContext`     | Task    | `InteractionHook`  |
+| `MessageReactionAddEvent`       | `EmojiTaskContext`      | Task    | `Message`          |
+| `ModalInteractionEvent`         | `ModalTaskContext`      | Task    | `InteractionHook`  |

docs/events.md

@@ -0,0 +1,102 @@
+# Event Handling & Routing
+
+**Package:** `me.bobert.netneutrality.platform.event`
+**Primary class:** `EventsHandler`
+
+`EventsHandler` is the single JDA `EventListener` registered on the `JDA` instance
+(`jda.addEventListener(new EventsHandler())` in `App.startup()`). It is the funnel through
+which **every** gateway event passes. Its job is to translate a raw JDA event into a
+[Context](contexts.md) and route that context to the correct subsystem.
+
+## Listener registry
+
+Listeners are held in a static, thread-safe map keyed by the JDA event class:
+
+```java
+private static final Map<Class<? extends Event>, Function<? extends Event, Context>> listeners
+        = new ConcurrentHashMap<>();
+```
+
+Each entry is a **factory function**: given an event of that type, it returns a `Context` (or `null`).
+The map is populated once in a `static {}` block.
+
+### `addListener` vs `addGenericListener`
+
+- `addListener(Class<T>, Function<? super T, Context>)` — registers a factory that produces a
+  `Context` to be routed onward (command or task flow).
+- `addGenericListener(Class<T>, Consumer<T>)` — registers a factory that runs a side-effecting
+  consumer and returns `null`, so nothing is routed onward. This is the **lambda flow** for simple
+  events.
+
+## Registered events
+
+| JDA event | Produces | Flow |
+|---|---|---|
+| `MessageReceivedEvent` (prefix match) | `MessageCommandContext` | Command |
+| `MessageReceivedEvent` (no prefix) | `MessageTaskContext` | Task |
+| `SlashCommandInteractionEvent` | `SlashCommandContext` | Command |
+| `UserContextInteractionEvent` | `UserMenuContext` | Command |
+| `MessageContextInteractionEvent` | `MessageMenuContext` | Command |
+| `ButtonInteractionEvent` | `ButtonTaskContext` | Task |
+| `ModalInteractionEvent` | `ModalTaskContext` | Task |
+| `MessageReactionAddEvent` | `EmojiTaskContext` | Task |
+| `GuildJoinEvent` | — (consumer) | Lambda |
+| `GuildLeaveEvent` | — (consumer) | Lambda |
+
+### Message routing detail
+
+For `MessageReceivedEvent` the factory:
+
+1. Ignores messages authored by bots and webhook messages (returns `null`).
+2. Reads the configured prefix (`NETNEUTRALITY_BOT_PREFIX`, default `$`).
+3. If the trimmed message starts with the prefix → **`MessageCommandContext`** (command flow).
+4. Otherwise → **`MessageTaskContext`** (task flow). This lets ordinary messages participate in the
+   task system, e.g. as a reply that advances a [step task](tasks.md#33-step-tasks).
+
+### Guild lifecycle (lambda flow)
+
+- `GuildJoinEvent` — resolves `GuildService.get(guild)`; if debug logging is enabled for that guild,
+  sends a notice to the debug channel.
+- `GuildLeaveEvent` — `GuildService.get(guild).deleteGuild()` removes the guild's stored data.
+
+## Dispatch algorithm
+
+```java
+@Override
+public void onEvent(@Nonnull GenericEvent event) {
+    handleEvent((Event) event);
+}
+
+private void handleEvent(Event event) {
+    Class<?> eventClass = event.getClass();
+    while (eventClass != null) {
+        if (listeners.containsKey(eventClass)) {
+            Context context = listeners.get(eventClass).apply(event);
+            if (context instanceof CommandContext c) handleCommand(c);
+            if (context instanceof TaskContext t)    handleTask(t);
+            break;
+        }
+        eventClass = eventClass.getSuperclass();   // walk up the class hierarchy
+    }
+}
+```
+
+Key points:
+
+- **Superclass walk** — if the exact event class is not registered, the handler walks up the
+  superclass chain until it finds a match. This means a listener registered for a base event type
+  also catches subclasses.
+- **Routing by context type** — the resulting object is routed purely by its runtime type:
+  a `CommandContext` goes to `CommandProcessor.dispatch()`, a `TaskContext` goes to
+  `TaskManager.getInstance().handle(context)`.
+- **`null` contexts** (bot messages, consumer-only events) are simply not routed anywhere.
+
+## Extending the event system
+
+To handle a new event type:
+
+1. Add an `addListener(SomeEvent.class, SomeContext::new)` (or `addGenericListener(...)` for a
+   consumer-only side effect) to the `static {}` block.
+2. If it should run the command or task flow, make the produced context extend
+   [`CommandContext`](contexts.md#commandcontext) or [`TaskContext`](contexts.md#taskcontext)
+   respectively.

docs/music.md

@@ -0,0 +1,170 @@
+# Music
+
+**Package:** `me.bobert.netneutrality.music`
+**Engine:** a remote [Lavalink](https://lavalink.dev) v4 node driven by
+[`dev.arbjerg:lavalink-client`](https://github.com/lavalink-devs/Lavalink-Client) 3.4.0.
+
+The music subsystem provides per-guild audio playback: searching/loading tracks from multiple
+sources, queueing, scheduling, and streaming audio into a Discord voice channel. Since the
+migration to Lavalink, **decoding, source resolution and voice sending happen on the node**, not in
+the bot process. The bot only sends REST/WebSocket commands and reacts to the node's events, which
+means new sources (YouTube, LavaSrc, …) are added by configuring server-side plugins rather than by
+changing Java code.
+
+## Key classes
+
+| Class | Responsibility |
+|---|---|
+| `MusicServiceImpl` | Owns the shared `LavalinkClient`, registers the node, and dispatches its event flux. |
+| `MusicManager` | Central per-guild coordinator; resolves the guild's `Link` and exposes a synchronous facade. |
+| `QueueManager` | Holds the guild's track queue (`LinkedBlockingDeque<TrackInfo>`); enqueue/skip/shuffle. |
+| `TrackScheduler` | Event sink for `onTrackStart` / `onTrackEnd` / `onTrackException` / `onTrackStuck`; caches the current track. |
+| `TrackLoadingHandler` | `AbstractAudioLoadResultHandler`; handles track/playlist/search/no-match/failure results. |
+| `TrackInfo` | Value object pairing a Lavalink `Track` with its requester (`Member`). |
+| `SourceFinder` | Identifies the source/type of a query (YouTube, SoundCloud, HTTP, …). |
+| `StuckTrackRecoveryHandler` | Retry-then-skip logic for tracks the node reports as stuck. |
+
+`MusicServiceImpl` keeps a `Map<String, MusicManager>` of managers keyed by guild id, so each guild
+has its own link, scheduler, and queue.
+
+## Startup
+
+`MusicServiceImpl` is a priority-40 [`Lifecycle`](architecture.md#startup-lifecycle) component. Its
+constructor creates the `LavalinkClient` (the bot user id is derived from the token) and `start()`
+registers the configured node. **A node that is unreachable never prevents the bot from booting**:
+the client retries in the background and music commands reply with an error in the meantime.
+
+Because the client must exist before JDA is built, `App.initJDA()` (priority 60) installs
+`new JDAVoiceUpdateListener(music.getClient())` as the gateway's voice dispatch interceptor. JDA's
+`AudioManager` is therefore **not** used for playback; voice connections are opened and closed
+through `JDA#getDirectAudioController()`.
+
+### Settings
+
+| Setting | Default | Meaning |
+|---|---|---|
+| `NETNEUTRALITY_LAVALINK_URI` | `ws://lavalink:2333` | WebSocket URI of the node |
+| `NETNEUTRALITY_LAVALINK_PASSWORD` | — | Node password; music is disabled when missing |
+| `NETNEUTRALITY_LAVALINK_NAME` | `main` | Node name used in logs |
+
+## Audio pipeline (end-to-end)
+
+```
+/play query
+   │
+   ▼
+MusicManager.play(query, ctx)
+   │  SourceFinder identifies the source and builds the identifier
+   ▼
+link.loadItem(identifier).subscribe(new TrackLoadingHandler(...))
+   │
+   ├─ ontrackLoaded ──▶ connect to voice (MusicUtils) ──▶ QueueManager.queue(track, member)
+   ├─ onPlaylistLoaded / onSearchResultLoaded ──▶ install a LoadPlaylistTask (choice buttons)
+   ├─ noMatches ──▶ reply "nothing found"
+   └─ loadFailed ──▶ reply / log error
+   │
+   ▼
+QueueManager: if nothing is playing, send createOrUpdatePlayer().setTrack(...); else append
+   │
+   ▼
+Lavalink node decodes and streams the audio to the Discord voice gateway
+   │
+   ▼ (track ends)
+node event ──▶ MusicServiceImpl dispatcher ──▶ TrackScheduler.onTrackEnd ──▶ QueueManager.startNextTrack()
+```
+
+- **Event dispatch** — `MusicServiceImpl` holds a single subscription per event type
+  (`TrackStartEvent`, `TrackEndEvent`, `TrackExceptionEvent`, `TrackStuckEvent`,
+  `WebSocketClosedEvent`) and routes each event to the owning guild's `TrackScheduler`. All
+  subscriptions are disposed in `stop()`.
+- **Synchronous facade** — every Lavalink operation returns a reactive `Mono`. `MusicManager`
+  subscribes internally so the 13 music commands keep their existing synchronous signatures;
+  failures are reported through `LogHandler` and the attached `MusicChannelContext`.
+- **Current track** — the node's player state is only readable via REST, so the last
+  `TrackStartEvent` is cached on the scheduler and used by `getCurrentlyPlaying()` and by the queue
+  to decide whether playback must be started.
+- **Requester tracking** — each queued item is a `TrackInfo` (track + requesting `Member`), used for
+  now-playing/queue displays and vote-skip. Duplicate rejection compares the encoded track payload.
+- **Playlists / search** — playlist and search loads produce a
+  [`LoadPlaylistTask`](tasks.md#concrete-task-catalog) with per-result buttons
+  (`LoadTrackFromPlaylistTask`), tying the music and [task](tasks.md) subsystems together. Playlist
+  size is bounded by the [`MUSIC_MAXPLAYLISTSIZE`](persistence.md#gsettings) guild setting.
+- **Stuck tracks** — the first `TrackStuckEvent` re-queues the track and seeks back to the last
+  known position; a second consecutive event skips to the next track.
+- **Output** — playback messages are posted through a
+  [`MusicChannelContext`](contexts.md#musicchannelcontext) so they land in the guild's configured
+  music channel.
+
+## Running the node
+
+`docker-compose.yml` defines a `lavalink` service (image `ghcr.io/lavalink-devs/lavalink:4.2`, the
+minimum version that handles DAVE end-to-end encrypted voice) on the `netneutrality` network, with
+`lavalink/application.yml` mounted read-only at `/opt/Lavalink/application.yml`. The bot depends on
+it and the node depends on the existing `ejs-api` (yt-cipher) container.
+
+```bash
+docker compose up -d lavalink
+docker compose logs -f lavalink   # wait for "Lavalink is ready to accept connections"
+```
+
+### Adding a server-side plugin
+
+Plugins are declared in `lavalink/application.yml` and downloaded by the node on boot into the
+`netneutrality-lavalink-plugins` volume — no bot rebuild is required:
+
+```yaml
+lavalink:
+  plugins:
+    - dependency: "dev.lavalink.youtube:youtube-plugin:1.18.2"
+      snapshot: false
+```
+
+A plugin that is not on the default Lavalink repository can be pulled from any Maven repository by
+adding `repository:` to the entry. The node currently runs a JitPack build of the SABR-enabled
+YouTube fork ([`ashton045/youtube-source`](https://jitpack.io/#ashton045/youtube-source), branch
+`feat/sabr-support`) — no local build of the fork is required, JitPack publishes a ready Lavalink
+plugin jar:
+
+```yaml
+lavalink:
+  plugins:
+    - dependency: "com.github.ashton045.youtube-source:youtube-plugin:17619654b1"
+      repository: "https://jitpack.io"
+      snapshot: false
+```
+
+The node logs `Failed to check for updates for youtube-plugin: Not Found` on boot; this is harmless,
+JitPack publishes no `maven-metadata.xml` for commit-pinned versions.
+
+Plugin-specific configuration goes under the top-level `plugins:` key. The YouTube plugin is
+configured there with the remote cipher URL, poToken and visitorData, which used to live in
+`MusicServiceImpl.start()`.
+
+## Udio support (deferred)
+
+Udio playback is **temporarily unavailable**. The previous implementation was a client-side
+Lavaplayer `AudioSourceManager`, and Lavalink can only resolve sources that live on the server.
+`SourceFinder` still recognises Udio URLs but returns no identifier, and `MusicManager.play` replies
+that Udio is temporarily unsupported.
+
+The original `UdioAudioSourceManager`, `UdioAudioTrack` and their test have been preserved verbatim
+under [`docs/reference/udio-lavalink-plugin/`](reference/udio-lavalink-plugin) — they are **not
+compiled** — as the reference for a future Lavalink **server plugin** port. That plugin is out of
+scope of this migration and is tracked as a follow-up.
+
+## Guild lifecycle & cleanup
+
+- `MusicPlayerAutoDisconnect` (scheduled task) leaves voice when the channel is empty or the queue
+  has run out; the connected channel is read from the bot's gateway voice state.
+- `MusicManagerCleanup` (scheduled task) evicts unused per-guild `MusicManager` instances.
+- On shutdown, `MusicServiceImpl.stop()` disposes the event subscriptions, clears the queues,
+  destroys every player and closes the client
+  (called from [`App.shutdown()`](architecture.md#shutdown-lifecycle)).
+
+## Related commands
+
+All music commands extend [`MusicCommand`](commands.md#base-implementations-corecommandimpl) (guild
+only + music role/channel enforced): `PlayCommand`, `SkipCommand`/`VoteSkipCommand`,
+`QueueCommand`/`ViewQueueCommand`, `ClearQueueCommand`, `ShuffleCommand`, `JoinCommand`/`LeaveCommand`,
+`CurrentlyPlayingCommand`, `ResumeCommand`/`StopCommand`, `VolumeCommand`, `BitconnectCommand`. See
+[commands.md](commands.md#command-catalog).

docs/persistence.md

@@ -0,0 +1,133 @@
+# Persistence & Database
+
+**Packages:** `me.bobert.netneutrality.platform.persistence` (session/migration),
+`me.bobert.netneutrality.db` (entities, repositories, services).
+**Resources:** `hibernate.cfg.xml`, `db/migration/V1__initial_schema.sql`,
+`db/migration/V2__task_type_id.sql`.
+
+## Stack
+
+| Concern    | Technology                                                                    |
+|------------|-------------------------------------------------------------------------------|
+| ORM        | Hibernate 7.1.9 (Jakarta JPA)                                                 |
+| Engine     | MariaDB 11 (per `docker-compose.yml`), MySQL Connector/J 9.7.0 driver, InnoDB |
+| Pooling    | HikariCP (via `hibernate-hikaricp`)                                           |
+| Migrations | Flyway 11.20.3 (`flyway-core` + `flyway-mysql`)                               |
+
+Configuration is externalized via `Settings` (env vars / `bot.properties`):
+`MYSQL_HOST`, `MYSQL_PORT`, `MYSQL_USER`, `MYSQL_PASSWORD`, `MYSQL_DATABASE`.
+
+## Session & migration lifecycle
+
+Both are wired in at [startup](architecture.md#startup-lifecycle):
+
+1. **`SessionManager.getSessionFactory()`** — lazily builds the Hibernate `SessionFactory`. It reads
+   the static config from `hibernate.cfg.xml` (dialect `MySQLDialect`, driver
+   `com.mysql.cj.jdbc.Driver`, the Hikari connection provider, and the mapped entity list) and
+   overrides the JDBC url/user/password from environment variables:
+
+   ```java
+   settings.put(Environment.JAKARTA_JDBC_URL,
+       String.format("jdbc:mysql://%s:%s/%s", dbHost, dbPort, dbName));
+   settings.put(Environment.JAKARTA_JDBC_USER, dbUser);
+   settings.put(Environment.JAKARTA_JDBC_PASSWORD, dbPass);
+   ```
+
+2. **`DatabaseMigration.migrate()`** — runs `flyway.migrate()` against the same database, applying the
+   versioned scripts under `src/main/resources/db/migration/` (starting with
+   `V1__initial_schema.sql`). The Flyway Maven plugin (`flyway-dev.sh`/`.ps1`) is available for local
+   development, using `FLYWAY_URL` / `FLYWAY_USER` / `FLYWAY_PASSWORD`.
+
+3. **`SessionManager.shutdown()`** — destroys the service registry / releases the pool on shutdown.
+
+Repositories obtain sessions through the factory; transactional access uses helpers in
+[`JpaUtils`](utilities-and-bootstrap.md) (open session, run in a transaction, close).
+
+## Entity catalog
+
+Entities live in `me.bobert.netneutrality.data.entity` and are prefixed with `O`. `OGuild` is the hub
+of a star-shaped model; most other tables reference `guild_id` with `ON DELETE CASCADE`.
+
+| Entity          | Table            | Key                      | Relationships / notes                                                                                  |
+|-----------------|------------------|--------------------------|--------------------------------------------------------------------------------------------------------|
+| `OGuild`        | `guilds`         | `guild_id` (String)      | Central entity; one-to-many with settings, blacklist, log messages, logging.                           |
+| `OGuildSetting` | `guild_settings` | `id` (auto int)          | Many-to-one `OGuild`; key/value guild settings.                                                        |
+| `OBlacklist`    | `blacklist`      | `id` (auto int)          | Many-to-one `OGuild`; blacklisted words.                                                               |
+| `OLogging`      | `logging`        | `OLoggingId` (composite) | Composite key `guild_id` + `channel_id`; `@MapsId` to `OGuild`; debug/error log channel config.        |
+| `OLoggingId`    | — (embeddable)   | —                        | `@Embeddable`/`@IdClass` for the composite key.                                                        |
+| `OLogMessage`   | `log_message`    | `id` (auto int)          | Many-to-one `OGuild`; message logging history.                                                         |
+| `OTask`         | `tasks`          | `id` (auto int)          | [Persistable task](tasks.md#31-persistable-tasks) state; unique `task_id`, `task_class` holds the logical `typeId`, JSON `payload`. |
+| `OWebUser`      | `web_users`      | `id` (String)            | Web dashboard user (tokens/expiry). *Present in schema & code but not listed in `hibernate.cfg.xml`.*  |
+
+### ER overview
+
+```
+                    ┌───────────────┐
+                    │    OGuild     │  (guilds.guild_id)
+                    └───────┬───────┘
+        ┌───────────┬───────┼────────────┬─────────────┐
+        ▼           ▼       ▼            ▼             ▼
+ OGuildSetting  OBlacklist  OLogging   OLogMessage   (…)
+ guild_settings  blacklist  logging    log_message
+   (FK guild)    (FK guild) (PK guild+ (FK guild)
+                             channel)
+
+  OTask (tasks)          OWebUser (web_users)     ── standalone
+```
+
+`OTask` and `OWebUser` are not tied to the guild graph.
+
+## Repository layer
+
+A lightweight generic repository pattern is used.
+
+- **`Repository<O>`** (interface) — generic CRUD: `findAll()`, `findById(String)`, `save(O)` (via
+  `session.merge()`), `deleteBy(String)`.
+- **`BlacklistRepository`** — find-by-guild and case-insensitive word lookups.
+- **`GuildRepository`** — CRUD for guilds.
+- **`GuildSettingRepository`** — set/get setting values; removes rows that equal the default value.
+- **`MessageRepository`** — message logging / edit history.
+- **`TaskRepository`** — CRUD for `OTask` rows (used by the task persistence flow).
+
+## Service layer
+
+Services wrap repositories with business logic and **caching**.
+
+- **`GuildService`** — gateway for guild operations; caches one `GuildService` per guild id
+  (`ConcurrentHashMap`); `findOrCreate` guarantees a guild row exists; `deleteGuild()` on leave;
+  `isDebugEnabled()` / debug-channel helpers used by [`EventsHandler`](events.md) and
+  [`LogHandler`](utilities-and-bootstrap.md#loghandler).
+- **`BlacklistService`** — maintains a `blacklistCache` (guild id → set of words) for fast message
+  filtering.
+- **`GuildSettingService`** — reads/writes guild settings backed by [`GSettings`](#gsettings); caches
+  values in `settingsCache` and reloads on change; used by the
+  [web API settings endpoints](web-api.md).
+- **`TaskService`** — serializes [`PersistableTask`](tasks.md#31-persistable-tasks) instances to JSON
+  for the `tasks` table, keyed by the task's stable `typeId()` in `task_class`, and reconstructs them
+  at startup via [`PersistableTaskRegistry`](tasks.md#persistabletaskregistry--discovery-and-restore).
+  Rows with an unknown `task_class` are logged and skipped.
+
+## GSettings
+
+`GSettings` is an **enum** of the available per-guild configuration keys and their defaults:
+
+| Setting                 | Default |
+|-------------------------|---------|
+| `MUSIC_ROLE`            | (none)  |
+| `MUSIC_CHANNEL`         | (none)  |
+| `MUSIC_VOLUME`          | `30`    |
+| `MUSIC_MAXPLAYLISTSIZE` | `20`    |
+
+`GuildSettingService` looks up an `OGuildSetting` row by the enum `name()`; if no row exists for a
+guild/setting, the enum's `defaultValue` is used. This is how `MusicCommand` obtains the guild's music
+role/channel and how `ConfigureCommand` persists changes.
+
+## Schema (`V1__initial_schema.sql`)
+
+The initial migration creates the tables backing the entities above (`guilds`, `guild_settings`,
+`blacklist`, `logging`, `log_message`, `tasks`, `web_users`), with `guild_id` foreign keys and
+`ON DELETE CASCADE` from the guild-scoped tables to `guilds`. Subsequent schema changes should be
+added as new `V3__…`, `V4__…` Flyway scripts in the same directory.
+
+`V2__task_type_id.sql` rewrites `tasks.task_class` from the old fully-qualified class names to the
+stable logical `typeId` (e.g. `emoji-reaction-role`), so previously persisted rows remain loadable.

docs/tasks.md

@@ -0,0 +1,290 @@
+# Tasks
+
+**Packages:** `me.bobert.netneutrality.framework.task` (framework),
+`me.bobert.netneutrality.feature.*.task` (concrete tasks)
+
+Tasks are one of the more advanced concepts in the bot. A **Task** is a unit of logic that is looked
+up and executed by **id** when a matching Discord event arrives, as opposed to a
+[command](commands.md) which is looked up by name.
+
+The original motivation was **Discord interactions** (buttons). When a user clicks a button, Discord
+sends a `ButtonInteractionEvent` whose id is `getComponentId()`. A `Task` with that same id was
+inserted earlier (typically by the command that created the button), so the `TaskManager` can find
+the task and execute it. The system has since grown to cover several task subtypes:
+
+| Subtype                                      | Trigger                            | Id source                              |
+|----------------------------------------------|------------------------------------|----------------------------------------|
+| [Button task](#button-emoji-and-modal-tasks) | `ButtonInteractionEvent`           | button `componentId`                   |
+| [Modal task](#button-emoji-and-modal-tasks)  | `ModalInteractionEvent`            | modal `customId`                       |
+| [Emoji task](#button-emoji-and-modal-tasks)  | `MessageReactionAddEvent`          | composite `guildId:messageId`          |
+| [Step task](#33-step-tasks)                  | replied-to message                 | last-message id (assigned dynamically) |
+| [Built-in task](#32-built-in-tasks)          | button with a hardcoded id         | hardcoded id                           |
+| [Persistable task](#31-persistable-tasks)    | any of the above, restored from DB | as stored                              |
+| [Scheduled task](#34-scheduled-tasks)        | timer                              | n/a (time-based, not id-based)         |
+
+## The `Task` id
+
+The id is the **primary lookup key** used by `TaskManager`. How it is derived depends on the subtype:
+
+- **Buttons** → the button's `componentId`.
+- **Modals** → the modal's `customId`.
+- **Emoji reactions** → a composite `guildId:messageId` (a reaction is tied to a specific message).
+- **Step tasks** → start life with a random UUID, then re-key themselves to the DM/last-message id
+  once that message exists (see [step tasks](#33-step-tasks)).
+
+## `Task` contract & lifecycle
+
+`Task` (interface) defines `execute(TaskContext)` and returns a **`Lifecycle`** value that tells the
+`TaskManager` what to do with the task afterwards:
+
+| Lifecycle                  | Meaning                                                           |
+|----------------------------|-------------------------------------------------------------------|
+| `BUILTIN`                  | Task is static and stays registered indefinitely.                 |
+| `KEEP`                     | Keep the task in memory after execution (can run again).          |
+| `REMOVE_SELF`              | Remove this task after execution (one-shot).                      |
+| `REMOVE_SELF_AND_CHILDREN` | Remove this task and all of its [child tasks](#trait-interfaces). |
+
+### Task base classes (`core.tasks.impl`)
+
+```
+AbstractTask (implements Task)
+├── ButtonTask                 ── executed from a ButtonTaskContext
+├── EmojiTask                  ── executed from an EmojiTaskContext
+├── ModalTask                  ── executed from a ModalTaskContext
+├── GenericCustomIdTask        ── task keyed by an explicit custom id
+├── GenericRandomIdTask        ── task keyed by a generated random id
+├── AbstractBuiltInTask        ── base for hardcoded, reflectively-loaded tasks
+├── AbstractPersistableTask    ── base for DB-backed tasks (implements PersistableTask)
+└── AbstractStepTask           ── base for multi-step Q&A flows (implements StepTask)
+```
+
+## `TaskManager`
+
+`me.bobert.netneutrality.framework.task.TaskManager` is the registry, lookup, and execution
+coordinator.
+
+### Registration — `insert`
+
+- Adds the task to the active map keyed by its id.
+- If the task is a [`PersistableTask`](#31-persistable-tasks), it is also **saved to the database**
+  via [`TaskService`](persistence.md#service-layer).
+- If the task is a [`StepTask`](#33-step-tasks) without a message id yet, it is held in a separate
+  `pendingTasks` collection until its id is assigned.
+
+### Execution — `handle(TaskContext)`
+
+1. Look up the task by `context.getId()`.
+2. For ordinary (non-built-in, non-persistable) tasks, acquire a **`ReentrantLock`** so the same task
+   cannot be executed concurrently (prevents double-clicks / races). Tasks that share a
+   [parent](#trait-interfaces) share the same lock id.
+3. Call `task.execute(context)`.
+4. Apply the returned `Lifecycle` (keep / remove / remove-with-children); persistable tasks removed
+   here are also deleted from the DB.
+5. If the task is [`Deletable`](#trait-interfaces), delete the original message/interaction.
+6. Unless the task is [`NotAcknowledgeable`](#trait-interfaces), acknowledge the interaction.
+
+### Startup — `init`
+
+Called from `App.startup()`:
+
+1. Reflectively load all [`BuiltInTask`](#32-built-in-tasks) implementations.
+2. Reflectively load all [`ScheduledTask`](#34-scheduled-tasks) implementations and register them
+   with [`ScheduledTaskManager`](threading.md).
+3. Load persistable tasks from the database (via `TaskService`) and reconstruct them (see
+   [persistence rules](#31-persistable-tasks)).
+
+## Button, emoji and modal tasks
+
+These are the "interaction" tasks and the original purpose of the subsystem:
+
+- **`ButtonTask`** — executed when a button whose `componentId` matches the task id is clicked. The
+  matching context is a [`ButtonTaskContext`](contexts.md#task-contexts).
+- **`ModalTask`** — executed when a modal is submitted; matched by the modal `customId`. A modal is
+  typically opened by another interaction (e.g. `ReportIssueTask` opens a title/description modal).
+- **`EmojiTask`** — executed when a reaction is added to a specific message; matched by the composite
+  `guildId:messageId` id.
+
+The generic helpers `GenericCustomIdTask` / `GenericRandomIdTask` let a command install an ad-hoc,
+function-backed task under a chosen or generated id (e.g. the generic `AcceptButton` / `CancelButton`
+under `tasks/generic`).
+
+## 3.1 Persistable tasks
+
+**Classes:** `PersistableTask` (interface), `AbstractPersistableTask`,
+`core.tasks.persistence.PersistableTaskRegistry`; entity
+[`OTask`](persistence.md#entity-catalog).
+
+Persistable tasks survive restarts: they are serialized to the database and rebuilt on startup.
+There is **no mapping file** — task types are discovered on the classpath and each task knows how to
+rebuild itself.
+
+### The contract
+
+```java
+public interface PersistableTask extends Task {
+    default String typeId() { return getName(); }   // stable logical id stored in the DB
+    void restore(JSONObject payload);               // rebuild state from a previous toPayload()
+    void insert(CommandContext context);
+    void save();
+    void delete();
+    String toPayload();
+}
+```
+
+- **`typeId()`** is the value written to `tasks.task_class`. It defaults to `getName()`, so a package
+  move or class rename never breaks restoring existing rows.
+- **`restore(JSONObject)`** is the counterpart of `toPayload()`. `AbstractPersistableTask` provides a
+  no-op default, so only tasks that carry extra state override it.
+- **`toPayload()`** serializes the bean getters (`new JSONObject(this)`) and always includes `id` and
+  `lockId`, which `TaskService.validateTask` verifies against the stored row.
+
+### `PersistableTaskRegistry` — discovery and restore
+
+`PersistableTaskRegistry.scan()` runs once during `TaskManagerImpl.init()` and uses the same
+`ReflectionHelper.loadTasks(..., ApplicationContext, ...)` discovery used for
+[built-in](#32-built-in-tasks) and [scheduled](#34-scheduled-tasks) tasks: every concrete
+`PersistableTask` under `me.bobert.netneutrality` is instantiated once and indexed by its `typeId()`.
+Two types declaring the same id fail fast at startup with both class names in the message.
+
+`create(typeId, payload)` then produces a **fresh** instance per row:
+
+```java
+PersistableTask task = ReflectionHelper.instantiate(type, context);
+task.restore(payload);
+```
+
+Because instantiation goes through the DI context, a restored task needs a constructor whose
+parameters are all resolvable from the `ApplicationContext` — in practice `(TaskManager)`. Fields
+that only exist in the payload (ids, mappings) are assigned by `restore()` before the instance is
+handed to the `TaskManager`.
+
+> **Adding a persistable task:** write **one class** extending `AbstractPersistableTask` (or
+> `EmojiTask`), give it a `(TaskManager)` constructor for the registry plus whatever constructors the
+> feature code needs, and override `restore()` if it holds state beyond the bean getters. Nothing
+> else has to be registered — the scan picks it up and `getName()` becomes its `typeId()`.
+
+### Persistence round-trip
+
+```
+insert(task)  ──▶ TaskService.persistTask ──▶ OTask row (task_id, task_class = typeId, payload JSON)
+   startup    ──▶ PersistableTaskRegistry.scan()  (typeId ──▶ class)
+              ──▶ TaskService reads OTask rows ──▶ registry.create(task_class, payload)
+                                                     ──▶ DI instantiate ──▶ task.restore(payload)
+```
+
+Rows whose `task_class` is not a registered `typeId` are logged and skipped; the remaining rows still
+load.
+
+## 3.2 Built-in tasks
+
+**Classes:** `BuiltInTask`, `AbstractBuiltInTask`.
+
+Built-in tasks are hardcoded tasks with hardcoded ids, conceptually similar to commands. They are
+loaded reflectively at startup (in `TaskManager.init()`) and stay registered for the lifetime of the
+bot (`Lifecycle.BUILTIN`).
+
+A button that triggers a built-in task is created from its class:
+
+```java
+Button button = BuiltInTask.createButton(SomeBuiltInTask.class);
+```
+
+This produces a JDA `Button` whose component id equals the built-in task's hardcoded id, so clicking
+it routes straight to that task. Examples: the help buttons `BotInfo`, `CommandHelp`, `ReportBug`
+(`tasks/help`).
+
+## 3.3 Step tasks
+
+**Classes:** `StepTask` (interface), `AbstractStepTask`.
+
+Step tasks ask the user a series of questions and run logic based on each answer. Because Discord has
+no native "conversation" primitive, the abstraction tracks the **last message id** and only runs the
+next step when *that* message is replied to.
+
+Flow:
+
+1. A step task is created (e.g. by a setup command) and sends a prompt message; initially it is keyed
+   by a random UUID and held in `pendingTasks`.
+2. Once the prompt message exists, the task **re-keys itself to that message's id** and moves into the
+   active `tasks` map.
+3. When the user replies to that message, the incoming `MessageReceivedEvent` becomes a
+   [`MessageTaskContext`](contexts.md#task-contexts) whose id is the replied-to message id — so
+   `TaskManager` finds the step task.
+4. `executeStep` validates/processes the answer and returns a `StepResult`:
+   success, failure, or **next step** (which installs the following step task).
+
+`AbstractStepTask` provides answer validation keyed to a step "type" (e.g. a role id, an emoji, …).
+
+## 3.4 Scheduled tasks
+
+**Classes:** `ScheduledTask`, coordinated by
+[`ScheduledTaskManager`](threading.md#scheduledtaskmanager).
+
+Scheduled tasks are time-based background jobs (as opposed to id-based interaction tasks). They are
+loaded reflectively at startup and registered with `ScheduledTaskManager`, which schedules them at a
+fixed interval derived from the task's `TimeFrame` (e.g. minutely / hourly / daily / custom) and
+cancels them all on shutdown.
+
+> **Status:** the scheduled-task abstraction is intended to eventually replace the ad-hoc
+> [`ThreadManager`](threading.md) threads and is still evolving. The concrete scheduled tasks that
+> exist today are listed in the [catalog](#concrete-task-catalog).
+
+## Trait interfaces
+
+Tasks can opt into extra behavior by implementing marker/behavior interfaces in
+`core.tasks.trait`:
+
+| Trait                | Effect                                                                                   |
+|----------------------|------------------------------------------------------------------------------------------|
+| `Deletable`          | After successful execution, `TaskManager` deletes the original message/interaction.      |
+| `NotAcknowledgeable` | Suppresses the default acknowledgement (the task sends its own response).                |
+| `WithButton`         | The task can render itself as a JDA `Button` (`createButton()`).                         |
+| `WithChildren`       | The task tracks child tasks and can clean them up together (`REMOVE_SELF_AND_CHILDREN`). |
+| `WithParent`         | Links a child task to a parent; children share the parent's execution lock.              |
+
+## Concrete task catalog
+
+| Task                        | Package     | Base type                    | Description                                                  |
+|-----------------------------|-------------|------------------------------|--------------------------------------------------------------|
+| `EmojiReactionRoleTask`     | `emoji`     | `EmojiTask` (persistable)    | Assign/remove a role when a user reacts with a mapped emoji. |
+| `AcceptButton`              | `generic`   | `ButtonTask`                 | Generic "accept" button running a supplied function.         |
+| `CancelButton`              | `generic`   | `ButtonTask`                 | Generic "cancel" button running a supplied function.         |
+| `ReportIssueTask`           | `git`       | `ModalTask`                  | Modal to report a bug; creates a Gitea issue. |
+| `BotInfo`                   | `help`      | `AbstractBuiltInTask`        | Show bot info + invite link.                                 |
+| `CommandHelp`               | `help`      | `AbstractBuiltInTask`        | Show command help + the bot prefix.                          |
+| `ReportBug`                 | `help`      | `AbstractBuiltInTask`        | Start a bug-report flow / provide the report link.           |
+| `LoadPlaylistTask`          | `music`     | `ButtonTask` (with children) | Present playlist/search results as choice buttons.           |
+| `LoadTrackFromPlaylistTask` | `music`     | `ButtonTask`                 | Load one specific track from the results.                    |
+| `EmojiRoleFirstStep`        | `reaction`  | `AbstractStepTask`           | Ask for the target role id.                                  |
+| `EmojiRoleSecondStep`       | `reaction`  | `AbstractStepTask`           | Ask for the emoji to map.                                    |
+| `EmojiRoleModify`           | `reaction`  | `AbstractStepTask`           | Modify an existing emoji-role mapping.                       |
+| `EmojiRoleRemoveStep`       | `reaction`  | `AbstractStepTask`           | Remove an emoji-role mapping.                                |
+| `MusicManagerCleanup`       | `scheduled` | `ScheduledTask`              | Evict unused per-guild music managers.                       |
+| `MusicPlayerAutoDisconnect` | `scheduled` | `ScheduledTask`              | Disconnect from voice when idle.                             |
+| `TaskCleanup`               | `scheduled` | `ScheduledTask`              | Periodically remove expired non-persistable tasks.           |
+
+### Worked example — emoji-role setup (step → persistable)
+
+1. `EmojiRoleFirstStep` sends a prompt: "reply with the role id"; `AbstractStepTask` validates it is a
+   real role in the guild.
+2. `executeStep` returns `StepResult.next(new EmojiRoleSecondStep(...))`, carrying the chosen role.
+3. `EmojiRoleSecondStep` asks for the emoji; on a valid answer it creates an
+   `EmojiReactionRoleTask`.
+4. That `EmojiReactionRoleTask` is `insert`ed into `TaskManager` — because it is a
+   [persistable task](#31-persistable-tasks) it is written to the `tasks` table and will be restored
+   on the next startup via the
+   [`PersistableTaskRegistry`](#persistabletaskregistry--discovery-and-restore).
+
+### Worked example — Gitea bug report (modal)
+
+1. `ReportIssueTask.replyToInteraction` opens a modal with **title** and **description** fields.
+2. On submit, `ModalTaskContext` routes back to the task; `execute` reads the field values.
+3. The task calls the Gitea API via `GiteaClient` (using `GITEA_HOST` / `GITEA_TOKEN` /`r`n   `GITEA_OWNER` / `GITEA_REPO` from configuration) and creates an issue, then returns `Lifecycle.REMOVE_SELF`.
+
+### Worked example — music results (parent/children)
+
+1. `LoadPlaylistTask` posts a message with a button per result (children:
+   `LoadTrackFromPlaylistTask` / `AcceptButton`).
+2. All children share the parent's lock id ([`WithParent`](#trait-interfaces)), so simultaneous
+   clicks are serialized.
+3. Selecting a result can return `REMOVE_SELF_AND_CHILDREN` to tear down the whole interaction.

docs/threading.md

@@ -0,0 +1,46 @@
+# Threading & Scheduling
+
+**Package:** `me.bobert.netneutrality.platform.concurrency`
+
+This subsystem centralizes asynchronous execution and recurring jobs.
+
+## Classes
+
+| Class | Responsibility |
+|---|---|
+| `ThreadManager` | Static registry of `ExecutorService` instances shared across the bot. |
+| `BaseThreadFactory` | Custom `ThreadFactory` giving threads meaningful names and an uncaught-exception handler. |
+| `ScheduledTaskManager` | Schedules and cancels recurring [scheduled tasks](tasks.md#34-scheduled-tasks). |
+
+## `ThreadManager`
+
+- `getScheduledExecutor()` — a `ScheduledThreadPool` sized to the number of CPU cores.
+- `getExecutor(name)` — returns (and caches) a named thread pool for ad-hoc async work.
+- `shutdownExecutor()` — shuts the executors down cleanly; called from
+  [`App.shutdown()`](architecture.md#shutdown-lifecycle).
+
+## `BaseThreadFactory`
+
+Names created threads (e.g. `web-api-1`) so they are identifiable in logs and stack dumps, and installs
+an [`ExecutorException`](utilities-and-bootstrap.md#exceptions) as the thread's
+`UncaughtExceptionHandler` so crashes on worker threads are still routed through
+[`LogHandler`](utilities-and-bootstrap.md#loghandler). It is used both by `ThreadManager` and by the
+[Web API](web-api.md) server pool.
+
+## `ScheduledTaskManager`
+
+Coordinates [`ScheduledTask`](tasks.md#34-scheduled-tasks) instances (discovered reflectively at
+startup by [`TaskManager.init()`](tasks.md#taskmanager)):
+
+- `schedule(ScheduledTask task)` — schedules the task at a fixed delay/interval derived from its
+  `TimeFrame` (minutely / hourly / daily / custom), using the shared scheduled executor.
+- `cancelAll()` — cancels every scheduled task; called first in
+  [`App.shutdown()`](architecture.md#shutdown-lifecycle).
+
+The existing scheduled tasks are `MusicManagerCleanup`, `MusicPlayerAutoDisconnect` (which reads the
+bot's gateway voice state rather than JDA's audio manager, see [music.md](music.md)), and
+`TaskCleanup` (see the [task catalog](tasks.md#concrete-task-catalog)).
+
+> **Direction of travel:** the scheduled-task abstraction is intended to eventually replace ad-hoc
+> threads created via `ThreadManager`, giving a single, uniform way to express recurring background
+> work. It is still evolving (see [tasks.md §3.4](tasks.md#34-scheduled-tasks)).

docs/utilities-and-bootstrap.md

@@ -0,0 +1,164 @@
+# Utilities, Bootstrap, Logging & Exceptions
+
+This document covers the cross-cutting glue of the bot: the entry points, configuration, logging /
+error tracking, the shared utility helpers, and the custom exception hierarchy.
+
+## Bootstrap
+
+**Package:** `me.bobert.netneutrality` / `me.bobert.netneutrality.bootstrap`
+
+| Class                          | Role                                                                                                                                                                                                                        |
+|--------------------------------|-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+| `App`                          | The application: holds the process instance and the `JDA` handle, builds the `ApplicationContext`, runs `context.start()` / `context.stop()`, and is the JAR main class (`main()`). See [architecture.md](architecture.md). |
+| `bootstrap.ApplicationContext` | Hand-rolled container: `register(T)`, `get(Class<T>)`, ordered `start()` / `stop()` for `Lifecycle` components.                                                                                                             |
+| `bootstrap.Lifecycle`          | Optional component contract: `start() throws Exception`, default `stop()`, default `priority()`.                                                                                                                            |
+| `core.BotState`                | Work-in-progress global state helper: exposes a `SAFE` flag and `dump()`, which serializes per-guild/music state to `state.json`. Bound to `GuildServiceProvider` / `MusicService` during bootstrap.                        |
+
+The full startup and shutdown sequences are documented in
+[architecture.md](architecture.md#startup-lifecycle).
+
+### `ApplicationContext` + `Lifecycle`
+
+Domain services are constructed once in `App.buildContext()`, registered with the context,
+and resolved later by type:
+
+- `register(component)` — indexes the concrete class; if the component implements `Lifecycle` it
+  participates in ordered start/stop.
+- `get(Class<T>)` — returns the first registered instance assignable to `T` (interfaces work).
+- `start()` — sorts `Lifecycle` components by ascending `priority()` and starts them.
+- `stop()` — stops them in the exact reverse order; individual failures are logged and swallowed so
+  remaining components still tear down.
+
+Constructor injection for reflectively loaded commands/tasks is handled by
+[`ReflectionHelper`](#reflectionhelper): the richest public constructor whose parameter types all
+resolve via `context.get(type)` is preferred; otherwise the no-arg constructor is used.
+
+**Interfaces used for injection** (implemented by the concrete managers registered above):
+
+| Interface                               | Typical implementor                   |
+|-----------------------------------------|---------------------------------------|
+| `platform.config.SettingsProvider`      | `utils.Settings`                      |
+| `platform.persistence.SessionProvider`  | `core.db.SessionManager`              |
+| `platform.concurrency.ExecutorProvider` | `core.thread.ThreadManager`           |
+| `framework.command.CommandRegistry`     | `core.command.CommandManager`         |
+| `framework.task.TaskManager`            | `core.tasks.TaskManagerImpl`          |
+| `feature.music.MusicService`            | `music.MusicServiceImpl`              |
+| `data.service.GuildServiceProvider`     | `db.service.GuildServiceProviderImpl` |
+
+There are **no** `getInstance()` / `instance()` shims on the managers above. The only intentional
+static access points left are:
+
+- `Settings.getInstance()` — early bootstrap only (`main()`, Sentry, token validation) before the
+  context exists; the same instance is registered as `SettingsProvider` for everything else.
+- `App.getInstance()` — application root used by a couple of shutdown entry points
+  (`ShutdownCommand`). Prefer constructor injection of the needed collaborators where possible.
+- `JpaUtils.bind(SessionProvider)` / `LogHandler.bind(GuildServiceProvider)` /
+  `ChannelMessagePurger.bind(ExecutorProvider)` — single well-defined static bind points for deep
+  utility graphs that are not constructor-injected (repositories, static log helpers).
+
+## Configuration
+
+### `Settings` / `SettingsProvider`
+
+**Class:** `me.bobert.netneutrality.platform.config.Settings` implements
+`me.bobert.netneutrality.platform.config.SettingsProvider`.
+
+`Settings` is the single source of truth for configuration. It loads values from the `bot.properties`
+file and overlays **environment variables** on top (environment variables win).
+
+- **Early bootstrap:** `Settings.getInstance()` (process-wide, created once before the context).
+- **Runtime injection:** depend on `SettingsProvider` and let `ApplicationContext` supply the same
+  instance. Prefer this path in commands, tasks, handlers, and services.
+- `Settings.getVersion()` / `Settings.getDiscordInvite()` — thin static helpers used by the banner /
+  invite strings; they delegate to the bootstrap instance.
+
+An example configuration file is `bot.properties.example`. Key configuration values:
+
+| Key                                                                                | Purpose                                                                                         |
+|------------------------------------------------------------------------------------|-------------------------------------------------------------------------------------------------|
+| `NETNEUTRALITY_BOT_ENV`                                                            | `dev` / `prod`; controls debug logging and the Sentry environment.                              |
+| `NETNEUTRALITY_BOT_TOKEN`                                                          | Discord bot token (**required**).                                                               |
+| `NETNEUTRALITY_BOT_PREFIX`                                                         | Message-command prefix (default `$`).                                                           |
+| `NETNEUTRALITY_BOT_OWNER`                                                          | Bot owner user id (used for owner-only commands / permissions).                                 |
+| `NETNEUTRALITY_BOT_INVITE`                                                         | Invite link surfaced by help/info.                                                              |
+| `NETNEUTRALITY_API_PORT`                                                           | Port for the [Web API](web-api.md) (default `9000`).                                            |
+| `MYSQL_*`                                                                          | Database connection settings (see [persistence.md](persistence.md)).                            |
+| `NETNEUTRALITY_SENTRY_DSN`                                                         | Enables Sentry when present.                                                                    |
+| `GITEA_HOST` / `GITEA_TOKEN` / `GITEA_OWNER` / `GITEA_REPO`                        | Gitea issue reporting ([`ReportIssueTask`](tasks.md#worked-example--gitea-bug-report-modal)). Token needs `write:issue`. |
+| `NETNEUTRALITY_LAVALINK_URI` / `_PASSWORD` / `_NAME`                               | Connection settings for the [Lavalink node](music.md#settings).                                 |
+| `NETNEUTRALITY_PO_TOKEN` / `NETNEUTRALITY_VISITOR_DATA` / `NETNEUTRALITY_CIPHER_*` | YouTube auth/cipher settings, consumed by the node via `lavalink/application.yml`.              |
+
+## Utility helpers
+
+**Package:** `me.bobert.netneutrality.shared.util` (helpers) / `me.bobert.netneutrality.bootstrap` / `me.bobert.netneutrality.platform.*`
+
+| Class | Purpose |
+|---|---|
+| `Settings` | Configuration (see above). |
+| `ReflectionHelper` | Classpath scanning / reflective instantiation (see below). |
+| `ContextUtils` | Boilerplate helpers for building/handling [contexts](contexts.md). |
+| `GuildUtils` | Guild-related helpers (lookups, permission checks). |
+| `JpaUtils` | Session/transaction helpers for the [persistence](persistence.md) layer. Bound once to a `SessionProvider` during bootstrap (`JpaUtils.bind`). |
+| `MusicUtils` | Voice-channel connectivity and DJ/permission checks for [music](music.md). Callers pass the guild `MusicManager` (no static music lookup). |
+| `MiscUtils` | Assorted small helpers. |
+| `ChannelMessagePurger` | Bulk message deletion (used by the purge command). Bound once to an `ExecutorProvider` during bootstrap. |
+| `MessageFunction` | Standardized message/embed formatting. Help text builders take a `CommandRegistry` rather than a static command manager. |
+| `UserFunction` | Standardized user/string formatting. |
+
+### `ReflectionHelper`
+
+Built on the `org.reflections` library, `ReflectionHelper` discovers and instantiates implementation
+classes in specific packages. It is the mechanism behind the bot's "drop a class in the right package
+and it's picked up" model, used to auto-load:
+
+- [`Command`](commands.md) implementations (`CommandManager` / `CommandRegistry.start()`),
+- [`BuiltInTask`](tasks.md#32-built-in-tasks) and [`ScheduledTask`](tasks.md#34-scheduled-tasks)
+  implementations (`TaskManager.start()`).
+
+When given an `ApplicationContext`, `newInstance(Class, ApplicationContext)` selects the public
+constructor with the most parameters that can all be resolved via `context.get(parameterType)`. If
+no such constructor exists it falls back to the no-arg constructor. That is how music/admin/react
+commands receive `MusicService`, `GuildServiceProvider`, `TaskManager`, etc. without static
+singletons.
+
+## Logging & error tracking
+
+### `LogHandler`
+
+**Class:** `me.bobert.netneutrality.platform.logging.LogHandler`.
+
+`LogHandler` is the unified logging/error entry point. It routes messages and exceptions to:
+
+1. **Log4j2** (configured by `log4j2.properties`; SLF4J is bridged via `log4j-slf4j2-impl`),
+2. **Sentry** (when `NETNEUTRALITY_SENTRY_DSN` is configured), and
+3. optionally a per-guild **Discord debug channel** (e.g. `sendMessageToDebugChannel(guild, msg)`),
+   gated by [`GuildService.isDebugEnabled()`](persistence.md#service-layer) /
+   [`OLogging`](persistence.md#entity-catalog) configuration.
+
+The Sentry **user** context is attached automatically when a
+[`AbstractContext`](contexts.md#abstractcontext-abstract-class) is created, so captured errors are
+attributed to the Discord user that triggered them.
+
+## Exception hierarchy
+
+**Package:** `me.bobert.netneutrality.exceptions`
+
+```
+RuntimeException
+└── ContextException                 ── carries a Context (guild/channel/user)
+    ├── CommandExecutionException    ── thrown during command processing
+    └── TaskExecutionException       ── thrown during task execution
+
+GracefulContextError                 ── user-facing, non-logged failure → ephemeral reply
+ExecutorException                    ── Thread.UncaughtExceptionHandler → routes crashes to LogHandler
+```
+
+- **`ContextException`** — base runtime exception that carries the [`Context`](contexts.md) in which
+  it occurred, so downstream handling can respond in the right channel and attribute the error.
+- **`CommandExecutionException`** / **`TaskExecutionException`** — specializations thrown by the
+  [command](commands.md) and [task](tasks.md) flows respectively.
+- **`GracefulContextError`** — signals an expected, user-facing problem (e.g. bad input); when caught
+  it produces an ephemeral message to the user instead of a full error log/Sentry event.
+- **`ExecutorException`** — an `UncaughtExceptionHandler` installed by
+  [`BaseThreadFactory`](threading.md#basethreadfactory) so exceptions escaping worker threads are still
+  captured by [`LogHandler`](#loghandler).

docs/web-api.md

@@ -0,0 +1,52 @@
+# HTTP Web API
+
+**Package:** `me.bobert.netneutrality.platform.web` (client module) and
+`me.bobert.netneutrality.platform.web.server` (server).
+**Server:** JDK built-in `com.sun.net.httpserver.HttpServer` (no external web framework).
+
+The bot exposes a small internal HTTP API for health monitoring, control, and guild introspection —
+intended for an external dashboard/companion, not for end users in Discord.
+
+## Server startup
+
+`WebApi` is a [`Lifecycle`](utilities-and-bootstrap.md#applicationcontext--lifecycle) component
+(priority 70) registered in [`App.buildContext()`](architecture.md#startup-lifecycle).
+It receives `SettingsProvider`, `GuildServiceProvider`, and suppliers for the live `JDA` /
+shutdown callback via its constructor. On `start()` it:
+
+- reads the port from `NETNEUTRALITY_API_PORT` (default `9000`),
+- creates an `HttpServer` bound to that port,
+- installs an `Executor` backed by a fixed thread pool of 10 threads named via
+  [`BaseThreadFactory`](threading.md),
+- registers the handler contexts (below), and
+- starts the server.
+
+On `stop()` the server and its executor are shut down gracefully.
+
+## Handler model
+
+`AbstractHandler` (implements `HttpHandler`) is the base for all handlers and provides helpers such as
+`sendJsonResponse(...)` and `sendStringResponse(...)`. Concrete handlers extend it and are mounted at
+a path prefix.
+
+| Handler | Base path | Endpoints |
+|---|---|---|
+| `RootHandler` | `/` | Simple HTML "OK" landing response. |
+| `GuildHandler` | `/guilds` | `/guilds/owner` — guild ids + owner ids (JSON); `/guilds/{guildId}/channels` — text channels (JSON); `/guilds/{guildId}/roles` — roles (JSON). |
+| `ActionHandler` | `/actions` | `/actions/status` — JDA health + gateway ping; `/actions/shutdown` — graceful shutdown. |
+| `SettingsHandler` | `/settings` | `/settings/catalog` — every known setting with its default value and description; `/settings/current/{guildId}` — current guild settings; `/settings/reload/{guildId}` — invalidate & reload the settings cache. |
+
+The action/guild handlers read live state from the [`JDA`](architecture.md) instance and from the
+[persistence services](persistence.md#service-layer) (e.g. `GuildSettingService` for the settings
+endpoints).
+
+## HTTP client — `WebModule`
+
+`WebModule` wraps an `OkHttpClient` for the bot's own outbound HTTP calls (e.g. checking for updates
+via GitLab). It keeps a small `LinkedHashMap`-based response cache limited to 50 entries.
+
+## Notes
+
+- There is no authentication layer documented on these endpoints; the API is expected to be bound to a
+  trusted/internal network (e.g. within the Docker network). `/actions/shutdown` is destructive, so the
+  port should not be exposed publicly.

lavalink/application.yml

@@ -0,0 +1,65 @@
+server:
+  port: 2333
+  address: 0.0.0.0
+
+lavalink:
+  plugins:
+    # Replacement for the in-process dev.lavalink.youtube:v2 source manager.
+    # Custom SABR-enabled fork (ashton045/youtube-source, feat/sabr-support) built by JitPack.
+    - dependency: "com.github.ashton045.youtube-source:youtube-plugin:33d50abd5f"
+      repository: "https://jitpack.io"
+      snapshot: false
+  server:
+    password: "${SERVER_PASSWORD:youshallnotpass}"
+    sources:
+      # Handled by the youtube-plugin below, must stay disabled here.
+      youtube: false
+      soundcloud: true
+      bandcamp: false
+      twitch: false
+      vimeo: false
+      nico: false
+      http: true
+      local: false
+    filters:
+      volume: true
+    bufferDurationMs: 400
+    frameBufferDurationMs: 5000
+    opusEncodingQuality: 10
+    resamplingQuality: LOW
+    trackStuckThresholdMs: 10000
+    useSeekGhosting: true
+    youtubePlaylistLoadLimit: 6
+    playerUpdateInterval: 5
+    youtubeSearchEnabled: true
+    soundcloudSearchEnabled: true
+
+plugins:
+  youtube:
+    enabled: true
+    allowSearch: true
+    allowDirectVideoIds: true
+    allowDirectPlaylistIds: true
+    clients:
+      - TV
+      - MWEB
+      - WEB
+      - MUSIC
+      - WEBEMBEDDED
+      - ANDROID_VR
+      - TVHTML5_SIMPLY
+    oauth:
+      enabled: true
+      refreshToken: "${NETNEUTRALITY_OAUTH_TOKEN}"
+    remoteCipher:
+      url: "${NETNEUTRALITY_CIPHER_URL:http://ejs-api:8001}"
+      password: "${NETNEUTRALITY_CIPHER_PASSWORD:}"
+    remotePot:
+      url: "${NETNEUTRALITY_POT_URL:http://webpo:8080}"
+
+logging:
+  level:
+    root: INFO
+    lavalink: DEBUG
+    # Set to INFO to see the OAuth flow instructions (device code / verification URL) in the terminal.
+    dev.lavalink.youtube.http.YoutubeOauth2Handler: INFO

pom.xml

@@ -11,20 +11,14 @@
     <description>Discord bot</description>
     <packaging>jar</packaging>
 
-    <distributionManagement>
-        <repository>
-            <id>gitea</id>
-            <url>https://gitea.bobert.me/api/packages/anthorob/maven</url>
-        </repository>
-    </distributionManagement>
-
     <properties>
-        <main.class>me.bobert.netneutrality.NetNeutrality</main.class>
+        <main.class>me.bobert.netneutrality.App</main.class>
         <java.version>25</java.version>
         <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
         <maven.compiler.source>25</maven.compiler.source>
         <maven.compiler.target>25</maven.compiler.target>
         <mockito.version>5.23.0</mockito.version>
+        <testcontainers.version>2.0.5</testcontainers.version>
     </properties>
 
     <build>
@@ -36,6 +30,27 @@
         </resources>
 
         <plugins>
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-compiler-plugin</artifactId>
+                <version>3.14.1</version>
+                <configuration>
+                    <release>${java.version}</release>
+                    <proc>full</proc>
+                    <annotationProcessorPaths>
+                        <path>
+                            <groupId>org.hibernate.orm</groupId>
+                            <artifactId>hibernate-processor</artifactId>
+                            <version>7.1.9.Final</version>
+                        </path>
+                        <path>
+                            <groupId>io.javalin.community.openapi</groupId>
+                            <artifactId>openapi-annotation-processor</artifactId>
+                            <version>7.2.3</version>
+                        </path>
+                    </annotationProcessorPaths>
+                </configuration>
+            </plugin>
             <plugin>
                 <groupId>org.apache.maven.plugins</groupId>
                 <artifactId>maven-surefire-plugin</artifactId>
@@ -51,8 +66,11 @@
                 <artifactId>flyway-maven-plugin</artifactId>
                 <version>11.20.3</version>
                 <configuration>
+                    <!--suppress UnresolvedMavenProperty -->
                     <url>${env.FLYWAY_URL}</url>
+                    <!--suppress UnresolvedMavenProperty -->
                     <user>${env.FLYWAY_USER}</user>
+                    <!--suppress UnresolvedMavenProperty -->
                     <password>${env.FLYWAY_PASSWORD}</password>
                 </configuration>
             </plugin>
@@ -89,6 +107,30 @@
                         </goals>
                         <configuration>
                             <finalName>netneutrality</finalName>
+                            <filters>
+                                <filter>
+                                    <artifact>*:*</artifact>
+                                    <excludes>
+                                        <exclude>module-info.class</exclude>
+                                        <exclude>META-INF/versions/*/module-info.class</exclude>
+                                        <exclude>META-INF/MANIFEST.MF</exclude>
+                                        <exclude>META-INF/LICENSE*</exclude>
+                                        <exclude>META-INF/NOTICE*</exclude>
+                                        <exclude>META-INF/DEPENDENCIES</exclude>
+                                        <exclude>META-INF/jandex.idx</exclude>
+                                        <exclude>META-INF/versions/9/OSGI-INF/MANIFEST.MF</exclude>
+                                        <exclude>META-INF/*.SF</exclude>
+                                        <exclude>META-INF/*.DSA</exclude>
+                                        <exclude>META-INF/*.RSA</exclude>
+                                    </excludes>
+                                </filter>
+                                <filter>
+                                    <artifact>com.squareup.okhttp3:okhttp</artifact>
+                                    <excludes>
+                                        <exclude>**</exclude>
+                                    </excludes>
+                                </filter>
+                            </filters>
                             <transformers>
                                 <transformer implementation="org.apache.maven.plugins.shade.resource.ManifestResourceTransformer">
                                     <mainClass>${main.class}</mainClass>
@@ -143,7 +185,7 @@
         <repository>
             <id>arbjergDev-releases</id>
             <name>Lavalink Repository</name>
-            <url>https://maven.lavalink.dev/snapshots</url>
+            <url>https://maven.lavalink.dev/releases</url>
         </repository>
     </repositories>
 
@@ -153,35 +195,11 @@
             <artifactId>JDA</artifactId>
             <version>6.4.1</version>
         </dependency>
+        <!-- Lavalink v4 client; audio decoding happens on the remote node. -->
         <dependency>
             <groupId>dev.arbjerg</groupId>
-            <artifactId>lavaplayer</artifactId>
+            <artifactId>lavalink-client</artifactId>
-            <version>2.2.6</version>
+            <version>3.4.0</version>
-        </dependency>
-        <dependency>
-            <groupId>dev.lavalink.youtube</groupId>
-            <artifactId>v2</artifactId>
-            <version>f45bbb7aebfcbc1c553769e04af6cd43afa8b7c3-SNAPSHOT</version>
-        </dependency>
-        <dependency>
-            <groupId>club.minnced</groupId>
-            <artifactId>jdave-api</artifactId>
-            <version>0.1.8</version>
-        </dependency>
-        <dependency>
-            <groupId>club.minnced</groupId>
-            <artifactId>jdave-native-linux-x86-64</artifactId>
-            <version>0.1.8</version>
-        </dependency>
-        <dependency>
-            <groupId>club.minnced</groupId>
-            <artifactId>jdave-native-win-x86-64</artifactId>
-            <version>0.1.8</version>
-        </dependency>
-        <dependency>
-            <groupId>club.minnced</groupId>
-            <artifactId>jdave-native-darwin</artifactId>
-            <version>0.1.8</version>
         </dependency>
 
         <dependency>
@@ -190,6 +208,33 @@
             <version>5.3.2</version>
         </dependency>
 
+        <dependency>
+            <groupId>io.javalin</groupId>
+            <artifactId>javalin</artifactId>
+            <version>7.2.3</version>
+        </dependency>
+
+        <dependency>
+            <groupId>io.javalin.community.openapi</groupId>
+            <artifactId>openapi-specification</artifactId>
+            <version>7.2.3</version>
+        </dependency>
+        <dependency>
+            <groupId>io.javalin.community.openapi</groupId>
+            <artifactId>javalin-openapi-plugin</artifactId>
+            <version>7.2.3</version>
+        </dependency>
+        <dependency>
+            <groupId>io.javalin.community.openapi</groupId>
+            <artifactId>openapi-generator</artifactId>
+            <version>7.2.3</version>
+        </dependency>
+        <dependency>
+            <groupId>io.javalin.community.openapi</groupId>
+            <artifactId>javalin-swagger-plugin</artifactId>
+            <version>7.2.3</version>
+        </dependency>
+
         <dependency>
             <groupId>org.hibernate.orm</groupId>
             <artifactId>hibernate-core</artifactId>
@@ -200,6 +245,11 @@
             <artifactId>hibernate-hikaricp</artifactId>
             <version>7.1.9.Final</version>
         </dependency>
+        <dependency>
+            <groupId>jakarta.data</groupId>
+            <artifactId>jakarta.data-api</artifactId>
+            <version>1.0.1</version>
+        </dependency>
         <dependency>
             <groupId>com.mysql</groupId>
             <artifactId>mysql-connector-j</artifactId>
@@ -222,11 +272,6 @@
             <artifactId>sentry</artifactId>
             <version>8.41.0</version>
         </dependency>
-        <dependency>
-            <groupId>org.gitlab4j</groupId>
-            <artifactId>gitlab4j-api</artifactId>
-            <version>6.2.0</version>
-        </dependency>
 
         <dependency>
             <groupId>net.fellbaum</groupId>
@@ -235,14 +280,9 @@
         </dependency>
 
         <dependency>
-            <groupId>org.json</groupId>
+            <groupId>com.fasterxml.jackson.core</groupId>
-            <artifactId>json</artifactId>
+            <artifactId>jackson-databind</artifactId>
-            <version>20250517</version>
+            <version>2.21.2</version>
-        </dependency>
-        <dependency>
-            <groupId>com.google.code.gson</groupId>
-            <artifactId>gson</artifactId>
-            <version>2.14.0</version>
         </dependency>
 
         <dependency>
@@ -254,17 +294,17 @@
         <dependency>
             <groupId>org.apache.logging.log4j</groupId>
             <artifactId>log4j-api</artifactId>
-            <version>2.26.1</version>
+            <version>2.26.0</version>
         </dependency>
         <dependency>
             <groupId>org.apache.logging.log4j</groupId>
             <artifactId>log4j-core</artifactId>
-            <version>2.26.1</version>
+            <version>2.26.0</version>
         </dependency>
         <dependency>
             <groupId>org.apache.logging.log4j</groupId>
             <artifactId>log4j-slf4j2-impl</artifactId>
-            <version>2.26.1</version>
+            <version>2.26.0</version>
         </dependency>
 
         <dependency>
@@ -296,6 +336,18 @@
             <version>${mockito.version}</version>
             <scope>test</scope>
         </dependency>
+        <dependency>
+            <groupId>org.testcontainers</groupId>
+            <artifactId>testcontainers-junit-jupiter</artifactId>
+            <version>${testcontainers.version}</version>
+            <scope>test</scope>
+        </dependency>
+        <dependency>
+            <groupId>org.testcontainers</groupId>
+            <artifactId>testcontainers-mysql</artifactId>
+            <version>${testcontainers.version}</version>
+            <scope>test</scope>
+        </dependency>
     </dependencies>
 
 </project>

src/main/java/me/bobert/netneutrality/App.java

@@ -0,0 +1,243 @@
+package me.bobert.netneutrality;
+
+/*
+ * Copyright (c) anthorob
+ *
+ * https://discord.gg/qUa6zNFZsd
+ */
+
+import dev.arbjerg.lavalink.libraries.jda.JDAVoiceUpdateListener;
+import io.sentry.Sentry;
+import me.bobert.netneutrality.bootstrap.ApplicationContext;
+import me.bobert.netneutrality.bootstrap.Lifecycle;
+import me.bobert.netneutrality.bootstrap.BotState;
+import me.bobert.netneutrality.core.LogHandler;
+import me.bobert.netneutrality.core.command.CommandManager;
+import me.bobert.netneutrality.db.SessionManager;
+import me.bobert.netneutrality.core.tasks.TaskManagerImpl;
+import me.bobert.netneutrality.core.scheduled.ScheduledTaskManager;
+import me.bobert.netneutrality.core.thread.ThreadManager;
+import me.bobert.netneutrality.db.service.GuildServiceProviderImpl;
+import me.bobert.netneutrality.music.MusicService;
+import me.bobert.netneutrality.core.command.CommandRegistry;
+import me.bobert.netneutrality.core.tasks.TaskManager;
+import me.bobert.netneutrality.hooks.EventsHandler;
+import me.bobert.netneutrality.http.server.WebApi;
+import me.bobert.netneutrality.music.MusicServiceImpl;
+import me.bobert.netneutrality.core.thread.ExecutorProvider;
+import me.bobert.netneutrality.utils.SettingsProvider;
+import me.bobert.netneutrality.db.service.GuildServiceProvider;
+import me.bobert.netneutrality.utils.ChannelMessagePurger;
+import me.bobert.netneutrality.utils.UserFunction;
+import me.bobert.netneutrality.core.command.precondition.DisabledCommandPrecondition;
+import me.bobert.netneutrality.db.repository.BlacklistRepository;
+import me.bobert.netneutrality.db.repository.GuildRepository;
+import me.bobert.netneutrality.db.repository.GuildSettingRepository;
+import me.bobert.netneutrality.db.repository.TaskRepository;
+import me.bobert.netneutrality.utils.Settings;
+import me.bobert.netneutrality.http.WebModule;
+import net.dv8tion.jda.api.JDA;
+import net.dv8tion.jda.api.JDABuilder;
+import net.dv8tion.jda.api.entities.Activity;
+import net.dv8tion.jda.api.exceptions.InvalidTokenException;
+import net.dv8tion.jda.api.requests.GatewayIntent;
+import org.apache.logging.log4j.Level;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+import org.apache.logging.log4j.core.config.Configurator;
+
+public class App {
+    private static final Logger logger = LogManager.getLogger(App.class);
+    private static App instance;
+    private final Settings settings;
+    private JDA jda;
+    private MusicService music;
+    private final ApplicationContext context = new ApplicationContext();
+
+    static void main() {
+        Settings settings = new Settings();
+        String version = settings.getMavenVersion();
+        WebModule.setDefaultVersion(version);
+        logger.info("Starting App v{}", version);
+
+        String env = settings.get("NETNEUTRALITY_BOT_ENV", "dev");
+        String sentryDsn = settings.get("NETNEUTRALITY_SENTRY_DSN");
+        if (sentryDsn != null) {
+            logger.info("Found Sentry DSN in config, setting up the SDK..");
+
+            Sentry.init(options -> {
+                options.setDsn(sentryDsn);
+                options.setEnvironment(env);
+                options.setTracesSampleRate(1.0);
+                options.setDebug(false);
+                options.setRelease(version);
+            });
+        }
+
+        if ("dev".equals(env)) {
+            Configurator.setLevel("net.dv8tion.jda", Level.DEBUG);
+            Configurator.setLevel("dev.arbjerg.lavalink", Level.DEBUG);
+        }
+
+        instance = new App(settings);
+    }
+
+    public App(Settings settings) {
+        this.settings = settings;
+        startup();
+    }
+
+    private void startup() {
+        String token = settings.get("NETNEUTRALITY_BOT_TOKEN");
+        if (token == null) {
+            throw new RuntimeException("No bot token provided, exiting.");
+        }
+
+        buildContext();
+
+        try {
+            context.start();
+        } catch (Exception e) {
+            LogHandler.log(e);
+            // Roll back the components that did start so no non-daemon thread keeps the JVM alive.
+            context.stop();
+            throw new IllegalStateException("Startup failed", e);
+        }
+
+        Runtime.getRuntime().addShutdownHook(new Thread(this::shutdown));
+    }
+
+    /**
+     * Registers domain services and remaining startup/shutdown adapters with the
+     * {@link ApplicationContext}. Ascending {@link Lifecycle#priority()} drives startup order; the
+     * context stops components in the exact reverse order.
+     */
+    private void buildContext() {
+        // Config first so SettingsProvider is resolvable for constructor injection.
+        context.register((SettingsProvider) settings);
+
+        // Allow ApplicationContext itself to be injected into components that need it.
+        context.register(context);
+
+        // Persistence: run migrations + build the SessionFactory; released last on shutdown.
+        SessionManager sessions = context.register(new SessionManager(settings));
+        GuildRepository guildRepository = new GuildRepository(sessions);
+        BlacklistRepository blacklistRepository = new BlacklistRepository(sessions);
+        GuildSettingRepository guildSettingRepository = new GuildSettingRepository(sessions);
+
+        // Executors: no explicit start today; shut down after music players are disconnected.
+        ExecutorProvider executors = context.register(new ThreadManager());
+        ChannelMessagePurger.bind(executors);
+
+        // Scheduled tasks (priority 55): discovers and schedules all ScheduledTask implementations
+        // on start; cancelled early on shutdown, before executors.
+        context.register(new ScheduledTaskManager(executors, context));
+
+        // Command registry (priority 30).
+        CommandRegistry commands = context.register(new CommandManager(context));
+
+        // Task registry (priority 30).
+        TaskManager tasks = context.register(new TaskManagerImpl(context, new TaskRepository(sessions)));
+
+        // Per-guild service cache (not a Lifecycle component).
+        GuildServiceProvider guildServices = context.register(
+            new GuildServiceProviderImpl(guildRepository, blacklistRepository, guildSettingRepository));
+        LogHandler.bind(guildServices);
+        UserFunction.bind(guildServices);
+        DisabledCommandPrecondition.bind(guildServices);
+
+        // Music sources (priority 40): initialise the shared player manager; disconnect on shutdown.
+        music = context.register(new MusicServiceImpl(settings, guildServices, tasks, executors));
+        BotState.bind(guildServices, music);
+
+        // JDA gateway; disconnected on shutdown.
+        context.register(lifecycle(60, this::initJDA, this::disconnect));
+
+        // Register slash commands, attach the event handler and set the presence once JDA is ready.
+        context.register(lifecycle(65, () -> {
+            commands.registerSlashCommands(jda);
+            jda.addEventListener(new EventsHandler(settings, guildServices, commands, tasks));
+            jda.getPresence().setActivity(Activity.watching("you"));
+        }, () -> { }));
+
+        // Web API (priority 70) — Lifecycle with graceful stop.
+        context.register(new WebApi(settings, guildServices, music, this::getJDA, this::shutdown));
+    }
+
+    private static Lifecycle lifecycle(int priority, ThrowingRunnable start, Runnable stop) {
+        return new Lifecycle() {
+            @Override
+            public void start() throws Exception {
+                start.run();
+            }
+
+            @Override
+            public void stop() {
+                stop.run();
+            }
+
+            @Override
+            public int priority() {
+                return priority;
+            }
+        };
+    }
+
+    @FunctionalInterface
+    private interface ThrowingRunnable {
+        void run() throws Exception;
+    }
+
+    public static App getInstance() {
+        return instance;
+    }
+
+    public void initJDA() {
+        String token = settings.get("NETNEUTRALITY_BOT_TOKEN");
+        if (token == null) {
+            SessionManager sessions = context.get(SessionManager.class);
+            if (sessions != null) {
+                sessions.stop();
+            }
+            throw new RuntimeException("No bot token provided, exiting.");
+        }
+
+        try {
+            jda = JDABuilder
+                .createDefault(token)
+                .enableIntents(
+                    GatewayIntent.GUILD_MEMBERS,
+                    GatewayIntent.GUILD_MESSAGE_REACTIONS,
+                    GatewayIntent.GUILD_VOICE_STATES,
+                    GatewayIntent.MESSAGE_CONTENT)
+                // Voice state/server updates are handed to Lavalink instead of JDA's audio stack;
+                // DAVE encryption is handled by the node.
+                .setVoiceDispatchInterceptor(new JDAVoiceUpdateListener(music.getClient()))
+                .setActivity(Activity.watching("me load..."))
+                .build();
+            jda.awaitReady();
+        } catch (InvalidTokenException | IllegalArgumentException | InterruptedException e) {
+            if (e instanceof InterruptedException) {
+                Thread.currentThread().interrupt();
+            }
+            LogHandler.log(e);
+            throw new IllegalStateException("Unable to connect to Discord", e);
+        }
+    }
+
+    public void shutdown() {
+        logger.info("[Net Neutrality] Shutting down...");
+        context.stop();
+        logger.info("[Net Neutrality] Shutdown complete");
+    }
+
+    public JDA getJDA() {
+        return jda;
+    }
+
+    private void disconnect() {
+        if (jda != null) {
+            jda.shutdown();
+        }
+    }
+}

src/main/java/me/bobert/netneutrality/NetNeutrality.java

@@ -1,138 +0,0 @@
-package me.bobert.netneutrality;
-
-/*
- * Copyright (c) anthorob
- *
- * https://discord.gg/qUa6zNFZsd
- */
-
-import club.minnced.discord.jdave.interop.JDaveSessionFactory;
-import io.sentry.Sentry;
-import me.bobert.netneutrality.core.LogHandler;
-import me.bobert.netneutrality.core.command.CommandManager;
-import me.bobert.netneutrality.core.db.DatabaseMigration;
-import me.bobert.netneutrality.core.db.SessionManager;
-import me.bobert.netneutrality.core.tasks.TaskManager;
-import me.bobert.netneutrality.core.thread.ScheduledTaskManager;
-import me.bobert.netneutrality.core.thread.ThreadManager;
-import me.bobert.netneutrality.hooks.EventsHandler;
-import me.bobert.netneutrality.http.server.WebApi;
-import me.bobert.netneutrality.music.MusicManager;
-import me.bobert.netneutrality.utils.Settings;
-import net.dv8tion.jda.api.JDA;
-import net.dv8tion.jda.api.JDABuilder;
-import net.dv8tion.jda.api.audio.AudioModuleConfig;
-import net.dv8tion.jda.api.entities.Activity;
-import net.dv8tion.jda.api.exceptions.InvalidTokenException;
-import net.dv8tion.jda.api.requests.GatewayIntent;
-import org.apache.logging.log4j.Level;
-import org.apache.logging.log4j.LogManager;
-import org.apache.logging.log4j.Logger;
-import org.apache.logging.log4j.core.config.Configurator;
-
-public class NetNeutrality {
-    private static final Logger logger = LogManager.getLogger(NetNeutrality.class);
-    public static final String VERSION = Settings.getVersion();
-    private static NetNeutrality instance;
-    private static JDA jda;
-
-    static void main() {
-        System.out.println("Starting NetNeutrality v" + VERSION);
-
-        String env = Settings.getInstance().get("NETNEUTRALITY_BOT_ENV", "dev");
-        String sentryDsn = Settings.getInstance().get("NETNEUTRALITY_SENTRY_DSN");
-        if (sentryDsn != null) {
-            logger.info("Found Sentry DSN in config, setting up the SDK..");
-
-            Sentry.init(options -> {
-                options.setDsn(sentryDsn);
-                options.setEnvironment(env);
-                options.setTracesSampleRate(1.0);
-                options.setDebug(false);
-                options.setRelease(VERSION);
-            });
-        }
-
-        if ("dev".equals(env)) {
-            Configurator.setLevel("net.dv8tion.jda", Level.DEBUG);
-            Configurator.setLevel("dev.lavalink.youtube", Level.DEBUG);
-            Configurator.setLevel("com.sedmelluq.discord", Level.DEBUG);
-        }
-
-        instance = new NetNeutrality();
-    }
-
-    public NetNeutrality() {
-        startup();
-    }
-
-    private void startup() {
-        String token = Settings.getInstance().get("NETNEUTRALITY_BOT_TOKEN");
-        if (token == null) {
-            throw new RuntimeException("No bot token provided, exiting.");
-        }
-
-        SessionManager.getSessionFactory();
-        DatabaseMigration.migrate();
-        CommandManager.init();
-        MusicManager.initPlayerManager();
-        TaskManager.getInstance().init();
-        initJDA();
-        CommandManager.registerSlashCommands(jda);
-        jda.addEventListener(new EventsHandler());
-        new WebApi(Integer.parseInt(Settings.getInstance().get("NETNEUTRALITY_API_PORT", "9000")));
-        jda.getPresence().setActivity(Activity.watching("you"));
-
-        Runtime.getRuntime().addShutdownHook(new Thread(this::shutdown));
-    }
-
-    public static NetNeutrality getInstance() {
-        return instance;
-    }
-
-    public void initJDA() {
-        String token = Settings.getInstance().get("NETNEUTRALITY_BOT_TOKEN");
-        if (token == null) {
-            SessionManager.shutdown();
-            throw new RuntimeException("No bot token provided, exiting.");
-        }
-
-        try {
-            jda = JDABuilder
-                .createDefault(token)
-                .enableIntents(
-                    GatewayIntent.GUILD_MEMBERS,
-                    GatewayIntent.GUILD_MESSAGE_REACTIONS,
-                    GatewayIntent.GUILD_VOICE_STATES,
-                    GatewayIntent.MESSAGE_CONTENT)
-                .setAudioModuleConfig(
-                    new AudioModuleConfig().withDaveSessionFactory(new JDaveSessionFactory()))
-                .setActivity(Activity.watching("me load..."))
-                .build();
-            jda.awaitReady();
-        } catch (InvalidTokenException | IllegalArgumentException | InterruptedException e) {
-            LogHandler.log(e);
-            System.exit(1);
-        }
-    }
-
-    public void shutdown() {
-        System.out.println("[Net Neutrality] Shutting down...");
-        ScheduledTaskManager.cancelAll();
-        MusicManager.disconnectPlayers();
-        ThreadManager.shutdownExecutor();
-        disconnect();
-        SessionManager.shutdown();
-        System.out.println("[Net Neutrality] Shutdown complete");
-    }
-
-    public JDA getJDA() {
-        return jda;
-    }
-
-    private void disconnect() {
-        if (jda != null) {
-            jda.shutdown();
-        }
-    }
-}

src/main/java/me/bobert/netneutrality/bootstrap/ApplicationContext.java

@@ -0,0 +1,99 @@
+package me.bobert.netneutrality.bootstrap;
+
+/*
+ * Copyright (c) anthorob
+ *
+ * https://discord.gg/qUa6zNFZsd
+ */
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.Comparator;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+
+/**
+ * A small hand-rolled application container that owns wired instances and drives ordered
+ * startup/shutdown.
+ *
+ * <p>Components implementing {@link Lifecycle} are started in ascending {@link Lifecycle#priority()}
+ * order and stopped in the exact reverse order, giving symmetric, deterministic startup and
+ * shutdown without any DI framework.
+ */
+public final class ApplicationContext {
+    private static final Logger logger = LogManager.getLogger(ApplicationContext.class);
+
+    private final List<Lifecycle> components = new ArrayList<>();
+    private final Map<Class<?>, Object> instances = new HashMap<>();
+
+    /**
+     * Registers a component with the context. If the component implements {@link Lifecycle} it will
+     * participate in ordered start/stop. The instance is also indexed by its concrete type and can
+     * be resolved later via {@link #get(Class)}.
+     *
+     * @param component the component to register
+     * @param <T>       the component type
+     * @return the same component, for fluent wiring
+     */
+    public <T> T register(T component) {
+        if (component instanceof Lifecycle lifecycle) {
+            components.add(lifecycle);
+        }
+        instances.put(component.getClass(), component);
+        return component;
+    }
+
+    /**
+     * Resolves a previously registered instance assignable to the given type.
+     *
+     * @param type the requested type
+     * @param <T>  the requested type
+     * @return the matching instance, or {@code null} if none was registered
+     */
+    public <T> T get(Class<T> type) {
+        Object direct = instances.get(type);
+        if (direct != null) {
+            return type.cast(direct);
+        }
+        for (Object instance : instances.values()) {
+            if (type.isInstance(instance)) {
+                return type.cast(instance);
+            }
+        }
+        return null;
+    }
+
+    /**
+     * Starts all registered {@link Lifecycle} components in ascending priority order.
+     *
+     * @throws Exception if any component fails to start
+     */
+    public void start() throws Exception {
+        components.sort(Comparator.comparingInt(Lifecycle::priority));
+        for (Lifecycle component : components) {
+            logger.debug("Starting component {} (priority {})", component.name(), component.priority());
+            component.start();
+        }
+    }
+
+    /**
+     * Stops all registered {@link Lifecycle} components in the reverse of their start order. Failures
+     * are logged and do not prevent the remaining components from being stopped.
+     */
+    public void stop() {
+        List<Lifecycle> reversed = new ArrayList<>(components);
+        reversed.sort(Comparator.comparingInt(Lifecycle::priority));
+        Collections.reverse(reversed);
+        for (Lifecycle component : reversed) {
+            try {
+                logger.debug("Stopping component {} (priority {})", component.name(), component.priority());
+                component.stop();
+            } catch (Exception e) {
+                logger.error("Error while stopping component {}", component.name(), e);
+            }
+        }
+    }
+}

src/main/java/me/bobert/netneutrality/bootstrap/BotState.java

@@ -0,0 +1,95 @@
+package me.bobert.netneutrality.bootstrap;
+/*
+ * Copyright (c) anthorob
+ *
+ * https://discord.gg/qUa6zNFZsd
+ */
+
+import com.fasterxml.jackson.databind.node.ArrayNode;
+import com.fasterxml.jackson.databind.node.ObjectNode;
+import me.bobert.netneutrality.db.service.GuildServiceProvider;
+import me.bobert.netneutrality.db.service.GuildService;
+import me.bobert.netneutrality.music.MusicService;
+import me.bobert.netneutrality.music.MusicManager;
+import me.bobert.netneutrality.music.TrackScheduler;
+import me.bobert.netneutrality.utils.Json;
+
+import java.io.File;
+import java.io.FileWriter;
+import java.io.IOException;
+import java.util.Map;
+
+public class BotState {
+    public static boolean SAFE = false;
+
+    private static volatile GuildServiceProvider guildServices;
+    private static volatile MusicService musicService;
+
+    /**
+     * Binds providers used by the optional state dump. Called once during bootstrap.
+     *
+     * @param guildServices the guild service provider
+     * @param musicService  the music service
+     */
+    public static void bind(GuildServiceProvider guildServices, MusicService musicService) {
+        BotState.guildServices = guildServices;
+        BotState.musicService = musicService;
+    }
+
+    //TODO: is it needed?
+    private static void saveGuildsState() {
+        if (guildServices == null || musicService == null) {
+            return;
+        }
+
+        Map<String, GuildService> services = guildServices.snapshot();
+
+        ObjectNode main = Json.object();
+        ArrayNode guildsArray = Json.array();
+
+        for (MusicManager manager : musicService.getManagers()) {
+            TrackScheduler trackScheduler = manager.getScheduler();
+        }
+
+        for (GuildService service : services.values()) {
+
+
+            ObjectNode guild = Json.object();
+            ObjectNode music = Json.object();
+            guild.put("id", service.getGuildId());
+
+//            MessageChannel currentChannel = trackScheduler.getTextChannel();
+//            if (currentChannel == null) {
+//                music.put("current_channel", "null");
+//            } else {
+//                music.put("current_channel", currentChannel.getId());
+//            }
+
+            guild.set("music", music);
+
+            guildsArray.add(guild);
+        }
+
+        main.set("guilds", guildsArray);
+
+        File state = new File("state.json");
+        try {
+            if (!state.exists()) {
+                state.createNewFile();
+            }
+
+            try (FileWriter writer = new FileWriter(state)) {
+                writer.write(main.toString());
+            }
+
+        } catch (IOException e) {
+            e.printStackTrace();
+        }
+    }
+
+    public static void dump() {
+        if (!SAFE) {
+            saveGuildsState();
+        }
+    }
+}

src/main/java/me/bobert/netneutrality/bootstrap/Lifecycle.java

@@ -0,0 +1,56 @@
+package me.bobert.netneutrality.bootstrap;
+
+/*
+ * Copyright (c) anthorob
+ *
+ * https://discord.gg/qUa6zNFZsd
+ */
+
+/**
+ * Contract for a component whose lifecycle is owned and driven by the {@link ApplicationContext}.
+ *
+ * <p>Components are {@linkplain #start() started} in ascending {@link #priority()} order and
+ * {@linkplain #stop() stopped} in the exact reverse order, giving symmetric, deterministic startup
+ * and shutdown without any DI framework. A lower {@code priority()} means the component is started
+ * earlier and, consequently, stopped later.
+ */
+public interface Lifecycle {
+
+    /**
+     * Brings the component up. Called exactly once, during {@link ApplicationContext#start()}.
+     *
+     * @throws Exception if the component cannot be started; startup is aborted
+     */
+    void start() throws Exception;
+
+    /**
+     * Tears the component down, releasing whatever {@link #start()} acquired. Called at most once,
+     * during {@link ApplicationContext#stop()}. Implementations should be null-safe / idempotent so
+     * they can cope with a component that never fully started.
+     *
+     * <p>The default is a no-op for components that hold no resources.
+     *
+     * @throws Exception if teardown fails; the context logs it and continues stopping the rest
+     */
+    default void stop() throws Exception {
+    }
+
+    /**
+     * Relative ordering weight. Lower values start earlier and stop later; equal values keep their
+     * registration order. Defaults to {@code 0}.
+     *
+     * @return the priority of this component
+     */
+    default int priority() {
+        return 0;
+    }
+
+    /**
+     * Human-readable name used in lifecycle diagnostics/logging. Defaults to the simple class name.
+     *
+     * @return a short label identifying this component
+     */
+    default String name() {
+        return getClass().getSimpleName();
+    }
+}

src/main/java/me/bobert/netneutrality/bootstrap/ReflectionHelper.java

@@ -0,0 +1,129 @@
+package me.bobert.netneutrality.bootstrap;
+
+/*
+ * Copyright (c) anthorob
+ *
+ * https://discord.gg/qUa6zNFZsd
+ */
+
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+import org.reflections.Reflections;
+
+import java.lang.reflect.Constructor;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Modifier;
+import java.util.Set;
+import java.util.function.BiConsumer;
+import java.util.function.Consumer;
+
+public class ReflectionHelper {
+    private static final Logger logger = LogManager.getLogger(ReflectionHelper.class);
+    private static final BiConsumer<Class<?>, Exception> DEFAULT_FAILURE = (aClass, e) -> logger.error("Failed to load class: {}", aClass.getName(), e);
+
+    public static <E> void loadClassesFromPackage(String packageName, Class<E> clazz, Consumer<E> onInstanciated, BiConsumer<Class<?>, Exception> onFailed) {
+        loadClassesFromPackage(packageName, clazz, null, onInstanciated, onFailed);
+    }
+
+    /**
+     * Discovers concrete subtypes of {@code clazz} under {@code packageName} and instantiates each
+     * one. When a non-null {@link ApplicationContext} is provided, prefers the public constructor
+     * with the most parameters whose every parameter type is resolvable via
+     * {@link ApplicationContext#get(Class)}; otherwise (or when no such constructor exists) falls
+     * back to the no-arg constructor.
+     *
+     * @param packageName    root package to scan
+     * @param clazz          base type of classes to load
+     * @param context        optional DI context used for constructor injection; {@code null} keeps
+     *                       legacy no-arg construction only
+     * @param onInstanciated callback invoked with each successfully created instance
+     * @param onFailed       callback invoked when a class cannot be instantiated
+     * @param <E>            the base type
+     */
+    public static <E> void loadClassesFromPackage(String packageName, Class<E> clazz, ApplicationContext context, Consumer<E> onInstanciated, BiConsumer<Class<?>, Exception> onFailed) {
+        Set<Class<? extends E>> classes = new Reflections(packageName).getSubTypesOf(clazz);
+        for (Class<? extends E> s : classes) {
+            try {
+                if (Modifier.isAbstract(s.getModifiers())) {
+                    continue;
+                }
+
+                E instance = instantiate(s, context);
+                onInstanciated.accept(instance);
+            } catch (InstantiationException | IllegalAccessException | IllegalArgumentException
+                     | InvocationTargetException | NoSuchMethodException | SecurityException e) {
+                onFailed.accept(s, e);
+            }
+        }
+    }
+
+    /**
+     * Instantiates {@code type} using context-based constructor injection when possible.
+     *
+     * <p>Selection algorithm: among public constructors, pick the one with the most parameters for
+     * which every parameter type resolves to a non-null value via {@code context.get(paramType)}.
+     * If no such constructor exists (or {@code context} is null), fall back to the public no-arg
+     * constructor.
+     */
+    @SuppressWarnings("unchecked")
+    public static <E> E instantiate(Class<? extends E> type, ApplicationContext context)
+        throws InstantiationException, IllegalAccessException, InvocationTargetException, NoSuchMethodException {
+        if (context != null) {
+            Constructor<?> best = null;
+            Object[] bestArgs = null;
+
+            for (Constructor<?> ctor : type.getConstructors()) {
+                Class<?>[] paramTypes = ctor.getParameterTypes();
+                if (paramTypes.length == 0) {
+                    continue;
+                }
+
+                Object[] args = new Object[paramTypes.length];
+                boolean resolvable = true;
+                for (int i = 0; i < paramTypes.length; i++) {
+                    Object dependency = context.get(paramTypes[i]);
+                    if (dependency == null) {
+                        resolvable = false;
+                        break;
+                    }
+                    args[i] = dependency;
+                }
+
+                if (resolvable && (best == null || paramTypes.length > best.getParameterCount())) {
+                    best = ctor;
+                    bestArgs = args;
+                }
+            }
+
+            if (best != null) {
+                return (E) best.newInstance(bestArgs);
+            }
+        }
+
+        return type.getConstructor().newInstance();
+    }
+
+    public static <E> void loadCommands(Class<E> clazz, Consumer<E> onInstanciated, BiConsumer<Class<?>, Exception> onFailed) {
+        loadClassesFromPackage("me.bobert.netneutrality", clazz, onInstanciated, onFailed);
+    }
+
+    public static <E> void loadCommands(Class<E> clazz, Consumer<E> onInstanciated) {
+        loadClassesFromPackage("me.bobert.netneutrality", clazz, onInstanciated, DEFAULT_FAILURE);
+    }
+
+    public static <E> void loadCommands(Class<E> clazz, ApplicationContext context, Consumer<E> onInstanciated) {
+        loadClassesFromPackage("me.bobert.netneutrality", clazz, context, onInstanciated, DEFAULT_FAILURE);
+    }
+
+    public static <E> void loadTasks(Class<E> clazz, Consumer<E> onInstanciated, BiConsumer<Class<?>, Exception> onFailed) {
+        loadClassesFromPackage("me.bobert.netneutrality", clazz, onInstanciated, onFailed);
+    }
+
+    public static <E> void loadTasks(Class<E> clazz, Consumer<E> onInstanciated) {
+        loadClassesFromPackage("me.bobert.netneutrality", clazz, onInstanciated, DEFAULT_FAILURE);
+    }
+
+    public static <E> void loadTasks(Class<E> clazz, ApplicationContext context, Consumer<E> onInstanciated) {
+        loadClassesFromPackage("me.bobert.netneutrality", clazz, context, onInstanciated, DEFAULT_FAILURE);
+    }
+}

src/main/java/me/bobert/netneutrality/command/admin/BlacklistCommand.java

@@ -10,15 +10,28 @@ import me.bobert.netneutrality.core.command.CommandOptionsBuilder;
 import me.bobert.netneutrality.core.command.impl.AdminCommand;
 import me.bobert.netneutrality.core.command.options.CommandOption;
 import me.bobert.netneutrality.core.context.CommandContext;
-import me.bobert.netneutrality.db.entities.OBlacklist;
+import me.bobert.netneutrality.db.service.BlacklistEntry;
+import me.bobert.netneutrality.db.service.BlacklistResult;
 import me.bobert.netneutrality.db.service.BlacklistService;
-import me.bobert.netneutrality.db.service.GuildService;
+import me.bobert.netneutrality.db.service.GuildServiceProvider;
 import net.dv8tion.jda.api.interactions.commands.OptionType;
 import net.dv8tion.jda.api.interactions.commands.build.SubcommandData;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
 
 import java.util.List;
+import java.util.Objects;
 
 public class BlacklistCommand extends AdminCommand {
+    private static final Logger logger = LogManager.getLogger(BlacklistCommand.class);
+
+    private final GuildServiceProvider guildServices;
+
+    public BlacklistCommand(GuildServiceProvider guildServices) {
+        Objects.requireNonNull(guildServices, "GuildServiceProvider must not be null");
+        this.guildServices = guildServices;
+    }
+
 
     @Override
     public boolean isEnabled() {
@@ -55,16 +68,16 @@ public class BlacklistCommand extends AdminCommand {
     public CommandExecutionResult execute(CommandContext context) {
         String sub = context.getSubcommand();
         String word = context.getOption("word", "", CommandOption::getAsString);
-        BlacklistService service = GuildService.get(context.getGuild()).getBlacklistService();
+        BlacklistService service = guildServices.get(context.getGuild().getId()).getBlacklistService();
 
         switch (sub) {
             case "get" -> context.async("Retrieving list, please wait...", asyncMessage -> {
-                List<OBlacklist> blacklists = service.getBlacklistForGuild();
+                List<BlacklistEntry> blacklists = service.list();
 
                 StringBuilder sb = new StringBuilder();
                 sb.append("List of blacklisted words for this server: \n");
-                for (OBlacklist bl : blacklists) {
+                for (BlacklistEntry bl : blacklists) {
-                    sb.append(bl.getWord()).append(" -> ").append(bl.getEnabled() ? "enabled" : "disabled").append("\n");
+                    sb.append(bl.word()).append(" -> ").append(bl.enabled() ? "enabled" : "disabled").append("\n");
                 }
 
                 if (blacklists.isEmpty()) {
@@ -74,13 +87,32 @@ public class BlacklistCommand extends AdminCommand {
                 asyncMessage.edit(sb.toString());
             });
             case "add" -> {
-                return service.add(context.getGuildUser(), word);
+                try {
+                    return toReply(service.add(context.getGuildUser().getId(), word), word);
+                } catch (RuntimeException e) {
+                    logger.error("Failed to add word to blacklist", e);
+                    return CommandExecutionResult.warn("Failed to add word to blacklist: " + e.getMessage());
+                }
             }
             case "remove" -> {
-                return service.delete(word);
+                try {
+                    return toReply(service.remove(word), word);
+                } catch (RuntimeException e) {
+                    logger.error("Failed to remove word from blacklist", e);
+                    return CommandExecutionResult.warn("Failed to remove word from blacklist: " + e.getMessage());
+                }
             }
         }
 
         return CommandExecutionResult.none();
     }
+
+    static CommandExecutionResult toReply(BlacklistResult result, String word) {
+        return switch (result) {
+            case ADDED, REENABLED -> CommandExecutionResult.success("Added the word [%s] to the blacklist.", word);
+            case ALREADY_EXISTS -> CommandExecutionResult.warn(String.format("The word [%s] is already in the blacklist.", word));
+            case REMOVED -> CommandExecutionResult.success("Removed the word [%s] from the blacklist.", word);
+            case NOT_FOUND -> CommandExecutionResult.warn(String.format("The word [%s] is not in the blacklist.", word));
+        };
+    }
 }

src/main/java/me/bobert/netneutrality/command/admin/PurgeCommand.java

@@ -0,0 +1,78 @@
+package me.bobert.netneutrality.command.admin;
+/*
+ * Copyright (c) anthorob
+ *
+ * https://discord.gg/qUa6zNFZsd
+ */
+
+import me.bobert.netneutrality.core.command.CommandCategory;
+import me.bobert.netneutrality.core.command.CommandExecutionResult;
+import me.bobert.netneutrality.core.command.CommandOptionsBuilder;
+import me.bobert.netneutrality.core.command.impl.AbstractCommand;
+import me.bobert.netneutrality.core.command.options.CommandOption;
+import me.bobert.netneutrality.core.context.CommandContext;
+import me.bobert.netneutrality.utils.ChannelMessagePurger;
+import net.dv8tion.jda.api.entities.channel.middleman.GuildMessageChannel;
+import net.dv8tion.jda.api.interactions.commands.OptionType;
+import net.dv8tion.jda.api.interactions.commands.build.OptionData;
+
+public class PurgeCommand extends AbstractCommand {
+
+    @Override
+    public boolean needAdmin() {
+        return true;
+    }
+
+    @Override
+    public boolean isEnabled() {
+        return false;
+    }
+
+    @Override
+    public boolean isGuildOnly() {
+        return true;
+    }
+
+    @Override
+    public String getCommandName() {
+        return "purge";
+    }
+
+    @Override
+    public String getDescription() {
+        return "Delete messages from the channel you are currently on";
+    }
+
+    @Override
+    public void registerCommandOptions(CommandOptionsBuilder builder) {
+        builder.addOptions(
+            new OptionData(OptionType.INTEGER, "to-purge", "Number of messages to delete (max 2500)", true)
+                .setRequiredRange(1, 2500));
+    }
+
+    @Override
+    public CommandCategory getCategory() {
+        return CommandCategory.ADMINISTRATION;
+    }
+
+    @Override
+    public CommandExecutionResult execute(CommandContext context) {
+        int toDelete = context.getOption("to-purge", 0, CommandOption::getAsInt);
+        context.ephemeral();
+
+        if (toDelete > 0) {
+            GuildMessageChannel messageChannel = (GuildMessageChannel) context.getChannel();
+            ChannelMessagePurger channelMessagePurger = ChannelMessagePurger.getPurger(messageChannel);
+            boolean lock = channelMessagePurger.canLockBeAcquired();
+            channelMessagePurger.purgeMessages(context, toDelete);
+
+            context.reply("Processing purge command.. This can take some time.");
+
+            if (!lock) {
+                context.reply("Another purge is currently in progress on this channel, please wait before purging again");
+            }
+        }
+
+        return CommandExecutionResult.none();
+    }
+}

src/main/java/me/bobert/netneutrality/command/admin/ReactionCommand.java

@@ -10,8 +10,7 @@ import me.bobert.netneutrality.core.command.CommandOptionsBuilder;
 import me.bobert.netneutrality.core.command.impl.AdminCommand;
 import me.bobert.netneutrality.core.command.options.CommandOption;
 import me.bobert.netneutrality.core.context.CommandContext;
-import me.bobert.netneutrality.core.tasks.TaskManager;
+import me.bobert.netneutrality.tasks.reaction.EmojiReactionRoleTask;
-import me.bobert.netneutrality.tasks.emoji.EmojiReactionRoleTask;
 import net.dv8tion.jda.api.entities.Message;
 import net.dv8tion.jda.api.entities.Role;
 import net.dv8tion.jda.api.interactions.commands.OptionType;
@@ -23,9 +22,18 @@ import java.util.List;
 import java.util.Map;
 import java.util.Objects;
 import java.util.stream.Collectors;
+import me.bobert.netneutrality.core.tasks.TaskManager;
 
 public class ReactionCommand extends AdminCommand {
 
+    private final TaskManager taskManager;
+
+    public ReactionCommand(TaskManager taskManager) {
+        Objects.requireNonNull(taskManager, "TaskManager must not be null");
+        this.taskManager = taskManager;
+    }
+
+
     @Override
     public boolean isEnabled() {
         return true;
@@ -93,11 +101,11 @@ public class ReactionCommand extends AdminCommand {
 
     private CommandExecutionResult executeEmoji(CommandContext context, String guildId, String messageId, String sub) {
         String id = String.format("%s:%s", guildId, messageId);
-        EmojiReactionRoleTask task = (EmojiReactionRoleTask) TaskManager.getInstance().getTask(id);
+        EmojiReactionRoleTask task = (EmojiReactionRoleTask) taskManager.getTask(id);
 
         switch (sub) {
             case "list" -> {
-                List<EmojiReactionRoleTask> tasks = TaskManager.getInstance().findTasksByPartialId(EmojiReactionRoleTask.class, guildId);
+                List<EmojiReactionRoleTask> tasks = taskManager.findTasksByPartialId(EmojiReactionRoleTask.class, guildId);
                 if (tasks.isEmpty()) {
                     return CommandExecutionResult.info("No tasks found for this guild");
                 }

src/main/java/me/bobert/netneutrality/command/basic/HelpCommand.java

@@ -8,12 +8,13 @@ package me.bobert.netneutrality.command.basic;
 import me.bobert.netneutrality.core.command.CommandCategory;
 import me.bobert.netneutrality.core.command.CommandContainer;
 import me.bobert.netneutrality.core.command.CommandExecutionResult;
-import me.bobert.netneutrality.core.command.CommandManager;
 import me.bobert.netneutrality.core.command.CommandOptionsBuilder;
 import me.bobert.netneutrality.core.command.impl.AbstractCommand;
 import me.bobert.netneutrality.core.command.options.CommandOption;
 import me.bobert.netneutrality.core.context.CommandContext;
-import me.bobert.netneutrality.core.tasks.Task;
+import me.bobert.netneutrality.core.tasks.trait.WithButton;
+import me.bobert.netneutrality.core.command.CommandRegistry;
+import me.bobert.netneutrality.core.tasks.TaskManager;
 import me.bobert.netneutrality.tasks.help.BotInfo;
 import me.bobert.netneutrality.tasks.help.CommandHelp;
 import me.bobert.netneutrality.tasks.help.ReportBug;
@@ -26,6 +27,18 @@ import java.util.List;
 
 public class HelpCommand extends AbstractCommand {
 
+    private final CommandRegistry commands;
+    private final TaskManager taskManager;
+
+    public HelpCommand() {
+        this(null, null);
+    }
+
+    public HelpCommand(CommandRegistry commands, TaskManager taskManager) {
+        this.commands = commands;
+        this.taskManager = taskManager;
+    }
+
     @Override
     public boolean needAdmin() {
         return false;
@@ -65,15 +78,15 @@ public class HelpCommand extends AbstractCommand {
     public CommandExecutionResult execute(CommandContext context) {
         String command = context.getOption("command", null, CommandOption::getAsString);
         if (command == null) {
-            Button commands = Task.createButton(CommandHelp.class);
+            Button commandsBtn = createTaskButton(CommandHelp.class);
-            Button info = Task.createButton(BotInfo.class);
+            Button info = createTaskButton(BotInfo.class);
-            Button reportbug = Task.createButton(ReportBug.class);
+            Button reportbug = createTaskButton(ReportBug.class);
-            ActionRow row = ActionRow.of(commands, info, reportbug);
+            ActionRow row = ActionRow.of(commandsBtn, info, reportbug);
             context.replyEphemeral("Thanks for using the Net Neutrality Bot! What do you need help with?", List.of(row));
             return CommandExecutionResult.none();
         }
 
-        CommandContainer container = CommandManager.getCommandContainer(command);
+        CommandContainer container = commands.getCommandContainer(command);
         if (container.getCommand() == null) {
             return CommandExecutionResult.warn("Command does not exist");
         }
@@ -81,4 +94,12 @@ public class HelpCommand extends AbstractCommand {
         context.replyEphemeral(MessageFunction.buildCommandHelpMessage(container));
         return CommandExecutionResult.none();
     }
+
+    private Button createTaskButton(Class<? extends WithButton> clazz) {
+        WithButton withButton = taskManager.findButtonTaskByClass(clazz);
+        if (withButton == null) {
+            throw new IllegalArgumentException("Task " + clazz.getName() + " was not registered by the task manager.");
+        }
+        return withButton.createButton();
+    }
 }

src/main/java/me/bobert/netneutrality/command/bot/ConfigureCommand.java

@@ -12,18 +12,40 @@ import me.bobert.netneutrality.core.command.options.CommandOption;
 import me.bobert.netneutrality.core.context.CommandContext;
 import me.bobert.netneutrality.db.GSettings;
 import me.bobert.netneutrality.db.service.GuildService;
-import me.bobert.netneutrality.music.MusicManager;
+import me.bobert.netneutrality.db.service.GuildSettingService;
 import net.dv8tion.jda.api.entities.Role;
 import net.dv8tion.jda.api.entities.channel.concrete.TextChannel;
 import net.dv8tion.jda.api.entities.channel.unions.GuildChannelUnion;
 import net.dv8tion.jda.api.interactions.commands.OptionType;
 import net.dv8tion.jda.api.interactions.commands.build.OptionData;
 import net.dv8tion.jda.api.interactions.commands.build.SubcommandData;
+import me.bobert.netneutrality.db.service.GuildServiceProvider;
+import me.bobert.netneutrality.music.MusicService;
 import net.dv8tion.jda.api.utils.messages.MessageCreateBuilder;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
 
+import java.util.Arrays;
+import java.util.LinkedHashSet;
 import java.util.Map;
+import java.util.Set;
+import java.util.stream.Collectors;
 
 public class ConfigureCommand extends AdminCommand {
+    private static final Logger logger = LogManager.getLogger(ConfigureCommand.class);
+
+    private final GuildServiceProvider guildServices;
+    private final MusicService musicService;
+
+    public ConfigureCommand() {
+        this(null, null);
+    }
+
+    public ConfigureCommand(GuildServiceProvider guildServices, MusicService musicService) {
+        this.guildServices = guildServices;
+        this.musicService = musicService;
+    }
+
 
     @Override
     public boolean isEnabled() {
@@ -56,85 +78,201 @@ public class ConfigureCommand extends AdminCommand {
             new SubcommandData("music-role", "Role needed to use music commands")
                 .addOption(OptionType.ROLE, "role", "Name of role", true),
             new SubcommandData("music-channel", "Only allow music commands on this channel")
-                .addOption(OptionType.CHANNEL, "channel", "Leave empty to allow everywhere")
+                .addOption(OptionType.CHANNEL, "channel", "Leave empty to allow everywhere"),
+            new SubcommandData("music-max-playlist-size", "Playlist size above which confirmation is asked before queueing")
+                .addOptions(new OptionData(OptionType.INTEGER, "size", "Number of tracks", true)
+                    .setRequiredRange(1, 1000)),
+            new SubcommandData("music-dj-role", "Role that may control music playback without being the current DJ")
+                .addOption(OptionType.ROLE, "role", "Leave empty to clear"),
+            new SubcommandData("music-vote-skip-threshold", "Percentage of listeners required to approve a vote-skip")
+                .addOptions(new OptionData(OptionType.INTEGER, "percent", "Percentage (1-100)", true)
+                    .setRequiredRange(1, 100)),
+            new SubcommandData("music-idle-timeout", "Minutes of inactivity before the bot auto-disconnects")
+                .addOptions(new OptionData(OptionType.INTEGER, "minutes", "Number of minutes", true)
+                    .setRequiredRange(1, 1440)),
+            new SubcommandData("command-prefix", "Override the bot's message command prefix on this server")
+                .addOption(OptionType.STRING, "prefix", "Leave empty to use the bot-wide default"),
+            new SubcommandData("admin-role", "Role granted admin permissions, in addition to Discord permissions")
+                .addOption(OptionType.ROLE, "role", "Leave empty to clear"),
+            new SubcommandData("disabled-commands", "Comma-separated list of command names disabled on this server")
+                .addOption(OptionType.STRING, "commands", "Leave empty to re-enable everything"),
+            new SubcommandData("disable-command", "Disable a single command on this server")
+                .addOption(OptionType.STRING, "name", "Name of the command to disable", true),
+            new SubcommandData("enable-command", "Re-enable a single command on this server")
+                .addOption(OptionType.STRING, "name", "Name of the command to re-enable", true),
+            new SubcommandData("log-level", "Minimum severity of events sent to the log channel")
+                .addOptions(new OptionData(OptionType.STRING, "level", "Severity level", true)
+                    .addChoice("ERROR", "ERROR").addChoice("WARN", "WARN").addChoice("INFO", "INFO")),
+            new SubcommandData("locale", "Preferred locale for the bot's replies on this server")
+                .addOption(OptionType.STRING, "locale", "Locale code, e.g. en, fr", true),
+            new SubcommandData("timezone", "Timezone used to display timestamps on this server")
+                .addOption(OptionType.STRING, "timezone", "Timezone id, e.g. UTC, Europe/Paris", true),
+            new SubcommandData("music-search-engine", "Default search engine used when a play query is not a direct url")
+                .addOptions(new OptionData(OptionType.STRING, "engine", "Search engine", true)
+                    .addChoice("YouTube", "YOUTUBE").addChoice("YouTube Music", "YTMUSIC").addChoice("SoundCloud", "SOUNDCLOUD"))
         );
     }
 
     @Override
     public CommandExecutionResult execute(CommandContext context) {
+        try {
+            return configure(context);
+        } catch (RuntimeException e) {
+            logger.error("Failed to update configuration", e);
+            return CommandExecutionResult.warn("Failed to update configuration: " + e.getMessage());
+        }
+    }
+
+    private CommandExecutionResult configure(CommandContext context) {
         String sub = context.getSubcommand();
-        GuildService guildService = GuildService.get(context.getGuild().getId());
+        GuildService guildService = guildServices.get(context.getGuild().getId());
+        GuildSettingService settingService = guildService.getGuildSettingService();
         context.ephemeral();
 
-        if ("music-role".equals(sub)) {
+        return switch (sub) {
-            Role role = context.getOption("role", CommandOption::getAsRole);
+            case "music-role" -> configureMusicRole(context, settingService);
-            assert role != null;
+            case "music-channel" -> configureMusicChannel(context, settingService);
+            case "music-volume" -> configureMusicVolume(context, settingService);
+            case "error-logging" -> configureErrorLogging(context, guildService);
+            case "music-max-playlist-size" -> configureIntSetting(context, settingService, GSettings.MUSIC_MAXPLAYLISTSIZE, "size", "Maximum playlist size before confirmation is now %d");
+            case "music-dj-role" -> configureRoleSetting(context, settingService, GSettings.MUSIC_DJ_ROLE, "No dedicated DJ role is set anymore", "Successfully set %s as the DJ role");
+            case "music-vote-skip-threshold" -> configureIntSetting(context, settingService, GSettings.MUSIC_VOTE_SKIP_THRESHOLD, "percent", "Vote-skip threshold is now %d%%");
+            case "music-idle-timeout" -> configureIntSetting(context, settingService, GSettings.MUSIC_IDLE_TIMEOUT, "minutes", "Idle disconnect timeout is now %d minutes");
+            case "command-prefix" -> configureStringSetting(context, settingService, GSettings.COMMAND_PREFIX, "prefix", "Command prefix is now reset to the bot-wide default", "Command prefix is now set to %s");
+            case "admin-role" -> configureRoleSetting(context, settingService, GSettings.ADMIN_ROLE, "No dedicated admin role is set anymore", "Successfully set %s as the admin role");
+            case "disabled-commands" -> configureStringSetting(context, settingService, GSettings.DISABLED_COMMANDS, "commands", "All commands are now re-enabled", "Disabled commands are now: %s");
+            case "disable-command" -> toggleDisabledCommand(context, settingService, true);
+            case "enable-command" -> toggleDisabledCommand(context, settingService, false);
+            case "log-level" -> configureStringSetting(context, settingService, GSettings.LOG_LEVEL, "level", "Log level reset to default", "Log level is now %s");
+            case "locale" -> configureStringSetting(context, settingService, GSettings.LOCALE, "locale", "Locale reset to default", "Locale is now %s");
+            case "timezone" -> configureStringSetting(context, settingService, GSettings.TIMEZONE, "timezone", "Timezone reset to default", "Timezone is now %s");
+            case "music-search-engine" -> configureStringSetting(context, settingService, GSettings.MUSIC_SEARCH_ENGINE, "engine", "Default search engine reset to YouTube", "Default search engine is now %s");
+            case "show-all" -> showAll(context, settingService);
+            default -> CommandExecutionResult.error("Unknown subcommand: " + sub);
+        };
+    }
 
-            if (role.getPosition() == -1) {
+    private CommandExecutionResult configureIntSetting(CommandContext context, GuildSettingService settingService, GSettings setting, String optionName, String successFormat) {
-                guildService.getGuildSettingService().setSettingValue(GSettings.MUSIC_ROLE, null);
+        int value = context.getOption(optionName, Integer.parseInt(setting.getDefaultValue()), CommandOption::getAsInt);
+        settingService.set(setting, String.valueOf(value));
 
-                return CommandExecutionResult.success("Everyone can now use music commands");
+        return CommandExecutionResult.success(successFormat, value);
-            }
+    }
 
-            if (role.getGuild().getId().equals(context.getGuild().getId())) {
+    private CommandExecutionResult configureStringSetting(CommandContext context, GuildSettingService settingService, GSettings setting, String optionName, String clearedMessage, String successFormat) {
-                guildService.getGuildSettingService().setSettingValue(GSettings.MUSIC_ROLE, role.getId());
+        String value = context.getOption(optionName, "", CommandOption::getAsString);
 
-                return CommandExecutionResult.success(String.format("Successfully set %s as the role needed for music command", role.getAsMention()));
+        if (value.isEmpty()) {
-            }
+            settingService.set(setting, null);
+            return CommandExecutionResult.success(clearedMessage);
         }
 
-        if ("music-channel".equals(sub)) {
+        settingService.set(setting, value);
-            GuildChannelUnion channel = context.getOption("channel", CommandOption::getAsChannel);
+        return CommandExecutionResult.success(successFormat, value);
+    }
 
-            if (channel == null) {
+    private CommandExecutionResult toggleDisabledCommand(CommandContext context, GuildSettingService settingService, boolean disable) {
-                guildService.getGuildSettingService().setSettingValue(GSettings.MUSIC_CHANNEL, null);
+        String name = context.getOption("name", "", CommandOption::getAsString).trim();
 
-                return CommandExecutionResult.success("No channel restrictions for music commands");
+        Set<String> disabledCommands = Arrays.stream(settingService.getOrDefault(GSettings.DISABLED_COMMANDS).split(","))
-            }
+            .map(String::trim)
-
+            .filter(value -> !value.isEmpty())
-            if (channel instanceof TextChannel) {
+            .collect(Collectors.toCollection(LinkedHashSet::new));
-                if (channel.getGuild().getId().equals(context.getGuild().getId())) {
+
-                    guildService.getGuildSettingService().setSettingValue(GSettings.MUSIC_CHANNEL, channel.getId());
+        if (disable) {
-
+            if (disabledCommands.stream().noneMatch(value -> value.equalsIgnoreCase(name))) {
-                    return CommandExecutionResult.success(String.format("Successfully set %s as the channel required to execute music command", channel.getAsMention()));
+                disabledCommands.add(name);
-                }
+            }
+        } else {
+            disabledCommands.removeIf(value -> value.equalsIgnoreCase(name));
+        }
+
+        settingService.set(GSettings.DISABLED_COMMANDS, disabledCommands.isEmpty() ? null : String.join(",", disabledCommands));
+
+        return CommandExecutionResult.success(disable ? "Command %s is now disabled on this server" : "Command %s is now re-enabled on this server", name);
+    }
+
+    private CommandExecutionResult configureRoleSetting(CommandContext context, GuildSettingService settingService, GSettings setting, String clearedMessage, String successFormat) {
+        Role role = context.getOption("role", CommandOption::getAsRole);
+
+        if (role == null) {
+            settingService.set(setting, null);
+            return CommandExecutionResult.success(clearedMessage);
+        }
+
+        settingService.set(setting, role.getId());
+        return CommandExecutionResult.success(successFormat, role.getAsMention());
+    }
+
+    private CommandExecutionResult configureMusicRole(CommandContext context, GuildSettingService settingService) {
+        Role role = context.getOption("role", CommandOption::getAsRole);
+        assert role != null;
+
+        if (role.getPosition() == -1) {
+            settingService.set(GSettings.MUSIC_ROLE, null);
+
+            return CommandExecutionResult.success("Everyone can now use music commands");
+        }
+
+        if (role.getGuild().getId().equals(context.getGuild().getId())) {
+            settingService.set(GSettings.MUSIC_ROLE, role.getId());
+
+            return CommandExecutionResult.success(String.format("Successfully set %s as the role needed for music command", role.getAsMention()));
+        }
+
+        return CommandExecutionResult.error("Unknown subcommand: music-role");
+    }
+
+    private CommandExecutionResult configureMusicChannel(CommandContext context, GuildSettingService settingService) {
+        GuildChannelUnion channel = context.getOption("channel", CommandOption::getAsChannel);
+
+        if (channel == null) {
+            settingService.set(GSettings.MUSIC_CHANNEL, null);
+
+            return CommandExecutionResult.success("No channel restrictions for music commands");
+        }
+
+        if (channel instanceof TextChannel && channel.getGuild().getId().equals(context.getGuild().getId())) {
+            settingService.set(GSettings.MUSIC_CHANNEL, channel.getId());
+
+            return CommandExecutionResult.success(String.format("Successfully set %s as the channel required to execute music command", channel.getAsMention()));
+        }
+
+        return CommandExecutionResult.error("Unknown subcommand: music-channel");
+    }
+
+    private CommandExecutionResult configureMusicVolume(CommandContext context, GuildSettingService settingService) {
+        int volume = context.getOption("volume", 30, CommandOption::getAsInt);
+        settingService.set(GSettings.MUSIC_VOLUME, String.valueOf(volume));
+        musicService.get(context.getGuild()).setVolume(volume);
+
+        return CommandExecutionResult.success(String.format("Default volume for music player is now %d", volume));
+    }
+
+    private CommandExecutionResult configureErrorLogging(CommandContext context, GuildService guildService) {
+        boolean debug = context.getOption("debug", true, CommandOption::getAsBoolean);
+        guildService.updateDebugMode(debug);
+
+        return CommandExecutionResult.success("Error logging is now %s for this guild", (debug ? "enabled" : "disabled"));
+    }
+
+    private CommandExecutionResult showAll(CommandContext context, GuildSettingService settingService) {
+        Map<String, String> settings = settingService.snapshot();
+        MessageCreateBuilder builder = new MessageCreateBuilder();
+
+        for (GSettings o : GSettings.values()) {
+            String value = o.getDefaultValue();
+
+            if (settings.containsKey(o.getName())) {
+                value = settings.get(o.getName());
             }
 
+            builder.addContent(o.getName()).addContent(" (").addContent(o.getDescription()).addContent("): ").addContent(value);
+            builder.addContent("\n");
         }
 
-        if ("music-volume".equals(sub)) {
+        context.replyEphemeral(builder.build());
-            int volume = context.getOption("volume", 30, CommandOption::getAsInt);
-            guildService.getGuildSettingService().setSettingValue(GSettings.MUSIC_VOLUME, String.valueOf(volume));
-            MusicManager.get(context.getGuild()).setVolume(volume);
 
-            return CommandExecutionResult.success(String.format("Default volume for music player is now %d", volume));
+        return CommandExecutionResult.success("Displayed current configuration");
-        }
-
-        if ("error-logging".equals(sub)) {
-            boolean debug = context.getOption("debug", true, CommandOption::getAsBoolean);
-            guildService.updateDebugMode(debug);
-
-            return CommandExecutionResult.success("Error logging is now %s for this guild", (debug ? "enabled" : "disabled"));
-        }
-
-        if ("show-all".equals(sub)) {
-            Map<String, String> settings = guildService.getGuildSettingService().getSettings();
-            MessageCreateBuilder builder = new MessageCreateBuilder();
-
-            for (GSettings o : GSettings.values()) {
-                String value = o.getDefaultValue();
-
-                if (settings.containsKey(o.getName())) {
-                    value = settings.get(o.getName());
-                }
-
-                builder.addContent(o.getName()).addContent(": ").addContent(value);
-                builder.addContent("\n");
-            }
-
-            context.replyEphemeral(builder.build());
-        }
-
-        return CommandExecutionResult.error("Unknown subcommand: " + sub);
     }
 }

src/main/java/me/bobert/netneutrality/command/crypto/CryptoPriceCommand.java

@@ -5,6 +5,8 @@ package me.bobert.netneutrality.command.crypto;
  * https://discord.gg/qUa6zNFZsd
  */
 
+import com.fasterxml.jackson.databind.JsonNode;
+import com.fasterxml.jackson.databind.node.ObjectNode;
 import me.bobert.netneutrality.core.LogHandler;
 import me.bobert.netneutrality.core.command.CommandCategory;
 import me.bobert.netneutrality.core.command.CommandExecutionResult;
@@ -15,7 +17,6 @@ import me.bobert.netneutrality.core.context.CommandContext;
 import me.bobert.netneutrality.http.WebModule;
 import net.dv8tion.jda.api.interactions.commands.OptionType;
 import net.dv8tion.jda.api.interactions.commands.build.OptionData;
-import org.json.JSONObject;
 
 import java.text.NumberFormat;
 import java.util.Currency;
@@ -69,7 +70,7 @@ public class CryptoPriceCommand extends AbstractCommand {
 
     @Override
     public CommandExecutionResult execute(CommandContext context) {
-        Locale usa = new Locale("en", "US");
+        Locale usa = Locale.US;
         NumberFormat dollarFormat = NumberFormat.getCurrencyInstance(usa);
         dollarFormat.setMaximumFractionDigits(24);
 
@@ -91,14 +92,19 @@ public class CryptoPriceCommand extends AbstractCommand {
                 }
 
                 WebModule http = new WebModule.Builder(String.format(baseURL, symbol, finalCurrency)).cache(30, TimeUnit.MINUTES).build().request();
-                JSONObject json = http.getAsObject();
+                ObjectNode json = http.getAsObject();
 
-                if (json.isEmpty() || (json.has("Response") && json.getString("Response").equalsIgnoreCase("Error"))) {
+                if (json.isEmpty() || json.path("Response").asText("").equalsIgnoreCase("Error")) {
                     asyncMessage.edit("Crypto doesn't exist.. yet");
                     return;
                 }
 
-                double value = json.getDouble(finalCurrency);
+                JsonNode priceNode = json.path(finalCurrency);
+                if (!priceNode.isNumber()) {
+                    throw new IllegalStateException("Missing price for currency " + finalCurrency);
+                }
+
+                double value = priceNode.asDouble();
                 String price = dollarFormat.format(value);
 
                 asyncMessage.edit(String.format("The current price of %s in %s is %s", symbol, finalCurrency, price));
@@ -115,12 +121,12 @@ public class CryptoPriceCommand extends AbstractCommand {
     private boolean validateSymbol(String symbol) {
         try {
             WebModule http = new WebModule.Builder(exchangeApi).get().cache(1, TimeUnit.DAYS).build().request();
-            JSONObject json = http.getAsObject();
+            ObjectNode json = http.getAsObject();
 
-            JSONObject pairs = json.getJSONObject("Data")
+            JsonNode pairs = json.path("Data")
-                .getJSONObject("exchanges")
+                .path("exchanges")
-                .getJSONObject(exchange)
+                .path(exchange)
-                .getJSONObject("pairs");
+                .path("pairs");
 
             return pairs.has(symbol);
 

src/main/java/me/bobert/netneutrality/command/custom/.gitignore

@@ -1 +1 @@
-*.java
+**/*.java

src/main/java/me/bobert/netneutrality/command/git/ReportIssueCommand.java

@@ -10,13 +10,25 @@ import me.bobert.netneutrality.core.command.CommandExecutionResult;
 import me.bobert.netneutrality.core.command.CommandOptionsBuilder;
 import me.bobert.netneutrality.core.command.impl.AbstractCommand;
 import me.bobert.netneutrality.core.context.CommandContext;
-import me.bobert.netneutrality.http.WebModule;
+import me.bobert.netneutrality.utils.GiteaClient;
 import me.bobert.netneutrality.tasks.git.ReportIssueTask;
-import me.bobert.netneutrality.utils.Settings;
 
-import java.util.concurrent.TimeUnit;
+import java.util.Objects;
+import me.bobert.netneutrality.core.tasks.TaskManager;
+import me.bobert.netneutrality.utils.SettingsProvider;
 
 public class ReportIssueCommand extends AbstractCommand {
+
+    private final SettingsProvider settings;
+    private final TaskManager taskManager;
+
+    public ReportIssueCommand(SettingsProvider settings, TaskManager taskManager) {
+        Objects.requireNonNull(settings, "SettingsProvider must not be null");
+        Objects.requireNonNull(taskManager, "TaskManager must not be null");
+        this.settings = settings;
+        this.taskManager = taskManager;
+    }
+
     @Override
     public boolean needAdmin() {
         return false;
@@ -59,16 +71,17 @@ public class ReportIssueCommand extends AbstractCommand {
 
     @Override
     public CommandExecutionResult execute(CommandContext context) {
-        String gitlabHost = Settings.getInstance().get("GITLAB_HOST");
+        String host = settings.get("GITEA_HOST");
-        String gitlabToken = Settings.getInstance().get("GITLAB_TOKEN");
+        String token = settings.get("GITEA_TOKEN");
-        String projectId = Settings.getInstance().get("GITLAB_PROJECT_ID");
+        String owner = settings.get("GITEA_OWNER");
+        String repo = settings.get("GITEA_REPO");
 
-        if (gitlabHost == null || gitlabToken == null || projectId == null) {
+        if (host == null || token == null || owner == null || repo == null) {
             return CommandExecutionResult.error("Command is not configured, failed to create issue.");
         }
 
-        if (new WebModule.Builder(gitlabHost).ping().timeout(2, TimeUnit.SECONDS).build().request().isSuccess()) {
+        if (new GiteaClient(host, token, owner, repo).ping()) {
-            return CommandExecutionResult.task(new ReportIssueTask(context));
+            return CommandExecutionResult.task(new ReportIssueTask(taskManager, context, settings));
         }
 
         return CommandExecutionResult.error("Unable to create bug reports at this time, please try again later.");

src/main/java/me/bobert/netneutrality/command/music/BitconnectCommand.java

@@ -10,11 +10,28 @@ import me.bobert.netneutrality.core.command.CommandCategory;
 import me.bobert.netneutrality.core.command.CommandExecutionResult;
 import me.bobert.netneutrality.core.command.CommandOptionsBuilder;
 import me.bobert.netneutrality.core.command.impl.MusicCommand;
+import me.bobert.netneutrality.db.service.GuildServiceProvider;
+import me.bobert.netneutrality.music.MusicService;
 import me.bobert.netneutrality.core.context.CommandContext;
 import me.bobert.netneutrality.music.MusicManager;
 
 public class BitconnectCommand extends MusicCommand {
 
+    private final MusicService musicService;
+
+    public BitconnectCommand() {
+        this(null, null);
+    }
+
+    public BitconnectCommand(MusicService musicService) {
+        this(musicService, null);
+    }
+
+    public BitconnectCommand(MusicService musicService, GuildServiceProvider guildServices) {
+        super(guildServices);
+        this.musicService = musicService;
+    }
+
     @Override
     public boolean isEnabled() {
         return true;
@@ -42,7 +59,7 @@ public class BitconnectCommand extends MusicCommand {
 
     @Override
     public CommandExecutionResult execute(CommandContext context) {
-        MusicManager manager = MusicManager.get(context.getGuild());
+        MusicManager manager = musicService.get(context.getGuild());
         context.ephemeral();
         context.deleteMessage();
 

src/main/java/me/bobert/netneutrality/command/music/ClearQueueCommand.java

@@ -9,12 +9,29 @@ package me.bobert.netneutrality.command.music;
 import me.bobert.netneutrality.core.command.CommandExecutionResult;
 import me.bobert.netneutrality.core.command.CommandOptionsBuilder;
 import me.bobert.netneutrality.core.command.impl.MusicCommand;
+import me.bobert.netneutrality.db.service.GuildServiceProvider;
+import me.bobert.netneutrality.music.MusicService;
 import me.bobert.netneutrality.core.context.CommandContext;
 import me.bobert.netneutrality.music.MusicManager;
 import me.bobert.netneutrality.utils.MusicUtils;
 
 public class ClearQueueCommand extends MusicCommand {
 
+    private final MusicService musicService;
+
+    public ClearQueueCommand() {
+        this(null, null);
+    }
+
+    public ClearQueueCommand(MusicService musicService) {
+        this(musicService, null);
+    }
+
+    public ClearQueueCommand(MusicService musicService, GuildServiceProvider guildServices) {
+        super(guildServices);
+        this.musicService = musicService;
+    }
+
     @Override
     public boolean needAdmin() {
         return true;
@@ -42,11 +59,11 @@ public class ClearQueueCommand extends MusicCommand {
 
     @Override
     public CommandExecutionResult execute(CommandContext context) {
-        MusicManager manager = MusicManager.get(context.getGuild());
+        MusicManager manager = musicService.get(context.getGuild());
         context.ack();
 
-        if (MusicUtils.checkIfConnected(context)) {
+        if (MusicUtils.checkIfConnected(context, manager)) {
-            return manager.getQueueManager().clearQueue();
+            return CommandExecutionResult.from(manager.getQueueManager().clearQueue());
         }
 
         return CommandExecutionResult.none();

src/main/java/me/bobert/netneutrality/command/music/CurrentlyPlayingCommand.java

@@ -9,6 +9,8 @@ package me.bobert.netneutrality.command.music;
 import me.bobert.netneutrality.core.command.CommandExecutionResult;
 import me.bobert.netneutrality.core.command.CommandOptionsBuilder;
 import me.bobert.netneutrality.core.command.impl.MusicCommand;
+import me.bobert.netneutrality.db.service.GuildServiceProvider;
+import me.bobert.netneutrality.music.MusicService;
 import me.bobert.netneutrality.core.context.CommandContext;
 import me.bobert.netneutrality.music.MusicManager;
 import me.bobert.netneutrality.utils.MessageFunction;
@@ -16,6 +18,21 @@ import me.bobert.netneutrality.utils.MusicUtils;
 
 public class CurrentlyPlayingCommand extends MusicCommand {
 
+    private final MusicService musicService;
+
+    public CurrentlyPlayingCommand() {
+        this(null, null);
+    }
+
+    public CurrentlyPlayingCommand(MusicService musicService) {
+        this(musicService, null);
+    }
+
+    public CurrentlyPlayingCommand(MusicService musicService, GuildServiceProvider guildServices) {
+        super(guildServices);
+        this.musicService = musicService;
+    }
+
     @Override
     public boolean isEnabled() {
         return true;
@@ -38,10 +55,10 @@ public class CurrentlyPlayingCommand extends MusicCommand {
 
     @Override
     public CommandExecutionResult execute(CommandContext context) {
-        MusicManager manager = MusicManager.get(context.getGuild());
+        MusicManager manager = musicService.get(context.getGuild());
         context.ack();
 
-        if (MusicUtils.checkIfConnected(context)) {
+        if (MusicUtils.checkIfConnected(context, manager)) {
             if (!manager.isCurrentlyPlaying()) {
                 return CommandExecutionResult.info("Bot isn't playing any tracks right now");
             }

src/main/java/me/bobert/netneutrality/command/music/JoinCommand.java

@@ -9,11 +9,29 @@ package me.bobert.netneutrality.command.music;
 import me.bobert.netneutrality.core.command.CommandExecutionResult;
 import me.bobert.netneutrality.core.command.CommandOptionsBuilder;
 import me.bobert.netneutrality.core.command.impl.MusicCommand;
+import me.bobert.netneutrality.db.service.GuildServiceProvider;
+import me.bobert.netneutrality.music.MusicService;
+import me.bobert.netneutrality.music.MusicManager;
 import me.bobert.netneutrality.core.context.CommandContext;
 import me.bobert.netneutrality.utils.MusicUtils;
 
 public class JoinCommand extends MusicCommand {
 
+    private final MusicService musicService;
+
+    public JoinCommand() {
+        this(null, null);
+    }
+
+    public JoinCommand(MusicService musicService) {
+        this(musicService, null);
+    }
+
+    public JoinCommand(MusicService musicService, GuildServiceProvider guildServices) {
+        super(guildServices);
+        this.musicService = musicService;
+    }
+
     @Override
     public boolean isEnabled() {
         return true;
@@ -36,7 +54,9 @@ public class JoinCommand extends MusicCommand {
 
     @Override
     public CommandExecutionResult execute(CommandContext context) {
-        if (MusicUtils.connect(context)) {
+        MusicManager manager = musicService.get(context.getGuild());
+
+        if (MusicUtils.connect(context, manager)) {
             context.reply("Joining current voice channel");
         }
 

src/main/java/me/bobert/netneutrality/command/music/LeaveCommand.java

@@ -10,11 +10,35 @@ import me.bobert.netneutrality.core.command.CommandExecutionResult;
 import me.bobert.netneutrality.core.command.CommandOptionsBuilder;
 import me.bobert.netneutrality.core.command.impl.MusicCommand;
 import me.bobert.netneutrality.core.context.CommandContext;
+import me.bobert.netneutrality.db.service.GuildServiceProvider;
+import me.bobert.netneutrality.music.MusicService;
 import me.bobert.netneutrality.music.MusicManager;
 import me.bobert.netneutrality.utils.MusicUtils;
 
+/**
+ * Leaves the voice channel for the current guild.
+ *
+ * <p>Representative command migrated to constructor injection of {@link MusicService} (and optional
+ * {@link GuildServiceProvider} for the {@link MusicCommand} base). The no-arg constructor remains as
+ * a fallback for non-DI loaders.
+ */
 public class LeaveCommand extends MusicCommand {
 
+    private final MusicService musicService;
+
+    public LeaveCommand() {
+        this(null, null);
+    }
+
+    public LeaveCommand(MusicService musicService) {
+        this(musicService, null);
+    }
+
+    public LeaveCommand(MusicService musicService, GuildServiceProvider guildServices) {
+        super(guildServices);
+        this.musicService = musicService;
+    }
+
     @Override
     public boolean isEnabled() {
         return true;
@@ -37,9 +61,9 @@ public class LeaveCommand extends MusicCommand {
 
     @Override
     public CommandExecutionResult execute(CommandContext context) {
-        MusicManager manager = MusicManager.get(context.getGuild());
+        MusicManager manager = musicService.get(context.getGuild());
 
-        if (MusicUtils.checkIfConnected(context)) {
+        if (MusicUtils.checkIfConnected(context, manager)) {
             context.reply("Leaving voice channel and clearing queue");
             manager.disconnect();
         }

src/main/java/me/bobert/netneutrality/command/music/PlayCommand.java

@@ -9,6 +9,8 @@ package me.bobert.netneutrality.command.music;
 import me.bobert.netneutrality.core.command.CommandExecutionResult;
 import me.bobert.netneutrality.core.command.CommandOptionsBuilder;
 import me.bobert.netneutrality.core.command.impl.MusicCommand;
+import me.bobert.netneutrality.db.service.GuildServiceProvider;
+import me.bobert.netneutrality.music.MusicService;
 import me.bobert.netneutrality.core.command.options.CommandOption;
 import me.bobert.netneutrality.core.context.CommandContext;
 import me.bobert.netneutrality.music.MusicManager;
@@ -16,6 +18,21 @@ import net.dv8tion.jda.api.interactions.commands.OptionType;
 
 public class PlayCommand extends MusicCommand {
 
+    private final MusicService musicService;
+
+    public PlayCommand() {
+        this(null, null);
+    }
+
+    public PlayCommand(MusicService musicService) {
+        this(musicService, null);
+    }
+
+    public PlayCommand(MusicService musicService, GuildServiceProvider guildServices) {
+        super(guildServices);
+        this.musicService = musicService;
+    }
+
     @Override
     public boolean isEnabled() {
         return true;
@@ -38,7 +55,7 @@ public class PlayCommand extends MusicCommand {
 
     @Override
     public CommandExecutionResult execute(CommandContext context) {
-        MusicManager manager = MusicManager.get(context.getGuild());
+        MusicManager manager = musicService.get(context.getGuild());
         String query = context.getOption("query", CommandOption::getAsString);
         context.ack();
 

src/main/java/me/bobert/netneutrality/command/music/QueueCommand.java

@@ -8,6 +8,8 @@ package me.bobert.netneutrality.command.music;
 import me.bobert.netneutrality.core.command.CommandExecutionResult;
 import me.bobert.netneutrality.core.command.CommandOptionsBuilder;
 import me.bobert.netneutrality.core.command.impl.MusicCommand;
+import me.bobert.netneutrality.db.service.GuildServiceProvider;
+import me.bobert.netneutrality.music.MusicService;
 import me.bobert.netneutrality.core.command.options.CommandOption;
 import me.bobert.netneutrality.core.context.CommandContext;
 import me.bobert.netneutrality.music.MusicManager;
@@ -20,6 +22,21 @@ import net.dv8tion.jda.api.interactions.commands.build.SubcommandData;
 
 public class QueueCommand extends MusicCommand {
 
+    private final MusicService musicService;
+
+    public QueueCommand() {
+        this(null, null);
+    }
+
+    public QueueCommand(MusicService musicService) {
+        this(musicService, null);
+    }
+
+    public QueueCommand(MusicService musicService, GuildServiceProvider guildServices) {
+        super(guildServices);
+        this.musicService = musicService;
+    }
+
     @Override
     public boolean isEnabled() {
         return true;
@@ -58,26 +75,26 @@ public class QueueCommand extends MusicCommand {
 
     @Override
     public CommandExecutionResult execute(CommandContext context) {
-        MusicManager manager = MusicManager.get(context.getGuild());
+        MusicManager manager = musicService.get(context.getGuild());
         String sub = context.getSubcommand();
         context.ack();
 
-        if (MusicUtils.checkIfConnected(context)) {
+        if (MusicUtils.checkIfConnected(context, manager)) {
 
             switch (sub) {
                 case "clear-all" -> {
-                    return manager.getQueueManager().clearQueue();
+                    return CommandExecutionResult.from(manager.getQueueManager().clearQueue());
                 }
 
                 case "delete-track" -> {
                     int position = context.getOption("position", 0, CommandOption::getAsInt);
-                    return manager.getQueueManager().removeFromQueue(position);
+                    return CommandExecutionResult.from(manager.getQueueManager().removeFromQueue(position));
                 }
 
                 case "show-queue" -> context.reply(MessageFunction.buildViewQueueMessage(manager));
 
                 case "shuffle" -> {
-                    return manager.getQueueManager().shuffle();
+                    return CommandExecutionResult.from(manager.getQueueManager().shuffle());
                 }
 
                 case "from-user" -> {
@@ -95,7 +112,7 @@ public class QueueCommand extends MusicCommand {
                         return CommandExecutionResult.warn("The user isn't from this guild");
                     }
 
-                    return manager.getQueueManager().removeTracksFromUser(member);
+                    return CommandExecutionResult.from(manager.getQueueManager().removeTracksFromUser(member));
                 }
             }
         }

src/main/java/me/bobert/netneutrality/command/music/ResumeCommand.java

@@ -4,14 +4,37 @@ package me.bobert.netneutrality.command.music;/*
  * https://discord.gg/qUa6zNFZsd
  */
 
+/*
+ * Copyright (c) anthorob
+ *
+ * https://discord.gg/qUa6zNFZsd
+ */
+
 import me.bobert.netneutrality.core.command.CommandExecutionResult;
 import me.bobert.netneutrality.core.command.CommandOptionsBuilder;
 import me.bobert.netneutrality.core.command.impl.MusicCommand;
+import me.bobert.netneutrality.db.service.GuildServiceProvider;
+import me.bobert.netneutrality.music.MusicService;
 import me.bobert.netneutrality.core.context.CommandContext;
 import me.bobert.netneutrality.music.MusicManager;
 import me.bobert.netneutrality.utils.MusicUtils;
 
 public class ResumeCommand extends MusicCommand {
+
+    private final MusicService musicService;
+
+    public ResumeCommand() {
+        this(null, null);
+    }
+
+    public ResumeCommand(MusicService musicService) {
+        this(musicService, null);
+    }
+
+    public ResumeCommand(MusicService musicService, GuildServiceProvider guildServices) {
+        super(guildServices);
+        this.musicService = musicService;
+    }
     @Override
     public boolean isEnabled() {
         return true;
@@ -34,10 +57,10 @@ public class ResumeCommand extends MusicCommand {
 
     @Override
     public CommandExecutionResult execute(CommandContext context) {
-        MusicManager manager = MusicManager.get(context.getGuild());
+        MusicManager manager = musicService.get(context.getGuild());
 
-        if (MusicUtils.checkIfConnected(context)) {
+        if (MusicUtils.checkIfConnected(context, manager)) {
-            return manager.resume();
+            return CommandExecutionResult.from(manager.resume());
         }
 
         return CommandExecutionResult.none();

src/main/java/me/bobert/netneutrality/command/music/ShuffleCommand.java

@@ -9,11 +9,28 @@ package me.bobert.netneutrality.command.music;
 import me.bobert.netneutrality.core.command.CommandExecutionResult;
 import me.bobert.netneutrality.core.command.CommandOptionsBuilder;
 import me.bobert.netneutrality.core.command.impl.MusicCommand;
+import me.bobert.netneutrality.db.service.GuildServiceProvider;
+import me.bobert.netneutrality.music.MusicService;
 import me.bobert.netneutrality.core.context.CommandContext;
 import me.bobert.netneutrality.music.MusicManager;
 import me.bobert.netneutrality.utils.MusicUtils;
 
 public class ShuffleCommand extends MusicCommand {
+
+    private final MusicService musicService;
+
+    public ShuffleCommand() {
+        this(null, null);
+    }
+
+    public ShuffleCommand(MusicService musicService) {
+        this(musicService, null);
+    }
+
+    public ShuffleCommand(MusicService musicService, GuildServiceProvider guildServices) {
+        super(guildServices);
+        this.musicService = musicService;
+    }
     @Override
     public boolean isEnabled() {
         return true;
@@ -36,11 +53,11 @@ public class ShuffleCommand extends MusicCommand {
 
     @Override
     public CommandExecutionResult execute(CommandContext context) {
-        MusicManager manager = MusicManager.get(context.getGuild());
+        MusicManager manager = musicService.get(context.getGuild());
         context.ack();
 
-        if (MusicUtils.checkIfConnected(context)) {
+        if (MusicUtils.checkIfConnected(context, manager)) {
-            return manager.getQueueManager().shuffle();
+            return CommandExecutionResult.from(manager.getQueueManager().shuffle());
         }
 
         return CommandExecutionResult.none();

src/main/java/me/bobert/netneutrality/command/music/SkipCommand.java

@@ -9,6 +9,8 @@ package me.bobert.netneutrality.command.music;
 import me.bobert.netneutrality.core.command.CommandExecutionResult;
 import me.bobert.netneutrality.core.command.CommandOptionsBuilder;
 import me.bobert.netneutrality.core.command.impl.MusicCommand;
+import me.bobert.netneutrality.db.service.GuildServiceProvider;
+import me.bobert.netneutrality.music.MusicService;
 import me.bobert.netneutrality.core.command.options.CommandOption;
 import me.bobert.netneutrality.core.context.CommandContext;
 import me.bobert.netneutrality.music.MusicManager;
@@ -19,6 +21,21 @@ import net.dv8tion.jda.api.interactions.commands.build.OptionData;
 
 public class SkipCommand extends MusicCommand {
 
+    private final MusicService musicService;
+
+    public SkipCommand() {
+        this(null, null);
+    }
+
+    public SkipCommand(MusicService musicService) {
+        this(musicService, null);
+    }
+
+    public SkipCommand(MusicService musicService, GuildServiceProvider guildServices) {
+        super(guildServices);
+        this.musicService = musicService;
+    }
+
     @Override
     public boolean isEnabled() {
         return true;
@@ -42,15 +59,15 @@ public class SkipCommand extends MusicCommand {
 
     @Override
     public CommandExecutionResult execute(CommandContext context) {
-        MusicManager manager = MusicManager.get(context.getGuild());
+        MusicManager manager = musicService.get(context.getGuild());
         context.ack();
 
-        if (MusicUtils.checkIfConnected(context)) {
+        if (MusicUtils.checkIfConnected(context, manager)) {
             int skips = context.getOption("skip", 1, CommandOption::getAsInt);
-            if (UserFunction.isAdmin(context) || MusicUtils.isUserDj(context)) {
+            if (UserFunction.isAdmin(context) || MusicUtils.isUserDj(context, manager)) {
-                return manager.getQueueManager().skip(skips);
+                return CommandExecutionResult.from(manager.getQueueManager().skip(skips));
             } else {
-                return manager.voteSkip(context);
+                return CommandExecutionResult.from(manager.voteSkip(context.getGuildUser()));
             }
         }
 

src/main/java/me/bobert/netneutrality/command/music/StopCommand.java

@@ -9,6 +9,8 @@ package me.bobert.netneutrality.command.music;
 import me.bobert.netneutrality.core.command.CommandExecutionResult;
 import me.bobert.netneutrality.core.command.CommandOptionsBuilder;
 import me.bobert.netneutrality.core.command.impl.MusicCommand;
+import me.bobert.netneutrality.db.service.GuildServiceProvider;
+import me.bobert.netneutrality.music.MusicService;
 import me.bobert.netneutrality.core.context.CommandContext;
 import me.bobert.netneutrality.music.MusicManager;
 import me.bobert.netneutrality.utils.MusicUtils;
@@ -16,6 +18,21 @@ import me.bobert.netneutrality.utils.UserFunction;
 
 public class StopCommand extends MusicCommand {
 
+    private final MusicService musicService;
+
+    public StopCommand() {
+        this(null, null);
+    }
+
+    public StopCommand(MusicService musicService) {
+        this(musicService, null);
+    }
+
+    public StopCommand(MusicService musicService, GuildServiceProvider guildServices) {
+        super(guildServices);
+        this.musicService = musicService;
+    }
+
     @Override
     public boolean isEnabled() {
         return true;
@@ -38,10 +55,10 @@ public class StopCommand extends MusicCommand {
 
     @Override
     public CommandExecutionResult execute(CommandContext context) {
-        MusicManager manager = MusicManager.get(context.getGuild());
+        MusicManager manager = musicService.get(context.getGuild());
         context.ack();
 
-        if (MusicUtils.checkIfConnected(context)) {
+        if (MusicUtils.checkIfConnected(context, manager)) {
             if (UserFunction.isAdmin(context)) {
                 manager.stopTrack();
                 context.reply("Stopping current track");

src/main/java/me/bobert/netneutrality/command/music/ViewQueueCommand.java

@@ -8,6 +8,8 @@ package me.bobert.netneutrality.command.music;
 import me.bobert.netneutrality.core.command.CommandExecutionResult;
 import me.bobert.netneutrality.core.command.CommandOptionsBuilder;
 import me.bobert.netneutrality.core.command.impl.MusicCommand;
+import me.bobert.netneutrality.db.service.GuildServiceProvider;
+import me.bobert.netneutrality.music.MusicService;
 import me.bobert.netneutrality.core.context.CommandContext;
 import me.bobert.netneutrality.music.MusicManager;
 import me.bobert.netneutrality.utils.MessageFunction;
@@ -15,6 +17,21 @@ import me.bobert.netneutrality.utils.MusicUtils;
 
 public class ViewQueueCommand extends MusicCommand {
 
+    private final MusicService musicService;
+
+    public ViewQueueCommand() {
+        this(null, null);
+    }
+
+    public ViewQueueCommand(MusicService musicService) {
+        this(musicService, null);
+    }
+
+    public ViewQueueCommand(MusicService musicService, GuildServiceProvider guildServices) {
+        super(guildServices);
+        this.musicService = musicService;
+    }
+
     @Override
     public boolean isEnabled() {
         return true;
@@ -37,10 +54,10 @@ public class ViewQueueCommand extends MusicCommand {
 
     @Override
     public CommandExecutionResult execute(CommandContext context) {
-        MusicManager manager = MusicManager.get(context.getGuild());
+        MusicManager manager = musicService.get(context.getGuild());
         context.ack();
 
-        if (MusicUtils.checkIfConnected(context)) {
+        if (MusicUtils.checkIfConnected(context, manager)) {
             int queueSize = manager.getQueueSize();
             if (queueSize == 0) {
                 return CommandExecutionResult.warn("Queue is empty!");

src/main/java/me/bobert/netneutrality/command/music/VolumeCommand.java

@@ -9,6 +9,8 @@ package me.bobert.netneutrality.command.music;
 import me.bobert.netneutrality.core.command.CommandExecutionResult;
 import me.bobert.netneutrality.core.command.CommandOptionsBuilder;
 import me.bobert.netneutrality.core.command.impl.MusicCommand;
+import me.bobert.netneutrality.db.service.GuildServiceProvider;
+import me.bobert.netneutrality.music.MusicService;
 import me.bobert.netneutrality.core.command.options.CommandOption;
 import me.bobert.netneutrality.core.context.CommandContext;
 import me.bobert.netneutrality.music.MusicManager;
@@ -19,6 +21,21 @@ import net.dv8tion.jda.api.interactions.commands.build.OptionData;
 
 public class VolumeCommand extends MusicCommand {
 
+    private final MusicService musicService;
+
+    public VolumeCommand() {
+        this(null, null);
+    }
+
+    public VolumeCommand(MusicService musicService) {
+        this(musicService, null);
+    }
+
+    public VolumeCommand(MusicService musicService, GuildServiceProvider guildServices) {
+        super(guildServices);
+        this.musicService = musicService;
+    }
+
     @Override
     public boolean isEnabled() {
         return true;
@@ -42,11 +59,11 @@ public class VolumeCommand extends MusicCommand {
 
     @Override
     public CommandExecutionResult execute(CommandContext context) {
-        MusicManager manager = MusicManager.get(context.getGuild());
+        MusicManager manager = musicService.get(context.getGuild());
         int volume = context.getOption("volume", 30, CommandOption::getAsInt);
 
-        if (MusicUtils.checkIfConnected(context)) {
+        if (MusicUtils.checkIfConnected(context, manager)) {
-            if (UserFunction.isAdmin(context) || MusicUtils.isUserDj(context)) {
+            if (UserFunction.isAdmin(context) || MusicUtils.isUserDj(context, manager)) {
                 manager.setVolume(volume);
                 return CommandExecutionResult.success(String.format("Volume set to %s", volume));
             }

src/main/java/me/bobert/netneutrality/command/music/VoteSkipCommand.java

@@ -8,12 +8,29 @@ package me.bobert.netneutrality.command.music;
 import me.bobert.netneutrality.core.command.CommandExecutionResult;
 import me.bobert.netneutrality.core.command.CommandOptionsBuilder;
 import me.bobert.netneutrality.core.command.impl.MusicCommand;
+import me.bobert.netneutrality.db.service.GuildServiceProvider;
+import me.bobert.netneutrality.music.MusicService;
 import me.bobert.netneutrality.core.context.CommandContext;
 import me.bobert.netneutrality.music.MusicManager;
 import me.bobert.netneutrality.utils.MusicUtils;
 
 public class VoteSkipCommand extends MusicCommand {
 
+    private final MusicService musicService;
+
+    public VoteSkipCommand() {
+        this(null, null);
+    }
+
+    public VoteSkipCommand(MusicService musicService) {
+        this(musicService, null);
+    }
+
+    public VoteSkipCommand(MusicService musicService, GuildServiceProvider guildServices) {
+        super(guildServices);
+        this.musicService = musicService;
+    }
+
     @Override
     public boolean isEnabled() {
         return true;
@@ -36,10 +53,10 @@ public class VoteSkipCommand extends MusicCommand {
 
     @Override
     public CommandExecutionResult execute(CommandContext context) {
-        MusicManager manager = MusicManager.get(context.getGuild());
+        MusicManager manager = musicService.get(context.getGuild());
 
-        if (MusicUtils.checkIfConnected(context)) {
+        if (MusicUtils.checkIfConnected(context, manager)) {
-            return manager.voteSkip(context);
+            return CommandExecutionResult.from(manager.voteSkip(context.getGuildUser()));
         }
 
         return CommandExecutionResult.none();

src/main/java/me/bobert/netneutrality/command/react/CreateEmojiReaction.java

@@ -9,22 +9,32 @@ package me.bobert.netneutrality.command.react;
 import me.bobert.netneutrality.core.command.CommandExecutionResult;
 import me.bobert.netneutrality.core.command.impl.MessageMenuCommand;
 import me.bobert.netneutrality.core.context.CommandContext;
-import me.bobert.netneutrality.core.tasks.TaskManager;
+import me.bobert.netneutrality.tasks.reaction.EmojiReactionRoleTask;
-import me.bobert.netneutrality.tasks.emoji.EmojiReactionRoleTask;
 import me.bobert.netneutrality.tasks.reaction.EmojiRoleFirstStep;
 import net.dv8tion.jda.api.entities.Message;
+import me.bobert.netneutrality.core.tasks.TaskManager;
+
+import java.util.Objects;
 
 public class CreateEmojiReaction extends MessageMenuCommand {
+
+    private final TaskManager taskManager;
+
+    public CreateEmojiReaction(TaskManager taskManager) {
+        Objects.requireNonNull(taskManager, "TaskManager must not be null");
+        this.taskManager = taskManager;
+    }
+
     @Override
     public CommandExecutionResult execute(Message target, CommandContext context) {
-        EmojiReactionRoleTask task = TaskManager.getInstance().findTaskByPartialId(EmojiReactionRoleTask.class, target.getId()).orElse(null);
+        EmojiReactionRoleTask task = taskManager.findTaskByPartialId(EmojiReactionRoleTask.class, target.getId()).orElse(null);
 
         if (task != null) {
             context.replyEphemeral("This message is already registered with the bot, please use the modify command instead");
             return CommandExecutionResult.none();
         }
 
-        return CommandExecutionResult.task(new EmojiRoleFirstStep(target));
+        return CommandExecutionResult.task(new EmojiRoleFirstStep(taskManager, target));
     }
 
     @Override

src/main/java/me/bobert/netneutrality/command/react/ModifyEmojiReaction.java

@@ -9,22 +9,32 @@ package me.bobert.netneutrality.command.react;
 import me.bobert.netneutrality.core.command.CommandExecutionResult;
 import me.bobert.netneutrality.core.command.impl.MessageMenuCommand;
 import me.bobert.netneutrality.core.context.CommandContext;
-import me.bobert.netneutrality.core.tasks.TaskManager;
+import me.bobert.netneutrality.tasks.reaction.EmojiReactionRoleTask;
-import me.bobert.netneutrality.tasks.emoji.EmojiReactionRoleTask;
 import me.bobert.netneutrality.tasks.reaction.EmojiRoleModify;
 import net.dv8tion.jda.api.entities.Message;
+import me.bobert.netneutrality.core.tasks.TaskManager;
+
+import java.util.Objects;
 
 public class ModifyEmojiReaction extends MessageMenuCommand {
 
+    private final TaskManager taskManager;
+
+    public ModifyEmojiReaction(TaskManager taskManager) {
+        Objects.requireNonNull(taskManager, "TaskManager must not be null");
+        this.taskManager = taskManager;
+    }
+
+
     @Override
     public CommandExecutionResult execute(Message target, CommandContext context) {
-        EmojiReactionRoleTask task = TaskManager.getInstance().findTaskByPartialId(EmojiReactionRoleTask.class, target.getId()).orElse(null);
+        EmojiReactionRoleTask task = taskManager.findTaskByPartialId(EmojiReactionRoleTask.class, target.getId()).orElse(null);
         if (task == null) {
             context.replyEphemeral("This message is not registered with the bot, please use the create command instead");
             return CommandExecutionResult.none();
         }
 
-        return CommandExecutionResult.task(new EmojiRoleModify(target, task));
+        return CommandExecutionResult.task(new EmojiRoleModify(taskManager, target, task));
     }
 
     @Override

src/main/java/me/bobert/netneutrality/context/MusicChannelContext.java

@@ -6,6 +6,7 @@ package me.bobert.netneutrality.context;
  */
 
 import me.bobert.netneutrality.core.context.AbstractContext;
+import me.bobert.netneutrality.core.context.AsyncContext;
 import me.bobert.netneutrality.core.context.NoMessageContext;
 import net.dv8tion.jda.api.components.MessageTopLevelComponent;
 import net.dv8tion.jda.api.entities.Member;

src/main/java/me/bobert/netneutrality/context/command/MessageCommandContext.java

@@ -9,7 +9,8 @@ import me.bobert.netneutrality.core.command.options.CommandOption;
 import me.bobert.netneutrality.core.command.options.MessageCommandOption;
 import me.bobert.netneutrality.core.context.CommandContext;
 import me.bobert.netneutrality.core.context.MessageContext;
-import me.bobert.netneutrality.utils.Settings;
+import me.bobert.netneutrality.utils.SettingsProvider;
+import net.dv8tion.jda.api.entities.Guild;
 import net.dv8tion.jda.api.entities.Member;
 import net.dv8tion.jda.api.entities.Mentions;
 import net.dv8tion.jda.api.entities.Message;
@@ -22,16 +23,28 @@ import net.dv8tion.jda.api.interactions.commands.OptionType;
 import net.dv8tion.jda.api.interactions.commands.build.OptionData;
 
 import java.util.ArrayList;
+import java.util.EnumSet;
 import java.util.List;
 import java.util.Set;
 import java.util.StringJoiner;
+import java.util.regex.Pattern;
 
 public class MessageCommandContext extends CommandContext implements MessageContext {
+    private static final Pattern INTEGER_PATTERN = Pattern.compile("[-+]?\\d+");
+    private static final Pattern NUMBER_PATTERN = Pattern.compile("[-+]?\\d+(\\.\\d+)?");
+    private static final Pattern MENTION_PATTERN = Pattern.compile("<(@[!&]?|#)\\d+>");
+    private static final Set<OptionType> MENTION_TYPES =
+        EnumSet.of(OptionType.USER, OptionType.ROLE, OptionType.MENTIONABLE, OptionType.CHANNEL);
+    private static final OptionData LEFTOVER_ARGUMENTS = new OptionData(OptionType.STRING, "arguments", "arguments");
+
     private final MessageReceivedEvent event;
     private final Message message;
 
-    public MessageCommandContext(MessageReceivedEvent event) {
+    private final SettingsProvider settings;
-        super(event.getJDA(), event.isFromGuild() ? event.getGuild() : null, event.getChannel(), event.getMember(), event.getAuthor());
+
+    public MessageCommandContext(MessageReceivedEvent event, SettingsProvider settings) {
+        super(event.getJDA(), event.isFromGuild() ? event.getGuild() : null, event.getChannel(), event.getMember(), event.getAuthor(), settings);
+        this.settings = settings;
         this.event = event;
         this.message = event.getMessage();
     }
@@ -58,7 +71,6 @@ public class MessageCommandContext extends CommandContext implements MessageCont
     @Override
     public List<CommandOption> parseOptions(String[] args, List<OptionData> commandOptions) {
         List<CommandOption> options = new ArrayList<>();
-        int required = commandOptions.stream().filter(OptionData::isRequired).toList().size();
         Mentions mentions = message.getMentions();
         int roleMentionIndex = 0;
         int userMentionIndex = 0;
@@ -66,239 +78,251 @@ public class MessageCommandContext extends CommandContext implements MessageCont
         int channelMentionIndex = 0;
         int index = 0;
 
-        for (OptionData data : commandOptions) {
+        for (int i = 0; i < commandOptions.size(); i++) {
+            OptionData data = commandOptions.get(i);
             OptionType type = data.getType();
             Set<ChannelType> requiredChannelTypes = data.getChannelTypes();
             List<Command.Choice> choices = data.getChoices();
+            int position = index + 1;
             Object value = null;
 
-            try {
+            if (index >= args.length) {
-                switch (type) {
+                if (data.isRequired()) {
-                    case STRING -> {
+                    invalidateContext(data, "missing required argument at index " + position);
-                        int currentOptionIndex = commandOptions.indexOf(data);
+                }
-                        boolean nextOptionIsString = false;
+
-                        if (currentOptionIndex + 1 < commandOptions.size()) {
+                continue;
-                            OptionData nextOption = commandOptions.get(currentOptionIndex + 1);
+            }
-                            nextOptionIsString = nextOption.getType() == OptionType.STRING;
+
+            switch (type) {
+                case STRING -> {
+                    String str;
+                    if (i + 1 < commandOptions.size() && commandOptions.get(i + 1).getType() == OptionType.STRING) {
+                        // The next option is also a string, so only the current argument belongs to this one
+                        str = args[index++];
+                    } else {
+                        StringJoiner joiner = new StringJoiner(" ");
+                        while (index < args.length && !stopsTextCapture(args[index], commandOptions, i)) {
+                            joiner.add(args[index++]);
                         }
 
-                        StringBuilder strBuilder = new StringBuilder();
+                        str = joiner.toString();
-                        if (!nextOptionIsString) {
-                            while (index < args.length) {
-                                String nextArg = args[index];
-
-                                if ((nextArg.contains("<@") || nextArg.contains("<#") || nextArg.contains("<@&")) && nextArg.contains(">")) {
-                                    break;
-                                }
-
-                                if (nextArg.equalsIgnoreCase("true") || nextArg.equalsIgnoreCase("false")) {
-                                    break;
-                                }
-
-                                try {
-                                    Long.parseLong(nextArg);
-                                    break;
-                                } catch (NumberFormatException ignored) {}
-
-                                try {
-                                    Double.parseDouble(nextArg);
-                                    break;
-                                } catch (NumberFormatException ignored) {}
-
-                                if (!strBuilder.isEmpty()) {
-                                    strBuilder.append(" ");
-                                }
-
-                                strBuilder.append(nextArg);
-                                index++;
-                            }
-
-                            // Update index to skip the concatenated strings
-                            index = index - 1;
-                        } else {
-                            // Next option is also a string, so just take the current argument
-                            if (index < args.length) {
-                                strBuilder.append(args[index]);
-                            }
-                        }
-
-                        if (strBuilder.isEmpty()) {
-                            break;
-                        }
-
-                        String str = strBuilder.toString();
-
-                        if (!choices.isEmpty()) {
-                            List<Command.Choice> matched = choices.stream().filter(choice -> choice.getAsString().equalsIgnoreCase(str)).toList();
-                            if (matched.isEmpty()) {
-                                invalidateContext(data, "not a valid choice, valid choices are: " + validChoices(choices));
-                            }
-                        }
-
-                        Integer min = data.getMinLength();
-                        Integer max = data.getMaxLength();
-
-                        if (min != null && str.length() < min) {
-                            invalidateContext(data, "minimum length for argument is " + min);
-                        }
-
-                        if (max != null && str.length() > max) {
-                            invalidateContext(data, "maximum length for argument is " + max);
-                        }
-
-                        value = str;
                     }
-                    case INTEGER -> {
-                        long num = Long.parseLong(args[index]);
-                        if (!choices.isEmpty()) {
-                            List<Command.Choice> matched = choices.stream().filter(choice -> choice.getAsLong() == num).toList();
-                            if (matched.isEmpty()) {
-                                invalidateContext(data, "not a valid choice, valid choices are: " + validChoices(choices));
-                            }
-                        }
-                        value = num;
 
-                        Number max = data.getMaxValue();
+                    if (str.isEmpty()) {
-                        Number min = data.getMinValue();
+                        if (data.isRequired()) {
-
+                            invalidateContext(data, "missing required argument at index " + position);
-                        if (min != null && num < min.longValue()) {
-                            value = min.longValue();
-                        } else if (max != null && num > max.longValue()) {
-                            value = max.longValue();
                         }
+
+                        break;
                     }
-                    case BOOLEAN -> {
-                        String str = args[index];
-                        if (str.equalsIgnoreCase("true") || str.equalsIgnoreCase("false")) {
-                            value = Boolean.parseBoolean(str);
-                            break;
-                        }
 
+                    if (!choices.isEmpty() && choices.stream().noneMatch(choice -> choice.getAsString().equalsIgnoreCase(str))) {
+                        invalidateContext(data, "not a valid choice, valid choices are: " + validChoices(choices));
+                        break;
+                    }
+
+                    Integer min = data.getMinLength();
+                    Integer max = data.getMaxLength();
+
+                    if (min != null && str.length() < min) {
+                        invalidateContext(data, "minimum length for argument is " + min);
+                        break;
+                    }
+
+                    if (max != null && str.length() > max) {
+                        invalidateContext(data, "maximum length for argument is " + max);
+                        break;
+                    }
+
+                    value = str;
+                }
+                case INTEGER -> {
+                    String str = args[index++];
+                    if (!INTEGER_PATTERN.matcher(str).matches()) {
+                        invalidateContext(data, "the argument provided is not a number.");
+                        break;
+                    }
+
+                    long num = Long.parseLong(str);
+                    if (!choices.isEmpty() && choices.stream().noneMatch(choice -> choice.getAsLong() == num)) {
+                        invalidateContext(data, "not a valid choice, valid choices are: " + validChoices(choices));
+                        break;
+                    }
+
+                    Number min = data.getMinValue();
+                    Number max = data.getMaxValue();
+
+                    if (min != null && num < min.longValue()) {
+                        invalidateContext(data, "minimum value for argument is " + min.longValue());
+                        break;
+                    }
+
+                    if (max != null && num > max.longValue()) {
+                        invalidateContext(data, "maximum value for argument is " + max.longValue());
+                        break;
+                    }
+
+                    value = num;
+                }
+                case BOOLEAN -> {
+                    String str = args[index++];
+                    if (!str.equalsIgnoreCase("true") && !str.equalsIgnoreCase("false")) {
                         invalidateContext(data, "expected true or false");
+                        break;
                     }
-                    case NUMBER -> {
-                        double num = Double.parseDouble(args[index]);
-                        if (!choices.isEmpty()) {
-                            List<Command.Choice> matched = choices.stream().filter(choice -> choice.getAsDouble() == num).toList();
-                            if (matched.isEmpty()) {
-                                invalidateContext(data, "not a valid choice, valid choices are: " + validChoices(choices));
-                                break;
-                            }
-                        }
 
-                        Number max = data.getMaxValue();
+                    value = Boolean.parseBoolean(str);
-                        Number min = data.getMinValue();
+                }
-                        value = num;
+                case NUMBER -> {
-
+                    String str = args[index++];
-                        if (min != null && num < min.doubleValue()) {
+                    if (!NUMBER_PATTERN.matcher(str).matches()) {
-                            value = min.doubleValue();
+                        invalidateContext(data, "the argument provided is not a number.");
-                        } else if (max != null && num > max.doubleValue()) {
+                        break;
-                            value = max.doubleValue();
-                        }
                     }
-                    case ROLE -> {
-                        if (mentions.getRoles().size() > roleMentionIndex) {
-                            Role role = mentions.getRoles().get(roleMentionIndex++);
-                            if (role.getGuild().getId().equals(getGuild().getId())) {
-                                value = role;
-                            }
 
-                            break;
+                    double num = Double.parseDouble(str);
-                        }
+                    if (!choices.isEmpty() && choices.stream().noneMatch(choice -> choice.getAsDouble() == num)) {
-
+                        invalidateContext(data, "not a valid choice, valid choices are: " + validChoices(choices));
-                        invalidateContext(data, "provided argument at position " + (index + 1) + " is not a valid role.");
+                        break;
                     }
-                    case USER -> {
-                        if (mentions.getMembers().size() > memberMentionIndex) {
-                            Member member = mentions.getMembers().get(memberMentionIndex++);
-                            if (member.getGuild().getId().equals(getGuild().getId())) {
-                                value = member;
-                                break;
-                            }
-                        }
 
-                        if (mentions.getUsers().size() > userMentionIndex) {
+                    Number min = data.getMinValue();
-                            value = mentions.getUsers().get(userMentionIndex++);
+                    Number max = data.getMaxValue();
-                            break;
-                        }
 
-                        invalidateContext(data, "provided argument at position " + (index + 1) + " is not a valid user.");
+                    if (min != null && num < min.doubleValue()) {
+                        invalidateContext(data, "minimum value for argument is " + min.doubleValue());
+                        break;
                     }
-                    case MENTIONABLE -> {
-                        if (mentions.getRoles().size() > roleMentionIndex) {
-                            Role role = mentions.getRoles().get(roleMentionIndex++);
-                            if (role.getGuild().getId().equals(getGuild().getId())) {
-                                value = role;
-                            }
 
-                            break;
+                    if (max != null && num > max.doubleValue()) {
-                        }
+                        invalidateContext(data, "maximum value for argument is " + max.doubleValue());
-
+                        break;
-                        if (mentions.getMembers().size() > memberMentionIndex) {
-                            Member member = mentions.getMembers().get(memberMentionIndex++);
-                            if (member.getGuild().getId().equals(getGuild().getId())) {
-                                value = member;
-                            }
-
-                            break;
-                        }
-
-                        if (mentions.getUsers().size() > userMentionIndex) {
-                            value = mentions.getUsers().get(userMentionIndex++);
-                            break;
-                        }
-
-                        invalidateContext(data, "provided argument at position " + (index + 1) + " is not a valid user or role.");
                     }
-                    case CHANNEL -> {
-                        if (mentions.getChannels().size() > channelMentionIndex) {
-                            GuildChannel channel = mentions.getChannels().get(channelMentionIndex++);
 
-                            if (!requiredChannelTypes.isEmpty() && !requiredChannelTypes.contains(channel.getType())) {
+                    value = num;
-                                invalidateContext(data, "not a valid channel type at index " + (index + 1) +
+                }
-                                    " , valid types are: " + validTypes(requiredChannelTypes));
+                case ROLE -> {
-                                break;
+                    index++;
-                            }
+                    Role role = mentions.getRoles().size() > roleMentionIndex ? mentions.getRoles().get(roleMentionIndex++) : null;
+                    if (role == null || !isFromCurrentGuild(role.getGuild())) {
+                        invalidateContext(data, "provided argument at position " + position + " is not a valid role.");
+                        break;
+                    }
 
-                            if (channel.getGuild().getId().equals(getGuild().getId())) {
+                    value = role;
-                                value = channel;
+                }
-                                break;
+                case USER -> {
-                            }
+                    index++;
-                        }
+                    value = resolveUser(mentions, memberMentionIndex, userMentionIndex);
+                    if (value instanceof Member) {
+                        memberMentionIndex++;
+                    } else if (value != null) {
+                        userMentionIndex++;
+                    }
 
-                        invalidateContext(data, "provided argument at position " + (index + 1) + " is not a valid channel.");
+                    if (value == null) {
+                        invalidateContext(data, "provided argument at position " + position + " is not a valid user.");
                     }
                 }
-            } catch (IndexOutOfBoundsException e) {
+                case MENTIONABLE -> {
-                if (options.size() < required) {
+                    index++;
-                    invalidateContext(data, "missing required argument at index " + (index + 1));
+                    if (mentions.getRoles().size() > roleMentionIndex) {
-                }
+                        Role role = mentions.getRoles().get(roleMentionIndex++);
+                        if (!isFromCurrentGuild(role.getGuild())) {
+                            invalidateContext(data, "provided argument at position " + position + " is not a valid role.");
+                            break;
+                        }
 
-                if (data.isRequired() && index < required) {
+                        value = role;
-                    // This should never happen because required options are validated before calling parseOptions()
+                        break;
-                    throw new IllegalArgumentException("Required option " + data.getName() + " was not found at index " + index);
+                    }
+
+                    value = resolveUser(mentions, memberMentionIndex, userMentionIndex);
+                    if (value instanceof Member) {
+                        memberMentionIndex++;
+                    } else if (value != null) {
+                        userMentionIndex++;
+                    }
+
+                    if (value == null) {
+                        invalidateContext(data, "provided argument at position " + position + " is not a valid user or role.");
+                    }
                 }
-            } catch (NumberFormatException ignored) {
+                case CHANNEL -> {
-                invalidateContext(data, "the argument provided is not a number.");
+                    index++;
+                    GuildChannel channel = mentions.getChannels().size() > channelMentionIndex ? mentions.getChannels().get(channelMentionIndex++) : null;
+                    if (channel == null || !isFromCurrentGuild(channel.getGuild())) {
+                        invalidateContext(data, "provided argument at position " + position + " is not a valid channel.");
+                        break;
+                    }
+
+                    if (!requiredChannelTypes.isEmpty() && !requiredChannelTypes.contains(channel.getType())) {
+                        invalidateContext(data, "not a valid channel type at index " + position +
+                            " , valid types are: " + validTypes(requiredChannelTypes));
+                        break;
+                    }
+
+                    value = channel;
+                }
+                default -> index++;
             }
 
             if (value != null) {
                 options.add(new MessageCommandOption(data, value));
             }
-
-            index++;
         }
 
         // Check if there are leftover arguments that weren't consumed
         if (index < args.length) {
-            if (options.size() >= required) {
+            OptionData lastOption = commandOptions.isEmpty() ? LEFTOVER_ARGUMENTS : commandOptions.getLast();
-                invalidateContext(commandOptions.getLast(), "too many arguments");
+            invalidateContext(lastOption, "too many arguments");
-            }
         }
 
         return options;
     }
 
+    /**
+     * A string option greedily consumes the remaining arguments, it has to stop as soon as an argument
+     * belongs to one of the following options.
+     */
+    private boolean stopsTextCapture(String arg, List<OptionData> commandOptions, int currentOptionIndex) {
+        if (NUMBER_PATTERN.matcher(arg).matches()) {
+            return true;
+        }
+
+        List<OptionData> remaining = commandOptions.subList(currentOptionIndex + 1, commandOptions.size());
+
+        if (arg.equalsIgnoreCase("true") || arg.equalsIgnoreCase("false")) {
+            return remaining.stream().anyMatch(option -> option.getType() == OptionType.BOOLEAN);
+        }
+
+        if (MENTION_PATTERN.matcher(arg).matches()) {
+            return remaining.stream().anyMatch(option -> MENTION_TYPES.contains(option.getType()));
+        }
+
+        return false;
+    }
+
+    private Object resolveUser(Mentions mentions, int memberMentionIndex, int userMentionIndex) {
+        if (mentions.getMembers().size() > memberMentionIndex) {
+            Member member = mentions.getMembers().get(memberMentionIndex);
+            if (isFromCurrentGuild(member.getGuild())) {
+                return member;
+            }
+        }
+
+        if (mentions.getUsers().size() > userMentionIndex) {
+            return mentions.getUsers().get(userMentionIndex);
+        }
+
+        return null;
+    }
+
+    private boolean isFromCurrentGuild(Guild guild) {
+        return getGuild() != null && guild != null && guild.getId().equals(getGuild().getId());
+    }
+
     private String validChoices(List<Command.Choice> choices) {
         StringJoiner joiner = new StringJoiner(", ");
         for (Command.Choice choice : choices) {
@@ -320,7 +344,7 @@ public class MessageCommandContext extends CommandContext implements MessageCont
     @Override
     public String parseCommandName() {
         String rawMessage = message.getContentRaw().trim();
-        String prefix = Settings.getInstance().getPrefix();
+        String prefix = settings.getPrefix();
 
         if (rawMessage.startsWith(prefix)) {
             return getFullCommand().split(" ", 2)[0];
@@ -332,7 +356,7 @@ public class MessageCommandContext extends CommandContext implements MessageCont
     @Override
     public String getFullCommand() {
         String rawMessage = message.getContentRaw().trim();
-        String prefix = Settings.getInstance().getPrefix();
+        String prefix = settings.getPrefix();
 
         return rawMessage.replaceFirst("^[" + prefix + "\\s]+", "").trim();
     }

src/main/java/me/bobert/netneutrality/context/command/MessageMenuContext.java

@@ -9,6 +9,7 @@ package me.bobert.netneutrality.context.command;
 import me.bobert.netneutrality.core.command.options.CommandOption;
 import me.bobert.netneutrality.core.context.CommandContext;
 import me.bobert.netneutrality.core.context.InteractionContext;
+import me.bobert.netneutrality.utils.SettingsProvider;
 import net.dv8tion.jda.api.entities.Message;
 import net.dv8tion.jda.api.entities.channel.ChannelType;
 import net.dv8tion.jda.api.events.Event;
@@ -20,8 +21,13 @@ import java.util.List;
 public class MessageMenuContext extends CommandContext implements InteractionContext {
     private final MessageContextInteractionEvent event;
 
-    public MessageMenuContext(MessageContextInteractionEvent event) {
+    @Override
-        super(event.getJDA(), event.getGuild(), event.getChannel(), event.getMember(), event.getUser());
+    public boolean isInteraction() {
+        return true;
+    }
+
+    public MessageMenuContext(MessageContextInteractionEvent event, SettingsProvider settings) {
+        super(event.getJDA(), event.getGuild(), event.getChannel(), event.getMember(), event.getUser(), settings);
         this.event = event;
     }
 

src/main/java/me/bobert/netneutrality/context/command/SlashCommandContext.java

@@ -9,6 +9,7 @@ import me.bobert.netneutrality.core.command.options.CommandOption;
 import me.bobert.netneutrality.core.command.options.SlashCommandOption;
 import me.bobert.netneutrality.core.context.CommandContext;
 import me.bobert.netneutrality.core.context.InteractionContext;
+import me.bobert.netneutrality.utils.SettingsProvider;
 import net.dv8tion.jda.api.entities.channel.ChannelType;
 import net.dv8tion.jda.api.events.interaction.command.SlashCommandInteractionEvent;
 import net.dv8tion.jda.api.interactions.commands.build.OptionData;
@@ -19,11 +20,16 @@ import java.util.stream.Collectors;
 public class SlashCommandContext extends CommandContext implements InteractionContext {
     private final SlashCommandInteractionEvent event;
 
-    public SlashCommandContext(SlashCommandInteractionEvent event) {
+    public SlashCommandContext(SlashCommandInteractionEvent event, SettingsProvider settings) {
-        super(event.getJDA(), event.getGuild(), event.getChannel(), event.getMember(), event.getUser());
+        super(event.getJDA(), event.getGuild(), event.getChannel(), event.getMember(), event.getUser(), settings);
         this.event = event;
     }
 
+    @Override
+    public boolean isInteraction() {
+        return true;
+    }
+
     @Override
     public SlashCommandInteractionEvent getEvent() {
         return event;

src/main/java/me/bobert/netneutrality/context/command/UserMenuContext.java

@@ -9,6 +9,7 @@ package me.bobert.netneutrality.context.command;
 import me.bobert.netneutrality.core.command.options.CommandOption;
 import me.bobert.netneutrality.core.context.CommandContext;
 import me.bobert.netneutrality.core.context.InteractionContext;
+import me.bobert.netneutrality.utils.SettingsProvider;
 import net.dv8tion.jda.api.entities.User;
 import net.dv8tion.jda.api.entities.channel.ChannelType;
 import net.dv8tion.jda.api.entities.channel.middleman.MessageChannel;
@@ -21,8 +22,13 @@ import java.util.List;
 public class UserMenuContext extends CommandContext implements InteractionContext {
     private final UserContextInteractionEvent event;
 
-    public UserMenuContext(UserContextInteractionEvent event) {
+    @Override
-        super(event.getJDA(), event.getGuild(), (MessageChannel) event.getChannel(), event.getMember(), event.getUser());
+    public boolean isInteraction() {
+        return true;
+    }
+
+    public UserMenuContext(UserContextInteractionEvent event, SettingsProvider settings) {
+        super(event.getJDA(), event.getGuild(), (MessageChannel) event.getChannel(), event.getMember(), event.getUser(), settings);
         this.event = event;
     }
 

src/main/java/me/bobert/netneutrality/context/tasks/EmojiTaskContext.java

@@ -5,7 +5,7 @@ package me.bobert.netneutrality.context.tasks;
  * https://discord.gg/qUa6zNFZsd
  */
 
-import me.bobert.netneutrality.context.AsyncContext;
+import me.bobert.netneutrality.core.context.AsyncContext;
 import me.bobert.netneutrality.core.context.NoMessageContext;
 import me.bobert.netneutrality.core.context.TaskContext;
 import net.dv8tion.jda.api.components.MessageTopLevelComponent;

src/main/java/me/bobert/netneutrality/core/BotState.java

@@ -1,74 +0,0 @@
-package me.bobert.netneutrality.core;
-/*
- * Copyright (c) anthorob
- *
- * https://discord.gg/qUa6zNFZsd
- */
-
-import me.bobert.netneutrality.db.service.GuildService;
-import me.bobert.netneutrality.music.MusicManager;
-import me.bobert.netneutrality.music.TrackScheduler;
-import org.json.JSONArray;
-import org.json.JSONObject;
-
-import java.io.File;
-import java.io.FileWriter;
-import java.io.IOException;
-import java.util.Map;
-
-public class BotState {
-    public static boolean SAFE = false;
-
-    //TODO: is it needed?
-    private static void saveGuildsState() {
-        Map<String, GuildService> services = GuildService.getServices();
-
-        JSONObject main = new JSONObject();
-        JSONArray guildsArray = new JSONArray();
-
-        for (MusicManager manager : MusicManager.getManagers()) {
-            TrackScheduler trackScheduler = manager.getScheduler();
-        }
-
-        for (GuildService service : services.values()) {
-
-
-            JSONObject guild = new JSONObject();
-            JSONObject music = new JSONObject();
-            guild.put("id", service.getEntity().getGuildId());
-
-//            MessageChannel currentChannel = trackScheduler.getTextChannel();
-//            if (currentChannel == null) {
-//                music.put("current_channel", "null");
-//            } else {
-//                music.put("current_channel", currentChannel.getId());
-//            }
-
-            guild.put("music", music);
-
-            guildsArray.put(guild);
-        }
-
-        main.put("guilds", guildsArray);
-
-        File state = new File("state.json");
-        try {
-            if (!state.exists()) {
-                state.createNewFile();
-            }
-
-            try (FileWriter writer = new FileWriter(state)) {
-                writer.write(main.toString());
-            }
-
-        } catch (IOException e) {
-            e.printStackTrace();
-        }
-    }
-
-    public static void dump() {
-        if (!SAFE) {
-            saveGuildsState();
-        }
-    }
-}

src/main/java/me/bobert/netneutrality/core/LogHandler.java

@@ -5,11 +5,12 @@ package me.bobert.netneutrality.core;
  * https://discord.gg/qUa6zNFZsd
  */
 
-import io.sentry.Sentry;
+import me.bobert.netneutrality.core.log.DiscordDebugChannelLogSink;
-import me.bobert.netneutrality.core.context.CommandContext;
+import me.bobert.netneutrality.core.log.Log4jLogSink;
-import me.bobert.netneutrality.core.context.Context;
+import me.bobert.netneutrality.core.log.LogSink;
-import me.bobert.netneutrality.core.context.TaskContext;
+import me.bobert.netneutrality.core.log.LoggedException;
-import me.bobert.netneutrality.db.service.GuildService;
+import me.bobert.netneutrality.core.log.SentryLogSink;
+import me.bobert.netneutrality.db.service.GuildServiceProvider;
 import me.bobert.netneutrality.exceptions.ContextException;
 import me.bobert.netneutrality.utils.MessageFunction;
 import net.dv8tion.jda.api.entities.Guild;
@@ -17,9 +18,52 @@ import net.dv8tion.jda.api.entities.channel.concrete.TextChannel;
 import org.apache.logging.log4j.LogManager;
 import org.apache.logging.log4j.Logger;
 
+import java.util.concurrent.CopyOnWriteArrayList;
+
 public class LogHandler {
 
     private static final Logger logger = LogManager.getLogger(LogHandler.class);
+    private static final CopyOnWriteArrayList<LogSink> sinks = new CopyOnWriteArrayList<>();
+    private static volatile DiscordDebugChannelLogSink discordSink;
+
+    static {
+        sinks.add(new Log4jLogSink());
+        sinks.add(new SentryLogSink());
+    }
+
+    /**
+     * Binds the guild-service provider used for debug-channel logging. Called once during bootstrap.
+     * Internally registers (or replaces) the Discord debug-channel {@link LogSink}.
+     *
+     * @param provider the live guild service provider
+     */
+    public static void bind(GuildServiceProvider provider) {
+        if (discordSink != null) {
+            sinks.remove(discordSink);
+        }
+
+        discordSink = new DiscordDebugChannelLogSink(provider);
+        sinks.add(discordSink);
+    }
+
+    /**
+     * Registers an additional log destination. Sinks are notified for every exception logged via
+     * {@link #log(Exception)}.
+     *
+     * @param sink the sink to register
+     */
+    public static void addSink(LogSink sink) {
+        sinks.add(sink);
+    }
+
+    /**
+     * Unregisters a previously registered log destination.
+     *
+     * @param sink the sink to remove
+     */
+    public static void removeSink(LogSink sink) {
+        sinks.remove(sink);
+    }
 
     /**
      * Log an exception accordingly
@@ -27,17 +71,15 @@ public class LogHandler {
      * @param e The exceptions to log
      */
     public static void log(Exception e) {
-        Sentry.captureException(e);
+        LoggedException event = LoggedException.of(e);
 
-        if (e instanceof ContextException exception) {
+        for (LogSink sink : sinks) {
-            logInternally(exception);
+            safelyHandle(sink, event);
-            tryLogToDebugChannel(exception);
-            tryGracefulContextError(exception);
-
-            return;
         }
 
-        logger.error(e.getMessage(), e);
+        if (e instanceof ContextException exception) {
+            tryGracefulContextError(exception);
+        }
     }
 
     public static void log(String s, Exception e) {
@@ -58,36 +100,11 @@ public class LogHandler {
 
     }
 
-    private static void logInternally(ContextException exception) {
+    private static void safelyHandle(LogSink sink, LoggedException event) {
-        Context context = exception.getContext();
+        try {
-        String guildId = context.getGuild() == null ? "PrivateMessage" : context.getGuild().getId();
+            sink.handle(event);
-
+        } catch (Throwable t) {
-        logger.error("Exception thrown from context (guild: {}, user: {}): {}", guildId,
+            logger.error("Log sink {} failed to handle exception", sink.getClass().getSimpleName(), t);
-            context.getDiscordUser().getId(),
-            exception.getMessage()
-        );
-
-        if (context instanceof CommandContext commandContext) {
-            logger.error("Caused by command: {}", commandContext.getCommand().getCommandName(), exception);
-        }
-
-        if (context instanceof TaskContext taskContext) {
-            logger.error("Caused by task with ID: {}", taskContext.getId(), exception);
-        }
-    }
-
-    private static void tryLogToDebugChannel(ContextException exception) {
-        Context context = exception.getContext();
-
-        if (context.getGuild() != null) {
-            if (GuildService.get(context.getGuild()).isDebugEnabled()) {
-                context.getGuild()
-                    .getTextChannels()
-                    .stream()
-                    .filter(textChannel -> textChannel.getName().equals("debug") || textChannel.getName().equals("log"))
-                    .filter(TextChannel::canTalk)
-                    .forEach(textChannel -> textChannel.sendMessageEmbeds(MessageFunction.buildDebugMessage(exception)).queue());
-            }
         }
     }
 

src/main/java/me/bobert/netneutrality/core/LogSeverity.java

@@ -0,0 +1,43 @@
+package me.bobert.netneutrality.core;
+/*
+ * Copyright (c) anthorob
+ *
+ * https://discord.gg/qUa6zNFZsd
+ */
+
+/**
+ * Severity ordering used to gate what gets sent to a guild's log channel, from least to most verbose:
+ * {@code ERROR} < {@code WARN} < {@code INFO}.
+ */
+public enum LogSeverity {
+    ERROR,
+    WARN,
+    INFO;
+
+    /**
+     * Parses a severity name, falling back to {@link #ERROR} (the most restrictive level) when the
+     * value is missing or unrecognized.
+     *
+     * @param value the raw severity name (case-insensitive)
+     * @return the matching severity, or {@link #ERROR} as a safe default
+     */
+    public static LogSeverity parse(String value) {
+        if (value == null || value.isEmpty()) {
+            return ERROR;
+        }
+
+        try {
+            return LogSeverity.valueOf(value.toUpperCase());
+        } catch (IllegalArgumentException e) {
+            return ERROR;
+        }
+    }
+
+    /**
+     * @param configured the guild's configured minimum severity
+     * @return {@code true} when this severity should be sent given the configured minimum
+     */
+    public boolean meetsThreshold(LogSeverity configured) {
+        return this.ordinal() <= configured.ordinal();
+    }
+}

src/main/java/me/bobert/netneutrality/core/command/CommandExecutionResult.java

@@ -6,6 +6,7 @@ package me.bobert.netneutrality.core.command;
  */
 
 import me.bobert.netneutrality.core.tasks.Task;
+import me.bobert.netneutrality.music.QueueActionResult;
 
 public class CommandExecutionResult {
 
@@ -80,4 +81,18 @@ public class CommandExecutionResult {
     public static CommandExecutionResult task(Task task) {
         return new CommandExecutionResult(Result.TASK, null, task, null);
     }
+
+    /**
+     * Adapts a {@link QueueActionResult} returned by {@link me.bobert.netneutrality.music.QueueManager}
+     * into a {@link CommandExecutionResult} so it can be surfaced as a Discord reply or HTTP response.
+     */
+    public static CommandExecutionResult from(QueueActionResult result) {
+        return switch (result.getStatus()) {
+            case SUCCESS -> success(result.getMessage());
+            case INFO -> info(result.getMessage());
+            case WARN -> warn(result.getMessage());
+            case ERROR -> error(result.getMessage());
+            case NOACTION -> none();
+        };
+    }
 }

src/main/java/me/bobert/netneutrality/core/command/CommandManager.java

@@ -5,7 +5,8 @@ package me.bobert.netneutrality.core.command;
  * https://discord.gg/qUa6zNFZsd
  */
 
-import me.bobert.netneutrality.utils.ReflectionHelper;
+import me.bobert.netneutrality.bootstrap.ApplicationContext;
+import me.bobert.netneutrality.bootstrap.ReflectionHelper;
 import net.dv8tion.jda.api.JDA;
 import net.dv8tion.jda.api.interactions.InteractionContextType;
 import net.dv8tion.jda.api.interactions.commands.build.CommandData;
@@ -17,15 +18,43 @@ import org.apache.logging.log4j.Logger;
 import java.util.ArrayList;
 import java.util.List;
 import java.util.Map;
+import java.util.Objects;
 import java.util.Set;
 import java.util.concurrent.ConcurrentHashMap;
+import java.util.function.Consumer;
 
-public class CommandManager {
+/**
+ * Instance-based {@link CommandRegistry} owning the discovered command map.
+ */
+public class CommandManager implements CommandRegistry {
 
     private static final Logger logger = LogManager.getLogger(CommandManager.class);
-    public static final Map<String, CommandContainer> commands = new ConcurrentHashMap<>();
 
-    public static void init() {
+    private final Map<String, CommandContainer> commands = new ConcurrentHashMap<>();
+    private final ApplicationContext context;
+
+    /**
+     * Creates a command manager that can inject context-registered dependencies into reflectively
+     * loaded commands.
+     *
+     * @param context the application context; must not be {@code null}
+     */
+    public CommandManager(ApplicationContext context) {
+        Objects.requireNonNull(context, "ApplicationContext must not be null");
+        this.context = context;
+    }
+
+    @Override
+    public int priority() {
+        return 30;
+    }
+
+    @Override
+    public void start() {
+        init();
+    }
+
+    public void init() {
         logger.info("Loading commands..");
 
         initCommands();
@@ -33,12 +62,30 @@ public class CommandManager {
         logger.info("Loaded {} commands!", commands.size());
     }
 
-    public static CommandContainer getCommandContainer(String commandString) {
+    @Override
-        return commands.getOrDefault(commandString, CommandContainer.NULL_COMMAND);
+    public CommandContainer getCommandContainer(String name) {
+        return commands.getOrDefault(name, CommandContainer.NULL_COMMAND);
     }
 
-    public static void initCommands() {
+    @Override
-        ReflectionHelper.loadCommands(Command.class, command -> {
+    public boolean hasCommand(String name) {
+        return commands.containsKey(name);
+    }
+
+    /**
+     * Exposes the live command map for call sites (and tests) that still iterate or mutate it
+     * directly. Prefer {@link #hasCommand(String)} / {@link #getCommandContainer(String)} where
+     * possible.
+     *
+     * @return the registered commands keyed by name
+     */
+    @Override
+    public Map<String, CommandContainer> getCommands() {
+        return commands;
+    }
+
+    public void initCommands() {
+        Consumer<Command> onLoaded = command -> {
             if (!command.isEnabled()) {
                 logger.info("Skipping command {} as it is disabled", command.getClass().getName());
                 return;
@@ -58,10 +105,13 @@ public class CommandManager {
             if (!commands.containsKey(command.getCommandName())) {
                 commands.put(command.getCommandName(), container);
             }
-        });
+        };
+
+        ReflectionHelper.loadCommands(Command.class, context, onLoaded);
     }
 
-    public static void registerSlashCommands(JDA jda) {
+    @Override
+    public void registerSlashCommands(JDA jda) {
         CommandListUpdateAction commandListUpdateAction = jda.updateCommands();
         List<CommandData> slashCommands = new ArrayList<>();
 

src/main/java/me/bobert/netneutrality/core/command/CommandProcessor.java

@@ -6,61 +6,76 @@ package me.bobert.netneutrality.core.command;
  */
 
 import io.sentry.Sentry;
-import me.bobert.netneutrality.context.command.SlashCommandContext;
 import me.bobert.netneutrality.core.LogHandler;
+import me.bobert.netneutrality.core.command.precondition.CommandPrecondition;
+import me.bobert.netneutrality.core.command.precondition.DisabledCommandPrecondition;
+import me.bobert.netneutrality.core.command.precondition.GuildOnlyPrecondition;
+import me.bobert.netneutrality.core.command.precondition.PermissionPrecondition;
+import me.bobert.netneutrality.core.command.precondition.SlashCommandOnlyPrecondition;
 import me.bobert.netneutrality.core.context.CommandContext;
-import me.bobert.netneutrality.core.context.InteractionContext;
-import me.bobert.netneutrality.core.tasks.TaskManager;
 import me.bobert.netneutrality.exceptions.CommandExecutionException;
 import me.bobert.netneutrality.exceptions.GracefulContextError;
+import me.bobert.netneutrality.core.tasks.TaskManager;
 import me.bobert.netneutrality.utils.UserFunction;
 import net.dv8tion.jda.api.interactions.commands.build.OptionData;
-import net.dv8tion.jda.api.interactions.commands.build.SubcommandData;
-import net.dv8tion.jda.api.interactions.commands.build.SubcommandGroupData;
 import org.apache.logging.log4j.LogManager;
 import org.apache.logging.log4j.Logger;
 
-import java.util.ArrayList;
-import java.util.Arrays;
 import java.util.List;
 import java.util.Map;
-
+import java.util.Objects;
-import static java.util.function.Predicate.not;
-import static me.bobert.netneutrality.core.command.CommandExecutionResult.Result.ERROR;
-import static me.bobert.netneutrality.core.command.CommandExecutionResult.Result.NOACTION;
-import static me.bobert.netneutrality.core.command.CommandExecutionResult.Result.TASK;
-import static me.bobert.netneutrality.core.command.CommandExecutionResult.Result.WARN;
 
 public class CommandProcessor {
 
     private static final Logger logger = LogManager.getLogger(CommandProcessor.class);
     private final CommandContext context;
+    private final CommandRegistry commands;
+    private final TaskManager taskManager;
+    private final List<CommandPrecondition> preconditions;
+    private final UsageValidator usageValidator;
+    private final CommandResultHandler resultHandler;
 
-    public CommandProcessor(CommandContext context) {
+    public CommandProcessor(CommandContext context, CommandRegistry commands, TaskManager taskManager) {
+        this(context, commands, taskManager, defaultPreconditions(), new UsageValidator(), new CommandResultHandler());
+    }
+
+    public CommandProcessor(CommandContext context, CommandRegistry commands, TaskManager taskManager,
+                            List<CommandPrecondition> preconditions, UsageValidator usageValidator,
+                            CommandResultHandler resultHandler) {
         this.context = context;
+        this.commands = Objects.requireNonNull(commands, "commands");
+        this.taskManager = Objects.requireNonNull(taskManager, "taskManager");
+        this.preconditions = Objects.requireNonNull(preconditions, "preconditions");
+        this.usageValidator = Objects.requireNonNull(usageValidator, "usageValidator");
+        this.resultHandler = Objects.requireNonNull(resultHandler, "resultHandler");
+    }
+
+    private static List<CommandPrecondition> defaultPreconditions() {
+        return List.of(
+            new GuildOnlyPrecondition(),
+            new DisabledCommandPrecondition(),
+            new SlashCommandOnlyPrecondition(),
+            new PermissionPrecondition()
+        );
     }
 
     public void dispatch() {
-        if (!CommandManager.commands.containsKey(context.parseCommandName())) {
+        if (!commands.hasCommand(context.parseCommandName())) {
             return;
         }
 
-        CommandContainer container = CommandManager.getCommandContainer(context.parseCommandName());
+        CommandContainer container = commands.getCommandContainer(context.parseCommandName());
         Command command = container.getCommand();
         if (command == null) {
             throw new IllegalArgumentException("Context has no command");
         }
 
         context.setCommand(command);
-        if (command.isGuildOnly() && !context.isFromGuild()) {
-            context.replyEphemeral("This command is only available in a guild");
-            context.deleteMessage();
-            return;
-        }
 
-        if (command.isSlashCommandOnly() && !(context instanceof InteractionContext)) {
+        for (CommandPrecondition precondition : preconditions) {
-            context.replyEphemeral("This command is only available as a slash command");
+            if (!precondition.check(context, command)) {
-            return;
+                return;
+            }
         }
 
         try {
@@ -68,12 +83,7 @@ public class CommandProcessor {
             logger.info("Executing command {} on guild {}", command.getCommandName(), context.getGuild() == null ? "PrivateMessage" : context.getGuild().getId());
             configureSentry(command);
 
-            if (command.getType() == Command.Type.SLASH && !canExecute(command)) {
+            if (command.getType() == Command.Type.SLASH && !usageValidator.validate(context, container)) {
-                context.reply("You are not powerful enough, scrub");
-                return;
-            }
-
-            if (command.getType() == Command.Type.SLASH && !checkUsage(container)) {
                 return;
             }
 
@@ -88,31 +98,7 @@ public class CommandProcessor {
             }
 
             CommandExecutionResult commandExecutionResult = command.execute(context);
-            if (commandExecutionResult == null) {
+            resultHandler.handle(context, commandExecutionResult, taskManager);
-                throw new RuntimeException("CommandExecutionResult is null");
-            }
-
-            CommandExecutionResult.Result result = commandExecutionResult.getResult();
-            if (result == NOACTION) {
-                return;
-            }
-
-            if (result == TASK) {
-                TaskManager.getInstance().insert(context, commandExecutionResult.getTask());
-            }
-
-            String message = commandExecutionResult.getMessage();
-            if (result == ERROR) {
-                logger.error("Context[{}]: Error from command: {}", context.getId(), message, commandExecutionResult.getException());
-            }
-
-            if (result == WARN) {
-                logger.warn("Context[{}]: Warning from command: {}", context.getId(), message);
-            }
-
-            if (message != null) {
-                context.reply(message);
-            }
         } catch (GracefulContextError exception) {
             logger.error(exception.getMessage());
             context.replyEphemeral(exception.getMessage());
@@ -123,111 +109,6 @@ public class CommandProcessor {
         }
     }
 
-    private boolean checkUsage(CommandContainer container) {
-        List<SubcommandGroupData> groups = container.getSubcommandGroups();
-        List<SubcommandData> subcommands = container.getSubcommands();
-        List<OptionData> options = container.getOptions();
-        String[] possibleCommands = Arrays.stream(context.getFullCommand().split(" ")).skip(1).toArray(String[]::new);
-        if (possibleCommands.length == 0) {
-            if (!groups.isEmpty()) {
-                // missing subcommand group
-                context.reply(invalidUsage("missing subcommand group"));
-                return false;
-            }
-
-            if (!subcommands.isEmpty()) {
-                // missing subcommand
-                context.reply(invalidUsage("missing subcommand"));
-                return false;
-            }
-
-            return checkOptions(possibleCommands, 0, options);
-        }
-
-        SubcommandGroupData group = groups.stream().filter(data -> data.getName().equals(possibleCommands[0])).findFirst().orElse(null);
-        if (group == null) {
-            SubcommandData subcommand = subcommands.stream().filter(data -> data.getName().equals(possibleCommands[0])).findFirst().orElse(null);
-            if (subcommand == null) {
-                if (!groups.isEmpty()) {
-                    // no group found but one is expected
-                    context.reply(invalidUsage("unknown subcommand group"));
-                    return false;
-                }
-
-                if (!subcommands.isEmpty()) {
-                    // no subcommand found but one is expected
-                    context.reply(invalidUsage("unknown subcommand"));
-                    return false;
-                }
-
-                // no group found, no subcommand found, command with options only
-                return checkOptions(possibleCommands, 0, options);
-            }
-
-            // no group found, subcommand found
-            context.setSubcommand(subcommand);
-            return checkOptions(possibleCommands, 1, subcommand.getOptions());
-        }
-
-        if (possibleCommands.length < 2) {
-            // missing subcommand for group
-            context.reply(invalidUsage("missing subcommand for command group"));
-            return false;
-        }
-
-        SubcommandData subcommand = group.getSubcommands().stream().filter(data -> data.getName().equals(possibleCommands[1])).findFirst().orElse(null);
-        if (subcommand == null) {
-            // group found, no subcommand found
-            context.reply(invalidUsage("unknown subcommand in command group"));
-            return false;
-        }
-
-        // group found, subcommand found
-        context.setSubcommandGroup(group);
-        context.setSubcommand(subcommand);
-        return checkOptions(possibleCommands, 2, subcommand.getOptions());
-    }
-
-    private boolean checkOptions(String[] args, int skip, List<OptionData> options) {
-        if (context instanceof InteractionContext) {
-            context.setCurrentCommandOptions(args, options);
-            return true; // slash commands are validated by discord
-        }
-
-        List<String> arguments = new ArrayList<>(Arrays.stream(args).skip(skip).toList());
-        int required = options.stream().filter(OptionData::isRequired).toList().size();
-        int optional = options.stream().filter(not(OptionData::isRequired)).toList().size();
-
-        if (arguments.size() < required) {
-            context.reply(invalidUsage("missing one or more required arguments"));
-            return false;
-        }
-
-        context.setCurrentCommandOptions(arguments.toArray(String[]::new), options);
-        return true;
-    }
-
-    private boolean canExecute(Command command) {
-        if (command.canBeExecutedFrom(context.getChannel())) {
-            return true;
-        }
-
-        if (context instanceof SlashCommandContext) {
-            return true; // no further checks since slash perms are handled by guild settings on discord
-        }
-
-        if (command.canBeExecutedBy(context.getGuildUser())) {
-            return true;
-        }
-
-        return command.needAdmin() && UserFunction.isAdmin(context.getGuildUser());
-    }
-
-    private String invalidUsage(String message) {
-        return String.format("Invalid usage for command: %s\n" +
-            "Use **/help %s** for information on how to use this command", message, context.getCommand().getCommandName());
-    }
-
     private void configureSentry(Command command) {
         Sentry.configureScope(scope -> {
             scope.setTag("command", command.getCommandName());

src/main/java/me/bobert/netneutrality/core/command/CommandRegistry.java

@@ -0,0 +1,51 @@
+package me.bobert.netneutrality.core.command;
+
+/*
+ * Copyright (c) anthorob
+ *
+ * https://discord.gg/qUa6zNFZsd
+ */
+
+import me.bobert.netneutrality.bootstrap.Lifecycle;
+import net.dv8tion.jda.api.JDA;
+
+import java.util.Map;
+
+/**
+ * Owns the bot command registry and slash-command registration against Discord.
+ *
+ * <p>As a {@link Lifecycle} component it discovers and loads commands on {@link #start()}.
+ */
+public interface CommandRegistry extends Lifecycle {
+
+    /**
+     * Returns the container for the named command, or a null-object container if unknown.
+     *
+     * @param name the command name
+     * @return the command container
+     */
+    CommandContainer getCommandContainer(String name);
+
+    /**
+     * Whether a command with the given name is registered.
+     *
+     * @param name the command name
+     * @return {@code true} if registered
+     */
+    boolean hasCommand(String name);
+
+    /**
+     * Pushes every enabled slash command up to Discord via the given JDA instance.
+     *
+     * @param jda the connected JDA client
+     */
+    void registerSlashCommands(JDA jda);
+
+    /**
+     * Returns the live command map keyed by command name.
+     *
+     * @return the registered commands
+     */
+    Map<String, CommandContainer> getCommands();
+}
+

src/main/java/me/bobert/netneutrality/core/command/CommandResultHandler.java

@@ -0,0 +1,49 @@
+package me.bobert.netneutrality.core.command;
+/*
+ * Copyright (c) anthorob
+ *
+ * https://discord.gg/qUa6zNFZsd
+ */
+
+import me.bobert.netneutrality.core.context.CommandContext;
+import me.bobert.netneutrality.core.tasks.TaskManager;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+
+import static me.bobert.netneutrality.core.command.CommandExecutionResult.Result.ERROR;
+import static me.bobert.netneutrality.core.command.CommandExecutionResult.Result.NOACTION;
+import static me.bobert.netneutrality.core.command.CommandExecutionResult.Result.TASK;
+import static me.bobert.netneutrality.core.command.CommandExecutionResult.Result.WARN;
+
+public class CommandResultHandler {
+
+    private static final Logger logger = LogManager.getLogger(CommandResultHandler.class);
+
+    public void handle(CommandContext context, CommandExecutionResult commandExecutionResult, TaskManager taskManager) {
+        if (commandExecutionResult == null) {
+            throw new RuntimeException("CommandExecutionResult is null");
+        }
+
+        CommandExecutionResult.Result result = commandExecutionResult.getResult();
+        if (result == NOACTION) {
+            return;
+        }
+
+        if (result == TASK) {
+            taskManager.insert(context, commandExecutionResult.getTask());
+        }
+
+        String message = commandExecutionResult.getMessage();
+        if (result == ERROR) {
+            logger.error("Context[{}]: Error from command: {}", context.getId(), message, commandExecutionResult.getException());
+        }
+
+        if (result == WARN) {
+            logger.warn("Context[{}]: Warning from command: {}", context.getId(), message);
+        }
+
+        if (message != null) {
+            context.reply(message);
+        }
+    }
+}

src/main/java/me/bobert/netneutrality/core/command/UsageValidator.java

@@ -0,0 +1,97 @@
+package me.bobert.netneutrality.core.command;
+/*
+ * Copyright (c) anthorob
+ *
+ * https://discord.gg/qUa6zNFZsd
+ */
+
+import me.bobert.netneutrality.core.context.CommandContext;
+import net.dv8tion.jda.api.interactions.commands.build.OptionData;
+import net.dv8tion.jda.api.interactions.commands.build.SubcommandData;
+import net.dv8tion.jda.api.interactions.commands.build.SubcommandGroupData;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+
+public class UsageValidator {
+
+    public boolean validate(CommandContext context, CommandContainer container) {
+        List<SubcommandGroupData> groups = container.getSubcommandGroups();
+        List<SubcommandData> subcommands = container.getSubcommands();
+        List<OptionData> options = container.getOptions();
+        String[] possibleCommands = Arrays.stream(context.getFullCommand().split(" ")).skip(1).toArray(String[]::new);
+        if (possibleCommands.length == 0) {
+            if (!groups.isEmpty()) {
+                context.reply(invalidUsage("missing subcommand group", context));
+                return false;
+            }
+
+            if (!subcommands.isEmpty()) {
+                context.reply(invalidUsage("missing subcommand", context));
+                return false;
+            }
+
+            return checkOptions(context, possibleCommands, 0, options);
+        }
+
+        SubcommandGroupData group = groups.stream().filter(data -> data.getName().equals(possibleCommands[0])).findFirst().orElse(null);
+        if (group == null) {
+            SubcommandData subcommand = subcommands.stream().filter(data -> data.getName().equals(possibleCommands[0])).findFirst().orElse(null);
+            if (subcommand == null) {
+                if (!groups.isEmpty()) {
+                    context.reply(invalidUsage("unknown subcommand group", context));
+                    return false;
+                }
+
+                if (!subcommands.isEmpty()) {
+                    context.reply(invalidUsage("unknown subcommand", context));
+                    return false;
+                }
+
+                return checkOptions(context, possibleCommands, 0, options);
+            }
+
+            context.setSubcommand(subcommand);
+            return checkOptions(context, possibleCommands, 1, subcommand.getOptions());
+        }
+
+        if (possibleCommands.length < 2) {
+            context.reply(invalidUsage("missing subcommand for command group", context));
+            return false;
+        }
+
+        SubcommandData subcommand = group.getSubcommands().stream().filter(data -> data.getName().equals(possibleCommands[1])).findFirst().orElse(null);
+        if (subcommand == null) {
+            context.reply(invalidUsage("unknown subcommand in command group", context));
+            return false;
+        }
+
+        context.setSubcommandGroup(group);
+        context.setSubcommand(subcommand);
+        return checkOptions(context, possibleCommands, 2, subcommand.getOptions());
+    }
+
+    private boolean checkOptions(CommandContext context, String[] args, int skip, List<OptionData> options) {
+        if (context.isInteraction()) {
+            context.setCurrentCommandOptions(args, options);
+            return true;
+        }
+
+        List<String> arguments = new ArrayList<>(Arrays.stream(args).skip(skip).toList());
+        int required = options.stream().filter(OptionData::isRequired).toList().size();
+
+        if (arguments.size() < required) {
+            context.reply(invalidUsage("missing one or more required arguments", context));
+            return false;
+        }
+
+        context.setCurrentCommandOptions(arguments.toArray(String[]::new), options);
+        return true;
+    }
+
+    private String invalidUsage(String message, CommandContext context) {
+        return String.format("Invalid usage for command: %s\n" +
+            "Use **/help %s** for information on how to use this command", message, context.getCommand().getCommandName());
+    }
+}

src/main/java/me/bobert/netneutrality/core/command/impl/MusicCommand.java

@@ -6,18 +6,55 @@ package me.bobert.netneutrality.core.command.impl;
  */
 
 import me.bobert.netneutrality.core.command.CommandCategory;
+import me.bobert.netneutrality.db.service.GuildServiceProvider;
 import me.bobert.netneutrality.db.GSettings;
 import me.bobert.netneutrality.db.service.GuildService;
-import me.bobert.netneutrality.utils.UserFunction;
+import me.bobert.netneutrality.utils.MusicAccess;
 import net.dv8tion.jda.api.entities.Guild;
 import net.dv8tion.jda.api.entities.Member;
-import net.dv8tion.jda.api.entities.Role;
 import net.dv8tion.jda.api.entities.channel.ChannelType;
 import net.dv8tion.jda.api.entities.channel.middleman.GuildMessageChannel;
 import net.dv8tion.jda.api.entities.channel.middleman.MessageChannel;
 
+import java.util.Objects;
+
 public abstract class MusicCommand extends AbstractCommand {
 
+    /**
+     * Injected guild-service provider when constructed via DI.
+     */
+    private final GuildServiceProvider guildServices;
+
+    /**
+     * Preferred constructor for DI.
+     *
+     * @param guildServices the shared guild service provider, must not be {@code null}
+     */
+    public MusicCommand(GuildServiceProvider guildServices) {
+        Objects.requireNonNull(guildServices, "GuildServiceProvider must not be null");
+        this.guildServices = guildServices;
+    }
+
+    /**
+     * Resolves the {@link GuildService} for a guild via the injected provider.
+     *
+     * @param guild the guild
+     * @return the guild service
+     */
+    protected final GuildService guildService(Guild guild) {
+        return guildServices.get(guild.getId());
+    }
+
+    /**
+     * Resolves the {@link GuildService} for a guild id via the injected provider.
+     *
+     * @param guildId the guild id
+     * @return the guild service
+     */
+    protected final GuildService guildService(String guildId) {
+        return guildServices.get(guildId);
+    }
+
     @Override
     public boolean needAdmin() {
         return false;
@@ -39,26 +76,7 @@ public abstract class MusicCommand extends AbstractCommand {
             return true;
         }
 
-        Guild guild = member.getGuild();
+        return MusicAccess.canUse(member, guildService(member.getGuild()));
-
-        String roleDb = GuildService.get(guild.getId()).getGuildSettingService().getSetting(GSettings.MUSIC_ROLE);
-
-        if (roleDb != null && !roleDb.isEmpty()) {
-            if (UserFunction.isAdmin(member)) {
-                return true;
-            }
-
-            Role neededRole = guild.getRoleById(roleDb);
-            if (neededRole == null) {
-                // Role doesn't exist on guild anymore, remove from db
-                GuildService.get(guild.getId()).getGuildSettingService().setSettingValue(GSettings.MUSIC_ROLE, null);
-                return true;
-            }
-
-            return member.getRoles().contains(neededRole);
-        }
-
-        return true;
     }
 
     @Override
@@ -68,7 +86,7 @@ public abstract class MusicCommand extends AbstractCommand {
                 return false;
             }
 
-            String channelDb = GuildService.get(guildMessageChannel.getGuild()).getGuildSettingService().getSetting(GSettings.MUSIC_CHANNEL);
+            String channelDb = guildService(guildMessageChannel.getGuild()).getGuildSettingService().getOrDefault(GSettings.MUSIC_CHANNEL);
             if (channelDb != null && !channelDb.isEmpty()) {
                 return channelDb.equals(channel.getId());
             }

src/main/java/me/bobert/netneutrality/core/command/precondition/CommandPrecondition.java

@@ -0,0 +1,17 @@
+package me.bobert.netneutrality.core.command.precondition;
+/*
+ * Copyright (c) anthorob
+ *
+ * https://discord.gg/qUa6zNFZsd
+ */
+
+import me.bobert.netneutrality.core.command.Command;
+import me.bobert.netneutrality.core.context.CommandContext;
+
+public interface CommandPrecondition {
+    /**
+     * Returns true if the precondition passes and execution should continue,
+     * or false if it failed (the implementation is responsible for sending any reply).
+     */
+    boolean check(CommandContext context, Command command);
+}

src/main/java/me/bobert/netneutrality/core/command/precondition/DisabledCommandPrecondition.java

@@ -0,0 +1,52 @@
+package me.bobert.netneutrality.core.command.precondition;
+/*
+ * Copyright (c) anthorob
+ *
+ * https://discord.gg/qUa6zNFZsd
+ */
+
+import me.bobert.netneutrality.core.command.Command;
+import me.bobert.netneutrality.core.context.CommandContext;
+import me.bobert.netneutrality.db.GSettings;
+import me.bobert.netneutrality.db.service.GuildServiceProvider;
+
+import java.util.Arrays;
+
+public class DisabledCommandPrecondition implements CommandPrecondition {
+
+    private static volatile GuildServiceProvider guildServices;
+
+    /**
+     * Binds the guild-service provider used to resolve the guild's configured {@code DISABLED_COMMANDS}.
+     * Called once during bootstrap.
+     *
+     * @param provider the live guild service provider
+     */
+    public static void bind(GuildServiceProvider provider) {
+        guildServices = provider;
+    }
+
+    @Override
+    public boolean check(CommandContext context, Command command) {
+        GuildServiceProvider provider = guildServices;
+        if (provider == null || context.getGuild() == null) {
+            return true;
+        }
+
+        String disabledCommands = provider.get(context.getGuild().getId()).getGuildSettingService().getOrDefault(GSettings.DISABLED_COMMANDS);
+        if (disabledCommands.isEmpty()) {
+            return true;
+        }
+
+        boolean disabled = Arrays.stream(disabledCommands.split(","))
+            .map(String::trim)
+            .anyMatch(name -> name.equalsIgnoreCase(command.getCommandName()));
+
+        if (disabled) {
+            context.replyEphemeral("This command is disabled on this server");
+            return false;
+        }
+
+        return true;
+    }
+}

src/main/java/me/bobert/netneutrality/core/command/precondition/GuildOnlyPrecondition.java

@@ -0,0 +1,23 @@
+package me.bobert.netneutrality.core.command.precondition;
+/*
+ * Copyright (c) anthorob
+ *
+ * https://discord.gg/qUa6zNFZsd
+ */
+
+import me.bobert.netneutrality.core.command.Command;
+import me.bobert.netneutrality.core.context.CommandContext;
+
+public class GuildOnlyPrecondition implements CommandPrecondition {
+
+    @Override
+    public boolean check(CommandContext context, Command command) {
+        if (command.isGuildOnly() && !context.isFromGuild()) {
+            context.replyEphemeral("This command is only available in a guild");
+            context.deleteMessage();
+            return false;
+        }
+
+        return true;
+    }
+}

src/main/java/me/bobert/netneutrality/core/command/precondition/PermissionPrecondition.java

@@ -0,0 +1,41 @@
+package me.bobert.netneutrality.core.command.precondition;
+/*
+ * Copyright (c) anthorob
+ *
+ * https://discord.gg/qUa6zNFZsd
+ */
+
+import me.bobert.netneutrality.core.command.Command;
+import me.bobert.netneutrality.core.context.CommandContext;
+import me.bobert.netneutrality.utils.UserFunction;
+
+public class PermissionPrecondition implements CommandPrecondition {
+
+    @Override
+    public boolean check(CommandContext context, Command command) {
+        if (command.getType() != Command.Type.SLASH) {
+            return true;
+        }
+
+        if (context.canSkipPermissionCheck()) {
+            return true;
+        }
+
+        if (!command.canBeExecutedFrom(context.getChannel())) {
+            context.replyEphemeral("This command cannot be executed in the current channel");
+            return false;
+        }
+
+        if (command.needAdmin() && !UserFunction.isAdmin(context.getGuildUser())) {
+            context.replyEphemeral("You are not powerful enough, scrub");
+            return false;
+        }
+
+        if (!command.canBeExecutedBy(context.getGuildUser())) {
+            context.replyEphemeral("You are not powerful enough, scrub");
+            return false;
+        }
+
+        return true;
+    }
+}

src/main/java/me/bobert/netneutrality/core/command/precondition/SlashCommandOnlyPrecondition.java

@@ -0,0 +1,22 @@
+package me.bobert.netneutrality.core.command.precondition;
+/*
+ * Copyright (c) anthorob
+ *
+ * https://discord.gg/qUa6zNFZsd
+ */
+
+import me.bobert.netneutrality.core.command.Command;
+import me.bobert.netneutrality.core.context.CommandContext;
+
+public class SlashCommandOnlyPrecondition implements CommandPrecondition {
+
+    @Override
+    public boolean check(CommandContext context, Command command) {
+        if (command.isSlashCommandOnly() && !context.isInteraction()) {
+            context.replyEphemeral("This command is only available as a slash command");
+            return false;
+        }
+
+        return true;
+    }
+}

src/main/java/me/bobert/netneutrality/core/context/AsyncContext.java

@@ -1,11 +1,10 @@
-package me.bobert.netneutrality.context;
+package me.bobert.netneutrality.core.context;
 /*
  * Copyright (c) anthorob
  *
  * https://discord.gg/qUa6zNFZsd
  */
 
-import me.bobert.netneutrality.core.context.AbstractContext;
 import net.dv8tion.jda.api.components.MessageTopLevelComponent;
 import net.dv8tion.jda.api.entities.Message;
 import net.dv8tion.jda.api.entities.channel.ChannelType;

src/main/java/me/bobert/netneutrality/core/context/CommandContext.java

@@ -7,7 +7,7 @@ package me.bobert.netneutrality.core.context;
 
 import me.bobert.netneutrality.core.command.Command;
 import me.bobert.netneutrality.core.command.options.CommandOption;
-import me.bobert.netneutrality.utils.Settings;
+import me.bobert.netneutrality.utils.SettingsProvider;
 import net.dv8tion.jda.api.JDA;
 import net.dv8tion.jda.api.entities.Guild;
 import net.dv8tion.jda.api.entities.Member;
@@ -33,10 +33,12 @@ public abstract class CommandContext extends AbstractContext {
     private SubcommandData subcommand;
     private final Map<OptionData, String> invalidOptions = new HashMap<>();
     private final List<CommandOption> options;
+    private final SettingsProvider settings;
 
-    public CommandContext(JDA jda, Guild guild, MessageChannel channel, Member member, User user) {
+    public CommandContext(JDA jda, Guild guild, MessageChannel channel, Member member, User user, SettingsProvider settings) {
         super(jda, guild, channel, member, user);
         this.options = new ArrayList<>();
+        this.settings = settings;
     }
 
     public Command getCommand() {
@@ -98,7 +100,7 @@ public abstract class CommandContext extends AbstractContext {
 
     public CommandOption getOption(String name) {
         List<CommandOption> options = getOptionsByName(name);
-        return options.isEmpty() ? null : options.get(0);
+        return options.isEmpty() ? null : options.getFirst();
     }
 
     public List<CommandOption> getOptionsByName(String name) {
@@ -131,7 +133,7 @@ public abstract class CommandContext extends AbstractContext {
     }
 
     public boolean isMessageFromCreator() {
-        String creatorId = Settings.getInstance().get("NETNEUTRALITY_BOT_OWNER");
+        String creatorId = settings.get("NETNEUTRALITY_BOT_OWNER");
 
         return creatorId.equals(getDiscordUser().getId());
     }
@@ -141,4 +143,12 @@ public abstract class CommandContext extends AbstractContext {
     public abstract String parseCommandName();
 
     public abstract String getFullCommand();
+
+    public boolean isInteraction() {
+        return false;
+    }
+
+    public boolean canSkipPermissionCheck() {
+        return false;
+    }
 }

src/main/java/me/bobert/netneutrality/core/context/Context.java

@@ -5,7 +5,6 @@ package me.bobert.netneutrality.core.context;
  * https://discord.gg/qUa6zNFZsd
  */
 
-import me.bobert.netneutrality.context.AsyncContext;
 import me.bobert.netneutrality.utils.ContextUtils;
 import net.dv8tion.jda.api.JDA;
 import net.dv8tion.jda.api.components.MessageTopLevelComponent;

src/main/java/me/bobert/netneutrality/core/context/InteractionContext.java

@@ -5,7 +5,6 @@ package me.bobert.netneutrality.core.context;
  * https://discord.gg/qUa6zNFZsd
  */
 
-import me.bobert.netneutrality.context.AsyncContext;
 import net.dv8tion.jda.api.components.MessageTopLevelComponent;
 import net.dv8tion.jda.api.interactions.Interaction;
 import net.dv8tion.jda.api.interactions.InteractionHook;

src/main/java/me/bobert/netneutrality/core/context/MessageContext.java

@@ -6,7 +6,6 @@ package me.bobert.netneutrality.core.context;
  * https://discord.gg/qUa6zNFZsd
  */
 
-import me.bobert.netneutrality.context.AsyncContext;
 import net.dv8tion.jda.api.components.MessageTopLevelComponent;
 import net.dv8tion.jda.api.entities.Message;
 import net.dv8tion.jda.api.entities.channel.ChannelType;

src/main/java/me/bobert/netneutrality/core/context/NoMessageContext.java

@@ -6,7 +6,6 @@ package me.bobert.netneutrality.core.context;
  * https://discord.gg/qUa6zNFZsd
  */
 
-import me.bobert.netneutrality.context.AsyncContext;
 import net.dv8tion.jda.api.entities.channel.ChannelType;
 import net.dv8tion.jda.api.interactions.InteractionHook;
 import net.dv8tion.jda.api.modals.Modal;

src/main/java/me/bobert/netneutrality/core/db/DatabaseMigration.java

@@ -1,38 +0,0 @@
-package me.bobert.netneutrality.core.db;
-/*
- * Copyright (c) anthorob
- *
- * https://discord.gg/qUa6zNFZsd
- */
-
-import me.bobert.netneutrality.utils.Settings;
-import org.apache.logging.log4j.LogManager;
-import org.apache.logging.log4j.Logger;
-import org.flywaydb.core.Flyway;
-import org.flywaydb.core.api.output.MigrateResult;
-
-public class DatabaseMigration {
-    private final static Logger logger = LogManager.getLogger(DatabaseMigration.class);
-
-    public static void migrate() {
-        String dbName = Settings.getInstance().get("MYSQL_DATABASE", "netneutrality");
-        String dbUser = Settings.getInstance().get("MYSQL_USER", "root");
-        String dbPass = Settings.getInstance().get("MYSQL_PASSWORD", "");
-        String dbHost = Settings.getInstance().get("MYSQL_HOST", "localhost");
-        String dbPort = Settings.getInstance().get("MYSQL_PORT", "3306");
-        String dbUrl = String.format("jdbc:mysql://%s:%s/%s", dbHost, dbPort, dbName);
-
-        try {
-            logger.info("Running database migrations..");
-            Flyway flyway = Flyway.configure()
-                .dataSource(dbUrl, dbUser, dbPass)
-                .load();
-
-            MigrateResult result = flyway.migrate();
-            logger.info("Database migrations finished successfully! (total: {})", result.migrationsExecuted);
-        } catch (Exception e) {
-            logger.error(e);
-            System.exit(1);
-        }
-    }
-}

src/main/java/me/bobert/netneutrality/core/db/SessionManager.java

@@ -1,69 +0,0 @@
-package me.bobert.netneutrality.core.db;
-/*
- * Copyright (c) anthorob
- *
- * https://discord.gg/qUa6zNFZsd
- */
-
-import io.sentry.Sentry;
-import me.bobert.netneutrality.utils.Settings;
-import org.apache.logging.log4j.LogManager;
-import org.apache.logging.log4j.Logger;
-import org.hibernate.SessionFactory;
-import org.hibernate.boot.Metadata;
-import org.hibernate.boot.MetadataSources;
-import org.hibernate.boot.registry.StandardServiceRegistry;
-import org.hibernate.boot.registry.StandardServiceRegistryBuilder;
-import org.hibernate.cfg.Environment;
-
-import java.util.HashMap;
-import java.util.Map;
-
-public class SessionManager {
-    private static final Logger logger = LogManager.getLogger(SessionManager.class);
-    private static StandardServiceRegistry registry;
-    private static SessionFactory sessionFactory;
-
-    public static SessionFactory getSessionFactory() {
-        if (sessionFactory == null) {
-            try {
-                StandardServiceRegistryBuilder registryBuilder = new StandardServiceRegistryBuilder().configure();
-                Map<String, Object> settings = new HashMap<>();
-                String dbName = Settings.getInstance().get("MYSQL_DATABASE", "netneutrality");
-                String dbUser = Settings.getInstance().get("MYSQL_USER", "root");
-                String dbPass = Settings.getInstance().get("MYSQL_PASSWORD", "");
-                String dbHost = Settings.getInstance().get("MYSQL_HOST", "localhost");
-                String dbPort = Settings.getInstance().get("MYSQL_PORT", "3306");
-                logger.info("Connecting to database '{}' at {}:{} with user '{}'", dbName, dbHost, dbPort, dbUser);
-
-                settings.put(Environment.JAKARTA_JDBC_URL, String.format("jdbc:mysql://%s:%s/%s", dbHost, dbPort, dbName));
-                settings.put(Environment.JAKARTA_JDBC_USER, dbUser);
-                settings.put(Environment.JAKARTA_JDBC_PASSWORD, dbPass);
-                registryBuilder.applySettings(settings);
-
-                registry = registryBuilder.build();
-                MetadataSources sources = new MetadataSources(registry);
-                Metadata metadata = sources.getMetadataBuilder().build();
-                sessionFactory = metadata.getSessionFactoryBuilder().build();
-
-            } catch (Exception e) {
-                String env = Settings.getInstance().get("NETNEUTRALITY_BOT_ENV", "dev");
-                if (!"dev".equals(env)) {
-                    Sentry.captureException(e);
-                }
-
-                shutdown();
-                logger.error("Error connecting to database. Shutting down..");
-                System.exit(1);
-            }
-        }
-
-        return sessionFactory;
-    }
-
-    public static void shutdown() {
-        if (registry != null) {
-            StandardServiceRegistryBuilder.destroy(registry);
-        }
-    }
-}

src/main/java/me/bobert/netneutrality/core/log/DiscordDebugChannelLogSink.java

@@ -0,0 +1,63 @@
+package me.bobert.netneutrality.core.log;
+/*
+ * Copyright (c) anthorob
+ *
+ * https://discord.gg/qUa6zNFZsd
+ */
+
+import me.bobert.netneutrality.core.LogSeverity;
+import me.bobert.netneutrality.core.context.Context;
+import me.bobert.netneutrality.db.GSettings;
+import me.bobert.netneutrality.db.service.GuildServiceProvider;
+import me.bobert.netneutrality.db.service.GuildSettingService;
+import me.bobert.netneutrality.exceptions.ContextException;
+import me.bobert.netneutrality.utils.MessageFunction;
+import net.dv8tion.jda.api.entities.channel.concrete.TextChannel;
+
+/**
+ * A {@link LogSink} that posts {@link ContextException}s to a guild's debug/log channel, subject to
+ * {@link GuildServiceProvider#isDebugEnabled} and the guild's configured {@link LogSeverity} threshold.
+ */
+public class DiscordDebugChannelLogSink implements LogSink {
+
+    private final GuildServiceProvider guildServices;
+
+    /**
+     * @param guildServices the guild service provider used to look up debug settings per guild
+     */
+    public DiscordDebugChannelLogSink(GuildServiceProvider guildServices) {
+        this.guildServices = guildServices;
+    }
+
+    @Override
+    public void handle(LoggedException event) {
+        if (!(event.exception() instanceof ContextException exception)) {
+            return;
+        }
+
+        Context context = exception.getContext();
+
+        if (context.getGuild() == null) {
+            return;
+        }
+
+        if (guildServices == null || !guildServices.get(context.getGuild().getId()).isDebugEnabled()) {
+            return;
+        }
+
+        GuildSettingService settingService = guildServices.get(context.getGuild().getId()).getGuildSettingService();
+        LogSeverity configured = LogSeverity.parse(settingService.getOrDefault(GSettings.LOG_LEVEL));
+
+        if (!LogSeverity.ERROR.meetsThreshold(configured)) {
+            return;
+        }
+
+        String timezone = settingService.getOrDefault(GSettings.TIMEZONE);
+        context.getGuild()
+            .getTextChannels()
+            .stream()
+            .filter(textChannel -> textChannel.getName().equals("debug") || textChannel.getName().equals("log"))
+            .filter(TextChannel::canTalk)
+            .forEach(textChannel -> textChannel.sendMessageEmbeds(MessageFunction.buildDebugMessage(exception, timezone)).queue());
+    }
+}

src/main/java/me/bobert/netneutrality/core/log/Log4jLogSink.java

@@ -0,0 +1,53 @@
+package me.bobert.netneutrality.core.log;
+/*
+ * Copyright (c) anthorob
+ *
+ * https://discord.gg/qUa6zNFZsd
+ */
+
+import me.bobert.netneutrality.core.context.CommandContext;
+import me.bobert.netneutrality.core.context.Context;
+import me.bobert.netneutrality.core.context.TaskContext;
+import me.bobert.netneutrality.exceptions.ContextException;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+
+/**
+ * A {@link LogSink} that logs every exception via Log4j, including contextual details
+ * (guild, user, command/task) when the exception is a {@link ContextException}.
+ */
+public class Log4jLogSink implements LogSink {
+
+    private static final Logger logger = LogManager.getLogger(Log4jLogSink.class);
+
+    @Override
+    public void handle(LoggedException event) {
+        Exception exception = event.exception();
+
+        if (exception instanceof ContextException contextException) {
+            logInternally(contextException);
+
+            return;
+        }
+
+        logger.error(exception.getMessage(), exception);
+    }
+
+    private void logInternally(ContextException exception) {
+        Context context = exception.getContext();
+        String guildId = context.getGuild() == null ? "PrivateMessage" : context.getGuild().getId();
+
+        logger.error("Exception thrown from context (guild: {}, user: {}): {}", guildId,
+            context.getDiscordUser().getId(),
+            exception.getMessage()
+        );
+
+        if (context instanceof CommandContext commandContext) {
+            logger.error("Caused by command: {}", commandContext.getCommand().getCommandName(), exception);
+        }
+
+        if (context instanceof TaskContext taskContext) {
+            logger.error("Caused by task with ID: {}", taskContext.getId(), exception);
+        }
+    }
+}

src/main/java/me/bobert/netneutrality/core/log/LogSink.java

@@ -0,0 +1,22 @@
+package me.bobert.netneutrality.core.log;
+/*
+ * Copyright (c) anthorob
+ *
+ * https://discord.gg/qUa6zNFZsd
+ */
+
+/**
+ * A pluggable log destination. Implementations decide internally whether and how to act on a
+ * {@link LoggedException}. Failures thrown by a sink are caught and isolated by the dispatcher
+ * (e.g. {@code LogHandler}) so one broken sink never blocks the others.
+ */
+public interface LogSink {
+
+    /**
+     * Handles a logged exception event. Implementations should not throw checked exceptions that
+     * would prevent other sinks from running; any thrown exception is caught by the dispatcher.
+     *
+     * @param event the logged exception event
+     */
+    void handle(LoggedException event);
+}

src/main/java/me/bobert/netneutrality/core/log/LoggedException.java

@@ -0,0 +1,35 @@
+package me.bobert.netneutrality.core.log;
+/*
+ * Copyright (c) anthorob
+ *
+ * https://discord.gg/qUa6zNFZsd
+ */
+
+import me.bobert.netneutrality.core.context.Context;
+
+/**
+ * Immutable event payload dispatched to every registered {@link LogSink}.
+ *
+ * @param exception the exception being logged
+ * @param context   the context the exception occurred in, or {@code null} if none
+ * @param message   an optional additional message, or {@code null} if none
+ */
+public record LoggedException(Exception exception, Context context, String message) {
+
+    /**
+     * @param e the exception to log
+     * @return a {@link LoggedException} with no context or message
+     */
+    public static LoggedException of(Exception e) {
+        return new LoggedException(e, null, null);
+    }
+
+    /**
+     * @param message the message to attach to the exception
+     * @param e       the exception to log
+     * @return a {@link LoggedException} with no context
+     */
+    public static LoggedException of(String message, Exception e) {
+        return new LoggedException(e, null, message);
+    }
+}

src/main/java/me/bobert/netneutrality/core/log/SentryLogSink.java

@@ -0,0 +1,19 @@
+package me.bobert.netneutrality.core.log;
+/*
+ * Copyright (c) anthorob
+ *
+ * https://discord.gg/qUa6zNFZsd
+ */
+
+import io.sentry.Sentry;
+
+/**
+ * A {@link LogSink} that reports every logged exception to Sentry.
+ */
+public class SentryLogSink implements LogSink {
+
+    @Override
+    public void handle(LoggedException event) {
+        Sentry.captureException(event.exception());
+    }
+}

src/main/java/me/bobert/netneutrality/core/scheduled/ScheduledTask.java

@@ -1,4 +1,4 @@
-package me.bobert.netneutrality.core.tasks;
+package me.bobert.netneutrality.core.scheduled;
 
 /*
  * Copyright (c) anthorob

src/main/java/me/bobert/netneutrality/core/scheduled/ScheduledTaskManager.java

@@ -0,0 +1,112 @@
+package me.bobert.netneutrality.core.scheduled;
+
+/*
+ * Copyright (c) anthorob
+ *
+ * https://discord.gg/qUa6zNFZsd
+ */
+
+import me.bobert.netneutrality.bootstrap.ApplicationContext;
+import me.bobert.netneutrality.bootstrap.Lifecycle;
+import me.bobert.netneutrality.bootstrap.ReflectionHelper;
+import me.bobert.netneutrality.core.LogHandler;
+import me.bobert.netneutrality.core.thread.ExecutorProvider;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+
+import java.util.Map;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.ScheduledExecutorService;
+import java.util.concurrent.ScheduledFuture;
+import java.util.function.Consumer;
+
+/**
+ * Instance-based {@link Lifecycle} component that owns scheduled fixed-delay tasks.
+ *
+ * <p>On {@link #start()} it discovers all concrete {@link ScheduledTask} implementations via
+ * reflection and schedules them automatically.
+ */
+public class ScheduledTaskManager implements Lifecycle {
+    private static final Logger logger = LogManager.getLogger(ScheduledTaskManager.class);
+
+    private final Map<String, ScheduledFuture<?>> scheduledTasks = new ConcurrentHashMap<>();
+    private final ScheduledExecutorService executorService;
+    private final ApplicationContext context;
+
+    public ScheduledTaskManager(ExecutorProvider executors, ApplicationContext context) {
+        this.executorService = executors.getScheduledExecutor();
+        this.context = context;
+    }
+
+    @Override
+    public int priority() {
+        // High priority number => stopped early on shutdown, before executors (priority 20).
+        return 55;
+    }
+
+    @Override
+    public void start() {
+        loadScheduledTasks();
+    }
+
+    @Override
+    public void stop() {
+        cancelAll();
+    }
+
+    public void schedule(ScheduledTask task) {
+        String taskId = task.getId();
+
+        if (scheduledTasks.containsKey(taskId)) {
+            logger.warn("Task {} is already scheduled.", taskId);
+            return;
+        }
+
+        ScheduledTask.TimeFrame timeFrame = task.getTimeFrame();
+
+        Runnable runnable = () -> {
+            logger.debug("Executing scheduled task: {}", taskId);
+
+            try {
+                task.run();
+            } catch (Exception e) {
+                logger.error("An exception was thrown while executing scheduled task {}", taskId);
+                LogHandler.log(e);
+            }
+        };
+
+        ScheduledFuture<?> future = executorService.scheduleWithFixedDelay(
+            runnable,
+            1,
+            timeFrame.getInterval(),
+            timeFrame.getUnit()
+        );
+
+        scheduledTasks.put(taskId, future);
+        logger.info("Successfully scheduled task: {} with interval {} {}",
+            taskId, timeFrame.getInterval(), timeFrame.getUnit());
+    }
+
+    public void cancelAll() {
+        logger.info("Cancelling all {} scheduled tasks", scheduledTasks.size());
+        scheduledTasks.forEach((_, future) -> future.cancel(false));
+        scheduledTasks.clear();
+    }
+
+    private void loadScheduledTasks() {
+        logger.info("Loading scheduled tasks...");
+
+        Consumer<ScheduledTask> onLoaded = scheduledTask -> {
+            String taskId = scheduledTask.getId();
+
+            if (taskId == null || taskId.trim().isEmpty()) {
+                logger.error("Cannot load scheduled task {}: task ID is null or empty", scheduledTask.getClass().getName());
+                return;
+            }
+
+            schedule(scheduledTask);
+        };
+
+        ReflectionHelper.loadTasks(ScheduledTask.class, context, onLoaded);
+    }
+}

src/main/java/me/bobert/netneutrality/core/tasks/PersistableTask.java

@@ -5,6 +5,7 @@ package me.bobert.netneutrality.core.tasks;
  * https://discord.gg/qUa6zNFZsd
  */
 
+import com.fasterxml.jackson.databind.node.ObjectNode;
 import me.bobert.netneutrality.core.context.CommandContext;
 
 /**
@@ -13,6 +14,23 @@ import me.bobert.netneutrality.core.context.CommandContext;
  * so that it can be stored in a database.
  */
 public interface PersistableTask extends Task {
+    /**
+     * Stable logical type id stored in {@code tasks.task_class}.
+     * Defaults to {@link Task#getName()} so package moves and class renames are not breaking changes.
+     *
+     * @return the stable type id of this task type
+     */
+    default String typeId() {
+        return getName();
+    }
+
+    /**
+     * Rebuilds this instance's state from a payload previously produced by {@link #toPayload()}.
+     *
+     * @param payload the persisted payload, must not be {@code null}
+     */
+    void restore(ObjectNode payload);
+
     void insert(CommandContext context);
 
     void save();

src/main/java/me/bobert/netneutrality/core/tasks/Task.java

@@ -79,14 +79,4 @@ public interface Task {
     Lifecycle execute(TaskContext context);
 
     void insert(CommandContext context);
-
-    static Button createButton(Class<? extends WithButton> clazz) {
-        WithButton withButton = TaskManager.getInstance().findButtonTaskByClass(clazz);
-
-        if (withButton == null) {
-            throw new IllegalArgumentException("Task " + clazz.getName() + " was not registered by the task manager.");
-        }
-
-        return withButton.createButton();
-    }
 }

src/main/java/me/bobert/netneutrality/core/tasks/TaskManager.java

@@ -1,321 +1,120 @@
 package me.bobert.netneutrality.core.tasks;
+
 /*
  * Copyright (c) anthorob
  *
  * https://discord.gg/qUa6zNFZsd
  */
 
-import me.bobert.netneutrality.core.LogHandler;
-import me.bobert.netneutrality.core.context.CommandContext;
-import me.bobert.netneutrality.core.context.InteractionContext;
-import me.bobert.netneutrality.core.context.TaskContext;
-import me.bobert.netneutrality.core.tasks.trait.Deletable;
-import me.bobert.netneutrality.core.tasks.trait.NotAcknowledgeable;
-import me.bobert.netneutrality.core.tasks.trait.WithButton;
-import me.bobert.netneutrality.core.tasks.trait.WithChildren;
-import me.bobert.netneutrality.core.tasks.trait.WithParent;
-import me.bobert.netneutrality.core.thread.ScheduledTaskManager;
-import me.bobert.netneutrality.db.service.TaskService;
-import me.bobert.netneutrality.exceptions.GracefulContextError;
-import me.bobert.netneutrality.exceptions.TaskExecutionException;
-import me.bobert.netneutrality.utils.ReflectionHelper;
-import net.dv8tion.jda.api.interactions.InteractionHook;
-import org.apache.logging.log4j.LogManager;
-import org.apache.logging.log4j.Logger;
-
 import java.util.Collection;
 import java.util.List;
-import java.util.Map;
 import java.util.Optional;
-import java.util.concurrent.ConcurrentHashMap;
+import me.bobert.netneutrality.bootstrap.Lifecycle;
-import java.util.concurrent.CopyOnWriteArrayList;
+import me.bobert.netneutrality.core.context.CommandContext;
-import java.util.concurrent.locks.ReentrantLock;
+import me.bobert.netneutrality.core.context.TaskContext;
-import java.util.stream.Collectors;
+import me.bobert.netneutrality.core.tasks.trait.WithButton;
+import me.bobert.netneutrality.db.service.TaskService;
 
-public class TaskManager {
+/**
-    private static final Logger logger = LogManager.getLogger(TaskManager.class);
+ * Owns the in-memory task registry, button/interaction dispatch, and persistable-task loading.
-    private static TaskManager instance;
+ *
-    private final TaskService taskService;
+ * <p>As a {@link Lifecycle} component it loads built-in and persisted tasks on
-    private final Map<String, Task> tasks;
+ * {@link #start()}.
-    private final List<Task> pendingTasks;
+ */
-    private final Map<String, CommandContext> deletableTasksContext;
+public interface TaskManager extends Lifecycle {
-    private final Map<String, ReentrantLock> tasksLock;
 
-    private TaskManager() {
+    /**
-        this.tasks = new ConcurrentHashMap<>();
+     * Inserts a newly created task into the registry (and persists it when applicable).
-        this.pendingTasks = new CopyOnWriteArrayList<>();
+     *
-        this.deletableTasksContext = new ConcurrentHashMap<>();
+     * @param ctx  the command context that produced the task
-        this.tasksLock = new ConcurrentHashMap<>();
+     * @param task the task to insert
-        this.taskService = new TaskService();
+     */
-    }
+    void insert(CommandContext ctx, Task task);
 
-    public static TaskManager getInstance() {
+    /**
-        if (instance == null) {
+     * Looks up a task by its full id.
-            instance = new TaskManager();
+     *
-        }
+     * @param id the task id
+     * @return the task, or {@code null} if unknown
+     */
+    Task getTask(String id);
 
-        return instance;
+    /**
-    }
+     * Whether a task with the given id is registered or pending activation.
+     *
+     * @param id the task id
+     * @return {@code true} if present
+     */
+    boolean hasTask(String id);
 
-    public void init() {
+    /**
-        logger.info("Initializing task manager...");
+     * Dispatches an interaction/context event to the matching task.
+     *
+     * @param ctx the task context
+     */
+    void handle(TaskContext ctx);
 
-        loadBuiltInTasks();
+    /**
-        loadScheduledTasks();
+     * Promotes a pending step-task into the active registry under its (possibly new) id.
-        taskService.loadTasks();
+     *
-    }
+     * @param task  the task to activate
+     * @param oldId the previous id used while the task was pending
+     */
+    void activateTask(Task task, String oldId);
 
-    public TaskService getTaskService() {
+    /**
-        return taskService;
+     * Removes a task from the active registry.
-    }
+     *
+     * @param task the task to remove
+     */
+    void removeTask(Task task);
 
-    public Task getTask(String id) {
+    /**
-        return tasks.get(id);
+     * Inserts a previously persisted task back into the active registry.
-    }
+     *
+     * @param task the persistable task
+     */
+    void insertPersistableTask(PersistableTask task);
 
-    public boolean hasTask(String id) {
+    /**
-        return tasks.containsKey(id) || pendingTasks.stream().anyMatch(task -> task.getId().equals(id));
+     * Returns every currently active task.
-    }
+     *
+     * @return the active tasks
+     */
+    Collection<Task> getTasks();
 
-    public synchronized Collection<Task> getTasks() {
+    /**
-        return tasks.values();
+     * Finds the first task of the given type whose id contains {@code partialId}.
-    }
+     *
+     * @param clazz     the expected task type
+     * @param partialId a fragment of the task id
+     * @param <E>       the task type
+     * @return the matching task, if any
+     */
+    <E extends Task> Optional<E> findTaskByPartialId(Class<E> clazz, String partialId);
 
-    public void insert(CommandContext context, Task task) {
+    /**
-        String id = task.getId();
+     * Finds every task of the given type whose id contains {@code partialId}.
+     *
+     * @param clazz     the expected task type
+     * @param partialId a fragment of the task id
+     * @param <E>       the task type
+     * @return the matching tasks
+     */
+    <E extends Task> List<E> findTasksByPartialId(Class<E> clazz, String partialId);
 
-        if (hasTask(id)) {
+    /**
-            context.reply("A task with the same ID already exists!");
+     * Finds the first button-bearing task of the given class.
-            return;
+     *
-        }
+     * @param clazz the expected button-task type
+     * @return the matching task, or {@code null}
+     */
+    WithButton findButtonTaskByClass(Class<? extends WithButton> clazz);
 
-        task.replyToInteraction(context);
+    /**
-
+     * Returns the persistence service used for loadable tasks.
-        if (task.isInsertable()) {
+     *
-            logger.info("Inserting task: {}", task);
+     * @return the task service
-
+     */
-            if (task instanceof PersistableTask persistableTask) {
+    TaskService getTaskService();
-                taskService.persistTask(persistableTask);
-            }
-
-            if (task instanceof StepTask) {
-                pendingTasks.add(task);
-            } else {
-                tasks.put(id, task);
-            }
-        }
-
-        if (task instanceof Deletable) {
-            deletableTasksContext.put(task.getId(), context);
-        }
-
-        if (task instanceof WithChildren taskWithChildren) {
-            List<Task> childrens = taskWithChildren.getChildTasks();
-            if (childrens == null || childrens.isEmpty()) {
-                logger.warn("Parent task '{}' doesn't create any childs", task.getName());
-                return;
-            }
-
-            for (Task child : childrens) {
-                insert(context, child);
-            }
-        }
-    }
-
-    public void activateTask(Task task, String oldId) {
-        if (pendingTasks.remove(task)) {
-            tasks.put(task.getId(), task);
-            logger.info("Updating task {} with new id: {} (was: {})",
-                task.getName(), task.getId(), oldId);
-        }
-    }
-
-    public void removeTask(Task task) {
-        String id = task.getId();
-
-        if (tasks.remove(id) != null) {
-            logger.debug("Removing task: {}", id);
-
-            ReentrantLock lock = tasksLock.remove(task.getLockId());
-            if (lock != null) {
-                logger.debug("Cleaning up lock for removed task: {}", task.getId());
-            }
-        }
-    }
-
-    public void handle(TaskContext context) {
-        String taskId = context.getId();
-        Task task = getTask(taskId);
-
-        if (task == null && context instanceof InteractionContext) {
-            context.replyEphemeral("This task is no longer available, someone might have already used it or it might have expired");
-        }
-
-        if (task != null) {
-            String lockId = task.getLockId();
-            ReentrantLock lock = tasksLock.computeIfAbsent(lockId, k -> {
-                if (task instanceof PersistableTask || task instanceof BuiltInTask) {
-                    return null;
-                }
-
-                return new ReentrantLock();
-            });
-
-            try {
-                if (lock != null) {
-                    logger.debug("Aquiring lock for task: {}", taskId);
-                    lock.lock();
-
-                    if (!tasks.containsKey(taskId)) {
-                        logger.debug("Task {} is no longer available after aquiring lock", taskId);
-                        tasksLock.remove(lockId);
-                        return;
-                    }
-                }
-
-                logger.info("Executing task: {}", taskId);
-                Task.Lifecycle status = task.execute(context);
-                handleTaskLifecycle(task, status);
-
-                deleteInteraction(task);
-
-                // If interaction is still not acknowledged after execution, send a placeholder response.
-                if (!context.isAcknowledged() && !(task instanceof NotAcknowledgeable)) {
-                    logger.warn("Interaction not acknowledged");
-                    context.replyEphemeral("Task executed successfully but interaction wasn't acknowledged, report this bug by using the command /report-bug");
-                }
-            } catch (GracefulContextError exception) {
-                logger.error(exception.getMessage());
-                context.replyEphemeral(exception.getMessage());
-            } catch (TaskExecutionException exception) {
-                LogHandler.log(exception);
-            } catch (Exception exception) {
-                LogHandler.log(new TaskExecutionException("Error during task execution", context, exception));
-            } finally {
-                if (lock != null) {
-                    logger.debug("Releasing lock for task: {}", taskId);
-                    lock.unlock();
-                }
-            }
-        }
-    }
-
-    public <E extends Task> Optional<E> findTaskByPartialId(Class<E> clazz, String partialId) {
-        List<E> tasks = findTasksByPartialId(clazz, partialId);
-        return Optional.ofNullable(tasks.isEmpty() ? null : tasks.getFirst());
-    }
-
-    public <E extends Task> List<E> findTasksByPartialId(Class<E> clazz, String partialId) {
-        return tasks.values().stream()
-            .filter(clazz::isInstance)
-            .map(clazz::cast)
-            .filter(task -> task.getId().contains(partialId))
-            .collect(Collectors.toList());
-    }
-
-    public WithButton findButtonTaskByClass(Class<? extends WithButton> clazz) {
-        return tasks.values().stream()
-            .filter(clazz::isInstance)
-            .map(task -> (WithButton) task)
-            .findFirst()
-            .orElse(null);
-    }
-
-    public void insertPersistableTask(PersistableTask task) {
-        if (tasks.containsKey(task.getId())) {
-            logger.error("Trying to load persistable task but ID already exists: {}", task.getId());
-            return;
-        }
-
-        logger.info("Loaded persistable task: {}", task);
-        tasks.put(task.getId(), task);
-    }
-
-    private void loadBuiltInTasks() {
-        logger.info("Loading built-in tasks...");
-
-        ReflectionHelper.loadTasks(BuiltInTask.class, builtInTask -> {
-            if (builtInTask.isInsertable()) {
-                logger.info("Loaded task: {}", builtInTask.getClass().getName());
-                tasks.put(builtInTask.getId(), builtInTask);
-            }
-        });
-    }
-
-    private void loadScheduledTasks() {
-        logger.info("Loading scheduled tasks...");
-
-        ReflectionHelper.loadTasks(ScheduledTask.class, scheduledTask -> {
-            String taskId = scheduledTask.getId();
-
-            if (taskId == null || taskId.trim().isEmpty()) {
-                logger.error("Cannot load scheduled task {}: task ID is null or empty", scheduledTask.getClass().getName());
-                return;
-            }
-
-            ScheduledTaskManager.schedule(scheduledTask);
-        });
-    }
-
-    private void deleteInteraction(Task task) {
-        if (task instanceof WithParent<?> taskWithParent) {
-            Task parent = taskWithParent.getParentTask();
-
-            if (parent instanceof Deletable deletable && task.isInsertable()) {
-                deleteInteraction(parent.getId(), deletable);
-                return;
-            }
-        }
-
-        if (task instanceof Deletable deletable && task.isInsertable()) {
-            deleteInteraction(task.getId(), deletable);
-        }
-    }
-
-    private void deleteInteraction(String taskId, Deletable deletable) {
-        logger.debug("Deleting interaction: {}", taskId);
-
-        CommandContext context = deletableTasksContext.get(taskId);
-        if (context != null) {
-            deletableTasksContext.remove(taskId);
-
-            InteractionHook hook = context.getInteractionHook();
-            if (hook != null) {
-                if (hook.isExpired()) {
-                    context.replyEphemeral("This interaction has expired, can't remove it");
-                }
-
-                if (!hook.isExpired()) {
-                    hook.deleteOriginal().queue();
-                }
-            }
-        }
-
-        deletable.onInteractionDelete();
-    }
-
-    private void handleTaskLifecycle(Task task, Task.Lifecycle status) {
-        if (status == null) {
-            throw new IllegalArgumentException("Task lifecycle status cannot be null");
-        }
-
-        switch (status) {
-            case REMOVE_SELF:
-                removeTask(task);
-                break;
-
-            case REMOVE_SELF_AND_CHILDREN:
-                if (task instanceof WithChildren taskWithChildren) {
-                    for (Task child : taskWithChildren.getChildTasks()) {
-                        removeTask(child);
-                    }
-                }
-                removeTask(task);
-                break;
-
-            case KEEP:
-            default:
-                break;
-        }
-    }
 }

src/main/java/me/bobert/netneutrality/core/tasks/TaskManagerImpl.java

@@ -0,0 +1,397 @@
+package me.bobert.netneutrality.core.tasks;
+/*
+ * Copyright (c) anthorob
+ *
+ * https://discord.gg/qUa6zNFZsd
+ */
+
+import me.bobert.netneutrality.bootstrap.ApplicationContext;
+import me.bobert.netneutrality.core.LogHandler;
+import me.bobert.netneutrality.core.context.CommandContext;
+import me.bobert.netneutrality.core.context.InteractionContext;
+import me.bobert.netneutrality.core.context.TaskContext;
+import me.bobert.netneutrality.core.tasks.trait.Deletable;
+import me.bobert.netneutrality.core.tasks.trait.NotAcknowledgeable;
+import me.bobert.netneutrality.core.tasks.trait.WithButton;
+import me.bobert.netneutrality.core.tasks.trait.WithChildren;
+import me.bobert.netneutrality.core.tasks.trait.WithParent;
+import me.bobert.netneutrality.core.tasks.persistence.PersistableTaskRegistry;
+import me.bobert.netneutrality.db.repository.TaskRepository;
+import me.bobert.netneutrality.db.service.TaskService;
+import me.bobert.netneutrality.exceptions.GracefulContextError;
+import me.bobert.netneutrality.exceptions.TaskExecutionException;
+import me.bobert.netneutrality.bootstrap.ReflectionHelper;
+import net.dv8tion.jda.api.interactions.InteractionHook;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.List;
+import java.util.Map;
+import java.util.Objects;
+import java.util.Optional;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.locks.ReentrantLock;
+import java.util.function.Consumer;
+import java.util.stream.Collectors;
+
+/**
+ * Instance-based {@link TaskManager} owning the in-memory task registry.
+ */
+public class TaskManagerImpl implements TaskManager {
+    private static final Logger logger = LogManager.getLogger(TaskManagerImpl.class);
+    private final TaskService taskService;
+    private final Map<String, Task> tasks;
+    private final Map<String, Task> pendingTasks;
+    private final Map<String, CommandContext> deletableTasksContext;
+    private final Map<String, ReentrantLock> tasksLock;
+    private final ApplicationContext context;
+    private final PersistableTaskRegistry persistableTaskRegistry;
+
+    /**
+     * Creates a task manager that can inject context-registered dependencies into reflectively
+     * loaded tasks.
+     *
+     * @param context        the application context; must not be {@code null}
+     * @param taskRepository the repository persisting {@link PersistableTask}s
+     */
+    public TaskManagerImpl(ApplicationContext context, TaskRepository taskRepository) {
+        Objects.requireNonNull(context, "ApplicationContext must not be null");
+        this.tasks = new ConcurrentHashMap<>();
+        this.pendingTasks = new ConcurrentHashMap<>();
+        this.deletableTasksContext = new ConcurrentHashMap<>();
+        this.tasksLock = new ConcurrentHashMap<>();
+        this.context = context;
+        this.persistableTaskRegistry = new PersistableTaskRegistry(context);
+        this.taskService = new TaskService(this, persistableTaskRegistry, taskRepository);
+    }
+
+    @Override
+    public int priority() {
+        return 30;
+    }
+
+    @Override
+    public void start() {
+        init();
+    }
+
+    public void init() {
+        logger.info("Initializing task manager...");
+
+        loadBuiltInTasks();
+        persistableTaskRegistry.scan();
+        taskService.loadTasks();
+    }
+
+    @Override
+    public TaskService getTaskService() {
+        return taskService;
+    }
+
+    @Override
+    public Task getTask(String id) {
+        if (id == null) {
+            return null;
+        }
+        Task task = tasks.get(id);
+        if (task != null) {
+            return task;
+        }
+        return pendingTasks.get(id);
+    }
+
+    /**
+     * Checks whether a task with the given ID exists. Note: this check spans two collections
+     * ({@code tasks} and {@code pendingTasks}) without a single lock, so the result is
+     * best-effort and may be stale by the time the caller acts on it.
+     */
+    @Override
+    public boolean hasTask(String id) {
+        if (id == null) {
+            return false;
+        }
+        return tasks.containsKey(id) || pendingTasks.containsKey(id);
+    }
+
+    @Override
+    public Collection<Task> getTasks() {
+        List<Task> allTasks = new ArrayList<>(tasks.values());
+        allTasks.addAll(pendingTasks.values());
+        return allTasks;
+    }
+
+    @Override
+    public void insert(CommandContext context, Task task) {
+        String id = task.getId();
+
+        if (hasTask(id)) {
+            context.reply("A task with the same ID already exists!");
+            return;
+        }
+
+        task.replyToInteraction(context);
+
+        if (task.isInsertable()) {
+            logger.info("Inserting task: {}", task);
+
+            if (task instanceof PersistableTask persistableTask) {
+                taskService.persistTask(persistableTask);
+            }
+
+            if (task instanceof StepTask) {
+                pendingTasks.put(id, task);
+            } else {
+                tasks.put(id, task);
+            }
+        }
+
+        if (task instanceof Deletable) {
+            deletableTasksContext.put(task.getId(), context);
+        }
+
+        if (task instanceof WithChildren taskWithChildren) {
+            List<Task> childrens = taskWithChildren.getChildTasks();
+            if (childrens == null || childrens.isEmpty()) {
+                logger.warn("Parent task '{}' doesn't create any children", task.getName());
+                return;
+            }
+
+            for (Task child : childrens) {
+                insert(context, child);
+            }
+        }
+    }
+
+    @Override
+    public void activateTask(Task task, String oldId) {
+        if (task == null) {
+            return;
+        }
+        boolean removed = oldId != null && pendingTasks.remove(oldId) != null;
+        if (!removed) {
+            removed = pendingTasks.remove(task.getId()) != null;
+        }
+        if (!removed) {
+            pendingTasks.values().remove(task);
+        }
+        tasks.put(task.getId(), task);
+        logger.info("Updating task {} with new id: {} (was: {})",
+                task.getName(), task.getId(), oldId);
+    }
+
+    @Override
+    public void removeTask(Task task) {
+        if (task == null) {
+            return;
+        }
+        String id = task.getId();
+
+        boolean removed = tasks.remove(id) != null;
+        removed |= pendingTasks.remove(id) != null;
+        removed |= pendingTasks.values().remove(task);
+
+        if (removed) {
+            logger.debug("Removing task: {}", id);
+
+            if (task instanceof PersistableTask persistableTask) {
+                taskService.unpersistTask(persistableTask);
+            }
+        }
+    }
+
+    @Override
+    public void handle(TaskContext context) {
+        String taskId = context.getId();
+        Task task = getTask(taskId);
+
+        if (task == null && context instanceof InteractionContext) {
+            context.replyEphemeral("This task is no longer available, someone might have already used it or it might have expired");
+        }
+
+        if (task != null) {
+            String lockId = task.getLockId();
+            ReentrantLock lock = (task instanceof PersistableTask || task instanceof BuiltInTask)
+                    ? null
+                    : tasksLock.computeIfAbsent(lockId, _ -> new ReentrantLock());
+
+            try {
+                if (lock != null) {
+                    logger.debug("Acquiring lock for task: {}", taskId);
+                    lock.lock();
+
+                    if (!tasks.containsKey(taskId)) {
+                        logger.debug("Task {} is no longer available after acquiring lock", taskId);
+                        return;
+                    }
+                }
+
+                logger.info("Executing task: {}", taskId);
+                Task.Lifecycle status = task.execute(context);
+                handleTaskLifecycle(task, status);
+
+                deleteInteraction(task);
+
+                // If interaction is still not acknowledged after execution, send a placeholder response.
+                if (!context.isAcknowledged() && !(task instanceof NotAcknowledgeable)) {
+                    logger.warn("Interaction not acknowledged");
+                    context.replyEphemeral("Task executed successfully but interaction wasn't acknowledged, report this bug by using the command /report-bug");
+                }
+            } catch (GracefulContextError exception) {
+                logger.error(exception.getMessage());
+                context.replyEphemeral(exception.getMessage());
+            } catch (TaskExecutionException exception) {
+                LogHandler.log(exception);
+            } catch (Exception exception) {
+                LogHandler.log(new TaskExecutionException("Error during task execution", context, exception));
+            } finally {
+                if (lock != null) {
+                    logger.debug("Releasing lock for task: {}", taskId);
+                    lock.unlock();
+                }
+            }
+        }
+    }
+
+    @Override
+    public <E extends Task> Optional<E> findTaskByPartialId(Class<E> clazz, String partialId) {
+        if (clazz == null || partialId == null) {
+            return Optional.empty();
+        }
+        return tasks.values().stream()
+                .filter(clazz::isInstance)
+                .map(clazz::cast)
+                .filter(task -> task.getId() != null && task.getId().contains(partialId))
+                .findFirst();
+    }
+
+    @Override
+    public <E extends Task> List<E> findTasksByPartialId(Class<E> clazz, String partialId) {
+        if (clazz == null || partialId == null) {
+            return List.of();
+        }
+        return tasks.values().stream()
+                .filter(clazz::isInstance)
+                .map(clazz::cast)
+                .filter(task -> task.getId() != null && task.getId().contains(partialId))
+                .collect(Collectors.toList());
+    }
+
+    @Override
+    public WithButton findButtonTaskByClass(Class<? extends WithButton> clazz) {
+        return tasks.values().stream()
+                .filter(clazz::isInstance)
+                .map(task -> (WithButton) task)
+                .findFirst()
+                .orElse(null);
+    }
+
+    @Override
+    public void insertPersistableTask(PersistableTask task) {
+        if (tasks.containsKey(task.getId())) {
+            logger.error("Trying to load persistable task but ID already exists: {}", task.getId());
+            return;
+        }
+
+        logger.info("Loaded persistable task: {}", task);
+        tasks.put(task.getId(), task);
+    }
+
+    private void loadBuiltInTasks() {
+        logger.info("Loading built-in tasks...");
+
+        Consumer<BuiltInTask> onLoaded = builtInTask -> {
+            if (builtInTask.isInsertable()) {
+                logger.info("Loaded task: {}", builtInTask.getClass().getName());
+                tasks.put(builtInTask.getId(), builtInTask);
+            }
+        };
+
+        ReflectionHelper.loadTasks(BuiltInTask.class, context, onLoaded);
+    }
+
+
+    private void deleteInteraction(Task task) {
+        if (task == null) {
+            return;
+        }
+        if (task instanceof WithParent<?> taskWithParent) {
+            Task parent = taskWithParent.getParentTask();
+
+            if (parent instanceof Deletable deletable && task.isInsertable()) {
+                deleteInteraction(parent.getId(), deletable);
+                return;
+            }
+        }
+
+        if (task instanceof Deletable deletable && task.isInsertable()) {
+            deleteInteraction(task.getId(), deletable);
+        }
+    }
+
+    private void deleteInteraction(String taskId, Deletable deletable) {
+        logger.debug("Deleting interaction: {}", taskId);
+
+        CommandContext commandContext = deletableTasksContext.remove(taskId);
+        if (commandContext != null) {
+            InteractionHook hook = commandContext.getInteractionHook();
+            if (hook != null) {
+                if (hook.isExpired()) {
+                    commandContext.replyEphemeral("This interaction has expired, can't remove it");
+                } else {
+                    hook.deleteOriginal().queue(null, error ->
+                            logger.warn("Failed to delete interaction for task {}: {}", taskId, error.getMessage())
+                    );
+                }
+            }
+        }
+
+        deletable.onInteractionDelete();
+    }
+
+    private void handleTaskLifecycle(Task task, Task.Lifecycle status) {
+        if (status == null) {
+            throw new IllegalArgumentException("Task lifecycle status cannot be null");
+        }
+
+        switch (status) {
+            case REMOVE_SELF:
+                removeTask(task);
+                break;
+
+            case REMOVE_SELF_AND_CHILDREN:
+                if (task instanceof WithParent<?> taskWithParent) {
+                    Task parent = taskWithParent.getParentTask();
+                    if (parent != null) {
+                        if (parent instanceof WithChildren parentWithChildren) {
+                            List<Task> childTasks = parentWithChildren.getChildTasks();
+                            if (childTasks != null) {
+                                for (Task child : childTasks) {
+                                    removeTask(child);
+                                }
+                            }
+                        }
+                        removeTask(parent);
+                    } else {
+                        removeTask(task);
+                    }
+                } else if (task instanceof WithChildren taskWithChildren) {
+                    List<Task> childTasks = taskWithChildren.getChildTasks();
+                    if (childTasks != null) {
+                        for (Task child : childTasks) {
+                            removeTask(child);
+                        }
+                    }
+                    removeTask(task);
+                } else {
+                    removeTask(task);
+                }
+                break;
+
+            case KEEP:
+            default:
+                break;
+        }
+    }
+}

src/main/java/me/bobert/netneutrality/core/tasks/generic/AcceptButton.java

@@ -1,4 +1,4 @@
-package me.bobert.netneutrality.tasks.generic;
+package me.bobert.netneutrality.core.tasks.generic;
 
 /*
  * Copyright (c) anthorob
@@ -7,6 +7,7 @@ package me.bobert.netneutrality.tasks.generic;
  */
 
 import me.bobert.netneutrality.core.context.TaskContext;
+import me.bobert.netneutrality.core.tasks.TaskManager;
 import me.bobert.netneutrality.core.tasks.impl.ButtonTask;
 import me.bobert.netneutrality.core.tasks.trait.NotAcknowledgeable;
 import me.bobert.netneutrality.core.tasks.trait.WithChildren;
@@ -24,26 +25,26 @@ public class AcceptButton<P extends WithChildren> extends ButtonTask implements
     private final P parentTask;
     private final Function<TaskContext, Lifecycle> function;
 
-    protected AcceptButton(P parentTask, ButtonStyle buttonStyle, String buttonLabel, Function<TaskContext, Lifecycle> function) {
+    protected AcceptButton(TaskManager taskManager, P parentTask, ButtonStyle buttonStyle, String buttonLabel, Function<TaskContext, Lifecycle> function) {
-        super(buttonStyle, buttonLabel);
+        super(taskManager, buttonStyle, buttonLabel);
         this.parentTask = parentTask;
         this.function = function;
     }
 
-    public static <P extends WithChildren> AcceptButton<P> createPrimaryButton(P parentTask, String buttonLabel, Function<TaskContext, Lifecycle> function) {
+    public static <P extends WithChildren> AcceptButton<P> createPrimaryButton(TaskManager taskManager, P parentTask, String buttonLabel, Function<TaskContext, Lifecycle> function) {
-        return new AcceptButton<>(parentTask, ButtonStyle.PRIMARY, buttonLabel, function);
+        return new AcceptButton<>(taskManager, parentTask, ButtonStyle.PRIMARY, buttonLabel, function);
     }
 
-    public static <P extends WithChildren> AcceptButton<P> createSecondaryButton(P parentTask, String buttonLabel, Function<TaskContext, Lifecycle> function) {
+    public static <P extends WithChildren> AcceptButton<P> createSecondaryButton(TaskManager taskManager, P parentTask, String buttonLabel, Function<TaskContext, Lifecycle> function) {
-        return new AcceptButton<>(parentTask, ButtonStyle.SECONDARY, buttonLabel, function);
+        return new AcceptButton<>(taskManager, parentTask, ButtonStyle.SECONDARY, buttonLabel, function);
     }
 
-    public static <P extends WithChildren> AcceptButton<P> createSuccessButton(P parentTask, String buttonLabel, Function<TaskContext, Lifecycle> function) {
+    public static <P extends WithChildren> AcceptButton<P> createSuccessButton(TaskManager taskManager, P parentTask, String buttonLabel, Function<TaskContext, Lifecycle> function) {
-        return new AcceptButton<>(parentTask, ButtonStyle.SUCCESS, buttonLabel, function);
+        return new AcceptButton<>(taskManager, parentTask, ButtonStyle.SUCCESS, buttonLabel, function);
     }
 
-    public static <P extends WithChildren> AcceptButton<P> createDangerButton(P parentTask, String buttonLabel, Function<TaskContext, Lifecycle> function) {
+    public static <P extends WithChildren> AcceptButton<P> createDangerButton(TaskManager taskManager, P parentTask, String buttonLabel, Function<TaskContext, Lifecycle> function) {
-        return new AcceptButton<>(parentTask, ButtonStyle.DANGER, buttonLabel, function);
+        return new AcceptButton<>(taskManager, parentTask, ButtonStyle.DANGER, buttonLabel, function);
     }
 
     @Override

src/main/java/me/bobert/netneutrality/core/tasks/generic/CancelButton.java

@@ -1,4 +1,4 @@
-package me.bobert.netneutrality.tasks.generic;
+package me.bobert.netneutrality.core.tasks.generic;
 
 /*
  * Copyright (c) anthorob
@@ -7,6 +7,7 @@ package me.bobert.netneutrality.tasks.generic;
  */
 
 import me.bobert.netneutrality.core.context.TaskContext;
+import me.bobert.netneutrality.core.tasks.TaskManager;
 import me.bobert.netneutrality.core.tasks.impl.ButtonTask;
 import me.bobert.netneutrality.core.tasks.trait.NotAcknowledgeable;
 import me.bobert.netneutrality.core.tasks.trait.WithChildren;
@@ -19,14 +20,14 @@ public class CancelButton<P extends WithChildren> extends ButtonTask implements
     private final P parentTask;
     private final Function<TaskContext, Lifecycle> function;
 
-    protected CancelButton(P parentTask, ButtonStyle buttonStyle, String buttonLabel, Function<TaskContext, Lifecycle> function) {
+    protected CancelButton(TaskManager taskManager, P parentTask, ButtonStyle buttonStyle, String buttonLabel, Function<TaskContext, Lifecycle> function) {
-        super(buttonStyle, buttonLabel);
+        super(taskManager, buttonStyle, buttonLabel);
         this.parentTask = parentTask;
         this.function = function;
     }
 
-    public static <P extends WithChildren> CancelButton<P> create(P parentTask, String buttonLabel, Function<TaskContext, Lifecycle> function) {
+    public static <P extends WithChildren> CancelButton<P> create(TaskManager taskManager, P parentTask, String buttonLabel, Function<TaskContext, Lifecycle> function) {
-        return new CancelButton<>(parentTask, ButtonStyle.DANGER, buttonLabel, function);
+        return new CancelButton<>(taskManager, parentTask, ButtonStyle.DANGER, buttonLabel, function);
     }
 
     @Override

src/main/java/me/bobert/netneutrality/core/tasks/impl/AbstractBuiltInTask.java

@@ -8,9 +8,14 @@ package me.bobert.netneutrality.core.tasks.impl;
 import me.bobert.netneutrality.core.context.CommandContext;
 import me.bobert.netneutrality.core.context.TaskContext;
 import me.bobert.netneutrality.core.tasks.BuiltInTask;
+import me.bobert.netneutrality.core.tasks.TaskManager;
 
 public abstract class AbstractBuiltInTask extends AbstractTask implements BuiltInTask {
 
+    public AbstractBuiltInTask(TaskManager taskManager) {
+        super(taskManager);
+    }
+
     @Override
     public String getName() {
         return getId();

src/main/java/me/bobert/netneutrality/core/tasks/impl/AbstractPersistableTask.java

@@ -5,13 +5,23 @@ package me.bobert.netneutrality.core.tasks.impl;
  * https://discord.gg/qUa6zNFZsd
  */
 
+import com.fasterxml.jackson.databind.node.ObjectNode;
 import me.bobert.netneutrality.core.context.CommandContext;
 import me.bobert.netneutrality.core.tasks.PersistableTask;
 import me.bobert.netneutrality.core.tasks.TaskManager;
-import org.json.JSONObject;
+import me.bobert.netneutrality.utils.Json;
 
 public abstract class AbstractPersistableTask extends AbstractTask implements PersistableTask {
 
+    /**
+     * Preferred constructor for DI.
+     *
+     * @param taskManager the application task manager, must not be {@code null}
+     */
+    public AbstractPersistableTask(TaskManager taskManager) {
+        super(taskManager);
+    }
+
     @Override
     public boolean isInsertable() {
         return true;
@@ -29,31 +39,55 @@ public abstract class AbstractPersistableTask extends AbstractTask implements Pe
 
     @Override
     public void insert(CommandContext context) {
-        if (TaskManager.getInstance().hasTask(getId())) {
+        if (taskManager().hasTask(getId())) {
             throw new RuntimeException("Cannot insert a task that already exists");
         }
 
-        TaskManager.getInstance().insert(context, this);
+        taskManager().insert(context, this);
     }
 
     @Override
     public void save() {
-        if (!TaskManager.getInstance().hasTask(getId())) {
+        if (!taskManager().hasTask(getId())) {
             throw new RuntimeException("Cannot save a task that doesn't exist yet");
         }
 
-        TaskManager.getInstance().getTaskService().persistTask(this);
+        taskManager().getTaskService().persistTask(this);
     }
 
     @Override
     public void delete() {
-        TaskManager.getInstance().getTaskService().unpersistTask(this);
+        taskManager().getTaskService().unpersistTask(this);
-        TaskManager.getInstance().removeTask(this);
+        taskManager().removeTask(this);
+    }
+
+    /**
+     * No-op default: only tasks carrying extra state need to override this.
+     *
+     * @param payload the persisted payload
+     */
+    @Override
+    public void restore(ObjectNode payload) {
+        // Nothing to restore by default
+    }
+
+    /**
+     * No-op default: only tasks carrying extra state need to override this.
+     *
+     * @param payload the payload being written
+     */
+    protected void writePayload(ObjectNode payload) {
+        // Nothing extra to write by default
     }
 
     @Override
     public String toPayload() {
-        JSONObject payload = new JSONObject(this);
+        ObjectNode payload = Json.object();
+        payload.put("id", getId());
+        payload.put("lockId", getLockId());
+        payload.put("name", getName());
+
+        writePayload(payload);
 
         return payload.toString();
     }

src/main/java/me/bobert/netneutrality/core/tasks/impl/AbstractStepTask.java

@@ -31,6 +31,15 @@ public abstract class AbstractStepTask extends AbstractTask implements StepTask
     private Guild guild;
     private String id = UUID.randomUUID().toString();
 
+    /**
+     * Preferred constructor for DI.
+     *
+     * @param taskManager the application task manager, must not be {@code null}
+     */
+    public AbstractStepTask(TaskManager taskManager) {
+        super(taskManager);
+    }
+
     @Override
     public String getId() {
         return id;
@@ -156,7 +165,7 @@ public abstract class AbstractStepTask extends AbstractTask implements StepTask
         String oldId = id;
         synchronized (this) {
             this.id = newId;
-            TaskManager.getInstance().activateTask(this, oldId);
+            taskManager().activateTask(this, oldId);
         }
     }
 }

src/main/java/me/bobert/netneutrality/core/tasks/impl/AbstractTask.java

@@ -14,9 +14,29 @@ import java.util.Objects;
 
 public abstract class AbstractTask implements Task {
     private final OffsetDateTime creationTime;
+    /**
+     * Injected task manager when constructed via DI.
+     */
+    private final TaskManager taskManager;
 
-    public AbstractTask() {
+    /**
-        creationTime = OffsetDateTime.now();
+     * Preferred constructor for DI: stores the shared {@link TaskManager} for insert/activate/remove.
+     *
+     * @param taskManager the application task manager, must not be {@code null}
+     */
+    public AbstractTask(TaskManager taskManager) {
+        Objects.requireNonNull(taskManager, "TaskManager must not be null");
+        this.creationTime = OffsetDateTime.now();
+        this.taskManager = taskManager;
+    }
+
+    /**
+     * Returns the injected task manager.
+     *
+     * @return the task manager to use
+     */
+    protected final TaskManager taskManager() {
+        return taskManager;
     }
 
     @Override
@@ -26,7 +46,7 @@ public abstract class AbstractTask implements Task {
 
     @Override
     public void insert(CommandContext context) {
-        TaskManager.getInstance().insert(context, this);
+        taskManager().insert(context, this);
     }
 
     @Override

src/main/java/me/bobert/netneutrality/core/tasks/impl/ButtonTask.java

@@ -7,6 +7,7 @@ package me.bobert.netneutrality.core.tasks.impl;
 
 import me.bobert.netneutrality.core.tasks.Task;
 import me.bobert.netneutrality.core.tasks.trait.WithButton;
+import me.bobert.netneutrality.core.tasks.TaskManager;
 import net.dv8tion.jda.api.components.buttons.Button;
 import net.dv8tion.jda.api.components.buttons.ButtonStyle;
 import net.dv8tion.jda.api.entities.emoji.Emoji;
@@ -18,7 +19,8 @@ public abstract class ButtonTask extends GenericRandomIdTask implements WithButt
     private final String buttonLabel;
     private Emoji emoji;
 
-    public ButtonTask(ButtonStyle buttonStyle, String buttonLabel) {
+    public ButtonTask(TaskManager taskManager, ButtonStyle buttonStyle, String buttonLabel) {
+        super(taskManager);
         this.buttonStyle = buttonStyle;
         this.buttonLabel = buttonLabel;
     }

src/main/java/me/bobert/netneutrality/core/tasks/impl/EmojiTask.java

@@ -5,23 +5,66 @@ package me.bobert.netneutrality.core.tasks.impl;
  * https://discord.gg/qUa6zNFZsd
  */
 
+import com.fasterxml.jackson.databind.JsonNode;
+import com.fasterxml.jackson.databind.node.ObjectNode;
 import me.bobert.netneutrality.context.tasks.EmojiTaskContext;
+import me.bobert.netneutrality.core.tasks.TaskManager;
 
 import java.util.Map;
 import java.util.concurrent.ConcurrentHashMap;
 
 public abstract class EmojiTask extends AbstractPersistableTask {
     private final Map<String, String> emojiMapping = new ConcurrentHashMap<>();
-    private final String guildId;
+    private String guildId;
-    private final String channelId;
+    private String channelId;
-    private final String messageId;
+    private String messageId;
 
-    public EmojiTask(String guildId, String channelId, String messageId) {
+    public EmojiTask(TaskManager taskManager, String guildId, String channelId, String messageId) {
+        super(taskManager);
         this.guildId = guildId;
         this.channelId = channelId;
         this.messageId = messageId;
     }
 
+    /**
+     * Constructor used by the persistable task registry: the message coordinates and the emoji
+     * mapping are hydrated afterwards by {@link #restore(ObjectNode)}.
+     *
+     * @param taskManager the application task manager, must not be {@code null}
+     */
+    public EmojiTask(TaskManager taskManager) {
+        super(taskManager);
+    }
+
+    @Override
+    public void restore(ObjectNode payload) {
+        this.guildId = payload.path("guildId").asText(null);
+        this.channelId = payload.path("channelId").asText(null);
+        this.messageId = payload.path("messageId").asText(null);
+
+        emojiMapping.clear();
+        JsonNode mapping = payload.path("emojiMapping");
+        if (mapping.isObject()) {
+            mapping.properties().forEach(entry -> emojiMapping.put(entry.getKey(), entry.getValue().asText()));
+        }
+    }
+
+    @Override
+    protected void writePayload(ObjectNode payload) {
+        putIfPresent(payload, "guildId", guildId);
+        putIfPresent(payload, "channelId", channelId);
+        putIfPresent(payload, "messageId", messageId);
+
+        ObjectNode mapping = payload.putObject("emojiMapping");
+        emojiMapping.forEach(mapping::put);
+    }
+
+    private static void putIfPresent(ObjectNode payload, String key, String value) {
+        if (value != null) {
+            payload.put(key, value);
+        }
+    }
+
     public String getGuildId() {
         return guildId;
     }

src/main/java/me/bobert/netneutrality/core/tasks/impl/GenericCustomIdTask.java

@@ -1,20 +1,22 @@
 package me.bobert.netneutrality.core.tasks.impl;
-
 /*
  * Copyright (c) anthorob
  *
  * https://discord.gg/qUa6zNFZsd
  */
 
-public abstract class GenericCustomIdTask extends AbstractTask {
+import me.bobert.netneutrality.core.tasks.TaskManager;
-    private final String customId;
 
-    public GenericCustomIdTask(String id) {
+public abstract class GenericCustomIdTask extends AbstractTask {
-        this.customId = id;
+    private final String id;
+
+    public GenericCustomIdTask(TaskManager taskManager, String id) {
+        super(taskManager);
+        this.id = id;
     }
 
     @Override
     public String getId() {
-        return customId;
+        return id;
     }
 }

src/main/java/me/bobert/netneutrality/core/tasks/impl/GenericRandomIdTask.java

@@ -1,15 +1,16 @@
 package me.bobert.netneutrality.core.tasks.impl;
-
 /*
  * Copyright (c) anthorob
  *
  * https://discord.gg/qUa6zNFZsd
  */
 
+import me.bobert.netneutrality.core.tasks.TaskManager;
+
 import java.util.UUID;
 
 public abstract class GenericRandomIdTask extends GenericCustomIdTask {
-    public GenericRandomIdTask() {
+    public GenericRandomIdTask(TaskManager taskManager) {
-        super(UUID.randomUUID().toString());
+        super(taskManager, UUID.randomUUID().toString());
     }
 }

src/main/java/me/bobert/netneutrality/core/tasks/impl/ModalTask.java

@@ -6,6 +6,7 @@ package me.bobert.netneutrality.core.tasks.impl;
  */
 
 import me.bobert.netneutrality.core.context.TaskContext;
+import me.bobert.netneutrality.core.tasks.TaskManager;
 import net.dv8tion.jda.api.interactions.modals.ModalMapping;
 
 import java.time.OffsetDateTime;
@@ -14,6 +15,10 @@ import java.util.Optional;
 
 public abstract class ModalTask extends GenericRandomIdTask {
 
+    public ModalTask(TaskManager taskManager) {
+        super(taskManager);
+    }
+
     @Override
     public boolean isExpired() {
         return getCreationTime().plusMinutes(5).isBefore(OffsetDateTime.now());

src/main/java/me/bobert/netneutrality/core/tasks/persistence/PersistableTaskRegistry.java

@@ -0,0 +1,102 @@
+package me.bobert.netneutrality.core.tasks.persistence;
+/*
+ * Copyright (c) anthorob
+ *
+ * https://discord.gg/qUa6zNFZsd
+ */
+
+import com.fasterxml.jackson.databind.node.ObjectNode;
+import me.bobert.netneutrality.bootstrap.ApplicationContext;
+import me.bobert.netneutrality.bootstrap.ReflectionHelper;
+import me.bobert.netneutrality.core.tasks.PersistableTask;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+
+import java.util.Collections;
+import java.util.Map;
+import java.util.Objects;
+import java.util.Set;
+import java.util.concurrent.ConcurrentHashMap;
+
+/**
+ * Registry of the persistable task types available on the classpath.
+ *
+ * <p>Types are discovered by scanning for concrete {@link PersistableTask} implementations and are
+ * keyed by their {@link PersistableTask#typeId()}, which is the value stored in
+ * {@code tasks.task_class}. Restoring a row creates a fresh instance through the regular DI path
+ * and lets the task hydrate itself from its payload.
+ */
+public final class PersistableTaskRegistry {
+    private static final Logger logger = LogManager.getLogger(PersistableTaskRegistry.class);
+
+    private final Map<String, Class<? extends PersistableTask>> typesById = new ConcurrentHashMap<>();
+    private final ApplicationContext context;
+
+    /**
+     * @param context the DI context used to instantiate discovered task types, must not be {@code null}
+     */
+    public PersistableTaskRegistry(ApplicationContext context) {
+        this.context = Objects.requireNonNull(context, "ApplicationContext must not be null");
+    }
+
+    /**
+     * Discovers every concrete {@link PersistableTask} implementation and registers it by its type id.
+     *
+     * @throws IllegalStateException if two task types declare the same type id
+     */
+    public void scan() {
+        typesById.clear();
+
+        ReflectionHelper.loadTasks(PersistableTask.class, context, this::register);
+
+        logger.info("Registered {} persistable task type(s): {}", typesById.size(), typesById.keySet());
+    }
+
+    void register(PersistableTask prototype) {
+        String typeId = prototype.typeId();
+        Class<? extends PersistableTask> type = prototype.getClass();
+
+        Class<? extends PersistableTask> previous = typesById.putIfAbsent(typeId, type);
+        if (previous != null && !previous.equals(type)) {
+            throw new IllegalStateException(String.format(
+                    "Duplicate persistable task type id '%s' declared by %s and %s",
+                    typeId, previous.getName(), type.getName()));
+        }
+    }
+
+    /**
+     * @param typeId the type id to look up
+     * @return {@code true} if a task type is registered under the given id
+     */
+    public boolean isRegistered(String typeId) {
+        return typeId != null && typesById.containsKey(typeId);
+    }
+
+    /**
+     * @return the registered type ids
+     */
+    public Set<String> getTypeIds() {
+        return Collections.unmodifiableSet(typesById.keySet());
+    }
+
+    /**
+     * Creates a fresh task instance for the given type id and hydrates it from the payload.
+     *
+     * @param typeId  the registered type id
+     * @param payload the payload previously produced by {@link PersistableTask#toPayload()}
+     * @return the restored task
+     * @throws IllegalArgumentException if no task type is registered under {@code typeId}
+     * @throws ReflectiveOperationException if the task type cannot be instantiated
+     */
+    public PersistableTask create(String typeId, ObjectNode payload) throws ReflectiveOperationException {
+        Class<? extends PersistableTask> type = typesById.get(typeId);
+        if (type == null) {
+            throw new IllegalArgumentException("No persistable task type registered for id: " + typeId);
+        }
+
+        PersistableTask task = ReflectionHelper.instantiate(type, context);
+        task.restore(payload);
+
+        return task;
+    }
+}