swarm: per-agent inference settings (model, effort, subagent_models) in KV

swarm-controller keeps each agent's inference settings in a new
`agent-inference` KV bucket, one key per agent, and is its only writer
(`GET`/`PUT`/`DELETE /api/agents/{name}/inference`; `swarmctl agent
inference get|set|clear`). Every field is optional. Each agent reads its
own key every 10 s through a direct-get grant on that key alone, and a
set `model` or `effort` replaces the Bus value, so the next turn runs on
it and the badge follows.

The swarm value is applied without persisting it: `Bus::set_model` and
`set_effort` are split into a persisting setter and a non-persisting
`apply_*`, and the poller uses the latter. Otherwise the swarm value
would overwrite `hyperhive-model`/`hyperhive-effort`, and clearing it, or
a restart, would no longer find the agent's own value. An unset field
changes nothing; a field cleared after being applied goes back to the
local value (`harness_state::local_model`/`local_effort`, the same
resolution `Bus::new` uses), read again at the clear.

`subagent_models` is validated, stored and shown by `get`; no agent
applies it yet.

Refs #5034

swarm-controller/src/main.rs

@@ -52,6 +52,7 @@ mod config_pr;
 mod forge;
 mod forge_account;
 mod github_account;
+mod inference;
 mod issue_report;
 mod linked_accounts;
 mod matrix_account;
@@ -3211,6 +3212,11 @@ fn build_app(state: AppState) -> axum::Router {
         .routes(routes!(get_jobq_rollup))
         .routes(routes!(get_agent_config_pr))
         .routes(routes!(get_agent_icon))
+        .routes(routes!(
+            inference::get_agent_inference,
+            inference::put_agent_inference,
+            inference::delete_agent_inference
+        ))
         .routes(routes!(get_config_prs))
         .routes(routes!(create_agent))
         .routes(routes!(mint_agent_identity))
@@ -5479,6 +5485,59 @@ mod tests {
         );
     }
 
+    /// Every inference verb refuses a name that is not an identifier with a
+    /// 400 and answers 503 without a queue; a PUT whose body is refused is a
+    /// 400 before the queue is asked.
+    #[tokio::test]
+    async fn the_inference_routes_check_the_name_and_body_before_the_queue() {
+        use super::inference::{delete_agent_inference, get_agent_inference, put_agent_inference};
+        use axum::extract::{Path, State};
+        use axum::http::StatusCode;
+
+        fn status<T>(r: Result<T, problem_details::ProblemDetails>) -> Option<StatusCode> {
+            r.map(|_| ()).expect_err("must not succeed").status
+        }
+        let (state, _sched) = state_with_roster();
+        let body = |json: &str| axum::Json(serde_json::from_str(json).expect("decodes"));
+        for name in ["iris", "Not An Ident"] {
+            let want = Some(if name == "iris" {
+                StatusCode::SERVICE_UNAVAILABLE
+            } else {
+                StatusCode::BAD_REQUEST
+            });
+            let path = || Path(name.to_owned());
+            assert_eq!(
+                status(get_agent_inference(State(state.clone()), path()).await),
+                want,
+                "GET {name}"
+            );
+            assert_eq!(
+                status(
+                    put_agent_inference(State(state.clone()), path(), body(r#"{"model":"opus"}"#))
+                        .await
+                ),
+                want,
+                "PUT {name}"
+            );
+            assert_eq!(
+                status(delete_agent_inference(State(state.clone()), path()).await),
+                want,
+                "DELETE {name}"
+            );
+        }
+        assert_eq!(
+            status(
+                put_agent_inference(
+                    State(state),
+                    Path("iris".to_owned()),
+                    body(r#"{"model":"opus 4"}"#)
+                )
+                .await
+            ),
+            Some(StatusCode::BAD_REQUEST)
+        );
+    }
+
     #[tokio::test]
     async fn listing_subagents_needs_a_queue_and_an_identifier() {
         let (state, _sched) = state_with_roster();