Update app.py

app.py

@@ -1,8 +1,9 @@
 # app.py
 # MH370 Flight Simulator — Leaflet map (Folium) + Ping Rings (KML)
 #
-# Guided scenario (ACTIVE):
+# Guided scenarios (ACTIVE):
 #   A) Straight (single heading)
+#   A2) Straight + drift (per-leg ±deg, penalized)
 #
 # Key behavior:
 # - Last radar spot FIXED: 18:22:00Z @ 6.578N, 96.341E
@@ -10,32 +11,24 @@
 # - Guided mode computes a realistic turn between 18:22→18:40 and then southern path.
 # - Guided validation timestamps: 18:22, 18:40, 19:40, 20:40, 21:40, 22:40, 00:10, 00:20
 #
-# FIXES IMPLEMENTED:
+# FIXES IMPLEMENTED IN THIS VERSION:
 # 1) Remove trajectory (red line) AFTER 00:20
 #    - In guided mode, we CLIP the simulated legs so the polyline ends exactly at 00:20Z.
-# 2) Restore BFO plot
-#    - Full BFO analysis computation + chart + MAE/RMSE markdown.
+# 2) Restore BFO plot (it disappeared previously)
+#    - Re-added full BFO analysis computation + chart + MAE/RMSE markdown.
 #
-# TURN MODEL:
+# NEW (PREVIOUS UPDATE):
 # 3) Plausible final major turn (18:22→18:40) can adjust BOTH heading and speed
+#    - Turn speed is no longer fixed to the southern cruise speed.
+#    - The solver searches a plausible TURN speed range and chooses the best-scoring solution.
+#    - After 18:40, the southern trajectory continues “as per usual” using the selected speed profile.
+#    - Applies to BOTH scenarios: Straight and Straight + drift.
 #
-# SPEED MODEL:
-# 4) Southern trajectory speed is NOT constant:
-#    - Solver chooses 2 speeds:
-#      v1 from 18:40 → 19:40
-#      v2 from 19:40 → 00:10
-#    - Then 00:10 → 00:20 uses v2 (for display), but 00:20 is ignored in scoring.
-#
-# OPTIMIZER MIRROR + PERFORMANCE (THIS UPDATE):
-# - Uses bounded optimizer (L-BFGS-B) on [heading, turn speed, v1, v2]
-# - FAST seed pruning: pre-score coarse seeds using only 3 pings, keep top K
-# - Strict scoring pings: only 18:40,19:40,20:40,21:40,22:40,00:10 (00:20 excluded)
-# - Aggressive memoization cache for BFO/BTO calculations (big speed-up)
-#
-# SCORING NOTE:
-# 5) 00:20 (24:20) is IGNORED for scoring:
-#    - Excluded from guided scoring set.
-#    - Validation table shows calc at 00:20, but measured BFO/BTO are blanked there.
+# NEW (THIS UPDATE):
+# 4) Two-stage guided search (COARSE → REFINE) to make generation much faster
+#    - Stage 1: coarse grid search to find the region of the best solution
+#    - Stage 2: refined grid around the best candidate only
+#    - Applies to BOTH scenarios: Straight and Straight + drift
 
 import os
 import re
@@ -52,9 +45,6 @@ import plotly.graph_objects as go
 
 import flight_plotter_v32 as fp
 
-# Requires SciPy installed in your HF Space
-from scipy.optimize import minimize
-
 
 # ================= CONFIG =================
 KML_FILE = "MH370 - 13 nov (3).kml"
@@ -86,9 +76,9 @@ RING_TIMES = {
     "Ping Ring 7": "24:10:00Z",
 }
 
-# Normalization scales (used to normalize residuals)
+# Normalization (used for combining BFO + BTO into a single score in guided solve)
 BFO_SCALE_HZ = 5.0
-BTO_SCALE_US = 25.0  # tighter BTO enforcement
+BTO_SCALE_US = 50.0
 
 # EXPLICIT WEIGHTS
 DEFAULT_WEIGHT_BFO = 1.0
@@ -102,12 +92,15 @@ SATLOC_IDX_MEAS_BTO = 5
 RADAR_FIX_LAT = 6.578
 RADAR_FIX_LON = 96.341
 RADAR_FIX_TIME_UTC = datetime(2014, 3, 7, 18, 22, 0, tzinfo=timezone.utc)
+
 TURN_COMPLETE_TIME_UTC = datetime(2014, 3, 7, 18, 40, 0, tzinfo=timezone.utc)
+TURN_WINDOW_MIN = (TURN_COMPLETE_TIME_UTC - RADAR_FIX_TIME_UTC).total_seconds() / 60.0
 
 # Initial track shown in your radar annotation
 RADAR_INITIAL_TRACK_DEG = 296.0
 
 # ===== Guided validation timestamps of interest =====
+# (00:10 and 00:20 are represented as 24:10 and 24:20 in your SAT epoch helper)
 GUIDED_VALIDATION_LABELS = [
     "18:22:00",
     "18:40:00",
@@ -116,68 +109,49 @@ GUIDED_VALIDATION_LABELS = [
     "21:40:00",
     "22:40:00",
     "24:10:00",  # 00:10Z
-    "24:20:00",  # 00:20Z (final)
+    "24:20:00",  # 00:20Z
 ]
 GUIDED_FINAL_LABEL = "24:20:00"  # 00:20Z FINAL RESTING POINT
 
-# Score ONLY these pings (and NEVER 00:20)
-GUIDED_SCORE_LABELS = [
-    "18:40:00",
-    "19:40:00",
-    "20:40:00",
-    "21:40:00",
-    "22:40:00",
-    "24:10:00",  # 00:10Z
-]
-GUIDED_FAST_SEED_LABELS = [
-    "18:40:00",
-    "19:40:00",
-    "22:40:00",
-]
-
 # Turn modeling parameters
 TURN_BANK_MIN_DEG = 15.0
 TURN_BANK_MAX_DEG = 30.0
 TURN_BANK_DEFAULT_DEG = 25.0
 TURN_STEP_SEC = 30.0
 
-# Turn speed bounds
-TURN_SPEED_MIN_ABS_KT = 470.0
-TURN_SPEED_MAX_ABS_KT = 500.0
-
-# Southern speed bounds (2 segments)
-SOUTH_SPEED_CENTER_GUESS_KT = 445.0
-SOUTH_SPEED_MIN_ABS_KT = 400.0
-SOUTH_SPEED_MAX_ABS_KT = 500.0
-
-
-# Southern schedule:
-# - scoring window ends at 00:10 (24:10)
-# - solve v1: 18:40->19:40 (60 min), v2: 19:40->00:10 (270 min)
-# - final 00:10->00:20 (10 min) uses v2 for display; 00:20 ignored in scoring
-SOUTH_SCHEDULE_SCORE_MIN = [60.0, 270.0]
-SOUTH_SCHEDULE_FULL_MIN = [60.0, 270.0, 10.0]
-
-# Regularization to avoid overfitting crazy speed behavior
-SPEED_SMOOTH_WEIGHT = 0.05
-SPEED_CENTER_WEIGHT = 0.01
+# Turn-speed search parameters (turn only; southern uses speed profile)
+TURN_SPEED_SEARCH_DELTA_KT = 40.0     # search ± around the southern cruise speed
+TURN_SPEED_STEP_KT = 5.0              # refined candidate spacing
+TURN_SPEED_MIN_ABS_KT = 350.0         # hard min plausible
+TURN_SPEED_MAX_ABS_KT = 550.0         # hard max plausible
 
 # Guided heading search (south-ish)
 GUIDED_HEADING_MIN = 150.0
 GUIDED_HEADING_MAX = 210.0
+STRAIGHT_STEP_DEG = 0.5  # refined step
 
-# ===== Seed grid + pruning =====
-COARSE_HEADING_STEP_DEG = 2.0
-COARSE_TURN_SPEED_STEP_KT = 5.0
-SEED_PRUNE_TOPK = 8  # BIG speed-up: only optimize from top K seeds
+# Southern schedule (kept)
+GUIDED_LEG_SCHEDULE_MIN = [12.0, 60.0, 60.0, 60.0, 60.0, 90.0, 10.0]
+
+# Drift
+DEFAULT_DRIFT_MAX_DEG = 2.0
+DRIFT_STEP_DEG = 0.5  # refined step
+DEFAULT_WEIGHT_DRIFT = 0.30
+DEFAULT_DRIFT_ITERS = 2
+DRIFT_SCALE_DEG = 1.0
 
-# Optimizer iterations
-OPT_MAXITER = 160  # lower than before (faster), usually enough with good seeds
+# ===== NEW: Two-stage search knobs =====
+# Stage 1 (coarse)
+COARSE_HEADING_STEP_DEG = 2.0
+COARSE_TURN_SPEED_STEP_KT = 10.0
+COARSE_DRIFT_STEP_DEG = 1.0
 
-# Cache controls
-CACHE_MAX_ITEMS = 50000  # safety cap
+# Stage 2 (refine around best)
+REFINE_HEADING_HALF_WINDOW_DEG = 2.0   # +/- around best
+REFINE_TURN_SPEED_HALF_WINDOW_KT = 10.0
+REFINE_DRIFT_HALF_WINDOW_DEG = 1.0
 
-# Search area colors
+# Search area colors (optional)
 SEARCH_AREA_COLORS = {
     "Ocean Infinity": "#ff3b3b",
     "Australia": "#1f77b4",
@@ -475,9 +449,11 @@ def build_turn_legs(
 
     legs = []
 
+    # initial straight on radar track
     if straight_sec > 1.0:
         legs.append((h0, float(speed_knots), straight_sec / 60.0))
 
+    # discretized turn segments
     if turn_sec > 1.0 and delta_abs > 1e-6:
         step_sec = max(5.0, float(step_sec))
         n = int(math.ceil(turn_sec / step_sec))
@@ -692,43 +668,12 @@ def _map_marker_times(start_dt, legs):
     return times
 
 
-def _make_state_evaluator(start_lat: float, start_lon: float, legs, method: str, start_dt: datetime):
-    """
-    Precompute boundaries + leg start positions once, then evaluate lat/lon/spd/hdg at dt quickly.
-    """
-    legs = [(float(h), float(s), float(m)) for (h, s, m) in legs]
-    leg_secs = np.array([m * 60.0 for (_h, _s, m) in legs], dtype=float)
-    boundaries = np.cumsum(np.concatenate([[0.0], leg_secs]))
-    total_end = float(boundaries[-1])
-
-    leg_starts = _precompute_leg_starts(start_lat, start_lon, legs, method)
-
-    def state_at(dt_k: datetime):
-        if dt_k < start_dt:
-            return None
-        t_sec = float((dt_k - start_dt).total_seconds())
-        if t_sec > total_end:
-            t_sec = total_end
-
-        i = int(np.searchsorted(boundaries, t_sec, side="right") - 1)
-        i = max(0, min(i, len(legs) - 1))
-        t_inside = t_sec - float(boundaries[i])
-
-        lat0, lon0 = leg_starts[i]
-        hdg, spd, _m = legs[i]
-        lat, lon = _predict_state_from_leg_start(method, lat0, lon0, hdg, spd, t_inside)
-        return {
-            "lat": float(lat),
-            "lon": float(lon),
-            "speed_kt": float(spd),
-            "heading_deg": float(hdg),
-        }
-
-    return state_at
-
-
 # ================= CLIP TRAJECTORY TO 00:20 (GUIDED) =================
 def clip_legs_to_end_dt(legs, start_dt: datetime, end_dt: datetime):
+    """
+    Returns a new legs list truncated so total duration ends exactly at end_dt.
+    If legs already shorter than end_dt-start_dt, returns legs unchanged.
+    """
     total_target_sec = (end_dt - start_dt).total_seconds()
     if total_target_sec <= 0:
         return []
@@ -744,6 +689,7 @@ def clip_legs_to_end_dt(legs, start_dt: datetime, end_dt: datetime):
             out.append((float(hdg), float(spd), float(minutes)))
             remaining -= sec
         else:
+            # truncate this leg
             trunc_min = max(0.0, remaining / 60.0)
             if trunc_min > 1e-6:
                 out.append((float(hdg), float(spd), float(trunc_min)))
@@ -860,50 +806,12 @@ def bfo_analysis_with_legs(start_lat, start_lon, legs, method, start_dt, alt_ft,
 
 
 # ================= VALIDATION TABLE =================
-def _lookup_measured_at_dt(dt_ping: datetime, prefer_bto: bool = True, bto_search_radius: int = 4):
-    """
-    Returns (meas_bfo, meas_bto).
-
-    IMPORTANT:
-    Sometimes the nearest satLoc sample has BFO but BTO is None (your 18:40 case).
-    If prefer_bto=True, we search nearby indices for the closest non-None BTO.
-    """
-    if not hasattr(fp, "nearest_measured_for_time"):
-        return None, None
-
-    idx0 = int(fp.nearest_measured_for_time(dt_ping)[0])
-    row0 = fp.satLoc[idx0]
-    bfo0 = row0[SATLOC_IDX_MEAS_BFO]
-    bto0 = row0[SATLOC_IDX_MEAS_BTO]
-
-    if (not prefer_bto) or (bto0 is not None):
-        return bfo0, bto0
-
-    # Search neighbors for a valid BTO
-    best = (None, None, None)  # (abs_dt_sec, bto, idx)
-    for d in range(1, int(bto_search_radius) + 1):
-        for idx in (idx0 - d, idx0 + d):
-            if idx < 0 or idx >= len(fp.satLoc):
-                continue
-            row = fp.satLoc[idx]
-            bto = row[SATLOC_IDX_MEAS_BTO]
-            if bto is None:
-                continue
-            # Approx time distance using satLoc label time
-            try:
-                lab = fp._extract_time_string(row[0])
-                dt_row = fp._time_label_to_dt(lab, fp.SAT_EPOCH_UTC)
-                abs_sec = abs((dt_row - dt_ping).total_seconds())
-            except Exception:
-                abs_sec = float(d) * 60.0
-
-            if best[0] is None or abs_sec < best[0]:
-                best = (abs_sec, bto, idx)
-
-    if best[1] is None:
-        return bfo0, bto0
-
-    return bfo0, best[1]
+def _lookup_measured_at_dt(dt_ping: datetime):
+    if hasattr(fp, "nearest_measured_for_time"):
+        idx = fp.nearest_measured_for_time(dt_ping)[0]
+        row = fp.satLoc[idx]
+        return row[SATLOC_IDX_MEAS_BFO], row[SATLOC_IDX_MEAS_BTO]
+    return None, None
 
 
 def build_validation_table(
@@ -951,11 +859,7 @@ def build_validation_table(
         bfo_calc = float(fp.calculateBFO_at_time(spd_mps, float(hdg), float(lat), float(lon), alt_m, vs_mps, dt_k))
         bto_calc = float(fp.calculateBTO_at_time(float(lat), float(lon), alt_m, dt_k))
 
-        bfo_meas, bto_meas = _lookup_measured_at_dt(dt_k, prefer_bto=True)
-
-        # remove measured values at 00:20 (final)
-        if is_guided and dt_k == _dt_from_label(GUIDED_FINAL_LABEL):
-            bfo_meas, bto_meas = None, None
+        bfo_meas, bto_meas = _lookup_measured_at_dt(dt_k)
 
         bfo_err = None if bfo_meas is None else (float(bfo_calc) - float(bfo_meas))
         bto_err = None if bto_meas is None else (float(bto_calc) - float(bto_meas))
@@ -1022,6 +926,13 @@ def add_permanent_label(m, name, lat, lon):
 
 
 def build_leaflet_map(path_pts, legs, method, start_dt):
+    """
+    - Ping rings always drawn
+    - Search areas always drawn (color-coded)
+    - Validation markers are the authoritative markers
+    - Guided mode does NOT draw a purple End marker
+    - Trajectory is clipped to 00:20 in guided mode by clipping legs before simulate_path
+    """
     start_lat, start_lon = path_pts[0]
     is_guided = (start_dt == RADAR_FIX_TIME_UTC)
 
@@ -1166,6 +1077,7 @@ def build_leaflet_map(path_pts, legs, method, start_dt):
             f"Distance flown: {dist_km:.2f} km",
         ]
 
+        # Make final point visually distinct
         if is_final:
             folium.CircleMarker(
                 location=(lat, lon),
@@ -1220,319 +1132,404 @@ def build_leaflet_map(path_pts, legs, method, start_dt):
     """
 
 
-# ================= Guided scoring point selection =================
-def _score_points_for_labels(labels: list[str]):
+# ================= Guided Speed Profile =================
+def isa_speed_of_sound_mps(alt_m: float) -> float:
+    T0 = 288.15
+    L = -0.0065
+    h_trop = 11000.0
+    if alt_m <= h_trop:
+        T = T0 + L * alt_m
+    else:
+        T = 216.65
+    gamma = 1.4
+    R = 287.05
+    return math.sqrt(gamma * R * T)
+
+
+def mach_to_tas_knots(mach: float, alt_ft: float) -> float:
+    alt_m = float(alt_ft) * 0.3048
+    a = isa_speed_of_sound_mps(alt_m)
+    tas_mps = float(mach) * a
+    return tas_mps / 0.514444
+
+
+def speed_from_profile(profile: str, alt_ft: float, custom_mach: float, custom_knots: float) -> float:
+    profile = (profile or "").strip()
+    if profile.startswith("MRC"):
+        return mach_to_tas_knots(0.82, alt_ft)
+    if profile.startswith("LRC"):
+        return mach_to_tas_knots(0.84, alt_ft)
+    if profile.startswith("ECON"):
+        return mach_to_tas_knots(0.80, alt_ft)
+    if profile.startswith("Custom Mach"):
+        return mach_to_tas_knots(float(custom_mach), alt_ft)
+    if profile.startswith("Custom knots"):
+        return float(custom_knots)
+    return mach_to_tas_knots(0.82, alt_ft)
+
+
+def _turn_speed_candidates(south_speed_knots: float, step_kt: float):
     """
-    Return [(label, dt, meas_bfo, meas_bto)] using nearest measured sample for each label time.
-    Ensures unique rows (if two labels snap to same satLoc index).
+    Plausible turn-speed candidates around the southern cruise speed.
+    Hard-clipped to [TURN_SPEED_MIN_ABS_KT, TURN_SPEED_MAX_ABS_KT].
     """
-    out = []
-    used_idx = set()
-    for lab in labels:
-        dt = _dt_from_label(lab)
-        if hasattr(fp, "nearest_measured_for_time"):
-            idx = fp.nearest_measured_for_time(dt)[0]
-            if idx in used_idx:
-                continue
-            used_idx.add(idx)
-            row = fp.satLoc[idx]
-            bfo = row[SATLOC_IDX_MEAS_BFO]
-            bto = row[SATLOC_IDX_MEAS_BTO]
-            if bfo is None:
-                continue
-            out.append((lab, dt, float(bfo), None if bto is None else float(bto)))
-        else:
-            # fallback: scan satLoc text label match
-            best = None
-            for r in fp.satLoc:
-                label_r = fp._extract_time_string(r[0])
-                if label_r.replace("Z", "") == lab.replace("Z", ""):
-                    best = r
-                    break
-            if best is None or best[SATLOC_IDX_MEAS_BFO] is None:
-                continue
-            out.append((lab, dt, float(best[SATLOC_IDX_MEAS_BFO]),
-                        None if best[SATLOC_IDX_MEAS_BTO] is None else float(best[SATLOC_IDX_MEAS_BTO])))
-    out.sort(key=lambda x: x[1])
+    base = float(south_speed_knots)
+    lo = max(TURN_SPEED_MIN_ABS_KT, base - float(TURN_SPEED_SEARCH_DELTA_KT))
+    hi = min(TURN_SPEED_MAX_ABS_KT, base + float(TURN_SPEED_SEARCH_DELTA_KT))
+    step = max(1.0, float(step_kt))
+    if hi < lo:
+        lo, hi = hi, lo
+    cand = list(np.arange(lo, hi + 1e-9, step))
+    # Ensure base is included
+    if all(abs(c - base) > 1e-9 for c in cand):
+        cand.append(base)
+    cand = sorted({round(float(c), 6) for c in cand})
+    return cand
+
+
+def _clamp(x, lo, hi):
+    return max(lo, min(hi, x))
+
+
+def _frange(lo: float, hi: float, step: float):
+    # inclusive hi, stable float stepping
+    step = float(step)
+    if step <= 0:
+        return []
+    n = int(math.floor((hi - lo) / step + 1e-9)) + 1
+    out = [lo + i * step for i in range(max(0, n))]
+    # trim due to floating errors
+    out = [x for x in out if x <= hi + 1e-9]
     return out
 
 
-# ================= Guided Solver (OPTIMIZER MIRROR + FAST) =================
-def solve_guided_straight(
-    method, alt_ft, vs_fpm,
-    descent_start_choice, weight_bfo, weight_bto
+def _refine_range(center: float, half_window: float, step: float, lo: float, hi: float):
+    lo2 = _clamp(center - half_window, lo, hi)
+    hi2 = _clamp(center + half_window, lo, hi)
+    return _frange(lo2, hi2, step)
+
+
+# ================= Guided Legs Creation =================
+def make_legs_from_schedule(headings, speed_knots, schedule_minutes):
+    legs = []
+    if isinstance(headings, (int, float)):
+        headings = [float(headings)] * len(schedule_minutes)
+    for hdg, m in zip(headings, schedule_minutes):
+        m = float(m)
+        if m <= 0:
+            continue
+        legs.append((float(hdg), float(speed_knots), float(m)))
+    return legs
+
+
+# ================= Scoring helper (used in guided solvers) =================
+def score_legs_bfo_bto(
+    start_lat, start_lon, method, start_dt, end_dt, legs,
+    alt_ft, vs_fpm, descent_start_dt,
+    weight_bfo: float, weight_bto: float,
+    pts_window=None
 ):
-    start_dt = RADAR_FIX_TIME_UTC
-    end_dt = _dt_from_label(GUIDED_FINAL_LABEL)
+    # pts_window: optional precomputed list [(lbl, dt, meas_bfo, meas_bto), ...] already clipped to [start_dt, end_dt]
+    if pts_window is None:
+        pts = _ping_points_after(start_dt)
+        pts = [(lbl, dt, bfo, bto) for (lbl, dt, bfo, bto) in pts if start_dt <= dt <= end_dt]
+    else:
+        pts = pts_window
 
-    descent_start_dt = None
-    if (descent_start_choice or "").startswith("After Ping Ring 6"):
-        descent_start_dt = dt_ping6_utc()
-    elif (descent_start_choice or "").startswith("After Ping Ring 7"):
-        descent_start_dt = dt_ping7_utc()
+    if len(pts) < 2:
+        return None
 
-    # Strict scoring pings (6 points)
-    pts_score = _score_points_for_labels(GUIDED_SCORE_LABELS)
-    if len(pts_score) < 2:
-        return None, "Guided solve: not enough scoring pings (check satLoc).", None
-
-    pts_fast = _score_points_for_labels(GUIDED_FAST_SEED_LABELS)
-    if len(pts_fast) < 2:
-        pts_fast = pts_score[:3]
-
-    # --- Cache for expensive BFO/BTO computations ---
-    cache = {}
-
-    def _cache_get(key):
-        return cache.get(key, None)
-
-    def _cache_put(key, val):
-        if len(cache) >= int(CACHE_MAX_ITEMS):
-            # simple eviction: clear (safe + fast)
-            cache.clear()
-        cache[key] = val
-
-    def _compute_residuals_at_point_cached(lat, lon, hdg_deg, spd_knots, dt_ping):
-        """
-        Returns (r_bfo, r_bto) where residual = calc - meas.
-        Uses memoization with rounding to speed repeated optimizer calls.
-        """
-        # altitude & VS depend on time
-        alt_now_ft = altitude_ft_at_dt(dt_ping, RADAR_FIX_TIME_UTC, float(alt_ft), float(vs_fpm), descent_start_dt)
+    leg_secs = [float(m) * 60.0 for _, _, m in legs]
+    boundaries = np.cumsum([0.0] + leg_secs)
+    total_end = float(boundaries[-1])
+
+    leg_start_positions = _precompute_leg_starts(start_lat, start_lon, legs, method)
+
+    bfo_preds, bfo_meas = [], []
+    bto_preds, bto_meas = [], []
+
+    for _lbl, dt_ping, meas_bfo, meas_bto in pts:
+        t_sec = (dt_ping - start_dt).total_seconds()
+        if t_sec < 0 or t_sec > total_end:
+            continue
+
+        i = int(np.searchsorted(boundaries, t_sec, side="right") - 1)
+        i = max(0, min(i, len(legs) - 1))
+        t_inside = float(t_sec) - float(boundaries[i])
+
+        leg_start_lat, leg_start_lon = leg_start_positions[i]
+        hdg, spd, _ = legs[i]
+        lat, lon = _predict_state_from_leg_start(method, leg_start_lat, leg_start_lon, hdg, spd, t_inside)
+
+        alt_now_ft = altitude_ft_at_dt(dt_ping, start_dt, float(alt_ft), float(vs_fpm), descent_start_dt)
         alt_m = alt_now_ft * 0.3048
 
         vs_mps = float(vs_fpm) * 0.00508
         if descent_start_dt is not None and dt_ping < descent_start_dt:
             vs_mps = 0.0
 
-        spd_mps = float(spd_knots) * 1852.0 / 3600.0
+        spd_mps = float(spd) * 1852.0 / 3600.0
+        pred_bfo = float(fp.calculateBFO_at_time(spd_mps, float(hdg), float(lat), float(lon), alt_m, vs_mps, dt_ping))
+        bfo_preds.append(pred_bfo)
+        bfo_meas.append(float(meas_bfo))
 
-        key = (
-            round(float(lat), 4),
-            round(float(lon), 4),
-            round(float(hdg_deg), 1),
-            round(float(spd_knots), 1),
-            int(dt_ping.timestamp()),
-            round(float(alt_m), 1),
-            round(float(vs_mps), 3),
-        )
-        got = _cache_get(key)
-        if got is not None:
-            return got
+        if meas_bto is not None:
+            pred_bto = float(fp.calculateBTO_at_time(float(lat), float(lon), alt_m, dt_ping))
+            bto_preds.append(pred_bto)
+            bto_meas.append(float(meas_bto))
+
+    if len(bfo_meas) < 2:
+        return None
 
-        bfo_calc = float(fp.calculateBFO_at_time(spd_mps, float(hdg_deg), float(lat), float(lon), alt_m, vs_mps, dt_ping))
-        bto_calc = float(fp.calculateBTO_at_time(float(lat), float(lon), alt_m, dt_ping))
-        bfo_meas, bto_meas = _lookup_measured_at_dt(dt_ping, prefer_bto=True)
+    e_bfo = np.array(bfo_preds) - np.array(bfo_meas)
+    rmse_bfo = float(np.sqrt(np.mean(e_bfo * e_bfo)))
 
-        r_bfo = None if bfo_meas is None else (bfo_calc - float(bfo_meas))
-        r_bto = None if bto_meas is None else (bto_calc - float(bto_meas))
+    rmse_bto = None
+    if len(bto_meas) >= 2:
+        e_bto = np.array(bto_preds) - np.array(bto_meas)
+        rmse_bto = float(np.sqrt(np.mean(e_bto * e_bto)))
 
-        _cache_put(key, (r_bfo, r_bto))
-        return r_bfo, r_bto
+    combined = float(weight_bfo) * (rmse_bfo / BFO_SCALE_HZ)
+    if rmse_bto is not None:
+        combined += float(weight_bto) * (rmse_bto / BTO_SCALE_US)
 
-    def _regularization_speed(v1: float, v2: float) -> float:
-        pen = 0.0
-        pen += float(SPEED_CENTER_WEIGHT) * ((float(v1) - float(SOUTH_SPEED_CENTER_GUESS_KT)) / 10.0) ** 2
-        pen += float(SPEED_CENTER_WEIGHT) * ((float(v2) - float(SOUTH_SPEED_CENTER_GUESS_KT)) / 10.0) ** 2
-        pen += float(SPEED_SMOOTH_WEIGHT) * ((float(v2) - float(v1)) / 10.0) ** 2
-        return float(pen)
+    return {
+        "n_bfo": len(bfo_meas),
+        "n_bto": len(bto_meas),
+        "rmse_bfo": rmse_bfo,
+        "rmse_bto": rmse_bto,
+        "combined": combined,
+    }
+
+
+# ================= Guided Solvers =================
+def _guided_start_dt():
+    return RADAR_FIX_TIME_UTC
+
+
+def solve_guided_straight(
+    method, south_speed_knots, alt_ft, vs_fpm,
+    descent_start_choice, weight_bfo, weight_bto
+):
+    # We clip everything to final 00:20Z; end_dt is fixed by label.
+    start_dt = _guided_start_dt()
+    end_dt = _dt_from_label(GUIDED_FINAL_LABEL)
 
-    def _build_legs_for_params(h_south, spd_turn, v1, v2, full=False):
-        turn_legs, _ = build_turn_legs(
+    # descent start
+    descent_start_dt = None
+    if (descent_start_choice or "").startswith("After Ping Ring 6"):
+        descent_start_dt = dt_ping6_utc()
+    elif (descent_start_choice or "").startswith("After Ping Ring 7"):
+        descent_start_dt = dt_ping7_utc()
+
+    # Precompute ping points once (windowed)
+    pts_all = _ping_points_after(start_dt)
+    pts_window = [(lbl, dt, bfo, bto) for (lbl, dt, bfo, bto) in pts_all if start_dt <= dt <= end_dt]
+    if len(pts_window) < 2:
+        return None, "Guided solve: not enough ping points to score.", None
+
+    def try_candidate(h_south: float, spd_turn: float):
+        southern_legs = make_legs_from_schedule(h_south, float(south_speed_knots), GUIDED_LEG_SCHEDULE_MIN)
+        preturn_legs, _turn_info = build_turn_legs(
             speed_knots=float(spd_turn),
             method=method,
             heading_final_deg=float(h_south),
         )
-        if not turn_legs:
-            return None
-        if full:
-            south = [
-                (float(h_south), float(v1), float(SOUTH_SCHEDULE_FULL_MIN[0])),
-                (float(h_south), float(v2), float(SOUTH_SCHEDULE_FULL_MIN[1])),
-                (float(h_south), float(v2), float(SOUTH_SCHEDULE_FULL_MIN[2])),
-            ]
-        else:
-            south = [
-                (float(h_south), float(v1), float(SOUTH_SCHEDULE_SCORE_MIN[0])),
-                (float(h_south), float(v2), float(SOUTH_SCHEDULE_SCORE_MIN[1])),
-            ]
-        return turn_legs + south
-
-    # Objective on a chosen ping set
-    def _objective_on_pts(x, pts):
-        h_south = float(x[0])
-        spd_turn = float(x[1])
-        v1 = float(x[2])
-        v2 = float(x[3])
-
-        legs_score = _build_legs_for_params(h_south, spd_turn, v1, v2, full=False)
-        if legs_score is None:
-            return 1e12
-
-        state_at = _make_state_evaluator(RADAR_FIX_LAT, RADAR_FIX_LON, legs_score, method, start_dt)
-
-        sse = 0.0
-        n_used = 0
-
-        for (_lbl, dt_ping, _mbfo, _mbto) in pts:
-            st = state_at(dt_ping)
-            if st is None:
-                continue
-
-            r_bfo, r_bto = _compute_residuals_at_point_cached(
-                st["lat"], st["lon"], st["heading_deg"], st["speed_kt"], dt_ping
-            )
+        full_legs = preturn_legs + southern_legs
+        full_legs = clip_legs_to_end_dt(full_legs, start_dt, end_dt)
+        s = score_legs_bfo_bto(
+            RADAR_FIX_LAT, RADAR_FIX_LON, method, start_dt, end_dt, full_legs,
+            alt_ft, vs_fpm, descent_start_dt,
+            weight_bfo, weight_bto,
+            pts_window=pts_window
+        )
+        return s, full_legs
 
-            sse_bto = 0.0
-sse_bfo = 0.0
-n_bto = 0
-n_bfo = 0
+    # -------- Stage 1: COARSE search --------
+    best_h = None
+    best_turn_spd = None
+    best_full_legs = None
+    best_score = None
 
-for (_lbl, dt_ping, _mbfo, _mbto) in pts:
-    st = state_at(dt_ping)
-    if st is None:
-        continue
+    coarse_headings = _frange(GUIDED_HEADING_MIN, GUIDED_HEADING_MAX, COARSE_HEADING_STEP_DEG)
+    coarse_turn_speeds = _turn_speed_candidates(float(south_speed_knots), COARSE_TURN_SPEED_STEP_KT)
 
-    r_bfo, r_bto = _compute_residuals_at_point_cached(
-        st["lat"], st["lon"], st["heading_deg"], st["speed_kt"], dt_ping
+    for h in coarse_headings:
+        for spd_turn in coarse_turn_speeds:
+            s, legs = try_candidate(h, spd_turn)
+            if s is not None and (best_score is None or s["combined"] < best_score["combined"]):
+                best_score = s
+                best_h = float(h)
+                best_turn_spd = float(spd_turn)
+                best_full_legs = legs
+
+    if best_full_legs is None:
+        return None, "Guided solve: not enough ping points to score.", None
+
+    # -------- Stage 2: REFINE around best --------
+    refine_headings = _refine_range(best_h, REFINE_HEADING_HALF_WINDOW_DEG, STRAIGHT_STEP_DEG, GUIDED_HEADING_MIN, GUIDED_HEADING_MAX)
+    refine_turn_speeds = _refine_range(
+        best_turn_spd, REFINE_TURN_SPEED_HALF_WINDOW_KT, TURN_SPEED_STEP_KT,
+        max(TURN_SPEED_MIN_ABS_KT, float(south_speed_knots) - TURN_SPEED_SEARCH_DELTA_KT),
+        min(TURN_SPEED_MAX_ABS_KT, float(south_speed_knots) + TURN_SPEED_SEARCH_DELTA_KT),
     )
 
-    # PRIMARY: BTO
-    if r_bto is not None:
-        sse_bto += (float(r_bto) / float(BTO_SCALE_US)) ** 2
-        n_bto += 1
+    for h in refine_headings:
+        for spd_turn in refine_turn_speeds:
+            s, legs = try_candidate(h, spd_turn)
+            if s is not None and (best_score is None or s["combined"] < best_score["combined"]):
+                best_score = s
+                best_h = float(h)
+                best_turn_spd = float(spd_turn)
+                best_full_legs = legs
 
-    # SECONDARY: BFO
-    if r_bfo is not None:
-        sse_bfo += (float(r_bfo) / float(BFO_SCALE_HZ)) ** 2
-        n_bfo += 1
-
-# If no BTO points, reject (we're optimizing for BTO)
-if n_bto == 0:
-    return 1e12
+    report = "\n".join([
+        "**Guided mode: Straight + computed turn (18:22→18:40), clipped to 00:20**",
+        f"- Search mode: **two-stage (coarse → refine)**",
+        f"- Southern speed (speed profile): **{float(south_speed_knots):.1f} kt**",
+        f"- Best turn speed (18:22→18:40): **{float(best_turn_spd):.1f} kt**",
+        f"- Best southern heading: **{best_h:.1f}°**",
+        f"- BFO points: **{best_score['n_bfo']}** | RMSE_BFO: **{best_score['rmse_bfo']:.2f} Hz**",
+        f"- BTO points: **{best_score['n_bto']}** | RMSE_BTO: **{best_score['rmse_bto']:.1f} µs**" if best_score.get("rmse_bto") is not None else
+        f"- BTO points: **{best_score['n_bto']}** | RMSE_BTO: n/a",
+    ])
 
-rmse_bto_n = math.sqrt(sse_bto / max(1, n_bto))
-rmse_bfo_n = math.sqrt(sse_bfo / max(1, n_bfo)) if n_bfo > 0 else 0.0
+    return best_full_legs, report, start_dt
 
-# Objective: BTO-first, BFO is a tie-breaker/regularizer
-# weight_bto acts like "how strongly you want BTO", but BTO is always primary here.
-obj = float(weight_bto) * rmse_bto_n + float(weight_bfo) * rmse_bfo_n
 
-# Keep your speed regularization (helps prevent crazy solutions)
-obj += _regularization_speed(v1, v2)
+def solve_guided_straight_with_drift(
+    method, south_speed_knots, alt_ft, vs_fpm,
+    descent_start_choice, weight_bfo, weight_bto,
+    drift_max_deg, drift_weight
+):
+    start_dt = _guided_start_dt()
+    end_dt = _dt_from_label(GUIDED_FINAL_LABEL)
 
-return float(obj)
+    # descent start
+    descent_start_dt = None
+    if (descent_start_choice or "").startswith("After Ping Ring 6"):
+        descent_start_dt = dt_ping6_utc()
+    elif (descent_start_choice or "").startswith("After Ping Ring 7"):
+        descent_start_dt = dt_ping7_utc()
 
-    # Full objective (strict scoring pings)
-    def objective(x):
-        return _objective_on_pts(x, pts_score)
+    # Precompute ping points once (windowed)
+    pts_all = _ping_points_after(start_dt)
+    pts_window = [(lbl, dt, bfo, bto) for (lbl, dt, bfo, bto) in pts_all if start_dt <= dt <= end_dt]
+    if len(pts_window) < 2:
+        return None, "Guided drift solve: not enough ping points to score.", None
 
-    # Bounds (mirrors bounded optimizer style)
-    bounds = [
-        (GUIDED_HEADING_MIN, GUIDED_HEADING_MAX),           # heading
-        (TURN_SPEED_MIN_ABS_KT, TURN_SPEED_MAX_ABS_KT),     # turn speed
-        (SOUTH_SPEED_MIN_ABS_KT, SOUTH_SPEED_MAX_ABS_KT),   # v1
-        (SOUTH_SPEED_MIN_ABS_KT, SOUTH_SPEED_MAX_ABS_KT),   # v2
-    ]
+    drift_max_deg = float(drift_max_deg)
 
-    # ===== Seed pruning (FAST) =====
-    coarse_headings = np.arange(GUIDED_HEADING_MIN, GUIDED_HEADING_MAX + 1e-9, COARSE_HEADING_STEP_DEG)
-    coarse_turn_speeds = np.arange(TURN_SPEED_MIN_ABS_KT, TURN_SPEED_MAX_ABS_KT + 1e-9, COARSE_TURN_SPEED_STEP_KT)
+    def try_candidate(h0_nominal: float, drift_deg: float, spd_turn: float):
+        h_eff = _wrap_heading_deg(float(h0_nominal) + float(drift_deg))
 
-    seed_scores = []
-    for h in coarse_headings:
-        for spd in coarse_turn_speeds:
-            x0 = np.array([float(h), float(spd), float(SOUTH_SPEED_CENTER_GUESS_KT), float(SOUTH_SPEED_CENTER_GUESS_KT)], dtype=float)
-            f0 = _objective_on_pts(x0, pts_fast)
-            seed_scores.append((float(f0), float(h), float(spd)))
-
-    seed_scores.sort(key=lambda t: t[0])
-    top = seed_scores[:max(1, int(SEED_PRUNE_TOPK))]
-
-    # ===== Optimize only top K seeds =====
-    best_res = None
-    for (_f0, h0, spd0) in top:
-        x0 = np.array([float(h0), float(spd0), float(SOUTH_SPEED_CENTER_GUESS_KT), float(SOUTH_SPEED_CENTER_GUESS_KT)], dtype=float)
-        res = minimize(
-            objective,
-            x0=x0,
-            method="L-BFGS-B",
-            bounds=bounds,
-            options={"maxiter": int(OPT_MAXITER), "ftol": 1e-9},
+        southern_legs = make_legs_from_schedule(h_eff, float(south_speed_knots), GUIDED_LEG_SCHEDULE_MIN)
+        preturn_legs, _turn_info = build_turn_legs(
+            speed_knots=float(spd_turn),
+            method=method,
+            heading_final_deg=float(h_eff),
         )
-        if not np.isfinite(res.fun):
-            continue
-        if (best_res is None) or (float(res.fun) < float(best_res.fun)):
-            best_res = res
-
-    if best_res is None:
-        return None, "Guided solve: no valid solution found (optimizer failed).", None
-
-    h_best = float(best_res.x[0])
-    spd_turn_best = float(best_res.x[1])
-    v1_best = float(best_res.x[2])
-    v2_best = float(best_res.x[3])
-
-    # Build final legs for display through 00:20
-    full_legs = _build_legs_for_params(h_best, spd_turn_best, v1_best, v2_best, full=True)
-    full_legs = clip_legs_to_end_dt(full_legs, start_dt, end_dt)
-
-    # Compute RMSEs for reporting (strict scoring pings)
-    def final_metrics():
-        legs_score = _build_legs_for_params(h_best, spd_turn_best, v1_best, v2_best, full=False)
-        state_at = _make_state_evaluator(RADAR_FIX_LAT, RADAR_FIX_LON, legs_score, method, start_dt)
-
-        sum_bfo2 = 0.0
-        sum_bto2 = 0.0
-        n_bfo = 0
-        n_bto = 0
-
-        for (_lbl, dt_ping, _mbfo, _mbto) in pts_score:
-            st = state_at(dt_ping)
-            if st is None:
-                continue
-            r_bfo, r_bto = _compute_residuals_at_point_cached(
-                st["lat"], st["lon"], st["heading_deg"], st["speed_kt"], dt_ping
-            )
-            if r_bfo is not None:
-                sum_bfo2 += float(r_bfo) ** 2
-                n_bfo += 1
-            if r_bto is not None:
-                sum_bto2 += float(r_bto) ** 2
-                n_bto += 1
-
-        rmse_bfo = math.sqrt(sum_bfo2 / max(1, n_bfo)) if n_bfo > 0 else 0.0
-        rmse_bto = math.sqrt(sum_bto2 / max(1, n_bto)) if n_bto > 0 else None
-        return n_bfo, n_bto, rmse_bfo, rmse_bto
-
-    n_bfo, n_bto, rmse_bfo, rmse_bto = final_metrics()
+        full_legs = preturn_legs + southern_legs
+        full_legs = clip_legs_to_end_dt(full_legs, start_dt, end_dt)
+
+        s = score_legs_bfo_bto(
+            RADAR_FIX_LAT, RADAR_FIX_LON, method, start_dt, end_dt, full_legs,
+            alt_ft, vs_fpm, descent_start_dt,
+            weight_bfo, weight_bto,
+            pts_window=pts_window
+        )
+        if s is None:
+            return None, None, None
+
+        combined_plus = float(s["combined"]) + float(drift_weight) * (abs(float(drift_deg)) / DRIFT_SCALE_DEG)
+        return s, combined_plus, full_legs
+
+    # -------- Stage 1: COARSE search --------
+    best_h0 = None
+    best_d = None
+    best_turn_spd = None
+    best_full_legs = None
+    best_score = None
+    best_combined_plus = None
+
+    coarse_headings = _frange(GUIDED_HEADING_MIN, GUIDED_HEADING_MAX, COARSE_HEADING_STEP_DEG)
+
+    # Drift candidates (coarse)
+    if drift_max_deg <= 1e-9:
+        coarse_drifts = [0.0]
+    else:
+        coarse_drifts = list(np.arange(-drift_max_deg, drift_max_deg + 1e-9, COARSE_DRIFT_STEP_DEG))
+        if 0.0 not in coarse_drifts:
+            coarse_drifts.append(0.0)
+        coarse_drifts = sorted({round(float(x), 6) for x in coarse_drifts})
+
+    coarse_turn_speeds = _turn_speed_candidates(float(south_speed_knots), COARSE_TURN_SPEED_STEP_KT)
+
+    for h0 in coarse_headings:
+        for d in coarse_drifts:
+            for spd_turn in coarse_turn_speeds:
+                s, combined_plus, legs = try_candidate(h0, d, spd_turn)
+                if s is None:
+                    continue
+                if best_combined_plus is None or float(combined_plus) < float(best_combined_plus):
+                    best_score = dict(s)
+                    best_combined_plus = float(combined_plus)
+                    best_h0 = float(h0)
+                    best_d = float(d)
+                    best_turn_spd = float(spd_turn)
+                    best_full_legs = legs
+
+    if best_full_legs is None:
+        return None, "Guided drift solve: not enough ping points to score.", None
+
+    # -------- Stage 2: REFINE around best --------
+    refine_headings = _refine_range(best_h0, REFINE_HEADING_HALF_WINDOW_DEG, 1.0, GUIDED_HEADING_MIN, GUIDED_HEADING_MAX)
+
+    # Refine drift around best_d with DRIFT_STEP_DEG (0.5)
+    d_lo = max(-drift_max_deg, best_d - REFINE_DRIFT_HALF_WINDOW_DEG)
+    d_hi = min(+drift_max_deg, best_d + REFINE_DRIFT_HALF_WINDOW_DEG)
+    refine_drifts = _frange(d_lo, d_hi, DRIFT_STEP_DEG)
+    if not refine_drifts:
+        refine_drifts = [best_d]
+
+    refine_turn_speeds = _refine_range(
+        best_turn_spd, REFINE_TURN_SPEED_HALF_WINDOW_KT, TURN_SPEED_STEP_KT,
+        max(TURN_SPEED_MIN_ABS_KT, float(south_speed_knots) - TURN_SPEED_SEARCH_DELTA_KT),
+        min(TURN_SPEED_MAX_ABS_KT, float(south_speed_knots) + TURN_SPEED_SEARCH_DELTA_KT),
+    )
+
+    for h0 in refine_headings:
+        for d in refine_drifts:
+            for spd_turn in refine_turn_speeds:
+                s, combined_plus, legs = try_candidate(h0, d, spd_turn)
+                if s is None:
+                    continue
+                if best_combined_plus is None or float(combined_plus) < float(best_combined_plus):
+                    best_score = dict(s)
+                    best_combined_plus = float(combined_plus)
+                    best_h0 = float(h0)
+                    best_d = float(d)
+                    best_turn_spd = float(spd_turn)
+                    best_full_legs = legs
 
     report = "\n".join([
-        "**Guided mode: Straight + computed turn (18:22→18:40), clipped to 00:20**",
-        "- Solver: **L-BFGS-B** on **[heading, turn_speed, v1, v2]**",
-        f"- Seed pruning: coarse grid → **top {SEED_PRUNE_TOPK}** seeds (fast pre-score on {len(pts_fast)} pings)",
-        f"- Strict scoring pings: **{', '.join(GUIDED_SCORE_LABELS)}**",
-        f"- Best southern heading: **{h_best:.2f}°**",
-        f"- Best turn speed (18:22→18:40): **{spd_turn_best:.2f} kt**",
-        f"- Southern speed segments:",
-        f"  - 18:40 → 19:40: **{v1_best:.2f} kt**",
-        f"  - 19:40 → 00:10: **{v2_best:.2f} kt**",
-        f"  - 00:10 → 00:20 (display only): **{v2_best:.2f} kt**",
-        f"- Objective (normalized): **{float(best_res.fun):.6f}**",
-        f"- Optimizer status: **{best_res.message}**",
-        f"- Function evals: **{getattr(best_res, 'nfev', 'n/a')}** | Iters: **{getattr(best_res, 'nit', 'n/a')}**",
-        f"- Cache size (end of solve): **{len(cache)}** items (cap {CACHE_MAX_ITEMS})",
-        f"- Regularization: smooth={SPEED_SMOOTH_WEIGHT:.2f}, center={SPEED_CENTER_WEIGHT:.2f}",
-        f"- BFO points: **{n_bfo}** | RMSE_BFO: **{rmse_bfo:.2f} Hz**",
-        f"- BTO points: **{n_bto}** | RMSE_BTO: **{rmse_bto:.1f} µs**" if rmse_bto is not None else
-        f"- BTO points: **{n_bto}** | RMSE_BTO: n/a",
+        "**Guided mode: Straight + drift + computed turn (18:22→18:40), clipped to 00:20**",
+        f"- Search mode: **two-stage (coarse → refine)**",
+        f"- Southern speed (speed profile): **{float(south_speed_knots):.1f} kt**",
+        f"- Best turn speed (18:22→18:40): **{float(best_turn_spd):.1f} kt**",
+        f"- Best nominal heading: **{best_h0:.1f}°**",
+        f"- Drift used: **{best_d:+.1f}°** | Drift penalty weight: **{float(drift_weight):.2f}**",
+        f"- BFO points: **{best_score['n_bfo']}** | RMSE_BFO: **{best_score['rmse_bfo']:.2f} Hz**",
+        f"- BTO points: **{best_score['n_bto']}** | RMSE_BTO: **{best_score['rmse_bto']:.1f} µs**" if best_score.get("rmse_bto") is not None else
+        f"- BTO points: **{best_score['n_bto']}** | RMSE_BTO: n/a",
     ])
 
-    return full_legs, report, start_dt
+    return best_full_legs, report, start_dt
 
 
 # ================= RUNNERS =================
 def _run_common(start_lat, start_lon, legs, method, start_dt, alt_ft, vs_fpm, descent_start_choice):
+    # In guided mode, ensure the polyline ends at 00:20 by clipping legs to end_dt first.
     if start_dt == RADAR_FIX_TIME_UTC:
         end_dt = _dt_from_label(GUIDED_FINAL_LABEL)
         legs = clip_legs_to_end_dt(legs, start_dt, end_dt)
@@ -1542,6 +1539,7 @@ def _run_common(start_lat, start_lon, legs, method, start_dt, alt_ft, vs_fpm, de
     html_map = build_leaflet_map(path_pts, legs, method, start_dt)
     stats_md = compute_stats(path_pts, seg_dists_m, total_time_min, legs)
 
+    # BFO plot (restored)
     bfo_fig, bfo_md = bfo_analysis_with_legs(
         start_lat, start_lon, legs, method, start_dt, alt_ft, vs_fpm, descent_start_choice
     )
@@ -1572,13 +1570,26 @@ def run_sim_manual(start_lat, start_lon, legs_df, method, start_time_str, alt_ft
 
 def run_guided(
     start_lat, start_lon, method, alt_ft, vs_fpm, descent_start_choice,
-    weight_bfo, weight_bto
+    speed_profile, custom_mach, custom_knots, guided_scenario,
+    weight_bfo, weight_bto,
+    drift_max_deg, drift_weight
 ):
-    legs, report_md, start_dt = solve_guided_straight(
-        method,
-        alt_ft, vs_fpm,
-        descent_start_choice, weight_bfo, weight_bto
-    )
+    # This is the SOUTHERN cruise speed (post-18:40). Turn speed is searched independently.
+    south_spd_knots = speed_from_profile(speed_profile, alt_ft, custom_mach, custom_knots)
+
+    if (guided_scenario or "").startswith("Straight + drift"):
+        legs, report_md, start_dt = solve_guided_straight_with_drift(
+            method, south_spd_knots,
+            alt_ft, vs_fpm,
+            descent_start_choice, weight_bfo, weight_bto,
+            drift_max_deg, drift_weight
+        )
+    else:
+        legs, report_md, start_dt = solve_guided_straight(
+            method, south_spd_knots,
+            alt_ft, vs_fpm,
+            descent_start_choice, weight_bfo, weight_bto
+        )
 
     if legs is None:
         fig = go.Figure()
@@ -1592,6 +1603,7 @@ def run_guided(
         ], value=[])
         return gr.update(), f"### ❌ {report_md}", "", "", fig, "", alt_fig, empty_table
 
+    # Guided always starts at radar fix
     html_map, stats_md, bfo_fig, bfo_md, alt_fig, headers, rows = _run_common(
         RADAR_FIX_LAT, RADAR_FIX_LON, legs, method, start_dt, alt_ft, vs_fpm, descent_start_choice
     )
@@ -1623,10 +1635,8 @@ with gr.Blocks() as demo:
         f"- **Turn completion (fixed):** 18:40:00Z\n"
         f"- **Initial track (fixed):** {RADAR_INITIAL_TRACK_DEG:.1f}°\n"
         f"- **Final resting point:** **00:20:00Z** (trajectory clipped exactly at this time)\n\n"
-        f"**Turn speed bounds:** **{TURN_SPEED_MIN_ABS_KT:.0f}–{TURN_SPEED_MAX_ABS_KT:.0f} kt**\n"
-        f"**Southern speed bounds:** **{SOUTH_SPEED_MIN_ABS_KT:.0f}–{SOUTH_SPEED_MAX_ABS_KT:.0f} kt** (center {SOUTH_SPEED_CENTER_GUESS_KT:.0f})\n"
-        f"**Scoring pings:** **{', '.join(GUIDED_SCORE_LABELS)}** (00:20 excluded)\n"
-        f"**Performance:** seed_prune_topk={SEED_PRUNE_TOPK}, opt_maxiter={OPT_MAXITER}, cache_cap={CACHE_MAX_ITEMS}"
+        f"**Turn behavior:** 18:22→18:40 turn is solved with **adjustable turn speed**.\n"
+        f"**Performance:** guided solver uses **two-stage search (coarse → refine)** to run faster."
     )
 
     with gr.Row():
@@ -1645,8 +1655,28 @@ with gr.Blocks() as demo:
             label="When does descent start? (VS applies after this time)",
         )
 
-    gr.Markdown("### Guided mode (Straight only)")
-    gr.Markdown("- Optimizer-based (L-BFGS-B) with fast seed pruning + caching.")
+    gr.Markdown("### Guided mode (Recommended)")
+    with gr.Row():
+        guided_scenario = gr.Dropdown(
+            [
+                "Straight (single heading)",
+                "Straight + drift (per-leg ±deg, penalized)",
+            ],
+            value="Straight (single heading)",
+            label="Scenario",
+        )
+        speed_profile = gr.Dropdown(
+            ["MRC Mach 0.82", "LRC Mach 0.84", "ECON Mach 0.80", "Custom Mach", "Custom knots"],
+            value="MRC Mach 0.82",
+            label="Speed profile (sets SOUTHERN speed after 18:40)",
+        )
+        custom_mach = gr.Number(value=0.82, label="Custom Mach (if selected)")
+        custom_knots = gr.Number(value=470, label="Custom knots (if selected)")
+
+    gr.Markdown("### Heading drift settings (for “Straight + drift” scenario)")
+    with gr.Row():
+        drift_max_deg = gr.Slider(0.0, 5.0, value=DEFAULT_DRIFT_MAX_DEG, step=0.1, label="Max drift per leg (±deg)")
+        drift_weight = gr.Slider(0.0, 2.0, value=DEFAULT_WEIGHT_DRIFT, step=0.05, label="Drift penalty weight (higher = less drift)")
 
     gr.Markdown("### Guided scoring weights")
     with gr.Row():
@@ -1654,7 +1684,7 @@ with gr.Blocks() as demo:
         weight_bto = gr.Slider(0.0, 10.0, value=DEFAULT_WEIGHT_BTO, step=0.1, label="Weight: BTO (increase to emphasize BTO)")
 
     with gr.Row():
-        guided_btn = gr.Button("Generate: Guided (Straight)")
+        guided_btn = gr.Button("Generate: Guided scenario")
         manual_btn = gr.Button("Simulate: Manual legs")
 
     status_md = gr.Markdown()
@@ -1701,7 +1731,9 @@ with gr.Blocks() as demo:
         run_guided,
         inputs=[
             start_lat, start_lon, method, alt_ft, vs_fpm, descent_start_choice,
-            weight_bfo, weight_bto
+            speed_profile, custom_mach, custom_knots, guided_scenario,
+            weight_bfo, weight_bto,
+            drift_max_deg, drift_weight
         ],
         outputs=[legs_df, status_md, out_map, stats, bfo_plot, bfo_score, alt_plot, validation_df],
     )