feat(api): N5 — /api/v1/proof_attempts/coverage cross-repo breakdown

Cross-repo transfer of learnings is already automatic: the
mv_prover_success_by_class MV aggregates (class, prover) regardless
of repo, so strategy recommendations implicitly fuse signal from all
repos. This endpoint surfaces the per-class breakdown so callers can
use n_repos as a confidence amplifier — 100 attempts across 10 repos
is stronger signal than 100 attempts from one repo.

GET /api/v1/proof_attempts/coverage returns:
  coverage: [
    { obligation_class, n_repos, n_provers, n_attempts, n_success }
  ]

Live snapshot (sorted by n_attempts):
  equiv       n_repos=2  n_provers=3  n_attempts=452  (2 repos contributing)
  safety      n_repos=3  n_provers=5  n_attempts=315
  correctness n_repos=2  n_provers=4  n_attempts=204
  totality    n_repos=1  n_provers=1  n_attempts=87   (narrow signal)
  linearity   n_repos=3  n_provers=3  ...

Hypatia's ProofStrategySelection can now detect "narrow signal"
classes (n_repos=1) and either boost exploration or flag low
transfer-confidence in its recommendations.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: hyperpolymath

rust-core/verisim-api/src/lib.rs

@@ -844,6 +844,10 @@ pub fn build_router(state: AppState) -> Router {
             "/api/v1/proof_attempts/certificates",
             get(proof_attempts::certificates_handler),
         )
+        .route(
+            "/api/v1/proof_attempts/coverage",
+            get(proof_attempts::coverage_handler),
+        )
         // Authentication middleware layer
         .layer(axum_middleware::from_fn_with_state(
             auth_state,

rust-core/verisim-api/src/proof_attempts.rs

@@ -251,6 +251,21 @@ pub struct StrategyResponse {
     pub recommendations: Vec<ProverRecommendation>,
 }
 
+/// One row per obligation_class showing cross-repo coverage stats.
+#[derive(Debug, Serialize)]
+pub struct CoverageRow {
+    pub obligation_class: String,
+    pub n_repos: u64,
+    pub n_provers: u64,
+    pub n_attempts: u64,
+    pub n_success: u64,
+}
+
+#[derive(Debug, Serialize)]
+pub struct CoverageResponse {
+    pub coverage: Vec<CoverageRow>,
+}
+
 // ---------------------------------------------------------------------------
 // V4: Certificate types
 // ---------------------------------------------------------------------------
@@ -494,6 +509,41 @@ pub async fn insert_handler(
     ))
 }
 
+/// `GET /api/v1/proof_attempts/coverage`
+///
+/// Returns cross-repo coverage stats per obligation_class: how many distinct
+/// repos have contributed attempts, how many distinct provers, and total
+/// attempt count. Callers can use `n_repos` as a confidence amplifier —
+/// 100 attempts across 10 repos is stronger signal than 100 from one repo.
+#[instrument]
+pub async fn coverage_handler() -> Result<Json<CoverageResponse>, HandlerError> {
+    let sql = "SELECT obligation_class, \
+                   countDistinct(repo) AS n_repos, \
+                   countDistinct(prover_used) AS n_provers, \
+                   count() AS n_attempts, \
+                   countIf(outcome = 'success') AS n_success \
+               FROM verisim.proof_attempts \
+               GROUP BY obligation_class \
+               ORDER BY n_attempts DESC \
+               FORMAT JSONEachRow";
+    let rows = send_clickhouse_read(sql).await?;
+    let coverage: Vec<CoverageRow> = rows
+        .lines()
+        .filter(|l| !l.trim().is_empty())
+        .filter_map(|line| {
+            let v: serde_json::Value = serde_json::from_str(line).ok()?;
+            Some(CoverageRow {
+                obligation_class: v["obligation_class"].as_str()?.to_string(),
+                n_repos: u64_from_json(&v["n_repos"])?,
+                n_provers: u64_from_json(&v["n_provers"])?,
+                n_attempts: u64_from_json(&v["n_attempts"])?,
+                n_success: u64_from_json(&v["n_success"])?,
+            })
+        })
+        .collect();
+    Ok(Json(CoverageResponse { coverage }))
+}
+
 /// `GET /api/v1/proof_attempts/strategy?class=<class>&limit=<n>`
 ///
 /// Queries `mv_prover_success_by_class` for the given `obligation_class` and