Update app.py

app.py

@@ -17,18 +17,22 @@
 # 2) Restore BFO plot (it disappeared previously)
 #    - Re-added full BFO analysis computation + chart + MAE/RMSE markdown.
 #
-# NEW (PREVIOUS UPDATE):
+# 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.
 #
-# NEW (THIS UPDATE):
+# PREVIOUS 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
+#
+# NEW (THIS UPDATE):
+# 5) Southern trajectory speed is NO LONGER locked to a fixed speed profile.
+#    - The guided solver now searches BOTH:
+#        - southern heading
+#        - southern speed (free variable)
+#        - turn speed (18:22→18:40)
+#      to best match BFO + BTO (with your weights).
+#    - “Speed profile” in UI becomes an INITIAL GUESS (center of the search window).
 
 import os
 import re
@@ -119,12 +123,20 @@ TURN_BANK_MAX_DEG = 30.0
 TURN_BANK_DEFAULT_DEG = 25.0
 TURN_STEP_SEC = 30.0
 
-# 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 search parameters (turn only)
+TURN_SPEED_SEARCH_DELTA_KT = 40.0     # search ± around the candidate southern 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
 
+# Southern-speed search parameters (NEW: southern speed is free)
+SOUTH_SPEED_SEARCH_DELTA_KT = 80.0    # search ± around the UI "speed profile" initial guess
+SOUTH_SPEED_MIN_ABS_KT = 330.0        # hard min plausible
+SOUTH_SPEED_MAX_ABS_KT = 530.0        # hard max plausible
+SOUTH_SPEED_STEP_KT = 2.5             # refined step
+COARSE_SOUTH_SPEED_STEP_KT = 10.0     # coarse step
+REFINE_SOUTH_SPEED_HALF_WINDOW_KT = 12.5  # refine window around best
+
 # Guided heading search (south-ish)
 GUIDED_HEADING_MIN = 150.0
 GUIDED_HEADING_MAX = 210.0
@@ -140,7 +152,7 @@ DEFAULT_WEIGHT_DRIFT = 0.30
 DEFAULT_DRIFT_ITERS = 2
 DRIFT_SCALE_DEG = 1.0
 
-# ===== NEW: Two-stage search knobs =====
+# ===== Two-stage search knobs =====
 # Stage 1 (coarse)
 COARSE_HEADING_STEP_DEG = 2.0
 COARSE_TURN_SPEED_STEP_KT = 10.0
@@ -1132,7 +1144,7 @@ def build_leaflet_map(path_pts, legs, method, start_dt):
     """
 
 
-# ================= Guided Speed Profile =================
+# ================= Guided Speed Profile (UI initial guess) =================
 def isa_speed_of_sound_mps(alt_m: float) -> float:
     T0 = 288.15
     L = -0.0065
@@ -1170,7 +1182,7 @@ def speed_from_profile(profile: str, alt_ft: float, custom_mach: float, custom_k
 
 def _turn_speed_candidates(south_speed_knots: float, step_kt: float):
     """
-    Plausible turn-speed candidates around the southern cruise speed.
+    Plausible turn-speed candidates around the candidate southern speed.
     Hard-clipped to [TURN_SPEED_MIN_ABS_KT, TURN_SPEED_MAX_ABS_KT].
     """
     base = float(south_speed_knots)
@@ -1180,7 +1192,24 @@ def _turn_speed_candidates(south_speed_knots: float, step_kt: float):
     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 _south_speed_candidates(base_guess_knots: float, step_kt: float):
+    """
+    Southern speed candidates around the UI profile-derived guess.
+    Hard-clipped to [SOUTH_SPEED_MIN_ABS_KT, SOUTH_SPEED_MAX_ABS_KT].
+    """
+    base = float(base_guess_knots)
+    lo = max(SOUTH_SPEED_MIN_ABS_KT, base - float(SOUTH_SPEED_SEARCH_DELTA_KT))
+    hi = min(SOUTH_SPEED_MAX_ABS_KT, base + float(SOUTH_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))
     if all(abs(c - base) > 1e-9 for c in cand):
         cand.append(base)
     cand = sorted({round(float(c), 6) for c in cand})
@@ -1192,13 +1221,11 @@ def _clamp(x, lo, hi):
 
 
 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
 
@@ -1229,7 +1256,6 @@ def score_legs_bfo_bto(
     weight_bfo: float, weight_bto: float,
     pts_window=None
 ):
-    # 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]
@@ -1308,28 +1334,25 @@ def _guided_start_dt():
 
 
 def solve_guided_straight(
-    method, south_speed_knots, alt_ft, vs_fpm,
+    method, south_speed_guess_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)
 
-    # 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)
+    def try_candidate(h_south: float, spd_south: float, spd_turn: float):
+        southern_legs = make_legs_from_schedule(h_south, float(spd_south), GUIDED_LEG_SCHEDULE_MIN)
         preturn_legs, _turn_info = build_turn_legs(
             speed_knots=float(spd_turn),
             method=method,
@@ -1337,6 +1360,7 @@ def solve_guided_straight(
         )
         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,
@@ -1345,48 +1369,67 @@ def solve_guided_straight(
         )
         return s, full_legs
 
-    # -------- Stage 1: COARSE search --------
+    # -------- Stage 1: COARSE search (heading + south speed + turn speed) --------
     best_h = None
+    best_south_spd = None
     best_turn_spd = None
     best_full_legs = None
     best_score = None
 
     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)
+    coarse_south_speeds = _south_speed_candidates(float(south_speed_guess_knots), COARSE_SOUTH_SPEED_STEP_KT)
 
     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
+        for spd_south in coarse_south_speeds:
+            coarse_turn_speeds = _turn_speed_candidates(float(spd_south), COARSE_TURN_SPEED_STEP_KT)
+            for spd_turn in coarse_turn_speeds:
+                s, legs = try_candidate(h, spd_south, 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_south_spd = float(spd_south)
+                    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),
+    refine_headings = _refine_range(
+        best_h, REFINE_HEADING_HALF_WINDOW_DEG, STRAIGHT_STEP_DEG, GUIDED_HEADING_MIN, GUIDED_HEADING_MAX
+    )
+
+    refine_south_speeds = _refine_range(
+        best_south_spd, REFINE_SOUTH_SPEED_HALF_WINDOW_KT, SOUTH_SPEED_STEP_KT,
+        max(SOUTH_SPEED_MIN_ABS_KT, float(south_speed_guess_knots) - SOUTH_SPEED_SEARCH_DELTA_KT),
+        min(SOUTH_SPEED_MAX_ABS_KT, float(south_speed_guess_knots) + SOUTH_SPEED_SEARCH_DELTA_KT),
     )
+    if not refine_south_speeds:
+        refine_south_speeds = [best_south_spd]
 
     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
+        for spd_south in refine_south_speeds:
+            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(spd_south) - TURN_SPEED_SEARCH_DELTA_KT),
+                min(TURN_SPEED_MAX_ABS_KT, float(spd_south) + TURN_SPEED_SEARCH_DELTA_KT),
+            )
+            if not refine_turn_speeds:
+                refine_turn_speeds = [best_turn_spd]
+
+            for spd_turn in refine_turn_speeds:
+                s, legs = try_candidate(h, spd_south, 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_south_spd = float(spd_south)
+                    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**",
         f"- Search mode: **two-stage (coarse → refine)**",
-        f"- Southern speed (speed profile): **{float(south_speed_knots):.1f} kt**",
+        f"- Southern speed (solved): **{float(best_south_spd):.1f} kt** (UI guess was ~{float(south_speed_guess_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**",
@@ -1398,21 +1441,19 @@ def solve_guided_straight(
 
 
 def solve_guided_straight_with_drift(
-    method, south_speed_knots, alt_ft, vs_fpm,
+    method, south_speed_guess_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)
 
-    # 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:
@@ -1420,10 +1461,10 @@ def solve_guided_straight_with_drift(
 
     drift_max_deg = float(drift_max_deg)
 
-    def try_candidate(h0_nominal: float, drift_deg: float, spd_turn: float):
+    def try_candidate(h0_nominal: float, drift_deg: float, spd_south: float, spd_turn: float):
         h_eff = _wrap_heading_deg(float(h0_nominal) + float(drift_deg))
 
-        southern_legs = make_legs_from_schedule(h_eff, float(south_speed_knots), GUIDED_LEG_SCHEDULE_MIN)
+        southern_legs = make_legs_from_schedule(h_eff, float(spd_south), GUIDED_LEG_SCHEDULE_MIN)
         preturn_legs, _turn_info = build_turn_legs(
             speed_knots=float(spd_turn),
             method=method,
@@ -1447,6 +1488,7 @@ def solve_guided_straight_with_drift(
     # -------- Stage 1: COARSE search --------
     best_h0 = None
     best_d = None
+    best_south_spd = None
     best_turn_spd = None
     best_full_legs = None
     best_score = None
@@ -1454,7 +1496,6 @@ def solve_guided_straight_with_drift(
 
     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:
@@ -1463,21 +1504,24 @@ def solve_guided_straight_with_drift(
             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)
+    coarse_south_speeds = _south_speed_candidates(float(south_speed_guess_knots), COARSE_SOUTH_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
+            for spd_south in coarse_south_speeds:
+                coarse_turn_speeds = _turn_speed_candidates(float(spd_south), COARSE_TURN_SPEED_STEP_KT)
+                for spd_turn in coarse_turn_speeds:
+                    s, combined_plus, legs = try_candidate(h0, d, spd_south, 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_south_spd = float(spd_south)
+                        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
@@ -1485,37 +1529,42 @@ def solve_guided_straight_with_drift(
     # -------- 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),
-    )
+    refine_drifts = _frange(d_lo, d_hi, DRIFT_STEP_DEG) or [best_d]
+
+    refine_south_speeds = _refine_range(
+        best_south_spd, REFINE_SOUTH_SPEED_HALF_WINDOW_KT, SOUTH_SPEED_STEP_KT,
+        max(SOUTH_SPEED_MIN_ABS_KT, float(south_speed_guess_knots) - SOUTH_SPEED_SEARCH_DELTA_KT),
+        min(SOUTH_SPEED_MAX_ABS_KT, float(south_speed_guess_knots) + SOUTH_SPEED_SEARCH_DELTA_KT),
+    ) or [best_south_spd]
 
     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
+            for spd_south in refine_south_speeds:
+                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(spd_south) - TURN_SPEED_SEARCH_DELTA_KT),
+                    min(TURN_SPEED_MAX_ABS_KT, float(spd_south) + TURN_SPEED_SEARCH_DELTA_KT),
+                ) or [best_turn_spd]
+
+                for spd_turn in refine_turn_speeds:
+                    s, combined_plus, legs = try_candidate(h0, d, spd_south, 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_south_spd = float(spd_south)
+                        best_turn_spd = float(spd_turn)
+                        best_full_legs = legs
 
     report = "\n".join([
         "**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"- Southern speed (solved): **{float(best_south_spd):.1f} kt** (UI guess was ~{float(south_speed_guess_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}**",
@@ -1529,7 +1578,6 @@ def solve_guided_straight_with_drift(
 
 # ================= 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)
@@ -1539,7 +1587,6 @@ 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
     )
@@ -1574,19 +1621,19 @@ def run_guided(
     weight_bfo, weight_bto,
     drift_max_deg, drift_weight
 ):
-    # 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)
+    # UI speed profile now acts as an INITIAL GUESS (center of southern speed search window)
+    south_speed_guess = 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,
+            method, south_speed_guess,
             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,
+            method, south_speed_guess,
             alt_ft, vs_fpm,
             descent_start_choice, weight_bfo, weight_bto
         )
@@ -1603,7 +1650,6 @@ 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
     )
@@ -1636,7 +1682,8 @@ with gr.Blocks() as demo:
         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 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."
+        f"**Southern behavior:** after 18:40, **southern speed is solved (free)** to best match BFO+BTO.\n"
+        f"**Performance:** guided solver uses **two-stage search (coarse → refine)**."
     )
 
     with gr.Row():
@@ -1668,7 +1715,7 @@ with gr.Blocks() as demo:
         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)",
+            label="Speed profile (INITIAL GUESS only — solver will choose best southern speed)",
         )
         custom_mach = gr.Number(value=0.82, label="Custom Mach (if selected)")
         custom_knots = gr.Number(value=470, label="Custom knots (if selected)")