Update app.py

app.py

@@ -11,9 +11,11 @@
 # - 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
 #
-# IMPORTANT CHANGE (your request):
-# - Remove the extra purple "End" marker in guided mode.
-#   The final resting point is the 00:20 validation marker (not an extra end marker).
+# 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 (it disappeared previously)
+#    - Re-added full BFO analysis computation + chart + MAE/RMSE markdown.
 
 import os
 import re
@@ -61,12 +63,15 @@ RING_TIMES = {
     "Ping Ring 7": "24:10:00Z",
 }
 
+# Normalization (used for combining BFO + BTO into a single score in guided solve)
 BFO_SCALE_HZ = 5.0
 BTO_SCALE_US = 50.0
 
+# EXPLICIT WEIGHTS
 DEFAULT_WEIGHT_BFO = 1.0
 DEFAULT_WEIGHT_BTO = 2.0
 
+# satLoc indices
 SATLOC_IDX_MEAS_BFO = 4
 SATLOC_IDX_MEAS_BTO = 5
 
@@ -78,9 +83,11 @@ 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)
 TURN_WINDOW_MIN = (TURN_COMPLETE_TIME_UTC - RADAR_FIX_TIME_UTC).total_seconds() / 60.0
 
+# Initial track shown in your radar annotation
 RADAR_INITIAL_TRACK_DEG = 296.0
 
 # ===== Guided validation timestamps of interest =====
+# (00:10 and 00:20 are represented as 24:10 and 24:20 in your SAT epoch helper)
 GUIDED_VALIDATION_LABELS = [
     "18:22:00",
     "18:40:00",
@@ -91,6 +98,7 @@ GUIDED_VALIDATION_LABELS = [
     "24:10:00",  # 00:10Z
     "24:20:00",  # 00:20Z
 ]
+GUIDED_FINAL_LABEL = "24:20:00"  # 00:20Z FINAL RESTING POINT
 
 # Turn modeling parameters
 TURN_BANK_MIN_DEG = 15.0
@@ -98,13 +106,13 @@ TURN_BANK_MAX_DEG = 30.0
 TURN_BANK_DEFAULT_DEG = 25.0
 TURN_STEP_SEC = 30.0
 
-# Guided heading search
+# Guided heading search (south-ish)
 GUIDED_HEADING_MIN = 150.0
 GUIDED_HEADING_MAX = 210.0
 STRAIGHT_STEP_DEG = 0.5
 
-# Southern schedule
-GUIDED_LEG_SCHEDULE_MIN = [12.0, 60.0, 60.0, 60.0, 60.0, 90.0, 10.0]  # (kept as-is)
+# Southern schedule (kept)
+GUIDED_LEG_SCHEDULE_MIN = [12.0, 60.0, 60.0, 60.0, 60.0, 90.0, 10.0]
 
 # Drift
 DEFAULT_DRIFT_MAX_DEG = 2.0
@@ -411,9 +419,11 @@ def build_turn_legs(
 
     legs = []
 
+    # initial straight on radar track
     if straight_sec > 1.0:
         legs.append((h0, float(speed_knots), straight_sec / 60.0))
 
+    # discretized turn segments
     if turn_sec > 1.0 and delta_abs > 1e-6:
         step_sec = max(5.0, float(step_sec))
         n = int(math.ceil(turn_sec / step_sec))
@@ -439,45 +449,6 @@ def build_turn_legs(
     return legs, info
 
 
-# ================= SIM CORE + STATS =================
-def simulate_path(start_lat, start_lon, legs, method):
-    lat, lon = float(start_lat), float(start_lon)
-    pts = [(lat, lon)]
-    seg_dists_m = []
-    total_time_min = 0.0
-
-    for heading, speed_knots, minutes in legs:
-        dist_m = float(speed_knots) * 1852.0 * (float(minutes) / 60.0)
-        if method == "VINCENTY":
-            (lat, lon), _ = fp.vincenty_direct((lat, lon), float(heading), dist_m)
-        else:
-            lat, lon = fp.rhumb_direct((lat, lon), float(heading), dist_m)
-
-        pts.append((lat, lon))
-        seg_dists_m.append(dist_m)
-        total_time_min += float(minutes)
-
-    return pts, seg_dists_m, total_time_min
-
-
-def compute_stats(path_pts, seg_dists_m, total_time_min, legs):
-    total_dist_m = float(np.sum(seg_dists_m)) if seg_dists_m else 0.0
-    total_dist_km = total_dist_m / 1000.0
-    total_dist_nm = total_dist_m / 1852.0
-
-    total_time_hr = total_time_min / 60.0
-    avg_gs_knots = (total_dist_nm / total_time_hr) if total_time_hr > 0 else 0.0
-
-    end_lat, end_lon = path_pts[-1]
-    return "\n\n".join([
-        f"**Legs:** {len(legs)}",
-        f"**Total time:** {total_time_min:.1f} min ({total_time_hr:.2f} hr)",
-        f"**Total distance:** {total_dist_nm:.1f} nm ({total_dist_km:.1f} km)",
-        f"**Average ground speed:** {avg_gs_knots:.1f} kt",
-        f"**Final position (simulation end):** lat {end_lat:.4f}, lon {end_lon:.4f}",
-    ])
-
-
 # ================= TIME HELPERS =================
 def _parse_start_time(s: str) -> datetime:
     s = (s or "").strip()
@@ -551,7 +522,46 @@ def build_altitude_plot(start_dt: datetime, total_time_min: float, alt0_ft: floa
     return fig
 
 
-# ================= STATE AT EXACT TIME =================
+# ================= SIM CORE =================
+def simulate_path(start_lat, start_lon, legs, method):
+    lat, lon = float(start_lat), float(start_lon)
+    pts = [(lat, lon)]
+    seg_dists_m = []
+    total_time_min = 0.0
+
+    for heading, speed_knots, minutes in legs:
+        dist_m = float(speed_knots) * 1852.0 * (float(minutes) / 60.0)
+        if method == "VINCENTY":
+            (lat, lon), _ = fp.vincenty_direct((lat, lon), float(heading), dist_m)
+        else:
+            lat, lon = fp.rhumb_direct((lat, lon), float(heading), dist_m)
+
+        pts.append((lat, lon))
+        seg_dists_m.append(dist_m)
+        total_time_min += float(minutes)
+
+    return pts, seg_dists_m, total_time_min
+
+
+def compute_stats(path_pts, seg_dists_m, total_time_min, legs):
+    total_dist_m = float(np.sum(seg_dists_m)) if seg_dists_m else 0.0
+    total_dist_km = total_dist_m / 1000.0
+    total_dist_nm = total_dist_m / 1852.0
+
+    total_time_hr = total_time_min / 60.0
+    avg_gs_knots = (total_dist_nm / total_time_hr) if total_time_hr > 0 else 0.0
+
+    end_lat, end_lon = path_pts[-1]
+    return "\n\n".join([
+        f"**Legs:** {len(legs)}",
+        f"**Total time:** {total_time_min:.1f} min ({total_time_hr:.2f} hr)",
+        f"**Total distance:** {total_dist_nm:.1f} nm ({total_dist_km:.1f} km)",
+        f"**Average ground speed:** {avg_gs_knots:.1f} kt",
+        f"**Final position (polyline end):** lat {end_lat:.4f}, lon {end_lon:.4f}",
+    ])
+
+
+# ================= EXACT STATE HELPERS =================
 def _predict_state_from_leg_start(method, leg_start_lat, leg_start_lon, hdg_deg, spd_knots, t_inside_leg_sec):
     dist_m = float(spd_knots) * 1852.0 * (float(t_inside_leg_sec) / 3600.0)
     if method == "VINCENTY":
@@ -627,6 +637,143 @@ def _map_marker_times(start_dt, legs):
     return times
 
 
+# ================= CLIP TRAJECTORY TO 00:20 (GUIDED) =================
+def clip_legs_to_end_dt(legs, start_dt: datetime, end_dt: datetime):
+    """
+    Returns a new legs list truncated so total duration ends exactly at end_dt.
+    If legs already shorter than end_dt-start_dt, returns legs unchanged.
+    """
+    total_target_sec = (end_dt - start_dt).total_seconds()
+    if total_target_sec <= 0:
+        return []
+
+    out = []
+    remaining = float(total_target_sec)
+
+    for (hdg, spd, minutes) in legs:
+        sec = float(minutes) * 60.0
+        if remaining <= 0:
+            break
+        if sec <= remaining + 1e-9:
+            out.append((float(hdg), float(spd), float(minutes)))
+            remaining -= sec
+        else:
+            # truncate this leg
+            trunc_min = max(0.0, remaining / 60.0)
+            if trunc_min > 1e-6:
+                out.append((float(hdg), float(spd), float(trunc_min)))
+            remaining = 0.0
+            break
+
+    return out
+
+
+# ================= BFO ANALYSIS (RESTORED) =================
+def _ping_points_after(start_dt: datetime):
+    pts = []
+    for row in fp.satLoc:
+        label = fp._extract_time_string(row[0])
+        meas_bfo = row[SATLOC_IDX_MEAS_BFO]
+        meas_bto = row[SATLOC_IDX_MEAS_BTO]
+        if meas_bfo is None:
+            continue
+        try:
+            dt_ping = fp._time_label_to_dt(label, fp.SAT_EPOCH_UTC)
+        except Exception:
+            continue
+        if dt_ping < start_dt:
+            continue
+        pts.append((label, dt_ping, float(meas_bfo), None if meas_bto is None else float(meas_bto)))
+    return pts
+
+
+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("After Ping Ring 6"):
+        descent_start_dt = dt_ping6_utc()
+    elif (descent_start_choice or "").startswith("After Ping Ring 7"):
+        descent_start_dt = dt_ping7_utc()
+
+    leg_secs = [float(m) * 60.0 for _, _, m in legs]
+    boundaries = np.cumsum([0.0] + leg_secs)
+    total_end = float(boundaries[-1])
+
+    leg_start_positions = _precompute_leg_starts(start_lat, start_lon, legs, method)
+
+    x_labels, measured, calculated = [], [], []
+
+    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:
+            continue
+
+        i = int(np.searchsorted(boundaries, t_sec, side="right") - 1)
+        i = max(0, min(i, len(legs) - 1))
+        t_inside = float(t_sec) - float(boundaries[i])
+
+        leg_start_lat, leg_start_lon = leg_start_positions[i]
+        hdg, spd, _m = legs[i]
+
+        lat, lon = _predict_state_from_leg_start(method, leg_start_lat, leg_start_lon, hdg, spd, t_inside)
+
+        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
+
+        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) * 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)
+        measured.append(float(meas_bfo))
+        calculated.append(float(pred_bfo))
+
+    fig = go.Figure()
+    if not x_labels:
+        fig.update_layout(title="BFO Analysis", xaxis_title="Time", yaxis_title="Hz", height=520)
+        return fig, "**BFO scoring:** no valid ping points inside your simulated time window."
+
+    m_arr = np.array(measured, dtype=float)
+    c_arr = np.array(calculated, dtype=float)
+    err = c_arr - m_arr
+    mae = float(np.mean(np.abs(err)))
+    rmse = float(np.sqrt(np.mean(err * err)))
+
+    fig.add_trace(go.Scatter(
+        x=x_labels, y=measured,
+        mode="markers",
+        name="Measured BFO",
+        marker=dict(size=11, symbol="circle")
+    ))
+    fig.add_trace(go.Scatter(
+        x=x_labels, y=calculated,
+        mode="lines+markers",
+        name="Calculated BFO",
+        line=dict(width=3),
+        marker=dict(size=10, symbol="diamond")
+    ))
+    fig.update_layout(
+        title="BFO Analysis",
+        xaxis_title="Time",
+        yaxis_title="Hz",
+        legend=dict(x=1.02, y=1.0),
+        margin=dict(l=60, r=160, t=80, b=60),
+        height=520,
+    )
+
+    score_md = (
+        f"**BFO scoring (Hz)**\n\n"
+        f"- Points: **{len(m_arr)}**\n"
+        f"- MAE: **{mae:.2f} Hz**\n"
+        f"- RMSE: **{rmse:.2f} Hz**"
+    )
+    return fig, score_md
+
+
 # ================= VALIDATION TABLE =================
 def _lookup_measured_at_dt(dt_ping: datetime):
     if hasattr(fp, "nearest_measured_for_time"):
@@ -752,7 +899,8 @@ def build_leaflet_map(path_pts, legs, method, start_dt):
     - Ping rings always drawn
     - Search areas always drawn (color-coded)
     - Validation markers are the authoritative markers
-    - IMPORTANT: Guided mode does NOT draw the extra purple "End" marker.
+    - Guided mode does NOT draw a purple End marker
+    - Trajectory is clipped to 00:20 in guided mode by clipping legs before simulate_path
     """
     start_lat, start_lon = path_pts[0]
     is_guided = (start_dt == RADAR_FIX_TIME_UTC)
@@ -835,7 +983,7 @@ def build_leaflet_map(path_pts, legs, method, start_dt):
         tooltip = f"{ring_name} ({ring_time})" if ring_time else ring_name
         folium.PolyLine(ring_pts, weight=2, opacity=0.6, color="yellow", tooltip=tooltip).add_to(m)
 
-    # Flight path
+    # Flight path (polyline)
     folium.PolyLine(path_pts, color="white", weight=8, opacity=0.3).add_to(m)
     folium.PolyLine(path_pts, color="red", weight=4, opacity=1.0, tooltip="Flight path").add_to(m)
 
@@ -852,8 +1000,7 @@ def build_leaflet_map(path_pts, legs, method, start_dt):
         ),
     ).add_to(m)
 
-    # ✅ IMPORTANT: remove the purple End marker in guided mode.
-    # Manual mode can still show it as a convenience.
+    # Manual mode can show an "End" marker. Guided mode: no extra end marker.
     if not is_guided:
         folium.CircleMarker(
             location=path_pts[-1],
@@ -875,6 +1022,7 @@ def build_leaflet_map(path_pts, legs, method, start_dt):
         st = _state_at_dt(path_pts[0][0], path_pts[0][1], legs, method, start_dt, dt_k)
         if st is None:
             continue
+
         lat = st["lat"]
         lon = st["lon"]
         marker_pts_for_bounds.append((lat, lon))
@@ -885,8 +1033,10 @@ def build_leaflet_map(path_pts, legs, method, start_dt):
         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>Validation point</b>",
+            f"<b>{'FINAL RESTING POINT' if is_final else 'Validation point'}</b>",
             f"UTC time: {tlabel}",
             f"Lat: {lat:.5f}",
             f"Lon: {lon:.5f}",
@@ -896,16 +1046,29 @@ def build_leaflet_map(path_pts, legs, method, start_dt):
             f"Distance flown: {dist_km:.2f} km",
         ]
 
-        folium.CircleMarker(
-            location=(lat, lon),
-            radius=6,
-            fill=True,
-            color="white",
-            fill_color="white",
-            fill_opacity=1.0,
-            tooltip=tlabel,
-            popup=folium.Popup("<br>".join(popup_lines), max_width=360),
-        ).add_to(m)
+        # Make final point visually distinct
+        if is_final:
+            folium.CircleMarker(
+                location=(lat, lon),
+                radius=9,
+                fill=True,
+                color="magenta",
+                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(
+                location=(lat, lon),
+                radius=6,
+                fill=True,
+                color="white",
+                fill_color="white",
+                fill_opacity=1.0,
+                tooltip=tlabel,
+                popup=folium.Popup("<br>".join(popup_lines), max_width=360),
+            ).add_to(m)
 
     # Permanent labels
     for name, lat, lon in WAYPOINTS:
@@ -987,125 +1150,30 @@ def make_legs_from_schedule(headings, speed_knots, schedule_minutes):
     return legs
 
 
-# ================= Minimal Scoring (kept from your previous working builds) =================
-def _ping_points_after(start_dt: datetime):
-    pts = []
-    for row in fp.satLoc:
-        label = fp._extract_time_string(row[0])
-        meas_bfo = row[SATLOC_IDX_MEAS_BFO]
-        meas_bto = row[SATLOC_IDX_MEAS_BTO]
-        if meas_bfo is None:
-            continue
-        try:
-            dt_ping = fp._time_label_to_dt(label, fp.SAT_EPOCH_UTC)
-        except Exception:
-            continue
-        if dt_ping < start_dt:
-            continue
-        pts.append((label, dt_ping, float(meas_bfo), None if meas_bto is None else float(meas_bto)))
-    return pts
-
-
-def score_legs_bfo_bto(
-    start_lat, start_lon, method, start_dt, end_dt, legs,
-    alt_ft, vs_fpm, descent_start_dt,
-    weight_bfo: float, weight_bto: float
-):
-    pts = _ping_points_after(start_dt)
-    pts = [(lbl, dt, bfo, bto) for (lbl, dt, bfo, bto) in pts if start_dt <= dt <= end_dt]
-    if len(pts) < 2:
-        return None
-
-    leg_secs = [float(m) * 60.0 for _, _, m in legs]
-    boundaries = np.cumsum([0.0] + leg_secs)
-    total_end = boundaries[-1]
-
-    leg_start_positions = _precompute_leg_starts(start_lat, start_lon, legs, method)
-
-    bfo_preds, bfo_meas = [], []
-    bto_preds, bto_meas = [], []
-
-    for _lbl, 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:
-            continue
-
-        i = int(np.searchsorted(boundaries, t_sec, side="right") - 1)
-        i = max(0, min(i, len(legs) - 1))
-        t_inside = t_sec - boundaries[i]
-
-        leg_start_lat, leg_start_lon = leg_start_positions[i]
-        hdg, spd, _ = legs[i]
-        lat, lon = _predict_state_from_leg_start(method, leg_start_lat, leg_start_lon, hdg, spd, t_inside)
-
-        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
-
-        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) * 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))
-        bfo_preds.append(pred_bfo)
-        bfo_meas.append(float(meas_bfo))
-
-        if meas_bto is not None:
-            pred_bto = float(fp.calculateBTO_at_time(float(lat), float(lon), alt_m, dt_ping))
-            bto_preds.append(pred_bto)
-            bto_meas.append(float(meas_bto))
-
-    if len(bfo_meas) < 2:
-        return None
-
-    e_bfo = np.array(bfo_preds) - np.array(bfo_meas)
-    rmse_bfo = float(np.sqrt(np.mean(e_bfo * e_bfo)))
-
-    rmse_bto = None
-    if len(bto_meas) >= 2:
-        e_bto = np.array(bto_preds) - np.array(bto_meas)
-        rmse_bto = float(np.sqrt(np.mean(e_bto * e_bto)))
-
-    combined = float(weight_bfo) * (rmse_bfo / BFO_SCALE_HZ)
-    if rmse_bto is not None:
-        combined += float(weight_bto) * (rmse_bto / BTO_SCALE_US)
-
-    return {
-        "n_bfo": len(bfo_meas),
-        "n_bto": len(bto_meas),
-        "rmse_bfo": rmse_bfo,
-        "rmse_bto": rmse_bto,
-        "combined": combined,
-    }
-
-
 # ================= Guided Solvers =================
 def _guided_start_dt():
     return RADAR_FIX_TIME_UTC
 
 
-def _guided_end_dt():
-    total_min = TURN_WINDOW_MIN + float(np.sum(GUIDED_LEG_SCHEDULE_MIN))
-    return RADAR_FIX_TIME_UTC + timedelta(minutes=total_min)
-
-
 def solve_guided_straight(
     method, speed_knots, alt_ft, vs_fpm,
     descent_start_choice, weight_bfo, weight_bto
 ):
+    # We clip everything to final 00:20Z; end_dt is fixed by label.
     start_dt = _guided_start_dt()
-    end_dt = _guided_end_dt()
+    end_dt = _dt_from_label(GUIDED_FINAL_LABEL)
 
+    best_h = None
+    best_full_legs = None
+    best_score = None
+
+    # descent start
     descent_start_dt = None
     if (descent_start_choice or "").startswith("After Ping Ring 6"):
         descent_start_dt = dt_ping6_utc()
     elif (descent_start_choice or "").startswith("After Ping Ring 7"):
         descent_start_dt = dt_ping7_utc()
 
-    best = None
-    best_h = None
-    best_full_legs = None
-
     h = GUIDED_HEADING_MIN
     while h <= GUIDED_HEADING_MAX + 1e-9:
         southern_legs = make_legs_from_schedule(h, float(speed_knots), GUIDED_LEG_SCHEDULE_MIN)
@@ -1116,27 +1184,32 @@ def solve_guided_straight(
         )
         full_legs = preturn_legs + southern_legs
 
+        # clip to 00:20 so scoring window and plotting window are consistent
+        full_legs = clip_legs_to_end_dt(full_legs, start_dt, end_dt)
+
+        # score using BFO/BTO inside start_dt→end_dt duration only
         s = score_legs_bfo_bto(
             RADAR_FIX_LAT, RADAR_FIX_LON, method, start_dt, end_dt, full_legs,
             alt_ft, vs_fpm, descent_start_dt,
             weight_bfo, weight_bto
         )
-        if s is not None and (best is None or s["combined"] < best["combined"]):
-            best = s
+        if s is not None and (best_score is None or s["combined"] < best_score["combined"]):
+            best_score = s
             best_h = float(h)
             best_full_legs = full_legs
 
         h += STRAIGHT_STEP_DEG
 
-    if best is None or best_full_legs is None:
+    if best_full_legs is None:
         return None, "Guided solve: not enough ping points to score.", None
 
     report = "\n".join([
-        "**Guided mode: Straight + computed turn (18:22→18:40)**",
+        "**Guided mode: Straight + computed turn (18:22→18:40), clipped to 00:20**",
         f"- Speed (constrained): **{float(speed_knots):.1f} kt**",
         f"- Best southern heading: **{best_h:.1f}°**",
-        f"- Fit: RMSE_BFO **{best['rmse_bfo']:.2f} Hz**, RMSE_BTO **{best['rmse_bto']:.1f} µs**" if best.get("rmse_bto") is not None else
-        f"- Fit: RMSE_BFO **{best['rmse_bfo']:.2f} Hz** (BTO n/a)"
+        f"- BFO points: **{best_score['n_bfo']}** | RMSE_BFO: **{best_score['rmse_bfo']:.2f} Hz**",
+        f"- BTO points: **{best_score['n_bto']}** | RMSE_BTO: **{best_score['rmse_bto']:.1f} µs**" if best_score.get("rmse_bto") is not None else
+        f"- BTO points: **{best_score['n_bto']}** | RMSE_BTO: n/a",
     ])
 
     return best_full_legs, report, start_dt
@@ -1147,67 +1220,168 @@ def solve_guided_straight_with_drift(
     descent_start_choice, weight_bfo, weight_bto,
     drift_max_deg, drift_weight
 ):
-    # For this simplified file, we keep drift solver basic:
-    # - drift applies by perturbing the southern heading by +/- drift_max around nominal and picking best.
+    # lightweight drift version: use nominal heading search, but add a small constant drift
     start_dt = _guided_start_dt()
-    end_dt = _guided_end_dt()
+    end_dt = _dt_from_label(GUIDED_FINAL_LABEL)
+
+    best_h0 = None
+    best_full_legs = None
+    best_score = None
 
+    # descent start
     descent_start_dt = None
     if (descent_start_choice or "").startswith("After Ping Ring 6"):
         descent_start_dt = dt_ping6_utc()
     elif (descent_start_choice or "").startswith("After Ping Ring 7"):
         descent_start_dt = dt_ping7_utc()
 
-    best = None
-    best_h0 = None
-    best_full_legs = None
+    # try drift candidates within ±drift_max_deg
+    drift_candidates = list(np.arange(-float(drift_max_deg), float(drift_max_deg) + 1e-9, DRIFT_STEP_DEG))
+    if not drift_candidates:
+        drift_candidates = [0.0]
 
     h0 = GUIDED_HEADING_MIN
     while h0 <= GUIDED_HEADING_MAX + 1e-9:
-        # apply a constant drift to ALL legs (lightweight drift version)
-        drift = float(np.clip(0.0, -float(drift_max_deg), float(drift_max_deg)))
-        h_eff = _wrap_heading_deg(float(h0) + drift)
+        for d in drift_candidates:
+            h_eff = _wrap_heading_deg(float(h0) + float(d))
+
+            southern_legs = make_legs_from_schedule(h_eff, float(speed_knots), GUIDED_LEG_SCHEDULE_MIN)
+            preturn_legs, _turn_info = build_turn_legs(
+                speed_knots=float(speed_knots),
+                method=method,
+                heading_final_deg=float(h_eff),
+            )
+            full_legs = preturn_legs + southern_legs
+
+            # clip to 00:20
+            full_legs = clip_legs_to_end_dt(full_legs, start_dt, end_dt)
+
+            s = score_legs_bfo_bto(
+                RADAR_FIX_LAT, RADAR_FIX_LON, method, start_dt, end_dt, full_legs,
+                alt_ft, vs_fpm, descent_start_dt,
+                weight_bfo, weight_bto
+            )
+            if s is None:
+                continue
 
-        southern_legs = make_legs_from_schedule(h_eff, float(speed_knots), GUIDED_LEG_SCHEDULE_MIN)
-        preturn_legs, _turn_info = build_turn_legs(
-            speed_knots=float(speed_knots),
-            method=method,
-            heading_final_deg=float(h_eff),
-        )
-        full_legs = preturn_legs + southern_legs
+            # add drift penalty (RMS here is just |d| for constant drift)
+            combined = float(s["combined"]) + float(drift_weight) * (abs(float(d)) / DRIFT_SCALE_DEG)
 
-        s = score_legs_bfo_bto(
-            RADAR_FIX_LAT, RADAR_FIX_LON, method, start_dt, end_dt, full_legs,
-            alt_ft, vs_fpm, descent_start_dt,
-            weight_bfo, weight_bto
-        )
-        if s is not None and (best is None or s["combined"] < best["combined"]):
-            best = s
-            best_h0 = float(h0)
-            best_full_legs = full_legs
+            if best_score is None or combined < best_score["combined_plus"]:
+                best_score = dict(s)
+                best_score["combined_plus"] = combined
+                best_score["drift_used"] = float(d)
+                best_h0 = float(h0)
+                best_full_legs = full_legs
 
         h0 += 1.0
 
-    if best is None or best_full_legs is None:
+    if best_full_legs is None:
         return None, "Guided drift solve: not enough ping points to score.", None
 
     report = "\n".join([
-        "**Guided mode: Straight + drift + computed turn (18:22→18:40)**",
+        "**Guided mode: Straight + drift + computed turn (18:22→18:40), clipped to 00:20**",
         f"- Speed (constrained): **{float(speed_knots):.1f} kt**",
         f"- Best nominal heading: **{best_h0:.1f}°**",
-        f"- Fit: RMSE_BFO **{best['rmse_bfo']:.2f} Hz**, RMSE_BTO **{best['rmse_bto']:.1f} µs**" if best.get("rmse_bto") is not None else
-        f"- Fit: RMSE_BFO **{best['rmse_bfo']:.2f} Hz** (BTO n/a)"
+        f"- Drift used: **{best_score.get('drift_used', 0.0):+.1f}°** | Drift penalty weight: **{float(drift_weight):.2f}**",
+        f"- BFO points: **{best_score['n_bfo']}** | RMSE_BFO: **{best_score['rmse_bfo']:.2f} Hz**",
+        f"- BTO points: **{best_score['n_bto']}** | RMSE_BTO: **{best_score['rmse_bto']:.1f} µs**" if best_score.get("rmse_bto") is not None else
+        f"- BTO points: **{best_score['n_bto']}** | RMSE_BTO: n/a",
     ])
 
     return best_full_legs, report, start_dt
 
 
+# ================= Scoring helper (used in guided solvers) =================
+def score_legs_bfo_bto(
+    start_lat, start_lon, method, start_dt, end_dt, legs,
+    alt_ft, vs_fpm, descent_start_dt,
+    weight_bfo: float, weight_bto: float
+):
+    pts = _ping_points_after(start_dt)
+    pts = [(lbl, dt, bfo, bto) for (lbl, dt, bfo, bto) in pts if start_dt <= dt <= end_dt]
+    if len(pts) < 2:
+        return None
+
+    leg_secs = [float(m) * 60.0 for _, _, m in legs]
+    boundaries = np.cumsum([0.0] + leg_secs)
+    total_end = float(boundaries[-1])
+
+    leg_start_positions = _precompute_leg_starts(start_lat, start_lon, legs, method)
+
+    bfo_preds, bfo_meas = [], []
+    bto_preds, bto_meas = [], []
+
+    for _lbl, 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:
+            continue
+
+        i = int(np.searchsorted(boundaries, t_sec, side="right") - 1)
+        i = max(0, min(i, len(legs) - 1))
+        t_inside = float(t_sec) - float(boundaries[i])
+
+        leg_start_lat, leg_start_lon = leg_start_positions[i]
+        hdg, spd, _ = legs[i]
+        lat, lon = _predict_state_from_leg_start(method, leg_start_lat, leg_start_lon, hdg, spd, t_inside)
+
+        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
+
+        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) * 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))
+        bfo_preds.append(pred_bfo)
+        bfo_meas.append(float(meas_bfo))
+
+        if meas_bto is not None:
+            pred_bto = float(fp.calculateBTO_at_time(float(lat), float(lon), alt_m, dt_ping))
+            bto_preds.append(pred_bto)
+            bto_meas.append(float(meas_bto))
+
+    if len(bfo_meas) < 2:
+        return None
+
+    e_bfo = np.array(bfo_preds) - np.array(bfo_meas)
+    rmse_bfo = float(np.sqrt(np.mean(e_bfo * e_bfo)))
+
+    rmse_bto = None
+    if len(bto_meas) >= 2:
+        e_bto = np.array(bto_preds) - np.array(bto_meas)
+        rmse_bto = float(np.sqrt(np.mean(e_bto * e_bto)))
+
+    combined = float(weight_bfo) * (rmse_bfo / BFO_SCALE_HZ)
+    if rmse_bto is not None:
+        combined += float(weight_bto) * (rmse_bto / BTO_SCALE_US)
+
+    return {
+        "n_bfo": len(bfo_meas),
+        "n_bto": len(bto_meas),
+        "rmse_bfo": rmse_bfo,
+        "rmse_bto": rmse_bto,
+        "combined": combined,
+    }
+
+
 # ================= RUNNERS =================
 def _run_common(start_lat, start_lon, legs, method, start_dt, alt_ft, vs_fpm, descent_start_choice):
-    path_pts, _seg_dists_m, total_time_min = simulate_path(start_lat, start_lon, legs, method)
+    # In guided mode, ensure the polyline ends at 00:20 by clipping legs to end_dt first.
+    if start_dt == RADAR_FIX_TIME_UTC:
+        end_dt = _dt_from_label(GUIDED_FINAL_LABEL)
+        legs = clip_legs_to_end_dt(legs, start_dt, end_dt)
+
+    path_pts, seg_dists_m, total_time_min = simulate_path(start_lat, start_lon, legs, method)
 
     html_map = build_leaflet_map(path_pts, legs, method, start_dt)
-    stats_md = compute_stats(path_pts, _seg_dists_m, total_time_min, legs)
+    stats_md = compute_stats(path_pts, seg_dists_m, total_time_min, legs)
+
+    # BFO plot (restored)
+    bfo_fig, bfo_md = bfo_analysis_with_legs(
+        start_lat, start_lon, legs, method, start_dt, alt_ft, vs_fpm, descent_start_choice
+    )
 
     descent_start_dt = None
     if (descent_start_choice or "").startswith("After Ping Ring 6"):
@@ -1220,17 +1394,13 @@ def _run_common(start_lat, start_lon, legs, method, start_dt, alt_ft, vs_fpm, de
         start_lat, start_lon, method, start_dt, legs, alt_ft, vs_fpm, descent_start_choice
     )
 
-    # lightweight empty BFO plot placeholder (your earlier full version had full BFO graph)
-    bfo_fig = go.Figure()
-    bfo_fig.update_layout(title="BFO Analysis", xaxis_title="Time", yaxis_title="Hz", height=520)
-    bfo_md = ""
-
     return html_map, stats_md, bfo_fig, bfo_md, alt_fig, headers, rows
 
 
 def run_sim_manual(start_lat, start_lon, legs_df, method, start_time_str, alt_ft, vs_fpm, descent_start_choice):
     legs = parse_legs_df(legs_df)
     start_dt = _parse_start_time(start_time_str)
+
     html_map, stats_md, bfo_fig, bfo_md, alt_fig, headers, rows = _run_common(
         start_lat, start_lon, legs, method, start_dt, alt_ft, vs_fpm, descent_start_choice
     )
@@ -1271,6 +1441,7 @@ def run_guided(
         ], value=[])
         return gr.update(), f"### ❌ {report_md}", "", "", fig, "", alt_fig, empty_table
 
+    # Guided always starts at radar fix
     html_map, stats_md, bfo_fig, bfo_md, alt_fig, headers, rows = _run_common(
         RADAR_FIX_LAT, RADAR_FIX_LON, legs, method, start_dt, alt_ft, vs_fpm, descent_start_choice
     )
@@ -1301,7 +1472,7 @@ with gr.Blocks() as demo:
         f"- **Last radar spot (fixed):** 18:22:00Z @ **{RADAR_FIX_LAT:.3f}N, {RADAR_FIX_LON:.3f}E**\n"
         f"- **Turn completion (fixed):** 18:40:00Z\n"
         f"- **Initial track (fixed):** {RADAR_INITIAL_TRACK_DEG:.1f}°\n"
-        f"- **Final resting point is the 00:20 validation marker** (no extra purple end marker in guided mode)"
+        f"- **Final resting point:** **00:20:00Z** (trajectory clipped exactly at this time)"
     )
 
     with gr.Row():