Prism 2.1 Scoring

crates/challenge-agentic/src/prompts.rs

@@ -1,7 +1,7 @@
 //! System prompt for the agentic anti-cheat loop.
 
 /// Prompt version stamp (audit).
-pub const AGENTIC_PROMPT_VERSION: &str = "agentic_v4";
+pub const AGENTIC_PROMPT_VERSION: &str = "agentic_v5";
 
 /// Prism-specific anti-cheat rules (metrics / copy / hooks / non-causal leak).
 ///
@@ -16,6 +16,7 @@ pub const PRISM_DOMAIN_RULES: &str = r"Prism domain:
 - Causal LM: next-token CE must not see future/label tokens. Dense TokenMix/t_mix/Linear over time after transpose(1,2) WITHOUT triu/tril/is_causal/attn_mask = non_causal_label_leak.
 - Cheat if: near-identical AST/byte copy of a corpus architecture/touched surface (AST similarity_bps >= 9500; identical patch_sha256 / patch text); hardcoded METRICS_JSON; bpb impossible vs tokens_seen/wall_clock; recipe-v1 bpb < 1.0; eval peeking; network/exfil in the delta; eval-set leakage patterns in the delta; non_causal_label_leak as above.
 - NEVER treat standard modern LM components as plagiarism: RMSNorm, LayerNorm, RoPE/ALiBi, SwiGLU/GeGLU, gated residual, parallel residual, GQA/MQA, Pre-Norm/Post-Norm. Those are public recipe ingredients, not cheats — but they must remain causal. New models/ packages under AutoModel are allowed novelty.
+- Tokenizer is SUBMITTED, not imposed (tree `tokenizer/` files or a `build_tokenizer(ctx)` hook beside build_model). Bringing your own tokenizer is allowed and G1 already scores tokenizer-neutral bits/byte. Read metrics.json -> tokenizer.card (probe_tokens_per_byte, vocab_multiword_frac, vocab_max_token_bytes, probe_roundtrip_ok, flags) plus any build_tokenizer/vocab source in the delta. Cheat (tokenizer_gaming) when the tokenizer is engineered for the metric instead of language modeling: multi-word / answer-phrase single tokens (vocab_multiword_frac flag), vocab stuffed with eval-looking strings, decode() that rewrites or injects output text, or extreme compression built to shortcut token-denominated probes. A merely WEAK tokenizer (byte-level, small vocab, poor merges) is NOT a cheat — judge intent to game, not quality; card flags alone without corroborating source evidence → suspicious at most.
 - suspicious: only for strong unique structural overlap with a champion (AST >= 8500) or inconsistent metrics without a slam-dunk forge. Below AST 8500 with no other cheat signal → clean.
 - Quality/coherence of the model is NOT your job — only anti-cheat.";
 

crates/prism-artifacts/src/receive.rs

@@ -29,14 +29,14 @@ pub const CHECKPOINT_OVERHEAD_NUM: u64 = 3;
 /// Denominator of the 1.5× overhead factor (with [`CHECKPOINT_OVERHEAD_NUM`] → 3/2).
 pub const CHECKPOINT_OVERHEAD_DEN: u64 = 2;
 
-/// Recipe parameter cap (`prism_recipe::MAX_PARAMS` = 350M). Used as the
+/// Recipe parameter cap (`prism_recipe::MAX_PARAMS` = 1B). Used as the
 /// absolute HTTP body ceiling and as the harvest fallback when measured
 /// `n_params` is missing (older harness). Prefer measured `n_params`.
-pub const RECIPE_MAX_PARAMS: u64 = 350_000_000;
+pub const RECIPE_MAX_PARAMS: u64 = 1_000_000_000;
 
 /// Absolute max packed/upload bytes = [`RECIPE_MAX_PARAMS`] × FP32 × 2 × 1.5.
 /// Per-receive budgets are tighter when measured `n_params` is known.
-pub const MAX_CHECKPOINT_BYTES: usize = 4_200_000_000; // 350_000_000 * 12
+pub const MAX_CHECKPOINT_BYTES: usize = 12_000_000_000; // 1_000_000_000 * 12
 
 const _: () = assert!(RECIPE_MAX_PARAMS * 12 == MAX_CHECKPOINT_BYTES as u64);
 

crates/prism-automodel/src/intake.rs

@@ -24,6 +24,15 @@ pub const MEMBER_BASE: &str = "automodel.base";
 pub const MEMBER_PATCH: &str = "automodel.patch";
 /// Optional entry / recipe knobs.
 pub const MEMBER_TOML: &str = "prism.toml";
+/// Optional miner dependency manifest: pip `requirements.txt` installed on
+/// the pod (network-on install phase) before the netns-isolated train/eval.
+/// Delivered to the pod when the miner's patch adds it to the applied tree
+/// (it becomes a touched file, so slim delivery keeps it); the harness
+/// installs any manifest it finds in the tree (see `prismlib/deps.py`).
+pub const MEMBER_REQUIREMENTS: &str = "requirements.txt";
+/// Optional miner dependency manifest: `pyproject.toml` (PEP 621) installed
+/// with `pip install .` on the pod's install phase.
+pub const MEMBER_PYPROJECT: &str = "pyproject.toml";
 
 /// Persisted under the packed tree for `GET …/diff`.
 pub const META_BASE: &str = ".prism/automodel.base";
@@ -149,22 +158,16 @@ pub fn extract_automodel_zip(zip_bytes: &[u8]) -> Result<AutomodelMembers, Intak
         .map_err(|_| IntakeError::Invalid(format!("non-utf8: {MEMBER_BASE}")))?
         .trim()
         .to_owned();
-    if pin_id.is_empty() {
-        return Err(IntakeError::Invalid(format!("empty {MEMBER_BASE}")));
-    }
-    if pin_id.chars().any(char::is_whitespace) {
+    if pin_id.is_empty() || pin_id.chars().any(char::is_whitespace) {
         return Err(IntakeError::Invalid(format!(
-            "{MEMBER_BASE} must be a single-line pin id without whitespace"
+            "{MEMBER_BASE} must be a non-empty single-line pin id without whitespace"
         )));
     }
-    let prism_toml = match files.get(MEMBER_TOML) {
-        Some(b) => Some(
-            std::str::from_utf8(b)
-                .map_err(|_| IntakeError::Invalid(format!("non-utf8: {MEMBER_TOML}")))?
-                .to_owned(),
-        ),
-        None => None,
-    };
+    let prism_toml = files
+        .get(MEMBER_TOML)
+        .map(|b| std::str::from_utf8(b).map(str::to_owned))
+        .transpose()
+        .map_err(|_| IntakeError::Invalid(format!("non-utf8: {MEMBER_TOML}")))?;
     Ok(AutomodelMembers {
         pin_id,
         patch,
@@ -309,6 +312,8 @@ fn slim_delivery_files(mat: &MaterializedAutomodel) -> BTreeMap<String, Vec<u8>>
         META_DIFFSTAT,
         mat.entry.as_str(),
         MEMBER_TOML,
+        MEMBER_REQUIREMENTS,
+        MEMBER_PYPROJECT,
     ]
     .into_iter()
     .chain(mat.diffstat.files.iter().map(|entry| entry.path.as_str()))

crates/prism-automodel/src/lib.rs

@@ -39,8 +39,8 @@ pub use intake::{
     expand_tree_blob_for_pod, extract_automodel_zip, fixture_automodel_zip, intake_automodel_zip,
     materialize, pack_tree_blob, pin_checkout_dir, resolve_pin, submission_id_for_patch,
     zip_is_automodel_layout, AutomodelMembers, ExpandedAutomodel, IntakeError,
-    MaterializedAutomodel, ALLOW_LEGACY_ENV, MEMBER_BASE, MEMBER_PATCH, MEMBER_TOML, META_BASE,
-    META_DIFFSTAT, META_PATCH,
+    MaterializedAutomodel, ALLOW_LEGACY_ENV, MEMBER_BASE, MEMBER_PATCH, MEMBER_PYPROJECT,
+    MEMBER_REQUIREMENTS, MEMBER_TOML, META_BASE, META_DIFFSTAT, META_PATCH,
 };
 pub use pin::{
     fixture_happy_patch_path, fixture_pin_dir, tree_content_sha256, verify_pin_tree, AutomodelPin,

crates/prism-challenge/src/api.rs

@@ -15,7 +15,7 @@ use axum::routing::{get, post};
 use axum::{Json, Router};
 use serde::Deserialize;
 use serde_json::{json, Value};
-use submission_gating::{infra_resubmit_allowed, GatingState, GatingStore, MetagraphCache};
+use submission_gating::{resubmit_allowed, GatingState, GatingStore, MetagraphCache};
 
 use prism_recipe::{BASELINE_ARCHITECTURE_PY, BASELINE_TRAINING_PY};
 
@@ -158,7 +158,7 @@ async fn gate_one_max(
     if let Some(g) = &st.gating {
         match g.get(challenge, hotkey).await {
             Ok(Some(row))
-                if row.state != GatingState::Open && !infra_resubmit_allowed(&row, now_ms()) =>
+                if row.state != GatingState::Open && !resubmit_allowed(&row, now_ms()) =>
             {
                 return Err(json_err(
                     StatusCode::CONFLICT,
@@ -434,7 +434,7 @@ async fn post_retry(
                 .await
                 .ok()
                 .flatten()
-                .is_some_and(|gr| infra_resubmit_allowed(&gr, now_ms()));
+                .is_some_and(|gr| resubmit_allowed(&gr, now_ms()));
         }
     }
     if !infra {

crates/prism-challenge/src/orchestrator.rs

@@ -23,7 +23,7 @@ use prism_pipeline::{
 };
 use prism_recipe::{BASELINE_ARCHITECTURE_PY, BASELINE_TRAINING_PY};
 use prism_review::{ReviewBackend, SimilarityVerdict, SourceSnippet};
-use submission_gating::GatingStore;
+use submission_gating::{classify_eval_fail, GatingStore};
 use tokio::time::sleep;
 use tracing::{info, warn};
 
@@ -50,6 +50,11 @@ pub struct OrchestratorConfig {
     pub auto_retry_max: u32,
     pub scoring_mode: ScoringMode,
     pub orphan_grace_secs: u64,
+    /// GPUs rented per eval pod (`PRISM_POD_GPU_COUNT`, default 4).
+    ///
+    /// Miners may train across all of them; the eval battery stays pinned to
+    /// GPU 0 so G7 timings stay comparable across submissions.
+    pub pod_gpu_count: u32,
 }
 
 impl Default for OrchestratorConfig {
@@ -69,6 +74,7 @@ impl Default for OrchestratorConfig {
             auto_retry_max: 3,
             scoring_mode: ScoringMode::from_env(),
             orphan_grace_secs: DEFAULT_ORPHAN_GRACE_SECS,
+            pod_gpu_count: prism_lium::pod_gpu_count_from_env(),
         }
     }
 }
@@ -365,16 +371,16 @@ impl<C: ChainClient + Send> Orchestrator<C> {
     ) -> Result<(), String> {
         let msg = format!("measure: {err}");
         // Harness EVAL_FAIL is miner/model code, not Lium infra — do not burn
-        // auto-retries (BYOK seal is kept on Err; see finish_measure).
+        // auto-retries (BYOK seal is kept on Err; see finish_measure). The
+        // miner-fixable phases (`install_deps` custom-deps install,
+        // `train_script` training crash) additionally fail terminal under
+        // their own class, which grants unbounded resubmit. Every other
+        // EVAL_FAIL phase (eval / battery / score) stays the historical
+        // windowed `install` class. Non-EVAL_FAIL failures are Lium infra and
+        // keep `install` + operator-paid auto-retry.
         if msg.contains("EVAL_FAIL") {
-            fail_terminal(
-                self.store.as_ref(),
-                self.gating.as_ref(),
-                row,
-                "install",
-                &msg,
-            )
-            .await;
+            let class = classify_eval_fail(&msg);
+            fail_terminal(self.store.as_ref(), self.gating.as_ref(), row, class, &msg).await;
             return Ok(());
         }
         if self.maybe_auto_retry(row, "install", &msg).await {
@@ -707,7 +713,7 @@ impl<C: ChainClient + Send> Orchestrator<C> {
                 name: format!("prism-{}", &id[..12.min(id.len())]),
                 max_lifetime_hours: self.cfg.max_lifetime_hours,
                 max_price_per_hour: self.cfg.max_price_per_hour,
-                gpu_count: 1,
+                gpu_count: self.cfg.pod_gpu_count,
                 image_digest: self.cfg.image_digest.clone(),
                 ssh_public_keys: self.cfg.ssh_public_keys.clone(),
                 ssh_key_name: Some("prism-mission-worker".into()),

crates/prism-competition/Cargo.toml

@@ -0,0 +1,15 @@
+[package]
+name = "prism-competition"
+description = "PRISM emission competition math (WTA / top3 collapse, owner split)"
+version.workspace = true
+edition.workspace = true
+license.workspace = true
+repository.workspace = true
+rust-version.workspace = true
+publish = false
+
+[dependencies]
+prism-store = { path = "../prism-store" }
+
+[lints]
+workspace = true