Update app.py

app.py

@@ -11,17 +11,17 @@
 # - Guided validation timestamps: 18:22, 18:40, 19:40, 20:40, 21:40, 22:40, 00:10, 00:20
 #
 # THIS VERSION:
-# - Guided solver is BTO-first "ring-fit", with fast speed optimization
+# - Guided solver is BTO-first "ring-fit"
 # - IMPORTANT: If a timestamp has no measured BTO (e.g. 18:40 in your satLoc),
 #   the solver automatically does NOT enforce BTO there.
 # - Turn speed range: 470–520 kt
 # - Southern segment speed range: 430–510 kt (per segment)
 # - Waypoints at ping times are driven to ping rings for those timestamps with measured BTO.
 #
-# NEW (per your request):
-# - Adds a fast "global polish" step over the 6 southern segment speeds ONLY
-#   (coordinate descent), to reduce max |BTO error| at enforced endpoints.
-#   This helps when greedy segment-fit hits the speed floor (430 kt) but still leaves residual error.
+# PERFORMANCE UPDATE (Top-K polish):
+# - The expensive “polish” step is NOT run for every candidate anymore.
+# - We search fast first, keep top-K candidates, then polish ONLY those.
+# - This cuts runtime a lot while keeping the good ≤50 µs fits.
 
 import os
 import re
@@ -132,10 +132,13 @@ BTO_TARGET_TIGHT_US = 1.0  # purely informational
 # HARD BTO labels list (will be AUTO-FILTERED to those with measured BTO)
 HARD_BTO_LABELS = ["18:40:00", "19:40:00", "20:40:00", "21:40:00", "22:40:00", "24:10:00", "24:20:00"]
 
-# ===== Global polish (southern speeds only) =====
-POLISH_PASSES = 5              # small number keeps it fast
-POLISH_WINDOW_KT = 6.0         # explore +/- window around current speed
-POLISH_STEP_KT = 1.0           # 1 kt grid within window (fast + robust)
+# ===== Performance knobs: Top-K polish =====
+TOPK_POLISH = 5                 # polish only the best K candidates globally
+ENABLE_POLISH = True            # keep polish, but only for top-K
+POLISH_PASSES = 3               # fewer passes = faster
+POLISH_WINDOW_KT = 6.0          # +/- window around current segment speed
+POLISH_STEP_KT = 2.0            # step for coordinate search
+POLISH_OBJ_EPS = 1e-3           # secondary weight for sum(abs)
 
 # Search area colors (optional)
 SEARCH_AREA_COLORS = {
@@ -1233,118 +1236,127 @@ def _build_south_legs_piecewise(h_south: float, speeds: list[float], minutes: li
     return legs
 
 
-def _simulate_south_endpoints(
+def _compute_bto_errors_at_enforced(
     method: str,
-    lat0: float,
-    lon0: float,
-    hdg: float,
-    speeds: list[float],
-    minutes: list[float],
-):
-    lat, lon = float(lat0), float(lon0)
-    endpoints = []
-    for v, m in zip(speeds, minutes):
-        lat, lon = _simulate_one_leg_end(method, lat, lon, float(hdg), float(v), float(m))
-        endpoints.append((float(lat), float(lon)))
-    return endpoints
-
-
-def _bto_errors_at_south_endpoints(
-    method: str,
-    endpoints: list[tuple[float, float]],
+    start_dt: datetime,
     alt_ft: float,
     vs_fpm: float,
-    start_dt: datetime,
     descent_start_dt: datetime | None,
+    full_legs: list[tuple[float, float, float]],
+    enforced_dts: list[datetime],
 ):
     errs = []
-    labels_used = []
-    for (lat, lon), end_lbl in zip(endpoints, GUIDED_SOUTH_SEG_LABELS_END):
-        dt_end = _dt_from_label(end_lbl)
-        meas = _lookup_measured_bto(dt_end)
+    for dt_k in enforced_dts:
+        meas = _lookup_measured_bto(dt_k)
         if meas is None:
             continue
-        bto = _bto_calc(method, lat, lon, dt_end, alt_ft, vs_fpm, start_dt, descent_start_dt)
-        errs.append(float(bto - meas))
-        labels_used.append(end_lbl)
-    return labels_used, errs
-
-
-def _bto_obj_from_errs(errs: list[float]):
-    if not errs:
-        return None
-    arr = np.array(errs, dtype=float)
-    max_abs = float(np.max(np.abs(arr)))
-    sum_abs = float(np.sum(np.abs(arr)))
-    rmse = float(np.sqrt(np.mean(arr * arr)))
-    # primary max abs, secondary sum abs
-    score = float(max_abs) + 1e-3 * float(sum_abs)
-    return score, max_abs, sum_abs, rmse
+        st = _state_at_dt(RADAR_FIX_LAT, RADAR_FIX_LON, full_legs, method, start_dt, dt_k)
+        if st is None:
+            continue
+        bto_calc = _bto_calc(method, st["lat"], st["lon"], dt_k, alt_ft, vs_fpm, start_dt, descent_start_dt)
+        errs.append(float(bto_calc - meas))
+    return errs
 
 
-def _polish_south_speeds(
+def _polish_south_speeds_topk(
     method: str,
-    lat0: float,
-    lon0: float,
-    hdg: float,
-    speeds_init: list[float],
+    start_dt: datetime,
+    end_dt: datetime,
     alt_ft: float,
     vs_fpm: float,
-    start_dt: datetime,
     descent_start_dt: datetime | None,
+    h_south: float,
+    turn_legs: list[tuple[float, float, float]],
+    enforced_dts: list[datetime],
+    init_speeds: list[float],
+    passes: int = POLISH_PASSES,
+    window_kt: float = POLISH_WINDOW_KT,
+    step_kt: float = POLISH_STEP_KT,
 ):
-    speeds = [float(v) for v in speeds_init]
-    best_endpoints = _simulate_south_endpoints(method, lat0, lon0, hdg, speeds, GUIDED_SOUTH_SEG_MIN)
-    _lbls, errs = _bto_errors_at_south_endpoints(method, best_endpoints, alt_ft, vs_fpm, start_dt, descent_start_dt)
-    obj0 = _bto_obj_from_errs(errs)
-    if obj0 is None:
-        return speeds, errs, {"polish_passes": 0, "improved": False}
+    """
+    Coordinate-descent style "polish" of south speeds:
+    - Adjust one segment at a time within +/- window to reduce objective:
+      max_abs_error + eps * sum_abs_error
+    This is expensive, so we run it ONLY for top-K candidates.
+    """
+    speeds = [float(v) for v in init_speeds]
+
+    # Precompute turn end position (constant for this candidate)
+    pts_turn, _, _ = simulate_path(RADAR_FIX_LAT, RADAR_FIX_LON, turn_legs, method)
+    turn_end_lat, turn_end_lon = float(pts_turn[-1][0]), float(pts_turn[-1][1])
 
-    best_score = obj0[0]
-    improved_any = False
+    def build_full(speeds_now: list[float]):
+        lat_cur, lon_cur = turn_end_lat, turn_end_lon
+        south_errs_local = []
+        for mins, end_lbl, vseg in zip(GUIDED_SOUTH_SEG_MIN, GUIDED_SOUTH_SEG_LABELS_END, speeds_now):
+            dt_end = _dt_from_label(end_lbl)
+            lat_cur, lon_cur = _simulate_one_leg_end(method, lat_cur, lon_cur, h_south, vseg, mins)
+            meas = _lookup_measured_bto(dt_end)
+            if meas is None:
+                south_errs_local.append(float("nan"))
+            else:
+                bto_here = _bto_calc(method, lat_cur, lon_cur, dt_end, alt_ft, vs_fpm, start_dt, descent_start_dt)
+                south_errs_local.append(float(bto_here - meas))
 
-    for _pass in range(int(POLISH_PASSES)):
-        improved_this_pass = False
+        south_legs = _build_south_legs_piecewise(h_south, speeds_now, GUIDED_SOUTH_SEG_MIN)
+        full_legs = clip_legs_to_end_dt(turn_legs + south_legs, start_dt, end_dt)
+        return full_legs, south_errs_local
 
+    def objective(full_legs):
+        bto_errs = _compute_bto_errors_at_enforced(method, start_dt, alt_ft, vs_fpm, descent_start_dt, full_legs, enforced_dts)
+        if not bto_errs:
+            return 1e9, []
+        abs_arr = np.abs(np.array(bto_errs, dtype=float))
+        max_abs = float(np.max(abs_arr))
+        sum_abs = float(np.sum(abs_arr))
+        return float(max_abs + POLISH_OBJ_EPS * sum_abs), bto_errs
+
+    # initial
+    full_legs, south_errs = build_full(speeds)
+    best_obj, best_bto_errs = objective(full_legs)
+    best_speeds = speeds[:]
+    best_full = full_legs
+    best_south_errs = south_errs
+
+    for _p in range(int(passes)):
+        improved_any = False
         for i in range(len(speeds)):
-            v0 = float(speeds[i])
-            v_lo = _clamp(v0 - POLISH_WINDOW_KT, SOUTH_SPEED_MIN_KT, SOUTH_SPEED_MAX_KT)
-            v_hi = _clamp(v0 + POLISH_WINDOW_KT, SOUTH_SPEED_MIN_KT, SOUTH_SPEED_MAX_KT)
+            v0 = float(best_speeds[i])
+            v_lo = _clamp(v0 - float(window_kt), SOUTH_SPEED_MIN_KT, SOUTH_SPEED_MAX_KT)
+            v_hi = _clamp(v0 + float(window_kt), SOUTH_SPEED_MIN_KT, SOUTH_SPEED_MAX_KT)
 
-            cand_vs = _frange(v_lo, v_hi, POLISH_STEP_KT)
-            if not cand_vs:
+            # candidate grid (small)
+            cand = list(np.arange(v_lo, v_hi + 1e-9, float(step_kt)))
+            if not cand:
                 continue
 
-            local_best_v = v0
-            local_best_score = best_score
-
-            # try each candidate on this coordinate
-            for v_try in cand_vs:
-                tmp = speeds[:]
-                tmp[i] = float(v_try)
-                endpoints = _simulate_south_endpoints(method, lat0, lon0, hdg, tmp, GUIDED_SOUTH_SEG_MIN)
-                _lbls2, errs2 = _bto_errors_at_south_endpoints(method, endpoints, alt_ft, vs_fpm, start_dt, descent_start_dt)
-                obj2 = _bto_obj_from_errs(errs2)
-                if obj2 is None:
-                    continue
-                score2 = obj2[0]
-                if score2 + 1e-12 < local_best_score:
-                    local_best_score = score2
-                    local_best_v = float(v_try)
-
-            if local_best_v != v0:
-                speeds[i] = local_best_v
-                best_score = local_best_score
-                improved_this_pass = True
+            local_best_obj = best_obj
+            local_best_speeds = best_speeds[:]
+            local_best_full = best_full
+            local_best_south_errs = best_south_errs
+
+            for v_try in cand:
+                sp = best_speeds[:]
+                sp[i] = float(v_try)
+                full_try, south_errs_try = build_full(sp)
+                obj_try, _ = objective(full_try)
+                if obj_try < local_best_obj - 1e-9:
+                    local_best_obj = obj_try
+                    local_best_speeds = sp
+                    local_best_full = full_try
+                    local_best_south_errs = south_errs_try
+
+            if local_best_obj < best_obj - 1e-9:
+                best_obj = local_best_obj
+                best_speeds = local_best_speeds
+                best_full = local_best_full
+                best_south_errs = local_best_south_errs
                 improved_any = True
 
-        if not improved_this_pass:
+        if not improved_any:
             break
 
-    # final errors for reporting
-    final_endpoints = _simulate_south_endpoints(method, lat0, lon0, hdg, speeds, GUIDED_SOUTH_SEG_MIN)
-    _lbls3, final_errs = _bto_errors_at_south_endpoints(method, final_endpoints, alt_ft, vs_fpm, start_dt, descent_start_dt)
-    return speeds, final_errs, {"polish_passes": int(POLISH_PASSES), "improved": bool(improved_any)}
+    return best_speeds, best_full, best_south_errs
 
 
 # ================= Guided Solver =================
@@ -1372,18 +1384,22 @@ def solve_guided_straight(
 
     enforced_dts = [_dt_from_label(lbl) for lbl in enforced_labels]
 
-    def evaluate_heading_and_turnspeed(h_south: float, v_turn: float):
+    def _evaluate(h_south: float, v_turn: float, do_polish: bool = False):
+        h_south = float(h_south)
+        v_turn = float(v_turn)
+
         # Build turn legs
         turn_legs, turn_info = build_turn_legs(
             speed_knots=float(v_turn),
             method=method,
             heading_final_deg=float(h_south),
         )
+
+        # Find turn end position
         pts_turn, _, _ = simulate_path(RADAR_FIX_LAT, RADAR_FIX_LON, turn_legs, method)
-        lat_turn_end, lon_turn_end = pts_turn[-1]
+        lat_cur, lon_cur = float(pts_turn[-1][0]), float(pts_turn[-1][1])
 
-        # Fit south segments sequentially (greedy per segment)
-        lat_cur, lon_cur = float(lat_turn_end), float(lon_turn_end)
+        # Fit south segments sequentially (per segment speed)
         south_speeds = []
         south_errs = []
         for mins, end_lbl in zip(GUIDED_SOUTH_SEG_MIN, GUIDED_SOUTH_SEG_LABELS_END):
@@ -1406,68 +1422,68 @@ def solve_guided_straight(
             south_errs.append(float(err_seg))
             lat_cur, lon_cur = float(lat1), float(lon1)
 
-        # ---- NEW: global polish on southern segment speeds only ----
-        south_speeds_pol, enforced_errs_pol, polish_info = _polish_south_speeds(
-            method=method,
-            lat0=float(lat_turn_end),
-            lon0=float(lon_turn_end),
-            hdg=float(h_south),
-            speeds_init=south_speeds,
-            alt_ft=alt_ft,
-            vs_fpm=vs_fpm,
-            start_dt=start_dt,
-            descent_start_dt=descent_start_dt,
-        )
-
-        # Build full legs with polished speeds
-        south_legs = _build_south_legs_piecewise(float(h_south), south_speeds_pol, GUIDED_SOUTH_SEG_MIN)
+        # Assemble full legs
+        south_legs = _build_south_legs_piecewise(float(h_south), south_speeds, GUIDED_SOUTH_SEG_MIN)
         full_legs = clip_legs_to_end_dt(turn_legs + south_legs, start_dt, end_dt)
 
-        # Compute BTO errors at enforced timestamps (from full legs for safety)
-        bto_errs = []
-        for dt_k in enforced_dts:
-            meas = _lookup_measured_bto(dt_k)
-            if meas is None:
-                continue
-            st = _state_at_dt(RADAR_FIX_LAT, RADAR_FIX_LON, full_legs, method, start_dt, dt_k)
-            if st is None:
-                continue
-            bto_calc = _bto_calc(method, st["lat"], st["lon"], dt_k, alt_ft, vs_fpm, start_dt, descent_start_dt)
-            bto_errs.append(float(bto_calc - meas))
+        # (Optional) polish only for Top-K
+        if do_polish and ENABLE_POLISH:
+            polished_speeds, polished_full, polished_seg_errs = _polish_south_speeds_topk(
+                method=method,
+                start_dt=start_dt,
+                end_dt=end_dt,
+                alt_ft=alt_ft,
+                vs_fpm=vs_fpm,
+                descent_start_dt=descent_start_dt,
+                h_south=float(h_south),
+                turn_legs=turn_legs,
+                enforced_dts=enforced_dts,
+                init_speeds=south_speeds,
+                passes=POLISH_PASSES,
+                window_kt=POLISH_WINDOW_KT,
+                step_kt=POLISH_STEP_KT,
+            )
+            south_speeds = polished_speeds
+            full_legs = polished_full
+            south_errs = polished_seg_errs
 
+        # Compute BTO errors at enforced timestamps
+        bto_errs = _compute_bto_errors_at_enforced(method, start_dt, alt_ft, vs_fpm, descent_start_dt, full_legs, enforced_dts)
         if not bto_errs:
             return None
 
-        obj = _bto_obj_from_errs(bto_errs)
-        if obj is None:
-            return None
-        _score, max_abs, sum_abs, rmse = obj
+        abs_arr = np.abs(np.array(bto_errs, dtype=float))
+        max_abs = float(np.max(abs_arr))
+        sum_abs = float(np.sum(abs_arr))
+        rmse = float(np.sqrt(np.mean(np.array(bto_errs, dtype=float) ** 2)))
 
         details = {
             "h_south": float(h_south),
             "v_turn": float(v_turn),
-            "south_speeds": [float(v) for v in south_speeds_pol],
-            "south_errs_us": south_errs,  # greedy segment-end err (may include nan if missing meas)
+            "south_speeds": [float(v) for v in south_speeds],
+            "south_errs_us": [float(e) for e in south_errs],
             "turn_info": turn_info,
             "enforced_labels": enforced_labels,
-            "max_abs_err_us": float(max_abs),
-            "sum_abs_err_us": float(sum_abs),
-            "rmse_bto_us": float(rmse),
-            "polish": polish_info,
+            "max_abs_err_us": max_abs,
+            "sum_abs_err_us": sum_abs,
+            "rmse_bto_us": rmse,
+            "polished": bool(do_polish and ENABLE_POLISH),
         }
-        return (max_abs, sum_abs, rmse), full_legs, details
+        # Primary sort: max_abs, then sum_abs, then rmse (stable-ish)
+        key = (max_abs, sum_abs, rmse)
+        return key, full_legs, details
 
     def best_for_heading(h_south: float):
         h_south = float(h_south)
 
-        # Coarse scan turn speed
+        # Coarse scan turn speed (fast)
         coarse_turns = list(np.arange(TURN_SPEED_MIN_KT, TURN_SPEED_MAX_KT + 1e-9, 5.0))
         best_key = None
         best_legs = None
         best_details = None
 
         for v in coarse_turns:
-            out = evaluate_heading_and_turnspeed(h_south, v)
+            out = _evaluate(h_south, v, do_polish=False)
             if out is None:
                 continue
             key, legs, det = out
@@ -1477,20 +1493,20 @@ def solve_guided_straight(
         if best_key is None:
             return None
 
-        # Refine around best coarse speed via golden minimize max_abs_err
+        # Refine around best coarse speed (golden minimize max_abs + eps * sum_abs)
         v0 = float(best_details["v_turn"])
         v_lo = _clamp(v0 - 7.5, TURN_SPEED_MIN_KT, TURN_SPEED_MAX_KT)
         v_hi = _clamp(v0 + 7.5, TURN_SPEED_MIN_KT, TURN_SPEED_MAX_KT)
 
         def obj(v):
-            out2 = evaluate_heading_and_turnspeed(h_south, v)
+            out2 = _evaluate(h_south, v, do_polish=False)
             if out2 is None:
                 return 1e9
             (max_abs, sum_abs, _rmse), _legs, _det = out2
-            return float(max_abs) + 1e-3 * float(sum_abs)
+            return float(max_abs) + POLISH_OBJ_EPS * float(sum_abs)
 
-        v_best, _ = _golden_min_abs(obj, v_lo, v_hi, iters=22)
-        out3 = evaluate_heading_and_turnspeed(h_south, v_best)
+        v_best, _ = _golden_min_abs(obj, v_lo, v_hi, iters=18)
+        out3 = _evaluate(h_south, v_best, do_polish=False)
         if out3 is None:
             return best_key, best_legs, best_details
         key3, legs3, det3 = out3
@@ -1502,11 +1518,15 @@ def solve_guided_straight(
     global_legs = None
     global_det = None
 
+    # Collect candidates for Top-K polish
+    candidates = []  # list of (key, h_south, v_turn)
+
     for h in coarse_headings:
         out = best_for_heading(h)
         if out is None:
             continue
         key, legs, det = out
+        candidates.append((key, float(det["h_south"]), float(det["v_turn"])))
         if global_best is None or key < global_best:
             global_best, global_legs, global_det = key, legs, det
 
@@ -1522,38 +1542,69 @@ def solve_guided_straight(
         if out is None:
             continue
         key, legs, det = out
+        candidates.append((key, float(det["h_south"]), float(det["v_turn"])))
         if global_best is None or key < global_best:
             global_best, global_legs, global_det = key, legs, det
 
+    # ===== Top-K polish ONLY here =====
+    # Sort and unique candidates
+    candidates_sorted = sorted(candidates, key=lambda x: x[0])
+    uniq = []
+    seen = set()
+    for key, hh, vv in candidates_sorted:
+        k2 = (round(hh, 4), round(vv, 4))
+        if k2 in seen:
+            continue
+        seen.add(k2)
+        uniq.append((key, hh, vv))
+        if len(uniq) >= max(1, int(TOPK_POLISH)):
+            break
+
+    # Start from best unpolished
+    best_final_key = global_best
+    best_final_legs = global_legs
+    best_final_det = global_det
+
+    if ENABLE_POLISH and uniq:
+        for _key, hh, vv in uniq:
+            outp = _evaluate(hh, vv, do_polish=True)
+            if outp is None:
+                continue
+            keyp, legsp, detp = outp
+            if best_final_key is None or keyp < best_final_key:
+                best_final_key = keyp
+                best_final_legs = legsp
+                best_final_det = detp
+
     # Reporting
-    south_speeds = global_det["south_speeds"]
-    greedy_seg_end_errs = global_det["south_errs_us"]
-    polish_info = global_det.get("polish", {}) or {}
+    south_speeds = best_final_det["south_speeds"]
+    south_errs = best_final_det["south_errs_us"]
+    polished_flag = best_final_det.get("polished", False)
 
     report_lines = [
         "**Guided mode: Straight + computed turn (18:22→18:40), clipped to 00:20**",
-        "- Solver mode: **BTO-first ring-fit (fast) + global polish (southern speeds)**",
-        f"- Best southern heading: **{global_det['h_south']:.2f}°**",
-        f"- Turn speed range: {TURN_SPEED_MIN_KT:.0f}–{TURN_SPEED_MAX_KT:.0f} kt | Best: **{global_det['v_turn']:.2f} kt**",
-        "",
-        f"**Polish:** passes={POLISH_PASSES}, window=±{POLISH_WINDOW_KT:.0f} kt, step={POLISH_STEP_KT:.0f} kt | improved={polish_info.get('improved', False)}",
+        "- Solver mode: **BTO-first ring-fit**",
+        f"- Best southern heading: **{best_final_det['h_south']:.2f}°**",
+        f"- Turn speed range: {TURN_SPEED_MIN_KT:.0f}–{TURN_SPEED_MAX_KT:.0f} kt | Best: **{best_final_det['v_turn']:.2f} kt**",
+        f"- Polish: **{'ON (Top-K only)' if ENABLE_POLISH else 'OFF'}** | Applied to winner: **{'YES' if polished_flag else 'NO'}**",
         "",
         "**Southern per-segment speeds (each constrained to 430–510 kt):**",
-        f"- 18:40→19:40: **{south_speeds[0]:.2f} kt** (greedy end err {greedy_seg_end_errs[0]:+.2f} µs)",
-        f"- 19:40→20:40: **{south_speeds[1]:.2f} kt** (greedy end err {greedy_seg_end_errs[1]:+.2f} µs)",
-        f"- 20:40→21:40: **{south_speeds[2]:.2f} kt** (greedy end err {greedy_seg_end_errs[2]:+.2f} µs)",
-        f"- 21:40→22:40: **{south_speeds[3]:.2f} kt** (greedy end err {greedy_seg_end_errs[3]:+.2f} µs)",
-        f"- 22:40→00:10: **{south_speeds[4]:.2f} kt** (greedy end err {greedy_seg_end_errs[4]:+.2f} µs)",
-        f"- 00:10→00:20: **{south_speeds[5]:.2f} kt** (greedy end err {greedy_seg_end_errs[5]:+.2f} µs)",
+        f"- 18:40→19:40: **{south_speeds[0]:.2f} kt** (segment end err {south_errs[0]:+.2f} µs)",
+        f"- 19:40→20:40: **{south_speeds[1]:.2f} kt** (segment end err {south_errs[1]:+.2f} µs)",
+        f"- 20:40→21:40: **{south_speeds[2]:.2f} kt** (segment end err {south_errs[2]:+.2f} µs)",
+        f"- 21:40→22:40: **{south_speeds[3]:.2f} kt** (segment end err {south_errs[3]:+.2f} µs)",
+        f"- 22:40→00:10: **{south_speeds[4]:.2f} kt** (segment end err {south_errs[4]:+.2f} µs)",
+        f"- 00:10→00:20: **{south_speeds[5]:.2f} kt** (segment end err {south_errs[5]:+.2f} µs)",
         "",
-        f"- Enforced BTO timestamps (measured available): **{', '.join(global_det['enforced_labels'])}**",
-        f"- Max |BTO error| at enforced times: **{global_det['max_abs_err_us']:.2f} µs**",
-        f"- RMSE_BTO at enforced times: **{global_det['rmse_bto_us']:.2f} µs**",
+        f"- Enforced BTO timestamps (measured available): **{', '.join(best_final_det['enforced_labels'])}**",
+        f"- Max |BTO error| at enforced times: **{best_final_det['max_abs_err_us']:.2f} µs**",
+        f"- RMSE_BTO at enforced times: **{best_final_det['rmse_bto_us']:.2f} µs**",
         "",
         "*If 18:40 has no measured BTO in your satLoc, it is automatically not enforced.*",
+        f"*Performance: polish runs only for top-{TOPK_POLISH} candidates now.*",
     ]
 
-    return global_legs, "\n".join(report_lines), start_dt
+    return best_final_legs, "\n".join(report_lines), start_dt
 
 
 # ================= RUNNERS =================
@@ -1651,7 +1702,7 @@ with gr.Blocks() as demo:
         f"**Turn speed bounds:** {TURN_SPEED_MIN_KT:.0f}–{TURN_SPEED_MAX_KT:.0f} kt\n"
         f"**Southern speed bounds:** {SOUTH_SPEED_MIN_KT:.0f}–{SOUTH_SPEED_MAX_KT:.0f} kt (per segment)\n"
         f"**Ring-fit goal:** match BTO at ping times where measured BTO exists (auto-detected from satLoc).\n"
-        f"**Global polish:** {POLISH_PASSES} passes, ±{POLISH_WINDOW_KT:.0f} kt window, {POLISH_STEP_KT:.0f} kt step (southern speeds only)."
+        f"**Performance:** polish runs only for **top-{TOPK_POLISH}** candidates."
     )
 
     with gr.Row():
@@ -1674,8 +1725,8 @@ with gr.Blocks() as demo:
     gr.Markdown(
         "- Guided mode has **no speed inputs**.\n"
         "- Solver uses **fast BTO-first ring-fit** (turn speed + per-segment southern speeds).\n"
-        "- Then runs a **global polish** step to reduce max |BTO error| across enforced endpoints.\n"
-        "- If 18:40 has no measured BTO in your satLoc, it is **automatically skipped** for enforcement."
+        "- If 18:40 has no measured BTO in your satLoc, it is **automatically skipped** for enforcement.\n"
+        f"- **Performance:** “polish” runs only on the best **top-{TOPK_POLISH}** candidates."
     )
 
     gr.Markdown("### Guided scoring weights (for reporting only)")