style: rustfmt after miner digest pin and validator import order

Keep CI fmt gate green on base/dev and gbase.

Ultraworked with [Sisyphus](https://github.com/code-yeongyu/oh-my-openagent)

Co-authored-by: Sisyphus <clio-agent@sisyphuslabs.ai>

Author: cortex-qa

bins/agent-runner/src/main.rs

@@ -17,8 +17,8 @@ use std::time::Duration;
 
 use agent_runner::{
     app, clamp_concurrency, load_or_generate, load_required, receipt_sk_path_from_env,
-    AgentEgressPosture, DEFAULT_AGENT_EGRESS_POSTURE, DockerExecConfig, ExecutionBackend,
-    RunnerConfig, RunnerState, DEFAULT_DISPATCH_NONCE_TTL, DEFAULT_RECEIPT_SK_PATH,
+    AgentEgressPosture, DockerExecConfig, ExecutionBackend, RunnerConfig, RunnerState,
+    DEFAULT_AGENT_EGRESS_POSTURE, DEFAULT_DISPATCH_NONCE_TTL, DEFAULT_RECEIPT_SK_PATH,
     RECEIPT_SK_FILE_ENV,
 };
 use clap::Parser;
@@ -60,7 +60,11 @@ struct Cli {
     #[arg(long, env = "GBASE_PACK_ROOT")]
     pack_root: Option<PathBuf>,
     /// Staging root for agent binds.
-    #[arg(long, env = "GBASE_AGENT_WORK_ROOT", default_value = "/tmp/gbase-agent-work")]
+    #[arg(
+        long,
+        env = "GBASE_AGENT_WORK_ROOT",
+        default_value = "/tmp/gbase-agent-work"
+    )]
     work_root: PathBuf,
     /// Miner-supplied model API key file (mounted into agent; never logged).
     #[arg(long, env = "GBASE_MODEL_KEY_FILE")]

bins/gateway/src/main.rs

@@ -46,10 +46,11 @@ async fn main() -> ExitCode {
         }
         _ => {
             // fake_owner (default): owner hotkey == configured gateway hotkey.
-            let hotkeys = gateway::parse_fake_metagraph_hotkeys(&config.hotkey).unwrap_or_else(|e| {
-                tracing::warn!(error = %e, "bad GBASE_FAKE_METAGRAPH_HOTKEYS; owner-only");
-                vec![config.hotkey.to_vec()]
-            });
+            let hotkeys =
+                gateway::parse_fake_metagraph_hotkeys(&config.hotkey).unwrap_or_else(|e| {
+                    tracing::warn!(error = %e, "bad GBASE_FAKE_METAGRAPH_HOTKEYS; owner-only");
+                    vec![config.hotkey.to_vec()]
+                });
             let fc = FakeChainConfig {
                 netuid: config.netuid,
                 owner_hotkey: config.hotkey.to_vec(),

bins/validator/src/main.rs

@@ -182,14 +182,7 @@ fn trust_root_dir() -> PathBuf {
 fn build_runtime_trust(
     netuid: u16,
     rotation_epochs: u32,
-) -> Result<
-    (
-        AttestState,
-        LocalTrustRoot,
-        Arc<SyncChain<FakeChain>>,
-    ),
-    String,
-> {
+) -> Result<(AttestState, LocalTrustRoot, Arc<SyncChain<FakeChain>>), String> {
     let dir = trust_root_dir();
     if !dir.is_dir() {
         return Err(format!(

crates/agent-challenge/src/challenge.rs

@@ -171,7 +171,8 @@ impl AgentV1Challenge {
     }
 
     fn entry(body: &ChallengesBody) -> Result<&ChallengeEntry, ChallengeError> {
-        body.get(CHALLENGE_ID_BYTES).ok_or_else(|| ChallengeError::UnknownChallenge(CHALLENGE_ID.into()))
+        body.get(CHALLENGE_ID_BYTES)
+            .ok_or_else(|| ChallengeError::UnknownChallenge(CHALLENGE_ID.into()))
     }
     fn policy(body: &ChallengesBody) -> Result<&ParticipantPolicy, ChallengeError> {
         Ok(&Self::entry(body)?.policy)
@@ -231,14 +232,17 @@ impl Challenge for AgentV1Challenge {
         attest: &dyn AttestationLookup,
     ) -> Result<BTreeMap<Hotkey, ScoreOrAbsence>, ChallengeError> {
         let expected = self.expected_set(ctx)?;
-        Ok(expected.iter().map(|h| {
-            let call = calls.get(h).cloned().unwrap_or(MinerCallOutcome::Observed {
-                duration_ms: 0,
-                outcome: CallOutcome::ChallengeInternal,
-                expected_model_patch: Vec::new(),
-            });
-            (*h, self.score_one(ctx, *h, &call, attest))
-        }).collect())
+        Ok(expected
+            .iter()
+            .map(|h| {
+                let call = calls.get(h).cloned().unwrap_or(MinerCallOutcome::Observed {
+                    duration_ms: 0,
+                    outcome: CallOutcome::ChallengeInternal,
+                    expected_model_patch: Vec::new(),
+                });
+                (*h, self.score_one(ctx, *h, &call, attest))
+            })
+            .collect())
     }
 
     fn sign_leaf(
@@ -293,7 +297,9 @@ pub fn correct_http200_fixture(netuid: u16, epoch: u64, miner: &Hotkey) -> CallO
 /// Helper: `NoScore` reason for missing call coverage (D24).
 #[must_use]
 pub fn silence_is_bug_leaf() -> ScoreOrAbsence {
-    ScoreOrAbsence::NoScore { reason: NoScoreReasonCode::ChallengeInternal }
+    ScoreOrAbsence::NoScore {
+        reason: NoScoreReasonCode::ChallengeInternal,
+    }
 }
 
 /// Sign exactly one leaf per `h ∈ expected`. Refuses subset/superset (D24).
@@ -318,10 +324,14 @@ pub fn emit_signed_leaf_set(
     if !extra.is_empty() {
         return Err(LeafEmitError::UnknownHotkeys(extra.join(",")));
     }
-    scores.iter().map(|(h, s)| {
-        make_signed_leaf(secret, CHALLENGE_ID_BYTES, *h, epoch, s.clone())
-            .map(|l| (*h, l)).map_err(|e| LeafEmitError::Sign(e.to_string()))
-    }).collect()
+    scores
+        .iter()
+        .map(|(h, s)| {
+            make_signed_leaf(secret, CHALLENGE_ID_BYTES, *h, epoch, s.clone())
+                .map(|l| (*h, l))
+                .map_err(|e| LeafEmitError::Sign(e.to_string()))
+        })
+        .collect()
 }
 
 /// Cover `E` from operator-side verify results (Harbor grade).
@@ -335,7 +345,10 @@ pub fn score_epoch_from_verify(
     ctx: &EpochCtx,
     results: &BTreeMap<Hotkey, Result<Reward, VerifyError>>,
 ) -> Result<BTreeMap<Hotkey, ScoreOrAbsence>, ChallengeError> {
-    Ok(cover_expected_verify_leaves(&challenge.expected_set(ctx)?, results))
+    Ok(cover_expected_verify_leaves(
+        &challenge.expected_set(ctx)?,
+        results,
+    ))
 }
 
 /// Map one verify grade into a leaf (no retries).
@@ -490,9 +503,7 @@ mod tests {
                 }),
                 "hotkey must not be silent"
             );
-            let leaf = ch
-                .sign_leaf(&sk, h, 7, scores[&h].clone())
-                .expect("sign");
+            let leaf = ch.sign_leaf(&sk, h, 7, scores[&h].clone()).expect("sign");
             assert!(matches!(
                 leaf.score_or_absence,
                 ScoreOrAbsence::NoScore {

crates/agent-challenge/src/epoch_loop.rs

@@ -31,7 +31,10 @@ pub struct RunnerCapacity {
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub enum MinerEpochOutcome {
     /// Done before deadline.
-    Completed { pack_id: String, result: TaskResultV1 },
+    Completed {
+        pack_id: String,
+        result: TaskResultV1,
+    },
     /// Deadline hit.
     TimedOut { pack_id: String },
     /// Failed early.
@@ -120,21 +123,31 @@ impl ActiveSignerRegistry {
         epoch: u64,
     ) -> Result<SignerGuard, EpochLoopError> {
         let key = (challenge_id.to_owned(), epoch);
-        let mut g = self.held.lock().unwrap_or_else(std::sync::PoisonError::into_inner);
+        let mut g = self
+            .held
+            .lock()
+            .unwrap_or_else(std::sync::PoisonError::into_inner);
         if g.contains_key(&key) {
             return Err(EpochLoopError::SignerAlreadyActive {
                 challenge_id: challenge_id.to_owned(),
                 epoch,
             });
         }
         g.insert(key.clone(), ());
-        Ok(SignerGuard { reg: Arc::clone(self), key })
+        Ok(SignerGuard {
+            reg: Arc::clone(self),
+            key,
+        })
     }
 }
 
 impl Drop for SignerGuard {
     fn drop(&mut self) {
-        self.reg.held.lock().unwrap_or_else(std::sync::PoisonError::into_inner).remove(&self.key);
+        self.reg
+            .held
+            .lock()
+            .unwrap_or_else(std::sync::PoisonError::into_inner)
+            .remove(&self.key);
     }
 }
 
@@ -153,11 +166,14 @@ pub fn score_map_covering_expected(
     expected
         .iter()
         .map(|h| {
-            let soa = graded.get(h).cloned().unwrap_or_else(|| match outcomes.get(h) {
-                Some(MinerEpochOutcome::TimedOut { .. }) => ns(R::Timeout),
-                Some(MinerEpochOutcome::Failed { .. }) => ns(R::MinerError),
-                _ => ns(R::ChallengeInternal),
-            });
+            let soa = graded
+                .get(h)
+                .cloned()
+                .unwrap_or_else(|| match outcomes.get(h) {
+                    Some(MinerEpochOutcome::TimedOut { .. }) => ns(R::Timeout),
+                    Some(MinerEpochOutcome::Failed { .. }) => ns(R::MinerError),
+                    _ => ns(R::ChallengeInternal),
+                });
             (*h, soa)
         })
         .collect()

crates/agent-challenge/src/expected_set.rs

@@ -294,8 +294,7 @@ mod tests {
             "{tip_err}"
         );
 
-        let none_err =
-            expected_set_from_optional_pin(&policy, None, &chain).expect_err("none pin");
+        let none_err = expected_set_from_optional_pin(&policy, None, &chain).expect_err("none pin");
         assert_eq!(none_err, ExpectedSetError::BlockNotPinned);
 
         // Prove we did not fall through to tip: FakeChain tip metagraph would succeed if called.

crates/agent-challenge/src/leaf_map.rs

@@ -44,8 +44,11 @@ pub const MAX_VERIFY_ATTEMPTS: u32 = 1 + MAX_VERIFY_RETRIES;
 pub fn is_operator_fault(err: &VerifyError) -> bool {
     matches!(
         err,
-        VerifyError::Timeout { .. } | VerifyError::Docker(_) | VerifyError::MalformedOutput { .. }
-            | VerifyError::Staging { .. } | VerifyError::MissingHeldOut { .. }
+        VerifyError::Timeout { .. }
+            | VerifyError::Docker(_)
+            | VerifyError::MalformedOutput { .. }
+            | VerifyError::Staging { .. }
+            | VerifyError::MissingHeldOut { .. }
     )
 }
 
@@ -77,10 +80,13 @@ pub fn map_verify_error(err: &VerifyError) -> ScoreOrAbsence {
         VerifyError::ApplyFailed { .. } | VerifyError::RewardZero { .. } => {
             ScoreOrAbsence::Score { value: 0 }
         }
-        VerifyError::Timeout { .. } | VerifyError::Docker(_) | VerifyError::MalformedOutput { .. }
-        | VerifyError::Staging { .. } | VerifyError::MissingHeldOut { .. } => {
-            ScoreOrAbsence::NoScore { reason: NoScoreReasonCode::ChallengeInternal }
-        }
+        VerifyError::Timeout { .. }
+        | VerifyError::Docker(_)
+        | VerifyError::MalformedOutput { .. }
+        | VerifyError::Staging { .. }
+        | VerifyError::MissingHeldOut { .. } => ScoreOrAbsence::NoScore {
+            reason: NoScoreReasonCode::ChallengeInternal,
+        },
     }
 }
 
@@ -120,13 +126,18 @@ pub fn cover_expected_verify_leaves(
     expected: &BTreeSet<Hotkey>,
     results: &BTreeMap<Hotkey, Result<Reward, VerifyError>>,
 ) -> BTreeMap<Hotkey, ScoreOrAbsence> {
-    expected.iter().map(|h| {
-        let soa = results.get(h).map_or_else(
-            || ScoreOrAbsence::NoScore { reason: NoScoreReasonCode::ChallengeInternal },
-            score_from_verify_result,
-        );
-        (*h, soa)
-    }).collect()
+    expected
+        .iter()
+        .map(|h| {
+            let soa = results.get(h).map_or_else(
+                || ScoreOrAbsence::NoScore {
+                    reason: NoScoreReasonCode::ChallengeInternal,
+                },
+                score_from_verify_result,
+            );
+            (*h, soa)
+        })
+        .collect()
 }
 
 /// Cap attempts by remaining seal budget so retries cannot outrun the deadline.
@@ -178,12 +189,16 @@ fn grade_loop(
             Err(e) => {
                 let retry = is_retryable_operator_fault(&e) && attempts < allowed;
                 last_operator = Some(e);
-                if !retry { break; }
+                if !retry {
+                    break;
+                }
             }
         }
     }
     last_operator.as_ref().map_or_else(
-        || ScoreOrAbsence::NoScore { reason: NoScoreReasonCode::ChallengeInternal },
+        || ScoreOrAbsence::NoScore {
+            reason: NoScoreReasonCode::ChallengeInternal,
+        },
         map_verify_error,
     )
 }

crates/agent-challenge/src/lib.rs

@@ -8,31 +8,31 @@
 #![forbid(unsafe_code)]
 
 mod challenge;
+mod epoch_loop;
+mod expected_set;
+mod intake;
 mod keys;
+mod leaf_map;
 mod score;
 mod submit;
 mod task_gen;
-mod leaf_map;
 mod verify;
-mod expected_set;
-mod epoch_loop;
-mod intake;
 
 pub use challenge::{
     correct_http200, correct_http200_fixture, emit_signed_leaf_set, leaf_from_verify_result,
     score_epoch_from_verify, silence_is_bug_leaf, AgentV1Challenge, AttestationLookup, Challenge,
     ChallengeError, EpochCtx, Hotkey, LeafEmitError, MapAttestationLookup, MinerCallOutcome,
 };
-pub use expected_set::{
-    expected_set_at, expected_set_at_chain, expected_set_from_optional_pin,
-    expected_set_from_pinned_metagraph, hex32, BlockSource, ExpectedParticipant, ExpectedSet,
-    ExpectedSetError, PinnedBlockHash,
-};
 pub use epoch_loop::{
     run_epoch_dispatch, score_map_covering_expected, ActiveSignerRegistry, EpochDispatchClient,
     EpochDispatchConfig, EpochDispatchResult, EpochLoopError, MinerEpochOutcome, RunnerCapacity,
     SignerGuard, R1_DEADLINE_FRACTION_DEN, R1_DEADLINE_FRACTION_NUM, TESTNET_TEMPO_BLOCKS,
 };
+pub use expected_set::{
+    expected_set_at, expected_set_at_chain, expected_set_from_optional_pin,
+    expected_set_from_pinned_metagraph, hex32, BlockSource, ExpectedParticipant, ExpectedSet,
+    ExpectedSetError, PinnedBlockHash,
+};
 pub use intake::{
     intake_and_grade, verify_intake_receipt, ExpectedReceiptBind, IntakeOk, IntakePatch,
     ReceiptBindError,

crates/agent-challenge/src/score.rs

@@ -89,7 +89,9 @@ pub enum CallOutcome {
 pub fn score_from_outcome(input: &ScoreInputs) -> ScoreOrAbsence {
     use NoScoreReasonCode as R;
     if input.attestation != AttestationStatus::Verified {
-        return ScoreOrAbsence::NoScore { reason: R::AttestationNotVerified };
+        return ScoreOrAbsence::NoScore {
+            reason: R::AttestationNotVerified,
+        };
     }
     let _ = input.duration_ms; // v2: no latency decay
     let ns = |r| ScoreOrAbsence::NoScore { reason: r };
@@ -100,12 +102,24 @@ pub fn score_from_outcome(input: &ScoreInputs) -> ScoreOrAbsence {
         CallOutcome::RateLimited => ns(R::RateLimited),
         CallOutcome::ChallengeInternal => ns(R::ChallengeInternal),
         CallOutcome::Http200 {
-            challenge_id, epoch, task_id: tid, answer_digest: ans, agent_version,
+            challenge_id,
+            epoch,
+            task_id: tid,
+            answer_digest: ans,
+            agent_version,
         } => {
-            let exp_tid = task_id_v2(input.netuid, input.epoch, &input.miner_hotkey, &input.pack_id, SCORING_VERSION);
+            let exp_tid = task_id_v2(
+                input.netuid,
+                input.epoch,
+                &input.miner_hotkey,
+                &input.pack_id,
+                SCORING_VERSION,
+            );
             let exp_ans = answer_digest_v2(&input.expected_model_patch);
-            if challenge_id != CHALLENGE_ID || *epoch != input.epoch
-                || tid.as_slice() != exp_tid.as_slice() || agent_version != "1"
+            if challenge_id != CHALLENGE_ID
+                || *epoch != input.epoch
+                || tid.as_slice() != exp_tid.as_slice()
+                || agent_version != "1"
             {
                 return ns(R::InvalidResponse);
             }

crates/agent-challenge/src/task_gen.rs

@@ -236,7 +236,10 @@ mod tests {
         let m = miner11();
         let v1 = task_id(FIX_NETUID, FIX_EPOCH, &m);
         let v2 = task_id_v2(FIX_NETUID, FIX_EPOCH, &m, FIX_PACK, SCORING_VERSION_V2);
-        assert_ne!(v1, v2, "v1 golden must not equal v2 for same netuid/epoch/hotkey");
+        assert_ne!(
+            v1, v2,
+            "v1 golden must not equal v2 for same netuid/epoch/hotkey"
+        );
     }
 
     #[test]