fix(swap): stage discovery against registered contracts, unbreak override seam

Pre-push went red three ways at HEAD; this restores every gate.

Behavior fixes (each pinned by an existing-but-RED test):

1. Tracked-pool CL sim beyond full-range liquidity: the staged
   discovery walk (swap_missing_words) built its transient with
   Sparse coverage unconditionally, so an empty-range word crossing
   fabricated missing words a Tracked pool never misses; with no
   stored fetcher the staged pass failed and the seam returned None
   (LiquidityPoolError on the V4 ETH/USDC golden parity test at
   amount 1e30, boundary 654751007996983783903/904 wei). The
   discovery transients now mirror the REGISTERED pool's coverage
   AND its checked-word set (T1 3WTDFK: a caller-checked empty word
   is never a fetch target), factored into v3/v4_discovery_transient
   helpers. Fixes test_uniswap_v4_onchain_parity +
   test_sparse_checked_zero_word_prevents_refetch.
2. Override seam: sim_override_inner aborted on a None stored
   fetcher BEFORE inspecting the missing-word list, so any pool
   without a fetcher could never sim an override at all. A complete
   hypothetical now sims; an absent fetcher only aborts when the
   walk found real misses (same shape as the disarmed
   FetchExhausted arm). Fixes test_calculate_tokens_out_with_override.
3. clippy --deny warnings: ~40 violations left by the RATR5A/CXRHW3
   refactor (stale #[expect]s, doc-markdown backticks, clone-on-Copy,
   missing # Errors/must_use) plus a file-level ![allow(dead_code)]
   in cpu_budget.rs tripping the inner-allow guard.

Verified: just pre-push green end to end - clippy --deny warnings,
2574 pytest passed / 20 skipped (incl. golden V4 quoter parity and
the checked-word FFI invariants).

Author: BowTiedDevil

rust/crates/degenbot-bot/src/bot_core/cl_orchestration.rs

@@ -52,6 +52,10 @@ impl StagedWordFetch {
     /// re-enters Python (`Python::attach` + the companion's web3 RPC), so
     /// this call is the multi-second window the fetch-under-write defect
     /// parked the whole pump inside (RATR5A).
+    ///
+    /// # Errors
+    /// Propagates the stored fetcher's [`FetchTickWordError`] (RPC/transport
+    /// or tick-word decode); the caller owns retry semantics, nothing panics.
     pub fn fetch(
         &self,
     ) -> Result<
@@ -1096,7 +1100,7 @@ impl BotState {
 
     /// RATR5A stage half of the word backfill: clone the stored fetcher +
     /// capture the pool's tick fingerprint UNDER a short write, and release
-    /// the caller's guard before the (multi-second, Python::attach + web3
+    /// the caller's guard before the (multi-second, `Python::attach` + web3
     /// RPC) fetch runs. The old single-hold path fetched while the write
     /// guard was alive, parking the pump’s apply/solve pipeline behind the
     /// RPC. Pair with [`Self::install_word_fetch`].

rust/crates/degenbot-bot/src/bot_core/cpu_budget.rs

@@ -16,8 +16,6 @@
 //! Python, the pump, and the `OTel` exporter share the quota and must not
 //! starve during bursts), overridable with `DEGENBOT_SOLVE_CPUS`.
 
-#![allow(dead_code)] // v1 helpers are exercised by tests; some hosts never hit them
-
 use std::path::{Path, PathBuf};
 use std::sync::OnceLock;
 

rust/crates/degenbot-bot/src/bot_core/mod.rs

@@ -5214,7 +5214,7 @@ mod tests {
     // --- T2 (FBJTUM): write-path sparse backfill — ensure_word_known ---
 
     #[test]
-    #[expect(clippy::expect_used, clippy::indexing_slicing)]
+    #[expect(clippy::expect_used, clippy::too_many_lines)]
     fn staged_word_fetch_install_races_on_interleaved_pool_write() {
         use crate::bot_core::InstallWordOutcome;
         use ::degenbot_pools::tick_fetch::{FetchedTickWord, TickWordFetcher};

rust/crates/degenbot-bot/src/bot_core/sim_anchor.rs

@@ -109,21 +109,29 @@ mod tests {
         anchor
             .anchor_words
             .get(key)
-            .map(|p| (p.kind.clone(), p.engine_word.into(), p.update_block))
+            .map(|p| (p.kind, p.engine_word.into(), p.update_block))
     }
 
     const V4_TEST_PM: Address = Address::new([0x44; 20]);
 
+    #[expect(clippy::cast_possible_truncation)] // fixture: i < 2 pools
     fn v3_addr(i: usize) -> Address {
         let mut a = [0x33u8; 20];
         a[0] = (i as u8) + 1;
         Address::new(a)
     }
 
+    #[expect(clippy::cast_possible_truncation)] // fixture: i, j < 2 pools
     fn v4_id(i: usize) -> [u8; 32] {
         std::array::from_fn(|j| (i as u8).wrapping_add(j as u8))
     }
 
+    #[expect(
+        clippy::expect_used,
+        clippy::unwrap_used,
+        clippy::cast_possible_truncation,
+        clippy::cast_possible_wrap
+    )]
     fn heavy_state(v3_pools: usize, v3_ticks: usize, v4_pools: usize) -> BotState {
         let mut core = BotState::new();
         core.register_v2_pool(&crate::bot_core::RegisterV2PoolParams {
@@ -200,7 +208,7 @@ mod tests {
     }
 
     #[test]
-    #[expect(clippy::expect_used, clippy::too_many_lines)]
+    #[expect(clippy::unwrap_used, clippy::panic, clippy::type_complexity)]
     fn snapshot_parity_with_query_semantics() {
         // Fixture: one pool of each family (Aerodrome/Curve/Balancer families
         // contribute no anchor words by probe semantics — pass-through None).
@@ -219,10 +227,7 @@ mod tests {
             (V4_TEST_PM, s_state.checked_add(U256::from(3u64)).unwrap()),
         ] {
             if let Some(p) = core.probe_tracked_storage_slot(addr, idx) {
-                expected.push((
-                    (addr, idx),
-                    (p.kind.clone(), p.engine_word.into(), p.update_block),
-                ));
+                expected.push(((addr, idx), (p.kind, p.engine_word.into(), p.update_block)));
             }
         }
         assert!(
@@ -264,7 +269,6 @@ mod tests {
     }
 
     #[test]
-    #[expect(clippy::too_many_lines)]
     fn snapshot_is_enumerated_not_a_scan() {
         // The ADR-039 perf gate: the projection enumerates per-family scalars
         // and NEVER iterates tick maps (V3 arbitrary-index fallthrough) or the

rust/crates/degenbot-bot/src/bot_core/swap_simulation.rs

@@ -34,10 +34,12 @@ use ::degenbot_pools::registry::PoolEntry;
 use ::degenbot_pools::simulate_swap::simulate_swap;
 use ::degenbot_pools::tick_fetch::{FetchedTickWord, TickWordFetcher};
 use ::degenbot_pools::v3_state::{
-    v3_simulate_swap, PoolTickCoverage, RegisterV3PoolParams, SimulateSwapError, V3PoolState,
-    V3SwapOutcome,
+    v3_simulate_swap, PoolTickCoverage, RegisterV3PoolParams, SimulateSwapError, V3PoolIdentity,
+    V3PoolState, V3SwapOutcome,
+};
+use ::degenbot_pools::v4_state::{
+    v4_simulate_swap, RegisterV4PoolParams, V4PoolIdentity, V4PoolState,
 };
-use ::degenbot_pools::v4_state::{v4_simulate_swap, RegisterV4PoolParams, V4PoolState};
 
 use super::BotState;
 
@@ -394,7 +396,7 @@ struct OverrideSim<'a> {
     fetcher: Option<Arc<dyn TickWordFetcher>>,
     pool_id: u64,
     /// RATR5A/CXRHW3: miss recovery DISARMED - a fresh missing word
-    /// surfaces as FetchExhausted (typed contract) instead of an inline
+    /// surfaces as `FetchExhausted` (typed contract) instead of an inline
     /// fetch under the caller read guard.
     disarm_fetch: bool,
 }
@@ -583,33 +585,7 @@ impl BotState {
             | PoolEntry::AerodromeV2(..) => Some(Vec::new()),
             PoolEntry::V3(identity, st) => {
                 let mut missing = Vec::new();
-                let mut transient = TransientCl {
-                    family: TransientFamily::V3(identity.fee, identity.tick_spacing),
-                    inner: TransientInner::V3(Box::new(
-                        V3PoolState::from_params(
-                            RegisterV3PoolParams {
-                                address: identity.address,
-                                token0: identity.token0,
-                                token1: identity.token1,
-                                fee: identity.fee,
-                                tick_spacing: identity.tick_spacing,
-                                factory: identity.factory,
-                                deployer: identity.deployer,
-                                init_hash: identity.init_hash,
-                                sqrt_price_x96: st.sqrt_price_x96,
-                                liquidity: st.liquidity,
-                                tick: st.tick,
-                                tick_data: st.tick_data.clone(),
-                                update_block: st.update_block,
-                                coverage: PoolTickCoverage::Sparse,
-                                fetcher: None,
-                                ..Default::default()
-                            },
-                            self.journal_depth,
-                        )
-                        .1,
-                    )),
-                };
+                let mut transient = self.v3_discovery_transient(identity, st);
                 let spec =
                     engine_amount_specified(request.amount_specified, EngineFamily::V3Engine);
                 let limit = request
@@ -626,33 +602,7 @@ impl BotState {
             }
             PoolEntry::V4(identity, st) => {
                 let mut missing = Vec::new();
-                let mut transient = TransientCl {
-                    family: TransientFamily::V4(
-                        identity.pool_key.fee,
-                        identity.pool_key.tick_spacing,
-                    ),
-                    inner: TransientInner::V4(Box::new(
-                        V4PoolState::from_params(
-                            RegisterV4PoolParams {
-                                pool_manager: identity.pool_manager,
-                                pool_id: identity.pool_id,
-                                pool_key: identity.pool_key.clone(),
-                                hook_flags: 0,
-                                protocol_fee: 0,
-                                sqrt_price_x96: st.sqrt_price_x96,
-                                liquidity: st.liquidity,
-                                tick: st.tick,
-                                tick_data: st.tick_data.clone(),
-                                update_block: st.update_block,
-                                tick_data_block: None,
-                                coverage: PoolTickCoverage::Sparse,
-                                fetcher: None,
-                            },
-                            self.journal_depth,
-                        )
-                        .1,
-                    )),
-                };
+                let mut transient = self.v4_discovery_transient(identity, st);
                 let spec =
                     engine_amount_specified(request.amount_specified, EngineFamily::V4Engine);
                 let limit = request
@@ -671,6 +621,75 @@ impl BotState {
         }
     }
 
+    /// Build the V3 discovery transient for a registered pool: it mirrors
+    /// the REGISTERED pool's coverage (a Tracked pool never raises
+    /// `MissingTickWord`, so the staging walk must not invent fetch work
+    /// for one) AND its checked-word set (T1 3WTDFK: `from_params` seeds
+    /// known words from tick ROWS only — a caller-CHECKED empty word has no
+    /// rows yet must never become a fetch target).
+    fn v3_discovery_transient(&self, identity: &V3PoolIdentity, st: &V3PoolState) -> TransientCl {
+        let mut v3_transient = V3PoolState::from_params(
+            RegisterV3PoolParams {
+                address: identity.address,
+                token0: identity.token0,
+                token1: identity.token1,
+                fee: identity.fee,
+                tick_spacing: identity.tick_spacing,
+                factory: identity.factory,
+                deployer: identity.deployer,
+                init_hash: identity.init_hash,
+                sqrt_price_x96: st.sqrt_price_x96,
+                liquidity: st.liquidity,
+                tick: st.tick,
+                tick_data: st.tick_data.clone(),
+                update_block: st.update_block,
+                coverage: st.coverage,
+                fetcher: None,
+                ..Default::default()
+            },
+            self.journal_depth,
+        )
+        .1;
+        v3_transient
+            .known_bitmap_words
+            .extend(st.known_bitmap_words.iter().copied());
+        TransientCl {
+            family: TransientFamily::V3(identity.fee, identity.tick_spacing),
+            inner: TransientInner::V3(Box::new(v3_transient)),
+        }
+    }
+
+    /// V4 twin of [`Self::v3_discovery_transient`] — the same coverage +
+    /// checked-word mirroring discipline (see that doc).
+    fn v4_discovery_transient(&self, identity: &V4PoolIdentity, st: &V4PoolState) -> TransientCl {
+        let mut v4_transient = V4PoolState::from_params(
+            RegisterV4PoolParams {
+                pool_manager: identity.pool_manager,
+                pool_id: identity.pool_id,
+                pool_key: identity.pool_key.clone(),
+                hook_flags: 0,
+                protocol_fee: 0,
+                sqrt_price_x96: st.sqrt_price_x96,
+                liquidity: st.liquidity,
+                tick: st.tick,
+                tick_data: st.tick_data.clone(),
+                update_block: st.update_block,
+                tick_data_block: None,
+                coverage: st.coverage,
+                fetcher: None,
+            },
+            self.journal_depth,
+        )
+        .1;
+        v4_transient
+            .known_bitmap_words
+            .extend(st.known_bitmap_words.iter().copied());
+        TransientCl {
+            family: TransientFamily::V4(identity.pool_key.fee, identity.pool_key.tick_spacing),
+            inner: TransientInner::V4(Box::new(v4_transient)),
+        }
+    }
+
     /// The stored word fetcher for a registered pool, if any — the staged
     /// pre-pass fetches through it OUTSIDE any state lock.
     #[must_use]
@@ -731,7 +750,7 @@ impl BotState {
     /// RATR5A/CXRHW3: the override sim with miss recovery DISARMED - a
     /// missing word surfaces as None (the legacy Option contract) instead of
     /// an inline fetch under the caller read guard. The pooled caller
-    /// pre-stages through [Self::override_missing_words] + the lock-free
+    /// pre-stages through [`Self::override_missing_words`] + the lock-free
     /// fetch choreography before entering.
     pub fn simulate_override_disarmed(
         &self,
@@ -745,7 +764,7 @@ impl BotState {
     /// listed by a collect-only walk over a transient built from the
     /// override scalars + the caller tick data (no fetch, no registered
     /// mutation). Pair with the lock-free fetch choreography in pool.rs
-    /// (ensure_override_missing_staged).
+    /// (`ensure_override_missing_staged`).
     #[must_use]
     pub fn override_missing_words(&self, over: &OverrideSwap) -> Option<Vec<i32>> {
         if over.request.amount_specified.is_zero() {
@@ -843,6 +862,7 @@ impl BotState {
         }
     }
 
+    #[must_use]
     pub fn simulate_override(&self, over: &OverrideSwap, block: u64) -> Option<V3SwapOutcome> {
         self.simulate_override_ext(over, block, false)
     }
@@ -960,17 +980,13 @@ impl BotState {
     ///
     /// `block` is the fetch context threaded into the tick-word fetcher on
     /// sparse-miss recovery; it does not affect pure computation.
-    // TODO(X4EU3J follow-up): extract the per-family arms once the hook
-    // caveat plumbing settles; the body is 101 lines against a 100-line
-    // clippy::too_many_lines budget.
-    #[expect(clippy::too_many_lines)]
     pub fn swap_simulation(&mut self, block: u64, pool_id: u64, request: SwapRequest) -> SwapRead {
         self.swap_simulation_ext(block, pool_id, &request, false)
     }
 
     /// RATR5A/CXRHW3: the swap with miss recovery DISARMED — a residual
     /// missing word after the staged pre-pass surfaces as the typed
-    /// FetchExhausted contract (additive, ADR-037) instead of fetching under
+    /// `FetchExhausted` contract (additive, ADR-037) instead of fetching under
     /// the caller write guard. Identical arithmetic otherwise (the caller
     /// must have staged the missing words via the lock-free pre-pass).
     pub fn swap_simulation_disarmed(
@@ -982,6 +998,10 @@ impl BotState {
         self.swap_simulation_ext(block, pool_id, request, true)
     }
 
+    // TODO(X4EU3J follow-up): extract the per-family arms once the hook
+    // caveat plumbing settles; the body is 114 lines against a 100-line
+    // clippy::too_many_lines budget.
+    #[expect(clippy::too_many_lines)]
     fn swap_simulation_ext(
         &mut self,
         block: u64,
@@ -1078,7 +1098,7 @@ impl BotState {
                     block,
                     SwapOutcomeFamily::V3,
                     coverage,
-                    request.clone(),
+                    *request,
                     Caveats::default(),
                 )
             }
@@ -1108,7 +1128,7 @@ impl BotState {
                     block,
                     SwapOutcomeFamily::V4,
                     coverage,
-                    request.clone(),
+                    *request,
                     extra_caveats,
                 )
             }
@@ -1148,7 +1168,12 @@ fn finish_cl(
 
 #[cfg(test)]
 mod tests {
-    #![expect(clippy::panic, clippy::unwrap_used, clippy::used_underscore_binding)]
+    #![expect(
+        clippy::panic,
+        clippy::unwrap_used,
+        clippy::expect_used,
+        clippy::used_underscore_binding
+    )]
 
     use super::*;
     use hashbrown::HashMap;
@@ -1160,7 +1185,6 @@ mod tests {
 
     /// Registered sparse pool whose stored fetcher counts every call.
     fn counting_fetcher_setup(calls: Arc<AtomicUsize>) -> (BotState, u64) {
-        let mut core = BotState::new();
         #[derive(Debug)]
         struct CountingFetcher(Arc<AtomicUsize>);
         impl ::degenbot_pools::tick_fetch::TickWordFetcher for CountingFetcher {
@@ -1180,6 +1204,7 @@ mod tests {
                 })
             }
         }
+        let mut core = BotState::new();
         let pool_id = core
             .register_v3_pool(&RegisterV3PoolParams {
                 address: alloy::primitives::Address::ZERO,

rust/crates/degenbot-bot/src/instruments.rs

@@ -150,7 +150,7 @@ pub struct PipelineInstruments {
     /// the registry, and a container OOM-kill presents as an overnight
     /// availability failure, not a solver symptom).
     ///
-    /// PROMETHEUS NAME COUPLING (pair-review flag, 2026-09-04): the OTel
+    /// PROMETHEUS NAME COUPLING (pair-review flag, 2026-09-04): the `OTel`
     /// name-mapping renders this gauge (dots->underscores + `By` unit
     /// suffix) as `degenbot_process_rss_bytes`, and the Grafana panel
     /// "Process RSS - registry drift watch" queries that string verbatim —
@@ -688,7 +688,7 @@ impl PipelineInstruments {
 
 /// Read the process resident set size in bytes from `/proc/self/statm`
 /// (second field: resident pages; page size classically 4096 — the runs
-/// this gauges are Linux x86_64). `None` when statm is unavailable or
+/// this gauges are Linux `x86_64`). `None` when statm is unavailable or
 /// unexpected (Windows/CI sandboxes) — callers must no-op on None.
 #[must_use]
 pub(crate) fn read_process_rss_bytes() -> Option<u64> {
@@ -709,6 +709,7 @@ mod tests {
     use super::parse_statm_resident;
 
     #[test]
+    #[expect(clippy::expect_used)]
     fn statm_parser_reads_resident_pages() {
         // /proc/self/statm: size resident shared text lib data dt (pages)
         let rss = parse_statm_resident("54321 21000 1234 100 0 7000 0", 4096)