Update app.py

app.py

@@ -19,17 +19,18 @@
 # TURN MODEL:
 # 3) Plausible final major turn (18:22→18:40) can adjust BOTH heading and speed
 #
-# SPEED MODEL (UPDATED):
+# 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.
 #
-# REQUESTED CHANGE (THIS UPDATE):
-# - Mirror the optimizer structure (continuous optimization with bounds) instead of beam search.
-#   We now solve for: [south_heading, turn_speed, v1, v2]
-#   using scipy.optimize.minimize (L-BFGS-B), with multi-start from a coarse grid.
+# 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:
@@ -51,6 +52,7 @@ import plotly.graph_objects as go
 
 import flight_plotter_v32 as fp
 
+# Requires SciPy installed in your HF Space
 from scipy.optimize import minimize
 
 
@@ -100,7 +102,6 @@ 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)
 
 # Initial track shown in your radar annotation
@@ -118,7 +119,21 @@ GUIDED_VALIDATION_LABELS = [
     "24:20:00",  # 00:20Z (final)
 ]
 GUIDED_FINAL_LABEL = "24:20:00"  # 00:20Z FINAL RESTING POINT
-GUIDED_SCORE_EXCLUDE_LABELS = {GUIDED_FINAL_LABEL}  # ignore 24:20 in scoring
+
+# 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
@@ -126,13 +141,11 @@ TURN_BANK_MAX_DEG = 30.0
 TURN_BANK_DEFAULT_DEG = 25.0
 TURN_STEP_SEC = 30.0
 
-# Turn speed search parameters (UPDATED per request)
-TURN_SPEED_SEARCH_DELTA_KT = 40.0
-TURN_SPEED_STEP_KT = 5.0
+# Turn speed bounds
 TURN_SPEED_MIN_ABS_KT = 470.0
 TURN_SPEED_MAX_ABS_KT = 500.0
 
-# Southern speed settings (2 segments + final display leg)
+# Southern speed bounds (2 segments)
 SOUTH_SPEED_CENTER_GUESS_KT = 445.0
 SOUTH_SPEED_MIN_ABS_KT = 440.0
 SOUTH_SPEED_MAX_ABS_KT = 450.0
@@ -152,9 +165,16 @@ SPEED_CENTER_WEIGHT = 0.01
 GUIDED_HEADING_MIN = 150.0
 GUIDED_HEADING_MAX = 210.0
 
-# ===== Multi-start seed grid knobs (still cheap) =====
+# ===== 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
+
+# Optimizer iterations
+OPT_MAXITER = 160  # lower than before (faster), usually enough with good seeds
+
+# Cache controls
+CACHE_MAX_ITEMS = 50000  # safety cap
 
 # Search area colors
 SEARCH_AREA_COLORS = {
@@ -671,7 +691,6 @@ def _map_marker_times(start_dt, legs):
     return times
 
 
-# ================= FAST PATH EVALUATOR (for optimizer) =================
 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.
@@ -1162,54 +1181,44 @@ def build_leaflet_map(path_pts, legs, method, start_dt):
     """
 
 
-# ================= SCORING HELPERS =================
-def _build_pts_window_for_guided(start_dt: datetime, end_dt: datetime):
-    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]
-    pts_window = [(lbl, dt, bfo, bto) for (lbl, dt, bfo, bto) in pts_window if lbl not in GUIDED_SCORE_EXCLUDE_LABELS]
-    return pts_window
-
-
-def _regularization_speed(v1: float, v2: float) -> float:
-    # center + smooth penalties (kept light)
-    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)
-
-
-def _compute_residuals_at_point(
-    method: str,
-    lat: float,
-    lon: float,
-    hdg_deg: float,
-    spd_knots: float,
-    dt_ping: datetime,
-    alt_ft: float,
-    vs_fpm: float,
-    descent_start_dt: datetime | None,
-):
-    alt_now_ft = altitude_ft_at_dt(dt_ping, RADAR_FIX_TIME_UTC, 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
-
-    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)
-
-    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))
-    return r_bfo, r_bto
+# ================= Guided scoring point selection =================
+def _score_points_for_labels(labels: list[str]):
+    """
+    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).
+    """
+    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])
+    return out
 
 
-# ================= Guided Solver (OPTIMIZER MIRROR) =================
+# ================= Guided Solver (OPTIMIZER MIRROR + FAST) =================
 def solve_guided_straight(
     method, alt_ft, vs_fpm,
     descent_start_choice, weight_bfo, weight_bto
@@ -1223,58 +1232,116 @@ def solve_guided_straight(
     elif (descent_start_choice or "").startswith("After Ping Ring 7"):
         descent_start_dt = dt_ping7_utc()
 
-    pts_window = _build_pts_window_for_guided(start_dt, end_dt)
-    if len(pts_window) < 2:
-        return None, "Guided solve: not enough ping points to score.", 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)
+        alt_m = alt_now_ft * 0.3048
 
-    # --- Objective: weighted normalized SSE across ping points (excluding 00:20) ---
-    def objective(x):
-        # x = [h_south, spd_turn, v1, v2]
+        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
+
+        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
+
+        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)
+
+        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))
+
+        _cache_put(key, (r_bfo, r_bto))
+        return r_bfo, r_bto
+
+    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)
+
+    def _build_legs_for_params(h_south, spd_turn, v1, v2, full=False):
+        turn_legs, _ = 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])
 
-        # Build legs: turn (18:22->18:40) based on final heading & turn speed
-        turn_legs, _info = build_turn_legs(
-            speed_knots=spd_turn,
-            method=method,
-            heading_final_deg=h_south,
-        )
-        if not turn_legs:
+        legs_score = _build_legs_for_params(h_south, spd_turn, v1, v2, full=False)
+        if legs_score is None:
             return 1e12
 
-        # Southern legs for scoring window only (18:40->00:10)
-        south_legs_score = [
-            (h_south, v1, float(SOUTH_SCHEDULE_SCORE_MIN[0])),
-            (h_south, v2, float(SOUTH_SCHEDULE_SCORE_MIN[1])),
-        ]
-
-        # Composite legs up to 00:10 scoring horizon
-        legs_score = turn_legs + south_legs_score
-
-        # Evaluator for states at ping times
         state_at = _make_state_evaluator(RADAR_FIX_LAT, RADAR_FIX_LON, legs_score, method, start_dt)
 
-        # Weighted normalized sum of squares
         sse = 0.0
         n_used = 0
 
-        for (_lbl, dt_ping, _mbfo, _mbto) in pts_window:
+        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(
-                method=method,
-                lat=st["lat"],
-                lon=st["lon"],
-                hdg_deg=st["heading_deg"],
-                spd_knots=st["speed_kt"],
-                dt_ping=dt_ping,
-                alt_ft=alt_ft,
-                vs_fpm=vs_fpm,
-                descent_start_dt=descent_start_dt,
+            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:
@@ -1287,38 +1354,45 @@ def solve_guided_straight(
         if n_used == 0:
             return 1e12
 
-        # Light regularization (speed)
         sse += _regularization_speed(v1, v2)
-
         return float(sse) / float(n_used)
 
+    # Full objective (strict scoring pings)
+    def objective(x):
+        return _objective_on_pts(x, pts_score)
+
     # Bounds (mirrors bounded optimizer style)
     bounds = [
-        (GUIDED_HEADING_MIN, GUIDED_HEADING_MAX),      # h_south
-        (TURN_SPEED_MIN_ABS_KT, TURN_SPEED_MAX_ABS_KT),# spd_turn
-        (SOUTH_SPEED_MIN_ABS_KT, SOUTH_SPEED_MAX_ABS_KT), # v1
-        (SOUTH_SPEED_MIN_ABS_KT, SOUTH_SPEED_MAX_ABS_KT), # v2
+        (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
     ]
 
-    # Multi-start seeds (coarse grid only for initialization, then continuous optimize)
+    # ===== 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)
 
-    # Keep seed count reasonable
-    seeds = []
+    seed_scores = []
     for h in coarse_headings:
         for spd in coarse_turn_speeds:
-            seeds.append([float(h), float(spd), float(SOUTH_SPEED_CENTER_GUESS_KT), float(SOUTH_SPEED_CENTER_GUESS_KT)])
+            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)))
 
-    best_res = None
+    seed_scores.sort(key=lambda t: t[0])
+    top = seed_scores[:max(1, int(SEED_PRUNE_TOPK))]
 
-    for x0 in seeds:
+    # ===== 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=np.array(x0, dtype=float),
+            x0=x0,
             method="L-BFGS-B",
             bounds=bounds,
-            options={"maxiter": 250, "ftol": 1e-9},
+            options={"maxiter": int(OPT_MAXITER), "ftol": 1e-9},
         )
         if not np.isfinite(res.fun):
             continue
@@ -1333,31 +1407,13 @@ def solve_guided_straight(
     v1_best = float(best_res.x[2])
     v2_best = float(best_res.x[3])
 
-    # Build final legs for display through 00:20 (00:20 excluded from scoring, but shown)
-    preturn_legs, _turn_info = build_turn_legs(
-        speed_knots=float(spd_turn_best),
-        method=method,
-        heading_final_deg=float(h_best),
-    )
-
-    full_southern = [
-        (float(h_best), float(v1_best), float(SOUTH_SCHEDULE_FULL_MIN[0])),
-        (float(h_best), float(v2_best), float(SOUTH_SCHEDULE_FULL_MIN[1])),
-        (float(h_best), float(v2_best), float(SOUTH_SCHEDULE_FULL_MIN[2])),
-    ]
-
-    full_legs = preturn_legs + full_southern
+    # 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 final RMSEs for reporting (on scoring window)
-    # We evaluate on the same objective components, but report RMSE separately
-    # using raw residuals for BFO and BTO.
-    def final_metrics(h_south, spd_turn, v1, v2):
-        turn_legs, _ = build_turn_legs(spd_turn, method, h_south)
-        legs_score = turn_legs + [
-            (h_south, v1, float(SOUTH_SCHEDULE_SCORE_MIN[0])),
-            (h_south, v2, float(SOUTH_SCHEDULE_SCORE_MIN[1])),
-        ]
+    # 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
@@ -1365,20 +1421,12 @@ def solve_guided_straight(
         n_bfo = 0
         n_bto = 0
 
-        for (_lbl, dt_ping, _mbfo, _mbto) in pts_window:
+        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(
-                method=method,
-                lat=st["lat"],
-                lon=st["lon"],
-                hdg_deg=st["heading_deg"],
-                spd_knots=st["speed_kt"],
-                dt_ping=dt_ping,
-                alt_ft=alt_ft,
-                vs_fpm=vs_fpm,
-                descent_start_dt=descent_start_dt,
+            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
@@ -1391,12 +1439,13 @@ def solve_guided_straight(
         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(h_best, spd_turn_best, v1_best, v2_best)
+    n_bfo, n_bto, rmse_bfo, rmse_bto = final_metrics()
 
     report = "\n".join([
         "**Guided mode: Straight + computed turn (18:22→18:40), clipped to 00:20**",
-        "- Optimizer: **scipy.optimize.minimize (L-BFGS-B)** with bounded variables (multi-start seeds)",
-        f"- Scoring excludes **00:20 (24: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:",
@@ -1406,6 +1455,7 @@ def solve_guided_straight(
         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
@@ -1509,8 +1559,8 @@ with gr.Blocks() as demo:
         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 note:** **00:20 is excluded** from scoring and its measured values are removed from the validation table.\n"
-        f"**Solver:** bounded optimizer (L-BFGS-B) on [heading, turn speed, v1, v2] with coarse multi-start seeds."
+        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}"
     )
 
     with gr.Row():
@@ -1530,7 +1580,7 @@ with gr.Blocks() as demo:
         )
 
     gr.Markdown("### Guided mode (Straight only)")
-    gr.Markdown("- This build has **only** the straight guided solver (optimizer-based).")
+    gr.Markdown("- Optimizer-based (L-BFGS-B) with fast seed pruning + caching.")
 
     gr.Markdown("### Guided scoring weights")
     with gr.Row():