feat(gnn): thread domain_hints through GnnGuidedSearch — activate weight-guided ranking

Phase 2 of the GNN feedback loop: now that /training/update populates
PROVER_DOMAIN_WEIGHTS in Julia, callers can route goal aspects through
the rank_premises path so Julia's weight-guided multiplier actually
fires (instead of always using the empty-aspects fast path).

- GnnClient::rank_premises_with_aspects(graph, aspects) — new method;
  populates GnnRankRequest.domain_hints from the caller's aspect slice.
  rank_premises(graph) is now a thin wrapper that passes &[] (no
  behaviour change for existing callers).
- GnnGuidedSearch::rank_premises_with_aspects(state, premises, aspects)
  — same pattern; rank_premises remains the no-aspect convenience
  wrapper. Future agent code passing AgenticGoal.aspects automatically
  activates the closed-loop scoring without any further wiring.
- build_request_payload now takes aspects and writes them into
  domain_hints; existing tests pass &[].

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

Author: hyperpolymath

src/rust/gnn/client.rs

@@ -242,6 +242,23 @@ impl GnnClient {
     /// If the server is unavailable, returns an empty result with
     /// `from_server: false`.
     pub async fn rank_premises(&self, graph: &ProofGraph) -> GnnInferenceResult {
+        self.rank_premises_with_aspects(graph, &[]).await
+    }
+
+    /// Rank premises with goal-aspect hints for weight-guided scoring.
+    ///
+    /// Identical to [`rank_premises`] but populates the `domain_hints` field
+    /// in the request so Julia can apply accumulated training weights from
+    /// `PROVER_DOMAIN_WEIGHTS` (updated by `POST /training/update`).  This
+    /// activates the closed-loop feedback path: prior proof outcomes on the
+    /// same domain influence current premise scoring.
+    ///
+    /// Pass an empty slice for behaviour identical to [`rank_premises`].
+    pub async fn rank_premises_with_aspects(
+        &self,
+        graph: &ProofGraph,
+        aspects: &[String],
+    ) -> GnnInferenceResult {
         if !self.server_available {
             debug!("GNN server not available, returning empty ranking");
             return GnnInferenceResult {
@@ -253,7 +270,7 @@ impl GnnClient {
             };
         }
 
-        match self.call_rank_api(graph).await {
+        match self.call_rank_api(graph, aspects).await {
             Ok(result) => result,
             Err(e) => {
                 warn!("GNN ranking failed: {}", e);
@@ -269,8 +286,12 @@ impl GnnClient {
     }
 
     /// Internal: call the /gnn/rank endpoint.
-    async fn call_rank_api(&self, graph: &ProofGraph) -> Result<GnnInferenceResult> {
-        let payload = self.build_request_payload(graph);
+    async fn call_rank_api(
+        &self,
+        graph: &ProofGraph,
+        aspects: &[String],
+    ) -> Result<GnnInferenceResult> {
+        let payload = self.build_request_payload(graph, aspects);
         let url = format!("{}/gnn/rank", self.config.api_url);
 
         let response = self
@@ -307,7 +328,7 @@ impl GnnClient {
     }
 
     /// Build the request payload from a proof graph.
-    fn build_request_payload(&self, graph: &ProofGraph) -> GnnRankRequest {
+    fn build_request_payload(&self, graph: &ProofGraph, aspects: &[String]) -> GnnRankRequest {
         let (edge_src, edge_dst, edge_weights) = graph.sparse_adjacency();
 
         let edge_kinds: Vec<String> = graph
@@ -360,7 +381,7 @@ impl GnnClient {
                 num_gnn_layers: self.config.num_gnn_layers,
                 use_attention: self.config.use_attention,
             },
-            domain_hints: vec![],
+            domain_hints: aspects.to_vec(),
         }
     }
 
@@ -426,11 +447,17 @@ mod tests {
         extractor.extract_features(&mut graph);
 
         let client = GnnClient::new();
-        let payload = client.build_request_payload(&graph);
+        let payload = client.build_request_payload(&graph, &[]);
 
         assert_eq!(payload.graph.num_nodes, graph.num_nodes());
         assert_eq!(payload.graph.num_edges, graph.num_edges());
         assert_eq!(payload.graph.edge_src.len(), graph.num_edges());
+        assert!(payload.domain_hints.is_empty());
+
+        // With aspects: the same payload but with domain_hints populated
+        let aspects = vec!["arithmetic.factorisation".to_string(), "crypto.hash.sha256".to_string()];
+        let payload_with = client.build_request_payload(&graph, &aspects);
+        assert_eq!(payload_with.domain_hints, aspects);
     }
 
     #[tokio::test]

src/rust/gnn/guided_search.rs

@@ -160,23 +160,39 @@ impl GnnGuidedSearch {
 
     /// Rank available premises for the current proof state.
     ///
+    /// Convenience wrapper around [`rank_premises_with_aspects`] that passes
+    /// no domain hints — equivalent to `rank_premises_with_aspects(state, premises, &[])`.
+    pub async fn rank_premises(
+        &mut self,
+        state: &ProofState,
+        available_premises: &[Theorem],
+    ) -> Vec<ScoredPremise> {
+        self.rank_premises_with_aspects(state, available_premises, &[]).await
+    }
+
+    /// Rank available premises with goal-aspect hints for closed-loop scoring.
+    ///
     /// This is the main entry point. It:
     /// 1. Builds a proof graph from the state
     /// 2. Extracts features
-    /// 3. Queries the GNN server (if available)
+    /// 3. Queries the GNN server (if available), passing `aspects` so Julia
+    ///    can apply accumulated `PROVER_DOMAIN_WEIGHTS` from prior outcomes
     /// 4. Computes symbolic scores
     /// 5. Combines and ranks results
     ///
     /// # Arguments
     /// * `state` - Current proof state (goals + context)
     /// * `available_premises` - Theorems that could be applied
+    /// * `aspects` - Goal aspect tags (e.g. from `AgenticGoal::aspects`).
+    ///   Empty slice = behaviour identical to [`rank_premises`].
     ///
     /// # Returns
     /// Premises ranked by combined score (highest first).
-    pub async fn rank_premises(
+    pub async fn rank_premises_with_aspects(
         &mut self,
         state: &ProofState,
         available_premises: &[Theorem],
+        aspects: &[String],
     ) -> Vec<ScoredPremise> {
         self.stats.total_calls += 1;
 
@@ -187,8 +203,13 @@ impl GnnGuidedSearch {
         // Step 2: Extract features
         self.feature_extractor.extract_features(&mut graph);
 
-        // Step 3: Get GNN scores (if server available)
-        let gnn_result = self.gnn_client.rank_premises(&graph).await;
+        // Step 3: Get GNN scores (if server available); aspects flow through
+        // as `domain_hints` so Julia's rank_with_gnn can apply per-domain
+        // weights accumulated from past proof outcomes.
+        let gnn_result = self
+            .gnn_client
+            .rank_premises_with_aspects(&graph, aspects)
+            .await;
 
         let gnn_scores: HashMap<String, f32> = if gnn_result.from_server {
             self.stats.gnn_calls += 1;