Update app.py

app.py

@@ -8,16 +8,17 @@
 # Key behavior:
 # - Last radar spot FIXED: 18:22:00Z @ 6.578N, 96.341E
 # - Turn completion FIXED TIME: 18:40:00Z
-# - 18:40 lat/lon is AUTHORITATIVE (hard-fixed) via sliders.
-# - NEW (important): Program finds the *best* turn (bank + timing + speed factor) automatically.
-#   No user bank angle. No ugly kinked paths.
+# - NEW: Turn completion LOCATION (18:40 lat/lon) is USER-ADJUSTABLE via sliders.
+# - Guided mode computes a realistic turn between 18:22→18:40 that ENDS at the 18:40 lat/lon,
+#   and then simulates/solves the southern path.
 # - Guided validation timestamps: 18:22, 18:40, 19:40, 20:40, 21:40, 22:40, 00:10, 00:20
 #
-# FIXES IMPLEMENTED:
-# 1) Remove trajectory (red line) AFTER 00:20 (guided) by clipping legs to 00:20
-# 2) Restore BFO plot
-# 3) 18:40 is a hard waypoint (no “approx error”); solver produces a smooth turn and then snaps a *tiny*
-#    correction segment (normally meters) if needed.
+# 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.
+# 3) NEW: 18:40 turn completion lat/lon sliders drive the guided preturn geometry (plausible turn).
 
 import os
 import re
@@ -88,7 +89,7 @@ TURN_WINDOW_MIN = (TURN_COMPLETE_TIME_UTC - RADAR_FIX_TIME_UTC).total_seconds()
 # Initial track shown in your radar annotation
 RADAR_INITIAL_TRACK_DEG = 296.0
 
-# ===== Default 18:40 turn completion location (user can override with sliders) =====
+# ===== NEW: Default 18:40 turn completion location (user can override with sliders) =====
 TURN_COMPLETE_DEFAULT_LAT = 6.76
 TURN_COMPLETE_DEFAULT_LON = 95.69
 
@@ -106,24 +107,16 @@ GUIDED_VALIDATION_LABELS = [
 ]
 GUIDED_FINAL_LABEL = "24:20:00"  # 00:20Z FINAL RESTING POINT
 
-# Turn solver search space (automatic)
-TURN_BANK_MIN_DEG = 10.0
-TURN_BANK_MAX_DEG = 35.0
+# Turn modeling parameters
+TURN_BANK_MIN_DEG = 15.0
+TURN_BANK_MAX_DEG = 30.0
+TURN_BANK_DEFAULT_DEG = 15.0
+TURN_STEP_SEC = 30.0
 
-TURN_SIM_DT_SEC = 10.0  # internal turn integration resolution (smaller = smoother, slower)
-TURN_PRE_FRAC_STEP_COARSE = 0.05
-TURN_PRE_FRAC_STEP_FINE = 0.01
-TURN_BANK_STEP_COARSE = 1.0
-TURN_BANK_STEP_FINE = 0.25
-TURN_SPEEDFAC_STEP_COARSE = 0.02
-TURN_SPEEDFAC_STEP_FINE = 0.005
-
-TURN_SPEEDFAC_MIN = 0.70
-TURN_SPEEDFAC_MAX = 1.30
-
-# If the best-fit endpoint is still off by a little, add a tiny correction segment to hit the waypoint exactly.
-TURN_FINAL_SNAP_MAX_KM = 2.0      # if worse than this, we report it (should not happen normally)
-TURN_FINAL_SNAP_SEC = 10.0        # duration of final snap segment (small)
+# NEW: How tightly we try to hit the 18:40 point (km)
+TURN_POINT_TOL_KM = 0.50  # "hit" tolerance for reporting; solver still picks best even if > tol
+TURN_PRESEARCH_COARSE_SEC = 10.0  # coarse grid for pre-straight duration
+TURN_PRESEARCH_FINE_SEC = 1.0     # refinement grid around the best coarse solution
 
 # Guided heading search (south-ish)
 GUIDED_HEADING_MIN = 150.0
@@ -137,6 +130,7 @@ GUIDED_LEG_SCHEDULE_MIN = [12.0, 60.0, 60.0, 60.0, 60.0, 90.0, 10.0]
 DEFAULT_DRIFT_MAX_DEG = 2.0
 DRIFT_STEP_DEG = 0.5
 DEFAULT_WEIGHT_DRIFT = 0.30
+DEFAULT_DRIFT_ITERS = 2
 DRIFT_SCALE_DEG = 1.0
 
 # Search area colors (optional)
@@ -395,6 +389,7 @@ def _turn_rate_deg_per_sec(speed_knots: float, bank_deg: float) -> float:
 
 
 def _haversine_km(lat1, lon1, lat2, lon2) -> float:
+    # quick & stable for our error scoring (km)
     R = 6371.0
     phi1 = math.radians(float(lat1))
     phi2 = math.radians(float(lat2))
@@ -404,16 +399,6 @@ def _haversine_km(lat1, lon1, lat2, lon2) -> float:
     return 2 * R * math.asin(min(1.0, math.sqrt(a)))
 
 
-def _initial_bearing_deg(lat1, lon1, lat2, lon2) -> float:
-    phi1 = math.radians(float(lat1))
-    phi2 = math.radians(float(lat2))
-    dl = math.radians(float(lon2) - float(lon1))
-    y = math.sin(dl) * math.cos(phi2)
-    x = math.cos(phi1) * math.sin(phi2) - math.sin(phi1) * math.cos(phi2) * math.cos(dl)
-    brng = math.degrees(math.atan2(y, x))
-    return (brng + 360.0) % 360.0
-
-
 def _direct(method: str, lat: float, lon: float, heading_deg: float, dist_m: float):
     if method == "VINCENTY":
         (lat2, lon2), _ = fp.vincenty_direct((float(lat), float(lon)), float(heading_deg), float(dist_m))
@@ -422,195 +407,237 @@ def _direct(method: str, lat: float, lon: float, heading_deg: float, dist_m: flo
     return float(lat2), float(lon2)
 
 
-# ================= TURN SOLVER (AUTOMATIC “BEST TURN”) =================
-def _simulate_turn_window(
+def _simulate_discretized_turn(
     method: str,
+    lat0: float,
+    lon0: float,
     speed_knots: float,
     h0: float,
     h1: float,
-    bank_deg: float,
-    pre_frac: float,
-    dt_sec: float,
+    turn_sec: float,
+    sign: float,
+    delta_abs: float,
+    step_sec: float
+):
+    # Returns endpoint after flying the discretized turn with mid-heading sampling
+    lat, lon = float(lat0), float(lon0)
+    if turn_sec <= 1e-9 or delta_abs <= 1e-9:
+        return lat, lon
+
+    step_sec = max(5.0, float(step_sec))
+    n = int(math.ceil(float(turn_sec) / step_sec))
+    if n < 1:
+        n = 1
+
+    remaining = float(turn_sec)
+    for i in range(n):
+        this = min(step_sec, remaining)
+        remaining -= this
+        frac_mid = (i + 0.5) / n
+        hdg_mid = _wrap_heading_deg(float(h0) + float(sign) * float(delta_abs) * float(frac_mid))
+        dist_m = float(speed_knots) * 1852.0 * (float(this) / 3600.0)
+        lat, lon = _direct(method, lat, lon, hdg_mid, dist_m)
+
+    return lat, lon
+
+
+def build_turn_legs_to_point(
+    speed_knots: float,
+    method: str,
+    heading_final_deg: float,
+    target_lat: float,
+    target_lon: float,
+    bank_pref_deg: float = TURN_BANK_DEFAULT_DEG,
+    step_sec: float = TURN_STEP_SEC,
 ):
     """
-    Simulate 18:22→18:40 as:
-      pre-straight at h0 for t_pre
-      constant-bank coordinated turn changing heading at omega for t_turn (to reach h1)
-      post-straight at h1 for remaining time
-    Returns final (lat,lon) plus a list of micro-legs (heading, speed, minutes) for the full window.
+    Build a plausible 18:22→18:40 turn profile that:
+    - starts on RADAR_INITIAL_TRACK_DEG
+    - ends at (target_lat, target_lon) exactly at TURN_COMPLETE_TIME_UTC (as close as numerically possible)
+    - ends with heading = heading_final_deg (start of southern leg)
+    - keeps constant speed_knots during the whole window
+    Model:
+      pre-straight on h0 for t_pre
+      constant-bank discretized turn to h1 for t_turn (from bank angle)
+      post-straight on h1 for t_post
+      with t_pre + t_turn + t_post = total
+    We brute-force t_pre (grid) and bank candidate to minimize endpoint error (km).
     """
     total_sec = (TURN_COMPLETE_TIME_UTC - RADAR_FIX_TIME_UTC).total_seconds()
     if total_sec <= 0:
-        return (RADAR_FIX_LAT, RADAR_FIX_LON), []
-
-    bank_deg = float(bank_deg)
-    speed_knots = float(speed_knots)
-    dt_sec = max(5.0, float(dt_sec))
+        return [], {"error": "Invalid turn window."}
 
+    h0 = float(RADAR_INITIAL_TRACK_DEG)
+    h1 = _wrap_heading_deg(float(heading_final_deg))
     delta = _shortest_signed_delta_deg(h0, h1)
     sign = 1.0 if delta >= 0 else -1.0
     delta_abs = abs(delta)
 
-    # turn time based on coordinated turn rate
-    rate = max(1e-6, _turn_rate_deg_per_sec(speed_knots, bank_deg))
-    t_turn = delta_abs / rate
-    t_turn = min(t_turn, total_sec)
+    # Quick feasibility check: the endpoint straight-line distance must not exceed path length budget
+    L_km = float(speed_knots) * 1.852 * (float(total_sec) / 3600.0)
+    d_km = _haversine_km(RADAR_FIX_LAT, RADAR_FIX_LON, float(target_lat), float(target_lon))
+    if d_km > L_km + 1e-6:
+        return [], {
+            "error": (
+                f"18:40 point is too far for the 18-minute window at {float(speed_knots):.1f} kt.\n"
+                f"Straight-line distance: {d_km:.1f} km; path-length budget: {L_km:.1f} km."
+            ),
+            "d_km": d_km,
+            "L_km": L_km,
+            "h0": h0,
+            "h1": h1,
+            "delta_deg": delta,
+        }
 
-    rem = max(0.0, total_sec - t_turn)
-    t_pre = float(pre_frac) * rem
-    t_post = rem - t_pre
+    bank_candidates = [float(bank_pref_deg)] + list(np.linspace(TURN_BANK_MIN_DEG, TURN_BANK_MAX_DEG, 9))
+    bank_candidates = sorted(list({round(b, 6): b for b in bank_candidates}.values()))
 
-    lat, lon = float(RADAR_FIX_LAT), float(RADAR_FIX_LON)
-    legs = []
+    best = None  # dict with error_km, bank, t_pre, t_turn, t_post, end_lat, end_lon
 
-    def _do_segment(hdg, seg_sec):
-        nonlocal lat, lon, legs
-        if seg_sec <= 0.1:
-            return
-        # break into dt steps
-        n = int(math.ceil(seg_sec / dt_sec))
-        for i in range(n):
-            this = min(dt_sec, seg_sec - i * dt_sec)
-            if this <= 0:
-                break
-            legs.append((float(hdg), float(speed_knots), float(this) / 60.0))
-            dist_m = speed_knots * 1852.0 * (this / 3600.0)
-            lat, lon = _direct(method, lat, lon, float(hdg), dist_m)
+    # coarse grid search
+    coarse = float(TURN_PRESEARCH_COARSE_SEC)
+    pre_candidates = np.arange(0.0, max(0.0, total_sec) + 1e-9, coarse)
 
-    # pre straight
-    _do_segment(h0, t_pre)
+    for b in bank_candidates:
+        rate = _turn_rate_deg_per_sec(speed_knots, b)
+        if rate <= 1e-9:
+            continue
+        t_turn = 0.0 if delta_abs <= 1e-9 else (delta_abs / rate)
+        t_turn = max(0.0, min(float(t_turn), float(total_sec)))
 
-    # turn: heading changes smoothly while moving
-    if t_turn > 0.1 and delta_abs > 1e-6:
-        n = int(math.ceil(t_turn / dt_sec))
-        for i in range(n):
-            this = min(dt_sec, t_turn - i * dt_sec)
-            if this <= 0:
-                break
-            # heading at mid-step
-            frac = (min(t_turn, (i + 0.5) * dt_sec) / t_turn)
-            hdg = _wrap_heading_deg(h0 + sign * delta_abs * frac)
-            legs.append((float(hdg), float(speed_knots), float(this) / 60.0))
-            dist_m = speed_knots * 1852.0 * (this / 3600.0)
-            lat, lon = _direct(method, lat, lon, float(hdg), dist_m)
+        for t_pre in pre_candidates:
+            t_post = float(total_sec) - float(t_pre) - float(t_turn)
+            if t_post < -1e-9:
+                continue
+            t_post = max(0.0, t_post)
 
-    # post straight
-    _do_segment(h1, t_post)
+            # simulate:
+            lat, lon = float(RADAR_FIX_LAT), float(RADAR_FIX_LON)
 
-    return (lat, lon), legs
+            # pre straight
+            if t_pre > 1e-9:
+                dist_m = float(speed_knots) * 1852.0 * (float(t_pre) / 3600.0)
+                lat, lon = _direct(method, lat, lon, h0, dist_m)
 
+            # turn
+            lat, lon = _simulate_discretized_turn(
+                method, lat, lon, speed_knots,
+                h0, h1, t_turn, sign, delta_abs, step_sec
+            )
 
-def build_turn_legs_best(
-    method: str,
-    speed_knots_nominal: float,
-    heading_final_deg: float,
-    target_lat: float,
-    target_lon: float,
-):
-    """
-    Finds the best (bank, pre_straight_frac, speed_factor) to land at 18:40 as smoothly as possible.
-    Produces legs for 18:22→18:40 that are already smooth.
-    If residual error remains, adds a tiny “snap” segment to hit the waypoint exactly (usually meters).
-    """
-    h0 = float(RADAR_INITIAL_TRACK_DEG)
-    h1 = _wrap_heading_deg(float(heading_final_deg))
+            # post straight
+            if t_post > 1e-9:
+                dist_m = float(speed_knots) * 1852.0 * (float(t_post) / 3600.0)
+                lat, lon = _direct(method, lat, lon, h1, dist_m)
+
+            err_km = _haversine_km(lat, lon, float(target_lat), float(target_lon))
+
+            if best is None or err_km < best["error_km"]:
+                best = {
+                    "error_km": float(err_km),
+                    "bank_deg": float(b),
+                    "t_pre": float(t_pre),
+                    "t_turn": float(t_turn),
+                    "t_post": float(t_post),
+                    "end_lat": float(lat),
+                    "end_lon": float(lon),
+                }
+
+    if best is None:
+        return [], {"error": "Unable to construct a valid turn profile."}
+
+    # fine refinement around best t_pre, same bank
+    fine = float(TURN_PRESEARCH_FINE_SEC)
+    t_pre0 = best["t_pre"]
+    b0 = best["bank_deg"]
+    rate0 = _turn_rate_deg_per_sec(speed_knots, b0)
+    t_turn0 = 0.0 if delta_abs <= 1e-9 else (delta_abs / rate0)
+    t_turn0 = max(0.0, min(float(t_turn0), float(total_sec)))
+
+    # search +/- 60 seconds around the best coarse t_pre
+    lo = max(0.0, t_pre0 - 60.0)
+    hi = min(float(total_sec), t_pre0 + 60.0)
+    pre_candidates_fine = np.arange(lo, hi + 1e-9, fine)
+
+    best2 = dict(best)
+    best2["t_turn"] = float(t_turn0)
+
+    for t_pre in pre_candidates_fine:
+        t_post = float(total_sec) - float(t_pre) - float(t_turn0)
+        if t_post < -1e-9:
+            continue
+        t_post = max(0.0, t_post)
+
+        lat, lon = float(RADAR_FIX_LAT), float(RADAR_FIX_LON)
+
+        if t_pre > 1e-9:
+            dist_m = float(speed_knots) * 1852.0 * (float(t_pre) / 3600.0)
+            lat, lon = _direct(method, lat, lon, h0, dist_m)
+
+        lat, lon = _simulate_discretized_turn(
+            method, lat, lon, speed_knots,
+            h0, h1, t_turn0, sign, delta_abs, step_sec
+        )
+
+        if t_post > 1e-9:
+            dist_m = float(speed_knots) * 1852.0 * (float(t_post) / 3600.0)
+            lat, lon = _direct(method, lat, lon, h1, dist_m)
+
+        err_km = _haversine_km(lat, lon, float(target_lat), float(target_lon))
+
+        if err_km < best2["error_km"]:
+            best2.update({
+                "error_km": float(err_km),
+                "t_pre": float(t_pre),
+                "t_post": float(t_post),
+                "end_lat": float(lat),
+                "end_lon": float(lon),
+            })
+
+    # Build legs list from best2
+    t_pre = best2["t_pre"]
+    t_turn = best2["t_turn"]
+    t_post = best2["t_post"]
+    bank_deg = best2["bank_deg"]
+
+    legs = []
+    if t_pre > 1.0:
+        legs.append((h0, float(speed_knots), float(t_pre) / 60.0))
+
+    # discretized turn segments
+    if t_turn > 1.0 and delta_abs > 1e-9:
+        step_sec = max(5.0, float(step_sec))
+        n = int(math.ceil(float(t_turn) / step_sec))
+        if n < 1:
+            n = 1
+        remaining = float(t_turn)
+        for i in range(n):
+            this = min(step_sec, remaining)
+            remaining -= this
+            frac_mid = ((i + 0.5) / n)
+            hdg_mid = _wrap_heading_deg(h0 + sign * delta_abs * frac_mid)
+            legs.append((hdg_mid, float(speed_knots), float(this) / 60.0))
 
-    best = None
-
-    # ---- coarse search
-    bank_vals = np.arange(TURN_BANK_MIN_DEG, TURN_BANK_MAX_DEG + 1e-9, TURN_BANK_STEP_COARSE)
-    pre_vals = np.arange(0.0, 1.0 + 1e-9, TURN_PRE_FRAC_STEP_COARSE)
-    spd_vals = np.arange(TURN_SPEEDFAC_MIN, TURN_SPEEDFAC_MAX + 1e-9, TURN_SPEEDFAC_STEP_COARSE)
-
-    for bank in bank_vals:
-        for pre in pre_vals:
-            for sf in spd_vals:
-                spd = float(speed_knots_nominal) * float(sf)
-                (lat_end, lon_end), legs = _simulate_turn_window(
-                    method=method,
-                    speed_knots=spd,
-                    h0=h0,
-                    h1=h1,
-                    bank_deg=bank,
-                    pre_frac=pre,
-                    dt_sec=TURN_SIM_DT_SEC,
-                )
-                err_km = _haversine_km(lat_end, lon_end, float(target_lat), float(target_lon))
-                if best is None or err_km < best["err_km"]:
-                    best = {
-                        "bank": float(bank),
-                        "pre": float(pre),
-                        "sf": float(sf),
-                        "spd": float(spd),
-                        "err_km": float(err_km),
-                        "legs": legs,
-                        "lat_end": float(lat_end),
-                        "lon_end": float(lon_end),
-                    }
-
-    # ---- fine search around best
-    b0 = best["bank"]
-    p0 = best["pre"]
-    sf0 = best["sf"]
-
-    bank_vals = np.arange(max(TURN_BANK_MIN_DEG, b0 - 2.0), min(TURN_BANK_MAX_DEG, b0 + 2.0) + 1e-9, TURN_BANK_STEP_FINE)
-    pre_vals = np.arange(max(0.0, p0 - 0.10), min(1.0, p0 + 0.10) + 1e-9, TURN_PRE_FRAC_STEP_FINE)
-    spd_vals = np.arange(max(TURN_SPEEDFAC_MIN, sf0 - 0.05), min(TURN_SPEEDFAC_MAX, sf0 + 0.05) + 1e-9, TURN_SPEEDFAC_STEP_FINE)
-
-    for bank in bank_vals:
-        for pre in pre_vals:
-            for sf in spd_vals:
-                spd = float(speed_knots_nominal) * float(sf)
-                (lat_end, lon_end), legs = _simulate_turn_window(
-                    method=method,
-                    speed_knots=spd,
-                    h0=h0,
-                    h1=h1,
-                    bank_deg=bank,
-                    pre_frac=pre,
-                    dt_sec=TURN_SIM_DT_SEC,
-                )
-                err_km = _haversine_km(lat_end, lon_end, float(target_lat), float(target_lon))
-                if err_km < best["err_km"]:
-                    best = {
-                        "bank": float(bank),
-                        "pre": float(pre),
-                        "sf": float(sf),
-                        "spd": float(spd),
-                        "err_km": float(err_km),
-                        "legs": legs,
-                        "lat_end": float(lat_end),
-                        "lon_end": float(lon_end),
-                    }
-
-    legs = list(best["legs"])
-    lat_end = best["lat_end"]
-    lon_end = best["lon_end"]
-    err_km = best["err_km"]
-
-    # Tiny snap-to-waypoint if needed, so 18:40 is exact.
-    # We keep it extremely small by relying on the search to get close.
-    snap_added = False
-    if err_km > 1e-6:
-        if err_km > TURN_FINAL_SNAP_MAX_KM:
-            # still force exact, but we will report it (this indicates search bounds are too tight)
-            pass
-        snap_sec = float(TURN_FINAL_SNAP_SEC)
-        hdg = _initial_bearing_deg(lat_end, lon_end, float(target_lat), float(target_lon))
-        dist_m = err_km * 1000.0
-        spd_kn = (dist_m / 1852.0) / (snap_sec / 3600.0)
-        legs.append((float(hdg), float(spd_kn), snap_sec / 60.0))
-        snap_added = True
+    if t_post > 1.0:
+        legs.append((h1, float(speed_knots), float(t_post) / 60.0))
 
     info = {
-        "bank_deg": float(best["bank"]),
-        "pre_straight_frac": float(best["pre"]),
-        "speed_factor": float(best["sf"]),
-        "turn_speed_knots": float(best["spd"]),
-        "end_error_km_before_snap": float(err_km),
-        "snap_added": bool(snap_added),
-        "h0": float(h0),
-        "h1": float(h1),
+        "h0": h0,
+        "h1": h1,
+        "delta_deg": float(delta),
+        "bank_deg": float(bank_deg),
+        "pre_min": float(t_pre) / 60.0,
+        "turn_min": float(t_turn) / 60.0,
+        "post_min": float(t_post) / 60.0,
+        "total_min": float(total_sec) / 60.0,
+        "target_lat": float(target_lat),
+        "target_lon": float(target_lon),
+        "end_lat": float(best2["end_lat"]),
+        "end_lon": float(best2["end_lon"]),
+        "error_km": float(best2["error_km"]),
+        "L_km": float(L_km),
+        "d_km": float(d_km),
+        "tol_km": float(TURN_POINT_TOL_KM),
     }
     return legs, info
 
@@ -805,6 +832,10 @@ def _map_marker_times(start_dt, legs):
 
 # ================= 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 []
@@ -820,6 +851,7 @@ def clip_legs_to_end_dt(legs, start_dt: datetime, end_dt: datetime):
             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)))
@@ -1056,6 +1088,13 @@ def add_permanent_label(m, name, lat, lon):
 
 
 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
+    - 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)
 
@@ -1200,6 +1239,7 @@ def build_leaflet_map(path_pts, legs, method, start_dt):
             f"Distance flown: {dist_km:.2f} km",
         ]
 
+        # Make final point visually distinct
         if is_final:
             folium.CircleMarker(
                 location=(lat, lon),
@@ -1223,6 +1263,7 @@ def build_leaflet_map(path_pts, legs, method, start_dt):
                 popup=folium.Popup("<br>".join(popup_lines), max_width=360),
             ).add_to(m)
 
+    # Permanent labels
     for name, lat, lon in WAYPOINTS:
         add_permanent_label(m, name, float(lat), float(lon))
 
@@ -1312,6 +1353,7 @@ def solve_guided_straight(
     descent_start_choice, weight_bfo, weight_bto,
     turn_complete_lat, turn_complete_lon
 ):
+    # We clip everything to final 00:20Z; end_dt is fixed by label.
     start_dt = _guided_start_dt()
     end_dt = _dt_from_label(GUIDED_FINAL_LABEL)
 
@@ -1320,6 +1362,7 @@ def solve_guided_straight(
     best_score = None
     best_turn_info = None
 
+    # descent start
     descent_start_dt = None
     if (descent_start_choice or "").startswith("After Ping Ring 6"):
         descent_start_dt = dt_ping6_utc()
@@ -1328,21 +1371,27 @@ def solve_guided_straight(
 
     h = GUIDED_HEADING_MIN
     while h <= GUIDED_HEADING_MAX + 1e-9:
-        # 1) best smooth turn to the authoritative 18:40 waypoint
-        preturn_legs, turn_info = build_turn_legs_best(
+        southern_legs = make_legs_from_schedule(h, float(speed_knots), GUIDED_LEG_SCHEDULE_MIN)
+
+        preturn_legs, turn_info = build_turn_legs_to_point(
+            speed_knots=float(speed_knots),
             method=method,
-            speed_knots_nominal=float(speed_knots),
             heading_final_deg=float(h),
             target_lat=float(turn_complete_lat),
             target_lon=float(turn_complete_lon),
+            bank_pref_deg=TURN_BANK_DEFAULT_DEG,
+            step_sec=TURN_STEP_SEC
         )
-
-        # 2) southern legs
-        southern_legs = make_legs_from_schedule(float(h), float(speed_knots), GUIDED_LEG_SCHEDULE_MIN)
+        if not preturn_legs and isinstance(turn_info, dict) and turn_info.get("error"):
+            h += STRAIGHT_STEP_DEG
+            continue
 
         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,
@@ -1357,15 +1406,21 @@ def solve_guided_straight(
         h += STRAIGHT_STEP_DEG
 
     if best_full_legs is None:
-        return None, "Guided solve: not enough ping points to score.", None
+        return None, "Guided solve: not enough ping points to score (or 18:40 point unreachable at chosen speed).", None
+
+    turn_line = ""
+    if isinstance(best_turn_info, dict) and "error_km" in best_turn_info:
+        ek = float(best_turn_info["error_km"])
+        if ek <= TURN_POINT_TOL_KM:
+            turn_line = f"- 18:40 target hit: **OK** (error {ek:.2f} km)\n"
+        else:
+            turn_line = f"- 18:40 target hit: **approx** (error {ek:.2f} km)\n"
 
-    ti = best_turn_info or {}
     report = "\n".join([
-        "**Guided mode: 18:40 waypoint fixed (authoritative) + BEST smooth turn + southern solve, clipped to 00:20**",
-        f"- Speed (south leg constrained): **{float(speed_knots):.1f} kt**",
-        f"- Turn completion (18:40 fixed): **lat {float(turn_complete_lat):.5f}, lon {float(turn_complete_lon):.5f}**",
-        f"- Best turn bank: **{ti.get('bank_deg', float('nan')):.2f}°** | pre-straight frac: **{ti.get('pre_straight_frac', float('nan')):.2f}** | turn speed factor: **{ti.get('speed_factor', float('nan')):.3f}**",
-        f"- 18:40 residual error before snap: **{ti.get('end_error_km_before_snap', 0.0):.3f} km** | snap added: **{ti.get('snap_added', False)}**",
+        "**Guided mode: Turn-to-18:40 (user lat/lon) + southern solve, clipped to 00:20**",
+        f"- Speed (constrained): **{float(speed_knots):.1f} kt**",
+        f"- Turn completion target (18:40): **lat {float(turn_complete_lat):.5f}, lon {float(turn_complete_lon):.5f}**",
+        turn_line.rstrip(),
         f"- Best southern heading: **{best_h:.1f}°**",
         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
@@ -1381,6 +1436,7 @@ def solve_guided_straight_with_drift(
     drift_max_deg, drift_weight,
     turn_complete_lat, turn_complete_lon
 ):
+    # lightweight drift version: use nominal heading search, but add a small constant drift
     start_dt = _guided_start_dt()
     end_dt = _dt_from_label(GUIDED_FINAL_LABEL)
 
@@ -1389,12 +1445,14 @@ def solve_guided_straight_with_drift(
     best_score = None
     best_turn_info = 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()
 
+    # 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]
@@ -1404,16 +1462,23 @@ def solve_guided_straight_with_drift(
         for d in drift_candidates:
             h_eff = _wrap_heading_deg(float(h0) + float(d))
 
-            preturn_legs, turn_info = build_turn_legs_best(
+            southern_legs = make_legs_from_schedule(h_eff, float(speed_knots), GUIDED_LEG_SCHEDULE_MIN)
+
+            preturn_legs, turn_info = build_turn_legs_to_point(
+                speed_knots=float(speed_knots),
                 method=method,
-                speed_knots_nominal=float(speed_knots),
                 heading_final_deg=float(h_eff),
                 target_lat=float(turn_complete_lat),
                 target_lon=float(turn_complete_lon),
+                bank_pref_deg=TURN_BANK_DEFAULT_DEG,
+                step_sec=TURN_STEP_SEC
             )
+            if not preturn_legs and isinstance(turn_info, dict) and turn_info.get("error"):
+                continue
 
-            southern_legs = make_legs_from_schedule(h_eff, float(speed_knots), GUIDED_LEG_SCHEDULE_MIN)
             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(
@@ -1424,6 +1489,7 @@ def solve_guided_straight_with_drift(
             if s is None:
                 continue
 
+            # add drift penalty (RMS here is just |d| for constant drift)
             combined = float(s["combined"]) + float(drift_weight) * (abs(float(d)) / DRIFT_SCALE_DEG)
 
             if best_score is None or combined < best_score["combined_plus"]:
@@ -1437,15 +1503,21 @@ def solve_guided_straight_with_drift(
         h0 += 1.0
 
     if best_full_legs is None:
-        return None, "Guided drift solve: not enough ping points to score.", None
+        return None, "Guided drift solve: not enough ping points to score (or 18:40 point unreachable at chosen speed).", None
+
+    turn_line = ""
+    if isinstance(best_turn_info, dict) and "error_km" in best_turn_info:
+        ek = float(best_turn_info["error_km"])
+        if ek <= TURN_POINT_TOL_KM:
+            turn_line = f"- 18:40 target hit: **OK** (error {ek:.2f} km)\n"
+        else:
+            turn_line = f"- 18:40 target hit: **approx** (error {ek:.2f} km)\n"
 
-    ti = best_turn_info or {}
     report = "\n".join([
-        "**Guided mode: 18:40 waypoint fixed (authoritative) + BEST smooth turn + southern solve (drift), clipped to 00:20**",
-        f"- Speed (south leg constrained): **{float(speed_knots):.1f} kt**",
-        f"- Turn completion (18:40 fixed): **lat {float(turn_complete_lat):.5f}, lon {float(turn_complete_lon):.5f}**",
-        f"- Best turn bank: **{ti.get('bank_deg', float('nan')):.2f}°** | pre-straight frac: **{ti.get('pre_straight_frac', float('nan')):.2f}** | turn speed factor: **{ti.get('speed_factor', float('nan')):.3f}**",
-        f"- 18:40 residual error before snap: **{ti.get('end_error_km_before_snap', 0.0):.3f} km** | snap added: **{ti.get('snap_added', False)}**",
+        "**Guided mode: Turn-to-18:40 (user lat/lon) + southern solve (drift), clipped to 00:20**",
+        f"- Speed (constrained): **{float(speed_knots):.1f} kt**",
+        f"- Turn completion target (18:40): **lat {float(turn_complete_lat):.5f}, lon {float(turn_complete_lon):.5f}**",
+        turn_line.rstrip(),
         f"- Best nominal heading: **{best_h0:.1f}°**",
         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**",
@@ -1532,6 +1604,7 @@ def score_legs_bfo_bto(
 
 # ================= RUNNERS =================
 def _run_common(start_lat, start_lon, legs, method, start_dt, alt_ft, vs_fpm, descent_start_choice):
+    # 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)
@@ -1541,6 +1614,7 @@ 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 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
     )
@@ -1576,6 +1650,7 @@ def run_guided(
     drift_max_deg, drift_weight,
     turn_complete_lat, turn_complete_lon
 ):
+    # NOTE: start_lat/start_lon inputs are manual-only; guided always uses RADAR_FIX_LAT/LON.
     spd_knots = speed_from_profile(speed_profile, alt_ft, custom_mach, custom_knots)
 
     if (guided_scenario or "").startswith("Straight + drift"):
@@ -1606,6 +1681,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
     )
@@ -1637,7 +1713,7 @@ with gr.Blocks() as demo:
         f"- **Turn completion time (fixed):** 18:40:00Z\n"
         f"- **Initial track (fixed):** {RADAR_INITIAL_TRACK_DEG:.1f}°\n"
         f"- **Final resting point:** **00:20:00Z** (trajectory clipped exactly at this time)\n\n"
-        "✅ **Auto-turn enabled:** Program finds the best bank + timing + speed-factor to reach the fixed 18:40 waypoint smoothly."
+        "✅ **New:** Use the sliders below to set the **18:40 turn-completion lat/lon**. Guided mode will build a plausible turn that ends at that point."
     )
 
     gr.Markdown("### 18:40 Turn Completion Location (Guided mode)")
@@ -1674,7 +1750,7 @@ with gr.Blocks() as demo:
         speed_profile = gr.Dropdown(
             ["MRC Mach 0.82", "LRC Mach 0.84", "ECON Mach 0.80", "Custom Mach", "Custom knots"],
             value="MRC Mach 0.82",
-            label="Speed profile (constrains southern leg; turn uses best-fit speed factor)",
+            label="Speed profile (constrains speed during turn + southern leg)",
         )
         custom_mach = gr.Number(value=0.82, label="Custom Mach (if selected)")
         custom_knots = gr.Number(value=470, label="Custom knots (if selected)")