fix(prism): rank top-model / board by G2 lattice score

bins/prism-challenge/src/main.rs

@@ -131,6 +131,13 @@ enum Cmd {
         #[arg(long, default_value_t = 500)]
         limit: u32,
     },
+    /// Force-publish one submission to GitHub/HF top-model (operator republish).
+    /// Requires DB + `PRISM_TOPMODEL_*` token files + parked checkpoint when
+    /// weights are required.
+    RepublishTopmodel {
+        /// Submission id (64 hex).
+        id: String,
+    },
 }
 
 fn main() -> ExitCode {
@@ -163,6 +170,13 @@ fn run(cli: Cli) -> Result<(), String> {
                 .map_err(|e| e.to_string())?;
             return rt.block_on(cmd_rescore_g2(*dry_run, id.clone(), *limit));
         }
+        Some(Cmd::RepublishTopmodel { id }) => {
+            let rt = tokio::runtime::Builder::new_multi_thread()
+                .enable_all()
+                .build()
+                .map_err(|e| e.to_string())?;
+            return rt.block_on(cmd_republish_topmodel(id.clone()));
+        }
         _ => {}
     }
     let rt = tokio::runtime::Builder::new_multi_thread()
@@ -265,6 +279,44 @@ async fn cmd_rescore_g2(dry_run: bool, id: Option<String>, limit: u32) -> Result
     Ok(())
 }
 
+async fn cmd_republish_topmodel(id: String) -> Result<(), String> {
+    let url = std::env::var("BASE_DATABASE_URL")
+        .map_err(|_| "BASE_DATABASE_URL required for republish-topmodel".to_string())?;
+    let pool = db::connect(&url).await.map_err(|e| e.to_string())?;
+    let store: Arc<dyn PrismStore> = Arc::new(DbPrismStore::new(pool));
+    let row = store
+        .get(&id)
+        .await
+        .map_err(|e| e.to_string())?
+        .ok_or_else(|| format!("unknown submission {id}"))?;
+    let lattice_score = match &row.final_score {
+        Some(FinalScore::Score(v)) if *v > 0 => *v,
+        _ => return Err(format!("submission {id} has no positive lattice score")),
+    };
+    if !row.weight_eligible() {
+        return Err(format!(
+            "submission {id} is not weight-eligible (AutoModel 2.0)"
+        ));
+    }
+    let gh = build_topmodel();
+    println!(
+        "republish-topmodel id={id} score={lattice_score} bpb={:?} arch={:?} github={}",
+        row.bpb,
+        row.arch_id,
+        gh.is_some()
+    );
+    prism_registry::post_score_hooks(&store, gh.as_deref(), &row, true).await;
+    if let Ok(Some(pub_row)) = store.last_publication().await {
+        println!(
+            "publication submission_id={} repo={} commit={:?}",
+            pub_row.submission_id, pub_row.repo_path, pub_row.commit_sha
+        );
+    } else {
+        println!("publication: no journal row (publish may have failed; check logs)");
+    }
+    Ok(())
+}
+
 /// Resolve the Lium API key (file/env/credentials — never logged).
 fn load_lium_api_key() -> Option<String> {
     if let Ok(path) = std::env::var("LIUM_API_KEY_FILE") {

crates/prism-challenge/src/orchestrator.rs

@@ -481,7 +481,8 @@ impl<C: ChainClient + Send> Orchestrator<C> {
             .map_err(|e| e.to_string())?;
 
         if let Ok(Some(scored)) = self.store.get(&id).await {
-            prism_registry::post_score_hooks(&self.store, self.topmodel.as_deref(), &scored).await;
+            prism_registry::post_score_hooks(&self.store, self.topmodel.as_deref(), &scored, false)
+                .await;
         }
         self.logs.clear(&id);
         Ok(())
@@ -988,12 +989,8 @@ impl<C: ChainClient + Send> Orchestrator<C> {
             .await
             .map_err(|e| e.to_string())?;
         if let Some(s) = &summary {
-            info!(
-                epoch = s.epoch,
-                leaves = s.leaves,
-                batch = s.batch,
-                "epoch leaf set emitted"
-            );
+            #[rustfmt::skip]
+            info!(epoch = s.epoch, leaves = s.leaves, batch = s.batch, "epoch leaf set emitted");
         }
         Ok(summary)
     }

crates/prism-challenge/tests/arch_competition.rs

@@ -349,7 +349,7 @@ async fn topmodel_hooks_graceful_without_publisher() {
     r.metrics_json = Some(serde_json::json!({"n_params": 12_000_000}));
     store.insert_queued(&r).await.unwrap();
 
-    prism_registry::post_score_hooks(&store, None, &r).await;
+    prism_registry::post_score_hooks(&store, None, &r, false).await;
 
     // Arch published even without a GitHub publisher; nothing journaled.
     assert!(store

crates/prism-registry/src/hf.rs

@@ -1,7 +1,8 @@
 //! HuggingFace Hub top-model publisher.
 //!
-//! When a submission becomes the new global-best bpb, the master publishes a
-//! **reloadable** Hub model card to `PRISM_TOPMODEL_HF_REPO` (default
+//! When a submission becomes the new global-best **lattice score** (G2 board
+//! ranking — never min-bpb alone), the master publishes a **reloadable** Hub
+//! model card to `PRISM_TOPMODEL_HF_REPO` (default
 //! `BaseIntelligence/top-prism-architecture`):
 //!
 //! - custom architecture / AutoModel novelty sources (`architecture.py`,

crates/prism-registry/src/hooks.rs

@@ -8,10 +8,12 @@
 //!    their arch. Idempotent on digest (simultaneous duplicates share the
 //!    first registration).
 //! 2. **Arch best bpb** — lower-wins update feeding owner credit + the
-//!    public leaderboard (any trainer's result counts).
-//! 3. **Top-model publish** — when the row's bpb is a new global best
-//!    (≤ best scored bpb ever AND < last published bpb), publish to GitHub
-//!    and journal the publication. No-op without a configured publisher.
+//!    public leaderboard (any trainer's result counts; audit / secondary).
+//! 3. **Top-model publish** — when the row's **lattice score** is a new
+//!    global best (≥ best scored score ever AND > last published score),
+//!    publish to GitHub/HF and journal. Matches live board ranking
+//!    (G2 benchmark lattice under `scoring_version` 4). Never min-bpb alone.
+//!    No-op without a configured publisher.
 
 use std::sync::Arc;
 
@@ -24,16 +26,20 @@ use tracing::{info, warn};
 use crate::publish::{TopModelPublisher, TopModelRequest, TOPMODEL_REPO_PATH};
 
 /// Run registry + top-model bookkeeping for one finalized row.
+///
+/// When `force` is true (operator republish CLI), skip the global-best /
+/// beats-published guards and publish anyway.
 #[allow(clippy::too_many_lines)]
 pub async fn post_score_hooks(
     store: &Arc<dyn PrismStore>,
     publisher: Option<&TopModelPublisher>,
     row: &SubmissionState,
+    force: bool,
 ) {
-    let (Some(bpb), Some(FinalScore::Score(v))) = (row.bpb, &row.final_score) else {
+    let (Some(bpb), Some(FinalScore::Score(lattice))) = (row.bpb, &row.final_score) else {
         return;
     };
-    if *v == 0 {
+    if *lattice == 0 {
         return; // cheat / copy-gate zero never publishes nor sets arch best
     }
 
@@ -83,9 +89,9 @@ pub async fn post_score_hooks(
         }
     }
 
-    // (3) Top-model publish on a new global best — GitHub (optional) + HF
-    // (optional). Both require a verified secure-receive receipt when
-    // `PRISM_TOPMODEL_REQUIRE_WEIGHTS=1` (default); source-only is opt-in.
+    // (3) Top-model publish on a new global-best **lattice score** — GitHub
+    // (optional) + HF (optional). Both require a verified secure-receive
+    // receipt when `PRISM_TOPMODEL_REQUIRE_WEIGHTS=1` (default).
     // Recipe 2.0 / AutoModel only — legacy 1.x never becomes the published
     // top-model champion (historical FE rows stay in Postgres).
     if !row.weight_eligible() {
@@ -95,12 +101,14 @@ pub async fn post_score_hooks(
         );
         return;
     }
-    let last = store.last_publication_bpb().await.unwrap_or(None);
-    let global = store.best_scored_bpb().await.unwrap_or(None);
-    let is_global_best = global.is_some_and(|g| bpb <= g);
-    let beats_published = last.is_none_or(|l| bpb < l);
-    if !(is_global_best && beats_published) {
-        return;
+    if force {
+        info!(submission_id = %row.id, score = lattice, "top-model: force republish");
+    } else {
+        let last = store.last_publication_score().await.unwrap_or(None);
+        let global = store.best_scored_score().await.unwrap_or(None);
+        if !(global.is_some_and(|g| *lattice >= g) && last.is_none_or(|l| *lattice > l)) {
+            return;
+        }
     }
     let ckpt = match prism_artifacts::verify_parked(&row.id) {
         Ok(receipt) => {
@@ -139,7 +147,7 @@ pub async fn post_score_hooks(
     if let Some(publisher) = publisher {
         match publisher.publish(&req).await {
             Ok(sha) => {
-                info!(submission_id = %row.id, bpb, commit = %sha, "top model published to GitHub");
+                info!(submission_id = %row.id, score = lattice, bpb, commit = %sha, "top model published");
                 let rec = TopModelPublication {
                     submission_id: row.id.clone(),
                     arch_id: arch_id.clone(),

crates/prism-registry/src/lib.rs

@@ -5,8 +5,9 @@
 //! - [`competition_scores`] — per-epoch emission math for the architecture
 //!   competition (SCORE_MAX lattice preserved; exact rule documented in
 //!   `docs/PRISM.md` § Architecture competition).
-//! - [`TopModelPublisher`] — publishes each new global-best bpb model to the
-//!   public `BaseIntelligence/prism` GitHub repo under `top-model/`, via a
+//! - [`TopModelPublisher`] — publishes each new global-best **lattice score**
+//!   model (G2 benches under `scoring_version` 4 — never min-bpb alone) to
+//!   the public `BaseIntelligence/prism` GitHub repo under `top-model/`, via a
 //!   token read from a deploy secret file (`PRISM_TOPMODEL_GITHUB_TOKEN_FILE`;
 //!   graceful no-op when absent).
 //! - [`HfTopModelPublisher`] — same trigger, commits a reloadable custom-arch

crates/prism-registry/src/publish.rs

@@ -1,7 +1,7 @@
-//! Top-model GitHub publisher: each new global-best bpb model is published
-//! to the public `BaseIntelligence/prism` repo under `top-model/`
-//! (architecture.py + training.py + METRICS.json + README.md block) via the
-//! GitHub contents API.
+//! Top-model GitHub publisher: each new global-best **lattice score** model
+//! (G2 benchmark board ranking) is published to the public
+//! `BaseIntelligence/prism` repo under `top-model/` (architecture.py +
+//! training.py + METRICS.json + README.md block) via the GitHub contents API.
 //!
 //! Token discipline: the GitHub token is read from a deploy secret **file**
 //! (`PRISM_TOPMODEL_GITHUB_TOKEN_FILE`, e.g. `deploy/secrets/github/token`),
@@ -51,7 +51,7 @@ pub struct TopModelRequest {
     pub arch_id: Option<String>,
     /// Miner hotkey that set the best.
     pub owner_hotkey: String,
-    /// Global-best bpb.
+    /// Measured bpb (audit / README; champion selection uses lattice score).
     pub bpb: f64,
     /// architecture.py (registry source for training-only entries).
     pub architecture_py: String,
@@ -240,8 +240,9 @@ fn readme_block(req: &TopModelRequest, weight_note: &str) -> String {
     };
     format!(
         "# PRISM top model\n\n\
-         Published by the Base master on every new global-best bpb. This\n\
-         directory always mirrors the current champion; history lives in git.\n\n\
+         Published by the Base master on every new global-best G2 lattice\n\
+         score (live board ranking). This directory always mirrors the\n\
+         current champion; history lives in git.\n\n\
          | field | value |\n|---|---|\n\
          | arch_id | `{}` |\n\
          | owner_hotkey | `{}…` |\n\

crates/prism-store/src/arch.rs

@@ -197,6 +197,19 @@ pub(crate) async fn last_publication_bpb(pool: &PgPool) -> Result<Option<f64>, S
     Ok(last_publication(pool).await?.map(|p| p.bpb))
 }
 
+pub(crate) async fn last_publication_score(pool: &PgPool) -> Result<Option<u64>, StoreError> {
+    let row: Option<(Option<i64>,)> = sqlx::query_as(
+        "SELECT s.score FROM prism_topmodel_publication p \
+         JOIN prism_submission s ON s.id = p.submission_id \
+         WHERE s.kind = 'score' AND s.score > 0 \
+         ORDER BY p.published_at DESC LIMIT 1",
+    )
+    .fetch_optional(pool)
+    .await
+    .map_err(backend)?;
+    Ok(row.and_then(|(s,)| s.map(i64::cast_unsigned)))
+}
+
 pub(crate) async fn last_publication(
     pool: &PgPool,
 ) -> Result<Option<TopModelPublication>, StoreError> {
@@ -232,3 +245,16 @@ pub(crate) async fn best_scored_bpb(pool: &PgPool) -> Result<Option<f64>, StoreE
     .map_err(backend)?;
     Ok(row.0)
 }
+
+pub(crate) async fn best_scored_score(pool: &PgPool) -> Result<Option<u64>, StoreError> {
+    let row: (Option<i64>,) = sqlx::query_as(&format!(
+        "SELECT MAX(score) FROM prism_submission \
+         WHERE kind = 'score' AND score > 0 \
+           AND {}",
+        crate::emit::WEIGHT_ELIGIBLE_SQL
+    ))
+    .fetch_one(pool)
+    .await
+    .map_err(backend)?;
+    Ok(row.0.map(i64::cast_unsigned))
+}

crates/prism-store/src/dbprism.rs

@@ -426,6 +426,10 @@ impl PrismStore for DbPrismStore {
         arch::last_publication_bpb(&self.pool).await
     }
 
+    async fn last_publication_score(&self) -> Result<Option<u64>, StoreError> {
+        arch::last_publication_score(&self.pool).await
+    }
+
     async fn last_publication(&self) -> Result<Option<TopModelPublication>, StoreError> {
         arch::last_publication(&self.pool).await
     }
@@ -434,6 +438,10 @@ impl PrismStore for DbPrismStore {
         arch::best_scored_bpb(&self.pool).await
     }
 
+    async fn best_scored_score(&self) -> Result<Option<u64>, StoreError> {
+        arch::best_scored_score(&self.pool).await
+    }
+
     async fn list_stuck(&self, grace_secs: u64) -> Result<Vec<SubmissionState>, StoreError> {
         let rows = dbs::stuck_prism_before_grace(
             &self.pool,