feat(prism): arch registry, training-only competition, top-model

Author: echobt

Cargo.lock

@@ -21,6 +21,7 @@ clap = { version = "4", features = ["derive", "env"] }
 prism-challenge = { path = "../../crates/prism-challenge" }
 prism-lium = { path = "../../crates/prism-lium" }
 prism-recipe = { path = "../../crates/prism-recipe" }
+prism-registry = { path = "../../crates/prism-registry" }
 prism-review = { path = "../../crates/prism-review" }
 submission-gating = { path = "../../crates/submission-gating" }
 crypto = { path = "../../crates/crypto" }

bins/prism-challenge/Cargo.toml

@@ -345,6 +345,16 @@ fn spawn_gating_watcher(
     });
 }
 
+/// Top-model GitHub publisher: graceful no-op (`None`) unless
+/// `PRISM_TOPMODEL_GITHUB_TOKEN_FILE` points at a readable token file.
+fn build_topmodel() -> Option<Arc<prism_registry::TopModelPublisher>> {
+    let p = prism_registry::TopModelPublisher::from_env().map(Arc::new);
+    if p.is_none() {
+        tracing::info!("top-model publish disabled (PRISM_TOPMODEL_GITHUB_TOKEN_FILE unset/empty)");
+    }
+    p
+}
+
 async fn cmd_serve(cli: Cli) -> Result<(), String> {
     let path = resolve_sk_path(cli.challenge_sk_file.as_ref())?;
     if !path.is_file() {
@@ -415,6 +425,7 @@ async fn cmd_serve(cli: Cli) -> Result<(), String> {
         stage_delay,
         auto_retry_max: cli.auto_retry_max,
     };
+    let topmodel = build_topmodel();
     let mut orchestrator = Orchestrator::new(
         oc,
         store,
@@ -424,7 +435,8 @@ async fn cmd_serve(cli: Cli) -> Result<(), String> {
         gateway,
         Arc::new(chain),
         sk,
-    );
+    )
+    .with_topmodel(topmodel);
     if gating_enabled {
         orchestrator = orchestrator.with_gating(Arc::clone(&gating));
         spawn_gating_watcher(

bins/prism-challenge/src/main.rs

@@ -46,6 +46,23 @@ impl SimAgent {
     }
 }
 
+/// Primaries in scope for corpus comparison. Prism compares `architecture.py`
+/// ONLY (similarity v2: training.py is exempt from corpus/candidate); other
+/// domains use every primary.
+fn scoped_primaries<'a>(req: &ReviewRequest, primaries: &'a [(String, String)]) -> Vec<&'a str> {
+    if req.domain_rules.contains("Prism domain") {
+        let arch: Vec<&str> = primaries
+            .iter()
+            .filter(|(p, _)| p.ends_with("architecture.py"))
+            .map(|(_, s)| s.as_str())
+            .collect();
+        if !arch.is_empty() {
+            return arch;
+        }
+    }
+    primaries.iter().map(|(_, s)| s.as_str()).collect()
+}
+
 #[async_trait]
 impl AgenticBackend for SimAgent {
     async fn review(&self, req: &ReviewRequest) -> Result<AgenticVerdict, AgenticError> {
@@ -66,25 +83,9 @@ impl AgenticBackend for SimAgent {
             return Ok(v);
         }
 
-        // Concatenate primaries for hash / fingerprint (stable order from
-        // request). Prism compares architecture.py ONLY (similarity v2:
-        // training.py is exempt from corpus/candidate); other domains use
-        // every primary.
-        let scoped: Vec<&str> = if req.domain_rules.contains("Prism domain") {
-            let arch: Vec<&str> = primaries
-                .iter()
-                .filter(|(p, _)| p.ends_with("architecture.py"))
-                .map(|(_, s)| s.as_str())
-                .collect();
-            if arch.is_empty() {
-                primaries.iter().map(|(_, s)| s.as_str()).collect()
-            } else {
-                arch
-            }
-        } else {
-            primaries.iter().map(|(_, s)| s.as_str()).collect()
-        };
-        let joined = scoped.join("\n#--\n");
+        // Concatenate the in-scope primaries for hash / fingerprint (stable
+        // order from request).
+        let joined = scoped_primaries(req, &primaries).join("\n#--\n");
         let cand_hash = source_hash_hex(&joined);
 
         for entry in &req.corpus {
@@ -185,9 +186,7 @@ fn telemetry_hooks_verdict(
     if !req.domain_rules.contains("Prism domain") {
         return None;
     }
-    let Some((path, src)) = primaries.iter().find(|(p, _)| p.ends_with("training.py")) else {
-        return None;
-    };
+    let (path, src) = primaries.iter().find(|(p, _)| p.ends_with("training.py"))?;
     let imports_shim = src.contains("prism_telemetry")
         || src.contains("ctx[\"telemetry\"]")
         || src.contains("ctx['telemetry']");

crates/challenge-agentic/src/sim.rs

@@ -298,30 +298,6 @@ pub async fn prism_stage_events(
     Ok(rows)
 }
 
-/// Latest final score per miner for `(netuid, epoch)`.
-///
-/// Rows without `kind` (not scored yet) do not appear.
-///
-/// # Errors
-/// SQL error.
-pub async fn prism_scores_for_epoch(
-    pool: &PgPool,
-    netuid: i32,
-    epoch: i64,
-) -> Result<Vec<(String, String, Option<i64>, Option<i16>)>, DbError> {
-    let rows: Vec<(String, String, Option<i64>, Option<i16>)> = sqlx::query_as(
-        "SELECT DISTINCT ON (miner_hotkey) miner_hotkey, kind, score, absence_reason \
-         FROM prism_submission \
-         WHERE netuid = $1 AND epoch = $2 AND kind IS NOT NULL \
-         ORDER BY miner_hotkey, updated_at DESC",
-    )
-    .bind(netuid)
-    .bind(epoch)
-    .fetch_all(pool)
-    .await?;
-    Ok(rows)
-}
-
 /// Stage statuses stuck non-terminal beyond the grace window (restart sweep).
 ///
 /// # Errors

crates/db/src/prism_store.rs

@@ -23,6 +23,7 @@ prism-challenge-task = { path = "../prism-challenge-task" }
 prism-lium = { path = "../prism-lium" }
 prism-pipeline = { path = "../prism-pipeline" }
 prism-recipe = { path = "../prism-recipe" }
+prism-registry = { path = "../prism-registry" }
 prism-review = { path = "../prism-review" }
 prism-store = { path = "../prism-store" }
 trustroot = { path = "../trustroot" }

crates/prism-challenge/Cargo.toml

@@ -52,17 +52,20 @@ pub fn build_review_request(
 /// Corpus entries are **architecture.py only** (similarity v2): `training.py`
 /// is exempt from every copy/similarity comparison — the same training
 /// script on two different architectures is legitimate competition behavior.
+/// `exempt_arch` drops entries byte-equal to that source (training-only
+/// submissions on a registry architecture: the identity is by design).
 #[must_use]
 pub fn corpus_from_rows(
     current_id: &str,
     recent: &[prism_store::SubmissionState],
+    exempt_arch: Option<&str>,
 ) -> Vec<CorpusEntry> {
     let mut v = vec![CorpusEntry {
         id: "baseline".into(),
         source: BASELINE_ARCHITECTURE_PY.into(),
     }];
     for r in recent {
-        if r.id == current_id {
+        if r.id == current_id || Some(r.architecture_py.as_str()) == exempt_arch {
             continue;
         }
         let label = if r.id.len() >= 8 {