Update app.py

app.py

@@ -7,9 +7,11 @@
 # (13) Permanent labeled waypoints
 # (14) BFO analysis chart + MAE/RMSE
 # Gentle auto-tune (BFO + BTO, BTO at satLoc index 5)
-# NEW: Esri Ocean + Satellite basemaps with layer control
-# NEW: Ping ring timestamps (Option A) shown in ring tooltip
-# NEW: Guided mode — "Straight to 7th arc" (single heading + single speed profile)
+# Esri Ocean + Satellite basemaps with layer control
+# Ping ring timestamps (Option A) shown in ring tooltip
+# Guided mode — Straight (single heading+speed) with FIXED leg schedule:
+#   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)
 # FIX: robust KML loading + no empty default selection crash
 
 import os
@@ -56,7 +58,7 @@ RING_TIMES = {
     "Ping Ring 7": "24:10:00Z",
 }
 
-# Gentle tuning constants (you can adjust to be more/less conservative)
+# Gentle tuning constants
 GENTLE_HEAD_LIMIT_DEG = 20
 GENTLE_SPEED_LIMIT_KT = 40
 HEAD_STEP_DEG = 2
@@ -72,11 +74,13 @@ BTO_SCALE_US = 50.0
 SATLOC_IDX_MEAS_BFO = 4
 SATLOC_IDX_MEAS_BTO = 5
 
-# Guided mode (straight to 7th arc) search range
+# Guided mode search range (south-ish headings)
 GUIDED_HEADING_MIN = 150.0
 GUIDED_HEADING_MAX = 210.0
 GUIDED_HEADING_STEP = 0.5
-GUIDED_SEGMENT_MIN = 10.0  # generate legs in ~10-min chunks for nicer waypoints
+
+# Guided schedule (minutes per leg): 60,60,60,60,90,10  (total = 340 min = 18:40 -> 24:20)
+GUIDED_LEG_SCHEDULE_MIN = [60.0, 60.0, 60.0, 60.0, 90.0, 10.0]
 
 
 # ================= KML =================
@@ -100,18 +104,12 @@ def load_ping_rings_from_kml(path: str):
     ns = {"kml": ns_uri}
 
     rings = {}
-
     for pm in root.findall(".//kml:Placemark", ns):
         name_el = pm.find("kml:name", ns)
-        if name_el is None:
-            continue
-        if name_el.text is None:
+        if name_el is None or name_el.text is None:
             continue
         name = name_el.text.strip()
-        if not name:
-            continue
-
-        if not name.lower().startswith("ping ring"):
+        if not name or not name.lower().startswith("ping ring"):
             continue
 
         coords_el = pm.find(".//kml:LineString/kml:coordinates", ns)
@@ -119,8 +117,7 @@ def load_ping_rings_from_kml(path: str):
             continue
 
         pts = []
-        text = coords_el.text.strip()
-        for token in re.split(r"\s+", text):
+        for token in re.split(r"\s+", coords_el.text.strip()):
             if not token:
                 continue
             parts = token.split(",")
@@ -139,7 +136,6 @@ def load_ping_rings_from_kml(path: str):
 try:
     PING_RINGS = load_ping_rings_from_kml(KML_FILE)
 except Exception as e:
-    # Keep app alive and show a readable UI error instead of crashing on import
     PING_RINGS = {}
     KML_LOAD_ERROR = str(e)
 else:
@@ -277,8 +273,6 @@ def add_permanent_label(m, name, lat, lon):
 
 def build_leaflet_map(path_pts, legs, seg_dists_m, selected_rings):
     start_lat, start_lon = path_pts[0]
-
-    # IMPORTANT: tiles=None so we can add multiple basemaps
     m = folium.Map(
         location=[start_lat, start_lon],
         zoom_start=4,
@@ -287,13 +281,7 @@ def build_leaflet_map(path_pts, legs, seg_dists_m, selected_rings):
     )
 
     # ---- BASEMAPS ----
-    folium.TileLayer(
-        "OpenStreetMap",
-        name="OpenStreetMap",
-        overlay=False,
-        control=True,
-    ).add_to(m)
-
+    folium.TileLayer("OpenStreetMap", name="OpenStreetMap", overlay=False, control=True).add_to(m)
     folium.TileLayer(
         tiles="https://server.arcgisonline.com/ArcGIS/rest/services/Ocean/World_Ocean_Base/MapServer/tile/{z}/{y}/{x}",
         attr="Esri",
@@ -301,7 +289,6 @@ def build_leaflet_map(path_pts, legs, seg_dists_m, selected_rings):
         overlay=False,
         control=True,
     ).add_to(m)
-
     folium.TileLayer(
         tiles="https://server.arcgisonline.com/ArcGIS/rest/services/World_Imagery/MapServer/tile/{z}/{y}/{x}",
         attr="Esri",
@@ -317,16 +304,9 @@ def build_leaflet_map(path_pts, legs, seg_dists_m, selected_rings):
             continue
         ring_time = RING_TIMES.get(ring_name)
         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)
 
-        folium.PolyLine(
-            ring_pts,
-            weight=2,
-            opacity=0.6,
-            color="yellow",
-            tooltip=tooltip,
-        ).add_to(m)
-
-    # ---- FLIGHT PATH (glow + main) ----
+    # ---- FLIGHT PATH ----
     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)
 
@@ -355,7 +335,7 @@ def build_leaflet_map(path_pts, legs, seg_dists_m, selected_rings):
         ),
     ).add_to(m)
 
-    # ---- SIMULATED WAYPOINTS (white dots with popups) ----
+    # ---- SIMULATED WAYPOINTS ----
     total_dist_km = 0.0
     elapsed_min = 0.0
     for i, (lat, lon) in enumerate(path_pts):
@@ -396,10 +376,8 @@ def build_leaflet_map(path_pts, legs, seg_dists_m, selected_rings):
     for name, lat, lon in WAYPOINTS:
         add_permanent_label(m, name, float(lat), float(lon))
 
-    # ---- LAYER CONTROL ----
     folium.LayerControl(collapsed=False).add_to(m)
 
-    # ---- FIT BOUNDS ----
     waypoint_pts = [(float(lat), float(lon)) for _, lat, lon in WAYPOINTS]
     bounds = _all_bounds(
         [path_pts]
@@ -421,14 +399,15 @@ def build_leaflet_map(path_pts, legs, seg_dists_m, selected_rings):
     """
 
 
-# ================= BFO/BTO HELPERS =================
+# ================= BFO HELPERS =================
 def _parse_start_time(s: str) -> datetime:
     s = (s or "").strip()
     if not s:
         return datetime(2014, 3, 7, 18, 22, 0, tzinfo=timezone.utc)
 
-    if re.fullmatch(r"\d{2}:\d{2}:\d{2}", s):
-        hh, mm, ss = map(int, s.split(":"))
+    if re.fullmatch(r"\d{2}:\d{2}:\d{2}Z?", s):
+        s2 = s.replace("Z", "")
+        hh, mm, ss = map(int, s2.split(":"))
         return datetime(2014, 3, 7, hh, mm, ss, tzinfo=timezone.utc)
 
     s = s.replace("T", " ").replace("Z", "")
@@ -445,7 +424,6 @@ def _ping_points_after(start_dt: datetime):
 
         meas_bfo = row[SATLOC_IDX_MEAS_BFO]
         meas_bto = row[SATLOC_IDX_MEAS_BTO]
-
         if meas_bfo is None:
             continue
 
@@ -547,165 +525,8 @@ def bfo_analysis_with_legs(start_lat, start_lon, legs, method, start_time_str, a
     return fig, score_md
 
 
-# ================= AUTOTUNE (BFO + BTO) =================
-def _wrap_heading(deg):
-    return float(deg) % 360.0
-
-
-def _heading_diff(a, b):
-    return (float(a) - float(b) + 180.0) % 360.0 - 180.0
-
-
-def gentle_autotune_all_legs(start_lat, start_lon, legs, method, start_time_str, alt_ft, vs_fpm):
-    start_dt = _parse_start_time(start_time_str)
-    pts = _ping_points_after(start_dt)
-    if not pts:
-        return legs, "Auto-tune: no BFO points after start time."
-
-    n = len(legs)
-    leg_secs = [float(m) * 60.0 for _, _, m in legs]
-    boundaries = np.cumsum([0.0] + leg_secs)
-    total_end = boundaries[-1]
-
-    pts2 = []
-    for label, dt_ping, meas_bfo, meas_bto in pts:
-        t_sec = (dt_ping - start_dt).total_seconds()
-        if 0 <= t_sec <= total_end:
-            pts2.append((label, dt_ping, meas_bfo, meas_bto, float(t_sec)))
-
-    if len(pts2) < 2:
-        return legs, "Auto-tune: not enough pings inside your simulated time."
-
-    tuned = list(legs)
-    cur_lat = float(start_lat)
-    cur_lon = float(start_lon)
-
-    prev_h, prev_s, _ = tuned[0]
-    report = ["**Gentle auto-tune (BFO + BTO, bounded + smooth):**"]
-    tuned_count = 0
-
-    for i in range(n):
-        leg_start = boundaries[i]
-        leg_end = boundaries[i + 1]
-        minutes_i = float(tuned[i][2])
-
-        leg_pings = [(dt, bfo, bto, (t - leg_start)) for (_, dt, bfo, bto, t) in pts2 if leg_start <= t <= leg_end]
-        orig_h, orig_s, _ = legs[i]
-
-        if len(leg_pings) < 2:
-            report.append(f"- Leg {i+1}: skipped (not enough pings in window)")
-            h0, s0, _ = tuned[i]
-            dist_m = float(s0) * 1852.0 * (minutes_i / 60.0)
-            if method == "VINCENTY":
-                (cur_lat, cur_lon), _ = fp.vincenty_direct((cur_lat, cur_lon), float(h0), dist_m)
-            else:
-                cur_lat, cur_lon = fp.rhumb_direct((cur_lat, cur_lon), float(h0), dist_m)
-            prev_h, prev_s = h0, s0
-            continue
-
-        leg_start_lat, leg_start_lon = cur_lat, cur_lon
-
-        h_center = _wrap_heading(orig_h)
-        s_center = float(orig_s)
-
-        h_low = h_center - GENTLE_HEAD_LIMIT_DEG
-        h_high = h_center + GENTLE_HEAD_LIMIT_DEG
-
-        h_candidates = []
-        h = h_low
-        while h <= h_high + 1e-9:
-            h_candidates.append(_wrap_heading(h))
-            h += HEAD_STEP_DEG
-        h_candidates = sorted(set(round(x, 6) for x in h_candidates))
-
-        s_low = max(150.0, s_center - GENTLE_SPEED_LIMIT_KT)
-        s_high = min(650.0, s_center + GENTLE_SPEED_LIMIT_KT)
-        s_candidates = np.arange(s_low, s_high + 0.0001, SPEED_STEP_KT).tolist()
-
-        def objective(hdg, spd):
-            bfo_preds, bfo_meas = [], []
-            bto_preds, bto_meas = [], []
-
-            alt_m = float(alt_ft) * 0.3048
-            vs_mps = float(vs_fpm) * 0.00508
-            spd_mps = float(spd) * 1852.0 / 3600.0
-
-            for dt_ping, meas_bfo, meas_bto, t_inside in leg_pings:
-                lat, lon = _predict_state_from_leg_start(
-                    method, leg_start_lat, leg_start_lon, hdg, spd, t_inside
-                )
-
-                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))
-
-            e_bfo = np.array(bfo_preds) - np.array(bfo_meas)
-            rmse_bfo = float(np.sqrt(np.mean(e_bfo * e_bfo)))
-
-            rmse_bto = 0.0
-            if len(bto_preds) >= 2:
-                e_bto = np.array(bto_preds) - np.array(bto_meas)
-                rmse_bto = float(np.sqrt(np.mean(e_bto * e_bto)))
-
-            fit_score = (rmse_bfo / BFO_SCALE_HZ) + (rmse_bto / BTO_SCALE_US)
-
-            stay_close = (abs(_heading_diff(hdg, orig_h)) / GENTLE_HEAD_LIMIT_DEG) ** 2 + ((float(spd) - float(orig_s)) / GENTLE_SPEED_LIMIT_KT) ** 2
-            smooth = (abs(_heading_diff(hdg, prev_h)) / 45.0) ** 2 + ((float(spd) - float(prev_s)) / 80.0) ** 2
-
-            loss = fit_score + LAMBDA_STAY_CLOSE * stay_close + LAMBDA_SMOOTH * smooth
-            return loss, rmse_bfo, rmse_bto
-
-        best_h, best_s = None, None
-        best_loss = float("inf")
-        best_rbfo = float("inf")
-        best_rbto = float("inf")
-
-        for hdg in h_candidates:
-            for spd in s_candidates:
-                loss, rbfo, rbto = objective(hdg, spd)
-                if loss < best_loss:
-                    best_loss = loss
-                    best_h, best_s = float(hdg), float(spd)
-                    best_rbfo, best_rbto = rbfo, rbto
-
-        tuned[i] = (float(best_h), float(best_s), minutes_i)
-        tuned_count += 1
-
-        if best_rbto > 0:
-            report.append(
-                f"- Leg {i+1}: {orig_h:.0f}°→**{best_h:.0f}°**, {orig_s:.0f}→**{best_s:.0f} kt** | "
-                f"RMSE_BFO **{best_rbfo:.2f} Hz** | RMSE_BTO **{best_rbto:.1f} µs**"
-            )
-        else:
-            report.append(
-                f"- Leg {i+1}: {orig_h:.0f}°→**{best_h:.0f}°**, {orig_s:.0f}→**{best_s:.0f} kt** | "
-                f"RMSE_BFO **{best_rbfo:.2f} Hz** | RMSE_BTO (n/a)"
-            )
-
-        dist_m = float(best_s) * 1852.0 * (minutes_i / 60.0)
-        if method == "VINCENTY":
-            (cur_lat, cur_lon), _ = fp.vincenty_direct((cur_lat, cur_lon), float(best_h), dist_m)
-        else:
-            cur_lat, cur_lon = fp.rhumb_direct((cur_lat, cur_lon), float(best_h), dist_m)
-
-        prev_h, prev_s = best_h, best_s
-
-    report.append(f"\nTuned legs: **{tuned_count}/{n}** (skipped legs had <2 pings in that time window)")
-    return tuned, "\n".join(report)
-
-
-# ================= GUIDED MODE: STRAIGHT TO 7TH ARC =================
+# ================= GUIDED MODE =================
 def isa_speed_of_sound_mps(alt_m: float) -> float:
-    """
-    ISA speed of sound (m/s) using a simple ISA temperature model:
-    - Troposphere to 11km: lapse rate -6.5 K/km
-    - Lower stratosphere: constant 216.65 K
-    """
     T0 = 288.15
     L = -0.0065
     h_trop = 11000.0
@@ -725,35 +546,45 @@ def mach_to_tas_knots(mach: float, alt_ft: float) -> float:
     return tas_mps / 0.514444
 
 
-def _dt_for_7th_arc() -> datetime:
-    # Use satLoc time label for ring 7 (24:10:00Z)
-    # flight_plotter_v32 already knows how to interpret 24:xx:xx with SAT_EPOCH_UTC
-    return fp._time_label_to_dt("24:10:00", fp.SAT_EPOCH_UTC)
+def speed_from_profile(profile: str, alt_ft: float, custom_mach: float, custom_knots: float) -> float:
+    profile = (profile or "").strip()
+    if profile.startswith("MRC"):
+        return mach_to_tas_knots(0.82, alt_ft)
+    if profile.startswith("LRC"):
+        return mach_to_tas_knots(0.84, alt_ft)
+    if profile.startswith("ECON"):
+        return mach_to_tas_knots(0.80, alt_ft)
+    if profile.startswith("Custom Mach"):
+        return mach_to_tas_knots(float(custom_mach), alt_ft)
+    if profile.startswith("Custom knots"):
+        return float(custom_knots)
+    return mach_to_tas_knots(0.82, alt_ft)
+
+
+def dt_1840_utc() -> datetime:
+    return fp._time_label_to_dt("18:40:00", fp.SAT_EPOCH_UTC)
 
 
-def make_straight_legs(total_minutes: float, heading_deg: float, speed_knots: float, chunk_min: float = 10.0):
-    total_minutes = float(max(0.0, total_minutes))
-    chunk_min = float(max(1.0, chunk_min))
+def dt_0020_utc() -> datetime:
+    # 00:20Z represented by 24:20:00 in the sat label system
+    return fp._time_label_to_dt("24:20:00", fp.SAT_EPOCH_UTC)
+
+
+def make_straight_legs_from_schedule(heading_deg: float, speed_knots: float, schedule_minutes):
     legs = []
-    remaining = total_minutes
-    while remaining > 1e-9:
-        m = min(chunk_min, remaining)
+    for m in schedule_minutes:
+        m = float(m)
+        if m <= 0:
+            continue
         legs.append((float(heading_deg), float(speed_knots), float(m)))
-        remaining -= m
-        if len(legs) > 1000:  # safety
-            break
     return legs
 
 
 def score_straight_track(start_lat, start_lon, method, start_dt, end_dt, heading_deg, speed_knots, alt_ft, vs_fpm):
-    """
-    Compute RMSE_BFO / RMSE_BTO for a straight track from start_dt to end_dt.
-    Uses pings inside [start_dt, end_dt].
-    """
     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  # not enough points
+        return None
 
     alt_m = float(alt_ft) * 0.3048
     vs_mps = float(vs_fpm) * 0.00508
@@ -788,7 +619,6 @@ def score_straight_track(start_lat, start_lon, method, start_dt, end_dt, heading
         e_bto = np.array(bto_preds) - np.array(bto_meas)
         rmse_bto = float(np.sqrt(np.mean(e_bto * e_bto)))
 
-    # combined score
     combined = rmse_bfo / BFO_SCALE_HZ
     if rmse_bto is not None:
         combined += rmse_bto / BTO_SCALE_US
@@ -802,67 +632,56 @@ def score_straight_track(start_lat, start_lon, method, start_dt, end_dt, heading
     }
 
 
-def solve_straight_to_7th_arc(start_lat, start_lon, method, start_time_str, speed_knots, alt_ft, vs_fpm):
+def solve_guided_straight_fixed_schedule(start_lat, start_lon, method, speed_knots, alt_ft, vs_fpm):
     """
-    Finds best constant heading for a straight track from start_time -> 7th arc time
-    using BFO+BTO scoring (RMSE-based).
+    Start fixed at 18:40:00Z, end fixed at 24:20:00Z.
+    Legs fixed at [60,60,60,60,90,10] minutes.
+    Solve for best constant heading (single heading, single speed).
     """
-    start_dt = _parse_start_time(start_time_str)
-    end_dt = _dt_for_7th_arc()
-
-    if start_dt >= end_dt:
-        return None, None, f"Guided solve: start time **{start_dt.isoformat()}** is after 7th arc time **{end_dt.isoformat()}**."
+    start_dt = dt_1840_utc()
+    end_dt = dt_0020_utc()
+
+    # sanity: schedule must match the end time window
+    total_sched_min = float(np.sum(GUIDED_LEG_SCHEDULE_MIN))
+    total_window_min = (end_dt - start_dt).total_seconds() / 60.0
+    if abs(total_sched_min - total_window_min) > 0.01:
+        return None, (
+            f"Guided schedule mismatch: schedule totals {total_sched_min:.1f} min "
+            f"but window is {total_window_min:.1f} min."
+        )
 
     best = None
     best_h = None
 
     h = GUIDED_HEADING_MIN
     while h <= GUIDED_HEADING_MAX + 1e-9:
-        s = score_straight_track(start_lat, start_lon, method, start_dt, end_dt, h, speed_knots, alt_ft, vs_fpm)
-        if s is not None:
-            if (best is None) or (s["combined"] < best["combined"]):
-                best = s
-                best_h = float(h)
+        s = score_straight_track(
+            start_lat, start_lon, method, start_dt, end_dt,
+            h, speed_knots, alt_ft, vs_fpm
+        )
+        if s is not None and ((best is None) or (s["combined"] < best["combined"])):
+            best = s
+            best_h = float(h)
         h += GUIDED_HEADING_STEP
 
     if best is None or best_h is None:
-        return None, None, "Guided solve: not enough ping points between start time and 7th arc to score."
+        return None, "Guided solve: not enough ping points between 18:40 and 00:20 to score."
 
-    total_minutes = (end_dt - start_dt).total_seconds() / 60.0
-    legs = make_straight_legs(total_minutes, best_h, float(speed_knots), chunk_min=GUIDED_SEGMENT_MIN)
+    legs = make_straight_legs_from_schedule(best_h, float(speed_knots), GUIDED_LEG_SCHEDULE_MIN)
 
-    # Report
     rbto = best["rmse_bto"]
     rbto_txt = f"{rbto:.1f} µs" if rbto is not None else "n/a"
+
     report = "\n".join([
-        "**Guided mode: Straight to 7th arc (single heading, single speed)**",
-        f"- Target end time (7th arc): **{end_dt.strftime('%Y-%m-%d %H:%M:%SZ')}**",
+        "**Guided mode: Straight 18:40 → 00:20 (fixed leg schedule)**",
+        f"- Start: **{start_dt.strftime('%Y-%m-%d %H:%M:%SZ')}** @ lat **{float(start_lat):.2f}**, lon **{float(start_lon):.2f}**",
+        f"- Legs: **60, 60, 60, 60, 90, 10** minutes",
         f"- Speed: **{float(speed_knots):.1f} kt**",
-        f"- Best heading: **{best_h:.1f}°** (searched {GUIDED_HEADING_MIN:.0f}–{GUIDED_HEADING_MAX:.0f}° step {GUIDED_HEADING_STEP}°)",
+        f"- Best heading: **{best_h:.1f}°** (searched {GUIDED_HEADING_MIN:.0f}–{GUIDED_HEADING_MAX:.0f}°, step {GUIDED_HEADING_STEP}°)",
         f"- BFO points: **{best['n_bfo']}** | RMSE_BFO: **{best['rmse_bfo']:.2f} Hz**",
         f"- BTO points: **{best['n_bto']}** | RMSE_BTO: **{rbto_txt}**",
     ])
-
-    return legs, report, ""
-
-
-def speed_from_profile(profile: str, alt_ft: float, custom_mach: float, custom_knots: float):
-    profile = (profile or "").strip()
-
-    if profile.startswith("MRC"):
-        return mach_to_tas_knots(0.82, alt_ft)
-    if profile.startswith("LRC"):
-        return mach_to_tas_knots(0.84, alt_ft)
-    if profile.startswith("ECON"):
-        return mach_to_tas_knots(0.80, alt_ft)
-    if profile.startswith("Custom Mach"):
-        m = float(custom_mach)
-        return mach_to_tas_knots(m, alt_ft)
-    if profile.startswith("Custom knots"):
-        return float(custom_knots)
-
-    # fallback
-    return mach_to_tas_knots(0.82, alt_ft)
+    return legs, report
 
 
 # ================= RUNNERS =================
@@ -882,40 +701,27 @@ def run_sim_manual(start_lat, start_lon, legs_df, method, rings, start_time_str,
     return gr.update(), "", html_map, stats_md, bfo_fig, bfo_md
 
 
-def run_sim_autotune(start_lat, start_lon, legs_df, method, rings, start_time_str, alt_ft, vs_fpm):
-    legs = parse_legs_df(legs_df)
-    tuned_legs, tune_md = gentle_autotune_all_legs(
-        start_lat, start_lon, legs, method, start_time_str, alt_ft, vs_fpm
-    )
-    html_map, stats_md, bfo_fig, bfo_md = _run_common(
-        start_lat, start_lon, tuned_legs, method, rings, start_time_str, alt_ft, vs_fpm
-    )
-    return gr.update(value=legs_to_rows(tuned_legs)), tune_md, html_map, stats_md, bfo_fig, bfo_md
-
-
-def run_guided_straight(start_lat, start_lon, method, rings, start_time_str, alt_ft, vs_fpm, speed_profile, custom_mach, custom_knots):
+def run_guided_fixed_schedule(start_lat, start_lon, method, rings, alt_ft, vs_fpm, speed_profile, custom_mach, custom_knots):
     spd_knots = speed_from_profile(speed_profile, alt_ft, custom_mach, custom_knots)
 
-    legs, report_md, err = solve_straight_to_7th_arc(
-        start_lat, start_lon, method, start_time_str, spd_knots, alt_ft, vs_fpm
+    legs, report_md = solve_guided_straight_fixed_schedule(
+        start_lat, start_lon, method, spd_knots, alt_ft, vs_fpm
     )
     if legs is None:
-        # keep current legs_df unchanged, show error
-        empty_map = ""
-        empty_stats = ""
         fig = go.Figure()
         fig.update_layout(title="BFO Analysis", xaxis_title="Time", yaxis_title="Hz", height=520)
-        return gr.update(), f"### ❌ {err or 'Guided solve failed.'}", empty_map, empty_stats, fig, ""
+        return gr.update(), f"### ❌ {report_md}", "", "", fig, ""
 
+    # Guided start time MUST be 18:40 for correct BFO window alignment
+    start_time_str = "18:40:00Z"
     html_map, stats_md, bfo_fig, bfo_md = _run_common(
         start_lat, start_lon, legs, method, rings, start_time_str, alt_ft, vs_fpm
     )
-    # overwrite legs table with generated legs (so user can inspect)
+
     return gr.update(value=legs_to_rows(legs)), report_md, html_map, stats_md, bfo_fig, bfo_md
 
 
 # ================= UI =================
-# Safe default selected ring(s)
 RING_CHOICES = sorted(PING_RINGS.keys())
 DEFAULT_SELECTED_RINGS = [RING_CHOICES[0]] if len(RING_CHOICES) > 0 else []
 
@@ -930,8 +736,9 @@ with gr.Blocks() as demo:
         )
 
     with gr.Row():
-        start_lat = gr.Slider(-10, 10, value=6.3, label="Start Latitude")
-        start_lon = gr.Slider(90, 110, value=96.3, label="Start Longitude")
+        # Defaults per your guided scenario
+        start_lat = gr.Slider(-10, 15, value=7.5, label="Start Latitude")
+        start_lon = gr.Slider(70, 115, value=94.4, label="Start Longitude")
         method = gr.Dropdown(["VINCENTY", "RHUMB"], value="VINCENTY", label="Method")
 
     gr.Markdown("### Multi-leg plan (Advanced / optional)")
@@ -956,11 +763,12 @@ with gr.Blocks() as demo:
 
     gr.Markdown("### #14 BFO/BTO Settings")
     with gr.Row():
-        start_time_str = gr.Textbox(value="2014-03-07 18:22:00Z", label="Simulation start time (UTC)")
+        # Manual mode uses this; Guided mode is fixed at 18:40 internally.
+        start_time_str = gr.Textbox(value="18:40:00Z", label="Simulation start time (UTC) — Manual mode")
         alt_ft = gr.Number(value=35000, label="Altitude (ft)")
         vs_fpm = gr.Number(value=0, label="Vertical speed (ft/min)")
 
-    gr.Markdown("### Guided mode (Recommended) — Straight to 7th arc")
+    gr.Markdown("### Guided mode (Recommended) — Straight 18:40 → 00:20 (60/60/60/60/90/10)")
     with gr.Row():
         speed_profile = gr.Dropdown(
             ["MRC Mach 0.82", "LRC Mach 0.84", "ECON Mach 0.80", "Custom Mach", "Custom knots"],
@@ -971,12 +779,10 @@ with gr.Blocks() as demo:
         custom_knots = gr.Number(value=470, label="Custom knots (if selected)")
 
     with gr.Row():
-        guided_btn = gr.Button("Generate: Straight to 7th arc (guided)")
+        guided_btn = gr.Button("Generate: Guided straight (fixed schedule)")
         manual_btn = gr.Button("Simulate on Map + BFO (Manual)")
-        tune_btn = gr.Button("Simulate on Map + BFO/BTO (Gentle auto-tune)")
-
-    tune_status = gr.Markdown()
 
+    status_md = gr.Markdown()
     out_map = gr.HTML()
     stats = gr.Markdown()
 
@@ -984,25 +790,16 @@ with gr.Blocks() as demo:
     bfo_plot = gr.Plot()
     bfo_score = gr.Markdown()
 
-    # Guided solve
     guided_btn.click(
-        run_guided_straight,
-        inputs=[start_lat, start_lon, method, rings, start_time_str, alt_ft, vs_fpm, speed_profile, custom_mach, custom_knots],
-        outputs=[legs_df, tune_status, out_map, stats, bfo_plot, bfo_score],
+        run_guided_fixed_schedule,
+        inputs=[start_lat, start_lon, method, rings, alt_ft, vs_fpm, speed_profile, custom_mach, custom_knots],
+        outputs=[legs_df, status_md, out_map, stats, bfo_plot, bfo_score],
     )
 
-    # Manual
     manual_btn.click(
         run_sim_manual,
         inputs=[start_lat, start_lon, legs_df, method, rings, start_time_str, alt_ft, vs_fpm],
-        outputs=[legs_df, tune_status, out_map, stats, bfo_plot, bfo_score],
-    )
-
-    # Auto-tune
-    tune_btn.click(
-        run_sim_autotune,
-        inputs=[start_lat, start_lon, legs_df, method, rings, start_time_str, alt_ft, vs_fpm],
-        outputs=[legs_df, tune_status, out_map, stats, bfo_plot, bfo_score],
+        outputs=[legs_df, status_md, out_map, stats, bfo_plot, bfo_score],
     )
 
     add_btn.click(add_leg, inputs=[legs_df], outputs=[legs_df])