diff --git a/docs/capacity-placeholders.md b/docs/capacity-placeholders.md
index 035058ff..16da6dab 100644
--- a/docs/capacity-placeholders.md
+++ b/docs/capacity-placeholders.md
@@ -1,6 +1,6 @@
 # Capacity Snapshot Feed
 
-> ProxyFeatures Capacity 1.3.0 · versioned Redis latest-value feed for ServerFeatures placeholders
+> ProxyFeatures Capacity 1.4.0 · versioned Redis latest-value feed for ServerFeatures placeholders
 
 ## Purpose
 
diff --git a/docs/features/capacity.md b/docs/features/capacity.md
index 4f7374f9..b3bf40d9 100644
--- a/docs/features/capacity.md
+++ b/docs/features/capacity.md
@@ -2,11 +2,12 @@
 
 > Velocity · Feature ID `Capacity` · disabled by default · authoritative admission control
 
-Capacity decides whether a proxy login or backend connection may start. It applies proxy,
-gameplay, group, server, reserved-slot and server-state rules in memory and creates a short-lived
-lease before Velocity starts the connection.
+Capacity is the single authority for proxy login and backend admission. It combines numeric limits,
+reserved slots, server states and Queue integration before Velocity starts a connection.
 
-Paper's local player limit remains an emergency resource ceiling, not the normal network limit.
+The feature is intentionally small operationally: administrators can inspect the current state,
+change live slot limits, change per-server queueability, set temporary server states and reload the
+YAML policy. Topology and safety tuning remain configuration-only.
 
 ## Storage and authority
 
@@ -16,91 +17,126 @@ Capacity has no database support and creates no tables or views. Its only persis
 plugins/proxyfeatures/features/Capacity/config.yml
 ```
 
-The YAML file is always authoritative:
+The YAML file is authoritative:
 
-- startup loads configuration and manual states directly from `config.yml`;
-- `/capacity config ...` writes the changed configuration back to `config.yml`;
-- `/capacity state ...` writes or removes a manual state under `manual_states`;
-- `/capacity reload` reloads all Capacity settings and manual states from `config.yml`;
-- Redis snapshots remain observational and do not store or authorize Capacity state.
+- startup loads the complete policy and manual states from `config.yml`;
+- slot and queueability commands save their result to `config.yml` before applying it;
+- state commands save manual state claims under `manual_states`;
+- `/capacity reload` atomically validates and applies topology, timings, integrations, messaging and
+  manual states from YAML;
+- an invalid reload is rejected and the last valid in-memory policy remains active;
+- Redis snapshots are observational and never authorize admissions.
 
-There is no SystemData connection, ORM context, SQL migration, revision history, rollback, audit,
-runtime table, metric table, database view or database fallback.
+## Configuration model
 
-## Requirements
+An admission can be constrained by all applicable scopes:
 
-- one Velocity proxy process as the Capacity authority;
-- Queue loaded after Capacity when Queue is enabled;
-- Redis messaging only when backend Capacity placeholders are wanted.
-
-DataProvider and MySQL are not required by Capacity itself.
+```text
+proxy
+AND gameplay
+AND group
+AND exact server
+```
 
-## Configuration structure
+A capacity of `0` disables that numeric scope. Reserved slots remain inside the absolute capacity;
+they never increase it. Negative values and `reserved_slots` values greater than `capacity` are
+invalid rather than silently corrected.
 
-The generated config contains the complete policy:
+Groups add one shared constraint over a set of servers. The group owns its membership:
 
 ```yaml
-enabled: false
-
-global:
-  proxy:
-    capacity: 600
-    reserved_slots: 10
-  gameplay:
-    capacity: 500
+groups:
+  survival:
+    capacity: 250
     reserved_slots: 10
+    servers:
+      - survival
+      - survival1
+      - survival2
+```
 
-leases:
-  ttl_millis: 15000
-  login_ttl_millis: 20000
+There is deliberately no `group` property below an individual server. A server may occur in at most
+one `groups.<name>.servers` list. Duplicate membership, duplicate identifiers after normalization,
+blank members and malformed lists are rejected during startup and reload.
 
-reconciliation:
-  interval_seconds: 5
+Exact-server policy is independent from group membership:
 
-integrations:
-  maintenance_sync_interval_millis: 500
+```yaml
+servers:
+  survival:
+    capacity: 100
+    reserved_slots: 5
+    counts_toward_gameplay: true
+    queueable: true
+    initial_state: OPEN
+
+  queue:
+    capacity: 0
+    reserved_slots: 0
+    counts_toward_gameplay: false
+    queueable: false
+    initial_state: OPEN
+```
 
-queue:
-  on_full: true
+A server can be listed only in a group, only in `servers`, or in both. Group-only servers inherit the
+unknown-server exact policy while still counting against the group. Server-only entries have no
+group constraint. Configured servers remain visible in Capacity snapshots and `/capacity info` even
+while they are not currently registered or online in Velocity.
 
-failure:
-  fail_open_on_internal_error: false
+Configuration values are type-strict. Booleans must be YAML booleans, capacities and durations must
+be integer values, and identifiers cannot contain whitespace, control characters or `|`.
 
-restart_return:
-  use_reserved_slots: true
+Topology and non-operational behavior are edited in YAML and applied with `/capacity reload`:
 
-unknown_servers:
-  counts_toward_gameplay: true
-  queueable: false
-  capacity: 0
-  reserved_slots: 0
+- group creation, deletion and membership;
+- `counts_toward_gameplay` and `initial_state`;
+- unknown-server policy;
+- lease and reconciliation timings;
+- Maintenance and Restart integration behavior;
+- fail-open behavior and Redis snapshot channel, publisher and interval settings.
+
+## Commands
 
-groups: {}
-servers: {}
-manual_states: {}
+Aliases:
+
+```text
+/capacity
+/cap
 ```
 
-Groups and servers are normal YAML maps. A command that adds, changes or deletes one rewrites those
-maps in the same file. Default group/server maps are injected only when the complete section is
-missing, so an intentionally deleted entry is not recreated on the next startup.
+Inspection:
 
-## Capacity scopes
+```text
+/capacity status
+/capacity status group <group>
+/capacity info <server>
+```
 
-An admission can be constrained by:
+`status` shows the proxy and gameplay scopes. `status group` shows a shared group constraint.
+`info` shows the exact-server scope, its group scope when applicable, queueability, gameplay
+participation, configured initial state, effective state and any manual state claim.
+
+Operational changes:
 
 ```text
-proxy hard limit
-AND gameplay-global limit
-AND optional group limit
-AND optional exact-server limit
+/capacity slots proxy <capacity> [reserved]
+/capacity slots gameplay <capacity> [reserved]
+/capacity slots group <group> <capacity> [reserved]
+/capacity slots server <server> <capacity> [reserved]
+/capacity queueable <server> <true|false>
+/capacity state <server> <open|draining|closed|offline|clear> [duration] [reason]
+/capacity reload
 ```
 
-A capacity of `0` disables only that numeric scope. Server states are independent of numeric
-capacity: a server with no configured numeric limit is still blocked when its effective state is
-not `OPEN`.
+Command arity is strict: trailing or incomplete arguments are rejected instead of being ignored.
+When `reserved` is omitted from a slots command, the current value is retained and clamped to the new
+capacity. Lowering a limit never kicks players; it blocks new positive-scope admissions until usage
+returns below the limit. Raising a limit or reloading a more permissive policy wakes affected queues
+immediately.
 
-Connected players, pending leases and restart restoration reservations are counted together.
-Reserved slots stay inside the absolute capacity; they never increase it.
+The command interface cannot create groups, move servers between groups, change timing internals,
+change failure policy or mutate unknown-server behavior. Edit `config.yml` and reload for those
+changes.
 
 ## Server states
 
@@ -114,28 +150,12 @@ The most restrictive owner wins. Owners include the configured initial state, th
 Maintenance and Restart.
 
 - `OPEN`: new connections are allowed when numeric capacity permits.
-- `DRAINING`: new normal connections are blocked; players already on the server stay connected.
-- `CLOSED`: new normal connections are blocked; players already on the server stay connected.
-- `OFFLINE`: new normal connections are blocked; players already on the server stay connected.
-
-Capacity is an admission controller and deliberately does not move or disconnect existing players.
-Maintenance and Restart retain their controlled evacuation/reconnect workflows. A state-bypass
-permission can enter restrictive states; existing prepared non-bypass leases are revoked when a
-state becomes restrictive.
-
-Manual state commands persist readable YAML such as:
-
-```yaml
-manual_states:
-  survival:
-    state: DRAINING
-    expires_at: '2026-08-04T12:00:00Z'
-    reason: Deploying update
-    actor: AdminName
-```
+- `DRAINING`: new normal connections are blocked; connected players remain.
+- `CLOSED`: new normal connections are blocked; connected players remain.
+- `OFFLINE`: new normal connections are blocked; connected players remain.
 
-For a permanent state, `expires_at` is `permanent`. Expired entries are removed from the config when
-Capacity loads them or when the expiry task runs.
+Capacity is an admission controller. It does not move or disconnect existing players. Maintenance
+and Restart retain ownership of their controlled evacuation and reconnect workflows.
 
 Examples:
 
@@ -146,87 +166,30 @@ Examples:
 /capacity state survival clear
 ```
 
-Using `open` is equivalent to `clear`: it removes only the manual owner. Another owner or a
-restrictive configured initial state may therefore keep the effective state restrictive.
-
-## Commands
-
-Aliases:
-
-```text
-/capacity
-/cap
-```
-
-Inspection:
-
-```text
-/capacity status
-/capacity status group <group>
-/capacity info <server>
-/capacity config show
-```
-
-`info` reports occupancy, pending leases, restoration reservations, limits, effective state, state
-behavior and the current manual claim.
-
-Configuration:
-
-```text
-/capacity config proxy <capacity> <reserved> [--confirm]
-/capacity config gameplay <capacity> <reserved> [--confirm]
-/capacity config group <group> limit <capacity> <reserved> [--confirm]
-/capacity config group <group> add-server <server> [--confirm]
-/capacity config group <group> remove-server <server> [--confirm]
-/capacity config group <group> delete --confirm
-/capacity config server <server> limit <capacity> <reserved> [--confirm]
-/capacity config server <server> group <group|none> [--confirm]
-/capacity config server <server> gameplay <true|false> [--confirm]
-/capacity config server <server> queueable <true|false>
-/capacity config server <server> initial-state <open|draining|closed|offline> --confirm
-/capacity config server <server> delete --confirm
-/capacity config unknown limit <capacity> <reserved> [--confirm]
-/capacity config unknown gameplay <true|false>
-/capacity config unknown queueable <true|false>
-/capacity config option <option> <value> [--confirm]
-/capacity reload
-```
-
-Supported options:
-
-```text
-lease-ttl
-login-ttl
-reconciliation
-maintenance-sync
-queue-on-full
-fail-open
-restart-reserved
-```
-
-Every successful mutation is saved to `config.yml` before the new in-memory policy is applied.
-Risky changes require the dangerous permission and `--confirm`. Lowering a limit never kicks
-players; it blocks positive-scope admissions until usage returns below the limit.
+Using `open` is equivalent to `clear`: it removes only the manual owner. A restrictive initial state,
+Maintenance claim or Restart claim may still keep the effective state restrictive. Clearing a server
+without a manual state reports that nothing changed instead of claiming a state was removed.
 
 ## Fixed permissions
 
-Permission nodes are code constants and are not configurable:
+Permission nodes are constants and are not configurable:
 
 | Permission | Purpose |
 |---|---|
 | `proxyfeatures.feature.capacity.reserved` | May consume reserved capacity. |
-| `proxyfeatures.feature.capacity.bypass.capacity` | Bypasses numeric Capacity limits. |
+| `proxyfeatures.feature.capacity.bypass.capacity` | Bypasses numeric limits. |
 | `proxyfeatures.feature.capacity.bypass.state` | Bypasses restrictive server states. |
 | `proxyfeatures.feature.capacity.admin` | Grants all Capacity administration. |
-| `proxyfeatures.feature.capacity.admin.view` | Status, info and config display. |
+| `proxyfeatures.feature.capacity.admin.view` | Status and info. |
 | `proxyfeatures.feature.capacity.admin.state` | Set and clear manual server states. |
-| `proxyfeatures.feature.capacity.admin.config` | Change and reload current configuration. |
-| `proxyfeatures.feature.capacity.admin.dangerous` | Confirm risky configuration changes. |
+| `proxyfeatures.feature.capacity.admin.config` | Change slots/queueability and reload YAML. |
+
+The root command and tab completion expose only operations permitted to the command source.
 
 ## Queue, Maintenance and Restart
 
-Queue never computes capacity independently. It may queue only ordinary `FULL` outcomes and every
-advancement must acquire a Capacity lease again.
+Queue never computes capacity independently. It may queue only ordinary `FULL` outcomes, only when
+the exact target is queueable, and every advancement must acquire a Capacity lease again.
 
 Maintenance contributes a `CLOSED` claim. Restart contributes a `DRAINING` claim and restoration
 reservations. Opening a manual claim cannot override either feature because the most restrictive
@@ -234,6 +197,7 @@ owner wins.
 
 ## Redis snapshot feed
 
-Capacity publishes its current in-memory snapshot to the configured Redis channel for
-ServerFeatures placeholders. This feed is observational and is not used to authorize admissions.
-A failed publication does not affect Capacity decisions.
+Capacity publishes its current in-memory snapshot for ServerFeatures placeholders. Publication is
+observational only. Redis failure does not alter admission decisions. A reload reconfigures the
+publisher when its channel, publisher ID or interval changes and keeps the existing publisher when
+those values are unchanged.
diff --git a/proxyfeatures-platform-acceptance/run-platform-acceptance.sh b/proxyfeatures-platform-acceptance/run-platform-acceptance.sh
index 5f8d2b40..10a31525 100644
--- a/proxyfeatures-platform-acceptance/run-platform-acceptance.sh
+++ b/proxyfeatures-platform-acceptance/run-platform-acceptance.sh
@@ -57,6 +57,44 @@ wait_for_file_absence() {
     done
     fail "$description"
 }
+wait_for_server_value() {
+    local file=$1 server=$2 key=$3 expected=$4 description=$5 deadline=$((SECONDS + 30))
+    while (( SECONDS < deadline )); do
+        if [[ -f "$file" ]] && [[ "$(awk -v server="$server" -v key="$key" '
+            function indentation(line, stripped) {
+                stripped = line
+                sub(/^[[:space:]]*/, "", stripped)
+                return length(line) - length(stripped)
+            }
+            {
+                raw = $0
+                stripped = $0
+                sub(/^[[:space:]]*/, "", stripped)
+            }
+            !in_servers && indentation(raw) == 0 && stripped == "servers:" {
+                in_servers = 1
+                section_indent = indentation(raw)
+                next
+            }
+            in_servers && stripped != "" && indentation(raw) <= section_indent { exit }
+            in_servers && !inside && stripped == server ":" {
+                inside = 1
+                server_indent = indentation(raw)
+                next
+            }
+            inside && stripped != "" && indentation(raw) <= server_indent { exit }
+            inside && stripped ~ ("^" key ":[[:space:]]*") {
+                sub("^" key ":[[:space:]]*", "", stripped)
+                print stripped
+                exit
+            }
+        ' "$file")" == "$expected" ]]; then
+            return
+        fi
+        sleep 1
+    done
+    fail "$description"
+}
 mysql_scalar() {
     local sql=$1
     docker compose --file "$compose_file" exec -T mysql \
@@ -105,7 +143,7 @@ printf '%s\n' \
     >"$work_directory/velocity/plugins/dataprovider/config.yml"
 
 # Capacity is deliberately enabled without a SystemData connection. Acceptance covers
-# YAML-only startup, command persistence, manual states, reload and shutdown.
+# YAML-only startup, operational command persistence, manual states, reload and shutdown.
 printf '%s\n' 'enabled: true' \
     >"$work_directory/velocity/plugins/proxyfeatures/features/Capacity/config.yml"
 
@@ -139,12 +177,15 @@ wait_for_log "$work_directory/velocity/velocity.log" 'Capacity started with conf
 [[ "$(mysql_scalar 'SELECT COUNT(*) FROM information_schema.VIEWS WHERE TABLE_SCHEMA = "minecraft" AND TABLE_NAME LIKE "vw_capacity_%"')" == "0" ]] \
     || fail "Capacity created database views despite being config-only."
 
-printf 'capacity config proxy 610 11\n' >&"$velocity_input_fd"
-wait_for_log "$work_directory/velocity/velocity.log" 'Capacity-configuratie is opgeslagen in config.yml'
+printf 'capacity slots proxy 610 11\n' >&"$velocity_input_fd"
 wait_for_file_pattern "$capacity_config" '^[[:space:]]*capacity:[[:space:]]*610[[:space:]]*$' \
-    'Capacity config command did not persist proxy capacity to config.yml'
+    'Capacity slots command did not persist proxy capacity to config.yml'
 wait_for_file_pattern "$capacity_config" '^[[:space:]]*reserved_slots:[[:space:]]*11[[:space:]]*$' \
-    'Capacity config command did not persist reserved slots to config.yml'
+    'Capacity slots command did not persist reserved slots to config.yml'
+
+printf 'capacity queueable survival false\n' >&"$velocity_input_fd"
+wait_for_server_value "$capacity_config" survival queueable false \
+    'Capacity queueable command did not persist the survival policy to config.yml'
 
 printf 'capacity state survival draining 10m acceptance-manual-state\n' >&"$velocity_input_fd"
 wait_for_file_pattern "$capacity_config" '^[[:space:]]*state:[[:space:]]*DRAINING[[:space:]]*$' \
diff --git a/proxyfeatures-platform-velocity/src/main/java/nl/hauntedmc/proxyfeatures/features/capacity/Capacity.java b/proxyfeatures-platform-velocity/src/main/java/nl/hauntedmc/proxyfeatures/features/capacity/Capacity.java
index 0683d334..862042a8 100644
--- a/proxyfeatures-platform-velocity/src/main/java/nl/hauntedmc/proxyfeatures/features/capacity/Capacity.java
+++ b/proxyfeatures-platform-velocity/src/main/java/nl/hauntedmc/proxyfeatures/features/capacity/Capacity.java
@@ -1,5 +1,6 @@
 package nl.hauntedmc.proxyfeatures.features.capacity;
 
+import com.velocitypowered.api.scheduler.ScheduledTask;
 import nl.hauntedmc.dataprovider.database.messaging.MessagingDataAccess;
 import nl.hauntedmc.proxyfeatures.api.capacity.CapacityAPI;
 import nl.hauntedmc.proxyfeatures.api.io.config.ConfigMap;
@@ -23,14 +24,15 @@
 import java.util.Optional;
 
 public final class Capacity extends VelocityBaseFeature<Meta> {
-    static final String DEFAULT_SNAPSHOT_CHANNEL = "proxy.capacity.snapshot";
-    static final int DEFAULT_PUBLISH_INTERVAL_SECONDS = 2;
-    static final String DEFAULT_PUBLISHER_ID = "proxy";
-
     private CapacityService service;
     private CapacityIntegrationSynchronizer integrationSynchronizer;
     private CapacityControlPlane controlPlane;
+    private MessagingDataAccess snapshotBus;
     private CapacitySnapshotPublisher snapshotPublisher;
+    private ScheduledTask snapshotTask;
+    private String snapshotChannel;
+    private String snapshotPublisherId;
+    private int snapshotIntervalSeconds;
 
     public Capacity(FeatureContext<Meta> context) {
         super(context);
@@ -45,9 +47,12 @@ public ConfigMap getDefaultConfig() {
         config.put("leases.login_ttl_millis", 20000L);
         config.put("reconciliation.interval_seconds", 5L);
         config.put("integrations.maintenance_sync_interval_millis", 500L);
-        config.put("messaging.channel", DEFAULT_SNAPSHOT_CHANNEL);
-        config.put("messaging.publish_interval_seconds", DEFAULT_PUBLISH_INTERVAL_SECONDS);
-        config.put("messaging.publisher_id", DEFAULT_PUBLISHER_ID);
+        config.put("messaging.channel", CapacityConfig.DEFAULT_SNAPSHOT_CHANNEL);
+        config.put(
+                "messaging.publish_interval_seconds",
+                CapacityConfig.DEFAULT_SNAPSHOT_INTERVAL_SECONDS
+        );
+        config.put("messaging.publisher_id", CapacityConfig.DEFAULT_SNAPSHOT_PUBLISHER_ID);
         config.put("queue.on_full", true);
         config.put("failure.fail_open_on_internal_error", false);
         config.put("restart_return.use_reserved_slots", true);
@@ -83,15 +88,15 @@ private static Map<String, Object> groupDefaults() {
 
     private static Map<String, Object> serverDefaults() {
         Map<String, Object> servers = new LinkedHashMap<>();
-        servers.put("lobby", server("lobby", true, false));
-        servers.put("survival", server("survival", true, true));
-        servers.put("skyblock", server("", true, true));
-        servers.put("creative", server("", true, true));
-        servers.put("kitpvp", server("", true, true));
-        servers.put("minigames", server("", true, true));
-        servers.put("queue", server("", false, false));
-        servers.put("limbo", server("", false, false));
-        servers.put("twofactor", server("", false, false));
+        servers.put("lobby", server(true, false));
+        servers.put("survival", server(true, true));
+        servers.put("skyblock", server(true, true));
+        servers.put("creative", server(true, true));
+        servers.put("kitpvp", server(true, true));
+        servers.put("minigames", server(true, true));
+        servers.put("queue", server(false, false));
+        servers.put("limbo", server(false, false));
+        servers.put("twofactor", server(false, false));
         return servers;
     }
 
@@ -101,11 +106,10 @@ private static Map<String, Object> group(List<String> servers) {
         return group;
     }
 
-    private static Map<String, Object> server(String group,
-                                              boolean countsTowardGameplay,
-                                              boolean queueable) {
+    private static Map<String, Object> server(
+            boolean countsTowardGameplay,
+            boolean queueable) {
         Map<String, Object> server = limit(0, 0);
-        server.put("group", group);
         server.put("counts_toward_gameplay", countsTowardGameplay);
         server.put("queueable", queueable);
         server.put("initial_state", "OPEN");
@@ -122,42 +126,70 @@ private static Map<String, Object> limit(int capacity, int reserved) {
     @Override
     public MessageMap getDefaultMessages() {
         MessageMap messages = new MessageMap();
-        messages.add("capacity.login.full", "&cHet netwerk heeft momenteel zijn maximale capaciteit bereikt. Probeer het later opnieuw.");
-        messages.add("capacity.login.internal_error", "&cDe netwerkcapaciteit kon niet veilig worden gecontroleerd. Probeer het later opnieuw.");
-        messages.add("capacity.join.full", "&eEr is momenteel geen plek beschikbaar op &f{server}&e. (&7{scope}&e)");
-        messages.add("capacity.join.unavailable", "&cServer &f{server}&c accepteert momenteel geen nieuwe verbindingen.");
+        messages.add("capacity.login.full",
+                "&cHet netwerk heeft momenteel zijn maximale capaciteit bereikt. Probeer het later opnieuw.");
+        messages.add("capacity.login.internal_error",
+                "&cDe netwerkcapaciteit kon niet veilig worden gecontroleerd. Probeer het later opnieuw.");
+        messages.add("capacity.join.full",
+                "&eEr is momenteel geen plek beschikbaar op &f{server}&e. (&7{scope}&e)");
+        messages.add("capacity.join.unavailable",
+                "&cServer &f{server}&c accepteert momenteel geen nieuwe verbindingen.");
         messages.add("capacity.join.unknown", "&cServer &f{server}&c is niet beschikbaar.");
-        messages.add("capacity.join.internal_error", "&cJe verbinding met &f{server}&c kon niet veilig worden voorbereid.");
-        messages.add("capacity.command.usage", "&eGebruik: /capacity <status|info|config|state|reload>");
-        messages.add("capacity.command.config_usage", "&eGebruik: /capacity config <show|proxy|gameplay|group|server|unknown|option> ...");
-        messages.add("capacity.command.no_permission", "&cJe hebt geen toestemming voor deze Capacity-actie.");
+        messages.add("capacity.join.internal_error",
+                "&cJe verbinding met &f{server}&c kon niet veilig worden voorbereid.");
+        messages.add("capacity.command.usage",
+                "&eGebruik: /capacity <status|info|slots|queueable|state|reload>");
+        messages.add("capacity.command.no_permission",
+                "&cJe hebt geen toestemming voor deze Capacity-actie.");
         messages.add("capacity.command.status.header", "&aCapacity status:");
-        messages.add("capacity.command.status.scope", "&7{scope}: &f{occupied}&7 online + &f{pending}&7 onderweg + &f{restoration}&7 gereserveerd / &f{capacity}&7 (&e{state}&7, normaal vrij &f{normal_available}&7, absoluut vrij &f{absolute_available}&7, reserved &f{reserved}&7)");
-        messages.add("capacity.command.status.footer", "&7Actieve leases: &f{leases}&7, handmatige states: &f{manual_states}");
+        messages.add("capacity.command.status.scope",
+                "&7{scope}: &f{occupied}&7 online + &f{pending}&7 onderweg + &f{restoration}&7 gereserveerd "
+                        + "/ &f{capacity}&7 (&e{state}&7, normaal vrij &f{normal_available}&7, absoluut vrij "
+                        + "&f{absolute_available}&7, reserved &f{reserved}&7)");
+        messages.add("capacity.command.status.footer",
+                "&7Groepen: &f{groups}&7, servers: &f{servers}&7, actieve leases: &f{leases}&7, "
+                        + "handmatige states: &f{manual_states}");
         messages.add("capacity.command.unknown_server", "&cOnbekende server: &f{server}");
         messages.add("capacity.command.invalid", "&cOngeldige Capacity-invoer: &f{error}");
         messages.add("capacity.command.failed", "&cCapacity-actie mislukt: &f{error}");
-        messages.add("capacity.command.busy", "&eCapacity verwerkt de configwijziging...");
-        messages.add("capacity.command.changed", "&aCapacity-configuratie is opgeslagen in config.yml en direct actief.");
-        messages.add("capacity.command.reloaded", "&aCapacity-configuratie en handmatige states zijn opnieuw uit config.yml geladen.");
-        messages.add("capacity.command.state_set", "&aHandmatige state voor &f{server}&a is &f{requested}&a; effectieve state is &f{effective}&a, verloop: &f{expiry}&a. &7{effect}.");
-        messages.add("capacity.command.state_cleared", "&aHandmatige state voor &f{server}&a is verwijderd; effectieve state is &f{effective}&a. &7{effect}.");
+        messages.add("capacity.command.busy", "&eCapacity verwerkt de wijziging...");
+        messages.add("capacity.command.slots_changed",
+                "&aSlots voor &f{scope}&a zijn ingesteld op &f{capacity}&a, waarvan &f{reserved}&a reserved.");
+        messages.add("capacity.command.queueable_changed",
+                "&aQueueability voor &f{server}&a is ingesteld op &f{queueable}&a.");
+        messages.add("capacity.command.reloaded",
+                "&aCapacity-configuratie en handmatige states zijn opnieuw uit config.yml geladen.");
+        messages.add("capacity.command.state_set",
+                "&aHandmatige state voor &f{server}&a is &f{requested}&a; effectieve state is "
+                        + "&f{effective}&a, verloop: &f{expiry}&a. &7{effect}.");
+        messages.add("capacity.command.state_cleared",
+                "&aHandmatige state voor &f{server}&a is verwijderd; effectieve state is "
+                        + "&f{effective}&a. &7{effect}.");
+        messages.add("capacity.command.state_unchanged",
+                "&eEr was geen handmatige state voor &f{server}&e; effectieve state is "
+                        + "&f{effective}&e. &7{effect}.");
         messages.add("capacity.command.state_behavior", "&7Gedrag: &f{effect}&7.");
-        messages.add("capacity.command.config.header", "&aCapacity configuratie:");
-        messages.add("capacity.command.config.global", "&7Proxy &f{proxy_capacity}&7/&f{proxy_reserved}&7 reserved; gameplay &f{gameplay_capacity}&7/&f{gameplay_reserved}&7 reserved; queue-on-full=&f{queue_on_full}&7; fail-open=&f{fail_open}");
-        messages.add("capacity.command.config.counts", "&7Groepen: &f{groups}&7; expliciete servers: &f{servers}");
+        messages.add("capacity.command.info.policy",
+                "&7Beleid: groep=&f{group}&7, gameplay=&f{gameplay}&7, queueable=&f{queueable}&7, "
+                        + "initial-state=&f{initial_state}&7.");
+        messages.add("capacity.command.info.manual",
+                "&7Handmatig: state=&f{state}&7, verloop=&f{expiry}&7, reden=&f{reason}&7, actor=&f{actor}&7.");
         return messages;
     }
 
     @Override
     public void initialize() {
         CapacityConfigStore store = new CapacityConfigStore(this);
-        CapacityConfig configuration = store.loadConfiguration();
-        List<CapacityConfigStore.ManualStateRecord> manualStates = store.loadManualStates();
+        CapacityConfigStore.StoredPolicy stored = store.loadPolicy();
 
-        service = new CapacityService(this);
-        controlPlane = new CapacityControlPlane(this, service, store, configuration);
-        controlPlane.start(manualStates);
+        service = new CapacityService(this, stored.configuration());
+        controlPlane = new CapacityControlPlane(
+                this,
+                service,
+                store,
+                stored.configuration()
+        );
+        controlPlane.start(stored.manualStates());
 
         integrationSynchronizer = new CapacityIntegrationSynchronizer(this, service);
         integrationSynchronizer.start();
@@ -166,13 +198,14 @@ public void initialize() {
         getLifecycleManager().getApiManager().registerService(CapacityAPI.class, service);
         getLifecycleManager().getListenerManager().registerListener(new CapacityListener(this, service));
         getLifecycleManager().getCommandManager().registerFeatureCommand(
-                new CapacityCommand(this, service, controlPlane));
+                new CapacityCommand(this, service, controlPlane)
+        );
 
-        startSnapshotPublisher();
+        initializeSnapshotPublisher();
         getLogger().info("Capacity started with config.yml as its only persistent storage.");
     }
 
-    private void startSnapshotPublisher() {
+    private void initializeSnapshotPublisher() {
         Optional<MessagingDataAccess> redisBus = registerRedisMessagingDataAccess(
                 "redis",
                 MessagingDataAccess.class
@@ -184,21 +217,41 @@ private void startSnapshotPublisher() {
             );
             return;
         }
+        snapshotBus = redisBus.get();
+        reloadSnapshotPublisher();
+    }
 
-        String channel = textSetting("messaging.channel", DEFAULT_SNAPSHOT_CHANNEL);
-        String publisherId = textSetting("messaging.publisher_id", DEFAULT_PUBLISHER_ID);
-        int intervalSeconds = positiveIntSetting(
-                "messaging.publish_interval_seconds",
-                DEFAULT_PUBLISH_INTERVAL_SECONDS
-        );
+    public synchronized void reloadRuntimeSettings() {
+        if (integrationSynchronizer != null) integrationSynchronizer.reload();
+        reloadSnapshotPublisher();
+    }
+
+    private synchronized void reloadSnapshotPublisher() {
+        if (snapshotBus == null || service == null) return;
+
+        CapacityConfig configuration = service.config();
+        String channel = configuration.snapshotChannel();
+        String publisherId = configuration.snapshotPublisherId();
+        int intervalSeconds = configuration.snapshotPublishIntervalSeconds();
+        if (snapshotPublisher != null
+                && channel.equals(snapshotChannel)
+                && publisherId.equals(snapshotPublisherId)
+                && intervalSeconds == snapshotIntervalSeconds) {
+            return;
+        }
+
+        stopSnapshotPublisher();
+        snapshotChannel = channel;
+        snapshotPublisherId = publisherId;
+        snapshotIntervalSeconds = intervalSeconds;
         snapshotPublisher = new CapacitySnapshotPublisher(
                 this,
-                redisBus.get(),
+                snapshotBus,
                 service,
                 channel,
                 publisherId
         );
-        getLifecycleManager().getTaskManager().scheduleRepeatingTask(
+        snapshotTask = getLifecycleManager().getTaskManager().scheduleRepeatingTask(
                 snapshotPublisher::publishNow,
                 Duration.ofSeconds(intervalSeconds)
         );
@@ -209,8 +262,18 @@ private void startSnapshotPublisher() {
         );
     }
 
-    public synchronized void reloadIntegrations() {
-        if (integrationSynchronizer != null) integrationSynchronizer.reload();
+    private synchronized void stopSnapshotPublisher() {
+        if (snapshotTask != null) {
+            getLifecycleManager().getTaskManager().cancelTask(snapshotTask);
+            snapshotTask = null;
+        }
+        if (snapshotPublisher != null) {
+            snapshotPublisher.close();
+            snapshotPublisher = null;
+        }
+        snapshotChannel = null;
+        snapshotPublisherId = null;
+        snapshotIntervalSeconds = 0;
     }
 
     public CapacityControlPlane controlPlane() {
@@ -219,10 +282,8 @@ public CapacityControlPlane controlPlane() {
 
     @Override
     public void disable() {
-        if (snapshotPublisher != null) {
-            snapshotPublisher.close();
-            snapshotPublisher = null;
-        }
+        stopSnapshotPublisher();
+        snapshotBus = null;
         if (controlPlane != null) {
             controlPlane.shutdown();
             controlPlane = null;
@@ -236,22 +297,4 @@ public void disable() {
             service = null;
         }
     }
-
-    private String textSetting(String key, String fallback) {
-        String configured = getConfigHandler().get(key, String.class, fallback);
-        if (configured == null || configured.isBlank()) {
-            getLogger().warn("Capacity setting '" + key + "' is blank; using '" + fallback + "'.");
-            return fallback;
-        }
-        return configured.trim();
-    }
-
-    private int positiveIntSetting(String key, int fallback) {
-        Object configured = getConfigHandler().get(key);
-        if (configured instanceof Number number && number.intValue() > 0) {
-            return number.intValue();
-        }
-        getLogger().warn("Capacity setting '" + key + "' must be positive; using " + fallback + ".");
-        return fallback;
-    }
 }
diff --git a/proxyfeatures-platform-velocity/src/main/java/nl/hauntedmc/proxyfeatures/features/capacity/command/CapacityCommand.java b/proxyfeatures-platform-velocity/src/main/java/nl/hauntedmc/proxyfeatures/features/capacity/command/CapacityCommand.java
index 3eef1b9e..c500617a 100644
--- a/proxyfeatures-platform-velocity/src/main/java/nl/hauntedmc/proxyfeatures/features/capacity/command/CapacityCommand.java
+++ b/proxyfeatures-platform-velocity/src/main/java/nl/hauntedmc/proxyfeatures/features/capacity/command/CapacityCommand.java
@@ -2,7 +2,6 @@
 
 import com.velocitypowered.api.command.CommandSource;
 import com.velocitypowered.api.proxy.Player;
-import net.kyori.adventure.text.Component;
 import nl.hauntedmc.proxyfeatures.api.capacity.CapacityScopeSnapshot;
 import nl.hauntedmc.proxyfeatures.api.capacity.CapacitySnapshot;
 import nl.hauntedmc.proxyfeatures.api.capacity.CapacityState;
@@ -17,29 +16,42 @@
 import java.time.Duration;
 import java.time.Instant;
 import java.util.ArrayList;
-import java.util.Arrays;
 import java.util.List;
 import java.util.Locale;
+import java.util.Set;
+import java.util.TreeSet;
 import java.util.concurrent.CompletableFuture;
 import java.util.concurrent.CompletionException;
+import java.util.function.Consumer;
 import java.util.function.UnaryOperator;
 
-/** Small asynchronous administration surface for the current Capacity configuration. */
+/** Small operational administration surface for Capacity. Topology remains config-only. */
 public final class CapacityCommand implements FeatureCommand {
-    private static final List<String> ROOT = List.of("status", "info", "config", "state", "reload");
-    private static final List<String> CONFIG_ROOT = List.of(
-            "show", "proxy", "gameplay", "group", "server", "unknown", "option");
-    private static final List<String> STATES = Arrays.stream(CapacityState.values())
+    private static final List<String> SLOT_SCOPES = List.of(
+            "proxy",
+            "gameplay",
+            "group",
+            "server"
+    );
+    private static final List<String> STATES = java.util.Arrays.stream(CapacityState.values())
             .map(state -> state.name().toLowerCase(Locale.ROOT))
             .toList();
 
+    private record SlotChange(
+            String scope,
+            int capacity,
+            int reserved,
+            UnaryOperator<CapacityConfig> mutation) {
+    }
+
     private final Capacity feature;
     private final CapacityService service;
     private final CapacityControlPlane controlPlane;
 
-    public CapacityCommand(Capacity feature,
-                           CapacityService service,
-                           CapacityControlPlane controlPlane) {
+    public CapacityCommand(
+            Capacity feature,
+            CapacityService service,
+            CapacityControlPlane controlPlane) {
         this.feature = feature;
         this.service = service;
         this.controlPlane = controlPlane;
@@ -65,49 +77,67 @@ public void execute(Invocation invocation) {
         CommandSource source = invocation.source();
         String[] args = invocation.arguments();
         try {
-            if (args.length == 0 || equals(args[0], "status")) {
-                status(source, args);
+            if (args.length == 0) {
+                if (permitted(source, CapacityConfig.ADMIN_VIEW_PERMISSION)) {
+                    status(source, args);
+                } else {
+                    message(source, "capacity.command.usage");
+                }
                 return;
             }
-            switch (args[0].toLowerCase(Locale.ROOT)) {
+            switch (normalize(args[0])) {
+                case "status" -> status(source, args);
                 case "info" -> info(source, args);
-                case "config" -> config(source, args);
+                case "slots" -> slots(source, args);
+                case "queueable" -> queueable(source, args);
                 case "state" -> state(source, args);
-                case "reload" -> reload(source);
+                case "reload" -> reload(source, args);
                 default -> message(source, "capacity.command.usage");
             }
         } catch (CommandHandledException ignored) {
             // A precise localized response has already been sent.
         } catch (IllegalArgumentException exception) {
             invalid(source, exception.getMessage());
+        } catch (RuntimeException exception) {
+            failed(source, exception);
         }
     }
 
     private void status(CommandSource source, String[] args) {
         require(source, CapacityConfig.ADMIN_VIEW_PERMISSION);
         CapacitySnapshot snapshot = service.snapshot();
-        if (args.length >= 3 && equals(args[1], "group")) {
-            CapacityScopeSnapshot group = snapshot.groups().get(normalize(args[2]));
+        if (args.length == 0 || args.length == 1) {
+            message(source, "capacity.command.status.header");
+            sendScope(source, "proxy", snapshot.proxy());
+            sendScope(source, "gameplay", snapshot.gameplay());
+            source.sendMessage(feature.getLocalizationHandler()
+                    .getMessage("capacity.command.status.footer")
+                    .with("groups", snapshot.groups().size())
+                    .with("servers", snapshot.servers().size())
+                    .with("leases", snapshot.activeLeases())
+                    .with("manual_states", controlPlane.manualStates().size())
+                    .forAudience(source)
+                    .build());
+            return;
+        }
+        if (args.length == 3 && equals(args[1], "group")) {
+            String groupName = normalize(args[2]);
+            CapacityScopeSnapshot group = snapshot.groups().get(groupName);
             if (group == null) throw new IllegalArgumentException("Onbekende groep: " + args[2]);
-            sendScope(source, "group:" + normalize(args[2]), group);
+            sendScope(source, "group:" + groupName, group);
             return;
         }
-        message(source, "capacity.command.status.header");
-        sendScope(source, "proxy", snapshot.proxy());
-        sendScope(source, "gameplay", snapshot.gameplay());
-        source.sendMessage(feature.getLocalizationHandler()
-                .getMessage("capacity.command.status.footer")
-                .with("leases", snapshot.activeLeases())
-                .with("manual_states", controlPlane.manualStates().size())
-                .forAudience(source)
-                .build());
+        throw new IllegalArgumentException(
+                "Gebruik: /capacity status [group <group>]"
+        );
     }
 
     private void info(CommandSource source, String[] args) {
         require(source, CapacityConfig.ADMIN_VIEW_PERMISSION);
-        if (args.length < 2) throw new IllegalArgumentException("Servernaam ontbreekt.");
+        requireArgumentCount(args, 2, "Gebruik: /capacity info <server>");
         String server = normalize(args[1]);
-        CapacityScopeSnapshot snapshot = service.snapshot().servers().get(server);
+        CapacitySnapshot complete = service.snapshot();
+        CapacityScopeSnapshot snapshot = complete.servers().get(server);
         if (snapshot == null) {
             source.sendMessage(feature.getLocalizationHandler()
                     .getMessage("capacity.command.unknown_server")
@@ -116,7 +146,21 @@ private void info(CommandSource source, String[] args) {
                     .build());
             return;
         }
+
+        CapacityConfig.ServerRule rule = controlPlane.config().server(server);
         sendScope(source, "server:" + server, snapshot);
+        if (!rule.group().isBlank()) {
+            CapacityScopeSnapshot group = complete.groups().get(rule.group());
+            if (group != null) sendScope(source, "group:" + rule.group(), group);
+        }
+        source.sendMessage(feature.getLocalizationHandler()
+                .getMessage("capacity.command.info.policy")
+                .with("group", rule.group().isBlank() ? "none" : rule.group())
+                .with("gameplay", rule.countsTowardGameplay())
+                .with("queueable", rule.queueable())
+                .with("initial_state", rule.initialState().name())
+                .forAudience(source)
+                .build());
         source.sendMessage(feature.getLocalizationHandler()
                 .getMessage("capacity.command.state_behavior")
                 .with("effect", stateEffect(snapshot.state()))
@@ -125,206 +169,143 @@ private void info(CommandSource source, String[] args) {
         controlPlane.manualStates().stream()
                 .filter(state -> state.server().equals(server))
                 .findFirst()
-                .ifPresent(state -> source.sendMessage(Component.text(
-                        "Manual: " + state.state() + ", expires=" + format(state.expiresAt())
-                                + ", reason=" + state.reason() + ", actor=" + state.actorName())));
+                .ifPresent(state -> source.sendMessage(feature.getLocalizationHandler()
+                        .getMessage("capacity.command.info.manual")
+                        .with("state", state.state().name())
+                        .with("expiry", format(state.expiresAt()))
+                        .with("reason", state.reason())
+                        .with("actor", state.actorName())
+                        .forAudience(source)
+                        .build()));
     }
 
-    private void config(CommandSource source, String[] args) {
-        if (args.length < 2 || equals(args[1], "show")) {
-            showConfig(source);
-            return;
-        }
+    private void slots(CommandSource source, String[] args) {
         require(source, CapacityConfig.ADMIN_CONFIG_PERMISSION);
-        switch (args[1].toLowerCase(Locale.ROOT)) {
-            case "proxy" -> limit(source, args, "proxy");
-            case "gameplay" -> limit(source, args, "gameplay");
-            case "group" -> group(source, args);
-            case "server" -> server(source, args);
-            case "unknown" -> unknown(source, args);
-            case "option" -> option(source, args);
-            default -> message(source, "capacity.command.config_usage");
+        if (args.length < 3) {
+            throw new IllegalArgumentException(
+                    "Gebruik: /capacity slots <proxy|gameplay|group|server> ..."
+            );
         }
-    }
 
-    private void showConfig(CommandSource source) {
-        require(source, CapacityConfig.ADMIN_VIEW_PERMISSION);
         CapacityConfig config = controlPlane.config();
-        message(source, "capacity.command.config.header");
-        source.sendMessage(feature.getLocalizationHandler()
-                .getMessage("capacity.command.config.global")
-                .with("proxy_capacity", config.proxy().capacity())
-                .with("proxy_reserved", config.proxy().reservedSlots())
-                .with("gameplay_capacity", config.gameplay().capacity())
-                .with("gameplay_reserved", config.gameplay().reservedSlots())
-                .with("queue_on_full", config.queueOnFull())
-                .with("fail_open", config.failOpenOnInternalError())
-                .forAudience(source)
-                .build());
-        source.sendMessage(feature.getLocalizationHandler()
-                .getMessage("capacity.command.config.counts")
-                .with("groups", config.groups().size())
-                .with("servers", config.servers().size())
-                .forAudience(source)
-                .build());
-    }
+        SlotChange change = switch (normalize(args[1])) {
+            case "proxy" -> globalSlotChange(args, config, true);
+            case "gameplay" -> globalSlotChange(args, config, false);
+            case "group" -> groupSlotChange(args, config);
+            case "server" -> serverSlotChange(args, config);
+            default -> throw new IllegalArgumentException(
+                    "Onbekend slots-bereik: " + args[1]
+            );
+        };
 
-    private void limit(CommandSource source, String[] args, String scope) {
-        if (args.length < 4) {
-            throw new IllegalArgumentException("Gebruik: /capacity config " + scope
-                    + " <capacity> <reserved> [--confirm]");
-        }
+        mutate(source, change.mutation(), audience -> audience.sendMessage(
+                feature.getLocalizationHandler()
+                        .getMessage("capacity.command.slots_changed")
+                        .with("scope", change.scope())
+                        .with("capacity", change.capacity())
+                        .with("reserved", change.reserved())
+                        .forAudience(audience)
+                        .build()
+        ));
+    }
+
+    private SlotChange globalSlotChange(
+            String[] args,
+            CapacityConfig config,
+            boolean proxyScope) {
+        requireArgumentRange(
+                args,
+                3,
+                4,
+                "Gebruik: /capacity slots " + (proxyScope ? "proxy" : "gameplay")
+                        + " <capacity> [reserved]"
+        );
+        CapacityConfig.Limit current = proxyScope ? config.proxy() : config.gameplay();
         int capacity = number(args[2], "capacity");
-        int reserved = number(args[3], "reserved");
-        CapacityScopeSnapshot currentScope = scope.equals("proxy")
-                ? service.snapshot().proxy() : service.snapshot().gameplay();
-        boolean dangerous = capacity > 0 && capacity < currentScope.effectiveUsed();
-        UnaryOperator<CapacityConfig> mutation = scope.equals("proxy")
-                ? config -> CapacityConfigEditor.proxyLimit(config, capacity, reserved)
-                : config -> CapacityConfigEditor.gameplayLimit(config, capacity, reserved);
-        mutate(source, args, dangerous, mutation);
-    }
-
-    private void group(CommandSource source, String[] args) {
-        if (args.length < 4) {
-            throw new IllegalArgumentException(
-                    "Gebruik: /capacity config group <group> <limit|add-server|remove-server|delete> ...");
-        }
+        int reserved = reserved(args, 3, current, capacity);
+        UnaryOperator<CapacityConfig> mutation = proxyScope
+                ? value -> CapacityConfigEditor.proxyLimit(value, capacity, reserved)
+                : value -> CapacityConfigEditor.gameplayLimit(value, capacity, reserved);
+        return new SlotChange(
+                proxyScope ? "proxy" : "gameplay",
+                capacity,
+                reserved,
+                mutation
+        );
+    }
+
+    private SlotChange groupSlotChange(String[] args, CapacityConfig config) {
+        requireArgumentRange(
+                args,
+                4,
+                5,
+                "Gebruik: /capacity slots group <group> <capacity> [reserved]"
+        );
         String group = normalize(args[2]);
-        String action = args[3].toLowerCase(Locale.ROOT);
-        switch (action) {
-            case "limit" -> {
-                if (args.length < 6) throw new IllegalArgumentException("Capacity en reserved ontbreken.");
-                int capacity = number(args[4], "capacity");
-                int reserved = number(args[5], "reserved");
-                CapacityScopeSnapshot scope = service.snapshot().groups().get(group);
-                boolean dangerous = scope != null && capacity > 0 && capacity < scope.effectiveUsed();
-                mutate(source, args, dangerous,
-                        config -> CapacityConfigEditor.groupLimit(config, group, capacity, reserved));
-            }
-            case "add-server" -> {
-                if (args.length < 5) throw new IllegalArgumentException("Servernaam ontbreekt.");
-                String server = normalize(args[4]);
-                mutate(source, args, occupied(server) > 0,
-                        config -> CapacityConfigEditor.addGroupServer(config, group, server));
-            }
-            case "remove-server" -> {
-                if (args.length < 5) throw new IllegalArgumentException("Servernaam ontbreekt.");
-                String server = normalize(args[4]);
-                mutate(source, args, occupied(server) > 0,
-                        config -> CapacityConfigEditor.removeGroupServer(config, group, server));
-            }
-            case "delete" -> mutate(source, args, true,
-                    config -> CapacityConfigEditor.deleteGroup(config, group));
-            default -> throw new IllegalArgumentException("Onbekende group-actie: " + action);
-        }
-    }
-
-    private void server(CommandSource source, String[] args) {
-        if (args.length < 4) {
-            throw new IllegalArgumentException(
-                    "Gebruik: /capacity config server <server> <limit|group|gameplay|queueable|initial-state|delete> ...");
-        }
-        String server = normalize(args[2]);
-        String action = args[3].toLowerCase(Locale.ROOT);
-        switch (action) {
-            case "limit" -> {
-                if (args.length < 6) throw new IllegalArgumentException("Capacity en reserved ontbreken.");
-                int capacity = number(args[4], "capacity");
-                int reserved = number(args[5], "reserved");
-                mutate(source, args, capacity > 0 && capacity < used(server),
-                        config -> CapacityConfigEditor.serverLimit(config, server, capacity, reserved));
-            }
-            case "group" -> {
-                if (args.length < 5) throw new IllegalArgumentException("Groep of none ontbreekt.");
-                mutate(source, args, occupied(server) > 0,
-                        config -> CapacityConfigEditor.serverGroup(config, server, args[4]));
-            }
-            case "gameplay" -> {
-                if (args.length < 5) throw new IllegalArgumentException("Boolean ontbreekt.");
-                boolean value = bool(args[4]);
-                mutate(source, args, occupied(server) > 0,
-                        config -> CapacityConfigEditor.serverGameplay(config, server, value));
-            }
-            case "queueable" -> {
-                if (args.length < 5) throw new IllegalArgumentException("Boolean ontbreekt.");
-                boolean value = bool(args[4]);
-                mutate(source, args, false,
-                        config -> CapacityConfigEditor.serverQueueable(config, server, value));
-            }
-            case "initial-state" -> {
-                if (args.length < 5) throw new IllegalArgumentException("State ontbreekt.");
-                CapacityState state = capacityState(args[4]);
-                mutate(source, args, state != CapacityState.OPEN,
-                        config -> CapacityConfigEditor.serverInitialState(config, server, state));
-            }
-            case "delete" -> mutate(source, args, true,
-                    config -> CapacityConfigEditor.deleteServer(config, server));
-            default -> throw new IllegalArgumentException("Onbekende server-actie: " + action);
-        }
-    }
-
-    private void unknown(CommandSource source, String[] args) {
-        if (args.length < 3) {
-            throw new IllegalArgumentException(
-                    "Gebruik: /capacity config unknown <limit|gameplay|queueable> ...");
-        }
-        String action = args[2].toLowerCase(Locale.ROOT);
-        switch (action) {
-            case "limit" -> {
-                if (args.length < 5) throw new IllegalArgumentException("Capacity en reserved ontbreken.");
-                int capacity = number(args[3], "capacity");
-                int reserved = number(args[4], "reserved");
-                boolean dangerous = capacity < controlPlane.config().unknownCapacity();
-                mutate(source, args, dangerous,
-                        config -> CapacityConfigEditor.unknownLimit(config, capacity, reserved));
-            }
-            case "gameplay" -> {
-                if (args.length < 4) throw new IllegalArgumentException("Boolean ontbreekt.");
-                boolean value = bool(args[3]);
-                mutate(source, args, false,
-                        config -> CapacityConfigEditor.unknownGameplay(config, value));
-            }
-            case "queueable" -> {
-                if (args.length < 4) throw new IllegalArgumentException("Boolean ontbreekt.");
-                boolean value = bool(args[3]);
-                mutate(source, args, false,
-                        config -> CapacityConfigEditor.unknownQueueable(config, value));
-            }
-            default -> throw new IllegalArgumentException("Onbekende unknown-actie: " + action);
-        }
-    }
-
-    private void option(CommandSource source, String[] args) {
-        if (args.length < 4) {
-            throw new IllegalArgumentException("Gebruik: /capacity config option <option> <value>");
-        }
-        String option = args[2];
-        String value = args[3];
-        boolean dangerous = equals(option, "fail-open") && bool(value);
-        mutate(source, args, dangerous,
-                config -> CapacityConfigEditor.option(config, option, value));
+        CapacityConfig.GroupRule rule = config.groups().get(group);
+        if (rule == null) throw new IllegalArgumentException("Onbekende groep: " + group);
+        int capacity = number(args[3], "capacity");
+        int reserved = reserved(args, 4, rule.limit(), capacity);
+        return new SlotChange(
+                "group:" + group,
+                capacity,
+                reserved,
+                value -> CapacityConfigEditor.groupLimit(value, group, capacity, reserved)
+        );
+    }
+
+    private SlotChange serverSlotChange(String[] args, CapacityConfig config) {
+        requireArgumentRange(
+                args,
+                4,
+                5,
+                "Gebruik: /capacity slots server <server> <capacity> [reserved]"
+        );
+        String server = requireKnownServer(args[2]);
+        CapacityConfig.Limit current = config.server(server).limit();
+        int capacity = number(args[3], "capacity");
+        int reserved = reserved(args, 4, current, capacity);
+        return new SlotChange(
+                "server:" + server,
+                capacity,
+                reserved,
+                value -> CapacityConfigEditor.serverLimit(value, server, capacity, reserved)
+        );
+    }
+
+    private void queueable(CommandSource source, String[] args) {
+        require(source, CapacityConfig.ADMIN_CONFIG_PERMISSION);
+        requireArgumentCount(
+                args,
+                3,
+                "Gebruik: /capacity queueable <server> <true|false>"
+        );
+        String server = requireKnownServer(args[1]);
+        boolean value = bool(args[2]);
+        mutate(
+                source,
+                config -> CapacityConfigEditor.serverQueueable(config, server, value),
+                audience -> audience.sendMessage(feature.getLocalizationHandler()
+                        .getMessage("capacity.command.queueable_changed")
+                        .with("server", server)
+                        .with("queueable", value)
+                        .forAudience(audience)
+                        .build())
+        );
     }
 
-    private void mutate(CommandSource source,
-                        String[] args,
-                        boolean dangerous,
-                        UnaryOperator<CapacityConfig> mutation) {
+    private void mutate(
+            CommandSource source,
+            UnaryOperator<CapacityConfig> mutation,
+            Consumer<CommandSource> success) {
         mutation.apply(controlPlane.config());
-        if (dangerous) {
-            require(source, CapacityConfig.ADMIN_DANGEROUS_PERMISSION);
-            if (!flag(args, "--confirm")) {
-                throw new IllegalArgumentException(
-                        "Risicovolle wijziging: controleer de waarden en voeg --confirm toe.");
-            }
-        }
         pending(source);
         controlPlane.updateConfiguration(mutation).whenComplete((stored, error) -> {
             if (error != null) {
                 failed(source, error);
                 return;
             }
-            message(source, "capacity.command.changed");
+            success.accept(source);
         });
     }
 
@@ -332,29 +313,19 @@ private void state(CommandSource source, String[] args) {
         require(source, CapacityConfig.ADMIN_STATE_PERMISSION);
         if (args.length < 3) {
             throw new IllegalArgumentException(
-                    "Gebruik: /capacity state <server> <open|draining|closed|offline|clear> [duration] [reason]");
-        }
-        String server = normalize(args[1]);
-        if (feature.getPlugin().getProxy().getServer(server).isEmpty()
-                && !controlPlane.config().servers().containsKey(server)) {
-            throw new IllegalArgumentException("Onbekende server: " + server);
+                    "Gebruik: /capacity state <server> "
+                            + "<open|draining|closed|offline|clear> [duration] [reason]"
+            );
         }
-        String requested = args[2].toLowerCase(Locale.ROOT);
+        String server = requireKnownServer(args[1]);
+        String requested = normalize(args[2]);
         if (requested.equals("clear") || requested.equals("open")) {
-            pending(source);
-            controlPlane.clearManualState(server).whenComplete((removed, error) -> {
-                if (error != null) {
-                    failed(source, error);
-                    return;
-                }
-                source.sendMessage(feature.getLocalizationHandler()
-                        .getMessage("capacity.command.state_cleared")
-                        .with("server", server)
-                        .with("effective", service.getServerState(server).name())
-                        .with("effect", stateEffect(service.getServerState(server)))
-                        .forAudience(source)
-                        .build());
-            });
+            requireArgumentCount(
+                    args,
+                    3,
+                    "Gebruik: /capacity state <server> <open|clear>"
+            );
+            clearState(source, server);
             return;
         }
 
@@ -368,7 +339,10 @@ private void state(CommandSource source, String[] args) {
                 try {
                     expiresAt = Instant.now().plus(duration);
                 } catch (DateTimeException | ArithmeticException exception) {
-                    throw new IllegalArgumentException("De opgegeven duur is te groot.", exception);
+                    throw new IllegalArgumentException(
+                            "De opgegeven duur is te groot.",
+                            exception
+                    );
                 }
             }
         }
@@ -381,20 +355,42 @@ private void state(CommandSource source, String[] args) {
                         failed(source, error);
                         return;
                     }
+                    CapacityState effective = service.getServerState(server);
                     source.sendMessage(feature.getLocalizationHandler()
                             .getMessage("capacity.command.state_set")
                             .with("server", server)
                             .with("requested", state.name())
-                            .with("effective", service.getServerState(server).name())
+                            .with("effective", effective.name())
                             .with("expiry", format(expiry))
-                            .with("effect", stateEffect(service.getServerState(server)))
+                            .with("effect", stateEffect(effective))
                             .forAudience(source)
                             .build());
                 });
     }
 
-    private void reload(CommandSource source) {
+    private void clearState(CommandSource source, String server) {
+        pending(source);
+        controlPlane.clearManualState(server).whenComplete((removed, error) -> {
+            if (error != null) {
+                failed(source, error);
+                return;
+            }
+            CapacityState effective = service.getServerState(server);
+            source.sendMessage(feature.getLocalizationHandler()
+                    .getMessage(removed
+                            ? "capacity.command.state_cleared"
+                            : "capacity.command.state_unchanged")
+                    .with("server", server)
+                    .with("effective", effective.name())
+                    .with("effect", stateEffect(effective))
+                    .forAudience(source)
+                    .build());
+        });
+    }
+
+    private void reload(CommandSource source, String[] args) {
         require(source, CapacityConfig.ADMIN_CONFIG_PERMISSION);
+        requireArgumentCount(args, 1, "Gebruik: /capacity reload");
         pending(source);
         controlPlane.reload().whenComplete((stored, error) -> {
             if (error != null) {
@@ -425,8 +421,7 @@ private boolean canUse(CommandSource source) {
         return source.hasPermission(CapacityConfig.ADMIN_PERMISSION)
                 || source.hasPermission(CapacityConfig.ADMIN_VIEW_PERMISSION)
                 || source.hasPermission(CapacityConfig.ADMIN_STATE_PERMISSION)
-                || source.hasPermission(CapacityConfig.ADMIN_CONFIG_PERMISSION)
-                || source.hasPermission(CapacityConfig.ADMIN_DANGEROUS_PERMISSION);
+                || source.hasPermission(CapacityConfig.ADMIN_CONFIG_PERMISSION);
     }
 
     private boolean permitted(CommandSource source, String permission) {
@@ -440,19 +435,24 @@ private void require(CommandSource source, String permission) {
         throw new CommandHandledException();
     }
 
-    private String actorName(CommandSource source) {
-        if (source instanceof Player player) return player.getUsername();
-        return source.getClass().getSimpleName();
+    private String requireKnownServer(String rawServer) {
+        String server = normalize(rawServer);
+        if (server.isBlank() || !knownServer(server)) {
+            throw new IllegalArgumentException("Onbekende server: " + server);
+        }
+        return server;
     }
 
-    private int occupied(String server) {
-        CapacityScopeSnapshot snapshot = service.snapshot().servers().get(server);
-        return snapshot == null ? 0 : snapshot.occupied();
+    private boolean knownServer(String server) {
+        if (feature.getPlugin().getProxy().getServer(server).isPresent()) return true;
+        if (controlPlane.config().servers().containsKey(server)) return true;
+        return controlPlane.config().groups().values().stream()
+                .anyMatch(group -> group.servers().contains(server));
     }
 
-    private int used(String server) {
-        CapacityScopeSnapshot snapshot = service.snapshot().servers().get(server);
-        return snapshot == null ? 0 : snapshot.effectiveUsed();
+    private String actorName(CommandSource source) {
+        if (source instanceof Player player) return player.getUsername();
+        return source.getClass().getSimpleName();
     }
 
     private void pending(CommandSource source) {
@@ -470,7 +470,10 @@ private void invalid(CommandSource source, String error) {
 
     private void failed(CommandSource source, Throwable throwable) {
         Throwable cause = unwrap(throwable);
-        String error = cause.getMessage() == null ? cause.getClass().getSimpleName() : cause.getMessage();
+        feature.getLogger().error("Capacity command operation failed.", cause);
+        String error = cause.getMessage() == null
+                ? cause.getClass().getSimpleName()
+                : cause.getMessage();
         source.sendMessage(feature.getLocalizationHandler()
                 .getMessage("capacity.command.failed")
                 .with("error", error)
@@ -479,7 +482,10 @@ private void failed(CommandSource source, Throwable throwable) {
     }
 
     private void message(CommandSource source, String key) {
-        source.sendMessage(feature.getLocalizationHandler().getMessage(key).forAudience(source).build());
+        source.sendMessage(feature.getLocalizationHandler()
+                .getMessage(key)
+                .forAudience(source)
+                .build());
     }
 
     private static Throwable unwrap(Throwable throwable) {
@@ -492,13 +498,26 @@ private static Throwable unwrap(Throwable throwable) {
         return current;
     }
 
+    private static int reserved(
+            String[] args,
+            int index,
+            CapacityConfig.Limit current,
+            int capacity) {
+        return args.length > index
+                ? number(args[index], "reserved")
+                : Math.min(current.reservedSlots(), capacity);
+    }
+
     private static int number(String value, String name) {
         try {
             int result = Integer.parseInt(value);
             if (result < 0) throw new NumberFormatException();
             return result;
         } catch (NumberFormatException exception) {
-            throw new IllegalArgumentException(name + " moet een niet-negatief geheel getal zijn.", exception);
+            throw new IllegalArgumentException(
+                    name + " moet een niet-negatief geheel getal zijn.",
+                    exception
+            );
         }
     }
 
@@ -507,7 +526,9 @@ private static boolean bool(String value) {
         return switch (value.trim().toLowerCase(Locale.ROOT)) {
             case "true", "yes", "on", "1" -> true;
             case "false", "no", "off", "0" -> false;
-            default -> throw new IllegalArgumentException("Verwacht true of false, kreeg: " + value);
+            default -> throw new IllegalArgumentException(
+                    "Verwacht true of false, kreeg: " + value
+            );
         };
     }
 
@@ -522,7 +543,8 @@ private static CapacityState capacityState(String value) {
     private static boolean durationToken(String value) {
         if (value == null) return false;
         String normalized = value.toLowerCase(Locale.ROOT);
-        return normalized.equals("permanent") || normalized.equals("perm")
+        return normalized.equals("permanent")
+                || normalized.equals("perm")
                 || normalized.matches("[0-9]+(ms|s|m|h|d)?");
     }
 
@@ -530,16 +552,12 @@ private static String reason(String[] args, int start, String fallback) {
         if (args.length <= start) return fallback;
         List<String> parts = new ArrayList<>();
         for (int index = start; index < args.length; index++) {
-            if (!args[index].startsWith("--")) parts.add(args[index]);
+            parts.add(args[index]);
         }
         String reason = String.join(" ", parts).trim();
         return reason.isBlank() ? fallback : reason;
     }
 
-    private static boolean flag(String[] args, String flag) {
-        return Arrays.stream(args).anyMatch(value -> value.equalsIgnoreCase(flag));
-    }
-
     private static String format(Instant instant) {
         return instant == null ? "permanent" : instant.toString();
     }
@@ -547,9 +565,12 @@ private static String format(Instant instant) {
     private static String stateEffect(CapacityState state) {
         return switch (state) {
             case OPEN -> "nieuwe verbindingen zijn toegestaan";
-            case DRAINING -> "nieuwe verbindingen worden geweigerd; aanwezige spelers blijven verbonden";
-            case CLOSED -> "nieuwe verbindingen worden geweigerd; aanwezige spelers blijven verbonden";
-            case OFFLINE -> "nieuwe verbindingen worden geweigerd; aanwezige spelers blijven verbonden";
+            case DRAINING ->
+                    "nieuwe verbindingen worden geweigerd; aanwezige spelers blijven verbonden";
+            case CLOSED ->
+                    "nieuwe verbindingen worden geweigerd; aanwezige spelers blijven verbonden";
+            case OFFLINE ->
+                    "nieuwe verbindingen worden geweigerd; aanwezige spelers blijven verbonden";
         };
     }
 
@@ -561,77 +582,117 @@ private static boolean equals(String value, String expected) {
         return value != null && value.equalsIgnoreCase(expected);
     }
 
+    private static void requireArgumentCount(String[] args, int count, String usage) {
+        if (args.length != count) throw new IllegalArgumentException(usage);
+    }
+
+    private static void requireArgumentRange(
+            String[] args,
+            int minimum,
+            int maximum,
+            String usage) {
+        if (args.length < minimum || args.length > maximum) {
+            throw new IllegalArgumentException(usage);
+        }
+    }
+
     @Override
     public CompletableFuture<List<String>> suggestAsync(Invocation invocation) {
+        CommandSource source = invocation.source();
         String[] args = invocation.arguments();
-        if (args.length <= 1) return completed(filter(ROOT, token(args, 0)));
-        if (equals(args[0], "status") && args.length == 2) {
-            return completed(filter(List.of("group"), token(args, 1)));
+        if (args.length <= 1) {
+            return completed(filter(rootSuggestions(source), token(args, 0)));
+        }
+        if (equals(args[0], "status")
+                && permitted(source, CapacityConfig.ADMIN_VIEW_PERMISSION)) {
+            if (args.length == 2) {
+                return completed(filter(List.of("group"), token(args, 1)));
+            }
+            if (args.length == 3 && equals(args[1], "group")) {
+                return completed(filter(groups(), token(args, 2)));
+            }
         }
-        if ((equals(args[0], "info") || equals(args[0], "state")) && args.length == 2) {
+        if (equals(args[0], "info")
+                && permitted(source, CapacityConfig.ADMIN_VIEW_PERMISSION)
+                && args.length == 2) {
             return completed(filter(servers(), token(args, 1)));
         }
-        if (equals(args[0], "status") && args.length == 3 && equals(args[1], "group")) {
-            return completed(filter(new ArrayList<>(controlPlane.config().groups().keySet()), token(args, 2)));
+        if (equals(args[0], "state")
+                && permitted(source, CapacityConfig.ADMIN_STATE_PERMISSION)) {
+            if (args.length == 2) {
+                return completed(filter(servers(), token(args, 1)));
+            }
+            if (args.length == 3) {
+                List<String> values = new ArrayList<>(STATES);
+                values.add("clear");
+                return completed(filter(values, token(args, 2)));
+            }
+            if (args.length == 4) {
+                return completed(filter(
+                        List.of("permanent", "15m", "1h", "1d"),
+                        token(args, 3)
+                ));
+            }
         }
-        if (equals(args[0], "state") && args.length == 3) {
-            List<String> values = new ArrayList<>(STATES);
-            values.add("clear");
-            return completed(filter(values, token(args, 2)));
+        if (equals(args[0], "queueable")
+                && permitted(source, CapacityConfig.ADMIN_CONFIG_PERMISSION)) {
+            if (args.length == 2) {
+                return completed(filter(servers(), token(args, 1)));
+            }
+            if (args.length == 3) {
+                return completed(filter(List.of("true", "false"), token(args, 2)));
+            }
         }
-        if (equals(args[0], "state") && args.length == 4) {
-            return completed(filter(List.of("permanent", "15m", "1h", "1d"), token(args, 3)));
+        if (equals(args[0], "slots")
+                && permitted(source, CapacityConfig.ADMIN_CONFIG_PERMISSION)) {
+            return slotSuggestions(args);
         }
-        if (equals(args[0], "config")) return configSuggestions(args);
         return completed(List.of());
     }
 
-    private CompletableFuture<List<String>> configSuggestions(String[] args) {
-        if (args.length == 2) return completed(filter(CONFIG_ROOT, token(args, 1)));
-        if (args.length == 3 && equals(args[1], "group")) {
-            return completed(filter(new ArrayList<>(controlPlane.config().groups().keySet()), token(args, 2)));
-        }
-        if (args.length == 3 && equals(args[1], "server")) {
-            return completed(filter(servers(), token(args, 2)));
-        }
-        if (args.length == 3 && equals(args[1], "unknown")) {
-            return completed(filter(List.of("limit", "gameplay", "queueable"), token(args, 2)));
-        }
-        if (args.length == 3 && equals(args[1], "option")) {
-            return completed(filter(List.of("lease-ttl", "login-ttl", "reconciliation",
-                    "maintenance-sync", "queue-on-full", "fail-open", "restart-reserved"),
-                    token(args, 2)));
-        }
-        if (args.length == 4 && equals(args[1], "group")) {
-            return completed(filter(List.of("limit", "add-server", "remove-server", "delete"),
-                    token(args, 3)));
+    private List<String> rootSuggestions(CommandSource source) {
+        List<String> suggestions = new ArrayList<>();
+        if (permitted(source, CapacityConfig.ADMIN_VIEW_PERMISSION)) {
+            suggestions.add("status");
+            suggestions.add("info");
         }
-        if (args.length == 4 && equals(args[1], "server")) {
-            return completed(filter(List.of("limit", "group", "gameplay", "queueable",
-                    "initial-state", "delete"), token(args, 3)));
+        if (permitted(source, CapacityConfig.ADMIN_CONFIG_PERMISSION)) {
+            suggestions.add("slots");
+            suggestions.add("queueable");
+            suggestions.add("reload");
         }
-        if (args.length == 5 && equals(args[1], "server") && equals(args[3], "group")) {
-            List<String> groups = new ArrayList<>(controlPlane.config().groups().keySet());
-            groups.add("none");
-            return completed(filter(groups, token(args, 4)));
+        if (permitted(source, CapacityConfig.ADMIN_STATE_PERMISSION)) {
+            suggestions.add("state");
         }
-        if (args.length == 5 && equals(args[1], "server") && equals(args[3], "initial-state")) {
-            return completed(filter(STATES, token(args, 4)));
+        return suggestions;
+    }
+
+    private CompletableFuture<List<String>> slotSuggestions(String[] args) {
+        if (args.length == 2) return completed(filter(SLOT_SCOPES, token(args, 1)));
+        if (args.length == 3 && equals(args[1], "group")) {
+            return completed(filter(groups(), token(args, 2)));
         }
-        if (args.length == 5 && equals(args[1], "server")
-                && (equals(args[3], "gameplay") || equals(args[3], "queueable"))) {
-            return completed(filter(List.of("true", "false"), token(args, 4)));
+        if (args.length == 3 && equals(args[1], "server")) {
+            return completed(filter(servers(), token(args, 2)));
         }
         return completed(List.of());
     }
 
     private List<String> servers() {
-        return feature.getPlugin().getProxy().getAllServers().stream()
+        Set<String> servers = new TreeSet<>(String.CASE_INSENSITIVE_ORDER);
+        feature.getPlugin().getProxy().getAllServers().stream()
                 .map(server -> server.getServerInfo().getName())
                 .map(CapacityCommand::normalize)
-                .distinct()
-                .sorted()
-                .toList();
+                .forEach(servers::add);
+        servers.addAll(controlPlane.config().servers().keySet());
+        controlPlane.config().groups().values().stream()
+                .flatMap(group -> group.servers().stream())
+                .forEach(servers::add);
+        return List.copyOf(servers);
+    }
+
+    private List<String> groups() {
+        return controlPlane.config().groups().keySet().stream().sorted().toList();
     }
 
     private static List<String> filter(List<String> values, String prefix) {
diff --git a/proxyfeatures-platform-velocity/src/main/java/nl/hauntedmc/proxyfeatures/features/capacity/config/CapacityConfig.java b/proxyfeatures-platform-velocity/src/main/java/nl/hauntedmc/proxyfeatures/features/capacity/config/CapacityConfig.java
index f09ce0e3..24a4ded4 100644
--- a/proxyfeatures-platform-velocity/src/main/java/nl/hauntedmc/proxyfeatures/features/capacity/config/CapacityConfig.java
+++ b/proxyfeatures-platform-velocity/src/main/java/nl/hauntedmc/proxyfeatures/features/capacity/config/CapacityConfig.java
@@ -4,14 +4,20 @@
 import nl.hauntedmc.proxyfeatures.api.io.config.ConfigNode;
 import nl.hauntedmc.proxyfeatures.features.capacity.Capacity;
 
+import java.math.BigDecimal;
 import java.time.Duration;
+import java.util.ArrayList;
 import java.util.Collections;
+import java.util.HashMap;
+import java.util.HashSet;
 import java.util.LinkedHashMap;
 import java.util.List;
 import java.util.Locale;
 import java.util.Map;
+import java.util.Objects;
+import java.util.Set;
 
-/** Immutable validated Capacity configuration. A non-positive capacity disables that scope. */
+/** Immutable validated Capacity configuration. A zero capacity disables that scope. */
 public record CapacityConfig(
         Limit proxy,
         Limit gameplay,
@@ -25,10 +31,20 @@ public record CapacityConfig(
         Duration loginReservationTtl,
         Duration reconciliationInterval,
         Duration maintenanceSyncInterval,
+        String snapshotChannel,
+        int snapshotPublishIntervalSeconds,
+        String snapshotPublisherId,
         boolean queueOnFull,
         boolean failOpenOnInternalError,
         boolean restartReturnUsesReservedSlots
 ) {
+    private static final int MAX_IDENTIFIER_LENGTH = 100;
+    private static final char COMPOSITE_KEY_SEPARATOR = '|';
+
+    public static final String DEFAULT_SNAPSHOT_CHANNEL = "proxy.capacity.snapshot";
+    public static final int DEFAULT_SNAPSHOT_INTERVAL_SECONDS = 2;
+    public static final String DEFAULT_SNAPSHOT_PUBLISHER_ID = "proxy";
+
     public static final String CAPACITY_BYPASS_PERMISSION =
             "proxyfeatures.feature.capacity.bypass.capacity";
     public static final String STATE_BYPASS_PERMISSION =
@@ -43,26 +59,79 @@ public record CapacityConfig(
             "proxyfeatures.feature.capacity.admin.state";
     public static final String ADMIN_CONFIG_PERMISSION =
             "proxyfeatures.feature.capacity.admin.config";
-    public static final String ADMIN_DANGEROUS_PERMISSION =
-            "proxyfeatures.feature.capacity.admin.dangerous";
 
     public CapacityConfig {
-        proxy = proxy == null ? new Limit(0, 0) : proxy;
-        gameplay = gameplay == null ? new Limit(0, 0) : gameplay;
+        proxy = Objects.requireNonNull(proxy, "proxy");
+        gameplay = Objects.requireNonNull(gameplay, "gameplay");
         groups = immutableGroups(groups);
-        servers = immutableServers(servers);
-        unknownCapacity = Math.max(0, unknownCapacity);
-        unknownReservedSlots = Math.max(0, Math.min(unknownCapacity, unknownReservedSlots));
-        leaseTtl = positive(leaseTtl, Duration.ofSeconds(15));
-        loginReservationTtl = positive(loginReservationTtl, Duration.ofSeconds(20));
-        reconciliationInterval = positive(reconciliationInterval, Duration.ofSeconds(5));
-        maintenanceSyncInterval = positive(maintenanceSyncInterval, Duration.ofMillis(500));
+        servers = immutableServers(servers, groups);
+        validateUnknownLimit(unknownCapacity, unknownReservedSlots);
+        leaseTtl = requirePositive(leaseTtl, "leases.ttl_millis");
+        loginReservationTtl = requirePositive(loginReservationTtl, "leases.login_ttl_millis");
+        reconciliationInterval = requirePositive(
+                reconciliationInterval,
+                "reconciliation.interval_seconds"
+        );
+        maintenanceSyncInterval = requirePositive(
+                maintenanceSyncInterval,
+                "integrations.maintenance_sync_interval_millis"
+        );
+        snapshotChannel = requireText(snapshotChannel, "messaging.channel", 256);
+        if (snapshotPublishIntervalSeconds <= 0) {
+            throw new IllegalArgumentException(
+                    "Value at messaging.publish_interval_seconds must be positive."
+            );
+        }
+        snapshotPublisherId = requireText(snapshotPublisherId, "messaging.publisher_id", 100);
+    }
+
+    /** Convenience constructor for admission policies that use the standard snapshot feed. */
+    public CapacityConfig(
+            Limit proxy,
+            Limit gameplay,
+            Map<String, GroupRule> groups,
+            Map<String, ServerRule> servers,
+            boolean unknownCountsTowardGameplay,
+            boolean unknownQueueable,
+            int unknownCapacity,
+            int unknownReservedSlots,
+            Duration leaseTtl,
+            Duration loginReservationTtl,
+            Duration reconciliationInterval,
+            Duration maintenanceSyncInterval,
+            boolean queueOnFull,
+            boolean failOpenOnInternalError,
+            boolean restartReturnUsesReservedSlots
+    ) {
+        this(
+                proxy,
+                gameplay,
+                groups,
+                servers,
+                unknownCountsTowardGameplay,
+                unknownQueueable,
+                unknownCapacity,
+                unknownReservedSlots,
+                leaseTtl,
+                loginReservationTtl,
+                reconciliationInterval,
+                maintenanceSyncInterval,
+                DEFAULT_SNAPSHOT_CHANNEL,
+                DEFAULT_SNAPSHOT_INTERVAL_SECONDS,
+                DEFAULT_SNAPSHOT_PUBLISHER_ID,
+                queueOnFull,
+                failOpenOnInternalError,
+                restartReturnUsesReservedSlots
+        );
     }
 
     public record Limit(int capacity, int reservedSlots) {
         public Limit {
-            capacity = Math.max(0, capacity);
-            reservedSlots = Math.max(0, Math.min(capacity, reservedSlots));
+            if (capacity < 0 || reservedSlots < 0 || reservedSlots > capacity) {
+                throw new IllegalArgumentException(
+                        "Capacity must be non-negative and reserved slots may not exceed capacity."
+                );
+            }
         }
 
         public boolean enabled() {
@@ -73,16 +142,12 @@ public boolean enabled() {
     public record GroupRule(String name, Limit limit, List<String> servers) {
         public GroupRule {
             name = normalize(name);
-            limit = limit == null ? new Limit(0, 0) : limit;
-            servers = servers == null ? List.of() : servers.stream()
-                    .map(CapacityConfig::normalize)
-                    .filter(value -> !value.isBlank())
-                    .distinct()
-                    .sorted()
-                    .toList();
+            limit = Objects.requireNonNull(limit, "limit");
+            servers = normalizeMembers(servers);
         }
     }
 
+    /** Effective server policy. Group membership is derived exclusively from {@link GroupRule#servers()}. */
     public record ServerRule(
             String name,
             Limit limit,
@@ -93,9 +158,9 @@ public record ServerRule(
     ) {
         public ServerRule {
             name = normalize(name);
-            limit = limit == null ? new Limit(0, 0) : limit;
+            limit = Objects.requireNonNull(limit, "limit");
             group = normalize(group);
-            initialState = initialState == null ? CapacityState.OPEN : initialState;
+            initialState = Objects.requireNonNull(initialState, "initialState");
         }
     }
 
@@ -103,49 +168,132 @@ public static CapacityConfig load(Capacity feature) {
         var config = feature.getConfigHandler();
         config.reloadConfig();
 
-        Limit proxy = limit(config.node("global.proxy"), 600, 10);
-        Limit gameplay = limit(config.node("global.gameplay"), 500, 10);
+        Limit proxy = limit(config.node("global.proxy"), 600, 10, "global.proxy");
+        Limit gameplay = limit(config.node("global.gameplay"), 500, 10, "global.gameplay");
 
+        ConfigNode groupSection = mapSection(config.node("groups"), "groups");
         Map<String, GroupRule> groups = new LinkedHashMap<>();
-        for (var entry : config.node("groups").children().entrySet()) {
-            String name = normalize(entry.getKey());
-            if (name.isBlank()) continue;
-            ConfigNode node = entry.getValue();
-            groups.put(name, new GroupRule(name, limit(node, 0, 0), safeList(node.get("servers"))));
+        for (var entry : groupSection.children().entrySet()) {
+            String name = requiredIdentifier(entry.getKey(), "group");
+            ConfigNode node = mapSection(entry.getValue(), "groups." + entry.getKey());
+            putUnique(
+                    groups,
+                    name,
+                    new GroupRule(
+                            name,
+                            limit(node, 0, 0, "groups." + entry.getKey()),
+                            stringList(node.get("servers"), "groups." + entry.getKey() + ".servers")
+                    ),
+                    "group"
+            );
         }
 
+        ConfigNode serverSection = mapSection(config.node("servers"), "servers");
         Map<String, ServerRule> servers = new LinkedHashMap<>();
-        for (var entry : config.node("servers").children().entrySet()) {
-            String name = normalize(entry.getKey());
-            if (name.isBlank()) continue;
-            ConfigNode node = entry.getValue();
-            servers.put(name, new ServerRule(
+        for (var entry : serverSection.children().entrySet()) {
+            String name = requiredIdentifier(entry.getKey(), "server");
+            ConfigNode node = mapSection(entry.getValue(), "servers." + entry.getKey());
+            putUnique(
+                    servers,
                     name,
-                    limit(node, 0, 0),
-                    stringValue(node.get("group").as(String.class, ""), ""),
-                    booleanValue(node.get("counts_toward_gameplay").as(Boolean.class, true), true),
-                    booleanValue(node.get("queueable").as(Boolean.class, true), true),
-                    parseState(stringValue(node.get("initial_state").as(String.class, "OPEN"), "OPEN"))
-            ));
+                    new ServerRule(
+                            name,
+                            limit(node, 0, 0, "servers." + entry.getKey()),
+                            "",
+                            booleanValue(
+                                    node.get("counts_toward_gameplay"),
+                                    true,
+                                    "servers." + entry.getKey() + ".counts_toward_gameplay"
+                            ),
+                            booleanValue(
+                                    node.get("queueable"),
+                                    true,
+                                    "servers." + entry.getKey() + ".queueable"
+                            ),
+                            parseState(stringValue(
+                                    node.get("initial_state"),
+                                    "OPEN",
+                                    "servers." + entry.getKey() + ".initial_state"
+                            ))
+                    ),
+                    "server"
+            );
         }
 
+        int unknownCapacity = integerValue(
+                config.node("unknown_servers.capacity"),
+                0,
+                "unknown_servers.capacity"
+        );
+        int unknownReserved = integerValue(
+                config.node("unknown_servers.reserved_slots"),
+                0,
+                "unknown_servers.reserved_slots"
+        );
+
         CapacityConfig loaded = new CapacityConfig(
                 proxy,
                 gameplay,
                 groups,
                 servers,
-                booleanValue(config.get("unknown_servers.counts_toward_gameplay", Boolean.class, true), true),
-                booleanValue(config.get("unknown_servers.queueable", Boolean.class, false), false),
-                nonNegative(config.get("unknown_servers.capacity", Integer.class, 0), 0),
-                nonNegative(config.get("unknown_servers.reserved_slots", Integer.class, 0), 0),
-                Duration.ofMillis(positive(config.get("leases.ttl_millis", Long.class, 15_000L), 15_000L)),
-                Duration.ofMillis(positive(config.get("leases.login_ttl_millis", Long.class, 20_000L), 20_000L)),
-                Duration.ofSeconds(positive(config.get("reconciliation.interval_seconds", Long.class, 5L), 5L)),
-                Duration.ofMillis(positive(config.get(
-                        "integrations.maintenance_sync_interval_millis", Long.class, 500L), 500L)),
-                booleanValue(config.get("queue.on_full", Boolean.class, true), true),
-                booleanValue(config.get("failure.fail_open_on_internal_error", Boolean.class, false), false),
-                booleanValue(config.get("restart_return.use_reserved_slots", Boolean.class, true), true)
+                booleanValue(
+                        config.node("unknown_servers.counts_toward_gameplay"),
+                        true,
+                        "unknown_servers.counts_toward_gameplay"
+                ),
+                booleanValue(
+                        config.node("unknown_servers.queueable"),
+                        false,
+                        "unknown_servers.queueable"
+                ),
+                unknownCapacity,
+                unknownReserved,
+                Duration.ofMillis(longValue(
+                        config.node("leases.ttl_millis"),
+                        15_000L,
+                        "leases.ttl_millis"
+                )),
+                Duration.ofMillis(longValue(
+                        config.node("leases.login_ttl_millis"),
+                        20_000L,
+                        "leases.login_ttl_millis"
+                )),
+                Duration.ofSeconds(longValue(
+                        config.node("reconciliation.interval_seconds"),
+                        5L,
+                        "reconciliation.interval_seconds"
+                )),
+                Duration.ofMillis(longValue(
+                        config.node("integrations.maintenance_sync_interval_millis"),
+                        500L,
+                        "integrations.maintenance_sync_interval_millis"
+                )),
+                stringValue(
+                        config.node("messaging.channel"),
+                        DEFAULT_SNAPSHOT_CHANNEL,
+                        "messaging.channel"
+                ),
+                positiveIntegerValue(
+                        config.node("messaging.publish_interval_seconds"),
+                        DEFAULT_SNAPSHOT_INTERVAL_SECONDS,
+                        "messaging.publish_interval_seconds"
+                ),
+                stringValue(
+                        config.node("messaging.publisher_id"),
+                        DEFAULT_SNAPSHOT_PUBLISHER_ID,
+                        "messaging.publisher_id"
+                ),
+                booleanValue(config.node("queue.on_full"), true, "queue.on_full"),
+                booleanValue(
+                        config.node("failure.fail_open_on_internal_error"),
+                        false,
+                        "failure.fail_open_on_internal_error"
+                ),
+                booleanValue(
+                        config.node("restart_return.use_reserved_slots"),
+                        true,
+                        "restart_return.use_reserved_slots"
+                )
         );
         CapacityConfigValidator.validate(loaded);
         return loaded;
@@ -158,15 +306,10 @@ public ServerRule server(String serverName) {
         }
         ServerRule explicit = servers.get(normalized);
         if (explicit != null) return explicit;
-        String group = groups.values().stream()
-                .filter(rule -> rule.servers().contains(normalized))
-                .map(GroupRule::name)
-                .findFirst()
-                .orElse("");
         return new ServerRule(
                 normalized,
                 new Limit(unknownCapacity, unknownReservedSlots),
-                group,
+                groupFor(groups, normalized),
                 unknownCountsTowardGameplay,
                 unknownQueueable,
                 CapacityState.OPEN
@@ -191,46 +334,129 @@ public String adminPermission() {
 
     private static Map<String, GroupRule> immutableGroups(Map<String, GroupRule> source) {
         Map<String, GroupRule> result = new LinkedHashMap<>();
+        Map<String, String> membership = new HashMap<>();
         if (source != null) {
             source.entrySet().stream()
                     .sorted(Map.Entry.comparingByKey())
                     .forEach(entry -> {
-                        GroupRule rule = entry.getValue();
-                        if (rule == null || rule.name().isBlank()) return;
-                        result.put(normalize(entry.getKey()), rule);
+                        GroupRule rule = Objects.requireNonNull(entry.getValue(), "group rule");
+                        String key = requiredIdentifier(entry.getKey(), "group");
+                        if (!key.equals(requiredIdentifier(rule.name(), "group"))) {
+                            throw new IllegalArgumentException("Group key and name differ: " + key);
+                        }
+                        for (String server : rule.servers()) {
+                            String previous = membership.putIfAbsent(server, key);
+                            if (previous != null) {
+                                throw new IllegalArgumentException(
+                                        "Server " + server + " belongs to multiple groups: "
+                                                + previous + " and " + key
+                                );
+                            }
+                        }
+                        putUnique(result, key, rule, "group");
                     });
         }
         return Collections.unmodifiableMap(result);
     }
 
-    private static Map<String, ServerRule> immutableServers(Map<String, ServerRule> source) {
+    private static Map<String, ServerRule> immutableServers(
+            Map<String, ServerRule> source,
+            Map<String, GroupRule> groups) {
         Map<String, ServerRule> result = new LinkedHashMap<>();
         if (source != null) {
             source.entrySet().stream()
                     .sorted(Map.Entry.comparingByKey())
                     .forEach(entry -> {
-                        ServerRule rule = entry.getValue();
-                        if (rule == null || rule.name().isBlank()) return;
-                        result.put(normalize(entry.getKey()), rule);
+                        ServerRule rule = Objects.requireNonNull(entry.getValue(), "server rule");
+                        String key = requiredIdentifier(entry.getKey(), "server");
+                        if (!key.equals(requiredIdentifier(rule.name(), "server"))) {
+                            throw new IllegalArgumentException("Server key and name differ: " + key);
+                        }
+                        putUnique(
+                                result,
+                                key,
+                                new ServerRule(
+                                        key,
+                                        rule.limit(),
+                                        groupFor(groups, key),
+                                        rule.countsTowardGameplay(),
+                                        rule.queueable(),
+                                        rule.initialState()
+                                ),
+                                "server"
+                        );
                     });
         }
         return Collections.unmodifiableMap(result);
     }
 
-    private static Limit limit(ConfigNode node, int defaultCapacity, int defaultReserved) {
-        int capacity = nonNegative(node.get("capacity").as(Integer.class, defaultCapacity), defaultCapacity);
-        int reserved = nonNegative(node.get("reserved_slots").as(Integer.class, defaultReserved), defaultReserved);
-        return new Limit(capacity, reserved);
+    private static List<String> normalizeMembers(List<String> source) {
+        if (source == null) return List.of();
+        List<String> normalized = new ArrayList<>();
+        Set<String> seen = new HashSet<>();
+        for (String raw : source) {
+            String server = requiredIdentifier(raw, "server");
+            if (!seen.add(server)) {
+                throw new IllegalArgumentException(
+                        "Duplicate server in group membership: " + server
+                );
+            }
+            normalized.add(server);
+        }
+        normalized.sort(String::compareTo);
+        return List.copyOf(normalized);
     }
 
-    private static List<String> safeList(ConfigNode node) {
+    private static String groupFor(Map<String, GroupRule> groups, String server) {
+        return groups.values().stream()
+                .filter(rule -> rule.servers().contains(server))
+                .map(GroupRule::name)
+                .findFirst()
+                .orElse("");
+    }
+
+    private static Limit limit(
+            ConfigNode node,
+            int defaultCapacity,
+            int defaultReserved,
+            String path) {
+        ConfigNode section = mapSection(node, path);
+        int capacity = integerValue(section.get("capacity"), defaultCapacity, path + ".capacity");
+        int reserved = integerValue(
+                section.get("reserved_slots"),
+                defaultReserved,
+                path + ".reserved_slots"
+        );
         try {
-            return node.listOf(String.class);
-        } catch (RuntimeException ignored) {
-            return List.of();
+            return new Limit(capacity, reserved);
+        } catch (IllegalArgumentException exception) {
+            throw new IllegalArgumentException("Invalid capacity values at " + path + '.', exception);
         }
     }
 
+    private static ConfigNode mapSection(ConfigNode node, String path) {
+        if (node == null || node.isNull()) return ConfigNode.ofRaw(Map.of(), path);
+        if (!(node.raw() instanceof Map<?, ?>)) {
+            throw new IllegalArgumentException("Expected a map at " + path + '.');
+        }
+        return node;
+    }
+
+    private static List<String> stringList(ConfigNode node, String path) {
+        if (node == null || node.isNull()) return List.of();
+        if (!(node.raw() instanceof List<?> values)) {
+            throw new IllegalArgumentException("Expected a string list at " + path + '.');
+        }
+        List<String> result = new ArrayList<>();
+        for (Object value : values) {
+            if (!(value instanceof String text)) {
+                throw new IllegalArgumentException("Expected a string list at " + path + '.');
+            }
+            result.add(text);
+        }
+        return List.copyOf(result);
+    }
+
     private static CapacityState parseState(String raw) {
         try {
             return CapacityState.valueOf(normalize(raw).toUpperCase(Locale.ROOT));
@@ -239,24 +465,107 @@ private static CapacityState parseState(String raw) {
         }
     }
 
-    private static int nonNegative(Integer value, int fallback) {
-        return Math.max(0, value == null ? fallback : value);
+    private static int integerValue(ConfigNode node, int fallback, String path) {
+        if (node == null || node.isNull()) return fallback;
+        long value = exactLong(node.raw(), path);
+        if (value < 0L || value > Integer.MAX_VALUE) {
+            throw new IllegalArgumentException(
+                    "Value at " + path + " must be a non-negative 32-bit integer."
+            );
+        }
+        return (int) value;
+    }
+
+    private static int positiveIntegerValue(ConfigNode node, int fallback, String path) {
+        int value = integerValue(node, fallback, path);
+        if (value <= 0) throw new IllegalArgumentException("Value at " + path + " must be positive.");
+        return value;
+    }
+
+    private static long longValue(ConfigNode node, long fallback, String path) {
+        if (node == null || node.isNull()) return fallback;
+        long value = exactLong(node.raw(), path);
+        if (value <= 0L) {
+            throw new IllegalArgumentException("Value at " + path + " must be positive.");
+        }
+        return value;
+    }
+
+    private static long exactLong(Object raw, String path) {
+        if (!(raw instanceof Number number)) {
+            throw new IllegalArgumentException("Expected an integer at " + path + '.');
+        }
+        try {
+            return new BigDecimal(number.toString()).longValueExact();
+        } catch (ArithmeticException | NumberFormatException exception) {
+            throw new IllegalArgumentException("Expected an integer at " + path + '.', exception);
+        }
+    }
+
+    private static boolean booleanValue(ConfigNode node, boolean fallback, String path) {
+        if (node == null || node.isNull()) return fallback;
+        if (node.raw() instanceof Boolean value) return value;
+        throw new IllegalArgumentException("Expected true or false at " + path + '.');
     }
 
-    private static long positive(Long value, long fallback) {
-        return value != null && value > 0L ? value : fallback;
+    private static String stringValue(ConfigNode node, String fallback, String path) {
+        if (node == null || node.isNull()) return fallback;
+        if (node.raw() instanceof String value) return value;
+        throw new IllegalArgumentException("Expected text at " + path + '.');
     }
 
-    private static boolean booleanValue(Boolean value, boolean fallback) {
-        return value == null ? fallback : value;
+    private static void validateUnknownLimit(int capacity, int reserved) {
+        try {
+            new Limit(capacity, reserved);
+        } catch (IllegalArgumentException exception) {
+            throw new IllegalArgumentException(
+                    "Invalid capacity values at unknown_servers.",
+                    exception
+            );
+        }
     }
 
-    private static String stringValue(String value, String fallback) {
-        return value == null ? fallback : value;
+    private static Duration requirePositive(Duration value, String path) {
+        if (value == null || value.isZero() || value.isNegative()) {
+            throw new IllegalArgumentException("Duration at " + path + " must be positive.");
+        }
+        return value;
     }
 
-    private static Duration positive(Duration value, Duration fallback) {
-        return value == null || value.isZero() || value.isNegative() ? fallback : value;
+    private static String requireText(String value, String path, int maximumLength) {
+        if (value == null || value.isBlank()) {
+            throw new IllegalArgumentException("Value at " + path + " must not be blank.");
+        }
+        String normalized = value.trim();
+        if (normalized.length() > maximumLength
+                || normalized.chars().anyMatch(Character::isISOControl)) {
+            throw new IllegalArgumentException("Invalid text value at " + path + '.');
+        }
+        return normalized;
+    }
+
+    private static String requiredIdentifier(String value, String type) {
+        String normalized = normalize(value);
+        if (normalized.isBlank()) throw new IllegalArgumentException("Blank " + type + " name.");
+        if (normalized.length() > MAX_IDENTIFIER_LENGTH) {
+            throw new IllegalArgumentException(
+                    type + " name exceeds " + MAX_IDENTIFIER_LENGTH + " characters."
+            );
+        }
+        if (normalized.indexOf(COMPOSITE_KEY_SEPARATOR) >= 0
+                || normalized.chars().anyMatch(character -> Character.isWhitespace(character)
+                || Character.isISOControl(character))) {
+            throw new IllegalArgumentException("Invalid " + type + " name: " + value);
+        }
+        return normalized;
+    }
+
+    private static <T> void putUnique(Map<String, T> target, String key, T value, String type) {
+        if (target.putIfAbsent(key, value) != null) {
+            throw new IllegalArgumentException(
+                    "Duplicate " + type + " identifier after normalization: " + key
+            );
+        }
     }
 
     public static String normalize(String value) {
diff --git a/proxyfeatures-platform-velocity/src/main/java/nl/hauntedmc/proxyfeatures/features/capacity/config/CapacityConfigEditor.java b/proxyfeatures-platform-velocity/src/main/java/nl/hauntedmc/proxyfeatures/features/capacity/config/CapacityConfigEditor.java
index 146d193c..c870d202 100644
--- a/proxyfeatures-platform-velocity/src/main/java/nl/hauntedmc/proxyfeatures/features/capacity/config/CapacityConfigEditor.java
+++ b/proxyfeatures-platform-velocity/src/main/java/nl/hauntedmc/proxyfeatures/features/capacity/config/CapacityConfigEditor.java
@@ -1,192 +1,61 @@
 package nl.hauntedmc.proxyfeatures.features.capacity.config;
 
-import nl.hauntedmc.proxyfeatures.api.capacity.CapacityState;
-
 import java.time.Duration;
-import java.util.ArrayList;
 import java.util.LinkedHashMap;
-import java.util.List;
 import java.util.Locale;
 import java.util.Map;
 import java.util.function.UnaryOperator;
 
-/** Pure immutable Capacity configuration mutations used by the administration command. */
+/** Pure immutable mutations for the small operational Capacity command surface. */
 public final class CapacityConfigEditor {
     private CapacityConfigEditor() {
     }
 
     public static CapacityConfig proxyLimit(CapacityConfig current, int capacity, int reserved) {
         return checked(copy(current, strictLimit(capacity, reserved, "proxy"), current.gameplay(),
-                current.groups(), current.servers(), current.unknownCountsTowardGameplay(),
-                current.unknownQueueable(), current.unknownCapacity(), current.unknownReservedSlots(),
-                current.leaseTtl(), current.loginReservationTtl(), current.reconciliationInterval(),
-                current.maintenanceSyncInterval(), current.queueOnFull(), current.failOpenOnInternalError(),
-                current.restartReturnUsesReservedSlots()));
+                current.groups(), current.servers()));
     }
 
     public static CapacityConfig gameplayLimit(CapacityConfig current, int capacity, int reserved) {
         return checked(copy(current, current.proxy(), strictLimit(capacity, reserved, "gameplay"),
-                current.groups(), current.servers(), current.unknownCountsTowardGameplay(),
-                current.unknownQueueable(), current.unknownCapacity(), current.unknownReservedSlots(),
-                current.leaseTtl(), current.loginReservationTtl(), current.reconciliationInterval(),
-                current.maintenanceSyncInterval(), current.queueOnFull(), current.failOpenOnInternalError(),
-                current.restartReturnUsesReservedSlots()));
+                current.groups(), current.servers()));
     }
 
     public static CapacityConfig groupLimit(CapacityConfig current, String groupName,
                                              int capacity, int reserved) {
         String group = requiredName(groupName, "group");
-        Map<String, CapacityConfig.GroupRule> groups = new LinkedHashMap<>(current.groups());
-        CapacityConfig.GroupRule existing = groups.get(group);
-        groups.put(group, new CapacityConfig.GroupRule(group,
-                strictLimit(capacity, reserved, "group " + group),
-                existing == null ? List.of() : existing.servers()));
-        return checked(withGroupsAndServers(current, groups, current.servers()));
-    }
-
-    public static CapacityConfig addGroupServer(CapacityConfig current, String groupName,
-                                                 String serverName) {
-        String group = requiredName(groupName, "group");
-        String server = requiredName(serverName, "server");
-        if (!current.groups().containsKey(group)) {
-            throw new IllegalArgumentException("Unknown group: " + group);
-        }
-        Map<String, CapacityConfig.GroupRule> groups = moveGroupMembership(current, group, server);
-        Map<String, CapacityConfig.ServerRule> servers = new LinkedHashMap<>(current.servers());
-        CapacityConfig.ServerRule explicit = servers.get(server);
-        if (explicit != null) {
-            servers.put(server, new CapacityConfig.ServerRule(server, explicit.limit(), group,
-                    explicit.countsTowardGameplay(), explicit.queueable(), explicit.initialState()));
-        }
-        return checked(withGroupsAndServers(current, groups, servers));
-    }
-
-    public static CapacityConfig removeGroupServer(CapacityConfig current, String groupName,
-                                                    String serverName) {
-        String group = requiredName(groupName, "group");
-        String server = requiredName(serverName, "server");
-        CapacityConfig.GroupRule existing = current.groups().get(group);
-        if (existing == null) throw new IllegalArgumentException("Unknown group: " + group);
-        Map<String, CapacityConfig.GroupRule> groups = new LinkedHashMap<>(current.groups());
-        List<String> members = new ArrayList<>(existing.servers());
-        members.remove(server);
-        groups.put(group, new CapacityConfig.GroupRule(group, existing.limit(), members));
-        Map<String, CapacityConfig.ServerRule> servers = new LinkedHashMap<>(current.servers());
-        CapacityConfig.ServerRule explicit = servers.get(server);
-        if (explicit != null && explicit.group().equals(group)) {
-            servers.put(server, new CapacityConfig.ServerRule(server, explicit.limit(), "",
-                    explicit.countsTowardGameplay(), explicit.queueable(), explicit.initialState()));
-        }
-        return checked(withGroupsAndServers(current, groups, servers));
-    }
-
-    public static CapacityConfig deleteGroup(CapacityConfig current, String groupName) {
-        String group = requiredName(groupName, "group");
         CapacityConfig.GroupRule existing = current.groups().get(group);
         if (existing == null) throw new IllegalArgumentException("Unknown group: " + group);
-        boolean referenced = !existing.servers().isEmpty() || current.servers().values().stream()
-                .anyMatch(server -> server.group().equals(group));
-        if (referenced) throw new IllegalArgumentException("Group is still used: " + group);
         Map<String, CapacityConfig.GroupRule> groups = new LinkedHashMap<>(current.groups());
-        groups.remove(group);
-        return checked(withGroupsAndServers(current, groups, current.servers()));
+        groups.put(group, new CapacityConfig.GroupRule(
+                group,
+                strictLimit(capacity, reserved, "group " + group),
+                existing.servers()
+        ));
+        return checked(copy(current, current.proxy(), current.gameplay(), groups, current.servers()));
     }
 
     public static CapacityConfig serverLimit(CapacityConfig current, String serverName,
                                               int capacity, int reserved) {
         return checked(updateServer(current, serverName, rule -> new CapacityConfig.ServerRule(
-                rule.name(), strictLimit(capacity, reserved, "server " + rule.name()), rule.group(),
-                rule.countsTowardGameplay(), rule.queueable(), rule.initialState())));
-    }
-
-    public static CapacityConfig serverGroup(CapacityConfig current, String serverName,
-                                              String groupName) {
-        String server = requiredName(serverName, "server");
-        String group = normalizeNone(groupName);
-        if (!group.isBlank() && !current.groups().containsKey(group)) {
-            throw new IllegalArgumentException("Unknown group: " + group);
-        }
-        Map<String, CapacityConfig.GroupRule> groups = moveGroupMembership(current, group, server);
-        Map<String, CapacityConfig.ServerRule> servers = new LinkedHashMap<>(current.servers());
-        CapacityConfig.ServerRule existing = current.server(server);
-        servers.put(server, new CapacityConfig.ServerRule(server, existing.limit(), group,
-                existing.countsTowardGameplay(), existing.queueable(), existing.initialState()));
-        return checked(withGroupsAndServers(current, groups, servers));
-    }
-
-    public static CapacityConfig serverGameplay(CapacityConfig current, String serverName, boolean value) {
-        return checked(updateServer(current, serverName, rule -> new CapacityConfig.ServerRule(
-                rule.name(), rule.limit(), rule.group(), value, rule.queueable(), rule.initialState())));
+                rule.name(),
+                strictLimit(capacity, reserved, "server " + rule.name()),
+                rule.group(),
+                rule.countsTowardGameplay(),
+                rule.queueable(),
+                rule.initialState()
+        )));
     }
 
     public static CapacityConfig serverQueueable(CapacityConfig current, String serverName, boolean value) {
         return checked(updateServer(current, serverName, rule -> new CapacityConfig.ServerRule(
-                rule.name(), rule.limit(), rule.group(), rule.countsTowardGameplay(), value,
-                rule.initialState())));
-    }
-
-    public static CapacityConfig serverInitialState(CapacityConfig current, String serverName,
-                                                     CapacityState state) {
-        if (state == null) throw new IllegalArgumentException("State is required.");
-        return checked(updateServer(current, serverName, rule -> new CapacityConfig.ServerRule(
-                rule.name(), rule.limit(), rule.group(), rule.countsTowardGameplay(), rule.queueable(), state)));
-    }
-
-    public static CapacityConfig deleteServer(CapacityConfig current, String serverName) {
-        String server = requiredName(serverName, "server");
-        if (!current.servers().containsKey(server)) {
-            throw new IllegalArgumentException("Unknown explicit server rule: " + server);
-        }
-        Map<String, CapacityConfig.ServerRule> servers = new LinkedHashMap<>(current.servers());
-        servers.remove(server);
-        Map<String, CapacityConfig.GroupRule> groups = moveGroupMembership(current, "", server);
-        return checked(withGroupsAndServers(current, groups, servers));
-    }
-
-    public static CapacityConfig unknownLimit(CapacityConfig current, int capacity, int reserved) {
-        CapacityConfig.Limit limit = strictLimit(capacity, reserved, "unknown servers");
-        return checked(copy(current, current.proxy(), current.gameplay(), current.groups(), current.servers(),
-                current.unknownCountsTowardGameplay(), current.unknownQueueable(), limit.capacity(),
-                limit.reservedSlots(), current.leaseTtl(), current.loginReservationTtl(),
-                current.reconciliationInterval(), current.maintenanceSyncInterval(), current.queueOnFull(),
-                current.failOpenOnInternalError(), current.restartReturnUsesReservedSlots()));
-    }
-
-    public static CapacityConfig unknownGameplay(CapacityConfig current, boolean value) {
-        return checked(copy(current, current.proxy(), current.gameplay(), current.groups(), current.servers(),
-                value, current.unknownQueueable(), current.unknownCapacity(), current.unknownReservedSlots(),
-                current.leaseTtl(), current.loginReservationTtl(), current.reconciliationInterval(),
-                current.maintenanceSyncInterval(), current.queueOnFull(), current.failOpenOnInternalError(),
-                current.restartReturnUsesReservedSlots()));
-    }
-
-    public static CapacityConfig unknownQueueable(CapacityConfig current, boolean value) {
-        return checked(copy(current, current.proxy(), current.gameplay(), current.groups(), current.servers(),
-                current.unknownCountsTowardGameplay(), value, current.unknownCapacity(),
-                current.unknownReservedSlots(), current.leaseTtl(), current.loginReservationTtl(),
-                current.reconciliationInterval(), current.maintenanceSyncInterval(), current.queueOnFull(),
-                current.failOpenOnInternalError(), current.restartReturnUsesReservedSlots()));
-    }
-
-    public static CapacityConfig option(CapacityConfig current, String option, String rawValue) {
-        String key = requiredName(option, "option").replace('_', '-');
-        return switch (key) {
-            case "lease-ttl" -> withTimings(current, duration(rawValue), current.loginReservationTtl(),
-                    current.reconciliationInterval(), current.maintenanceSyncInterval());
-            case "login-ttl" -> withTimings(current, current.leaseTtl(), duration(rawValue),
-                    current.reconciliationInterval(), current.maintenanceSyncInterval());
-            case "reconciliation" -> withTimings(current, current.leaseTtl(),
-                    current.loginReservationTtl(), duration(rawValue), current.maintenanceSyncInterval());
-            case "maintenance-sync" -> withTimings(current, current.leaseTtl(),
-                    current.loginReservationTtl(), current.reconciliationInterval(), duration(rawValue));
-            case "queue-on-full" -> withBehavior(current, bool(rawValue),
-                    current.failOpenOnInternalError(), current.restartReturnUsesReservedSlots());
-            case "fail-open" -> withBehavior(current, current.queueOnFull(), bool(rawValue),
-                    current.restartReturnUsesReservedSlots());
-            case "restart-reserved" -> withBehavior(current, current.queueOnFull(),
-                    current.failOpenOnInternalError(), bool(rawValue));
-            default -> throw new IllegalArgumentException("Unknown option: " + option);
-        };
+                rule.name(),
+                rule.limit(),
+                rule.group(),
+                rule.countsTowardGameplay(),
+                value,
+                rule.initialState()
+        )));
     }
 
     public static Duration duration(String raw) {
@@ -228,70 +97,35 @@ private static CapacityConfig updateServer(CapacityConfig current, String server
         String server = requiredName(serverName, "server");
         Map<String, CapacityConfig.ServerRule> servers = new LinkedHashMap<>(current.servers());
         servers.put(server, edit.apply(current.server(server)));
-        return withGroupsAndServers(current, current.groups(), servers);
-    }
-
-    private static Map<String, CapacityConfig.GroupRule> moveGroupMembership(
-            CapacityConfig current, String targetGroup, String server) {
-        Map<String, CapacityConfig.GroupRule> groups = new LinkedHashMap<>();
-        current.groups().forEach((name, rule) -> {
-            List<String> members = new ArrayList<>(rule.servers());
-            members.remove(server);
-            if (name.equals(targetGroup)) members.add(server);
-            groups.put(name, new CapacityConfig.GroupRule(name, rule.limit(), members));
-        });
-        return groups;
-    }
-
-    private static CapacityConfig withGroupsAndServers(CapacityConfig current,
-                                                       Map<String, CapacityConfig.GroupRule> groups,
-                                                       Map<String, CapacityConfig.ServerRule> servers) {
-        return copy(current, current.proxy(), current.gameplay(), groups, servers,
-                current.unknownCountsTowardGameplay(), current.unknownQueueable(), current.unknownCapacity(),
-                current.unknownReservedSlots(), current.leaseTtl(), current.loginReservationTtl(),
-                current.reconciliationInterval(), current.maintenanceSyncInterval(), current.queueOnFull(),
-                current.failOpenOnInternalError(), current.restartReturnUsesReservedSlots());
-    }
-
-    private static CapacityConfig withTimings(CapacityConfig current, Duration leaseTtl,
-                                              Duration loginTtl, Duration reconciliation,
-                                              Duration maintenanceSync) {
-        return checked(copy(current, current.proxy(), current.gameplay(), current.groups(), current.servers(),
-                current.unknownCountsTowardGameplay(), current.unknownQueueable(), current.unknownCapacity(),
-                current.unknownReservedSlots(), leaseTtl, loginTtl, reconciliation, maintenanceSync,
-                current.queueOnFull(), current.failOpenOnInternalError(),
-                current.restartReturnUsesReservedSlots()));
-    }
-
-    private static CapacityConfig withBehavior(CapacityConfig current, boolean queueOnFull,
-                                               boolean failOpen, boolean restartReserved) {
-        return checked(copy(current, current.proxy(), current.gameplay(), current.groups(), current.servers(),
-                current.unknownCountsTowardGameplay(), current.unknownQueueable(), current.unknownCapacity(),
-                current.unknownReservedSlots(), current.leaseTtl(), current.loginReservationTtl(),
-                current.reconciliationInterval(), current.maintenanceSyncInterval(), queueOnFull, failOpen,
-                restartReserved));
+        return copy(current, current.proxy(), current.gameplay(), current.groups(), servers);
     }
 
     private static CapacityConfig copy(CapacityConfig current,
                                        CapacityConfig.Limit proxy,
                                        CapacityConfig.Limit gameplay,
                                        Map<String, CapacityConfig.GroupRule> groups,
-                                       Map<String, CapacityConfig.ServerRule> servers,
-                                       boolean unknownGameplay,
-                                       boolean unknownQueueable,
-                                       int unknownCapacity,
-                                       int unknownReserved,
-                                       Duration leaseTtl,
-                                       Duration loginTtl,
-                                       Duration reconciliation,
-                                       Duration maintenanceSync,
-                                       boolean queueOnFull,
-                                       boolean failOpen,
-                                       boolean restartReserved) {
+                                       Map<String, CapacityConfig.ServerRule> servers) {
         if (current == null) throw new IllegalArgumentException("Current configuration is required.");
-        return new CapacityConfig(proxy, gameplay, groups, servers, unknownGameplay, unknownQueueable,
-                unknownCapacity, unknownReserved, leaseTtl, loginTtl, reconciliation, maintenanceSync,
-                queueOnFull, failOpen, restartReserved);
+        return new CapacityConfig(
+                proxy,
+                gameplay,
+                groups,
+                servers,
+                current.unknownCountsTowardGameplay(),
+                current.unknownQueueable(),
+                current.unknownCapacity(),
+                current.unknownReservedSlots(),
+                current.leaseTtl(),
+                current.loginReservationTtl(),
+                current.reconciliationInterval(),
+                current.maintenanceSyncInterval(),
+                current.snapshotChannel(),
+                current.snapshotPublishIntervalSeconds(),
+                current.snapshotPublisherId(),
+                current.queueOnFull(),
+                current.failOpenOnInternalError(),
+                current.restartReturnUsesReservedSlots()
+        );
     }
 
     private static CapacityConfig checked(CapacityConfig config) {
@@ -306,20 +140,6 @@ private static CapacityConfig.Limit strictLimit(int capacity, int reserved, Stri
         return new CapacityConfig.Limit(capacity, reserved);
     }
 
-    private static boolean bool(String raw) {
-        if (raw == null) throw new IllegalArgumentException("Boolean is required.");
-        return switch (raw.trim().toLowerCase(Locale.ROOT)) {
-            case "true", "yes", "on", "1" -> true;
-            case "false", "no", "off", "0" -> false;
-            default -> throw new IllegalArgumentException("Expected true or false, got: " + raw);
-        };
-    }
-
-    private static String normalizeNone(String value) {
-        String normalized = CapacityConfig.normalize(value);
-        return normalized.equals("none") ? "" : normalized;
-    }
-
     private static String requiredName(String value, String type) {
         String normalized = CapacityConfig.normalize(value);
         if (normalized.isBlank()) throw new IllegalArgumentException(type + " is required.");
diff --git a/proxyfeatures-platform-velocity/src/main/java/nl/hauntedmc/proxyfeatures/features/capacity/config/CapacityConfigStore.java b/proxyfeatures-platform-velocity/src/main/java/nl/hauntedmc/proxyfeatures/features/capacity/config/CapacityConfigStore.java
index 5c6aadb3..3504812f 100644
--- a/proxyfeatures-platform-velocity/src/main/java/nl/hauntedmc/proxyfeatures/features/capacity/config/CapacityConfigStore.java
+++ b/proxyfeatures-platform-velocity/src/main/java/nl/hauntedmc/proxyfeatures/features/capacity/config/CapacityConfigStore.java
@@ -8,6 +8,7 @@
 
 import java.time.DateTimeException;
 import java.time.Instant;
+import java.util.ArrayList;
 import java.util.LinkedHashMap;
 import java.util.List;
 import java.util.Locale;
@@ -16,8 +17,21 @@
 
 /** YAML-backed storage for Capacity configuration and manual server states. */
 public final class CapacityConfigStore {
-    public record ManualStateRecord(String server, CapacityState state, Instant expiresAt,
-                                    String reason, String actorName) {
+    public record ManualStateRecord(
+            String server,
+            CapacityState state,
+            Instant expiresAt,
+            String reason,
+            String actorName) {
+    }
+
+    public record StoredPolicy(
+            CapacityConfig configuration,
+            List<ManualStateRecord> manualStates) {
+        public StoredPolicy {
+            configuration = Objects.requireNonNull(configuration, "configuration");
+            manualStates = manualStates == null ? List.of() : List.copyOf(manualStates);
+        }
     }
 
     private static final String PERMANENT = "permanent";
@@ -28,12 +42,23 @@ public CapacityConfigStore(Capacity feature) {
         this.feature = Objects.requireNonNull(feature, "feature");
     }
 
+    /** Reloads the YAML once and parses both the policy and manual states from that same view. */
+    public StoredPolicy loadPolicy() {
+        CapacityConfig configuration = loadConfiguration();
+        return new StoredPolicy(configuration, readManualStates());
+    }
+
     public CapacityConfig loadConfiguration() {
         CapacityConfig config = CapacityConfig.load(feature);
         CapacityConfigValidator.validate(config);
         return config;
     }
 
+    public List<ManualStateRecord> loadManualStates() {
+        feature.getConfigHandler().reloadConfig();
+        return readManualStates();
+    }
+
     public void saveConfiguration(CapacityConfig config) {
         CapacityConfigValidator.validate(config);
         feature.getConfigHandler().batch(batch -> {
@@ -43,37 +68,34 @@ public void saveConfiguration(CapacityConfig config) {
             put(batch, "unknown_servers", unknownServers(config));
             put(batch, "leases", leases(config));
             put(batch, "reconciliation", Map.of(
-                    "interval_seconds", config.reconciliationInterval().toSeconds()));
-            put(batch, "integrations.maintenance_sync_interval_millis",
-                    config.maintenanceSyncInterval().toMillis());
+                    "interval_seconds", config.reconciliationInterval().toSeconds()
+            ));
+            put(
+                    batch,
+                    "integrations.maintenance_sync_interval_millis",
+                    config.maintenanceSyncInterval().toMillis()
+            );
+            put(batch, "messaging", messaging(config));
             put(batch, "queue.on_full", config.queueOnFull());
-            put(batch, "failure.fail_open_on_internal_error", config.failOpenOnInternalError());
-            put(batch, "restart_return.use_reserved_slots",
-                    config.restartReturnUsesReservedSlots());
+            put(
+                    batch,
+                    "failure.fail_open_on_internal_error",
+                    config.failOpenOnInternalError()
+            );
+            put(
+                    batch,
+                    "restart_return.use_reserved_slots",
+                    config.restartReturnUsesReservedSlots()
+            );
         });
     }
 
-    public List<ManualStateRecord> loadManualStates() {
-        feature.getConfigHandler().reloadConfig();
-        Map<String, Object> retained = new LinkedHashMap<>();
-        List<ManualStateRecord> states = feature.getConfigHandler().node("manual_states")
-                .children().entrySet().stream()
-                .map(entry -> parseManualState(entry.getKey(), entry.getValue()))
-                .filter(Objects::nonNull)
-                .peek(state -> retained.put(state.server(), manualState(state)))
-                .toList();
-
-        if (retained.size() != feature.getConfigHandler().node("manual_states").children().size()) {
-            feature.getConfigHandler().put("manual_states", retained);
-        }
-        return states;
-    }
-
-    public ManualStateRecord saveManualState(String rawServer,
-                                             CapacityState state,
-                                             Instant expiresAt,
-                                             String actorName,
-                                             String reason) {
+    public ManualStateRecord saveManualState(
+            String rawServer,
+            CapacityState state,
+            Instant expiresAt,
+            String actorName,
+            String reason) {
         String server = requiredName(rawServer, "server");
         if (state == null || state == CapacityState.OPEN) {
             throw new IllegalArgumentException("Use clearManualState for OPEN.");
@@ -102,43 +124,114 @@ public boolean clearManualState(String rawServer) {
         return removed;
     }
 
+    private List<ManualStateRecord> readManualStates() {
+        ConfigNode section = feature.getConfigHandler().node("manual_states");
+        if (section == null || section.isNull()) return List.of();
+        if (!(section.raw() instanceof Map<?, ?>)) {
+            throw new IllegalArgumentException("Expected a map at manual_states.");
+        }
+
+        Map<String, Object> retained = new LinkedHashMap<>();
+        List<ManualStateRecord> states = new ArrayList<>();
+        section.children().entrySet().stream()
+                .sorted(Map.Entry.comparingByKey())
+                .forEach(entry -> {
+                    ManualStateRecord state = parseManualState(entry.getKey(), entry.getValue());
+                    if (state == null) return;
+                    if (retained.putIfAbsent(state.server(), manualState(state)) != null) {
+                        throw new IllegalArgumentException(
+                                "Duplicate manual state after normalization: " + state.server()
+                        );
+                    }
+                    states.add(state);
+                });
+
+        if (retained.size() != section.children().size()) {
+            feature.getConfigHandler().put("manual_states", retained);
+        }
+        return List.copyOf(states);
+    }
+
     private ManualStateRecord parseManualState(String rawServer, ConfigNode node) {
         String server = requiredName(rawServer, "server");
+        if (node == null || !(node.raw() instanceof Map<?, ?>)) {
+            throw new IllegalArgumentException(
+                    "Expected a map at manual_states." + rawServer + '.'
+            );
+        }
+
         CapacityState state;
+        String stateValue = requiredText(node.get("state"), "manual_states." + rawServer + ".state");
         try {
-            state = CapacityState.valueOf(node.get("state")
-                    .asRequired(String.class)
-                    .trim()
-                    .toUpperCase(Locale.ROOT));
+            state = CapacityState.valueOf(stateValue.trim().toUpperCase(Locale.ROOT));
         } catch (RuntimeException exception) {
             throw new IllegalArgumentException(
-                    "Invalid manual Capacity state for server " + server + '.', exception);
+                    "Invalid manual Capacity state for server " + server + '.',
+                    exception
+            );
         }
         if (state == CapacityState.OPEN) return null;
 
-        Instant expiresAt = parseExpiry(node.get("expires_at").as(String.class, PERMANENT), server);
+        Instant expiresAt = parseExpiry(optionalText(
+                node.get("expires_at"),
+                PERMANENT,
+                "manual_states." + rawServer + ".expires_at"
+        ), server);
         if (expiresAt != null && !expiresAt.isAfter(Instant.now())) return null;
         return new ManualStateRecord(
                 server,
                 state,
                 expiresAt,
-                text(node.get("reason").as(String.class, "Manual state"), "Manual state", 512),
-                text(node.get("actor").as(String.class, "config"), "config", 64)
+                text(optionalText(
+                        node.get("reason"),
+                        "Manual state",
+                        "manual_states." + rawServer + ".reason"
+                ), "Manual state", 512),
+                text(optionalText(
+                        node.get("actor"),
+                        "config",
+                        "manual_states." + rawServer + ".actor"
+                ), "config", 64)
         );
     }
 
     private Map<String, Object> manualStateMap() {
+        ConfigNode section = feature.getConfigHandler().node("manual_states");
+        if (section == null || section.isNull()) return new LinkedHashMap<>();
+        if (!(section.raw() instanceof Map<?, ?>)) {
+            throw new IllegalArgumentException("Expected a map at manual_states.");
+        }
         Map<String, Object> result = new LinkedHashMap<>();
-        feature.getConfigHandler().node("manual_states").children().entrySet().stream()
+        section.children().entrySet().stream()
                 .sorted(Map.Entry.comparingByKey())
-                .forEach(entry -> result.put(CapacityConfig.normalize(entry.getKey()),
-                        entry.getValue().raw()));
+                .forEach(entry -> {
+                    String server = requiredName(entry.getKey(), "server");
+                    if (result.putIfAbsent(server, entry.getValue().raw()) != null) {
+                        throw new IllegalArgumentException(
+                                "Duplicate manual state after normalization: " + server
+                        );
+                    }
+                });
         return result;
     }
 
+    private static String requiredText(ConfigNode node, String path) {
+        if (node != null && node.raw() instanceof String value && !value.isBlank()) {
+            return value;
+        }
+        throw new IllegalArgumentException("Expected non-blank text at " + path + '.');
+    }
+
+    private static String optionalText(ConfigNode node, String fallback, String path) {
+        if (node == null || node.isNull()) return fallback;
+        if (node.raw() instanceof String value) return value;
+        throw new IllegalArgumentException("Expected text at " + path + '.');
+    }
+
     private static Instant parseExpiry(String raw, String server) {
         String value = raw == null ? PERMANENT : raw.trim();
-        if (value.isBlank() || value.equalsIgnoreCase(PERMANENT)
+        if (value.isBlank()
+                || value.equalsIgnoreCase(PERMANENT)
                 || value.equalsIgnoreCase("never")) {
             return null;
         }
@@ -147,7 +240,8 @@ private static Instant parseExpiry(String raw, String server) {
         } catch (DateTimeException exception) {
             throw new IllegalArgumentException(
                     "Invalid manual state expiry for server " + server + ": " + value,
-                    exception);
+                    exception
+            );
         }
     }
 
@@ -172,7 +266,6 @@ private static Map<String, Object> servers(CapacityConfig config) {
         Map<String, Object> servers = new LinkedHashMap<>();
         config.servers().forEach((name, rule) -> {
             Map<String, Object> raw = limit(rule.limit());
-            raw.put("group", rule.group());
             raw.put("counts_toward_gameplay", rule.countsTowardGameplay());
             raw.put("queueable", rule.queueable());
             raw.put("initial_state", rule.initialState().name());
@@ -197,6 +290,14 @@ private static Map<String, Object> leases(CapacityConfig config) {
         return leases;
     }
 
+    private static Map<String, Object> messaging(CapacityConfig config) {
+        Map<String, Object> messaging = new LinkedHashMap<>();
+        messaging.put("channel", config.snapshotChannel());
+        messaging.put("publish_interval_seconds", config.snapshotPublishIntervalSeconds());
+        messaging.put("publisher_id", config.snapshotPublisherId());
+        return messaging;
+    }
+
     private static Map<String, Object> limit(CapacityConfig.Limit limit) {
         Map<String, Object> raw = new LinkedHashMap<>();
         raw.put("capacity", limit.capacity());
@@ -207,7 +308,10 @@ private static Map<String, Object> limit(CapacityConfig.Limit limit) {
     private static Map<String, Object> manualState(ManualStateRecord state) {
         Map<String, Object> raw = new LinkedHashMap<>();
         raw.put("state", state.state().name());
-        raw.put("expires_at", state.expiresAt() == null ? PERMANENT : state.expiresAt().toString());
+        raw.put(
+                "expires_at",
+                state.expiresAt() == null ? PERMANENT : state.expiresAt().toString()
+        );
         raw.put("reason", state.reason());
         raw.put("actor", state.actorName());
         return raw;
@@ -217,7 +321,10 @@ private static void put(ConfigView.Batch batch, String path, Object value) {
         try {
             batch.put(path, value);
         } catch (SerializationException exception) {
-            throw new IllegalStateException("Could not write Capacity config path " + path + '.', exception);
+            throw new IllegalStateException(
+                    "Could not write Capacity config path " + path + '.',
+                    exception
+            );
         }
     }
 
diff --git a/proxyfeatures-platform-velocity/src/main/java/nl/hauntedmc/proxyfeatures/features/capacity/config/CapacityConfigValidator.java b/proxyfeatures-platform-velocity/src/main/java/nl/hauntedmc/proxyfeatures/features/capacity/config/CapacityConfigValidator.java
index a517cad9..b5bb1942 100644
--- a/proxyfeatures-platform-velocity/src/main/java/nl/hauntedmc/proxyfeatures/features/capacity/config/CapacityConfigValidator.java
+++ b/proxyfeatures-platform-velocity/src/main/java/nl/hauntedmc/proxyfeatures/features/capacity/config/CapacityConfigValidator.java
@@ -1,9 +1,7 @@
 package nl.hauntedmc.proxyfeatures.features.capacity.config;
 
 import java.util.HashMap;
-import java.util.HashSet;
 import java.util.Map;
-import java.util.Set;
 
 /** Strict structural validation shared by config loading and command mutations. */
 public final class CapacityConfigValidator {
@@ -20,7 +18,6 @@ public static void validate(CapacityConfig config) {
         validateLimit(new CapacityConfig.Limit(
                 config.unknownCapacity(), config.unknownReservedSlots()), "unknown servers");
 
-        Set<String> assignedServers = new HashSet<>();
         Map<String, String> membership = new HashMap<>();
         for (var entry : config.groups().entrySet()) {
             String name = requiredName(entry.getKey(), "group");
@@ -31,10 +28,11 @@ public static void validate(CapacityConfig config) {
             validateLimit(rule.limit(), "group " + name);
             for (String rawServer : rule.servers()) {
                 String server = requiredName(rawServer, "server");
-                if (!assignedServers.add(server)) {
-                    throw new IllegalArgumentException("Server belongs to multiple groups: " + server);
+                String previous = membership.putIfAbsent(server, name);
+                if (previous != null) {
+                    throw new IllegalArgumentException("Server " + server
+                            + " belongs to multiple groups: " + previous + " and " + name);
                 }
-                membership.put(server, name);
             }
         }
 
@@ -45,14 +43,10 @@ public static void validate(CapacityConfig config) {
                 throw new IllegalArgumentException("Server key and name differ: " + name);
             }
             validateLimit(rule.limit(), "server " + name);
-            String declaredGroup = rule.group().isBlank() ? "" : requiredName(rule.group(), "group");
-            if (!declaredGroup.isBlank() && !config.groups().containsKey(declaredGroup)) {
-                throw new IllegalArgumentException("Server " + name
-                        + " references unknown group " + declaredGroup);
-            }
-            if (!membership.getOrDefault(name, "").equals(declaredGroup)) {
-                throw new IllegalArgumentException("Server " + name
-                        + " has inconsistent explicit and group-list membership.");
+            String expectedGroup = membership.getOrDefault(name, "");
+            if (!expectedGroup.equals(rule.group())) {
+                throw new IllegalArgumentException("Resolved group for server " + name
+                        + " does not match groups.*.servers membership.");
             }
         }
     }
diff --git a/proxyfeatures-platform-velocity/src/main/java/nl/hauntedmc/proxyfeatures/features/capacity/internal/CapacityControlPlane.java b/proxyfeatures-platform-velocity/src/main/java/nl/hauntedmc/proxyfeatures/features/capacity/internal/CapacityControlPlane.java
index 8e83dded..d30a3b77 100644
--- a/proxyfeatures-platform-velocity/src/main/java/nl/hauntedmc/proxyfeatures/features/capacity/internal/CapacityControlPlane.java
+++ b/proxyfeatures-platform-velocity/src/main/java/nl/hauntedmc/proxyfeatures/features/capacity/internal/CapacityControlPlane.java
@@ -33,10 +33,11 @@ public final class CapacityControlPlane {
     private ScheduledTask expiryTask;
     private boolean closed;
 
-    public CapacityControlPlane(Capacity feature,
-                                CapacityService service,
-                                CapacityConfigStore store,
-                                CapacityConfig initial) {
+    public CapacityControlPlane(
+            Capacity feature,
+            CapacityService service,
+            CapacityConfigStore store,
+            CapacityConfig initial) {
         this.feature = Objects.requireNonNull(feature, "feature");
         this.service = Objects.requireNonNull(service, "service");
         this.store = Objects.requireNonNull(store, "store");
@@ -53,14 +54,18 @@ public synchronized void start(List<CapacityConfigStore.ManualStateRecord> store
         );
     }
 
-    public synchronized void shutdown() {
-        if (closed) return;
-        closed = true;
-        if (expiryTask != null) {
-            feature.getLifecycleManager().getTaskManager().cancelTask(expiryTask);
-            expiryTask = null;
+    public void shutdown() {
+        synchronized (operationLock) {
+            synchronized (this) {
+                if (closed) return;
+                closed = true;
+                if (expiryTask != null) {
+                    feature.getLifecycleManager().getTaskManager().cancelTask(expiryTask);
+                    expiryTask = null;
+                }
+                manualStates.clear();
+            }
         }
-        manualStates.clear();
     }
 
     public synchronized CapacityConfig config() {
@@ -80,10 +85,16 @@ public CompletableFuture<CapacityConfig> updateConfiguration(
                 ensureOpen();
                 current = config;
             }
-            CapacityConfig next = Objects.requireNonNull(mutation.apply(current), "mutation result");
+            CapacityConfig next = Objects.requireNonNull(
+                    mutation.apply(current),
+                    "mutation result"
+            );
             if (current.equals(next)) {
                 throw new IllegalArgumentException("Configuration is unchanged.");
             }
+            synchronized (this) {
+                ensureOpen();
+            }
             store.saveConfiguration(next);
             applyConfiguration(next);
             return next;
@@ -92,13 +103,15 @@ public CompletableFuture<CapacityConfig> updateConfiguration(
 
     public CompletableFuture<CapacityConfig> reload() {
         return submit(() -> {
-            CapacityConfig loaded = store.loadConfiguration();
-            List<CapacityConfigStore.ManualStateRecord> states = store.loadManualStates();
-            applyConfiguration(loaded);
             synchronized (this) {
-                replaceManualStates(states);
+                ensureOpen();
             }
-            return loaded;
+            CapacityConfigStore.StoredPolicy stored = store.loadPolicy();
+            applyConfiguration(stored.configuration());
+            synchronized (this) {
+                replaceManualStates(stored.manualStates());
+            }
+            return stored.configuration();
         });
     }
 
@@ -109,8 +122,16 @@ public CompletableFuture<CapacityConfigStore.ManualStateRecord> setManualState(
             String actorName,
             String reason) {
         return submit(() -> {
+            synchronized (this) {
+                ensureOpen();
+            }
             CapacityConfigStore.ManualStateRecord stored = store.saveManualState(
-                    server, state, expiresAt, actorName, reason);
+                    server,
+                    state,
+                    expiresAt,
+                    actorName,
+                    reason
+            );
             synchronized (this) {
                 ensureOpen();
                 manualStates.put(stored.server(), stored);
@@ -122,6 +143,9 @@ public CompletableFuture<CapacityConfigStore.ManualStateRecord> setManualState(
 
     public CompletableFuture<Boolean> clearManualState(String server) {
         return submit(() -> {
+            synchronized (this) {
+                ensureOpen();
+            }
             boolean removed = store.clearManualState(server);
             synchronized (this) {
                 ensureOpen();
@@ -134,9 +158,9 @@ public CompletableFuture<Boolean> clearManualState(String server) {
 
     private synchronized void applyConfiguration(CapacityConfig next) {
         ensureOpen();
+        service.reload(next);
         config = next;
-        service.reload();
-        feature.reloadIntegrations();
+        feature.reloadRuntimeSettings();
     }
 
     private synchronized void replaceManualStates(
@@ -197,21 +221,26 @@ private <T> CompletableFuture<T> submit(Callable<T> operation) {
         synchronized (this) {
             if (closed) {
                 future.completeExceptionally(new IllegalStateException(
-                        "Capacity control plane is closed."));
+                        "Capacity control plane is closed."
+                ));
                 return future;
             }
         }
-        feature.getLifecycleManager().getTaskManager().scheduleTask(() -> {
-            try {
-                T result;
-                synchronized (operationLock) {
-                    result = operation.call();
+        try {
+            feature.getLifecycleManager().getTaskManager().scheduleTask(() -> {
+                try {
+                    T result;
+                    synchronized (operationLock) {
+                        result = operation.call();
+                    }
+                    future.complete(result);
+                } catch (Throwable error) {
+                    future.completeExceptionally(error);
                 }
-                future.complete(result);
-            } catch (Throwable error) {
-                future.completeExceptionally(error);
-            }
-        });
+            });
+        } catch (Throwable error) {
+            future.completeExceptionally(error);
+        }
         return future;
     }
 
diff --git a/proxyfeatures-platform-velocity/src/main/java/nl/hauntedmc/proxyfeatures/features/capacity/internal/CapacityService.java b/proxyfeatures-platform-velocity/src/main/java/nl/hauntedmc/proxyfeatures/features/capacity/internal/CapacityService.java
index 4dc33de4..8c7faa16 100644
--- a/proxyfeatures-platform-velocity/src/main/java/nl/hauntedmc/proxyfeatures/features/capacity/internal/CapacityService.java
+++ b/proxyfeatures-platform-velocity/src/main/java/nl/hauntedmc/proxyfeatures/features/capacity/internal/CapacityService.java
@@ -3,7 +3,6 @@
 import com.velocitypowered.api.proxy.Player;
 import com.velocitypowered.api.proxy.ProxyServer;
 import com.velocitypowered.api.scheduler.ScheduledTask;
-import nl.hauntedmc.proxyfeatures.api.queue.QueueAdmissionAPI;
 import nl.hauntedmc.proxyfeatures.api.capacity.AdmissionIntent;
 import nl.hauntedmc.proxyfeatures.api.capacity.CapacityAPI;
 import nl.hauntedmc.proxyfeatures.api.capacity.CapacityDecision;
@@ -13,6 +12,7 @@
 import nl.hauntedmc.proxyfeatures.api.capacity.CapacityScopeSnapshot;
 import nl.hauntedmc.proxyfeatures.api.capacity.CapacitySnapshot;
 import nl.hauntedmc.proxyfeatures.api.capacity.CapacityState;
+import nl.hauntedmc.proxyfeatures.api.queue.QueueAdmissionAPI;
 import nl.hauntedmc.proxyfeatures.features.capacity.Capacity;
 import nl.hauntedmc.proxyfeatures.features.capacity.config.CapacityConfig;
 import nl.hauntedmc.proxyfeatures.framework.service.FeatureServices;
@@ -26,8 +26,10 @@
 import java.util.LinkedHashMap;
 import java.util.Locale;
 import java.util.Map;
+import java.util.Objects;
 import java.util.Optional;
 import java.util.Set;
+import java.util.TreeSet;
 import java.util.UUID;
 
 /**
@@ -73,9 +75,13 @@ private record ProxyUsage(int occupied, int pending) {
     private boolean closed;
 
     public CapacityService(Capacity feature) {
-        this.feature = feature;
+        this(feature, CapacityConfig.load(feature));
+    }
+
+    public CapacityService(Capacity feature, CapacityConfig initialConfig) {
+        this.feature = Objects.requireNonNull(feature, "feature");
         this.proxy = feature.getPlugin().getProxy();
-        this.config = CapacityConfig.load(feature);
+        this.config = Objects.requireNonNull(initialConfig, "initialConfig");
     }
 
     public synchronized void start() {
@@ -84,7 +90,11 @@ public synchronized void start() {
     }
 
     public synchronized void reload() {
-        config = CapacityConfig.load(feature);
+        reload(CapacityConfig.load(feature));
+    }
+
+    public synchronized void reload(CapacityConfig nextConfig) {
+        config = Objects.requireNonNull(nextConfig, "nextConfig");
         configGeneration++;
         cleanupExpired(System.currentTimeMillis());
         revokeBlockedLeases(null);
@@ -93,6 +103,7 @@ public synchronized void reload() {
             reconciliationTask = null;
             scheduleReconciliation();
         }
+        wakeQueues();
     }
 
     public CapacityConfig config() {
@@ -129,8 +140,10 @@ public synchronized LoginDecision reserveLogin(Player player) {
 
         CapacityConfig.Limit limit = config.proxy();
         if (!limit.enabled() || player.hasPermission(config.capacityBypassPermission())) {
-            loginReservations.put(playerId, new LoginReservation(deadline(now,
-                    config.loginReservationTtl().toMillis())));
+            loginReservations.put(playerId, new LoginReservation(deadline(
+                    now,
+                    config.loginReservationTtl().toMillis()
+            )));
             return LoginDecision.allow();
         }
 
@@ -149,8 +162,10 @@ public synchronized LoginDecision reserveLogin(Player player) {
             return LoginDecision.deny(CapacityDenialReason.PROXY_HARD_LIMIT, "proxy");
         }
 
-        loginReservations.put(playerId, new LoginReservation(deadline(now,
-                config.loginReservationTtl().toMillis())));
+        loginReservations.put(playerId, new LoginReservation(deadline(
+                now,
+                config.loginReservationTtl().toMillis()
+        )));
         return LoginDecision.allow();
     }
 
@@ -171,7 +186,10 @@ public synchronized CapacityDecision tryAcquire(CapacityRequest request) {
         long now = System.currentTimeMillis();
         cleanupExpired(now);
         if (proxy.getServer(request.targetServer()).isEmpty()) {
-            return CapacityDecision.deny(CapacityDenialReason.UNKNOWN_TARGET, "server:" + request.targetServer());
+            return CapacityDecision.deny(
+                    CapacityDenialReason.UNKNOWN_TARGET,
+                    "server:" + request.targetServer()
+            );
         }
 
         LeaseImpl existing = pendingByPlayer.get(request.playerId());
@@ -188,7 +206,10 @@ public synchronized CapacityDecision tryAcquire(CapacityRequest request) {
         CapacityState state = effectiveState(request.targetServer());
         if (!request.stateBypass() && !state.acceptsNormalAdmissions()) {
             if (existing != null) releaseLease(existing, true);
-            return CapacityDecision.deny(CapacityDenialReason.SERVER_STATE, "server:" + request.targetServer());
+            return CapacityDecision.deny(
+                    CapacityDenialReason.SERVER_STATE,
+                    "server:" + request.targetServer()
+            );
         }
         if (existing != null && existing.isActive()) {
             return CapacityDecision.allow(existing);
@@ -212,16 +233,30 @@ public synchronized CapacityDecision tryAcquire(CapacityRequest request) {
 
         if (!request.capacityBypass()) {
             if (!request.previousServer().equals(request.targetServer())
-                    && exceeds(targetRule.limit(), usage.serverUsed(request.targetServer()), delta,
-                    privilegedCapacity)) {
-                return CapacityDecision.deny(CapacityDenialReason.FULL, "server:" + request.targetServer());
+                    && exceeds(
+                    targetRule.limit(),
+                    usage.serverUsed(request.targetServer()),
+                    delta,
+                    privilegedCapacity
+            )) {
+                return CapacityDecision.deny(
+                        CapacityDenialReason.FULL,
+                        "server:" + request.targetServer()
+                );
             }
 
             if (!targetGroup.isBlank() && !targetGroup.equals(previousGroup)) {
                 CapacityConfig.GroupRule groupRule = config.groups().get(targetGroup);
-                if (groupRule != null && exceeds(groupRule.limit(), usage.groupUsed(targetGroup), delta,
-                        privilegedCapacity)) {
-                    return CapacityDecision.deny(CapacityDenialReason.FULL, "group:" + targetGroup);
+                if (groupRule != null && exceeds(
+                        groupRule.limit(),
+                        usage.groupUsed(targetGroup),
+                        delta,
+                        privilegedCapacity
+                )) {
+                    return CapacityDecision.deny(
+                            CapacityDenialReason.FULL,
+                            "group:" + targetGroup
+                    );
                 }
             }
 
@@ -251,7 +286,9 @@ public synchronized Optional<CapacityLease> findPreparedLease(UUID playerId, Str
         cleanupExpired(System.currentTimeMillis());
         LeaseImpl lease = pendingByPlayer.get(playerId);
         if (lease == null || !lease.isActive()) return Optional.empty();
-        return lease.targetServer().equals(normalize(targetServer)) ? Optional.of(lease) : Optional.empty();
+        return lease.targetServer().equals(normalize(targetServer))
+                ? Optional.of(lease)
+                : Optional.empty();
     }
 
     public synchronized void connected(UUID playerId, String serverName) {
@@ -287,7 +324,10 @@ public synchronized void setServerState(String serverName, CapacityState state,
         String claimOwner = normalizeOwner(owner);
         if (closed || server.isBlank() || claimOwner.isBlank()) return;
         CapacityState previous = effectiveState(server);
-        Map<String, StateClaim> claims = stateClaims.computeIfAbsent(server, ignored -> new LinkedHashMap<>());
+        Map<String, StateClaim> claims = stateClaims.computeIfAbsent(
+                server,
+                ignored -> new LinkedHashMap<>()
+        );
         if (state == null || state == CapacityState.OPEN) {
             claims.remove(claimOwner);
         } else {
@@ -308,13 +348,18 @@ public synchronized CapacityState getServerState(String serverName) {
     }
 
     @Override
-    public synchronized void reserveRestoration(String serverName, Collection<UUID> playerIds, Instant expiresAt) {
+    public synchronized void reserveRestoration(
+            String serverName,
+            Collection<UUID> playerIds,
+            Instant expiresAt) {
         String server = normalize(serverName);
         if (server.isBlank() || playerIds == null || playerIds.isEmpty() || expiresAt == null) return;
         long expiry = expiresAt.toEpochMilli();
         if (expiry <= System.currentTimeMillis()) return;
-        Map<UUID, Restoration> restorations = restorationsByServer.computeIfAbsent(server,
-                ignored -> new LinkedHashMap<>());
+        Map<UUID, Restoration> restorations = restorationsByServer.computeIfAbsent(
+                server,
+                ignored -> new LinkedHashMap<>()
+        );
         for (UUID playerId : playerIds) {
             if (playerId != null) restorations.put(playerId, new Restoration(expiry));
         }
@@ -374,8 +419,7 @@ public synchronized CapacitySnapshot snapshot() {
         }
 
         Map<String, CapacityScopeSnapshot> servers = new LinkedHashMap<>();
-        for (var registered : proxy.getAllServers()) {
-            String server = normalize(registered.getServerInfo().getName());
+        for (String server : observableServerNames()) {
             CapacityConfig.ServerRule rule = config.server(server);
             servers.put(server, scope(
                     server,
@@ -387,7 +431,13 @@ public synchronized CapacitySnapshot snapshot() {
             ));
         }
 
-        return new CapacitySnapshot(proxySnapshot, gameplaySnapshot, groups, servers, leasesById.size());
+        return new CapacitySnapshot(
+                proxySnapshot,
+                gameplaySnapshot,
+                groups,
+                servers,
+                leasesById.size()
+        );
     }
 
     private void scheduleReconciliation() {
@@ -426,7 +476,9 @@ private Usage captureUsage(long now) {
                 String server = normalize(connection.getServerInfo().getName());
                 CapacityConfig.ServerRule rule = config.server(server);
                 usage.serverOccupied.merge(server, 1, Integer::sum);
-                if (!rule.group().isBlank()) usage.groupOccupied.merge(rule.group(), 1, Integer::sum);
+                if (!rule.group().isBlank()) {
+                    usage.groupOccupied.merge(rule.group(), 1, Integer::sum);
+                }
                 if (rule.countsTowardGameplay()) usage.gameplayOccupied++;
             });
         }
@@ -480,8 +532,13 @@ private boolean exceeds(CapacityConfig.Limit limit, int used, int delta, boolean
         return used + delta > Math.max(0, maximum);
     }
 
-    private CapacityScopeSnapshot scope(String name, CapacityConfig.Limit limit, int occupied,
-                                    int pending, int restoration, CapacityState state) {
+    private CapacityScopeSnapshot scope(
+            String name,
+            CapacityConfig.Limit limit,
+            int occupied,
+            int pending,
+            int restoration,
+            CapacityState state) {
         return new CapacityScopeSnapshot(
                 name,
                 limit == null ? 0 : limit.capacity(),
@@ -541,8 +598,10 @@ private Restoration removeRestoration(String server, UUID playerId) {
     private void restoreRestoration(LeaseImpl lease) {
         if (lease.claimedRestoration == null
                 || lease.claimedRestoration.expiresAtMillis <= System.currentTimeMillis()) return;
-        restorationsByServer.computeIfAbsent(lease.targetServer(), ignored -> new LinkedHashMap<>())
-                .put(lease.playerId(), lease.claimedRestoration);
+        restorationsByServer.computeIfAbsent(
+                lease.targetServer(),
+                ignored -> new LinkedHashMap<>()
+        ).put(lease.playerId(), lease.claimedRestoration);
     }
 
     private void cleanupExpired(long now) {
@@ -555,6 +614,35 @@ private void cleanupExpired(long now) {
         restorationsByServer.entrySet().removeIf(entry -> entry.getValue().isEmpty());
     }
 
+    private Set<String> observableServerNames() {
+        Set<String> names = configuredServerNames();
+        names.addAll(stateClaims.keySet());
+        names.addAll(restorationsByServer.keySet());
+        leasesById.values().stream()
+                .filter(LeaseImpl::isActive)
+                .map(LeaseImpl::targetServer)
+                .forEach(names::add);
+        return names;
+    }
+
+    private Set<String> configuredServerNames() {
+        Set<String> names = new TreeSet<>();
+        proxy.getAllServers().stream()
+                .map(server -> normalize(server.getServerInfo().getName()))
+                .filter(name -> !name.isBlank())
+                .forEach(names::add);
+        names.addAll(config.servers().keySet());
+        config.groups().values().stream()
+                .flatMap(group -> group.servers().stream())
+                .forEach(names::add);
+        return names;
+    }
+
+    private void wakeQueues() {
+        FeatureServices.find(feature, QueueAdmissionAPI.class).ifPresent(api ->
+                configuredServerNames().forEach(api::wake));
+    }
+
     private void commitLease(LeaseImpl lease) {
         if (lease == null || !lease.active) return;
         lease.active = false;
@@ -619,8 +707,12 @@ private final class LeaseImpl implements CapacityLease {
         private final long configGeneration;
         private boolean active = true;
 
-        private LeaseImpl(UUID id, CapacityRequest request, Instant expiresAt,
-                          Restoration claimedRestoration, long configGeneration) {
+        private LeaseImpl(
+                UUID id,
+                CapacityRequest request,
+                Instant expiresAt,
+                Restoration claimedRestoration,
+                long configGeneration) {
             this.id = id;
             this.request = request;
             this.expiresAt = expiresAt;
diff --git a/proxyfeatures-platform-velocity/src/main/java/nl/hauntedmc/proxyfeatures/features/capacity/meta/Meta.java b/proxyfeatures-platform-velocity/src/main/java/nl/hauntedmc/proxyfeatures/features/capacity/meta/Meta.java
index 8f040bcd..bac9c0ee 100644
--- a/proxyfeatures-platform-velocity/src/main/java/nl/hauntedmc/proxyfeatures/features/capacity/meta/Meta.java
+++ b/proxyfeatures-platform-velocity/src/main/java/nl/hauntedmc/proxyfeatures/features/capacity/meta/Meta.java
@@ -10,6 +10,6 @@ public String getFeatureName() {
 
     @Override
     public String getFeatureVersion() {
-        return "1.3.0";
+        return "1.4.0";
     }
 }
diff --git a/proxyfeatures-platform-velocity/src/test/java/nl/hauntedmc/proxyfeatures/features/capacity/command/CapacityCommandTest.java b/proxyfeatures-platform-velocity/src/test/java/nl/hauntedmc/proxyfeatures/features/capacity/command/CapacityCommandTest.java
new file mode 100644
index 00000000..67c04b78
--- /dev/null
+++ b/proxyfeatures-platform-velocity/src/test/java/nl/hauntedmc/proxyfeatures/features/capacity/command/CapacityCommandTest.java
@@ -0,0 +1,122 @@
+package nl.hauntedmc.proxyfeatures.features.capacity.command;
+
+import com.velocitypowered.api.command.CommandSource;
+import com.velocitypowered.api.command.SimpleCommand;
+import com.velocitypowered.api.proxy.ProxyServer;
+import com.velocitypowered.api.proxy.server.RegisteredServer;
+import net.kyori.adventure.text.Component;
+import nl.hauntedmc.proxyfeatures.ProxyFeatures;
+import nl.hauntedmc.proxyfeatures.api.capacity.CapacityState;
+import nl.hauntedmc.proxyfeatures.features.capacity.Capacity;
+import nl.hauntedmc.proxyfeatures.features.capacity.config.CapacityConfig;
+import nl.hauntedmc.proxyfeatures.features.capacity.internal.CapacityControlPlane;
+import nl.hauntedmc.proxyfeatures.features.capacity.internal.CapacityService;
+import nl.hauntedmc.proxyfeatures.framework.localization.LocalizationHandler;
+import nl.hauntedmc.proxyfeatures.framework.log.FeatureLogger;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+
+import java.util.List;
+import java.util.Optional;
+import java.util.Set;
+import java.util.concurrent.CompletableFuture;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.anyBoolean;
+import static org.mockito.ArgumentMatchers.anyString;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.never;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
+class CapacityCommandTest {
+    private CapacityService service;
+    private CapacityControlPlane controlPlane;
+    private LocalizationHandler localization;
+    private CapacityCommand command;
+
+    @BeforeEach
+    void setUp() {
+        Capacity feature = mock(Capacity.class);
+        ProxyFeatures plugin = mock(ProxyFeatures.class);
+        ProxyServer proxy = mock(ProxyServer.class);
+        RegisteredServer survival = mock(RegisteredServer.class);
+        FeatureLogger logger = mock(FeatureLogger.class);
+        service = mock(CapacityService.class);
+        controlPlane = mock(CapacityControlPlane.class);
+        localization = mock(LocalizationHandler.class);
+        LocalizationHandler.MessageBuilder builder = mock(LocalizationHandler.MessageBuilder.class);
+
+        when(feature.getPlugin()).thenReturn(plugin);
+        when(feature.getLogger()).thenReturn(logger);
+        when(plugin.getProxy()).thenReturn(proxy);
+        when(proxy.getServer("survival")).thenReturn(Optional.of(survival));
+        when(feature.getLocalizationHandler()).thenReturn(localization);
+        when(localization.getMessage(anyString())).thenReturn(builder);
+        when(builder.with(anyString(), anyString())).thenReturn(builder);
+        when(builder.with(anyString(), any(Number.class))).thenReturn(builder);
+        when(builder.with(anyString(), anyBoolean())).thenReturn(builder);
+        when(builder.forAudience(any())).thenReturn(builder);
+        when(builder.build()).thenReturn(Component.text("ok"));
+
+        command = new CapacityCommand(feature, service, controlPlane);
+    }
+
+    @Test
+    void rootSuggestionsOnlyExposePermittedOperations() {
+        CommandSource source = sourceWithPermissions(Set.of(CapacityConfig.ADMIN_VIEW_PERMISSION));
+
+        assertEquals(
+                List.of("info", "status"),
+                command.suggestAsync(invocation(source, "")).join()
+        );
+    }
+
+    @Test
+    void stateOnlyAdministratorDoesNotReceiveUnauthorizedStatusAtRoot() {
+        CommandSource source = sourceWithPermissions(Set.of(CapacityConfig.ADMIN_STATE_PERMISSION));
+
+        command.execute(invocation(source));
+
+        verify(localization).getMessage("capacity.command.usage");
+        verify(service, never()).snapshot();
+    }
+
+    @Test
+    void reloadRejectsTrailingArgumentsBeforeStartingMutation() {
+        CommandSource source = sourceWithPermissions(Set.of(CapacityConfig.ADMIN_CONFIG_PERMISSION));
+
+        command.execute(invocation(source, "reload", "unexpected"));
+
+        verify(controlPlane, never()).reload();
+        verify(localization).getMessage("capacity.command.invalid");
+    }
+
+    @Test
+    void clearingAbsentManualStateReportsUnchanged() {
+        CommandSource source = sourceWithPermissions(Set.of(CapacityConfig.ADMIN_STATE_PERMISSION));
+        when(controlPlane.clearManualState("survival"))
+                .thenReturn(CompletableFuture.completedFuture(false));
+        when(service.getServerState("survival")).thenReturn(CapacityState.OPEN);
+
+        command.execute(invocation(source, "state", "survival", "clear"));
+
+        verify(localization).getMessage("capacity.command.state_unchanged");
+        verify(localization, never()).getMessage("capacity.command.state_cleared");
+    }
+
+    private static CommandSource sourceWithPermissions(Set<String> permissions) {
+        CommandSource source = mock(CommandSource.class);
+        when(source.hasPermission(anyString())).thenAnswer(invocation ->
+                permissions.contains(invocation.getArgument(0, String.class)));
+        return source;
+    }
+
+    private static SimpleCommand.Invocation invocation(CommandSource source, String... args) {
+        SimpleCommand.Invocation invocation = mock(SimpleCommand.Invocation.class);
+        when(invocation.source()).thenReturn(source);
+        when(invocation.arguments()).thenReturn(args);
+        return invocation;
+    }
+}
diff --git a/proxyfeatures-platform-velocity/src/test/java/nl/hauntedmc/proxyfeatures/features/capacity/config/CapacityConfigurationTest.java b/proxyfeatures-platform-velocity/src/test/java/nl/hauntedmc/proxyfeatures/features/capacity/config/CapacityConfigurationTest.java
index 38c383de..77fa0ba5 100644
--- a/proxyfeatures-platform-velocity/src/test/java/nl/hauntedmc/proxyfeatures/features/capacity/config/CapacityConfigurationTest.java
+++ b/proxyfeatures-platform-velocity/src/test/java/nl/hauntedmc/proxyfeatures/features/capacity/config/CapacityConfigurationTest.java
@@ -1,6 +1,9 @@
 package nl.hauntedmc.proxyfeatures.features.capacity.config;
 
 import nl.hauntedmc.proxyfeatures.api.capacity.CapacityState;
+import nl.hauntedmc.proxyfeatures.api.io.config.ConfigNode;
+import nl.hauntedmc.proxyfeatures.features.capacity.Capacity;
+import nl.hauntedmc.proxyfeatures.framework.config.FeatureConfigHandler;
 import org.junit.jupiter.api.Test;
 
 import java.time.Duration;
@@ -12,123 +15,178 @@
 import static org.junit.jupiter.api.Assertions.assertFalse;
 import static org.junit.jupiter.api.Assertions.assertThrows;
 import static org.junit.jupiter.api.Assertions.assertTrue;
+import static org.mockito.ArgumentMatchers.anyString;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
 
 class CapacityConfigurationTest {
 
     @Test
-    void validatorAcceptsCompleteConfigurationAndRejectsConflicts() {
+    void validatorAcceptsCanonicalGroupMembershipAndRejectsDuplicates() {
         CapacityConfig config = sample();
         CapacityConfigValidator.validate(config);
 
-        Map<String, CapacityConfig.ServerRule> conflicting = new LinkedHashMap<>(config.servers());
-        CapacityConfig.ServerRule survival = conflicting.get("survival");
-        conflicting.put("survival", new CapacityConfig.ServerRule(
-                survival.name(), survival.limit(), "lobby", survival.countsTowardGameplay(),
-                survival.queueable(), survival.initialState()));
+        Map<String, CapacityConfig.GroupRule> groups = new LinkedHashMap<>(config.groups());
+        groups.put("lobby", new CapacityConfig.GroupRule(
+                "lobby", new CapacityConfig.Limit(0, 0), List.of("lobby", "survival")));
         assertThrows(IllegalArgumentException.class,
-                () -> CapacityConfigValidator.validate(copy(config, config.groups(), conflicting)));
+                () -> CapacityConfigValidator.validate(copy(config, groups, config.servers())));
 
         Map<String, CapacityConfig.ServerRule> unsafe = new LinkedHashMap<>(config.servers());
         unsafe.put("bad|server", new CapacityConfig.ServerRule(
-                "bad|server", new CapacityConfig.Limit(10, 0), "", true, true,
+                "bad|server", new CapacityConfig.Limit(10, 0), "ignored", true, true,
                 CapacityState.OPEN));
         assertThrows(IllegalArgumentException.class,
                 () -> CapacityConfigValidator.validate(copy(config, config.groups(), unsafe)));
     }
 
     @Test
-    void editorMaterializesInheritedGroupMembershipWithoutLosingCapacityScope() {
+    void groupsAreTheOnlyMembershipAuthority() {
         CapacityConfig config = sample();
+
+        assertEquals("lobby", config.server("lobby").group());
+        assertEquals("survival", config.server("survival").group());
+        assertEquals("", config.server("creative").group());
+
         Map<String, CapacityConfig.GroupRule> groups = new LinkedHashMap<>(config.groups());
-        CapacityConfig.GroupRule survival = groups.get("survival");
         groups.put("survival", new CapacityConfig.GroupRule(
-                "survival", survival.limit(), List.of("survival", "survival2")));
+                "survival", new CapacityConfig.Limit(200, 5), List.of("survival", "survival2")));
         CapacityConfig inherited = copy(config, groups, config.servers());
 
+        assertEquals("survival", inherited.server("survival2").group());
         CapacityConfig edited = CapacityConfigEditor.serverLimit(inherited, "survival2", 75, 3);
-
         assertEquals("survival", edited.servers().get("survival2").group());
         assertEquals(new CapacityConfig.Limit(75, 3), edited.servers().get("survival2").limit());
         CapacityConfigValidator.validate(edited);
     }
 
     @Test
-    void editorUpdatesLimitsAndRejectsInvalidReservedCapacity() {
+    void editorChangesOnlyOperationalLimitsAndQueueability() {
         CapacityConfig config = sample();
 
         CapacityConfig proxy = CapacityConfigEditor.proxyLimit(config, 700, 20);
         CapacityConfig gameplay = CapacityConfigEditor.gameplayLimit(proxy, 550, 15);
         CapacityConfig group = CapacityConfigEditor.groupLimit(gameplay, "survival", 250, 8);
         CapacityConfig server = CapacityConfigEditor.serverLimit(group, "survival", 150, 5);
-        CapacityConfig unknown = CapacityConfigEditor.unknownLimit(server, 25, 2);
+        CapacityConfig queueable = CapacityConfigEditor.serverQueueable(server, "lobby", true);
 
         assertEquals(new CapacityConfig.Limit(700, 20), proxy.proxy());
         assertEquals(new CapacityConfig.Limit(550, 15), gameplay.gameplay());
         assertEquals(new CapacityConfig.Limit(250, 8), group.groups().get("survival").limit());
         assertEquals(new CapacityConfig.Limit(150, 5), server.servers().get("survival").limit());
-        assertEquals(25, unknown.unknownCapacity());
-        assertEquals(2, unknown.unknownReservedSlots());
+        assertTrue(queueable.server("lobby").queueable());
+        assertEquals(config.groups().get("lobby").servers(), queueable.groups().get("lobby").servers());
+        assertEquals(config.groups().get("survival").servers(), queueable.groups().get("survival").servers());
+        assertEquals(config.snapshotChannel(), queueable.snapshotChannel());
+        assertEquals(config.snapshotPublishIntervalSeconds(),
+                queueable.snapshotPublishIntervalSeconds());
+        assertEquals(config.snapshotPublisherId(), queueable.snapshotPublisherId());
+
         assertThrows(IllegalArgumentException.class,
                 () -> CapacityConfigEditor.proxyLimit(config, 10, 11));
         assertThrows(IllegalArgumentException.class,
                 () -> CapacityConfigEditor.serverLimit(config, "survival", -1, 0));
+        assertThrows(IllegalArgumentException.class,
+                () -> CapacityConfigEditor.groupLimit(config, "missing", 10, 0));
     }
 
     @Test
-    void editorKeepsGroupAndExplicitServerMembershipConsistent() {
+    void durationParsingAndPermissionsRemainSmallAndFixed() {
         CapacityConfig config = sample();
 
-        CapacityConfig moved = CapacityConfigEditor.serverGroup(config, "lobby", "survival");
-        assertEquals("survival", moved.servers().get("lobby").group());
-        assertTrue(moved.groups().get("survival").servers().contains("lobby"));
-        assertFalse(moved.groups().get("lobby").servers().contains("lobby"));
-
-        CapacityConfig removed = CapacityConfigEditor.removeGroupServer(moved, "survival", "lobby");
-        assertEquals("", removed.servers().get("lobby").group());
-        assertFalse(removed.groups().get("survival").servers().contains("lobby"));
-
-        CapacityConfig added = CapacityConfigEditor.addGroupServer(removed, "lobby", "lobby");
-        assertEquals("lobby", added.servers().get("lobby").group());
-        assertTrue(added.groups().get("lobby").servers().contains("lobby"));
+        assertEquals(Duration.ofMillis(500), CapacityConfigEditor.duration("500ms"));
+        assertEquals(Duration.ofSeconds(5), CapacityConfigEditor.duration("5"));
+        assertEquals(Duration.ofDays(2), CapacityConfigEditor.duration("2d"));
+        assertThrows(IllegalArgumentException.class, () -> CapacityConfigEditor.duration("0s"));
+        assertThrows(IllegalArgumentException.class, () -> CapacityConfigEditor.duration("later"));
 
-        assertThrows(IllegalArgumentException.class,
-                () -> CapacityConfigEditor.serverGroup(config, "survival", "missing"));
-        assertThrows(IllegalArgumentException.class,
-                () -> CapacityConfigEditor.deleteGroup(config, "survival"));
+        assertEquals("proxyfeatures.feature.capacity.reserved", CapacityConfig.RESERVED_PERMISSION);
+        assertEquals("proxyfeatures.feature.capacity.admin", CapacityConfig.ADMIN_PERMISSION);
+        assertEquals("proxyfeatures.feature.capacity.admin.config",
+                CapacityConfig.ADMIN_CONFIG_PERMISSION);
+        assertFalse(config.failOpenOnInternalError());
     }
 
     @Test
-    void optionsAreSmallAndPermissionsAreFixedConstants() {
+    void constructorRejectsInvalidLimitsDurationsMembershipAndMessaging() {
         CapacityConfig config = sample();
 
-        config = CapacityConfigEditor.option(config, "lease-ttl", "30s");
-        config = CapacityConfigEditor.option(config, "login-ttl", "45s");
-        config = CapacityConfigEditor.option(config, "reconciliation", "2s");
-        config = CapacityConfigEditor.option(config, "maintenance-sync", "250ms");
-        config = CapacityConfigEditor.option(config, "queue-on-full", "off");
-        config = CapacityConfigEditor.option(config, "fail-open", "yes");
-        config = CapacityConfigEditor.option(config, "restart-reserved", "false");
-
-        assertEquals(Duration.ofSeconds(30), config.leaseTtl());
-        assertEquals(Duration.ofSeconds(45), config.loginReservationTtl());
-        assertEquals(Duration.ofSeconds(2), config.reconciliationInterval());
-        assertEquals(Duration.ofMillis(250), config.maintenanceSyncInterval());
-        assertFalse(config.queueOnFull());
-        assertTrue(config.failOpenOnInternalError());
-        assertFalse(config.restartReturnUsesReservedSlots());
-        assertEquals("proxyfeatures.feature.capacity.reserved",
-                CapacityConfig.RESERVED_PERMISSION);
-        assertEquals("proxyfeatures.feature.capacity.admin",
-                CapacityConfig.ADMIN_PERMISSION);
+        assertThrows(IllegalArgumentException.class, () -> new CapacityConfig.Limit(-1, 0));
+        assertThrows(IllegalArgumentException.class, () -> new CapacityConfig.Limit(5, 6));
+        assertThrows(IllegalArgumentException.class, () -> new CapacityConfig.GroupRule(
+                "survival",
+                new CapacityConfig.Limit(10, 0),
+                List.of("survival", "SURVIVAL")
+        ));
 
-        assertEquals(Duration.ofMillis(500), CapacityConfigEditor.duration("500ms"));
-        assertEquals(Duration.ofSeconds(5), CapacityConfigEditor.duration("5"));
-        assertEquals(Duration.ofDays(2), CapacityConfigEditor.duration("2d"));
-        CapacityConfig finalConfig = config;
-        assertThrows(IllegalArgumentException.class,
-                () -> CapacityConfigEditor.option(finalConfig, "missing", "true"));
+        Map<String, CapacityConfig.GroupRule> groups = new LinkedHashMap<>(config.groups());
+        groups.put("second", new CapacityConfig.GroupRule(
+                "second",
+                new CapacityConfig.Limit(10, 0),
+                List.of("survival")
+        ));
         assertThrows(IllegalArgumentException.class,
-                () -> CapacityConfigEditor.option(finalConfig, "queue-on-full", "maybe"));
+                () -> copy(config, groups, config.servers()));
+
+        assertThrows(IllegalArgumentException.class, () -> new CapacityConfig(
+                config.proxy(),
+                config.gameplay(),
+                config.groups(),
+                config.servers(),
+                true,
+                false,
+                0,
+                0,
+                Duration.ZERO,
+                config.loginReservationTtl(),
+                config.reconciliationInterval(),
+                config.maintenanceSyncInterval(),
+                config.snapshotChannel(),
+                config.snapshotPublishIntervalSeconds(),
+                config.snapshotPublisherId(),
+                true,
+                false,
+                true
+        ));
+        assertThrows(IllegalArgumentException.class, () -> new CapacityConfig(
+                config.proxy(),
+                config.gameplay(),
+                config.groups(),
+                config.servers(),
+                true,
+                false,
+                0,
+                0,
+                config.leaseTtl(),
+                config.loginReservationTtl(),
+                config.reconciliationInterval(),
+                config.maintenanceSyncInterval(),
+                " ",
+                0,
+                " ",
+                true,
+                false,
+                true
+        ));
+    }
+
+    @Test
+    void loaderRejectsQuotedNumbersInsteadOfSilentlyCoercingThem() {
+        Capacity feature = mock(Capacity.class);
+        FeatureConfigHandler handler = mock(FeatureConfigHandler.class);
+        when(feature.getConfigHandler()).thenReturn(handler);
+        when(handler.node(anyString())).thenAnswer(invocation -> {
+            String path = invocation.getArgument(0, String.class);
+            if (path.equals("global.proxy")) {
+                return ConfigNode.ofRaw(
+                        Map.of("capacity", "600", "reserved_slots", 10),
+                        path
+                );
+            }
+            return ConfigNode.ofRaw(null, path);
+        });
+
+        assertThrows(IllegalArgumentException.class, () -> CapacityConfig.load(feature));
     }
 
     private static CapacityConfig copy(CapacityConfig source,
@@ -147,6 +205,9 @@ private static CapacityConfig copy(CapacityConfig source,
                 source.loginReservationTtl(),
                 source.reconciliationInterval(),
                 source.maintenanceSyncInterval(),
+                source.snapshotChannel(),
+                source.snapshotPublishIntervalSeconds(),
+                source.snapshotPublisherId(),
                 source.queueOnFull(),
                 source.failOpenOnInternalError(),
                 source.restartReturnUsesReservedSlots()
@@ -162,13 +223,13 @@ private static CapacityConfig sample() {
 
         Map<String, CapacityConfig.ServerRule> servers = new LinkedHashMap<>();
         servers.put("lobby", new CapacityConfig.ServerRule(
-                "lobby", new CapacityConfig.Limit(100, 2), "lobby", true, false,
+                "lobby", new CapacityConfig.Limit(100, 2), "wrong", true, false,
                 CapacityState.OPEN));
         servers.put("survival", new CapacityConfig.ServerRule(
-                "survival", new CapacityConfig.Limit(120, 3), "survival", true, true,
+                "survival", new CapacityConfig.Limit(120, 3), "wrong", true, true,
                 CapacityState.OPEN));
         servers.put("creative", new CapacityConfig.ServerRule(
-                "creative", new CapacityConfig.Limit(80, 2), "", true, true,
+                "creative", new CapacityConfig.Limit(80, 2), "wrong", true, true,
                 CapacityState.OPEN));
 
         return new CapacityConfig(
@@ -184,6 +245,9 @@ private static CapacityConfig sample() {
                 Duration.ofSeconds(20),
                 Duration.ofSeconds(5),
                 Duration.ofMillis(500),
+                CapacityConfig.DEFAULT_SNAPSHOT_CHANNEL,
+                CapacityConfig.DEFAULT_SNAPSHOT_INTERVAL_SECONDS,
+                CapacityConfig.DEFAULT_SNAPSHOT_PUBLISHER_ID,
                 true,
                 false,
                 true
diff --git a/proxyfeatures-platform-velocity/src/test/java/nl/hauntedmc/proxyfeatures/features/capacity/internal/CapacityServiceTest.java b/proxyfeatures-platform-velocity/src/test/java/nl/hauntedmc/proxyfeatures/features/capacity/internal/CapacityServiceTest.java
index 0302f6de..26c6de2a 100644
--- a/proxyfeatures-platform-velocity/src/test/java/nl/hauntedmc/proxyfeatures/features/capacity/internal/CapacityServiceTest.java
+++ b/proxyfeatures-platform-velocity/src/test/java/nl/hauntedmc/proxyfeatures/features/capacity/internal/CapacityServiceTest.java
@@ -10,14 +10,14 @@
 import nl.hauntedmc.proxyfeatures.api.capacity.CapacityDenialReason;
 import nl.hauntedmc.proxyfeatures.api.capacity.CapacityRequest;
 import nl.hauntedmc.proxyfeatures.api.capacity.CapacityState;
-import nl.hauntedmc.proxyfeatures.api.io.config.ConfigNode;
 import nl.hauntedmc.proxyfeatures.features.capacity.Capacity;
 import nl.hauntedmc.proxyfeatures.features.capacity.config.CapacityConfig;
-import nl.hauntedmc.proxyfeatures.framework.config.FeatureConfigHandler;
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
 
+import java.time.Duration;
 import java.time.Instant;
+import java.util.LinkedHashMap;
 import java.util.List;
 import java.util.Map;
 import java.util.Optional;
@@ -27,33 +27,25 @@
 import static org.junit.jupiter.api.Assertions.assertFalse;
 import static org.junit.jupiter.api.Assertions.assertNotEquals;
 import static org.junit.jupiter.api.Assertions.assertTrue;
-import static org.mockito.ArgumentMatchers.anyInt;
 import static org.mockito.ArgumentMatchers.anyString;
-import static org.mockito.ArgumentMatchers.eq;
 import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.when;
 
 class CapacityServiceTest {
 
+    private Capacity feature;
     private ProxyServer proxy;
-    private FeatureConfigHandler config;
     private CapacityService service;
 
     @BeforeEach
     void setUp() {
-        Capacity feature = mock(Capacity.class);
+        feature = mock(Capacity.class);
         ProxyFeatures plugin = mock(ProxyFeatures.class);
         proxy = mock(ProxyServer.class);
-        config = mock(FeatureConfigHandler.class);
         RegisteredServer survival = mock(RegisteredServer.class);
         ServerInfo survivalInfo = mock(ServerInfo.class);
-        ConfigNode proxyLimit = limitNode(2, 1);
-        ConfigNode gameplayLimit = limitNode(2, 1);
-        ConfigNode groups = childrenNode(Map.of());
-        ConfigNode servers = childrenNode(Map.of());
 
         when(feature.getPlugin()).thenReturn(plugin);
-        when(feature.getConfigHandler()).thenReturn(config);
         when(plugin.getProxy()).thenReturn(proxy);
         when(plugin.getDataRegistry()).thenReturn(Optional.empty());
         when(survival.getServerInfo()).thenReturn(survivalInfo);
@@ -62,32 +54,29 @@ void setUp() {
         when(proxy.getAllServers()).thenReturn(List.of(survival));
         when(proxy.getServer("survival")).thenReturn(Optional.of(survival));
 
-        when(config.node("global.proxy")).thenReturn(proxyLimit);
-        when(config.node("global.gameplay")).thenReturn(gameplayLimit);
-        when(config.node("groups")).thenReturn(groups);
-        when(config.node("servers")).thenReturn(servers);
-
-        when(config.get("unknown_servers.counts_toward_gameplay", Boolean.class, true)).thenReturn(true);
-        when(config.get("unknown_servers.queueable", Boolean.class, false)).thenReturn(true);
-        when(config.get("unknown_servers.capacity", Integer.class, 0)).thenReturn(2);
-        when(config.get("unknown_servers.reserved_slots", Integer.class, 0)).thenReturn(1);
-        when(config.get("leases.ttl_millis", Long.class, 15_000L)).thenReturn(15_000L);
-        when(config.get("leases.login_ttl_millis", Long.class, 20_000L)).thenReturn(20_000L);
-        when(config.get("reconciliation.interval_seconds", Long.class, 5L)).thenReturn(5L);
-        when(config.get("queue.on_full", Boolean.class, true)).thenReturn(true);
-        when(config.get("failure.fail_open_on_internal_error", Boolean.class, false)).thenReturn(false);
-        when(config.get("restart_return.use_reserved_slots", Boolean.class, true)).thenReturn(true);
-
-        service = new CapacityService(feature);
+        service = new CapacityService(feature, configuration(2, 1));
     }
 
     @Test
     void pendingLeaseConsumesNormalCapacityAndReservedPlayerCanUseRemainder() {
-        CapacityDecision first = service.tryAcquire(request(UUID.randomUUID(), false, false, AdmissionIntent.NORMAL));
-        CapacityDecision secondNormal = service.tryAcquire(request(UUID.randomUUID(), false, false,
-                AdmissionIntent.NORMAL));
-        CapacityDecision secondReserved = service.tryAcquire(request(UUID.randomUUID(), true, false,
-                AdmissionIntent.NORMAL));
+        CapacityDecision first = service.tryAcquire(request(
+                UUID.randomUUID(),
+                false,
+                false,
+                AdmissionIntent.NORMAL
+        ));
+        CapacityDecision secondNormal = service.tryAcquire(request(
+                UUID.randomUUID(),
+                false,
+                false,
+                AdmissionIntent.NORMAL
+        ));
+        CapacityDecision secondReserved = service.tryAcquire(request(
+                UUID.randomUUID(),
+                true,
+                false,
+                AdmissionIntent.NORMAL
+        ));
 
         assertTrue(first.allowed());
         assertFalse(secondNormal.allowed());
@@ -102,7 +91,11 @@ void pendingLeaseConsumesNormalCapacityAndReservedPlayerCanUseRemainder() {
     @Test
     void initialBackendConnectionCountsTowardGameplayPendingCapacity() {
         CapacityDecision decision = service.tryAcquire(request(
-                UUID.randomUUID(), false, false, AdmissionIntent.NORMAL));
+                UUID.randomUUID(),
+                false,
+                false,
+                AdmissionIntent.NORMAL
+        ));
 
         assertTrue(decision.allowed());
         assertEquals(1, service.snapshot().gameplay().pending());
@@ -111,8 +104,18 @@ void initialBackendConnectionCountsTowardGameplayPendingCapacity() {
 
     @Test
     void capacityBypassStillCreatesExactLease() {
-        CapacityDecision first = service.tryAcquire(request(UUID.randomUUID(), false, false, AdmissionIntent.NORMAL));
-        CapacityDecision bypass = service.tryAcquire(request(UUID.randomUUID(), false, true, AdmissionIntent.NORMAL));
+        CapacityDecision first = service.tryAcquire(request(
+                UUID.randomUUID(),
+                false,
+                false,
+                AdmissionIntent.NORMAL
+        ));
+        CapacityDecision bypass = service.tryAcquire(request(
+                UUID.randomUUID(),
+                false,
+                true,
+                AdmissionIntent.NORMAL
+        ));
 
         assertTrue(first.allowed());
         assertTrue(bypass.allowed());
@@ -125,11 +128,21 @@ void capacityBypassStillCreatesExactLease() {
     void namedStateClaimsBlockUnlessRequestHasStateBypass() {
         service.setServerState("survival", CapacityState.CLOSED, "maintenance");
 
-        CapacityDecision blocked = service.tryAcquire(request(UUID.randomUUID(), false, false,
-                AdmissionIntent.NORMAL));
+        CapacityDecision blocked = service.tryAcquire(request(
+                UUID.randomUUID(),
+                false,
+                false,
+                AdmissionIntent.NORMAL
+        ));
         CapacityDecision bypassed = service.tryAcquire(new CapacityRequest(
-                UUID.randomUUID(), "", "survival", AdmissionIntent.NORMAL,
-                false, false, true));
+                UUID.randomUUID(),
+                "",
+                "survival",
+                AdmissionIntent.NORMAL,
+                false,
+                false,
+                true
+        ));
 
         assertFalse(blocked.allowed());
         assertEquals(CapacityDenialReason.SERVER_STATE, blocked.reason());
@@ -143,13 +156,15 @@ void namedStateClaimsBlockUnlessRequestHasStateBypass() {
 
     @Test
     void stateStillBlocksWhenNoNumericServerCapacityIsConfigured() {
-        when(config.get("unknown_servers.capacity", Integer.class, 0)).thenReturn(0);
-        when(config.get("unknown_servers.reserved_slots", Integer.class, 0)).thenReturn(0);
-        service.reload();
+        service.reload(configuration(0, 0));
         service.setServerState("survival", CapacityState.DRAINING, "manual");
 
-        CapacityDecision blocked = service.tryAcquire(request(UUID.randomUUID(), false, false,
-                AdmissionIntent.NORMAL));
+        CapacityDecision blocked = service.tryAcquire(request(
+                UUID.randomUUID(),
+                false,
+                false,
+                AdmissionIntent.NORMAL
+        ));
 
         assertFalse(blocked.allowed());
         assertEquals(CapacityDenialReason.SERVER_STATE, blocked.reason());
@@ -160,14 +175,22 @@ void stateStillBlocksWhenNoNumericServerCapacityIsConfigured() {
     void restrictiveStateRevokesPreparedNonBypassLeaseBeforeConnect() {
         UUID playerId = UUID.randomUUID();
         CapacityDecision prepared = service.tryAcquire(request(
-                playerId, false, false, AdmissionIntent.NORMAL));
+                playerId,
+                false,
+                false,
+                AdmissionIntent.NORMAL
+        ));
         assertTrue(prepared.allowed());
 
         service.setServerState("survival", CapacityState.DRAINING, "restart");
 
         assertFalse(prepared.lease().isActive());
         CapacityDecision retried = service.tryAcquire(request(
-                playerId, false, false, AdmissionIntent.NORMAL));
+                playerId,
+                false,
+                false,
+                AdmissionIntent.NORMAL
+        ));
         assertFalse(retried.allowed());
         assertEquals(CapacityDenialReason.SERVER_STATE, retried.reason());
     }
@@ -176,16 +199,28 @@ void restrictiveStateRevokesPreparedNonBypassLeaseBeforeConnect() {
     void changedPreparedAuthorizationIsReleasedAndReevaluated() {
         UUID playerId = UUID.randomUUID();
         CapacityRequest privileged = new CapacityRequest(
-                playerId, "", "survival", AdmissionIntent.QUEUE_ADVANCE,
-                false, false, true);
+                playerId,
+                "",
+                "survival",
+                AdmissionIntent.QUEUE_ADVANCE,
+                false,
+                false,
+                true
+        );
         CapacityDecision prepared = service.tryAcquire(privileged);
         assertTrue(prepared.allowed());
         service.setServerState("survival", CapacityState.CLOSED, "maintenance");
         assertTrue(prepared.lease().isActive());
 
         CapacityRequest downgraded = new CapacityRequest(
-                playerId, "", "survival", AdmissionIntent.QUEUE_ADVANCE,
-                false, false, false);
+                playerId,
+                "",
+                "survival",
+                AdmissionIntent.QUEUE_ADVANCE,
+                false,
+                false,
+                false
+        );
         CapacityDecision retried = service.tryAcquire(downgraded);
 
         assertFalse(prepared.lease().isActive());
@@ -196,11 +231,16 @@ void changedPreparedAuthorizationIsReleasedAndReevaluated() {
     @Test
     void unchangedPreparedRequestIsReacquiredAfterConfigurationReload() {
         UUID playerId = UUID.randomUUID();
-        CapacityRequest request = request(playerId, false, false, AdmissionIntent.QUEUE_ADVANCE);
+        CapacityRequest request = request(
+                playerId,
+                false,
+                false,
+                AdmissionIntent.QUEUE_ADVANCE
+        );
         CapacityDecision prepared = service.tryAcquire(request);
         assertTrue(prepared.allowed());
 
-        service.reload();
+        service.reload(configuration(2, 1));
         CapacityDecision revalidated = service.tryAcquire(request);
 
         assertFalse(prepared.lease().isActive());
@@ -218,10 +258,18 @@ void restorationReservationProtectsReturnSlotAndIsClaimedWithoutExtraDelta() {
                 Instant.now().plusSeconds(60)
         );
 
-        CapacityDecision newcomer = service.tryAcquire(request(UUID.randomUUID(), false, false,
-                AdmissionIntent.NORMAL));
-        CapacityDecision returning = service.tryAcquire(request(returningPlayer, false, false,
-                AdmissionIntent.RESTART_RETURN));
+        CapacityDecision newcomer = service.tryAcquire(request(
+                UUID.randomUUID(),
+                false,
+                false,
+                AdmissionIntent.NORMAL
+        ));
+        CapacityDecision returning = service.tryAcquire(request(
+                returningPlayer,
+                false,
+                false,
+                AdmissionIntent.RESTART_RETURN
+        ));
 
         assertFalse(newcomer.allowed());
         assertEquals(CapacityDenialReason.FULL, newcomer.reason());
@@ -229,7 +277,10 @@ void restorationReservationProtectsReturnSlotAndIsClaimedWithoutExtraDelta() {
         assertEquals(AdmissionIntent.RESTART_RETURN, returning.lease().intent());
 
         returning.lease().release();
-        assertEquals(1, service.snapshot().servers().get("survival").restorationReserved());
+        assertEquals(
+                1,
+                service.snapshot().servers().get("survival").restorationReserved()
+        );
         service.releaseRestoration("survival", returningPlayer);
     }
 
@@ -255,13 +306,29 @@ void proxyLoginReservationDoesNotDoubleCountCurrentVelocityPlayer() {
     @Test
     void unknownTargetAndDuplicatePreparedLeaseAreHandledDeterministically() {
         CapacityDecision unknown = service.tryAcquire(CapacityRequest.normal(
-                UUID.randomUUID(), "", "missing", false, false, false));
+                UUID.randomUUID(),
+                "",
+                "missing",
+                false,
+                false,
+                false
+        ));
         assertFalse(unknown.allowed());
         assertEquals(CapacityDenialReason.UNKNOWN_TARGET, unknown.reason());
 
         UUID playerId = UUID.randomUUID();
-        CapacityDecision first = service.tryAcquire(request(playerId, false, false, AdmissionIntent.NORMAL));
-        CapacityDecision duplicate = service.tryAcquire(request(playerId, false, false, AdmissionIntent.NORMAL));
+        CapacityDecision first = service.tryAcquire(request(
+                playerId,
+                false,
+                false,
+                AdmissionIntent.NORMAL
+        ));
+        CapacityDecision duplicate = service.tryAcquire(request(
+                playerId,
+                false,
+                false,
+                AdmissionIntent.NORMAL
+        ));
         assertTrue(first.allowed());
         assertTrue(duplicate.allowed());
         assertEquals(first.lease().id(), duplicate.lease().id());
@@ -269,9 +336,51 @@ void unknownTargetAndDuplicatePreparedLeaseAreHandledDeterministically() {
         first.lease().release();
     }
 
-    private static CapacityRequest request(UUID playerId, boolean reserved, boolean capacityBypass,
-                                           AdmissionIntent intent) {
-        return new CapacityRequest(playerId, "", "survival", intent, reserved, capacityBypass, false);
+    @Test
+    void configuredAndGroupedOfflineServersRemainObservable() {
+        Map<String, CapacityConfig.GroupRule> groups = Map.of(
+                "events",
+                new CapacityConfig.GroupRule(
+                        "events",
+                        new CapacityConfig.Limit(40, 2),
+                        List.of("event1")
+                )
+        );
+        Map<String, CapacityConfig.ServerRule> servers = Map.of(
+                "configured-offline",
+                new CapacityConfig.ServerRule(
+                        "configured-offline",
+                        new CapacityConfig.Limit(20, 1),
+                        "",
+                        true,
+                        false,
+                        CapacityState.OFFLINE
+                )
+        );
+        service.reload(configuration(2, 1, groups, servers));
+
+        assertTrue(service.snapshot().servers().containsKey("event1"));
+        assertTrue(service.snapshot().servers().containsKey("configured-offline"));
+        assertEquals(
+                CapacityState.OFFLINE,
+                service.snapshot().servers().get("configured-offline").state()
+        );
+    }
+
+    private static CapacityRequest request(
+            UUID playerId,
+            boolean reserved,
+            boolean capacityBypass,
+            AdmissionIntent intent) {
+        return new CapacityRequest(
+                playerId,
+                "",
+                "survival",
+                intent,
+                reserved,
+                capacityBypass,
+                false
+        );
     }
 
     private static Player player(UUID playerId, boolean reserved) {
@@ -282,20 +391,31 @@ private static Player player(UUID playerId, boolean reserved) {
         return player;
     }
 
-    private static ConfigNode limitNode(int capacity, int reserved) {
-        ConfigNode node = mock(ConfigNode.class);
-        ConfigNode capacityNode = mock(ConfigNode.class);
-        ConfigNode reservedNode = mock(ConfigNode.class);
-        when(node.get("capacity")).thenReturn(capacityNode);
-        when(node.get("reserved_slots")).thenReturn(reservedNode);
-        when(capacityNode.as(eq(Integer.class), anyInt())).thenReturn(capacity);
-        when(reservedNode.as(eq(Integer.class), anyInt())).thenReturn(reserved);
-        return node;
+    private static CapacityConfig configuration(int unknownCapacity, int unknownReserved) {
+        return configuration(unknownCapacity, unknownReserved, Map.of(), Map.of());
     }
 
-    private static ConfigNode childrenNode(Map<String, ConfigNode> children) {
-        ConfigNode node = mock(ConfigNode.class);
-        when(node.children()).thenReturn(children);
-        return node;
+    private static CapacityConfig configuration(
+            int unknownCapacity,
+            int unknownReserved,
+            Map<String, CapacityConfig.GroupRule> groups,
+            Map<String, CapacityConfig.ServerRule> servers) {
+        return new CapacityConfig(
+                new CapacityConfig.Limit(2, 1),
+                new CapacityConfig.Limit(2, 1),
+                new LinkedHashMap<>(groups),
+                new LinkedHashMap<>(servers),
+                true,
+                true,
+                unknownCapacity,
+                unknownReserved,
+                Duration.ofSeconds(15),
+                Duration.ofSeconds(20),
+                Duration.ofSeconds(5),
+                Duration.ofMillis(500),
+                true,
+                false,
+                true
+        );
     }
 }