agent capabilities live in a swarm KV record, set from swarmctl

An agent's capabilities move from the hive's meta repo
(`meta/capabilities.json`, injected as `HIVE_CAPABILITIES`) into the
`capabilities` field of its key in a new `agent-permissions` KV bucket,
which swarm-controller alone writes.

- swarm-queue-client: `agent_permissions` (bucket, key, `AgentPermissions`,
  direct-get read, the import subject and its wire types).
- swarm-controller: creates the bucket at start; `GET|PUT|DELETE
  /api/agents/{name}/permissions` (deny_unknown_fields and unknown
  capability ⇒ 422, duplicate ⇒ 400, agent must be declared by a hive);
  answers each hive's one-shot import, writing a key only where there is
  none and only for agents that hive's wanted state declares.
- swarmctl: `agent permissions get|set|clear`.
- swarm-nats-auth: a hive reads every key of the bucket and sends its
  import on its own subject; the controller subscribes to the imports and
  may answer them (`responses`).
- hive-c0re: reads each of its agents' keys every 30s into
  /var/lib/hyperhive/swarm-agent-permissions.json and restarts an agent,
  gracefully, when its capabilities change. Unset is the compiled-in
  default (ruth: manage_root_agent; everyone else: none). A failed read
  keeps the stored value. On first boot it seeds that file from
  meta/capabilities.json, sends the grants to the controller, and deletes
  the file once the controller answers.

Deleted: the capabilities.json reader/writer, `HIVE_CAPABILITIES` in the
rendered meta flake, ruth's capability seed, the capabilities half of the
permissions rebuild job (`PermPayload::Capabilities`/`Combined`), the
dashboard's capabilities table and `capabilities_changed` event, and the
now-unused `Capability::description`.

Part of #5170.

swarmctl/src/main.rs

@@ -29,6 +29,7 @@ mod agent;
 mod forge;
 mod inference;
 mod login;
+mod permissions;
 mod remote;
 mod schedule;
 mod users;
@@ -290,6 +291,43 @@ enum AgentVerb {
         #[command(subcommand)]
         command: InferenceVerb,
     },
+    /// Show or change the capabilities the swarm grants an agent.
+    ///
+    /// The hive running the agent reads them every 30 seconds and, when they
+    /// change, restarts the agent after its current turn. Unset leaves the
+    /// agent on its hive's default: none, except `ruth`, who gets
+    /// `manage_root_agent`.
+    Permissions {
+        #[command(subcommand)]
+        command: PermissionsVerb,
+    },
+}
+
+#[derive(Subcommand)]
+enum PermissionsVerb {
+    /// Show the capabilities the swarm grants an agent, or that it sets none.
+    Get(InferenceAgentArgs),
+    /// Replace the capabilities the swarm grants an agent.
+    Set(PermissionsSetArgs),
+    /// Clear the agent's permissions, so its hive's default applies again.
+    Clear(InferenceAgentArgs),
+}
+
+#[derive(Args)]
+struct PermissionsSetArgs {
+    /// Agent name. A hive must declare it.
+    agent: String,
+    /// The capabilities to grant, comma-separated (`manage_root_agent`).
+    /// `--capabilities ''` grants none.
+    #[arg(
+        long,
+        value_name = "CAPABILITIES",
+        value_delimiter = ',',
+        required = true
+    )]
+    capabilities: Vec<String>,
+    #[command(flatten)]
+    socket: ControllerSocketArg,
 }
 
 #[derive(Subcommand)]
@@ -602,6 +640,9 @@ fn main() -> Result<()> {
         Verb::Agent {
             command: AgentVerb::Inference { command },
         } => inference(&remote, command),
+        Verb::Agent {
+            command: AgentVerb::Permissions { command },
+        } => permissions(&remote, command),
         // Same socket-resolution reasoning as `Create` above.
         Verb::Forge {
             command: ForgeVerb::MakeAdmin(args),
@@ -671,6 +712,16 @@ fn inference(remote: &RemoteArgs, command: InferenceVerb) -> Result<()> {
     }
 }
 
+fn permissions(remote: &RemoteArgs, command: PermissionsVerb) -> Result<()> {
+    match command {
+        PermissionsVerb::Get(a) => permissions::get(&a.socket.resolve(remote)?, &a.agent),
+        PermissionsVerb::Set(a) => {
+            permissions::set(&a.socket.resolve(remote)?, &a.agent, a.capabilities)
+        }
+        PermissionsVerb::Clear(a) => permissions::clear(&a.socket.resolve(remote)?, &a.agent),
+    }
+}
+
 fn schedule(remote: &RemoteArgs, command: ScheduleVerb) -> Result<()> {
     match command {
         ScheduleVerb::Add(a) => schedule::add(