fix(design): auto-schedule agents, keep CSS, screenshots for site UI

Active design agents now schedule every round; sanitizer retains presentation
CSS; same-hotkey peers are excluded from copy checks; capture full-page PNG
previews (Chromium in design-challenge image) and expose screenshotUrl via
site-api for the public submissions UI.

Author: echobt

Cargo.lock

@@ -328,6 +328,47 @@ pub async fn list_recent_design_harnesses(
         .await?)
 }
 
+/// Active harnesses eligible for automatic per-round scheduling.
+///
+/// One row per miner (newest active), excluding eliminated-until-future rows.
+///
+/// # Errors
+/// SQL error.
+pub async fn list_active_design_harnesses(
+    pool: &PgPool,
+    max_eliminated_until_round: i64,
+) -> Result<Vec<DesignHarnessRow>, DbError> {
+    let q = format!(
+        "SELECT DISTINCT ON (miner_hotkey) {HARNESS_COLS} FROM design_harness \
+         WHERE active = TRUE AND eliminated_until_round <= $1 \
+         ORDER BY miner_hotkey ASC, created_at DESC"
+    );
+    Ok(sqlx::query_as::<_, DesignHarnessRow>(&q)
+        .bind(max_eliminated_until_round)
+        .fetch_all(pool)
+        .await?)
+}
+
+/// Mark every other harness for this miner inactive (1 active agent per hotkey).
+///
+/// # Errors
+/// SQL error.
+pub async fn deactivate_other_design_harnesses(
+    pool: &PgPool,
+    miner_hotkey: &str,
+    keep_id: &str,
+) -> Result<(), DbError> {
+    sqlx::query(
+        "UPDATE design_harness SET active = FALSE, updated_at = now() \
+         WHERE miner_hotkey = $1 AND id <> $2 AND active = TRUE",
+    )
+    .bind(miner_hotkey)
+    .bind(keep_id)
+    .execute(pool)
+    .await?;
+    Ok(())
+}
+
 /// Set elimination cooldown.
 ///
 /// # Errors

crates/db/src/design_store.rs

@@ -10,6 +10,7 @@ publish = false
 
 [dependencies]
 async-trait = "0.1"
+base64 = "0.22"
 bundle = { path = "../bundle" }
 challenge-agentic = { path = "../challenge-agentic" }
 challenge-common = { path = "../challenge-common" }
@@ -24,6 +25,7 @@ design-store = { path = "../design-store" }
 hex = "0.4"
 serde = { version = "1", features = ["derive"] }
 serde_json = "1"
+sha2 = "0.10"
 submission-gating = { path = "../submission-gating" }
 tokio = { version = "1", features = ["macros", "rt-multi-thread", "time", "sync"] }
 tracing = "0.1"

crates/design-challenge/Cargo.toml

@@ -20,6 +20,7 @@
 pub mod host_sim;
 mod orchestrator;
 pub mod score;
+mod screenshot;
 
 pub use challenge_common::{
     emit_signed_leaf_set, public_key_from_secret, submit_signed_leaf_set, verify_leaf_sig,

crates/design-challenge/src/lib.rs

@@ -17,19 +17,22 @@ use challenge_common::{
 };
 use crypto::KEY_LEN;
 use design_challenge_task::{round_id_at, round_secs};
-use design_http::{mark_awaiting_admin, AdminAwardHook};
+use base64::Engine;
+use design_http::{mark_awaiting_admin, schedule_harness_for_round, AdminAwardHook};
 use design_prompts::{prompt_set_digest, select_prompts_for_round};
 use design_sandbox::{SandboxBackend, SandboxError};
 use design_sanitize::sanitize_bundle;
 use design_store::{
     DesignStore, FinalScore, RatingRow, RoundRow, RunStage, StageEvent, StorePatch,
 };
 use serde_json::json;
+use sha2::{Digest, Sha256};
 use submission_gating::{GatingState, GatingStore};
 use tokio::time::sleep;
 use tracing::{info, warn};
 
 use crate::score::{not_attempted, score_window, to_leaf, window_start, WindowScorePlan};
+use crate::screenshot::capture_full_page_png;
 use crate::CHALLENGE_ID;
 
 /// Cap harness log payload stored in stage-event detail (JSON).
@@ -254,11 +257,62 @@ impl<C: ChainClient + Send + Sync + 'static> Orchestrator<C> {
                     }
                 }
             }
-            // Ensure current round row exists.
+            // Ensure current round row exists and every active agent is queued.
             let _ = self.ensure_round(rid).await;
+            if let Err(e) = self.schedule_active_for_round(rid).await {
+                warn!(error = %e, round = rid, "schedule_active_for_round failed");
+            }
         }
     }
 
+    /// Queue runs for every active (non-eliminated) harness in `rid`.
+    ///
+    /// Submit only schedules the *next* round once; this roll-forward keeps
+    /// registered agents participating across the rolling 10-round window.
+    async fn schedule_active_for_round(&self, rid: u64) -> Result<(), String> {
+        let harnesses = self
+            .store
+            .list_active_harnesses(rid)
+            .await
+            .map_err(|e| e.to_string())?;
+        let epoch = chain::gather_schedule_state(self.chain.as_ref(), self.cfg.netuid)
+            .map(|s| chain::current_epoch_pre_run_coinbase(&s, s.current_block))
+            .unwrap_or(0);
+        for h in harnesses {
+            match schedule_harness_for_round(
+                self.store.as_ref(),
+                &h,
+                rid,
+                self.cfg.netuid,
+                epoch,
+            )
+            .await
+            {
+                Ok(ids) if !ids.is_empty() => {
+                    info!(
+                        harness_id = %h.id,
+                        miner = %h.miner_hotkey,
+                        round = rid,
+                        runs = ids.len(),
+                        "scheduled active harness for round"
+                    );
+                }
+                Ok(_) => {}
+                Err(e) => {
+                    // Quota / elimination are expected; do not abort the loop.
+                    warn!(
+                        harness_id = %h.id,
+                        miner = %h.miner_hotkey,
+                        round = rid,
+                        error = %e,
+                        "skip scheduling active harness"
+                    );
+                }
+            }
+        }
+        Ok(())
+    }
+
     /// Stuck sweeper.
     pub async fn run_sweeper(self: Arc<Self>) {
         loop {
@@ -705,7 +759,7 @@ impl<C: ChainClient + Send + Sync + 'static> Orchestrator<C> {
         // Sanitize reject is the miner's fault: terminal, no auto-retry.
         let sanitized = sanitize_bundle(&out.pages)
             .map_err(|e| RunFailure::new(ErrorClass::Miner, e.to_string()))?;
-        let pages: Vec<_> = sanitized
+        let mut pages: Vec<_> = sanitized
             .pages
             .iter()
             .map(|p| {
@@ -718,6 +772,29 @@ impl<C: ChainClient + Send + Sync + 'static> Orchestrator<C> {
                 )
             })
             .collect();
+        // Best-effort full-page screenshot of the styled index for the site UI
+        // (replaces iframe previews). Failure never fails the run.
+        if let Some(index) = sanitized.pages.iter().find(|p| p.path == "index.html") {
+            let shot_dir = self.cfg.staging_root.join("screenshots").join(&run.id);
+            if let Some(png) = capture_full_page_png(&index.sanitized_html, &shot_dir) {
+                let mut h = Sha256::new();
+                h.update(&png);
+                let sha = hex::encode(h.finalize());
+                let b64 = base64::engine::general_purpose::STANDARD.encode(&png);
+                let bytes = u32::try_from(png.len()).unwrap_or(u32::MAX);
+                pages.push((
+                    "index.png".into(),
+                    b64,
+                    String::new(),
+                    sha,
+                    bytes,
+                ));
+                info!(run_id = %run.id, bytes, "captured design page screenshot");
+            } else {
+                warn!(run_id = %run.id, "design page screenshot unavailable");
+            }
+            let _ = std::fs::remove_dir_all(&shot_dir);
+        }
         self.store
             .put_artifacts(&run.id, &pages)
             .await
@@ -726,7 +803,9 @@ impl<C: ChainClient + Send + Sync + 'static> Orchestrator<C> {
 
         // Pre-LLM copy gate: byte/AST copy of an *earlier* harness → terminal
         // `rejected` without spending the LLM review.
-        let gate_corpus = self.gate_corpus(&run.harness_id).await;
+        let gate_corpus = self
+            .gate_corpus(&run.harness_id, &harness.miner_hotkey)
+            .await;
         if let Some(hit) = copy_gate(&harness.agent_py, harness.created_at_ms, &gate_corpus) {
             warn!(
                 run_id = %run.id,
@@ -857,14 +936,21 @@ impl<C: ChainClient + Send + Sync + 'static> Orchestrator<C> {
         Ok(())
     }
 
-    /// Corpus for the pre-LLM copy gate (recent harnesses minus the candidate).
-    async fn gate_corpus(&self, exclude_harness_id: &str) -> Vec<GateCorpusEntry> {
+    /// Corpus for the pre-LLM copy gate (recent harnesses minus the candidate
+    /// and any prior revisions from the same miner hotkey).
+    async fn gate_corpus(
+        &self,
+        exclude_harness_id: &str,
+        exclude_miner_hotkey: &str,
+    ) -> Vec<GateCorpusEntry> {
+        let miner = exclude_miner_hotkey.to_ascii_lowercase();
         self.store
             .list_recent_harnesses(64)
             .await
             .unwrap_or_default()
             .into_iter()
             .filter(|h| h.id != exclude_harness_id)
+            .filter(|h| h.miner_hotkey.to_ascii_lowercase() != miner)
             .map(|h| GateCorpusEntry {
                 id: format!("harness:{}", h.id),
                 source: h.agent_py,
@@ -902,11 +988,11 @@ impl<C: ChainClient + Send + Sync + 'static> Orchestrator<C> {
             .list_recent_harnesses(64)
             .await
             .map_err(|e| RunFailure::new(ErrorClass::AstInfra, e.to_string()))?;
-        let cand_created = recent
-            .iter()
-            .find(|h| h.id == run.harness_id)
-            .map(|h| h.created_at_ms)
-            .unwrap_or(0);
+        let cand = recent.iter().find(|h| h.id == run.harness_id);
+        let cand_created = cand.map(|h| h.created_at_ms).unwrap_or(0);
+        let cand_miner = cand
+            .map(|h| h.miner_hotkey.to_ascii_lowercase())
+            .unwrap_or_default();
         let mut corpus: Vec<CorpusEntry> = vec![CorpusEntry {
             // The published baseline is always in the corpus (same as prism):
             // it anchors originality judgments and keeps an empty recent-set
@@ -919,6 +1005,10 @@ impl<C: ChainClient + Send + Sync + 'static> Orchestrator<C> {
             recent
                 .into_iter()
                 .filter(|h| h.id != run.harness_id)
+                // Same-hotkey revisions are self-improvement, not copying.
+                .filter(|h| {
+                    cand_miner.is_empty() || h.miner_hotkey.to_ascii_lowercase() != cand_miner
+                })
                 // Prior art only (created_at ordered like the pre-LLM gate): a
                 // later byte-copy must never poison the original's review.
                 .filter(|h| {

crates/design-challenge/src/orchestrator.rs

@@ -0,0 +1,83 @@
+//! Full-page screenshots of sanitized design pages for the public site.
+
+use std::path::Path;
+use std::process::Command;
+use std::time::{SystemTime, UNIX_EPOCH};
+
+use tracing::warn;
+
+/// Capture a full-page PNG of `html` (best-effort).
+///
+/// Prefers the Playwright CLI (`playwright screenshot --full-page`), then
+/// falls back to headless Chrome viewport capture. Returns `None` when no
+/// browser tool is available or capture fails — runs must not fail for this.
+pub fn capture_full_page_png(html: &str, work_dir: &Path) -> Option<Vec<u8>> {
+    let _ = std::fs::create_dir_all(work_dir);
+    let stamp = SystemTime::now()
+        .duration_since(UNIX_EPOCH)
+        .map(|d| d.as_millis())
+        .unwrap_or(0);
+    let html_path = work_dir.join(format!("shot-{stamp}.html"));
+    let png_path = work_dir.join(format!("shot-{stamp}.png"));
+    if std::fs::write(&html_path, html).is_err() {
+        return None;
+    }
+    let file_url = path_to_file_url(&html_path);
+    let ok = try_playwright(&file_url, &png_path) || try_chrome(&file_url, &png_path);
+    let _ = std::fs::remove_file(&html_path);
+    if !ok {
+        let _ = std::fs::remove_file(&png_path);
+        return None;
+    }
+    let bytes = std::fs::read(&png_path).ok();
+    let _ = std::fs::remove_file(&png_path);
+    match bytes {
+        Some(b) if !b.is_empty() && b.starts_with(b"\x89PNG") => Some(b),
+        Some(_) => {
+            warn!("screenshot tool wrote non-PNG output");
+            None
+        }
+        None => None,
+    }
+}
+
+fn path_to_file_url(path: &Path) -> String {
+    let abs = path.canonicalize().unwrap_or_else(|_| path.to_path_buf());
+    format!("file://{}", abs.display())
+}
+
+fn try_playwright(url: &str, out: &Path) -> bool {
+    let bin = std::env::var("DESIGN_PLAYWRIGHT_BIN").unwrap_or_else(|_| "playwright".into());
+    let status = Command::new(&bin)
+        .args(["screenshot", "--full-page", url])
+        .arg(out)
+        .status();
+    matches!(status, Ok(s) if s.success() && out.is_file())
+}
+
+fn try_chrome(url: &str, out: &Path) -> bool {
+    let candidates = [
+        std::env::var("DESIGN_CHROME_BIN").unwrap_or_default(),
+        "google-chrome".into(),
+        "google-chrome-stable".into(),
+        "chromium".into(),
+        "chromium-browser".into(),
+    ];
+    for bin in candidates.into_iter().filter(|b| !b.is_empty()) {
+        // Chrome `--screenshot` is viewport-sized; still better than no preview.
+        let status = Command::new(&bin)
+            .args([
+                "--headless=new",
+                "--disable-gpu",
+                "--hide-scrollbars",
+                "--window-size=1280,4000",
+                &format!("--screenshot={}", out.display()),
+                url,
+            ])
+            .status();
+        if matches!(status, Ok(s) if s.success() && out.is_file()) {
+            return true;
+        }
+    }
+    false
+}