swarm-controller: post the review classifier's verdict on a review request

Requesting the forge account `review-classifier` as a reviewer now runs the
repo's rules against the PR and posts the result as that account's review,
on the head commit the run read. A push starts no run; only a fresh review
request does.

- An instance-wide `pull_request_review_request` system hook delivers to
  `/webhook/forge/review-request`. A request for any other reviewer, or a
  removed request, does nothing.
- The controller reads the PR, loads the rules with the same reader as
  `GET /api/review-classifier/rules`, sends one request on the try-out
  subject, and posts APPROVED or REQUEST_CHANGES with the table as the body.
- With no clean verdict (PR or rules don't load, the run fails, or any
  classification has no answer) it posts a COMMENT saying why, never an
  approval. The event is one function, `no_clean_verdict_event`.
- Table cells are flattened, markup-escaped, and every `@` gets a
  zero-width space, so a model's reason can't break the table or mention
  anyone.
- At most two requested reviews run at once; the rest wait in memory.
- The account is minted the way hive accounts are: a five-minute pass
  queues a `MintClassifierForgeToken` node when the token at
  `swarm/services/review-classifier/forge/token` is missing or stale. The
  token is `write:repository`. The controller's bao policy gains that leaf
  (create/read/update), pinned in module-eval bao-grants. The classifier
  never sees the token.

The account gets no repo access automatically; a repo admin adds it by
hand. A re-request retires the account's earlier review: Forgejo clears
`official` on a reviewer's earlier reviews when it is requested again
(models/issues/review.go AddReviewRequest, v16.0.5), and approvals and
rejection blocks count official reviews only.

Refs #5137

swarm-controller/src/main.rs

@@ -147,6 +147,10 @@ enum SwarmNodeKind {
     /// the `hives` team, and holds a live token in the swarm store, where
     /// that hive's hive-c0re reads it. See `forge::hive_token`.
     MintHiveForgeToken { hive: String },
+    /// Make sure the review classifier's forge account exists and holds a
+    /// live token in the swarm store, where this daemon reads it to post the
+    /// classifier's reviews. See `forge::classifier_account`.
+    MintClassifierForgeToken,
     /// Re-mint `agent`'s queue secret if it is still stored and old enough.
     /// See `agent_renewal`.
     ///
@@ -187,6 +191,7 @@ impl hive_jobq_wire::WireNode for SwarmNodeKind {
             SwarmNodeKind::MintAgentMatrixAccount { .. } => "mint_agent_matrix_account".to_owned(),
             SwarmNodeKind::MintHiveSenderToken { .. } => "mint_hive_sender_token".to_owned(),
             SwarmNodeKind::MintHiveForgeToken { .. } => "mint_hive_forge_token".to_owned(),
+            SwarmNodeKind::MintClassifierForgeToken => "mint_classifier_forge_token".to_owned(),
             SwarmNodeKind::RenewAgentQueueCredential { .. } => {
                 "renew_agent_queue_credential".to_owned()
             }
@@ -217,6 +222,7 @@ impl hive_jobq_wire::WireNode for SwarmNodeKind {
             }
             SwarmNodeKind::MintHiveSenderToken { hive }
             | SwarmNodeKind::MintHiveForgeToken { hive } => serde_json::json!({ "hive": hive }),
+            SwarmNodeKind::MintClassifierForgeToken => serde_json::json!({}),
             SwarmNodeKind::TriggerDeploy { hive, agent, rev } => {
                 serde_json::json!({ "agent": agent, "hive": hive, "rev": rev })
             }
@@ -373,6 +379,7 @@ async fn run_swarm_node(
             mint_hive_sender(deps.matrix_homeserver.as_deref(), &hive).await
         }
         SwarmNodeKind::MintHiveForgeToken { hive } => mint_hive_forge_token(forge, &hive).await,
+        SwarmNodeKind::MintClassifierForgeToken => mint_classifier_forge_token(forge).await,
         SwarmNodeKind::RenewAgentQueueCredential { agent } => renew_queue_credential(&agent).await,
         SwarmNodeKind::SetAgentWanted { hive, agent } => match deps.wanted {
             None => Outcome::Failed(
@@ -527,6 +534,30 @@ async fn mint_hive_forge_token(
     }
 }
 
+/// The `MintClassifierForgeToken` arm, lifted out for the same reason.
+async fn mint_classifier_forge_token(
+    forge: Option<Arc<forge::Client>>,
+) -> hive_jobq::scheduler::Outcome {
+    use hive_jobq::scheduler::Outcome;
+
+    let Some(client) = forge else {
+        return Outcome::Failed(
+            "no forge access here (SWARM_CONTROLLER_FORGE_URL unset, or its token \
+             not in the swarm secret store), so no review classifier forge token can be minted"
+                .to_owned(),
+        );
+    };
+    match forge_node(
+        "mint_classifier_forge_token",
+        client.ensure_classifier_forge_token(),
+    )
+    .await
+    {
+        Ok(()) => Outcome::Done,
+        Err(e) => Outcome::Failed(format!("{e:#}")),
+    }
+}
+
 /// The `MintAgentMatrixAccount` arm, lifted out for the same reason.
 async fn mint_matrix_account(
     homeserver: Option<&str>,
@@ -862,6 +893,16 @@ struct AppState {
     /// The review classifier try-outs started here, until their results
     /// expire.
     try_outs: review_classifier::TryOuts,
+    /// Held by each requested review's run, so at most
+    /// `review_classifier::review::MAX_CONCURRENT_REVIEWS` go at once.
+    review_slots: Arc<tokio::sync::Semaphore>,
+}
+
+/// A fresh [`AppState::review_slots`].
+fn review_slots() -> Arc<tokio::sync::Semaphore> {
+    Arc::new(tokio::sync::Semaphore::new(
+        review_classifier::review::MAX_CONCURRENT_REVIEWS,
+    ))
 }
 
 /// Env var the controller's NixOS module sets from
@@ -2488,6 +2529,20 @@ fn queue_hive_forge_token_mints(
     Ok(ids)
 }
 
+/// Insert one `MintClassifierForgeToken` job and return its node's id.
+/// `forge::classifier_account::spawn`'s periodic pass is the one caller.
+fn queue_classifier_forge_token_mint(
+    sched: &Mutex<hive_jobq::scheduler::Scheduler<SwarmNodeKind, SwarmResourceKind>>,
+) -> Result<Vec<hive_jobq::NodeId>> {
+    sched
+        .lock()
+        .unwrap_or_else(std::sync::PoisonError::into_inner)
+        .insert_job(None, |b| {
+            vec![b.node(SwarmNodeKind::MintClassifierForgeToken).guid()]
+        })
+        .map_err(|e| anyhow::anyhow!("{e}"))
+}
+
 /// The homeserver agents' own matrix accounts are minted on. Unset is this
 /// controller creating agents with no matrix account, which the mint node
 /// reports by name rather than `main` refusing to start.
@@ -2548,6 +2603,12 @@ fn spawn_forge_workers(
         }
     });
     let sched = Arc::clone(jobq);
+    forge::classifier_account::spawn(Arc::clone(&client), move || {
+        if let Err(e) = queue_classifier_forge_token_mint(&sched) {
+            tracing::warn!(error = %format!("{e:#}"), "review classifier forge token: queueing failed");
+        }
+    });
+    let sched = Arc::clone(jobq);
     forge::docs_grant::spawn(Arc::clone(&client), move |agents| {
         if let Err(e) = queue_docs_grants(&sched, agents) {
             tracing::warn!(error = %format!("{e:#}"), "docs grants: queueing failed");
@@ -3214,6 +3275,7 @@ async fn main() -> Result<()> {
         create_gate: Arc::default(),
         accounts: linked_accounts::Accounts::Live,
         try_outs: review_classifier::TryOuts::default(),
+        review_slots: review_slots(),
     };
 
     let app = build_app(state);
@@ -3402,6 +3464,7 @@ mod tests {
             create_gate: std::sync::Arc::default(),
             accounts: super::linked_accounts::Accounts::Fake(std::sync::Arc::default()),
             try_outs: super::review_classifier::TryOuts::default(),
+            review_slots: super::review_slots(),
         };
         (state, sched)
     }
@@ -4316,6 +4379,10 @@ mod tests {
                     hive: "pr1ma".to_owned(),
                 },
             ),
+            (
+                "mint_classifier_forge_token",
+                SwarmNodeKind::MintClassifierForgeToken,
+            ),
         ];
         for (label, kind) in nodes {
             let mut sched = hive_jobq::scheduler::Scheduler::new(