feat: expose experimental TWAP and lean settings with signer conflict detection

- Add TWAP window and max-deviation fields to experimental settings card, with same validation as bot startup
- Add inventory-lean settings (enabled, shadow mode, floor/base/wide bps) to experimental section
- Implement `/api/signer/check` endpoint to detect when a wallet is already in use by another fleet bot
- Surface which sibling bots would conflict with a signer change, and whether they're live-transacting (blocks switch)
- Sort fleet list alphabetically by bot name in both HTTP and discovery layers
- Align bot detail action buttons on mobile with 2-column grid for lifecycle actions, full-width Remove
- Refactor settings patch application to preserve untouched experimental fields when spreads-only changes occur
- Improve error messages for failed settings writes by exposing full validation chain
- Add tests for fleet alphabetization, experimental field round-trips, and signer conflict detection

Author: bnolens

.textile-monorepo-source

@@ -1 +1 @@
-e1a1f43c78c7c42fa16002408fedc3f69096b442
+02fbe15ff9105ecaddf1999485d69be64e384dfd

.textile-stitch-release-version

@@ -1 +1 @@
-0.1.112
+0.1.113

Cargo.lock

@@ -1,6 +1,6 @@
 [package]
 name = "stitch-bot"
-version = "0.1.112"
+version = "0.1.113"
 edition = "2021"
 description = "Stitch — Textile filler-network operator bot; market-makes the filler order book with signed UniswapX limit orders."
 license = "AGPL-3.0-or-later"

Cargo.toml

@@ -142,12 +142,16 @@ struct FleetBody {
 
 pub async fn list(State(state): State<AppState>) -> Result<Response, ApiError> {
     let fleet = state.fleet().await?;
+    // Discovery already yields name order (BTreeMap), but sort here too so the
+    // fleet page stays alphabetical even if that ever changes.
+    let mut bots: Vec<BotBody> = fleet
+        .bots()
+        .iter()
+        .map(|b| to_body(b, &state, &fleet))
+        .collect();
+    bots.sort_by(|a, b| a.name.cmp(&b.name));
     Ok(Json(FleetBody {
-        bots: fleet
-            .bots()
-            .iter()
-            .map(|b| to_body(b, &state, &fleet))
-            .collect(),
+        bots,
         bot_image: state.cfg.bot_image.clone(),
         bots_dir: state.cfg.bots_dir.display().to_string(),
     })
@@ -1207,6 +1211,24 @@ mod tests {
         assert!(v["botImage"].as_str().unwrap().contains("textile-stitch"));
     }
 
+    #[tokio::test]
+    async fn the_fleet_list_is_alphabetical_by_bot_name() {
+        let h = harness("fleet-alpha");
+        write_bot(&h.root, "zeta");
+        write_bot(&h.root, "alpha");
+        write_bot(&h.root, "mid");
+        let (status, body) = h.get("/api/bots").await;
+        assert_eq!(status, StatusCode::OK, "{body}");
+        let parsed = Harness::parse(&body);
+        let names: Vec<_> = parsed["bots"]
+            .as_array()
+            .unwrap()
+            .iter()
+            .map(|b| b["name"].as_str().unwrap())
+            .collect();
+        assert_eq!(names, vec!["alpha", "mid", "zeta"]);
+    }
+
     #[tokio::test]
     async fn a_panel_bot_is_listed_with_its_config_and_no_secrets() {
         let h = harness("list");

src/panel/http/bots.rs

@@ -253,6 +253,7 @@ fn public_routes() -> Router<AppState> {
 fn protected_routes(state: &AppState) -> Router<AppState> {
     Router::new()
         .route("/api/corridors", get(wizard::corridors))
+        .route("/api/signer/check", post(wizard::check_signer))
         .route("/api/bots", get(bots::list).post(wizard::create))
         .route("/api/bots/{name}", get(bots::show).delete(bots::remove))
         .route("/api/bots/{name}/start", post(bots::start))

src/panel/http/mod.rs

@@ -136,6 +136,15 @@ pub struct SettingsBody {
     pub sell_sizing: SizingBody,
     pub ttl_secs: u64,
     pub tick_interval_secs: u64,
+    /// Rolling TWAP window in seconds. Empty = quote off the instantaneous feed.
+    pub twap_window_secs: String,
+    /// Spot-deviation guard in bps. Empty = bot default when TWAP is on.
+    pub twap_max_deviation_bps: String,
+    pub lean_enabled: bool,
+    pub lean_shadow: bool,
+    pub lean_floor_bps: String,
+    pub lean_base_bps: String,
+    pub lean_wide_bps: String,
     /// Whether saving will be accepted. False for a bot whose config the panel can
     /// see but not write.
     pub editable: bool,
@@ -156,6 +165,13 @@ impl SettingsBody {
             sell_sizing: SizingBody::from(&v.sell_sizing),
             ttl_secs: v.ttl_secs,
             tick_interval_secs: v.tick_interval_secs,
+            twap_window_secs: v.twap_window_secs.clone(),
+            twap_max_deviation_bps: v.twap_max_deviation_bps.clone(),
+            lean_enabled: v.lean_enabled,
+            lean_shadow: v.lean_shadow,
+            lean_floor_bps: v.lean_floor_bps.clone(),
+            lean_base_bps: v.lean_base_bps.clone(),
+            lean_wide_bps: v.lean_wide_bps.clone(),
             editable,
         }
     }
@@ -261,6 +277,20 @@ pub struct SettingsUpdate {
     pub ttl_secs: Option<u64>,
     #[serde(default)]
     pub tick_interval_secs: Option<u64>,
+    #[serde(default)]
+    pub twap_window_secs: Option<String>,
+    #[serde(default)]
+    pub twap_max_deviation_bps: Option<String>,
+    #[serde(default)]
+    pub lean_enabled: Option<bool>,
+    #[serde(default)]
+    pub lean_shadow: Option<bool>,
+    #[serde(default)]
+    pub lean_floor_bps: Option<String>,
+    #[serde(default)]
+    pub lean_base_bps: Option<String>,
+    #[serde(default)]
+    pub lean_wide_bps: Option<String>,
 }
 
 impl SettingsUpdate {
@@ -297,6 +327,38 @@ impl SettingsUpdate {
         if let Some(v) = self.tick_interval_secs {
             patch.tick_interval_secs = Some(v);
         }
+        // A partial UI patch must leave untouched experimental fields alone —
+        // otherwise a spread-only save would rewrite them from a stale form.
+        // So start from a "don't touch" patch for those and only fold in what
+        // the request named.
+        patch.twap_window_secs = None;
+        patch.twap_max_deviation_bps = None;
+        patch.lean_enabled = None;
+        patch.lean_shadow = None;
+        patch.lean_floor_bps = None;
+        patch.lean_base_bps = None;
+        patch.lean_wide_bps = None;
+        if let Some(v) = &self.twap_window_secs {
+            patch.twap_window_secs = Some(v.trim().to_string());
+        }
+        if let Some(v) = &self.twap_max_deviation_bps {
+            patch.twap_max_deviation_bps = Some(v.trim().to_string());
+        }
+        if let Some(v) = self.lean_enabled {
+            patch.lean_enabled = Some(v);
+        }
+        if let Some(v) = self.lean_shadow {
+            patch.lean_shadow = Some(v);
+        }
+        if let Some(v) = &self.lean_floor_bps {
+            patch.lean_floor_bps = Some(v.trim().to_string());
+        }
+        if let Some(v) = &self.lean_base_bps {
+            patch.lean_base_bps = Some(v.trim().to_string());
+        }
+        if let Some(v) = &self.lean_wide_bps {
+            patch.lean_wide_bps = Some(v.trim().to_string());
+        }
         Ok(patch)
     }
 }
@@ -322,8 +384,10 @@ pub async fn update(
     let current = setup::read_settings_at(&current_toml, pool).map_err(ApiError::bad_request)?;
     let patch = body.onto(&current)?;
     // `apply_settings` re-validates through the real loader, so an invalid value
-    // fails here and nothing is written.
-    let edited = setup::apply_settings(&current_toml, &patch).map_err(ApiError::bad_request)?;
+    // fails here and nothing is written. Use the full anyhow chain — the outer
+    // "edited config is not valid" alone doesn't name the field that failed.
+    let edited = setup::apply_settings(&current_toml, &patch)
+        .map_err(|e| ApiError::bad_request(format!("{e:#}")))?;
 
     save_and_restart(&state, &bot, &path, &edited, pool).await
 }
@@ -930,6 +994,40 @@ mod tests {
         assert_eq!(v["settings"]["sell"], before["sell"]);
         assert_eq!(v["settings"]["ttlSecs"], before["ttlSecs"]);
         assert_eq!(v["settings"]["buySizing"], before["buySizing"]);
+        assert_eq!(v["settings"]["twapWindowSecs"], before["twapWindowSecs"]);
+    }
+
+    #[tokio::test]
+    async fn experimental_twap_and_lean_round_trip_through_settings() {
+        let h = harness("settings-experimental");
+        seed(&h, "bot-a");
+        let (status, body) = h
+            .patch_json(
+                "/api/bots/bot-a/settings",
+                json!({
+                    "twapWindowSecs": "60",
+                    "twapMaxDeviationBps": "50",
+                    "leanShadow": true,
+                    "leanFloorBps": "3.0",
+                }),
+            )
+            .await;
+        assert_eq!(status, StatusCode::OK, "first patch: {body}");
+        let v = Harness::parse(&body);
+        assert_eq!(v["settings"]["twapWindowSecs"], "60");
+        assert_eq!(v["settings"]["twapMaxDeviationBps"], "50");
+        assert_eq!(v["settings"]["leanShadow"], true);
+        assert_eq!(v["settings"]["leanEnabled"], false);
+
+        // Lean on without a floor is refused; nothing written for that field set.
+        let (status, body) = h
+            .patch_json(
+                "/api/bots/bot-a/settings",
+                json!({ "leanEnabled": true, "leanFloorBps": "" }),
+            )
+            .await;
+        assert_eq!(status, StatusCode::BAD_REQUEST, "{body}");
+        assert!(body.contains("lean_floor"), "{body}");
     }
 
     #[tokio::test]