Update app.py

app.py

@@ -13,11 +13,15 @@
 # - 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
 #
-# THIS VERSION (UI CHANGES):
-# - Removes the big header/config text and removes guided/BFO scoring text blocks from UI
-# - Adds a Speed Profile graph (kt vs minutes)
-# - Descent-start dropdown now has: None / At 00:20Z only
-# - Adds a map marker: Captain Byron Bailey @ 39°10' S, 88°18' E
+# THIS VERSION (UI cleanup + fixes):
+# - Removes the big solver/bounds markdown from the UI (status panels hidden/blank)
+# - Adds Speed Profile plot (kt vs time)
+# - Descent option changed:
+#     * "None (constant VS from start)"
+#     * "At 00:20Z only"
+# - Ensures BFO at 00:20Z is measured at 182 Hz (patch + guaranteed inclusion in BFO plot)
+# - Restores waypoint hover info (tooltip now includes name + coords; popup added)
+# - Adds location marker at 39°10'S, 88°18'E with hover label "Captain Byron Bailey"
 
 import os
 import re
@@ -55,10 +59,13 @@ WAYPOINTS = [
     ("MEKAR", 6.5, 96.48333333),
 ]
 
-# Custom reference marker requested
-CAPT_BYRON_BAILEY_LABEL = "Captain Byron Bailey"
-CAPT_BYRON_BAILEY_LAT = -(39.0 + 10.0 / 60.0)   # 39°10' S  -> -39.1666667
-CAPT_BYRON_BAILEY_LON = (88.0 + 18.0 / 60.0)    # 88°18' E  ->  88.3
+# NEW: Reference marker requested
+CAPT_BYRON_BAILEY_NAME = "Captain Byron Bailey"
+CAPT_BYRON_BAILEY_LAT = -(39 + 10 / 60)   # 39°10' S
+CAPT_BYRON_BAILEY_LON = (88 + 18 / 60)    # 88°18' E
+
+# NEW: measured BFO at 00:20Z
+MEASURED_BFO_0020_HZ = 182.0
 
 RING_TIMES = {
     "Ping Ring 1": "18:25:00Z",
@@ -144,10 +151,7 @@ VAR_BEAM_WIDTH = 12                  # keep top-N partial paths each segment
 VAR_SMOOTH_PENALTY_US_PER_DEG = 1.5  # small penalty to avoid wiggles (still BTO-first)
 
 # ===== SE-bias-after-22:40 (new mode) =====
-# Only applied to the last two segments (22:40→00:10, 00:10→00:20).
-# Penalty is applied ONLY when heading increases (more west-of-south),
-# nudging solutions to be slightly more east while keeping BTO primary.
-SE_EAST_DIVERGE_START_SEG_INDEX = 4          # segment indices: 0..5 ; seg 3 ends at 22:40, seg 4 starts after 22:40
+SE_EAST_DIVERGE_START_SEG_INDEX = 4          # seg 4 starts after 22:40
 SE_VAR_EAST_DELTA_SET = [-8, -4, -2, 0, 2]   # prefer small decreases (eastward) after 22:40
 SE_EAST_BIAS_PENALTY_US_PER_DEG = 0.8        # small; BTO still dominates
 
@@ -505,6 +509,42 @@ def _dt_from_label(label_hms: str) -> datetime:
     return fp._time_label_to_dt(s, fp.SAT_EPOCH_UTC)
 
 
+def dt_ping6_utc() -> datetime:
+    return fp._time_label_to_dt("22:40:00", fp.SAT_EPOCH_UTC)
+
+
+def dt_ping7_utc() -> datetime:
+    return fp._time_label_to_dt("24:10:00", fp.SAT_EPOCH_UTC)
+
+
+def dt_0020_utc() -> datetime:
+    return fp._time_label_to_dt("24:20:00", fp.SAT_EPOCH_UTC)
+
+
+# ================= PATCH satLoc: ensure measured BFO at 00:20 is 182 Hz =================
+def _patch_measured_bfo_0020():
+    target_labels = {"24:20:00", "00:20:00"}
+    patched = False
+    try:
+        for row in fp.satLoc:
+            try:
+                lbl = fp._extract_time_string(row[0])
+            except Exception:
+                continue
+            if lbl in target_labels:
+                try:
+                    row[SATLOC_IDX_MEAS_BFO] = float(MEASURED_BFO_0020_HZ)
+                    patched = True
+                except Exception:
+                    pass
+    except Exception:
+        return False
+    return patched
+
+
+_ = _patch_measured_bfo_0020()
+
+
 # ================= ALTITUDE HELPERS =================
 def altitude_ft_at_dt(dt_ping: datetime, start_dt: datetime, alt0_ft: float,
                       vs_fpm: float, descent_start_dt: datetime | None):
@@ -543,26 +583,35 @@ def build_altitude_plot(start_dt: datetime, total_time_min: float, alt0_ft: floa
     return fig
 
 
+# ================= SPEED PROFILE PLOT =================
 def build_speed_profile_plot(start_dt: datetime, legs: list[tuple[float, float, float]]):
-    # Stepwise speed vs elapsed minutes
-    x = [0.0]
-    y = [float(legs[0][1]) if legs else 0.0]
-    t = 0.0
-    for (_h, spd, mins) in legs:
-        spd = float(spd)
+    # Step-like plot: speed held constant across each leg
+    xs = [0.0]
+    ys = []
+    cum_min = 0.0
+    for (_hdg, spd, mins) in legs:
         mins = float(mins)
-        # start of leg
-        if x[-1] != t:
-            x.append(t)
-            y.append(spd)
-        # end of leg
-        t2 = t + mins
-        x.append(t2)
-        y.append(spd)
-        t = t2
+        spd = float(spd)
+        if mins <= 0:
+            continue
+        if not ys:
+            ys.append(spd)
+        else:
+            ys.append(ys[-1])
+        # extend step
+        xs.append(cum_min)
+        ys.append(spd)
+        cum_min += mins
+        xs.append(cum_min)
+        ys.append(spd)
+
+    if not ys:
+        fig = go.Figure()
+        fig.update_layout(title="Speed Profile", xaxis_title="Minutes since start", yaxis_title="Speed (kt)", height=320)
+        return fig
 
     fig = go.Figure()
-    fig.add_trace(go.Scatter(x=x, y=y, mode="lines", name="Speed (kt)"))
+    fig.add_trace(go.Scatter(x=xs[1:], y=ys, mode="lines", name="Speed (kt)"))
     fig.update_layout(
         title="Speed Profile",
         xaxis_title="Minutes since start",
@@ -733,12 +782,19 @@ def _ping_points_after(start_dt: datetime):
     return pts
 
 
+def _descent_start_dt_from_choice(descent_start_choice: str) -> datetime | None:
+    ch = (descent_start_choice or "").strip()
+    if ch.startswith("At 00:20Z only"):
+        return dt_0020_utc()
+    if ch.startswith("None"):
+        return None
+    return None
+
+
 def bfo_analysis_with_legs(start_lat, start_lon, legs, method, start_dt, alt_ft, vs_fpm, descent_start_choice):
     pts = _ping_points_after(start_dt)
 
-    descent_start_dt = None
-    if (descent_start_choice or "").startswith("At 00:20Z"):
-        descent_start_dt = _dt_from_label("24:20:00")
+    descent_start_dt = _descent_start_dt_from_choice(descent_start_choice)
 
     leg_secs = [float(m) * 60.0 for _, _, m in legs]
     boundaries = np.cumsum([0.0] + leg_secs)
@@ -748,6 +804,14 @@ def bfo_analysis_with_legs(start_lat, start_lon, legs, method, start_dt, alt_ft,
 
     x_labels, measured, calculated = [], [], []
 
+    # Ensure 00:20 is included as a measured point in the plot if within window
+    dt_0020 = dt_0020_utc()
+    have_0020 = any((lbl.replace("Z", "") in {"24:20:00", "00:20:00"}) for (lbl, *_rest) in pts)
+    if (start_dt <= dt_0020 <= (start_dt + timedelta(seconds=total_end))) and not have_0020:
+        pts.append(("24:20:00", dt_0020, float(MEASURED_BFO_0020_HZ), None))
+
+    pts = sorted(pts, key=lambda x: x[1])
+
     for label, 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:
@@ -772,7 +836,7 @@ def bfo_analysis_with_legs(start_lat, start_lon, legs, method, start_dt, alt_ft,
         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))
 
-        x_labels.append(label)
+        x_labels.append(label if label.endswith("Z") else (label + "Z"))
         measured.append(float(meas_bfo))
         calculated.append(float(pred_bfo))
 
@@ -802,6 +866,8 @@ def bfo_analysis_with_legs(start_lat, start_lon, legs, method, start_dt, alt_ft,
         margin=dict(l=60, r=160, t=80, b=60),
         height=520,
     )
+
+    # UI request: remove "BFO scoring" markdown from UI
     return fig, ""
 
 
@@ -818,9 +884,7 @@ def build_validation_table(
     start_lat, start_lon, method, start_dt, legs,
     alt_ft, vs_fpm, descent_start_choice
 ):
-    descent_start_dt = None
-    if (descent_start_choice or "").startswith("At 00:20Z"):
-        descent_start_dt = _dt_from_label("24:20:00")
+    descent_start_dt = _descent_start_dt_from_choice(descent_start_choice)
 
     is_guided = (start_dt == RADAR_FIX_TIME_UTC)
 
@@ -859,6 +923,13 @@ def build_validation_table(
 
         bfo_meas, bto_meas = _lookup_measured_at_dt(dt_k)
 
+        # Force measured BFO at 00:20 to 182 Hz
+        try:
+            if dt_k == dt_0020_utc():
+                bfo_meas = float(MEASURED_BFO_0020_HZ)
+        except Exception:
+            pass
+
         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))
 
@@ -899,6 +970,13 @@ def _all_bounds(points_list):
 
 
 def add_permanent_label(m, name, lat, lon):
+    # Tooltip should contain waypoint info again (name + coords)
+    tip = f"{html.escape(name)}<br>Lat: {float(lat):.5f}<br>Lon: {float(lon):.5f}"
+    pop = folium.Popup(
+        f"<b>{html.escape(name)}</b><br>Lat: {float(lat):.5f}<br>Lon: {float(lon):.5f}",
+        max_width=260,
+    )
+
     folium.CircleMarker(
         location=(lat, lon),
         radius=4,
@@ -907,7 +985,8 @@ def add_permanent_label(m, name, lat, lon):
         fill=True,
         fill_color="white",
         fill_opacity=1.0,
-        tooltip=name,
+        tooltip=folium.Tooltip(tip, sticky=True),
+        popup=pop,
     ).add_to(m)
 
     label_html = f"""
@@ -918,25 +997,28 @@ def add_permanent_label(m, name, lat, lon):
         text-shadow: -1px -1px 0 #fff, 1px -1px 0 #fff, -1px 1px 0 #fff, 1px 1px 0 #fff;
         white-space: nowrap;
         transform: translate(8px, -12px);
+        pointer-events: none;
     ">{html.escape(name)}</div>
     """
     folium.Marker(location=(lat, lon), icon=folium.DivIcon(html=label_html)).add_to(m)
 
 
-def add_reference_marker(m, name: str, lat: float, lon: float):
+def add_named_marker(m, name: str, lat: float, lon: float):
+    tip = f"{html.escape(name)}<br>Lat: {float(lat):.5f}<br>Lon: {float(lon):.5f}"
+    pop = folium.Popup(
+        f"<b>{html.escape(name)}</b><br>Lat: {float(lat):.5f}<br>Lon: {float(lon):.5f}",
+        max_width=260,
+    )
     folium.CircleMarker(
         location=(float(lat), float(lon)),
-        radius=7,
-        color="cyan",
-        weight=3,
+        radius=6,
+        color="white",
+        weight=2,
         fill=True,
         fill_color="cyan",
-        fill_opacity=0.85,
-        tooltip=name,
-        popup=folium.Popup(
-            f"<b>{html.escape(name)}</b><br>Lat: {float(lat):.5f}<br>Lon: {float(lon):.5f}",
-            max_width=320,
-        ),
+        fill_opacity=0.9,
+        tooltip=folium.Tooltip(tip, sticky=True),
+        popup=pop,
     ).add_to(m)
 
 
@@ -1064,9 +1146,24 @@ def build_leaflet_map(path_pts, legs, method, start_dt):
         marker_pts_for_bounds.append((lat, lon))
 
         tlabel = _to_label_utc(dt_k)
+        elapsed_min = st["elapsed_min"]
+        hdg = st["heading_deg"]
+        spd = st["speed_kt"]
+        dist_km = st["dist_km"]
 
         is_final = (start_dt == RADAR_FIX_TIME_UTC) and (dt_k == _dt_from_label(GUIDED_FINAL_LABEL))
 
+        popup_lines = [
+            f"<b>{'FINAL RESTING POINT' if is_final else 'Validation point'}</b>",
+            f"UTC time: {tlabel}",
+            f"Lat: {lat:.5f}",
+            f"Lon: {lon:.5f}",
+            f"Time elapsed: {elapsed_min:.1f} min",
+            f"Heading: {hdg:.1f}°",
+            f"Speed: {spd:.1f} kt",
+            f"Distance flown: {dist_km:.2f} km",
+        ]
+
         if is_final:
             folium.CircleMarker(
                 location=(lat, lon),
@@ -1076,6 +1173,7 @@ def build_leaflet_map(path_pts, legs, method, start_dt):
                 fill_color="magenta",
                 fill_opacity=0.95,
                 tooltip=f"{tlabel} (FINAL)",
+                popup=folium.Popup("<br>".join(popup_lines), max_width=360),
             ).add_to(m)
         else:
             folium.CircleMarker(
@@ -1086,26 +1184,25 @@ def build_leaflet_map(path_pts, legs, method, start_dt):
                 fill_color="white",
                 fill_opacity=1.0,
                 tooltip=tlabel,
+                popup=folium.Popup("<br>".join(popup_lines), max_width=360),
             ).add_to(m)
 
+    # Waypoints
     for name, lat, lon in WAYPOINTS:
         add_permanent_label(m, name, float(lat), float(lon))
 
-    # Requested reference marker
-    add_reference_marker(m, CAPT_BYRON_BAILEY_LABEL, CAPT_BYRON_BAILEY_LAT, CAPT_BYRON_BAILEY_LON)
+    # Requested marker: Captain Byron Bailey
+    add_named_marker(m, CAPT_BYRON_BAILEY_NAME, CAPT_BYRON_BAILEY_LAT, CAPT_BYRON_BAILEY_LON)
 
-    waypoint_pts = [(float(lat), float(lon)) for _, lat, lon in WAYPOINTS]
+    waypoint_pts = [(float(lat), float(lon)) for _, lat, lon in WAYPOINTS] + [(CAPT_BYRON_BAILEY_LAT, CAPT_BYRON_BAILEY_LON)]
     all_ring_pts = []
     for k in PING_RINGS:
         all_ring_pts.extend(PING_RINGS.get(k, []))
 
-    ref_pts = [(CAPT_BYRON_BAILEY_LAT, CAPT_BYRON_BAILEY_LON)]
-
     bounds = _all_bounds(
         [path_pts]
         + [waypoint_pts]
         + [all_ring_pts]
-        + [ref_pts]
         + ([search_area_pts_for_bounds] if search_area_pts_for_bounds else [])
         + ([marker_pts_for_bounds] if marker_pts_for_bounds else [])
     )
@@ -1385,18 +1482,16 @@ def solve_guided_straight(method, alt_ft, vs_fpm, descent_start_choice):
     start_dt = _guided_start_dt()
     end_dt = _dt_from_label(GUIDED_FINAL_LABEL)
 
-    descent_start_dt = None
-    if (descent_start_choice or "").startswith("At 00:20Z"):
-        descent_start_dt = _dt_from_label("24:20:00")
+    descent_start_dt = _descent_start_dt_from_choice(descent_start_choice)
 
     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, "", None
+        return None, "Guided solve: not enough ping points to score.", None
 
     enforced_labels = _available_hard_bto_labels()
     if not enforced_labels:
-        return None, "", None
+        return None, "Guided solve: no measured BTO available at any enforced ring times.", None
 
     enforced_dts = [_dt_from_label(lbl) for lbl in enforced_labels]
 
@@ -1461,43 +1556,105 @@ def solve_guided_straight(method, alt_ft, vs_fpm, descent_start_choice):
         sum_abs = float(np.sum(abs_arr))
         rmse = float(np.sqrt(np.mean(np.array(bto_errs, dtype=float) ** 2)))
 
-        return (max_abs, sum_abs, rmse), full_legs
+        details = {
+            "h_south": float(h_south),
+            "v_turn": float(v_turn),
+            "south_speeds": [float(v) for v in south_speeds],
+            "south_errs_us": [float(e) for e in south_errs],
+            "enforced_labels": enforced_labels,
+            "max_abs_err_us": max_abs,
+            "sum_abs_err_us": sum_abs,
+            "rmse_bto_us": rmse,
+        }
+        return (max_abs, sum_abs, rmse), full_legs, details
 
     def best_for_heading(h_south: float):
         coarse_turns = list(np.arange(TURN_SPEED_MIN_KT, TURN_SPEED_MAX_KT + 1e-9, 5.0))
         best_key = None
         best_legs = None
+        best_det = None
 
         for v in coarse_turns:
             out = _evaluate(h_south, v, do_polish=False)
             if out is None:
                 continue
-            key, legs = out
+            key, legs, det = out
             if best_key is None or key < best_key:
-                best_key, best_legs = key, legs
+                best_key, best_legs, best_det = key, legs, det
 
         if best_key is None:
             return None
-        return best_key, best_legs
+
+        v0 = float(best_det["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(h_south, v, do_polish=False)
+            if out2 is None:
+                return 1e9
+            (max_abs, sum_abs, _rmse), _legs, _det = out2
+            return float(max_abs) + POLISH_OBJ_EPS * float(sum_abs)
+
+        v_best, _ = _golden_min_abs(obj, v_lo, v_hi, iters=16)
+        out3 = _evaluate(h_south, v_best, do_polish=False)
+        if out3 is None:
+            return best_key, best_legs, best_det
+        return out3
 
     coarse_headings = _frange(GUIDED_HEADING_MIN, GUIDED_HEADING_MAX, COARSE_HEADING_STEP_DEG)
+    candidates = []
     best = None
     best_legs = None
+    best_det = None
 
     for h in coarse_headings:
         out = best_for_heading(h)
         if out is None:
             continue
-        key, legs = out
+        key, legs, det = out
+        candidates.append((key, float(det["h_south"]), float(det["v_turn"])))
         if best is None or key < best:
-            best, best_legs = key, legs
+            best, best_legs, best_det = key, legs, det
 
     if best_legs is None:
-        return None, "", None
+        return None, "Guided solve: no solution found within bounds.", None
 
-    # refine around best heading by re-running coarse again in window
-    # (kept minimal since UI no longer shows the report)
-    return best_legs, "", start_dt
+    h0 = float(best_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:
+        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 best is None or key < best:
+            best, best_legs, best_det = key, legs, det
+
+    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
+
+    best_final_key, best_final_legs, best_final_det = best, best_legs, best_det
+    if ENABLE_POLISH_STRAIGHT 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, best_final_legs, best_final_det = keyp, legsp, detp
+
+    # UI request: remove solver report text from UI -> return empty report
+    return best_final_legs, "", start_dt
 
 
 # ================= Guided Solver: Variable heading & speed (FAST beam search) =================
@@ -1505,13 +1662,11 @@ def _solve_guided_variable_core(method, alt_ft, vs_fpm, descent_start_choice, se
     start_dt = _guided_start_dt()
     end_dt = _dt_from_label(GUIDED_FINAL_LABEL)
 
-    descent_start_dt = None
-    if (descent_start_choice or "").startswith("At 00:20Z"):
-        descent_start_dt = _dt_from_label("24:20:00")
+    descent_start_dt = _descent_start_dt_from_choice(descent_start_choice)
 
     enforced_labels = _available_hard_bto_labels()
     if not enforced_labels:
-        return None, "", None
+        return None, "Guided solve: no measured BTO available at any enforced ring times.", None
     enforced_dts = [_dt_from_label(lbl) for lbl in enforced_labels]
 
     turn_speeds = list(np.arange(TURN_SPEED_MIN_KT, TURN_SPEED_MAX_KT + 1e-9, VAR_TURN_SPEED_STEP))
@@ -1562,9 +1717,11 @@ def _solve_guided_variable_core(method, alt_ft, vs_fpm, descent_start_choice, se
 
                 for st in beam:
                     h_prev = float(st["h_prev"])
+
                     cand_h = []
                     for d in delta_set:
-                        h_try = _clamp(h_prev + float(d), VAR_HEADING_MIN, VAR_HEADING_MAX)
+                        h_try = h_prev + float(d)
+                        h_try = _clamp(h_try, VAR_HEADING_MIN, VAR_HEADING_MAX)
                         cand_h.append(h_try)
                     cand_h = sorted(list({round(x, 6): x for x in cand_h}.values()))
 
@@ -1638,8 +1795,9 @@ def _solve_guided_variable_core(method, alt_ft, vs_fpm, descent_start_choice, se
                     best_global_legs = full_legs
 
     if best_global_legs is None:
-        return None, "", None
+        return None, "Guided solve: Variable mode found no solution within bounds.", None
 
+    # UI request: remove solver report text from UI -> return empty report
     return best_global_legs, "", start_dt
 
 
@@ -1656,13 +1814,11 @@ def solve_guided_constant_speed(method, alt_ft, vs_fpm, descent_start_choice):
     start_dt = _guided_start_dt()
     end_dt = _dt_from_label(GUIDED_FINAL_LABEL)
 
-    descent_start_dt = None
-    if (descent_start_choice or "").startswith("At 00:20Z"):
-        descent_start_dt = _dt_from_label("24:20:00")
+    descent_start_dt = _descent_start_dt_from_choice(descent_start_choice)
 
     enforced_labels = _available_hard_bto_labels()
     if not enforced_labels:
-        return None, "", None
+        return None, "Guided solve: no measured BTO available at any enforced ring times.", None
     enforced_dts = [_dt_from_label(lbl) for lbl in enforced_labels]
 
     turn_speeds = list(np.arange(TURN_SPEED_MIN_KT, TURN_SPEED_MAX_KT + 1e-9, VAR_TURN_SPEED_STEP))
@@ -1701,13 +1857,16 @@ def solve_guided_constant_speed(method, alt_ft, vs_fpm, descent_start_choice):
                 "smooth_sum": 0.0,
             }]
 
+            seg_i = -1
             for mins, end_lbl in zip(GUIDED_SOUTH_SEG_MIN, GUIDED_SOUTH_SEG_LABELS_END):
+                seg_i += 1
                 dt_end = _dt_from_label(end_lbl)
                 meas = _lookup_measured_bto(dt_end)
                 next_beam = []
 
                 for st in beam:
                     h_prev = float(st["h_prev"])
+
                     cand_h = []
                     for d in VAR_HEADING_DELTA_SET:
                         h_try = _clamp(h_prev + float(d), VAR_HEADING_MIN, VAR_HEADING_MAX)
@@ -1768,8 +1927,9 @@ def solve_guided_constant_speed(method, alt_ft, vs_fpm, descent_start_choice):
                     best_global_legs = full_legs
 
     if best_global_legs is None:
-        return None, "", None
+        return None, "Guided solve: Constant-speed mode found no solution within bounds.", None
 
+    # UI request: remove solver report text from UI -> return empty report
     return best_global_legs, "", start_dt
 
 
@@ -1784,15 +1944,13 @@ 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_fig, _bfo_md_hidden = bfo_analysis_with_legs(
+    bfo_fig, _bfo_md = bfo_analysis_with_legs(
         start_lat, start_lon, legs, method, start_dt, alt_ft, vs_fpm, descent_start_choice
     )
 
-    descent_start_dt = None
-    if (descent_start_choice or "").startswith("At 00:20Z"):
-        descent_start_dt = _dt_from_label("24:20:00")
-
+    descent_start_dt = _descent_start_dt_from_choice(descent_start_choice)
     alt_fig = build_altitude_plot(start_dt, total_time_min, alt_ft, vs_fpm, descent_start_dt)
+
     speed_fig = build_speed_profile_plot(start_dt, legs)
 
     headers, rows = build_validation_table(
@@ -1809,19 +1967,20 @@ def run_sim_manual(start_lat, start_lon, legs_df, method, start_time_str, alt_ft
     html_map, stats_md, bfo_fig, alt_fig, speed_fig, headers, rows = _run_common(
         start_lat, start_lon, legs, method, start_dt, alt_ft, vs_fpm, descent_start_choice
     )
-    # status removed from UI (kept as hidden component), return blank for it
+
+    # UI cleanup: keep status blank; no BFO scoring markdown
     return gr.update(), "", html_map, stats_md, bfo_fig, alt_fig, speed_fig, gr.update(headers=headers, value=rows)
 
 
 def run_guided(guided_mode, start_lat, start_lon, method, alt_ft, vs_fpm, descent_start_choice):
     if guided_mode == "Straight heading":
-        legs, _report_md_hidden, start_dt = solve_guided_straight(method, alt_ft, vs_fpm, descent_start_choice)
+        legs, _report_md, start_dt = solve_guided_straight(method, alt_ft, vs_fpm, descent_start_choice)
     elif guided_mode == "Variable heading & speed":
-        legs, _report_md_hidden, start_dt = solve_guided_variable(method, alt_ft, vs_fpm, descent_start_choice)
+        legs, _report_md, start_dt = solve_guided_variable(method, alt_ft, vs_fpm, descent_start_choice)
     elif guided_mode == "Variable heading & speed (SE after 22:40)":
-        legs, _report_md_hidden, start_dt = solve_guided_variable_se(method, alt_ft, vs_fpm, descent_start_choice)
+        legs, _report_md, start_dt = solve_guided_variable_se(method, alt_ft, vs_fpm, descent_start_choice)
     else:
-        legs, _report_md_hidden, start_dt = solve_guided_constant_speed(method, alt_ft, vs_fpm, descent_start_choice)
+        legs, _report_md, start_dt = solve_guided_constant_speed(method, alt_ft, vs_fpm, descent_start_choice)
 
     if legs is None:
         fig = go.Figure()
@@ -1841,6 +2000,7 @@ def run_guided(guided_mode, start_lat, start_lon, method, alt_ft, vs_fpm, descen
         RADAR_FIX_LAT, RADAR_FIX_LON, legs, method, start_dt, alt_ft, vs_fpm, descent_start_choice
     )
 
+    # UI cleanup: keep status blank
     return gr.update(value=legs_to_rows(legs)), "", html_map, stats_md, bfo_fig, alt_fig, speed_fig, gr.update(headers=headers, value=rows)
 
 
@@ -1884,10 +2044,7 @@ with gr.Blocks() as demo:
         alt_ft = gr.Number(value=35000, label="Altitude at start (ft)")
         vs_fpm = gr.Number(value=0, label="Vertical speed (ft/min) (negative = descent)")
         descent_start_choice = gr.Dropdown(
-            [
-                "None (constant VS from start)",
-                "At 00:20Z only",
-            ],
+            ["None (constant VS from start)", "At 00:20Z only"],
             value="None (constant VS from start)",
             label="When does descent start? (VS applies after this time)",
         )
@@ -1896,7 +2053,7 @@ with gr.Blocks() as demo:
         guided_btn = gr.Button("Generate: Guided scenario")
         manual_btn = gr.Button("Simulate: Manual legs")
 
-    # Hidden status (so the UI no longer shows the long guided report / scoring text)
+    # UI cleanup: keep status hidden
     status_md = gr.Markdown(visible=False)
 
     out_map = gr.HTML()