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 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={score} bpb={:?} arch={:?} github={}",
+        row.bpb,
+        row.arch_id,
+        gh.is_some()
+    );
+    prism_registry::force_publish_topmodel(&store, gh.as_deref(), &row).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-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,35 @@ use tracing::{info, warn};
 use crate::publish::{TopModelPublisher, TopModelRequest, TOPMODEL_REPO_PATH};
 
 /// Run registry + top-model bookkeeping for one finalized row.
-#[allow(clippy::too_many_lines)]
 pub async fn post_score_hooks(
     store: &Arc<dyn PrismStore>,
     publisher: Option<&TopModelPublisher>,
     row: &SubmissionState,
 ) {
-    let (Some(bpb), Some(FinalScore::Score(v))) = (row.bpb, &row.final_score) else {
+    post_score_hooks_inner(store, publisher, row, false).await;
+}
+
+/// Operator force-publish (republish CLI): same path as the auto trigger but
+/// skips the global-best / beats-published guards.
+pub async fn force_publish_topmodel(
+    store: &Arc<dyn PrismStore>,
+    publisher: Option<&TopModelPublisher>,
+    row: &SubmissionState,
+) {
+    post_score_hooks_inner(store, publisher, row, true).await;
+}
+
+#[allow(clippy::too_many_lines)]
+async fn post_score_hooks_inner(
+    store: &Arc<dyn PrismStore>,
+    publisher: Option<&TopModelPublisher>,
+    row: &SubmissionState,
+    force: bool,
+) {
+    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 +104,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 +116,20 @@ 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 (operator)"
+        );
+    } else {
+        let last = store.last_publication_score().await.unwrap_or(None);
+        let global = store.best_scored_score().await.unwrap_or(None);
+        let is_global_best = global.is_some_and(|g| *lattice >= g);
+        let beats_published = last.is_none_or(|l| *lattice > l);
+        if !(is_global_best && beats_published) {
+            return;
+        }
     }
     let ckpt = match prism_artifacts::verify_parked(&row.id) {
         Ok(receipt) => {
@@ -139,7 +168,13 @@ 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 to GitHub"
+                );
                 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
@@ -27,7 +28,7 @@ mod weights;
 
 pub use competition::{apply_wta, competition_scores, OWNER_ARCH_CREDIT_ENABLED};
 pub use hf::HfTopModelPublisher;
-pub use hooks::post_score_hooks;
+pub use hooks::{force_publish_topmodel, post_score_hooks};
 pub use publish::{
     require_topmodel_weights, TopModelPublisher, TopModelRequest, TOPMODEL_REPO_PATH,
 };

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,

crates/prism-store/src/store.rs

@@ -118,17 +118,25 @@ pub trait PrismStore: Send + Sync + std::fmt::Debug {
     /// Journal one top-model publication.
     async fn record_publication(&self, p: &TopModelPublication) -> Result<(), StoreError>;
 
-    /// bpb of the most recent publication (idempotency guard; `None` = never
-    /// published).
+    /// bpb of the most recent publication (audit; prefer [`Self::last_publication_score`]).
     async fn last_publication_bpb(&self) -> Result<Option<f64>, StoreError>;
 
+    /// Lattice score of the submission behind the most recent publication
+    /// (idempotency guard for G2 / score ranking; `None` = never published or
+    /// the published row has no positive score).
+    async fn last_publication_score(&self) -> Result<Option<u64>, StoreError>;
+
     /// Most recent top-model publication row (`None` = never published).
     async fn last_publication(&self) -> Result<Option<TopModelPublication>, StoreError>;
 
-    /// Best (lowest) bpb across all scored submissions ever (global top-model
-    /// trigger baseline).
+    /// Best (lowest) bpb across weight-eligible scored submissions (audit /
+    /// legacy). Top-model publish uses [`Self::best_scored_score`].
     async fn best_scored_bpb(&self) -> Result<Option<f64>, StoreError>;
 
+    /// Best (highest) lattice score across weight-eligible scored submissions
+    /// (global top-model / HF champion trigger — matches live board ranking).
+    async fn best_scored_score(&self) -> Result<Option<u64>, StoreError>;
+
     /// Non-terminal rows beyond grace — for the stuck sweep.
     async fn list_stuck(&self, grace_secs: u64) -> Result<Vec<SubmissionState>, StoreError>;
 
@@ -596,6 +604,24 @@ impl PrismStore for MemoryPrismStore {
             .map(|p| p.bpb))
     }
 
+    async fn last_publication_score(&self) -> Result<Option<u64>, StoreError> {
+        let last = self.last_publication().await?;
+        let Some(p) = last else {
+            return Ok(None);
+        };
+        let rows = self
+            .rows
+            .lock()
+            .map_err(|_| StoreError::Backend("poison".into()))?;
+        Ok(rows
+            .iter()
+            .find(|r| r.id == p.submission_id)
+            .and_then(|r| match r.final_score {
+                Some(FinalScore::Score(v)) if v > 0 => Some(v),
+                _ => None,
+            }))
+    }
+
     async fn last_publication(&self) -> Result<Option<TopModelPublication>, StoreError> {
         Ok(self
             .publications
@@ -617,6 +643,20 @@ impl PrismStore for MemoryPrismStore {
             .min_by(f64::total_cmp))
     }
 
+    async fn best_scored_score(&self) -> Result<Option<u64>, StoreError> {
+        Ok(self
+            .rows
+            .lock()
+            .map_err(|_| StoreError::Backend("poison".into()))?
+            .iter()
+            .filter(|r| r.weight_eligible())
+            .filter_map(|r| match r.final_score {
+                Some(FinalScore::Score(v)) if v > 0 => Some(v),
+                _ => None,
+            })
+            .max())
+    }
+
     async fn list_stuck(&self, grace_secs: u64) -> Result<Vec<SubmissionState>, StoreError> {
         let cutoff = now_ms().saturating_sub(grace_secs.saturating_mul(1000));
         Ok(self