feat(rust): add GnnClient::health_status() returning richer health payload

Adds the public GnnHealth struct (model_path, vocab_size,
training_records_received, service, version) and health_status() method
that GETs /gnn/health and deserializes it. Existing check_health() is
unchanged and keeps updating server_available.

Also adds a check_health() call inside gnn_augment_tactics so backends
exercise the live server path in tests (previously a fresh GnnClient
with server_available=false silently returned empty rankings). Re-exports
GnnHealth from gnn::mod.

https://claude.ai/code/session_01YPqu7gti4azBach6ZvpRFJ

Author: claude

src/rust/gnn/client.rs

@@ -138,7 +138,7 @@ struct GnnRankResponse {
     error: Option<String>,
 }
 
-/// GNN health check response.
+/// GNN health check response (internal, minimal — kept for legacy deserialization path).
 #[derive(Debug, Deserialize)]
 struct GnnHealthResponse {
     /// Server status
@@ -150,6 +150,25 @@ struct GnnHealthResponse {
     num_gnn_layers: usize,
 }
 
+/// Richer health payload returned by `/gnn/health` after the S5 extension.
+///
+/// All fields present when `gnn_model_loaded` is true; `model_path`,
+/// `vocab_size`, and `training_records_received` are the new additions.
+#[derive(Debug, Clone, Deserialize)]
+pub struct GnnHealth {
+    pub status: String,
+    pub gnn_model_loaded: bool,
+    pub model_path: Option<String>,
+    #[serde(default)]
+    pub vocab_size: usize,
+    #[serde(default)]
+    pub training_records_received: u64,
+    #[serde(default)]
+    pub num_gnn_layers: usize,
+    pub service: String,
+    pub version: String,
+}
+
 /// Result of a GNN inference call.
 #[derive(Debug, Clone, Serialize, Deserialize)]
 pub struct GnnInferenceResult {
@@ -199,6 +218,28 @@ impl GnnClient {
         }
     }
 
+    /// Fetch the richer `/gnn/health` payload introduced in S5.
+    ///
+    /// Returns the full `GnnHealth` struct (model path, vocab size,
+    /// training record count, etc.).  Does NOT update `server_available`
+    /// — callers that need the availability gate should use `check_health`.
+    pub async fn health_status(&self) -> Result<GnnHealth> {
+        let url = format!("{}/gnn/health", self.config.api_url);
+        let response = self
+            .client
+            .get(&url)
+            .send()
+            .await
+            .context("Failed to reach GNN health endpoint")?;
+        if !response.status().is_success() {
+            anyhow::bail!("GNN health returned HTTP {}", response.status());
+        }
+        response
+            .json::<GnnHealth>()
+            .await
+            .context("Failed to parse GnnHealth response")
+    }
+
     /// Check if the GNN server is available and has a loaded model.
     ///
     /// Updates `server_available` state. Call this before making

src/rust/gnn/mod.rs

@@ -49,7 +49,7 @@ pub mod fallback_monitor;
 pub mod graph;
 pub mod guided_search;
 
-pub use client::{GnnClient, GnnConfig, GnnInferenceResult};
+pub use client::{GnnClient, GnnConfig, GnnHealth, GnnInferenceResult};
 pub use embeddings::{TermEmbedding, TermFeatureExtractor};
 pub use fallback_monitor::{FallbackMetrics, FallbackMonitor, FallbackSlaConfig};
 pub use graph::{EdgeKind, NodeKind, ProofGraph, ProofGraphBuilder};

src/rust/provers/mod.rs

@@ -1516,7 +1516,7 @@ pub(crate) async fn gnn_augment_tactics(
     use crate::gnn::graph::ProofGraphBuilder;
 
     let graph = ProofGraphBuilder::new(4).build_from_proof_state(state);
-    let gnn = GnnClient::with_config(GnnConfig {
+    let mut gnn = GnnClient::with_config(GnnConfig {
         api_url: url,
         timeout_ms: 2000,
         top_k: 8,
@@ -1530,6 +1530,11 @@ pub(crate) async fn gnn_augment_tactics(
     // so Julia's /gnn/rank can apply per-domain weights from prior outcomes.
     // When metadata has no "aspects" key (e.g. direct REPL invocation), aspects
     // is empty and behaviour is identical to the no-hint path.
+    // Ping the server so rank_premises_with_aspects sees server_available = true.
+    // Graceful: if check_health errors (server down), gnn.server_available stays
+    // false and rank_premises_with_aspects returns empty — no disruption to callers.
+    let _ = gnn.check_health().await;
+
     let aspects: Vec<String> = state
         .metadata
         .get("aspects")