Update app.py

app.py

@@ -10,24 +10,13 @@
 # - 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 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.
-# 3) Guided solver: FAST “Ring-fit” speed optimization (BTO-first)
-#    - Turn speed searched in [470, 520] kt to match Ping Ring 2 (18:40) BTO.
-#    - Southern trajectory uses PER-SEGMENT speeds (one per ping interval) in [430, 510] kt
-#      to match Ping Rings 3..7 and 00:20 as tightly as possible.
-#    - This is much faster than brute-forcing a huge grid.
-# 4) HARD BTO constraint applies at:
-#    18:40, 19:40, 20:40, 21:40, 22:40, 00:10, 00:20
-#    The solver tries to make these as close as possible (and will usually get extremely tight),
-#    while keeping runtime low.
-#
-# NOTE:
-# - “Exactly at ping rings” is interpreted as: at each listed waypoint time, the computed BTO
-#   matches the measured BTO as closely as numerically possible within the allowed speed ranges.
+# THIS VERSION:
+# - Guided solver is BTO-first "ring-fit", with fast speed optimization
+# - 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.
 
 import os
 import re
@@ -79,7 +68,6 @@ RING_TIMES = {
 BFO_SCALE_HZ = 5.0
 BTO_SCALE_US = 50.0
 
-# EXPLICIT WEIGHTS (used only for combined reporting; solver is BTO-first)
 DEFAULT_WEIGHT_BFO = 1.0
 DEFAULT_WEIGHT_BTO = 2.0
 
@@ -94,7 +82,6 @@ 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
 RADAR_INITIAL_TRACK_DEG = 296.0
 
 # ===== Guided validation timestamps of interest =====
@@ -116,7 +103,7 @@ TURN_BANK_MAX_DEG = 30.0
 TURN_BANK_DEFAULT_DEG = 25.0
 TURN_STEP_SEC = 30.0
 
-# ===== Updated speed bounds per your request =====
+# ===== Speed bounds per your request =====
 TURN_SPEED_MIN_KT = 470.0
 TURN_SPEED_MAX_KT = 520.0
 
@@ -131,21 +118,13 @@ REFINE_HEADING_HALF_WINDOW_DEG = 2.0
 REFINE_HEADING_STEP_DEG = 0.5
 
 # Southern ping-interval schedule (18:40→00:20 = 340 min)
-# segments:
-# 18:40→19:40 (60)
-# 19:40→20:40 (60)
-# 20:40→21:40 (60)
-# 21:40→22:40 (60)
-# 22:40→00:10 (90)
-# 00:10→00:20 (10)
 GUIDED_SOUTH_SEG_MIN = [60.0, 60.0, 60.0, 60.0, 90.0, 10.0]
 GUIDED_SOUTH_SEG_LABELS_END = ["19:40:00", "20:40:00", "21:40:00", "22:40:00", "24:10:00", "24:20:00"]
 
-# ===== BTO hard tolerance (solver aims tighter; used for "strict accept" gate if desired) =====
-# Keep relatively small; if no solutions, the solver will still return the best near-fit and report max error.
-BTO_HARD_TOL_US = 10.0
+# ===== BTO "tight" target (solver tries tighter; used only for reporting) =====
+BTO_TARGET_TIGHT_US = 1.0  # purely informational
 
-# HARD BTO timestamps to enforce (exact) — now includes 00:20 as requested
+# 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"]
 
 # Search area colors (optional)
@@ -1130,8 +1109,22 @@ def _refine_range(center: float, half_window: float, step: float, lo: float, hi:
     return _frange(lo2, hi2, step)
 
 
-def _hard_bto_dt_set():
-    return {int(_dt_from_label(lbl).timestamp()) for lbl in HARD_BTO_LABELS}
+def _guided_start_dt():
+    return RADAR_FIX_TIME_UTC
+
+
+def _lookup_measured_bto(dt_ping: datetime):
+    _bfo, bto = _lookup_measured_at_dt(dt_ping)
+    return None if bto is None else float(bto)
+
+
+def _available_hard_bto_labels():
+    out = []
+    for lbl in HARD_BTO_LABELS:
+        dt = _dt_from_label(lbl)
+        if _lookup_measured_bto(dt) is not None:
+            out.append(lbl)
+    return out
 
 
 def _simulate_one_leg_end(method: str, lat0: float, lon0: float, hdg: float, spd_kt: float, minutes: float):
@@ -1143,20 +1136,14 @@ def _simulate_one_leg_end(method: str, lat0: float, lon0: float, hdg: float, spd
     return float(lat1), float(lon1)
 
 
-def _bto_at(method: str, lat: float, lon: float, dt_ping: datetime, alt_ft: float, vs_fpm: float, start_dt: datetime, descent_start_dt: datetime | None):
+def _bto_calc(method: str, lat: float, lon: float, dt_ping: datetime, alt_ft: float, vs_fpm: float, start_dt: datetime, descent_start_dt: datetime | None):
     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
     return float(fp.calculateBTO_at_time(float(lat), float(lon), alt_m, dt_ping))
 
 
-def _measured_bto_at(dt_ping: datetime):
-    _bfo, bto = _lookup_measured_at_dt(dt_ping)
-    return None if bto is None else float(bto)
-
-
-def _golden_min_abs(fn, lo: float, hi: float, iters: int = 26):
-    # minimize |fn(x)| over [lo, hi] using golden section on abs value
-    grc = (math.sqrt(5.0) - 1.0) / 2.0  # ~0.618
+def _golden_min_abs(fn, lo: float, hi: float, iters: int = 24):
+    grc = (math.sqrt(5.0) - 1.0) / 2.0
     a, b = float(lo), float(hi)
     c = b - grc * (b - a)
     d = a + grc * (b - a)
@@ -1189,40 +1176,29 @@ def _fit_segment_speed(
     vmin: float,
     vmax: float,
 ):
-    meas = _measured_bto_at(dt_end)
+    meas = _lookup_measured_bto(dt_end)
     if meas is None:
-        # if no measurement, just pick mid
         v = 0.5 * (vmin + vmax)
         lat1, lon1 = _simulate_one_leg_end(method, lat0, lon0, hdg, v, minutes)
-        bto = _bto_at(method, lat1, lon1, dt_end, alt_ft, vs_fpm, start_dt, descent_start_dt)
-        return float(v), float(bto - (bto if bto is None else bto)), (lat1, lon1)
+        return float(v), float("nan"), (lat1, lon1)
 
     def err(v):
         lat1, lon1 = _simulate_one_leg_end(method, lat0, lon0, hdg, v, minutes)
-        bto = _bto_at(method, lat1, lon1, dt_end, alt_ft, vs_fpm, start_dt, descent_start_dt)
+        bto = _bto_calc(method, lat1, lon1, dt_end, alt_ft, vs_fpm, start_dt, descent_start_dt)
         return float(bto - meas)
 
     e_lo = float(err(vmin))
     e_hi = float(err(vmax))
 
-    # If sign change, bisection to root (very fast, very tight)
-    if e_lo == 0.0:
-        lat1, lon1 = _simulate_one_leg_end(method, lat0, lon0, hdg, vmin, minutes)
-        return float(vmin), 0.0, (lat1, lon1)
-    if e_hi == 0.0:
-        lat1, lon1 = _simulate_one_leg_end(method, lat0, lon0, hdg, vmax, minutes)
-        return float(vmax), 0.0, (lat1, lon1)
-
+    # If sign change: bisection root (fast + tight)
     if (e_lo < 0.0 and e_hi > 0.0) or (e_lo > 0.0 and e_hi < 0.0):
         a, b = float(vmin), float(vmax)
         fa, fb = e_lo, e_hi
-        # 28 iters is plenty for sub-1e-6 kt resolution; we’ll stop early if close
         for _ in range(28):
             m = 0.5 * (a + b)
             fm = float(err(m))
-            if abs(fm) < 0.2:  # ~0.2 µs tight stop
+            if abs(fm) < 0.2:
                 a = b = m
-                fa = fb = fm
                 break
             if (fa < 0 and fm > 0) or (fa > 0 and fm < 0):
                 b, fb = m, fm
@@ -1230,14 +1206,12 @@ def _fit_segment_speed(
                 a, fa = m, fm
         v_best = 0.5 * (a + b)
         lat1, lon1 = _simulate_one_leg_end(method, lat0, lon0, hdg, v_best, minutes)
-        final_err = float(err(v_best))
-        return float(v_best), float(final_err), (lat1, lon1)
+        return float(v_best), float(err(v_best)), (lat1, lon1)
 
-    # No sign change: fall back to golden minimize |error|
-    v_best, abs_err = _golden_min_abs(err, vmin, vmax, iters=30)
+    # No sign change: minimize |err| on bounds
+    v_best, _ = _golden_min_abs(err, vmin, vmax, iters=28)
     lat1, lon1 = _simulate_one_leg_end(method, lat0, lon0, hdg, v_best, minutes)
-    final_err = float(err(v_best))
-    return float(v_best), float(final_err), (lat1, lon1)
+    return float(v_best), float(err(v_best)), (lat1, lon1)
 
 
 def _build_south_legs_piecewise(h_south: float, speeds: list[float], minutes: list[float]):
@@ -1250,10 +1224,6 @@ def _build_south_legs_piecewise(h_south: float, speeds: list[float], minutes: li
 
 
 # ================= Guided Solver =================
-def _guided_start_dt():
-    return RADAR_FIX_TIME_UTC
-
-
 def solve_guided_straight(
     method, alt_ft, vs_fpm,
     descent_start_choice, weight_bfo, weight_bto
@@ -1267,69 +1237,37 @@ def solve_guided_straight(
     elif (descent_start_choice or "").startswith("After Ping Ring 7"):
         descent_start_dt = dt_ping7_utc()
 
-    # Precompute ping points window for later reporting/scoring (BFO plot still uses full set)
     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
 
-    hard_ts = _hard_bto_dt_set()
-
-    dt_1840 = TURN_COMPLETE_TIME_UTC
-    meas_bto_1840 = _measured_bto_at(dt_1840)
+    enforced_labels = _available_hard_bto_labels()
+    if not enforced_labels:
+        return None, "Guided solve: no measured BTO available at any enforced ring times.", None
 
-    if meas_bto_1840 is None:
-        return None, "Guided solve: missing measured BTO at 18:40 in satLoc.", None
-
-    def evaluate_heading(h_south: float):
-        """
-        For a given south heading:
-        1) Choose a turn speed in [470,520] to match BTO at 18:40 (Ping Ring 2).
-        2) From the 18:40 endpoint, choose per-segment speeds in [430,510] to match
-           BTO at 19:40..00:20 endpoints sequentially.
-        Returns: (total_abs_err_sum, max_abs_err, legs, details)
-        """
-        h_south = float(h_south)
-
-        # --- Turn speed fit: minimize |BTO(18:40)-meas|
-        def turn_err(v_turn):
-            turn_legs, _ = build_turn_legs(
-                speed_knots=float(v_turn),
-                method=method,
-                heading_final_deg=h_south,
-            )
-            # endpoint at 18:40 is the end of turn legs
-            pts, _seg, _tmin = simulate_path(RADAR_FIX_LAT, RADAR_FIX_LON, turn_legs, method)
-            lat_1840, lon_1840 = pts[-1]
-            bto = _bto_at(method, lat_1840, lon_1840, dt_1840, alt_ft, vs_fpm, start_dt, descent_start_dt)
-            return float(bto - meas_bto_1840)
-
-        v_turn_best, abs_turn_err = _golden_min_abs(turn_err, TURN_SPEED_MIN_KT, TURN_SPEED_MAX_KT, iters=28)
+    enforced_dts = [_dt_from_label(lbl) for lbl in enforced_labels]
 
+    def evaluate_heading_and_turnspeed(h_south: float, v_turn: float):
+        # Build turn legs
         turn_legs, turn_info = build_turn_legs(
-            speed_knots=float(v_turn_best),
+            speed_knots=float(v_turn),
             method=method,
-            heading_final_deg=h_south,
+            heading_final_deg=float(h_south),
         )
         pts_turn, _, _ = simulate_path(RADAR_FIX_LAT, RADAR_FIX_LON, turn_legs, method)
         lat_cur, lon_cur = pts_turn[-1]
 
-        # --- Southern sequential segment fits
+        # Fit south segments sequentially (per segment speed)
         south_speeds = []
         south_errs = []
-        seg_end_positions = []
-        dt_prev = dt_1840
-
-        total_abs = float(abs_turn_err)
-        max_abs = float(abs_turn_err)
-
         for mins, end_lbl in zip(GUIDED_SOUTH_SEG_MIN, GUIDED_SOUTH_SEG_LABELS_END):
             dt_end = _dt_from_label(end_lbl)
             v_seg, err_seg, (lat1, lon1) = _fit_segment_speed(
                 method=method,
                 lat0=lat_cur,
                 lon0=lon_cur,
-                hdg=h_south,
+                hdg=float(h_south),
                 minutes=float(mins),
                 dt_end=dt_end,
                 alt_ft=alt_ft,
@@ -1341,98 +1279,138 @@ def solve_guided_straight(
             )
             south_speeds.append(float(v_seg))
             south_errs.append(float(err_seg))
-            seg_end_positions.append((float(lat1), float(lon1)))
             lat_cur, lon_cur = float(lat1), float(lon1)
-            dt_prev = dt_end
 
-            total_abs += abs(float(err_seg))
-            max_abs = max(max_abs, abs(float(err_seg)))
+        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
+        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))
 
-        south_legs = _build_south_legs_piecewise(h_south, south_speeds, GUIDED_SOUTH_SEG_MIN)
-        full_legs = turn_legs + south_legs
-        full_legs = clip_legs_to_end_dt(full_legs, start_dt, end_dt)
+        if not bto_errs:
+            return None
+
+        max_abs = float(np.max(np.abs(bto_errs)))
+        sum_abs = float(np.sum(np.abs(bto_errs)))
+        rmse = float(np.sqrt(np.mean(np.array(bto_errs) ** 2)))
 
         details = {
             "h_south": float(h_south),
-            "v_turn": float(v_turn_best),
-            "turn_abs_err_us": float(abs_turn_err),
+            "v_turn": float(v_turn),
             "south_speeds": south_speeds,
             "south_errs_us": south_errs,
-            "max_abs_err_us": float(max_abs),
-            "sum_abs_err_us": float(total_abs),
             "turn_info": turn_info,
+            "enforced_labels": enforced_labels,
+            "max_abs_err_us": max_abs,
+            "sum_abs_err_us": sum_abs,
+            "rmse_bto_us": rmse,
         }
-        return float(total_abs), float(max_abs), full_legs, details
+        return (max_abs, sum_abs, rmse), full_legs, details
+
+    def best_for_heading(h_south: float):
+        h_south = float(h_south)
 
-    # ---- Stage 1: coarse heading scan (fast)
-    best = None
-    best_details = None
-    best_legs = None
+        # Coarse scan turn speed (fast, avoids expensive nested golden everywhere)
+        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)
+            if out is None:
+                continue
+            key, legs, det = out
+            if best_key is None or key < best_key:
+                best_key, best_legs, best_details = key, legs, det
+
+        if best_key is None:
+            return None
+
+        # Refine around best coarse speed via golden minimize max_abs_err
+        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)
+            if out2 is None:
+                return 1e9
+            (max_abs, sum_abs, _rmse), _legs, _det = out2
+            # primary max abs, secondary sum abs
+            return float(max_abs) + 1e-3 * float(sum_abs)
+
+        v_best, _ = _golden_min_abs(obj, v_lo, v_hi, iters=22)
+        out3 = evaluate_heading_and_turnspeed(h_south, v_best)
+        if out3 is None:
+            return best_key, best_legs, best_details
+        key3, legs3, det3 = out3
+        return key3, legs3, det3
+
+    # Stage 1: coarse headings
     coarse_headings = _frange(GUIDED_HEADING_MIN, GUIDED_HEADING_MAX, COARSE_HEADING_STEP_DEG)
+    global_best = None
+    global_legs = None
+    global_det = None
+
     for h in coarse_headings:
-        tot_abs, max_abs, legs, details = evaluate_heading(h)
-        # Primary: minimize max abs error at ring times, secondary: total abs error
-        key = (max_abs, tot_abs)
-        if best is None or key < best:
-            best = key
-            best_details = details
-            best_legs = legs
-
-    # ---- Stage 2: refine around best heading
-    h0 = float(best_details["h_south"])
+        out = best_for_heading(h)
+        if out is None:
+            continue
+        key, legs, det = out
+        if global_best is None or key < global_best:
+            global_best, global_legs, global_det = key, legs, det
+
+    if global_legs is None:
+        return None, "Guided solve: no solution found within speed bounds.", None
+
+    # Stage 2: refine headings around best
+    h0 = float(global_det["h_south"])
     refine_headings = _refine_range(h0, REFINE_HEADING_HALF_WINDOW_DEG, REFINE_HEADING_STEP_DEG, GUIDED_HEADING_MIN, GUIDED_HEADING_MAX)
 
     for h in refine_headings:
-        tot_abs, max_abs, legs, details = evaluate_heading(h)
-        key = (max_abs, tot_abs)
-        if best is None or key < best:
-            best = key
-            best_details = details
-            best_legs = legs
-
-    # Build a compact report
-    south_speeds = best_details["south_speeds"]
-    south_errs = best_details["south_errs_us"]
-
-    # Also compute RMSE_BTO on the enforced timestamps for reporting
-    enforced_dts = [_dt_from_label(lbl) for lbl in HARD_BTO_LABELS]
-    bto_errors = []
-    for dt_k in enforced_dts:
-        st = _state_at_dt(RADAR_FIX_LAT, RADAR_FIX_LON, best_legs, method, start_dt, dt_k)
-        if st is None:
-            continue
-        meas = _measured_bto_at(dt_k)
-        if meas is None:
+        out = best_for_heading(h)
+        if out is None:
             continue
-        bto_calc = _bto_at(method, st["lat"], st["lon"], dt_k, alt_ft, vs_fpm, start_dt, descent_start_dt)
-        bto_errors.append(float(bto_calc - meas))
+        key, legs, det = out
+        if global_best is None or key < global_best:
+            global_best, global_legs, global_det = key, legs, det
 
-    rmse_bto = float(np.sqrt(np.mean(np.array(bto_errors) ** 2))) if bto_errors else float("nan")
+    # Reporting
+    south_speeds = global_det["south_speeds"]
+    south_errs = global_det["south_errs_us"]
 
     report_lines = [
         "**Guided mode: Straight + computed turn (18:22→18:40), clipped to 00:20**",
         "- Solver mode: **BTO-first ring-fit (fast)**",
-        f"- Best southern heading: **{best_details['h_south']:.2f}°**",
-        f"- Turn speed (18:22→18:40) in [{TURN_SPEED_MIN_KT:.0f},{TURN_SPEED_MAX_KT:.0f}] kt: **{best_details['v_turn']:.2f} kt**",
-        f"- Turn BTO error at 18:40: **{best_details['turn_abs_err_us']:.2f} µs**",
+        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**",
         "",
         "**Southern per-segment speeds (each constrained to 430–510 kt):**",
-        f"- 18:40→19:40: **{south_speeds[0]:.2f} kt** (BTO err {south_errs[0]:+.2f} µs)",
-        f"- 19:40→20:40: **{south_speeds[1]:.2f} kt** (BTO err {south_errs[1]:+.2f} µs)",
-        f"- 20:40→21:40: **{south_speeds[2]:.2f} kt** (BTO err {south_errs[2]:+.2f} µs)",
-        f"- 21:40→22:40: **{south_speeds[3]:.2f} kt** (BTO err {south_errs[3]:+.2f} µs)",
-        f"- 22:40→00:10: **{south_speeds[4]:.2f} kt** (BTO err {south_errs[4]:+.2f} µs)",
-        f"- 00:10→00:20: **{south_speeds[5]:.2f} kt** (BTO err {south_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: **{', '.join(HARD_BTO_LABELS)}**",
-        f"- Max |BTO error| across enforced times: **{best_details['max_abs_err_us']:.2f} µs**",
-        f"- RMSE_BTO across enforced times: **{rmse_bto:.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"*(If max error isn’t near zero, it usually means the speed bounds prevent an exact ring-fit for that heading; the solver chooses the tightest possible fit.)*",
+        "*If 18:40 has no measured BTO in your satLoc, it is automatically not enforced.*",
     ]
 
-    return best_legs, "\n".join(report_lines), start_dt
+    return global_legs, "\n".join(report_lines), start_dt
 
 
 # ================= RUNNERS =================
@@ -1529,7 +1507,7 @@ 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_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 **18:40, 19:40, 20:40, 21:40, 22:40, 00:10, 00:20** as tightly as possible."
+        f"**Ring-fit goal:** match BTO at ping times where measured BTO exists (auto-detected from satLoc)."
     )
 
     with gr.Row():
@@ -1552,10 +1530,10 @@ 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"
-        "- BFO is still plotted, but the solver’s priority is **ring timing (BTO)**."
+        "- If 18:40 has no measured BTO in your satLoc, it is **automatically skipped** for enforcement."
     )
 
-    gr.Markdown("### Guided scoring weights (for reporting; solver is BTO-first)")
+    gr.Markdown("### Guided scoring weights (for reporting only)")
     with gr.Row():
         weight_bfo = gr.Slider(0.0, 5.0, value=DEFAULT_WEIGHT_BFO, step=0.1, label="Weight: BFO")
         weight_bto = gr.Slider(0.0, 10.0, value=DEFAULT_WEIGHT_BTO, step=0.1, label="Weight: BTO")