Resilient symbol switching + correct strike increments for mixed-grid chains

Frontend: AbortController + correlation-ID guards on every symbol-scoped
fetch (bars, contracts, config, quote) so a slow response from the previous
symbol can no longer overwrite state for the current one. Same pattern
TanStack Query and other modern trading frontends use.

Backend: Split strike-increment cache into verified (chain-derived, 1h TTL)
vs heuristic-fallback (60s TTL) so a transient API blip can't poison the
long-lived cache with a wrong value.

Strike-increment algorithm: switched from "min of common increments in
±$20 window" to "mode of adjacent diffs in 9-strike ATM window". Fixes
MSTR which has both $1 and $2.50 increments in the chain — the old code
picked $1, snapping orders to invalid strikes and zeroing out the premium.

Verified increments after fix: SPY=$1, PLTR=$1, MRVL=$2.5, AMZN=$2.5,
MSTR=$2.5, MU=$5.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: calesthio

assisted_trading/backend/alpaca_broker.py

@@ -501,25 +501,46 @@ def get_tick_size(self, symbol: str, price: float) -> float:
             return 0.01
 
     # Cache for strike increments: {symbol: (increment, timestamp)}
-    _strike_increment_cache = {}
-    _STRIKE_CACHE_TTL = 3600  # 1 hour
+    _strike_increment_cache = {}            # verified (chain-derived) values
+    _strike_increment_fallback_cache = {}   # heuristic fallbacks (don't poison long-TTL)
+    _STRIKE_CACHE_TTL = 3600                # 1 hour for verified values
+    _STRIKE_FALLBACK_TTL = 60               # 60s for heuristic — long enough to dedupe
+                                            # within a single user flow, short enough
+                                            # to retry the chain query soon after
 
     def get_strike_increment(self, underlying_symbol: str, price: float) -> float:
         """
         Get strike price increment for options.
 
         Primary: derives from live option chain data near ATM.
-        Cached per-symbol for 1 hour.
         Fallback: hardcoded heuristics if API call fails.
+
+        Cache strategy (added in v0.1.8 to prevent fallback poisoning):
+          - "verified" cache: only chain-derived values, 1 hour TTL.
+            These are trustworthy and stable per symbol.
+          - "fallback" cache: heuristic guesses, 60 second TTL.
+            If the chain query fails on first load and we cache a bad
+            heuristic for 1 hour, every order for that symbol gets a wrong
+            strike for the rest of the hour. The short TTL means a transient
+            API failure self-heals on the next request instead of poisoning.
         """
         import time as _time
         from collections import Counter
 
-        # Check cache first
-        cached = self._strike_increment_cache.get(underlying_symbol)
-        if cached:
-            increment, cached_at = cached
-            if _time.time() - cached_at < self._STRIKE_CACHE_TTL:
+        now = _time.time()
+
+        # Prefer verified — it's the long-TTL trustworthy bucket.
+        verified = self._strike_increment_cache.get(underlying_symbol)
+        if verified:
+            increment, cached_at = verified
+            if now - cached_at < self._STRIKE_CACHE_TTL:
+                return increment
+
+        # Fall through to short-TTL fallback bucket (only used when verified is stale).
+        fallback = self._strike_increment_fallback_cache.get(underlying_symbol)
+        if fallback:
+            increment, cached_at = fallback
+            if now - cached_at < self._STRIKE_FALLBACK_TTL:
                 return increment
 
         try:
@@ -566,40 +587,67 @@ def get_strike_increment(self, underlying_symbol: str, price: float) -> float:
             if len(strikes) < 2:
                 raise ValueError("Not enough strikes to compute increment")
 
-            # Calculate increments between adjacent strikes
+            # Compute increment ONLY from strikes IMMEDIATELY adjacent to ATM.
+            # The old algorithm widened to ±$20 from ATM and picked min — but
+            # chains often have $1 strikes at deep ITM/OTM (for hedging) AND
+            # $2.5 strikes near ATM. Picking min returns $1 even though the
+            # right "where to actually trade" increment is $2.5. For MSTR at
+            # $161 the widened range had 9× $1 increments and 12× $2.5; the
+            # old algorithm picked $1, leading to strikes like $161 that
+            # don't exist (real chain has $160 and $162.5).
+            #
+            # New algorithm: find the strike closest to ATM, take 4 neighbors
+            # on each side (9-strike window), compute adjacent diffs in that
+            # window only, and pick the mode (most common). This is what
+            # actual trading platforms do for "find the ATM increment."
+            closest_idx = min(range(len(strikes)), key=lambda i: abs(strikes[i] - price))
+            lo = max(0, closest_idx - 4)
+            hi = min(len(strikes), closest_idx + 5)
+            atm_window = strikes[lo:hi]
+
             increments = []
-            for i in range(1, len(strikes)):
-                diff = round(strikes[i] - strikes[i - 1], 2)
+            for i in range(1, len(atm_window)):
+                diff = round(atm_window[i] - atm_window[i - 1], 2)
                 if diff > 0:
                     increments.append(diff)
 
             if not increments:
-                raise ValueError("No valid increments found")
+                raise ValueError("No valid increments in ATM window")
 
-            # Use smallest common increment (appears >= 3 times)
+            # Use the MOST COMMON increment in the ATM window (mode), not min.
+            # If the window happens to span an increment boundary (e.g. $1 wing
+            # transitioning to $2.5 near ATM), mode still picks the dominant
+            # value at ATM rather than the smaller wing value.
             counter = Counter(increments)
-            common = [inc for inc, count in counter.items() if count >= 3]
-            if common:
-                result = min(common)
-            else:
-                result = counter.most_common(1)[0][0]
+            result = counter.most_common(1)[0][0]
+            logger.info(
+                "Strike increment for %s near $%.2f: $%s (from ATM window %s, diffs %s)",
+                underlying_symbol, price, result, atm_window, dict(counter),
+            )
 
             # Cache it
             self._strike_increment_cache[underlying_symbol] = (result, _time.time())
             logger.info(f"Detected strike increment for {underlying_symbol}: ${result}")
             return result
 
         except Exception as e:
-            logger.warning(f"Could not detect strike increment for {underlying_symbol}: {e}, using heuristic fallback")
-            # Fallback heuristics
+            logger.warning(
+                "Could not detect strike increment for %s: %s, using heuristic fallback",
+                underlying_symbol, e,
+            )
+            # Fallback heuristics — cached briefly so we retry the real chain
+            # query soon. Caching the heuristic for 1 hour (the previous bug)
+            # made a single chain-query failure poison the symbol for an hour.
             if underlying_symbol in ['SPY', 'QQQ', 'IWM', 'DIA']:
-                return 1.0
+                fallback_val = 1.0
             elif price > 200:
-                return 5.0
+                fallback_val = 5.0
             elif price > 100:
-                return 2.5
+                fallback_val = 2.5
             else:
-                return 1.0
+                fallback_val = 1.0
+            self._strike_increment_fallback_cache[underlying_symbol] = (fallback_val, _time.time())
+            return fallback_val
 
     def validate_connection(self) -> Tuple[bool, str]:
         """

assisted_trading/frontendv2/js/chart/ChartManager.js

@@ -172,6 +172,16 @@ class ChartManager {
 
         console.log(`Loading ${symbol} ${this.currentTimeframe} data...`);
 
+        // Cancel any in-flight bar load for the previous symbol. Without this,
+        // a slow getHistoricalBars from the OLD symbol can land AFTER the new
+        // symbol's response and overwrite the chart with stale bars from a
+        // different ticker — the kind of bug that makes traders take real
+        // money trades against the wrong instrument.
+        this._loadAborter?.abort();
+        this._loadAborter = new AbortController();
+        const signal = this._loadAborter.signal;
+        const requestedSymbol = symbol;
+
         try {
             // Unsubscribe from previous symbol BEFORE updating currentSymbol
             if (this.currentSymbol && this.currentSymbol !== symbol) {
@@ -184,8 +194,14 @@ class ChartManager {
             // Fetch historical data
             const response = await window.ApiClient.getHistoricalBars(symbol, {
                 timeframe: this.currentTimeframe,
-                limit: 1000
+                limit: 1000,
+                signal,
             });
+            // Correlation-ID belt-and-suspenders check.
+            if (requestedSymbol !== this.currentSymbol) {
+                console.log(`ChartManager: stale bars for ${requestedSymbol}, now on ${this.currentSymbol}`);
+                return;
+            }
 
             if (!response || !response.bars) {
                 throw new Error('No data received');
@@ -242,8 +258,14 @@ class ChartManager {
             }
 
         } catch (error) {
-            console.error('Error loading chart data:', error);
-            window.EventBus.emit('chart:error', { symbol, error });
+            // Aborts are expected on symbol switching; suppress quietly so we
+            // don't fire a misleading chart:error event for them.
+            if (error.name === 'AbortError') {
+                console.log(`ChartManager: load aborted for ${symbol} (now on ${this.currentSymbol})`);
+            } else {
+                console.error('Error loading chart data:', error);
+                window.EventBus.emit('chart:error', { symbol, error });
+            }
         } finally {
             this.isLoading = false;
         }

assisted_trading/frontendv2/js/data/ApiClient.js

@@ -22,7 +22,7 @@ class ApiClient {
      * @param {Object} params - Query parameters
      * @returns {Promise<Object>} Response data
      */
-    async get(endpoint, params = {}) {
+    async get(endpoint, params = {}, options = {}) {
         try {
             const url = new URL(`${this.baseUrl}${endpoint}`);
             Object.keys(params).forEach(key => {
@@ -31,14 +31,17 @@ class ApiClient {
                 }
             });
 
-            const response = await fetch(url);
+            const response = await fetch(url, { signal: options.signal });
 
             if (!response.ok) {
                 throw new Error(`HTTP error! status: ${response.status}`);
             }
 
             return await response.json();
         } catch (error) {
+            // Aborts are expected when the user switches symbols mid-request;
+            // let them propagate silently — the caller decides what to do.
+            if (error.name === 'AbortError') throw error;
             console.error(`API GET error (${endpoint}):`, error);
             throw error;
         }
@@ -50,15 +53,16 @@ class ApiClient {
      * @param {Object} data - Request body
      * @returns {Promise<Object>} Response data
      */
-    async post(endpoint, data = {}) {
+    async post(endpoint, data = {}, options = {}) {
         try {
             const response = await fetch(`${this.baseUrl}${endpoint}`, {
                 method: 'POST',
                 headers: {
                     'Content-Type': 'application/json',
                     'X-CSRF-Token': this.csrfToken,
                 },
-                body: JSON.stringify(data)
+                body: JSON.stringify(data),
+                signal: options.signal,
             });
 
             if (!response.ok) {
@@ -68,6 +72,7 @@ class ApiClient {
 
             return await response.json();
         } catch (error) {
+            if (error.name === 'AbortError') throw error;
             console.error(`API POST error (${endpoint}):`, error);
             throw error;
         }
@@ -112,8 +117,8 @@ class ApiClient {
             timeframe: options.timeframe || '5Min',
             limit: options.limit || 1000,
             start: options.start,
-            end: options.end
-        });
+            end: options.end,
+        }, { signal: options.signal });
     }
 
     /**
@@ -122,8 +127,10 @@ class ApiClient {
      * @param {boolean} refresh - Force refresh cache
      * @returns {Promise<Object>} Valid contracts with DTE and expiration dates
      */
-    async getSymbolContracts(symbol, refresh = false) {
-        return this.get(`/api/symbol/contracts/${symbol}`, { refresh: refresh.toString() });
+    async getSymbolContracts(symbol, refresh = false, options = {}) {
+        return this.get(`/api/symbol/contracts/${symbol}`,
+            { refresh: refresh.toString() },
+            { signal: options.signal });
     }
 
     /**
@@ -132,21 +139,21 @@ class ApiClient {
      * @param {number} price - Current price (optional)
      * @returns {Promise<Object>} Symbol config
      */
-    async getSymbolConfig(symbol, price = null) {
+    async getSymbolConfig(symbol, price = null, options = {}) {
         const params = {};
         if (price !== null) {
             params.price = price;
         }
-        return this.get(`/api/symbol/config/${symbol}`, params);
+        return this.get(`/api/symbol/config/${symbol}`, params, { signal: options.signal });
     }
 
     /**
      * Get real-time option quote
      * @param {string} optionSymbol - OCC option symbol
      * @returns {Promise<Object>} Option quote with bid, ask, last, mark
      */
-    async getOptionQuote(optionSymbol) {
-        return this.get(`/api/option/quote/${optionSymbol}`);
+    async getOptionQuote(optionSymbol, options = {}) {
+        return this.get(`/api/option/quote/${optionSymbol}`, {}, { signal: options.signal });
     }
 
     // ========== Trading Operations ==========