Enhance VASM inference with dual-threshold hysteresis and confidence hold-off

Replace legacy binary detection with tri-class model. Add EMA smoothing with dual-threshold hysteresis (activate at conf_thresh, deactivate at conf_thresh - 0.15) and update tests and settings for the new model. Update v_asm_model.onnx with new model weights
2026-08-26 02:33:46 +08:00 · 2026-08-24 16:14:58 -04:00
269 changed files with 4779 additions and 11724 deletions
@@ -1,5 +1,4 @@
 import os
-import importlib
 import shutil
 import subprocess
 import sys
@@ -129,41 +128,6 @@ elif arch == "aarch64" and AGNOS:
  arch = "larch64"
 assert arch in ["larch64", "aarch64", "x86_64", "Darwin"]

-# AGNOS 19.6 ships native dependencies as versioned Python packages. Link
-# Cap'n Proto statically from that managed package so release binaries don't
-# depend on the removed libcapnp-1.0.2.so system library.
-try:
-  capnproto = importlib.import_module("capnproto")
-except ModuleNotFoundError:
-  capnproto = None
-try:
-  ffmpeg = importlib.import_module("ffmpeg")
-except ModuleNotFoundError:
-  ffmpeg = None
-
-capnproto_include_dirs = [capnproto.INCLUDE_DIR] if capnproto is not None else []
-capnproto_lib_dirs = [capnproto.LIB_DIR] if capnproto is not None else []
-ffmpeg_include_dirs = [ffmpeg.INCLUDE_DIR] if ffmpeg is not None else []
-ffmpeg_lib_dirs = [ffmpeg.LIB_DIR] if ffmpeg is not None else []
-
-# Cross-builds install managed dependencies in /work/.venv-linux-arm64, but
-# comma devices expose the same packages from /usr/local/venv. Never embed the
-# host/container mount path in release binaries.
-ffmpeg_runtime_lib_dirs = ffmpeg_lib_dirs
-if arch == "larch64" and ffmpeg is not None:
-  ffmpeg_runtime_lib_dirs = [os.path.join("/usr/local/venv", os.path.relpath(ffmpeg.LIB_DIR, sys.prefix))]
-
-# The managed native-dependency packages keep their tools inside the package
-# instead of installing them into /usr/local/venv/bin. cereal invokes capnpc
-# directly while SConscript files are evaluated, so make the packaged tools
-# discoverable to both SCons actions and configure-time subprocesses.
-dependency_bin_dirs = [
-  package.BIN_DIR for package in (capnproto, ffmpeg)
-  if package is not None and os.path.isdir(package.BIN_DIR)
-]
-if dependency_bin_dirs:
-  os.environ["PATH"] = os.pathsep.join([*dependency_bin_dirs, os.environ["PATH"]])
-
 # Homebrew llvm can shadow Apple clang and break macOS SDK header resolution.
 # Use the system toolchain explicitly on macOS for reliable local builds.
 cc = '/usr/bin/clang' if arch == "Darwin" else 'clang'
@@ -305,10 +269,7 @@ env = Environment(
    "-Wno-vla-cxx-extension",
  ] + cflags + ccflags,

-  # Managed dependencies must precede the compatibility sysroot. The sysroot
-  # can intentionally retain legacy libraries for C3 support, but new release
-  # binaries must link against the versions shipped in the managed venv.
-  CPPPATH=capnproto_include_dirs + ffmpeg_include_dirs + cpppath + [
+  CPPPATH=cpppath + [
    "#",
    "#third_party/acados/include",
    "#third_party/acados/include/blasfeo/include",
@@ -327,11 +288,11 @@ env = Environment(
  RANLIB=ranlib,
  LINKFLAGS=ldflags,

-  RPATH=ffmpeg_runtime_lib_dirs + rpath,
+  RPATH=rpath,

  CFLAGS=["-std=gnu11"] + cflags,
  CXXFLAGS=["-std=c++1z"] + cxxflags,
-  LIBPATH=capnproto_lib_dirs + ffmpeg_lib_dirs + libpath + [
+  LIBPATH=libpath + [
    "#msgq_repo",
    "#third_party",
    "#selfdrive/pandad",
@@ -410,15 +371,7 @@ SConscript(['opendbc_repo/SConscript'], exports={'env': env_swaglog})
 SConscript(['cereal/SConscript'])

 Import('socketmaster', 'msgq')
-if capnproto is not None:
-  messaging = [
-    socketmaster,
-    msgq,
-    File(os.path.join(capnproto.LIB_DIR, "libcapnp.a")),
-    File(os.path.join(capnproto.LIB_DIR, "libkj.a")),
-  ]
-else:
-  messaging = [socketmaster, msgq, 'capnp', 'kj']
+messaging = [socketmaster, msgq, 'capnp', 'kj',]
 Export('messaging')


@@ -220,7 +220,6 @@ struct StarPilotPlan @0xf98d843bfd7004a3 {
  disableThrottle @35 :Bool;
  trackingLead @36 :Bool;
  stopSignConfirmed @37 :Bool;
-  pulseGlideCoasting @38 :Bool;  # developer-only P&G phase for on-road status UI
 }

 struct StarPilotRadarState @0xb86e6369214c01c8 {
@@ -265,7 +264,6 @@ struct StarPilotSelfdriveState @0xf416ec09499d9d19 {
  alertSize @3 :AlertSize;
  alertType @4 :Text;
  alertSound @5 :Car.CarControl.HUDControl.AudibleAlert;
-  vEgo @6 :Float32;

  enum AlertStatus {
    normal @0;
@@ -2757,7 +2757,6 @@ struct Event {
    userBookmark @93 :UserBookmark;
    bookmarkButton @148 :UserBookmark;
    audioFeedback @149 :AudioFeedback;
-    visionSpeedLimitBookmark @153 :UserBookmark;

    lateralManeuverPlan @150 :LateralManeuverPlan;
    # *********** debug ***********
@@ -69,7 +69,6 @@ static std::map<std::string, service> services = {
  { "rawAudioData", {"rawAudioData", false, 20.000000, -1, 256000}},
  { "bookmarkButton", {"bookmarkButton", true, 0.000000, 1, 256000}},
  { "audioFeedback", {"audioFeedback", true, 0.000000, 1, 256000}},
-  { "visionSpeedLimitBookmark", {"visionSpeedLimitBookmark", false, 0.000000, 1, 256000}},
  { "roadEncodeData", {"roadEncodeData", false, 20.000000, -1, 10485760}},
  { "driverEncodeData", {"driverEncodeData", false, 20.000000, -1, 10485760}},
  { "wideRoadEncodeData", {"wideRoadEncodeData", false, 20.000000, -1, 10485760}},
@@ -86,7 +86,6 @@ _services: dict[str, tuple] = {
  "rawAudioData": (False, 20.),
  "bookmarkButton": (True, 0., 1),
  "audioFeedback": (True, 0., 1),
-  "visionSpeedLimitBookmark": (False, 0., 1),
  "roadEncodeData": (False, 20., None, QueueSize.BIG),
  "driverEncodeData": (False, 20., None, QueueSize.BIG),
  "wideRoadEncodeData": (False, 20., None, QueueSize.BIG),
@@ -345,7 +345,6 @@ inline static std::unordered_map<std::string, ParamKeyAttributes> keys = {
    {"FordCurvatureBlendHigh", {PERSISTENT, FLOAT, "0.4", "0.4", 2}},
    {"FordCurvatureBlendLow", {PERSISTENT, FLOAT, "0.4", "0.4", 2}},
    {"FordCurvatureLaneChangeFactor", {PERSISTENT, FLOAT, "0.85", "0.85", 2}},
-    {"FordHandsFreeCluster", {PERSISTENT, BOOL, "0", "0", 2}},
    {"FordHumanTurnDetection", {PERSISTENT, BOOL, "1", "1", 2}},
    {"FordLateralMode", {PERSISTENT, INT, "1", "1", 2}},
    {"FLMActiveOverrides", {PERSISTENT, JSON, "{}", "{}", 2}},
@@ -549,6 +548,7 @@ inline static std::unordered_map<std::string, ParamKeyAttributes> keys = {
    {"RelaxedJerkDeceleration", {PERSISTENT, FLOAT, "100.0", "100.0", 3}},
    {"RelaxedJerkSpeed", {PERSISTENT, FLOAT, "100.0", "100.0", 3}},
    {"RelaxedJerkSpeedDecrease", {PERSISTENT, FLOAT, "100.0", "100.0", 3}},
+    {"ReverseCruise", {PERSISTENT, BOOL, "0", "0", 1}},
    {"RivianAngleControl", {PERSISTENT, BOOL, "0", "0", 2, SETTINGS_SIMPLE}},
    {"RivianAngleSaturated", {CLEAR_ON_MANAGER_START | CLEAR_ON_ONROAD_TRANSITION, BOOL, "0", "0"}},
    {"RivianToiRecoveryFailed", {CLEAR_ON_MANAGER_START | CLEAR_ON_ONROAD_TRANSITION, BOOL, "0", "0"}},
@@ -679,7 +679,6 @@ inline static std::unordered_map<std::string, ParamKeyAttributes> keys = {
    {"TuningLevel", {PERSISTENT, INT, "0", "0", 0}},
    {"TuningLevelConfirmed", {PERSISTENT, BOOL, "0", "0", 0}},
    {"TurnDesires", {PERSISTENT, BOOL, "0", "0", 2}},
-    {"TurnSteeringLimitMuteSpeed", {PERSISTENT, INT, "0", "0", 0}},
    {"UnlockDoors", {PERSISTENT, BOOL, "1", "0", 0}},
    {"Updated", {PERSISTENT, STRING, "0", "0"}},
    {"UpdateSpeedLimits", {CLEAR_ON_MANAGER_START, BOOL, "0", "0"}},
@@ -147,10 +147,101 @@ function launch {
    while true; do sleep 1; done
  fi

+  function prebuilt_runtime_compatible {
+    python3 - <<'PY'
+import importlib
+import os
+from pathlib import Path
+import sys
+import time
+
+from openpilot.common.file_chunker import get_existing_chunks
+
+start = time.monotonic()
+last = start
+log_path = os.environ.get("SP_BOOT_TIMING_LOG")
+
+def emit(line):
+  print(line, flush=True)
+  if log_path:
+    try:
+      with open(log_path, "a") as f:
+        f.write(line + "\n")
+    except OSError:
+      pass
+
+def log_step(label):
+  global last
+  now = time.monotonic()
+  emit(f"SP_BOOT_TIMING prebuilt_compat {label} +{now - last:.3f}s total={now - start:.3f}s")
+  last = now
+
+mods = [
+  "openpilot.common.params_pyx",
+  "msgq.ipc_pyx",
+  "msgq.visionipc.visionipc_pyx",
+  "openpilot.common.transformations.transformations",
+  "openpilot.selfdrive.pandad.pandad_api_impl",
+  "openpilot.selfdrive.controls.lib.lateral_mpc_lib.c_generated_code.acados_ocp_solver_pyx",
+  "openpilot.selfdrive.controls.lib.longitudinal_mpc_lib.c_generated_code.acados_ocp_solver_pyx",
+]
+
+for mod in mods:
+  try:
+    importlib.import_module(mod)
+  except Exception as e:
+    print(f"Prebuilt compatibility failure in {mod}: {e}", file=sys.stderr)
+    raise
+  log_step(f"import:{mod}")
+
+repo_root = Path.cwd().parents[1]
+required_model_artifacts = [
+  repo_root / "selfdrive/modeld/models/driving_tinygrad.pkl",
+  repo_root / "selfdrive/modeld/models/dmonitoring_model_metadata.pkl",
+  repo_root / "selfdrive/modeld/models/dmonitoring_model_tinygrad.pkl",
+  repo_root / "selfdrive/modeld/models/dm_warp_1928x1208_tinygrad.pkl",
+  repo_root / "selfdrive/modeld/models/dm_warp_1344x760_tinygrad.pkl",
+]
+required_files = [
+  repo_root / "selfdrive/pandad/pandad_api_impl.so",
+  repo_root / "selfdrive/controls/lib/lateral_mpc_lib/c_generated_code/acados_ocp_solver_pyx.so",
+  repo_root / "selfdrive/controls/lib/lateral_mpc_lib/c_generated_code/libacados_ocp_solver_lat.so",
+  repo_root / "selfdrive/controls/lib/longitudinal_mpc_lib/c_generated_code/acados_ocp_solver_pyx.so",
+  repo_root / "selfdrive/controls/lib/longitudinal_mpc_lib/c_generated_code/libacados_ocp_solver_long.so",
+  repo_root / "opendbc_repo/opendbc/dbc/gm_global_a_powertrain_generated.dbc",
+]
+
+for path in required_model_artifacts:
+  try:
+    artifact_paths = [Path(p) for p in get_existing_chunks(path)]
+  except Exception as e:
+    raise FileNotFoundError(f"Missing prebuilt runtime artifact: {path}") from e
+  missing_chunks = [p for p in artifact_paths if not p.is_file()]
+  if missing_chunks:
+    missing = ", ".join(str(p) for p in missing_chunks)
+    raise FileNotFoundError(f"Missing prebuilt runtime artifact chunks for {path}: {missing}")
+log_step("required_model_artifacts")
+
+for path in required_files:
+  if not path.is_file():
+    raise FileNotFoundError(f"Missing prebuilt runtime artifact: {path}")
+log_step("required_files")
+PY
+  }
+
+  USE_PREBUILT=1
+  if [ -f /data/params/d/UsePrebuilt ]; then
+    USE_PREBUILT=$(tr -d '\n' < /data/params/d/UsePrebuilt)
+  fi
+
  sp_launch_timing "prebuilt_decision_done"
-  # Published trees carry this marker and must never compile on-device.
-  # Developers can remove it explicitly when working from a source tree.
-  if [ ! -f "$DIR/prebuilt" ]; then
+  if [ "$USE_PREBUILT" = "1" ] && [ -f $DIR/prebuilt ] && ! prebuilt_runtime_compatible; then
+    echo "Prebuilt runtime artifacts are incompatible on this device; rebuilding locally."
+    USE_PREBUILT=0
+  fi
+  sp_launch_timing "prebuilt_compat_done"
+
+  if [ "$USE_PREBUILT" != "1" ] || [ ! -f $DIR/prebuilt ]; then
    sp_launch_timing "build_start"
    ./build.py
    sp_launch_timing "build_done"
@@ -21,7 +21,7 @@ fi
 export QCOM_PRIORITY=12

 if [ -z "$AGNOS_VERSION" ]; then
-  export AGNOS_VERSION="19.6.10"
+  export AGNOS_VERSION="19.6.1"
 fi

 if [ -z "$AGNOS_ACCEPTED_VERSIONS" ]; then
@@ -255,15 +255,9 @@ class CarController(CarControllerBase):

    if (self.frame % CarControllerParams.ACC_UI_STEP) == 0 or send_ui:
      show_distance_bars = self.frame - self.distance_bar_frame < 400
-      hands_free_cluster = bool(
-        self.ford_lateral is not None
-        and self.ford_lateral.mode != FordLateralMode.native
-        and self.ford_lateral.mode == self.ford_lateral_announced_mode
-        and self.ford_lateral.hands_free_cluster_enabled)
      can_sends.append(fordcan.create_acc_ui_msg(self.packer, self.CAN, self.CP, main_on, CC.latActive,
                                                 fcw_alert, CS.out.cruiseState.standstill, show_distance_bars,
-                                                 hud_control, CS.acc_tja_status_stock_values,
-                                                 hands_free_cluster))
+                                                 hud_control, CS.acc_tja_status_stock_values))

    self.main_on_last = main_on
    self.lkas_enabled_last = CC.latActive
@@ -181,7 +181,7 @@ def create_acc_msg(packer, CAN: CanBus, long_active: bool, gas: float, accel: fl


 def create_acc_ui_msg(packer, CAN: CanBus, CP, main_on: bool, enabled: bool, fcw_alert: bool, standstill: bool,
-                      show_distance_bars: bool, hud_control, stock_values: dict, hands_free_cluster: bool = False):
+                      show_distance_bars: bool, hud_control, stock_values: dict):
  """
  Creates a CAN message for the Ford IPC adaptive cruise, forward collision warning and traffic jam
  assist status.
@@ -197,8 +197,6 @@ def create_acc_ui_msg(packer, CAN: CanBus, CP, main_on: bool, enabled: bool, fcw
      status = 3  # ActiveInterventionLeft
    elif hud_control.rightLaneDepart:
      status = 4  # ActiveInterventionRight
-    elif hands_free_cluster:
-      status = 7  # Hands-free assistance display
    else:
      status = 2  # Active
  elif main_on:
@@ -54,10 +54,10 @@ class CarInterface(CarInterfaceBase):
      cfgs.insert(0, get_safety_config(structs.CarParams.SafetyModel.noOutput))
    ret.safetyConfigs = cfgs

-    ret.alphaLongitudinalAvailable = True
-    ret.openpilotLongitudinalControl = bool(alpha_long)
-    if ret.openpilotLongitudinalControl:
+    ret.alphaLongitudinalAvailable = ret.radarUnavailable
+    if alpha_long or not ret.radarUnavailable:
      ret.safetyConfigs[-1].safetyParam |= FordSafetyFlags.LONG_CONTROL.value
+      ret.openpilotLongitudinalControl = True

    if ret.flags & FordFlags.CANFD:
      ret.safetyConfigs[-1].safetyParam |= FordSafetyFlags.CANFD.value
@@ -1,17 +1,12 @@
 import random
 from collections.abc import Iterable
-from types import SimpleNamespace

 from hypothesis import settings, given, strategies as st
 from parameterized import parameterized

-from opendbc.car import gen_empty_fingerprint
-from opendbc.can import CANPacker
-from opendbc.car.ford import fordcan
 from opendbc.car.structs import CarParams
 from opendbc.car.fw_versions import build_fw_dict
-from opendbc.car.ford.interface import CarInterface
-from opendbc.car.ford.values import CAR, FW_QUERY_CONFIG, FW_PATTERN, FordSafetyFlags, get_platform_codes, match_vin_to_car
+from opendbc.car.ford.values import CAR, FW_QUERY_CONFIG, FW_PATTERN, get_platform_codes, match_vin_to_car
 from opendbc.car.ford.fingerprints import FW_VERSIONS

 Ecu = CarParams.Ecu
@@ -159,45 +154,3 @@ class TestFordFW:
    live_fw[(0x760, None)] = {b"M1MC-2D053-XX\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"}
    candidates = FW_QUERY_CONFIG.match_fw_to_car_fuzzy(live_fw, '', {expected_fingerprint: offline_fw})
    assert len(candidates) == 0, "Should not match new model year hint"
-
-
-def test_mach_e_longitudinal_toggle_controls_stock_acc_selection():
-  stock = CarInterface.get_params(
-    CAR.FORD_MUSTANG_MACH_E_MK1, gen_empty_fingerprint(), [], False, False, False, None)
-  enhanced = CarInterface.get_params(
-    CAR.FORD_MUSTANG_MACH_E_MK1, gen_empty_fingerprint(), [], True, False, False, None)
-
-  assert stock.alphaLongitudinalAvailable
-  assert not stock.openpilotLongitudinalControl
-  assert stock.pcmCruise
-  assert not (stock.safetyConfigs[-1].safetyParam & FordSafetyFlags.LONG_CONTROL)
-
-  assert enhanced.alphaLongitudinalAvailable
-  assert enhanced.openpilotLongitudinalControl
-  assert enhanced.safetyConfigs[-1].safetyParam & FordSafetyFlags.LONG_CONTROL
-
-
-def test_hands_free_cluster_status_is_opt_in():
-  packer = CANPacker("ford_lincoln_base_pt")
-  CAN = SimpleNamespace(main=0)
-  CP = SimpleNamespace(openpilotLongitudinalControl=False)
-  hud = SimpleNamespace(leftLaneDepart=False, rightLaneDepart=False)
-  stock_values = dict.fromkeys([
-    "HaDsply_No_Cs", "HaDsply_No_Cnt", "AccStopStat_D_Dsply", "AccTrgDist2_D_Dsply",
-    "AccStopRes_B_Dsply", "TjaWarn_D_Rq", "TjaMsgTxt_D_Dsply", "IaccLamp_D_Rq",
-    "AccMsgTxt_D2_Rq", "FcwDeny_B_Dsply", "FcwMemStat_B_Actl", "AccTGap_B_Dsply",
-    "CadsAlignIncplt_B_Actl", "AccFllwMde_B_Dsply", "CadsRadrBlck_B_Actl",
-    "CmbbPostEvnt_B_Dsply", "AccStopMde_B_Dsply", "FcwMemSens_D_Actl",
-    "FcwMsgTxt_D_Rq", "AccWarn_D_Dsply", "FcwVisblWarn_B_Rq", "FcwAudioWarn_B_Rq",
-    "AccTGap_D_Dsply", "AccMemEnbl_B_RqDrv", "FdaMem_B_Stat",
-  ], 0)
-
-  regular = fordcan.create_acc_ui_msg(
-    packer, CAN, CP, True, True, False, False, False, hud, stock_values)
-  hands_free = fordcan.create_acc_ui_msg(
-    packer, CAN, CP, True, True, False, False, False, hud, stock_values, True)
-  expected_regular = packer.make_can_msg("ACCDATA_3", 0, {"Tja_D_Stat": 2})
-  expected_hands_free = packer.make_can_msg("ACCDATA_3", 0, {"Tja_D_Stat": 7})
-
-  assert regular == expected_regular
-  assert hands_free == expected_hands_free
@@ -9,12 +9,10 @@ from opendbc.car.common.conversions import Conversions as CV
 from opendbc.car.hyundai import hyundaicanfd, hyundaican
 from opendbc.car.hyundai.hyundaicanfd import CanBus
 from opendbc.car.hyundai.values import HyundaiFlags, Buttons, CarControllerParams, CAR, CANFD_ANGLE_LONGITUDINAL_CAR, \
-                                        CANFD_RADAR_LIVE_LONGITUDINAL_CAR, CANFD_ALT_BUTTONS_RESUME_CAR, kia_ev6_gt_line_longitudinal_tuning, \
-                                        KIA_EV6_GT_LINE_LONG_TUNING_TESTING_GROUND_ID
+                                        CANFD_RADAR_LIVE_LONGITUDINAL_CAR, kia_ev6_gt_line_longitudinal_tuning
 from opendbc.car.interfaces import CarControllerBase
 from opendbc.car.vehicle_model import VehicleModel
 from openpilot.common.params import Params
-from openpilot.starpilot.common.testing_grounds import testing_ground

 VisualAlert = structs.CarControl.HUDControl.VisualAlert
 LongCtrlState = structs.CarControl.Actuators.LongControlState
@@ -81,10 +79,7 @@ BLINDSPOT_WARNING_SOUND_SAMPLES = 36

 def egmp_dynamic_longitudinal_tuning(CP) -> bool:
  return CP.carFingerprint in (CAR.HYUNDAI_IONIQ_6, CAR.KIA_EV9, CAR.HYUNDAI_IONIQ_5_PE) or \
-    kia_ev6_gt_line_longitudinal_tuning(
-      CP.carFingerprint, getattr(CP, "carVin", ""),
-      testing_ground.use(KIA_EV6_GT_LINE_LONG_TUNING_TESTING_GROUND_ID),
-    )
+    kia_ev6_gt_line_longitudinal_tuning(CP.carFingerprint, getattr(CP, "carVin", ""))


 def get_canfd_scc_decel_step(CP) -> float:
@@ -92,10 +87,7 @@ def get_canfd_scc_decel_step(CP) -> float:


 def should_reset_ev6_gt_line_longitudinal_tuning(CP, long_control_state: LongCtrlState) -> bool:
-  return kia_ev6_gt_line_longitudinal_tuning(
-    CP.carFingerprint, getattr(CP, "carVin", ""),
-    testing_ground.use(KIA_EV6_GT_LINE_LONG_TUNING_TESTING_GROUND_ID),
-  ) and \
+  return kia_ev6_gt_line_longitudinal_tuning(CP.carFingerprint, getattr(CP, "carVin", "")) and \
    long_control_state == LongCtrlState.off


@@ -639,10 +631,7 @@ class CarController(CarControllerBase):

    use_egmp_dynamic_long_tuning = egmp_dynamic_longitudinal_tuning(self.CP) and self.long_active_ecu and \
                                   actuators.longControlState in (LongCtrlState.starting, LongCtrlState.pid, LongCtrlState.stopping)
-    is_ev6_gt_line = kia_ev6_gt_line_longitudinal_tuning(
-      self.CP.carFingerprint, getattr(self.CP, "carVin", ""),
-      testing_ground.use(KIA_EV6_GT_LINE_LONG_TUNING_TESTING_GROUND_ID),
-    )
+    is_ev6_gt_line = kia_ev6_gt_line_longitudinal_tuning(self.CP.carFingerprint, getattr(self.CP, "carVin", ""))
    is_ccnc_angle_long = self.CP.carFingerprint in CANFD_ANGLE_LONGITUDINAL_CAR
    if is_ccnc_angle_long and (self._ev9_long_tuning.stop_request or not CC.enabled or CC.cruiseControl.override):
      self._ioniq_6_long_tuning = reset_egmp_longitudinal_tuning(self._ioniq_6_long_tuning)
@@ -789,7 +778,6 @@ class CarController(CarControllerBase):
      # TODO: unclear if this is needed
      jerk = 3.0 if actuators.longControlState == LongCtrlState.pid else 1.0
      use_fca = self.CP.flags & HyundaiFlags.USE_FCA.value
-      main_cruise_enabled = getattr(CS, "main_cruise_on", False) if getattr(CS, "main_cruise_tracking", False) else True
      if blended_hda2:
        stopping = stopping and CS.out.vEgoRaw < 0.1
        can_sends.extend(hyundaican.create_acc_commands_can_canfd_blended_hda2(
@@ -805,8 +793,7 @@ class CarController(CarControllerBase):
      else:
        can_sends.extend(hyundaican.create_acc_commands(self.packer, CC.enabled, accel, jerk, int(self.frame / 2),
                                                        hud_control, set_speed_in_units, stopping,
-                                                        CC.cruiseControl.override, use_fca, self.CP,
-                                                        main_cruise_enabled))
+                                                        CC.cruiseControl.override, use_fca, self.CP))

    # 20 Hz LFA MFA message
    if self.frame % 5 == 0 and (self.CP.flags & HyundaiFlags.SEND_LFA.value or (self.long_active_ecu and blended_hda2)):
@@ -868,7 +855,14 @@ class CarController(CarControllerBase):
                                                             steering_msg_active, apply_torque, apply_angle,
                                                             CS.stock_lfa_msg if preserve_stock_lfa_status else None,
                                                             CS.stock_lkas_msg if preserve_stock_lkas else None,
-                                                             lka_icon=lka_icon))
+                                                             lka_icon=lka_icon,
+                                                             send_lfa_status=self.ecu_disable_failed and
+                                                             self.CP.carFingerprint == CAR.KIA_EV9))
+    elif self.ecu_disable_failed and self.CP.carFingerprint == CAR.KIA_EV9:
+      can_sends.extend(hyundaicanfd.create_steering_messages(
+        self.packer, self.CP, self.CAN, CC.enabled, False, 0.0, 0.0,
+        CS.stock_lfa_msg, lka_icon=lka_icon, send_lfa_status=True, lfa_only=True,
+      ))
    direct_steering_active = ccnc_angle_long and drive_gear and CC.latActive and self.direct_angle_request_allowed and not CS.angle_steering_fault
    inactive_steering_angle = float(np.clip(CS.angle_steering_angle,
                                            -self.params.ANGLE_LIMITS.STEER_ANGLE_MAX,
@@ -1042,13 +1036,9 @@ class CarController(CarControllerBase):

        # cruise standstill resume
        elif CC.cruiseControl.resume:
-          if self.CP.flags & HyundaiFlags.CANFD_ALT_BUTTONS and self.CP.carFingerprint in CANFD_ALT_BUTTONS_RESUME_CAR:
-            for _ in range(20):
-              can_sends.append(hyundaicanfd.create_buttons(
-                self.packer, self.CP, self.CAN, (CS.buttons_counter + 1) % 0x100,
-                Buttons.RES_ACCEL, base_values=CS.cruise_buttons_msg,
-              ))
-            self.last_button_frame = self.frame
+          if self.CP.flags & HyundaiFlags.CANFD_ALT_BUTTONS:
+            # TODO: resume for alt button cars
+            pass
          else:
            for _ in range(20):
              can_sends.append(hyundaicanfd.create_buttons(self.packer, self.CP, self.CAN, CS.buttons_counter + 1, Buttons.RES_ACCEL))
@@ -9,7 +9,6 @@ from opendbc.car.common.conversions import Conversions as CV
 from opendbc.car.hyundai.hyundaicanfd import CanBus
 from opendbc.car.hyundai.values import HyundaiFlags, HyundaiStarPilotFlags, HyundaiStarPilotSafetyFlags, CAR, DBC, Buttons, CarControllerParams, \
                                       CANFD_ANGLE_LONGITUDINAL_CAR, CANFD_CORNER_RADAR_BSM_CAR, \
-                                       CANFD_ALT_BUTTONS_RESUME_CAR, \
                                       hyundai_cancel_button_enables_cruise, ALT_BUS_LDA_BUTTON_CARS, ALT_BUS_LDA_BUTTON_SWL_STAT_CARS
 from opendbc.car.interfaces import CarStateBase

@@ -133,7 +132,6 @@ class CarState(CarStateBase):
    self.is_metric = False
    self.buttons_counter = 0
    self.main_cruise_on = False
-    self.main_cruise_tracking = bool(getattr(FPCP, "flags", 0) & HyundaiStarPilotFlags.MAIN_CRUISE_STATE_TRACKING)

    self.cruise_info = {}
    self.msg_161 = {}
@@ -560,9 +558,7 @@ class CarState(CarStateBase):
    self.main_buttons.extend(cp.vl_all[self.cruise_btns_msg_canfd]["ADAPTIVE_CRUISE_MAIN_BTN"])
    self.lda_button = cp.vl[self.cruise_btns_msg_canfd]["LDA_BTN"]
    self.left_paddle = 0
-    if self.CP.carFingerprint in CANFD_ALT_BUTTONS_RESUME_CAR:
-      self.cruise_buttons_msg = copy.copy(cp.vl[self.cruise_btns_msg_canfd])
-    elif self.CP.carFingerprint == CAR.HYUNDAI_IONIQ_6:
+    if self.CP.carFingerprint == CAR.HYUNDAI_IONIQ_6:
      self.cruise_buttons_msg = copy.copy(cp.vl["CRUISE_BUTTONS"])
      self.left_paddle = cp.vl["CRUISE_BUTTONS"]["LEFT_PADDLE"]
    self.buttons_counter = cp.vl[self.cruise_btns_msg_canfd]["COUNTER"]
@@ -595,7 +591,7 @@ class CarState(CarStateBase):
                        *create_button_events(self.main_buttons[-1], prev_main_buttons, {1: ButtonType.mainCruise}),
                        *create_button_events(self.lda_button, prev_lda_button, {1: ButtonType.lkas}),
                        *create_button_events(self.left_paddle, prev_left_paddle, {1: ButtonType.altButton2})]
-    if self.CP.openpilotLongitudinalControl and (self.CP.carFingerprint == CAR.KIA_EV9 or self.main_cruise_tracking):
+    if self.CP.openpilotLongitudinalControl and self.CP.carFingerprint == CAR.KIA_EV9:
      ret.cruiseState.available = self.update_main_cruise(ret)

    ret.blockPcmEnable = not self.recent_button_interaction()
@@ -622,9 +618,7 @@ class CarState(CarStateBase):
  def get_can_parsers_canfd(self, CP):
    msgs = []
    cam_msgs = []
-    if CP.carFingerprint in CANFD_ALT_BUTTONS_RESUME_CAR:
-      msgs.append(("CRUISE_BUTTONS_ALT", 50))
-    elif not (CP.flags & HyundaiFlags.CANFD_ALT_BUTTONS):
+    if not (CP.flags & HyundaiFlags.CANFD_ALT_BUTTONS):
      # The EV9 can stop publishing this during the non-ECU-disabled startup
      # state. Keep decoding it when present without making CAN invalid.
      msgs += [
@@ -284,12 +284,11 @@ def create_acc_commands_can_canfd_blended_hda2(packer, enabled, accel, accel_las
  return commands


-def create_acc_commands(packer, enabled, accel, upper_jerk, idx, hud_control, set_speed, stopping, long_override, use_fca, CP,
-                        main_cruise_enabled=True):
+def create_acc_commands(packer, enabled, accel, upper_jerk, idx, hud_control, set_speed, stopping, long_override, use_fca, CP):
  commands = []

  scc11_values = {
-    "MainMode_ACC": int(bool(main_cruise_enabled)),
+    "MainMode_ACC": 1,
    "TauGapSet": hud_control.leadDistanceBars,
    "VSetDis": set_speed if enabled else 0,
    "AliveCounterACC": idx % 0x10,
@@ -3,7 +3,7 @@ import numpy as np
 from opendbc.car import CanBusBase, CanData
 from opendbc.car.common.conversions import Conversions as CV
 from opendbc.car.crc import CRC16_XMODEM
-from opendbc.car.hyundai.values import HyundaiFlags, CAR, CANFD_ALT_BUTTONS_RESUME_CAR
+from opendbc.car.hyundai.values import HyundaiFlags, CAR


 def _set_value(msg: bytearray, sig, ival: int) -> None:
@@ -152,14 +152,17 @@ def create_angle_adas_cmd(packer, CAN, apply_angle: float, lat_active: bool, tor


 def create_steering_messages(packer, CP, CAN, enabled, lat_active, apply_torque, apply_angle,
-                             lfa_base_values=None, lkas_base_values=None, lka_icon=None):
+                             lfa_base_values=None, lkas_base_values=None, lka_icon=None,
+                             send_lfa_status=False, lfa_only=False):
  if lka_icon is None:
    lka_icon = 2 if enabled else 1

  if CP.carFingerprint == CAR.GENESIS_GV70_ELECTRIFIED_1ST_GEN and CP.flags & HyundaiFlags.CANFD_LKA_STEERING:
    ret = []
-    if CP.openpilotLongitudinalControl:
+    if CP.openpilotLongitudinalControl or send_lfa_status:
      ret.append(_create_gv70_lka_status_msg(packer, CAN, "LFA", CAN.ECAN, enabled, lat_active, apply_torque))
+    if lfa_only:
+      return ret
    ret.append(_create_gv70_lka_status_msg(packer, CAN, "LKAS", CAN.ACAN, enabled, lat_active, apply_torque))
    return ret

@@ -255,8 +258,10 @@ def create_steering_messages(packer, CP, CAN, enabled, lat_active, apply_torque,
  ret = []
  if CP.flags & HyundaiFlags.CANFD_LKA_STEERING:
    lkas_msg = "LKAS_ALT" if CP.flags & HyundaiFlags.CANFD_LKA_STEERING_ALT else "LKAS"
-    if CP.openpilotLongitudinalControl and not CP.flags & HyundaiFlags.CAN_CANFD_BLENDED:
+    if (CP.openpilotLongitudinalControl and not CP.flags & HyundaiFlags.CAN_CANFD_BLENDED) or send_lfa_status:
      ret.append(packer.make_can_msg("LFA", CAN.ECAN, lfa_values))
+    if lfa_only:
+      return ret
    ret.append(packer.make_can_msg(lkas_msg, CAN.ACAN, lkas_values))
  else:
    if CP.flags & HyundaiFlags.CANFD_ANGLE_STEERING:
@@ -306,27 +311,16 @@ def create_suppress_lfa(packer, CAN, lfa_block_msg, lka_steering_alt):


 def create_buttons(packer, CP, CAN, cnt, btn=0, base_values=None, left_paddle=False, right_paddle=False):
-  values = {k: v for k, v in base_values.items() if k not in ("CHECKSUM", "_CHECKSUM", "COUNTER")} if base_values else {}
+  values = {k: v for k, v in base_values.items() if k not in ("_CHECKSUM", "COUNTER")} if base_values else {}
  values.update({
    "COUNTER": cnt,
    "SET_ME_1": 1,
    "CRUISE_BUTTONS": btn,
+    "LEFT_PADDLE": int(left_paddle),
+    "RIGHT_PADDLE": int(right_paddle),
  })
-  if not (CP.flags & HyundaiFlags.CANFD_ALT_BUTTONS and CP.carFingerprint in CANFD_ALT_BUTTONS_RESUME_CAR):
-    values.update({
-      "LEFT_PADDLE": int(left_paddle),
-      "RIGHT_PADDLE": int(right_paddle),
-    })

  bus = CAN.ECAN if CP.flags & HyundaiFlags.CANFD_LKA_STEERING else CAN.CAM
-  if CP.flags & HyundaiFlags.CANFD_ALT_BUTTONS and CP.carFingerprint in CANFD_ALT_BUTTONS_RESUME_CAR:
-    address, dat, bus = packer.make_can_msg("CRUISE_BUTTONS_ALT", bus, values)
-    dat = bytearray(dat)
-    checksum = hkg_can_fd_checksum(address, None, dat)
-    dat[0] = checksum & 0xFF
-    dat[1] = (checksum >> 8) & 0xFF
-    return address, bytes(dat), bus
-
  return packer.make_can_msg("CRUISE_BUTTONS", bus, values)


@@ -12,15 +12,13 @@ from opendbc.car.hyundai.values import HyundaiFlags, CAR, CarControllerParams, \
                                                   CAN_CANFD_BLENDED_HDA2_LONGITUDINAL_CAR, \
                                                   HyundaiStarPilotSafetyFlags, \
                                                   hyundai_cancel_button_enables_cruise, \
-                                                   kia_ev6_gt_line_longitudinal_tuning, \
-                                                   KIA_EV6_GT_LINE_LONG_TUNING_TESTING_GROUND_ID
+                                                   kia_ev6_gt_line_longitudinal_tuning
 from opendbc.car.hyundai.radar_interface import get_radar_track_config, radar_tracks_available
 from opendbc.car.interfaces import CarInterfaceBase, ACCEL_MIN
 from opendbc.car.disable_ecu import disable_ecu, ecu_log
 from opendbc.car.hyundai.carcontroller import CarController
 from opendbc.car.hyundai.carstate import CarState
 from opendbc.car.hyundai.radar_interface import RadarInterface
-from openpilot.starpilot.common.testing_grounds import testing_ground

 ButtonType = structs.CarState.ButtonEvent.Type
 Ecu = structs.CarParams.Ecu
@@ -108,8 +106,7 @@ class CarInterface(CarInterfaceBase):

  @staticmethod
  def apply_post_fingerprint_params(CP: structs.CarParams, candidate, fingerprint, car_fw) -> None:
-    gt_line_testing_ground = testing_ground.use(KIA_EV6_GT_LINE_LONG_TUNING_TESTING_GROUND_ID)
-    if kia_ev6_gt_line_longitudinal_tuning(CP.carFingerprint, CP.carVin, gt_line_testing_ground):
+    if kia_ev6_gt_line_longitudinal_tuning(CP.carFingerprint, CP.carVin):
      apply_kia_ev6_gt_line_longitudinal_params(CP)

  @staticmethod
@@ -25,7 +25,7 @@ from opendbc.car.hyundai.carstate import CarState, decode_canfd_camera_lead, dec
                                             get_canfd_cruise_available
 from opendbc.car.hyundai.interface import CarInterface, KIA_EV9_ACCEL_MAX
 from opendbc.car.hyundai import hyundaican, hyundaicanfd
-from opendbc.car.hyundai.hyundaicanfd import CanBus, hkg_can_fd_checksum
+from opendbc.car.hyundai.hyundaicanfd import CanBus
 from opendbc.car.hyundai.radar_interface import MRREVO14F_RADAR_START_ADDR, MRR30_RADAR_START_ADDR, MRR35_RADAR_START_ADDR, \
                                             RADAR_START_ADDR, get_radar_track_config
 from opendbc.car.hyundai.values import CAMERA_SCC_CAR, CANFD_CAR, CAN_GEARS, CAR, CHECKSUM, DATE_FW_ECUS, DATELESS_FUZZY_CARS, \
@@ -522,27 +522,6 @@ class TestHyundaiFingerprint:
    k4_cp = CarInterface.get_params(CAR.KIA_K4_2025, fingerprint, [], False, False, False, None)
    assert not (k4_cp.flags & HyundaiFlags.CANFD_ALT_BUTTONS)

-  @pytest.mark.parametrize("candidate", (CAR.KIA_CARNIVAL_2025, CAR.KIA_CARNIVAL_HEV_4TH_GEN))
-  def test_carnival_hda1_resume_uses_alternate_button_frame(self, candidate):
-    fingerprint = gen_empty_fingerprint()
-    fingerprint[0] = {0x1AA: 16}
-    CP = CarInterface.get_params(candidate, fingerprint, [], False, False, False, None)
-    assert CP.flags & HyundaiFlags.CANFD_ALT_BUTTONS
-    assert not CP.openpilotLongitudinalControl
-    assert "CRUISE_BUTTONS_ALT" in {
-      state.name for state in CarState(CP, None).get_can_parsers(CP)[Bus.pt].message_states.values()
-    }
-
-    packer = CANPacker(DBC[CP.carFingerprint][Bus.pt])
-    address, dat, bus = hyundaicanfd.create_buttons(
-      packer, CP, CanBus(CP), 0x41, Buttons.RES_ACCEL,
-      base_values={"SET_ME_1": 1, "DISTANCE_UNIT": 0},
-    )
-    assert (address, bus) == (0x1AA, CanBus(CP).CAM)
-    assert dat[2] == 0x41
-    assert (dat[4] >> 4) & 0x7 == Buttons.RES_ACCEL
-    assert int.from_bytes(dat[:2], "little") == hkg_can_fd_checksum(address, None, bytearray(dat))
-
  def test_ioniq_6_hda1_layout_stays_non_lka(self):
    fingerprint = gen_empty_fingerprint()
    fingerprint[1] = {0x100: 8, 0x110: 8}
@@ -727,18 +706,14 @@ class TestHyundaiFingerprint:
    assert combined_safety_param & HyundaiSafetyFlags.LONG
    assert combined_safety_param & HyundaiStarPilotSafetyFlags.AOL_LKAS_ON_ENGAGE

-  @pytest.mark.parametrize("candidate, tracks_main_cruise", (
-    (CAR.HYUNDAI_ELANTRA_2021, False),
-    (CAR.HYUNDAI_ELANTRA_HEV_2024, True),
-    (CAR.HYUNDAI_SONATA_HYBRID, True),
-  ))
-  def test_legacy_hyundai_long_main_cruise_tracking_is_vehicle_specific(self, candidate, tracks_main_cruise):
+  @pytest.mark.parametrize("candidate", (CAR.HYUNDAI_ELANTRA_2021, CAR.HYUNDAI_SONATA_HYBRID))
+  def test_legacy_hyundai_long_does_not_gate_availability_on_main_cruise(self, candidate):
    toggles = get_test_toggles()
    CP = CarInterface.get_params(candidate, gen_empty_fingerprint(), [], True, False, False, toggles)
    FPCP = CarInterface.get_starpilot_params(
      candidate, gen_empty_fingerprint(), [], CP, toggles,
    )
-    assert bool(FPCP.flags & HyundaiStarPilotFlags.MAIN_CRUISE_STATE_TRACKING) is tracks_main_cruise
+    assert not (FPCP.flags & HyundaiStarPilotFlags.MAIN_CRUISE_STATE_TRACKING)

    ioniq_cp = CarInterface.get_params(CAR.HYUNDAI_IONIQ_6, gen_empty_fingerprint(), [], True, False, False, toggles)
    ioniq_fpcp = CarInterface.get_starpilot_params(
@@ -1013,45 +988,6 @@ class TestHyundaiFingerprint:
    assert long_xceed.safetyConfigs[-1].safetyParam & HyundaiSafetyFlags.HYBRID_GAS
    assert long_xceed.safetyConfigs[-1].safetyParam & HyundaiSafetyFlags.LONG

-  def test_g80_alpha_long_preserves_legacy_safety(self):
-    toggles = get_test_toggles()
-
-    stock_g80 = CarInterface.get_params(CAR.GENESIS_G80, gen_empty_fingerprint(), [], False, False, False, toggles)
-    assert CAR.GENESIS_G80 in LEGACY_LONGITUDINAL_CAR
-    assert stock_g80.alphaLongitudinalAvailable
-    assert not stock_g80.openpilotLongitudinalControl
-    assert stock_g80.pcmCruise
-    assert stock_g80.safetyConfigs[-1].safetyModel == CarParams.SafetyModel.hyundaiLegacy
-    assert not (stock_g80.safetyConfigs[-1].safetyParam & HyundaiSafetyFlags.LONG)
-
-    long_g80 = CarInterface.get_params(CAR.GENESIS_G80, gen_empty_fingerprint(), [], True, False, False, toggles)
-    assert long_g80.alphaLongitudinalAvailable
-    assert long_g80.openpilotLongitudinalControl
-    assert not long_g80.pcmCruise
-    assert long_g80.safetyConfigs[-1].safetyModel == CarParams.SafetyModel.hyundaiLegacy
-    assert long_g80.safetyConfigs[-1].safetyParam & HyundaiSafetyFlags.LONG
-
-  @pytest.mark.parametrize("ecu_disabled", (True, False))
-  def test_g80_alpha_long_disables_stock_scc(self, monkeypatch, ecu_disabled):
-    toggles = get_test_toggles()
-    CP = CarInterface.get_params(CAR.GENESIS_G80, gen_empty_fingerprint(), [], True, False, False, toggles)
-
-    called = {}
-
-    def fake_disable_ecu(*args, **kwargs):
-      called.update(kwargs)
-      return ecu_disabled
-
-    monkeypatch.setattr("opendbc.car.hyundai.interface.disable_ecu", fake_disable_ecu)
-    CarInterface.init(CP, None, None)
-
-    assert called["addr"] == 0x7d0
-    assert called["bus"] == 0
-    assert called["reset"] is False
-    assert CP.openpilotLongitudinalControl == ecu_disabled
-    assert CP.pcmCruise != ecu_disabled
-    assert bool(CP.safetyConfigs[-1].safetyParam & HyundaiSafetyFlags.LONG) == ecu_disabled
-
  def test_xceed_phev_disable_failure_falls_back_to_stock_acc(self, monkeypatch):
    toggles = get_test_toggles()
    CP = CarInterface.get_params(CAR.KIA_XCEED_PHEV, gen_empty_fingerprint(), [], True, False, False, toggles)
@@ -1107,24 +1043,6 @@ class TestHyundaiFingerprint:
    assert reset_state.accel_last == pytest.approx(0.0)
    assert reset_state.long_control_state_last == LongCtrlState.off

-  def test_kia_ev6_gt_line_testing_ground_longitudinal_params(self, monkeypatch):
-    toggles = get_test_toggles()
-    CP = CarInterface.get_params(CAR.KIA_EV6, gen_empty_fingerprint(), [], True, False, False, toggles)
-    CP.carVin = "00000000000000000"
-
-    monkeypatch.setattr(
-      "opendbc.car.hyundai.interface.testing_ground",
-      SimpleNamespace(use=lambda slot_id: slot_id == "5"),
-    )
-    CarInterface.apply_post_fingerprint_params(CP, CAR.KIA_EV6, gen_empty_fingerprint(), [])
-
-    assert CP.startAccel == pytest.approx(1.4)
-    assert CP.vEgoStarting == pytest.approx(0.5)
-    assert CP.longitudinalActuatorDelay == pytest.approx(0.35)
-
-    assert kia_ev6_gt_line_longitudinal_tuning(CP.carFingerprint, CP.carVin, testing_ground_active=True)
-    assert not kia_ev6_gt_line_longitudinal_tuning(CAR.KIA_EV6_2025, CP.carVin, testing_ground_active=True)
-
  def test_kia_ev6_non_gt_line_keeps_family_longitudinal_params(self):
    toggles = get_test_toggles()
    CP = CarInterface.get_params(CAR.KIA_EV6, gen_empty_fingerprint(), [], True, False, False, toggles)
@@ -2477,22 +2395,6 @@ class TestHyundaiFingerprint:
    assert parser.vl["SCC14"]["ComfortBandLower"] == pytest.approx(0.0)
    assert parser.vl["SCC14"]["JerkLowerLimit"] == pytest.approx(5.0)

-  def test_can_acc_commands_follow_sonata_main_cruise_state(self):
-    CP = CarParams.new_message()
-    CP.carFingerprint = CAR.HYUNDAI_SONATA_HYBRID
-
-    packer = CANPacker(DBC[CP.carFingerprint][Bus.pt])
-    parser = CANParser(DBC[CP.carFingerprint][Bus.pt], [("SCC11", 0)], 0)
-
-    msgs = hyundaican.create_acc_commands(packer, enabled=False, accel=0.0, upper_jerk=1.0, idx=3,
-                                          hud_control=SimpleNamespace(leadDistanceBars=3, leadVisible=False), set_speed=42,
-                                          stopping=False, long_override=False, use_fca=False, CP=CP,
-                                          main_cruise_enabled=False)
-    parser.update([(1, msgs)])
-
-    assert parser.can_valid
-    assert parser.vl["SCC11"]["MainMode_ACC"] == 0
-
  def test_can_acc_commands_use_enabled_fca_status(self):
    CP = CarParams.new_message()
    CP.carFingerprint = CAR.GENESIS_G90
@@ -2711,47 +2613,26 @@ class TestHyundaiFingerprint:
      ("LKAS", can_bus.ACAN),
    ]

-  def test_ev9_fallback_active_lateral_uses_lkas_without_injecting_lfa(self):
+  def test_ev9_fallback_keeps_lfa_status_without_longitudinal_control(self):
    CP = CarParams.new_message()
    CP.carFingerprint = CAR.KIA_EV9
    CP.flags = int(HyundaiFlags.CANFD | HyundaiFlags.EV | HyundaiFlags.CCNC |
                   HyundaiFlags.CANFD_ANGLE_STEERING | HyundaiFlags.CANFD_LKA_STEERING |
                   HyundaiFlags.CANFD_LKA_STEERING_ALT)
-    CP.openpilotLongitudinalControl = True
-
-    controller = CarController(DBC[CP.carFingerprint], CP)
-    controller.frame = 1
-    controller.ecu_disable_failed = True
-    controller.long_active_ecu = False
    CP.openpilotLongitudinalControl = False
+
    packer = CANPacker(DBC[CP.carFingerprint][Bus.pt])
    can_bus = CanBus(CP)
-    cc = SimpleNamespace(
-      enabled=True,
-      latActive=True,
-      actuators=SimpleNamespace(longControlState=LongCtrlState.off),
-      cruiseControl=SimpleNamespace(cancel=False, resume=False),
-      leftBlinker=False,
-      rightBlinker=False,
-      hudControl=SimpleNamespace(),
-    )
-    cs = SimpleNamespace(
-      stock_lfa_msg={},
-      stock_lkas_msg={},
-      out=SimpleNamespace(
-        standstill=False,
-        steeringAngleDeg=-31.5,
-        gearShifter=structs.CarState.GearShifter.drive,
-      ),
+    msgs = hyundaicanfd.create_steering_messages(
+      packer, CP, can_bus, True, True, 0.44, -31.5, send_lfa_status=True,
    )

-    msgs = controller.create_canfd_msgs(0, True, 0.44, -31.5, 0.0, 0.0, False,
-                                        cc.hudControl, cs, cc, get_test_toggles(), lka_icon=2, lfa_icon=2)
    assert [(packer.dbc.addr_to_msg[addr].name, bus) for addr, _, bus in msgs] == [
+      ("LFA", can_bus.ECAN),
      ("LKAS_ALT", can_bus.ACAN),
    ]

-  def test_ev9_fallback_does_not_inject_lfa_while_parked(self):
+  def test_ev9_fallback_lfa_only_does_not_send_lkas_at_standstill(self):
    CP = CarParams.new_message()
    CP.carFingerprint = CAR.KIA_EV9
    CP.flags = int(HyundaiFlags.CANFD | HyundaiFlags.EV | HyundaiFlags.CCNC |
@@ -2759,31 +2640,15 @@ class TestHyundaiFingerprint:
                   HyundaiFlags.CANFD_LKA_STEERING_ALT)
    CP.openpilotLongitudinalControl = False

-    controller = CarController(DBC[CP.carFingerprint], CP)
-    controller.ecu_disable_failed = True
-    cc = SimpleNamespace(
-      enabled=False,
-      latActive=False,
-      actuators=SimpleNamespace(longControlState=LongCtrlState.off),
-      cruiseControl=SimpleNamespace(cancel=False, resume=False),
-      leftBlinker=False,
-      rightBlinker=False,
-      hudControl=SimpleNamespace(),
-    )
-    cs = SimpleNamespace(
-      stock_lfa_msg={},
-      stock_lkas_msg={},
-      out=SimpleNamespace(
-        standstill=True,
-        steeringAngleDeg=0.0,
-        gearShifter=structs.CarState.GearShifter.park,
-      ),
+    packer = CANPacker(DBC[CP.carFingerprint][Bus.pt])
+    can_bus = CanBus(CP)
+    msgs = hyundaicanfd.create_steering_messages(
+      packer, CP, can_bus, True, False, 0.0, 0.0, send_lfa_status=True, lfa_only=True,
    )

-    msgs = controller.create_canfd_msgs(0, False, 0.0, 0.0, 0.0, 0.0, False,
-                                        cc.hudControl, cs, cc, get_test_toggles(), lka_icon=1, lfa_icon=1)
-
-    assert not [msg for msg in msgs if msg[0] in (0x110, 0x12A)]
+    assert [(packer.dbc.addr_to_msg[addr].name, bus) for addr, _, bus in msgs] == [
+      ("LFA", can_bus.ECAN),
+    ]

  def test_kia_ev6_lkas_helper_preserves_stock_camera_fields_with_stock_long(self):
    CP = CarParams.new_message()
@@ -111,7 +111,6 @@ class HyundaiSafetyFlags(IntFlag):


 class HyundaiStarPilotSafetyFlags(IntFlag):
-  AOL_MAIN_LKAS_SYNC = 32
  HAS_LDA_BUTTON = 1024
  AOL_LKAS_ON_ENGAGE = 2048

@@ -975,7 +974,6 @@ CAN_CANFD_BLENDED_HDA2_LONGITUDINAL_CAR = frozenset({
 KIA_EV6_GT_LINE_LONG_TUNING_VDS_PREFIXES = frozenset({
  "C4DLC",
 })
-KIA_EV6_GT_LINE_LONG_TUNING_TESTING_GROUND_ID = "5"


 ALT_BUS_LDA_BUTTON_CARS = frozenset()
@@ -986,9 +984,9 @@ def hyundai_cancel_button_enables_cruise(car_fingerprint) -> bool:
  return car_fingerprint in CANCEL_BUTTON_ENABLE_CARS


-def kia_ev6_gt_line_longitudinal_tuning(car_fingerprint, vin: str, testing_ground_active: bool = False) -> bool:
-  vin_match = isinstance(vin, str) and len(vin) == 17 and vin[3:8] in KIA_EV6_GT_LINE_LONG_TUNING_VDS_PREFIXES
-  return car_fingerprint == CAR.KIA_EV6 and (vin_match or testing_ground_active)
+def kia_ev6_gt_line_longitudinal_tuning(car_fingerprint, vin: str) -> bool:
+  return car_fingerprint == CAR.KIA_EV6 and isinstance(vin, str) and \
+    len(vin) == 17 and vin[3:8] in KIA_EV6_GT_LINE_LONG_TUNING_VDS_PREFIXES


 def get_platform_codes(fw_versions: list[bytes]) -> set[tuple[bytes, bytes | None]]:
@@ -1183,7 +1181,6 @@ CANFD_SECURITYACCESS_CAR = {
 }
 CANFD_UNSUPPORTED_LONGITUDINAL_CAR = CAR.with_flags(HyundaiFlags.CANFD_NO_RADAR_DISABLE) - CANFD_SECURITYACCESS_CAR  # TODO: merge with UNSUPPORTED_LONGITUDINAL_CAR
 CANFD_ANGLE_LONGITUDINAL_CAR = {CAR.KIA_EV9, CAR.HYUNDAI_IONIQ_5_PE}
-CANFD_ALT_BUTTONS_RESUME_CAR = {CAR.KIA_CARNIVAL_2025, CAR.KIA_CARNIVAL_HEV_4TH_GEN}
 CANFD_CORNER_RADAR_BSM_CAR = {CAR.HYUNDAI_IONIQ_6, CAR.HYUNDAI_IONIQ_5_PE, CAR.KIA_EV9}
 CANFD_RADAR_LIVE_LONGITUDINAL_CAR = {
  CAR.HYUNDAI_IONIQ_5, CAR.HYUNDAI_IONIQ_5_PE, CAR.HYUNDAI_IONIQ_6, CAR.KIA_EV6, CAR.KIA_EV9, CAR.GENESIS_GV60_EV_1ST_GEN,
@@ -1214,9 +1211,6 @@ NON_SCC_CAR = CAR.with_flags(HyundaiFlags.NON_SCC)
 #       HyundaiFlags.CANFD_RADAR_SCC | HyundaiFlags.CANFD_NO_RADAR_DISABLE | )
 UNSUPPORTED_LONGITUDINAL_CAR = CAR.with_flags(HyundaiFlags.LEGACY) | CAR.with_flags(HyundaiFlags.UNSUPPORTED_LONGITUDINAL)

-LEGACY_LONGITUDINAL_CAR = {
-  CAR.GENESIS_G80,
-  CAR.KIA_XCEED_PHEV,
-}
+LEGACY_LONGITUDINAL_CAR = {CAR.KIA_XCEED_PHEV}

 DBC = CAR.create_dbc_map()
@@ -245,13 +245,6 @@ class CarInterfaceBase(ABC):
          fp_ret.pcmCruiseSpeed = False
          CP.openpilotLongitudinalControl = True

-        # These classic Hyundai hybrids need their stock ACC main state tracked while
-        # using OP long. Their cluster/EPS state becomes inconsistent when AOL remains
-        # active after the physical ACC main state changes.
-        if candidate in (HYUNDAI.HYUNDAI_SONATA_HYBRID, HYUNDAI.HYUNDAI_ELANTRA_HEV_2024) and \
-            CP.openpilotLongitudinalControl:
-          fp_ret.flags |= HyundaiStarPilotFlags.MAIN_CRUISE_STATE_TRACKING.value
-
        hyundai_has_lda_button = not (CP.flags & HyundaiFlags.CANFD) and (
          0x391 in fingerprint[0] or
          0x50C in fingerprint[0] or
@@ -268,10 +261,6 @@ class CarInterfaceBase(ABC):
        if params.get_bool("AlwaysOnLateral") and params.get_int("LKASButtonControl") == 9:
          fp_ret.safetyConfigs[-1].safetyParam |= HyundaiStarPilotSafetyFlags.AOL_LKAS_ON_ENGAGE.value

-        if candidate == HYUNDAI.HYUNDAI_SONATA_HYBRID and getattr(starpilot_toggles, "always_on_lateral_lkas", False) and \
-            getattr(starpilot_toggles, "main_cruise_aol_toggle", False):
-          fp_ret.safetyConfigs[-1].safetyParam |= HyundaiStarPilotSafetyFlags.AOL_MAIN_LKAS_SYNC.value
-
      elif platform in TOYOTA:
        fp_ret.canUsePedal = not CP.autoResumeSng
        fp_ret.canUseSDSU = candidate not in UNSUPPORTED_DSU_CAR and candidate not in TSS2_CAR
@@ -15,19 +15,19 @@ LEAF_ADAS_ECU_BUS = 0
 LEAF_ADAS_COMMAND_BUS = 1
 LEAF_ADAS_COMMAND_ADDRS = frozenset((0x1C3, 0x2B0))
 LEAF_2025_SV_PLUS_CAMERA_FW = b'6WK2CDB\x04\x18\x00\x00\x00\x00\x00R=1\x18\x99\x10\x00\x00\x00\x80'
-LEAF_2025_SV_PLUS_ALPHA_LONG_ENABLED = False

-LEAF_KWP_EXTENDED_REQUEST = b"\x10\xC0"
-LEAF_KWP_EXTENDED_RESPONSE = b"\x50\xC0"
-LEAF_KWP_DISABLE_NORMAL_TX_NO_RESPONSE = b"\x28\x02"
+# This Leaf camera uses KWP2000 rather than UDS for session management.
+LEAF_KWP_DATA_MONITOR_REQUEST = b"\x10\xF0"
+LEAF_KWP_DATA_MONITOR_RESPONSE = b"\x50\xF0"
+LEAF_KWP_DISABLE_NORMAL_TX = b"\x28\x01"

 LEAF_KWP_TAKEOVER_SESSIONS = (
-  (LEAF_KWP_EXTENDED_REQUEST, LEAF_KWP_EXTENDED_RESPONSE),
+  (LEAF_KWP_DATA_MONITOR_REQUEST, LEAF_KWP_DATA_MONITOR_RESPONSE),
 )


 def is_leaf_2025_sv_plus_longitudinal(candidate, car_fw):
-  return LEAF_2025_SV_PLUS_ALPHA_LONG_ENABLED and candidate == CAR.NISSAN_LEAF and any(
+  return candidate == CAR.NISSAN_LEAF and any(
    fw.address == LEAF_ADAS_ECU_ADDR and bytes(fw.fwVersion) == LEAF_2025_SV_PLUS_CAMERA_FW
    for fw in car_fw
  )
@@ -161,7 +161,7 @@ class CarInterface(CarInterfaceBase):
    for diag_request, diag_response in LEAF_KWP_TAKEOVER_SESSIONS:
      ecu_log(f"Nissan Leaf ADAS takeover using KWP session {diag_request.hex()}")
      ecu_disabled = disable_ecu(can_recv, can_send, bus=LEAF_ADAS_ECU_BUS, addr=LEAF_ADAS_ECU_ADDR,
-                                 com_cont_req=LEAF_KWP_DISABLE_NORMAL_TX_NO_RESPONSE, require_response=False, retry=1,
+                                 com_cont_req=LEAF_KWP_DISABLE_NORMAL_TX, require_response=True, retry=1,
                                 diag_request=diag_request, diag_response=diag_response, response_offset=NISSAN_RX_OFFSET)
      if ecu_disabled:
        break
@@ -4,7 +4,6 @@ import pytest

 from opendbc.car import Bus, ButtonType, gen_empty_fingerprint, structs
 from opendbc.car.can_definitions import CanData
-from opendbc.car.nissan import interface as nissan_interface
 from opendbc.car.nissan.carstate import CarState
 from opendbc.car.nissan.interface import CarInterface, LEAF_2025_SV_PLUS_CAMERA_FW, leaf_adas_commands_present, \
                                          leaf_adas_commands_silent, restore_leaf_adas_tx
@@ -19,12 +18,6 @@ SUPPORTED_LEAF_FW = [structs.CarParams.CarFw(
 )]


-@pytest.fixture
-def experimental_leaf_long(monkeypatch):
-  """Exercise the dormant implementation without making it available in production."""
-  monkeypatch.setattr(nissan_interface, "LEAF_2025_SV_PLUS_ALPHA_LONG_ENABLED", True)
-
-
 def run_controller(alpha_long, accel=0.0, long_active=True, long_state=structs.CarControl.Actuators.LongControlState.pid):
  CP = CarInterface.get_params(CAR.NISSAN_LEAF, gen_empty_fingerprint(), SUPPORTED_LEAF_FW, alpha_long, False, False, TEST_TOGGLES)
  FPCP = CarInterface.get_starpilot_params(CAR.NISSAN_LEAF, gen_empty_fingerprint(), SUPPORTED_LEAF_FW, CP, TEST_TOGGLES)
@@ -40,28 +33,7 @@ def run_controller(alpha_long, accel=0.0, long_active=True, long_state=structs.C
  return {msg[0]: msg for msg in can_sends}


-def test_leaf_2025_sv_plus_alpha_long_is_disabled(monkeypatch):
-  stock = CarInterface.get_params(CAR.NISSAN_LEAF, gen_empty_fingerprint(), SUPPORTED_LEAF_FW, False, False, False, None)
-  alpha_long = CarInterface.get_params(CAR.NISSAN_LEAF, gen_empty_fingerprint(), SUPPORTED_LEAF_FW, True, False, False, None)
-
-  assert not stock.alphaLongitudinalAvailable
-  assert not stock.openpilotLongitudinalControl
-  assert stock.pcmCruise
-  assert not (stock.safetyConfigs[-1].safetyParam & NissanSafetyFlags.LONG_CONTROL)
-
-  assert not alpha_long.alphaLongitudinalAvailable
-  assert not alpha_long.openpilotLongitudinalControl
-  assert alpha_long.pcmCruise
-  assert not alpha_long.autoResumeSng
-  assert not (alpha_long.safetyConfigs[-1].safetyParam & NissanSafetyFlags.LONG_CONTROL)
-
-  disable_calls = []
-  monkeypatch.setattr("opendbc.car.nissan.interface.disable_ecu", lambda *args, **kwargs: disable_calls.append((args, kwargs)))
-  CarInterface.init(alpha_long, None, None)
-  assert not disable_calls
-
-
-def test_dormant_leaf_2025_sv_plus_alpha_long_params(experimental_leaf_long):
+def test_leaf_2025_sv_plus_alpha_long_params():
  stock = CarInterface.get_params(CAR.NISSAN_LEAF, gen_empty_fingerprint(), SUPPORTED_LEAF_FW, False, False, False, None)
  alpha_long = CarInterface.get_params(CAR.NISSAN_LEAF, gen_empty_fingerprint(), SUPPORTED_LEAF_FW, True, False, False, None)

@@ -107,13 +79,7 @@ def test_stock_controller_does_not_send_longitudinal_messages():
  assert not ({0x2B0, 0x1C3, 0x707} & can_sends.keys())


-def test_disabled_alpha_long_controller_does_not_send_longitudinal_messages():
-  can_sends = run_controller(True)
-
-  assert not ({0x2B0, 0x1C3, 0x707} & can_sends.keys())
-
-
-def test_alpha_long_controller_sends_stock_shaped_commands_and_keepalive(experimental_leaf_long):
+def test_alpha_long_controller_sends_stock_shaped_commands_and_keepalive():
  can_sends = run_controller(True)

  assert can_sends[0x2B0][1].hex() == "ff6090ac5b000e03"
@@ -123,13 +89,13 @@ def test_alpha_long_controller_sends_stock_shaped_commands_and_keepalive(experim
  assert can_sends[0x707][2] == 0


-def test_alpha_long_controller_clamps_to_panda_accel_limit(experimental_leaf_long):
+def test_alpha_long_controller_clamps_to_panda_accel_limit():
  can_sends = run_controller(True, accel=5.0)

  assert can_sends[0x2B0][1].hex() == "007f8fac5b000e0c"


-def test_alpha_long_controller_blends_friction_brake_below_regen_limit(experimental_leaf_long):
+def test_alpha_long_controller_blends_friction_brake_below_regen_limit():
  can_sends = run_controller(True, accel=-2.0)

  assert can_sends[0x2B0][1].hex() == "a827d5ac5b000e09"
@@ -138,7 +104,7 @@ def test_alpha_long_controller_blends_friction_brake_below_regen_limit(experimen
  assert brake[5] & 0x84 == 0x84


-def test_alpha_long_controller_sends_inactive_commands_when_disengaged(experimental_leaf_long):
+def test_alpha_long_controller_sends_inactive_commands_when_disengaged():
  can_sends = run_controller(True, accel=1.0, long_active=False)

  assert can_sends[0x2B0][1].hex() == "dc53a2ac1b000e03"
@@ -147,7 +113,7 @@ def test_alpha_long_controller_sends_inactive_commands_when_disengaged(experimen

@pytest.mark.parametrize(("signal", "button_type"), [("SET_BUTTON", ButtonType.decelCruise),
                                                        ("RES_BUTTON", ButtonType.accelCruise)])
-def test_leaf_set_resume_release_enables_alpha_long(signal, button_type, experimental_leaf_long):
+def test_leaf_set_resume_release_enables_alpha_long(signal, button_type):
  CP = CarInterface.get_params(CAR.NISSAN_LEAF, gen_empty_fingerprint(), SUPPORTED_LEAF_FW, True, False, False, TEST_TOGGLES)
  FPCP = CarInterface.get_starpilot_params(CAR.NISSAN_LEAF, gen_empty_fingerprint(), SUPPORTED_LEAF_FW, CP, TEST_TOGGLES)
  CS = CarState(CP, FPCP)
@@ -164,7 +130,7 @@ def test_leaf_set_resume_release_enables_alpha_long(signal, button_type, experim


@pytest.mark.parametrize("ecu_disabled", [False, True])
-def test_leaf_ecu_disable_is_strict_and_falls_back(monkeypatch, ecu_disabled, experimental_leaf_long):
+def test_leaf_ecu_disable_is_strict_and_falls_back(monkeypatch, ecu_disabled):
  CP = CarInterface.get_params(CAR.NISSAN_LEAF, gen_empty_fingerprint(), SUPPORTED_LEAF_FW, True, False, False, None)
  calls = []

@@ -182,17 +148,17 @@ def test_leaf_ecu_disable_is_strict_and_falls_back(monkeypatch, ecu_disabled, ex
  assert calls[0]["addr"] == 0x707
  assert calls[0]["bus"] == 0
  assert calls[0]["response_offset"] == 0x20
-  assert calls[0]["require_response"] is False
-  assert calls[0]["diag_request"] == b"\x10\xc0"
-  assert calls[0]["diag_response"] == b"\x50\xc0"
-  assert calls[0]["com_cont_req"] == b"\x28\x02"
+  assert calls[0]["require_response"] is True
+  assert calls[0]["diag_request"] == b"\x10\xf0"
+  assert calls[0]["diag_response"] == b"\x50\xf0"
+  assert calls[0]["com_cont_req"] == b"\x28\x01"
  assert calls[0]["retry"] == 1
  assert CP.openpilotLongitudinalControl is ecu_disabled
  assert CP.pcmCruise is not ecu_disabled
  assert bool(CP.safetyConfigs[-1].safetyParam & NissanSafetyFlags.LONG_CONTROL) is ecu_disabled


-def test_leaf_kwp_no_response_disable_can_confirm_ecu_silence(monkeypatch, experimental_leaf_long):
+def test_leaf_kwp_data_monitor_session_can_confirm_ecu_disable(monkeypatch):
  CP = CarInterface.get_params(CAR.NISSAN_LEAF, gen_empty_fingerprint(), SUPPORTED_LEAF_FW, True, False, False, None)

  monkeypatch.setattr("opendbc.car.nissan.interface.disable_ecu", lambda *args, **kwargs: True)
@@ -205,7 +171,7 @@ def test_leaf_kwp_no_response_disable_can_confirm_ecu_silence(monkeypatch, exper
  assert CP.safetyConfigs[-1].safetyParam & NissanSafetyFlags.LONG_CONTROL


-def test_leaf_positive_disable_response_without_command_silence_falls_back(monkeypatch, experimental_leaf_long):
+def test_leaf_positive_disable_response_without_command_silence_falls_back(monkeypatch):
  CP = CarInterface.get_params(CAR.NISSAN_LEAF, gen_empty_fingerprint(), SUPPORTED_LEAF_FW, True, False, False, None)
  restore_calls = []

@@ -22,14 +22,14 @@ _LEGACY_2025_REENGAGE_MAX_STEER_RATE = 2.0
 _LEGACY_2025_REENGAGE_MAX_ANGLE_DELTA = 1.0
 _LEGACY_2025_RECLAIM_FRAMES = 36
 _LEGACY_2025_RECLAIM_EXPONENT = 2.5
-_ANGLE_OVERRIDE_HOLD_FRAMES = 10
-_ANGLE_REENGAGE_SETTLE_FRAMES = 8
-_ANGLE_REENGAGE_MAX_STEER_RATE = 2.0
-_ANGLE_REENGAGE_MAX_ANGLE_DELTA = 1.0
-_ANGLE_RECLAIM_FRAMES = 36
-_ANGLE_RECLAIM_EXPONENT = 2.5
-_ANGLE_MADS_MIN_SPEED = 0.44704
-_ANGLE_MADS_MAX_STEER_ANGLE = 120.0
+_ASCENT_OVERRIDE_HOLD_FRAMES = 10
+_ASCENT_REENGAGE_SETTLE_FRAMES = 8
+_ASCENT_REENGAGE_MAX_STEER_RATE = 2.0
+_ASCENT_REENGAGE_MAX_ANGLE_DELTA = 1.0
+_ASCENT_RECLAIM_FRAMES = 36
+_ASCENT_RECLAIM_EXPONENT = 2.5
+_ASCENT_MADS_MIN_SPEED = 0.44704
+_ASCENT_MADS_MAX_STEER_ANGLE = 120.0


 def get_safety_CP():
@@ -50,13 +50,13 @@ class CarController(CarControllerBase):
    self.legacy_2025_reengage_reference_angle = 0.0
    self.legacy_2025_reclaim_frames = 0
    self.legacy_2025_reclaim_start_angle = 0.0
-    self.angle_lkas_active = False
-    self.angle_handoff_active = False
-    self.angle_override_hold_frames = 0
-    self.angle_reengage_settle_frames = 0
-    self.angle_reengage_reference_angle = 0.0
-    self.angle_reclaim_frames = 0
-    self.angle_reclaim_start_angle = 0.0
+    self.ascent_lkas_active = False
+    self.ascent_handoff_active = False
+    self.ascent_override_hold_frames = 0
+    self.ascent_reengage_settle_frames = 0
+    self.ascent_reengage_reference_angle = 0.0
+    self.ascent_reclaim_frames = 0
+    self.ascent_reclaim_start_angle = 0.0

    self.cruise_button_prev = 0
    self.steer_rate_counter = 0
@@ -137,67 +137,67 @@ class CarController(CarControllerBase):
    self.legacy_2025_reclaim_frames -= 1
    return target_angle

-  def _reset_angle_handoff(self):
-    self.angle_handoff_active = False
-    self.angle_override_hold_frames = 0
-    self.angle_reengage_settle_frames = 0
-    self.angle_reengage_reference_angle = 0.0
-    self.angle_reclaim_frames = 0
-    self.angle_reclaim_start_angle = 0.0
+  def _reset_ascent_handoff(self):
+    self.ascent_handoff_active = False
+    self.ascent_override_hold_frames = 0
+    self.ascent_reengage_settle_frames = 0
+    self.ascent_reengage_reference_angle = 0.0
+    self.ascent_reclaim_frames = 0
+    self.ascent_reclaim_start_angle = 0.0

-  def _angle_manual_handoff(self, CS, lat_active):
+  def _ascent_manual_handoff(self, CS, lat_active):
    if not lat_active:
-      self._reset_angle_handoff()
+      self._reset_ascent_handoff()
      return False

    if CS.out.steeringPressed:
-      self.angle_handoff_active = True
-      self.angle_override_hold_frames = _ANGLE_OVERRIDE_HOLD_FRAMES
-      self.angle_reengage_settle_frames = 0
-      self.angle_reengage_reference_angle = CS.out.steeringAngleDeg
-      self.angle_reclaim_frames = 0
+      self.ascent_handoff_active = True
+      self.ascent_override_hold_frames = _ASCENT_OVERRIDE_HOLD_FRAMES
+      self.ascent_reengage_settle_frames = 0
+      self.ascent_reengage_reference_angle = CS.out.steeringAngleDeg
+      self.ascent_reclaim_frames = 0
      return True

-    if not self.angle_handoff_active and not self.angle_lkas_active and \
-       abs(CS.out.steeringRateDeg) > _ANGLE_REENGAGE_MAX_STEER_RATE:
-      self.angle_handoff_active = True
-      self.angle_reengage_reference_angle = CS.out.steeringAngleDeg
+    if not self.ascent_handoff_active and not self.ascent_lkas_active and \
+       abs(CS.out.steeringRateDeg) > _ASCENT_REENGAGE_MAX_STEER_RATE:
+      self.ascent_handoff_active = True
+      self.ascent_reengage_reference_angle = CS.out.steeringAngleDeg

-    if not self.angle_handoff_active:
+    if not self.ascent_handoff_active:
      return False

-    if self.angle_override_hold_frames > 0:
-      self.angle_override_hold_frames -= 1
-      if self.angle_override_hold_frames == 0:
-        self.angle_reengage_reference_angle = CS.out.steeringAngleDeg
+    if self.ascent_override_hold_frames > 0:
+      self.ascent_override_hold_frames -= 1
+      if self.ascent_override_hold_frames == 0:
+        self.ascent_reengage_reference_angle = CS.out.steeringAngleDeg
      return True

-    wheel_stable = abs(CS.out.steeringRateDeg) <= _ANGLE_REENGAGE_MAX_STEER_RATE and \
-      abs(CS.out.steeringAngleDeg - self.angle_reengage_reference_angle) <= _ANGLE_REENGAGE_MAX_ANGLE_DELTA
+    wheel_stable = abs(CS.out.steeringRateDeg) <= _ASCENT_REENGAGE_MAX_STEER_RATE and \
+      abs(CS.out.steeringAngleDeg - self.ascent_reengage_reference_angle) <= _ASCENT_REENGAGE_MAX_ANGLE_DELTA
    if wheel_stable:
-      self.angle_reengage_settle_frames += 1
+      self.ascent_reengage_settle_frames += 1
    else:
-      self.angle_reengage_settle_frames = 0
-      self.angle_reengage_reference_angle = CS.out.steeringAngleDeg
+      self.ascent_reengage_settle_frames = 0
+      self.ascent_reengage_reference_angle = CS.out.steeringAngleDeg

-    if self.angle_reengage_settle_frames < _ANGLE_REENGAGE_SETTLE_FRAMES:
+    if self.ascent_reengage_settle_frames < _ASCENT_REENGAGE_SETTLE_FRAMES:
      return True

-    self.angle_handoff_active = False
-    self.angle_reengage_settle_frames = 0
-    self.angle_reclaim_frames = _ANGLE_RECLAIM_FRAMES
-    self.angle_reclaim_start_angle = CS.out.steeringAngleDeg
+    self.ascent_handoff_active = False
+    self.ascent_reengage_settle_frames = 0
+    self.ascent_reclaim_frames = _ASCENT_RECLAIM_FRAMES
+    self.ascent_reclaim_start_angle = CS.out.steeringAngleDeg
    return True

-  def _angle_reclaim_target(self, target_angle):
-    if self.angle_reclaim_frames <= 0:
+  def _ascent_reclaim_target(self, target_angle):
+    if self.ascent_reclaim_frames <= 0:
      return target_angle

-    progress = (_ANGLE_RECLAIM_FRAMES - self.angle_reclaim_frames + 1) / _ANGLE_RECLAIM_FRAMES
-    eased_progress = progress ** _ANGLE_RECLAIM_EXPONENT
-    target_angle = self.angle_reclaim_start_angle + eased_progress * \
-      (target_angle - self.angle_reclaim_start_angle)
-    self.angle_reclaim_frames -= 1
+    progress = (_ASCENT_RECLAIM_FRAMES - self.ascent_reclaim_frames + 1) / _ASCENT_RECLAIM_FRAMES
+    eased_progress = progress ** _ASCENT_RECLAIM_EXPONENT
+    target_angle = self.ascent_reclaim_start_angle + eased_progress * \
+      (target_angle - self.ascent_reclaim_start_angle)
+    self.ascent_reclaim_frames -= 1
    return target_angle

  def lateral_angle(self, CC, CS):
@@ -224,41 +224,30 @@ class CarController(CarControllerBase):
      self.legacy_2025_lkas_active = lkas_active
      return subarucan.create_steering_control_angle(self.packer, apply_steer, lkas_active, self.angle_bus)

-    if self.CP.carFingerprint in (CAR.SUBARU_ASCENT_2023, CAR.SUBARU_OUTBACK_2023):
+    if self.CP.carFingerprint == CAR.SUBARU_ASCENT_2023:
      mads_only = CC.latActive and not CC.enabled
-      mads_only_ok = CS.out.vEgoRaw > _ANGLE_MADS_MIN_SPEED and \
-        abs(CS.out.steeringAngleDeg) < _ANGLE_MADS_MAX_STEER_ANGLE
+      mads_only_ok = CS.out.vEgoRaw > _ASCENT_MADS_MIN_SPEED and \
+        abs(CS.out.steeringAngleDeg) < _ASCENT_MADS_MAX_STEER_ANGLE
      lkas_available = CC.latActive and (not mads_only or mads_only_ok) and \
        CS.out.gearShifter == structs.CarState.GearShifter.drive and not CS.out.standstill

-      manual_handoff = self._angle_manual_handoff(CS, lkas_available)
+      manual_handoff = self._ascent_manual_handoff(CS, lkas_available)
      lkas_active = lkas_available and not manual_handoff

-      if lkas_active and not self.angle_lkas_active:
+      if lkas_active and not self.ascent_lkas_active:
        self.apply_steer_last = CS.out.steeringAngleDeg

-      steer_target = self._angle_reclaim_target(CC.actuators.steeringAngleDeg) if lkas_active else CC.actuators.steeringAngleDeg
-      if self.CP.carFingerprint == CAR.SUBARU_ASCENT_2023:
-        apply_steer = apply_std_steer_angle_limits(
-          steer_target,
-          self.apply_steer_last,
-          CS.out.vEgoRaw,
-          CS.out.steeringAngleDeg,
-          lkas_active,
-          self.p.FIXED_ANGLE_LIMITS,
-        )
-      else:
-        apply_steer = apply_steer_angle_limits_vm(
-          steer_target,
-          self.apply_steer_last,
-          CS.out.vEgoRaw,
-          CS.out.steeringAngleDeg,
-          lkas_active,
-          self.p,
-          self.VM,
-        )
+      steer_target = self._ascent_reclaim_target(CC.actuators.steeringAngleDeg) if lkas_active else CC.actuators.steeringAngleDeg
+      apply_steer = apply_std_steer_angle_limits(
+        steer_target,
+        self.apply_steer_last,
+        CS.out.vEgoRaw,
+        CS.out.steeringAngleDeg,
+        lkas_active,
+        self.p.FIXED_ANGLE_LIMITS,
+      )
      self.apply_steer_last = apply_steer
-      self.angle_lkas_active = lkas_active
+      self.ascent_lkas_active = lkas_active
      return subarucan.create_steering_control_angle(self.packer, apply_steer, lkas_active, self.angle_bus)

    abs_torque = abs(CS.out.steeringTorque)
@@ -51,8 +51,6 @@ class CarInterface(CarInterfaceBase):

    if ret.flags & SubaruFlags.LKAS_ANGLE:
      ret.steerControlType = structs.CarParams.SteerControlType.angle
-      if candidate == CAR.SUBARU_OUTBACK_2023:
-        ret.lateralSmoothSeconds = 0.4

    elif candidate in (CAR.SUBARU_ASCENT, CAR.SUBARU_ASCENT_2023):
      ret.steerActuatorDelay = 0.3  # end-to-end angle controller
@@ -202,7 +202,6 @@ def test_outback_2023_uses_d_platform_bus_layout():
  assert parsers[Bus.main].bus == CanBus.main
  assert controller.angle_bus == CanBus.main
  assert controller.status_bus == CanBus.main
-  assert CP.lateralSmoothSeconds == pytest.approx(0.4)


 def test_legacy_2025_uses_gen2_angle_bus_layout():
@@ -429,24 +428,14 @@ def test_angle_controller_tracks_driver_override():
  CP = CarInterface.get_non_essential_params(CAR.SUBARU_CROSSTREK_2025)
  controller = CarController({}, CP)
  CC = SimpleNamespace(latActive=True, actuators=SimpleNamespace(steeringAngleDeg=15.0))
-  CS = SimpleNamespace(out=SimpleNamespace(vEgoRaw=15.0, steeringAngleDeg=2.0, steeringTorque=175.0))
+  CS = SimpleNamespace(out=SimpleNamespace(vEgoRaw=15.0, steeringAngleDeg=2.0, steeringTorque=250.0))

  msg = controller.lateral_angle(CC, CS)

  assert controller.driver_override
-  assert controller.p.STEER_OVERRIDE_TORQUE_HIGH == 150
-  assert controller.p.STEER_OVERRIDE_TORQUE_LOW == 100
  assert controller.apply_steer_last == CS.out.steeringAngleDeg
  assert msg[0] == 0x124

-  CS.out.steeringTorque = 125.0
-  controller.lateral_angle(CC, CS)
-  assert controller.driver_override
-
-  CS.out.steeringTorque = 75.0
-  controller.lateral_angle(CC, CS)
-  assert not controller.driver_override
-

 def test_ascent_angle_controller_uses_fixed_angle_rate_limits():
  CP = CarInterface.get_non_essential_params(CAR.SUBARU_ASCENT_2023)
@@ -469,9 +458,8 @@ def test_ascent_angle_controller_uses_fixed_angle_rate_limits():
  assert CS.out.steeringAngleDeg < parser.vl["ES_LKAS_ANGLE"]["LKAS_Output"] < -25.0


-@pytest.mark.parametrize("platform", (CAR.SUBARU_ASCENT_2023, CAR.SUBARU_OUTBACK_2023))
-def test_angle_controller_yields_until_manual_steering_settles(platform):
-  CP = CarInterface.get_non_essential_params(platform)
+def test_ascent_angle_controller_yields_until_manual_steering_settles():
+  CP = CarInterface.get_non_essential_params(CAR.SUBARU_ASCENT_2023)
  controller = CarController({}, CP)
  CC = SimpleNamespace(enabled=True, latActive=True, actuators=SimpleNamespace(steeringAngleDeg=-10.0))
  CS = SimpleNamespace(out=SimpleNamespace(
@@ -37,11 +37,6 @@ class CarControllerParams:
    self.STEER_OVERRIDE_TORQUE_HIGH = 200
    self.STEER_OVERRIDE_TORQUE_LOW = 150

-    # Crosstrek 2025 reports manual parking-lot inputs below the generic handoff threshold.
-    if CP.carFingerprint == CAR.SUBARU_CROSSTREK_2025:
-      self.STEER_OVERRIDE_TORQUE_HIGH = 150
-      self.STEER_OVERRIDE_TORQUE_LOW = 100
-
    if CP.flags & SubaruFlags.GLOBAL_GEN2:
      # TODO: lower rate limits, this reaches min/max in 0.5s which negatively affects tuning
      self.STEER_MAX = 1500
@@ -74,6 +74,7 @@ def get_test_starpilot_toggles() -> SimpleNamespace:
    disable_openpilot_long=False,
    force_fingerprint=False,
    lock_doors=False,
+    reverse_cruise_increase=False,
    sng_hack=False,
    subaru_sng=False,
    subaru_sng_manual_parking_brake=False,
@@ -164,18 +165,13 @@ class TestCarInterfaces:
      "Center_Stack_2": {"LKAS_Button": 1},
    }, is_ram=True)

-  @pytest.mark.parametrize("candidate", (
-    CHRYSLER_CAR.CHRYSLER_PACIFICA_2020,
-    CHRYSLER_CAR.JEEP_GRAND_CHEROKEE,
-    CHRYSLER_CAR.JEEP_GRAND_CHEROKEE_2019,
-  ))
-  def test_chrysler_steer_to_zero_module(self, candidate):
+  def test_chrysler_wd_mod_enables_steer_to_zero(self):
    fingerprint = {bus: {} for bus in range(8)}
    fingerprint[0][0x4FF] = 8
    toggles = get_test_starpilot_toggles()

    car_params = ChryslerCarInterface.get_params(
-      candidate,
+      CHRYSLER_CAR.CHRYSLER_PACIFICA_2020,
      fingerprint,
      [],
      alpha_long=False,
@@ -186,7 +182,7 @@ class TestCarInterfaces:
    assert car_params.minSteerSpeed > 0.

    fp_car_params = ChryslerCarInterface.get_starpilot_params(
-      candidate,
+      CHRYSLER_CAR.CHRYSLER_PACIFICA_2020,
      fingerprint,
      [],
      car_params,
@@ -210,14 +206,11 @@ class TestCarInterfaces:
      button_message="CRUISE_BUTTONS",
      auto_high_beam=0,
    )
-    controller.update(CC, CS, 0, toggles)
-    controller.update(CC, CS, 0, toggles)
    _, can_sends = controller.update(CC, CS, 0, toggles)

    lkas_parser = CANParser(CHRYSLER_DBC[car_params.carFingerprint][Bus.pt], [("LKAS_COMMAND", 50)], 0)
    lkas_parser.update([0, can_sends])
    assert lkas_parser.vl["LKAS_COMMAND"]["LKAS_CONTROL_BIT"] == 1
-    assert lkas_parser.vl["LKAS_COMMAND"]["STEERING_TORQUE"] != 0

  @pytest.mark.parametrize("candidate", (CHRYSLER_CAR.JEEP_GRAND_CHEROKEE, CHRYSLER_CAR.JEEP_GRAND_CHEROKEE_2019))
  def test_jeep_brake_hold_safety_capability_is_provisioned(self, candidate):
@@ -437,11 +437,6 @@ static safety_config ford_init(uint16_t param) {
    {FORD_LateralMotionControl2, 0, 8, .check_relay = true},
  };

-  static const CanMsg FORD_STOCK_TX_MSGS[] = {
-    FORD_COMMON_TX_MSGS
-    {FORD_LateralMotionControl, 0, 8, .check_relay = true},
-  };
-
  static const CanMsg FORD_LONG_TX_MSGS[] = {
    FORD_COMMON_TX_MSGS
    {FORD_ACCDATA, 0, 8, .check_relay = true},
@@ -464,13 +459,15 @@ static safety_config ford_init(uint16_t param) {
  ford_longitudinal = GET_FLAG(param, FORD_PARAM_LONGITUDINAL);
 #endif

+  // Longitudinal is the default for CAN, and optional for CAN FD w/ ALLOW_DEBUG
+  ford_longitudinal = !ford_canfd || ford_longitudinal;
+
  safety_config ret;
  if (ford_canfd) {
    ret = ford_longitudinal ? BUILD_SAFETY_CFG(ford_rx_checks, FORD_CANFD_LONG_TX_MSGS) : \
                              BUILD_SAFETY_CFG(ford_rx_checks, FORD_CANFD_STOCK_TX_MSGS);
  } else {
-    ret = ford_longitudinal ? BUILD_SAFETY_CFG(ford_rx_checks, FORD_LONG_TX_MSGS) : \
-                              BUILD_SAFETY_CFG(ford_rx_checks, FORD_STOCK_TX_MSGS);
+    ret = BUILD_SAFETY_CFG(ford_rx_checks, FORD_LONG_TX_MSGS);
  }
  return ret;
 }
@@ -90,7 +90,6 @@ static const CanMsg HYUNDAI_LONG_REFRESH_TX_MSGS[] = {

 static bool hyundai_legacy = false;
 static bool hyundai_can_canfd_blended_hda2 = false;
-static bool hyundai_acc_main_on_rx_prev = false;

 #define HYUNDAI_CAN_CANFD_BLENDED_HDA2_COMMON_RX_CHECKS()                                                                                                      \
  {.msg = {{0x260, 1, 8, 100U, .max_counter = 3U, .ignore_quality_flag = true},                                                                                \
@@ -194,12 +193,7 @@ static void hyundai_rx_hook(const CANPacket_t *msg) {
  if (msg->addr == 0x420U) {
    if (msg->bus == scc_bus) {
      if (!hyundai_longitudinal) {
-        const bool acc_main_on_rx = GET_BIT(msg, hyundai_can_canfd_blended ? 27U : 0U);
-        if (hyundai_aol_main_lkas_sync && (acc_main_on_rx != hyundai_acc_main_on_rx_prev)) {
-          lkas_on = false;
-        }
-        acc_main_on = acc_main_on_rx;
-        hyundai_acc_main_on_rx_prev = acc_main_on_rx;
+        acc_main_on = GET_BIT(msg, hyundai_can_canfd_blended ? 27U : 0U);
      }
    }
  }
@@ -448,8 +442,6 @@ static safety_config hyundai_init(uint16_t param) {
  hyundai_common_init(param);
  hyundai_legacy = false;
  hyundai_can_canfd_blended_hda2 = hyundai_can_canfd_blended && hyundai_canfd_lka_steering;
-  hyundai_aol_main_lkas_sync = GET_FLAG(param, 32U);
-  hyundai_acc_main_on_rx_prev = false;

  if (hyundai_can_canfd_blended) {
    gen_crc_lookup_table_16(0x1021, hyundai_canfd_crc_lut);
@@ -6,9 +6,6 @@
 #define HYUNDAI_CANFD_CRUISE_BUTTON_TX_MSGS(bus) \
  {0x1CF, bus, 8, .check_relay = false},  /* CRUISE_BUTTON */   \

-#define HYUNDAI_CANFD_ALT_CRUISE_BUTTON_TX_MSGS(bus) \
-  {0x1AA, bus, 16, .check_relay = false},  /* CRUISE_BUTTONS_ALT */ \
-
 #define HYUNDAI_CANFD_LKA_STEERING_COMMON_TX_MSGS(a_can, e_can) \
  HYUNDAI_CANFD_CRUISE_BUTTON_TX_MSGS(e_can)                        \
  {0x50,  a_can, 16, .check_relay = (a_can) == 0},  /* LKAS */      \
@@ -294,8 +291,8 @@ static bool hyundai_canfd_tx_hook(const CANPacket_t *msg) {
  }

  // cruise buttons check
-  if ((msg->addr == 0x1cfU) || (hyundai_canfd_alt_buttons && (msg->addr == 0x1aaU))) {
-    int button = (msg->addr == 0x1aaU) ? ((msg->data[4] >> 4U) & 0x7U) : (msg->data[2] & 0x7U);
+  if (msg->addr == 0x1cfU) {
+    int button = msg->data[2] & 0x7U;
    bool is_cancel = (button == HYUNDAI_BTN_CANCEL);
    bool is_resume = (button == HYUNDAI_BTN_RESUME);
    bool is_set = (button == HYUNDAI_BTN_SET);
@@ -430,6 +427,11 @@ static safety_config hyundai_canfd_init(uint16_t param) {
    {0x1DA, 1, 32, .check_relay = false},  // ADRV_0x1da
  };

+  static const CanMsg HYUNDAI_CANFD_CCNC_ANGLE_FALLBACK_TX_MSGS[] = {
+    HYUNDAI_CANFD_LKA_STEERING_ALT_COMMON_TX_MSGS(0, 1)
+    {0x12A, 1, 16, .check_relay = false},  // LFA status
+  };
+
  static const CanMsg HYUNDAI_CANFD_LFA_STEERING_TX_MSGS[] = {
    HYUNDAI_CANFD_CRUISE_BUTTON_TX_MSGS(2)
    HYUNDAI_CANFD_LFA_STEERING_COMMON_TX_MSGS(0)
@@ -453,12 +455,6 @@ static safety_config hyundai_canfd_init(uint16_t param) {
    HYUNDAI_CANFD_SCC_CONTROL_COMMON_TX_MSGS(0, (longitudinal)) \
    {0x160, 0, 16, .check_relay = (longitudinal)}, /* ADRV_0x160 */ \

-#define HYUNDAI_CANFD_LFA_STEERING_CAMERA_SCC_ALT_BUTTONS_TX_MSGS(longitudinal) \
-    HYUNDAI_CANFD_ALT_CRUISE_BUTTON_TX_MSGS(2) \
-    HYUNDAI_CANFD_LFA_STEERING_COMMON_TX_MSGS(0) \
-    HYUNDAI_CANFD_SCC_CONTROL_COMMON_TX_MSGS(0, (longitudinal)) \
-    {0x160, 0, 16, .check_relay = (longitudinal)}, /* ADRV_0x160 */ \
-
 #define HYUNDAI_CANFD_LFA_STEERING_CAMERA_SCC_CCNC_TX_MSGS(longitudinal) \
    HYUNDAI_CANFD_CRUISE_BUTTON_TX_MSGS(2) \
    HYUNDAI_CANFD_LFA_STEERING_COMMON_TX_MSGS(0) \
@@ -468,15 +464,6 @@ static safety_config hyundai_canfd_init(uint16_t param) {
    {0x7C4, 2, 8, .check_relay = true},  /* camera support frame */ \
    {0xEA, 2, 24, .check_relay = true},  /* MDPS support frame */ \

-#define HYUNDAI_CANFD_LFA_STEERING_CAMERA_SCC_CCNC_ALT_BUTTONS_TX_MSGS(longitudinal) \
-    HYUNDAI_CANFD_ALT_CRUISE_BUTTON_TX_MSGS(2) \
-    HYUNDAI_CANFD_LFA_STEERING_COMMON_TX_MSGS(0) \
-    HYUNDAI_CANFD_SCC_CONTROL_COMMON_TX_MSGS(0, (longitudinal)) \
-    {0x161, 0, 32, .check_relay = true}, /* CCNC_0x161 */ \
-    {0x162, 0, 32, .check_relay = true}, /* CCNC_0x162 */ \
-    {0x7C4, 2, 8, .check_relay = true},  /* camera support frame */ \
-    {0xEA, 2, 24, .check_relay = true},  /* MDPS support frame */ \
-
  hyundai_common_init(param);

  gen_crc_lookup_table_16(0x1021, hyundai_canfd_crc_lut);
@@ -540,19 +527,7 @@ static safety_config hyundai_canfd_init(uint16_t param) {

      if (hyundai_camera_scc) {
        if (hyundai_ccnc) {
-          if (hyundai_canfd_alt_buttons) {
-            static CanMsg hyundai_canfd_lfa_steering_camera_scc_ccnc_alt_buttons_tx_msgs[] = {
-              HYUNDAI_CANFD_LFA_STEERING_CAMERA_SCC_CCNC_ALT_BUTTONS_TX_MSGS(true)
-            };
-            SET_TX_MSGS(hyundai_canfd_lfa_steering_camera_scc_ccnc_alt_buttons_tx_msgs, ret);
-          } else {
-            SET_TX_MSGS(hyundai_canfd_lfa_steering_camera_scc_ccnc_tx_msgs, ret);
-          }
-        } else if (hyundai_canfd_alt_buttons) {
-          static CanMsg hyundai_canfd_lfa_steering_camera_scc_alt_buttons_tx_msgs[] = {
-            HYUNDAI_CANFD_LFA_STEERING_CAMERA_SCC_ALT_BUTTONS_TX_MSGS(true)
-          };
-          SET_TX_MSGS(hyundai_canfd_lfa_steering_camera_scc_alt_buttons_tx_msgs, ret);
+          SET_TX_MSGS(hyundai_canfd_lfa_steering_camera_scc_ccnc_tx_msgs, ret);
        } else {
          SET_TX_MSGS(hyundai_canfd_lfa_steering_camera_scc_tx_msgs, ret);
        }
@@ -580,7 +555,9 @@ static safety_config hyundai_canfd_init(uint16_t param) {
      } else {
        SET_RX_CHECKS(hyundai_canfd_lka_steering_rx_checks, ret);
      }
-      if (hyundai_canfd_lka_steering_alt) {
+      if (hyundai_ccnc && hyundai_canfd_angle_steering && hyundai_canfd_lka_steering_alt) {
+        SET_TX_MSGS(HYUNDAI_CANFD_CCNC_ANGLE_FALLBACK_TX_MSGS, ret);
+      } else if (hyundai_canfd_lka_steering_alt) {
        if (hyundai_canfd_alt_buttons) {
          SET_TX_MSGS(HYUNDAI_CANFD_LKA_STEERING_ALT_ALT_BUTTONS_TX_MSGS, ret);
        } else {
@@ -636,22 +613,8 @@ static safety_config hyundai_canfd_init(uint16_t param) {
        HYUNDAI_CANFD_LFA_STEERING_CAMERA_SCC_CCNC_TX_MSGS(false)
      };

-      static CanMsg hyundai_canfd_lfa_steering_camera_scc_alt_buttons_tx_msgs[] = {
-        HYUNDAI_CANFD_LFA_STEERING_CAMERA_SCC_ALT_BUTTONS_TX_MSGS(false)
-      };
-
-      static CanMsg hyundai_canfd_lfa_steering_camera_scc_ccnc_alt_buttons_tx_msgs[] = {
-        HYUNDAI_CANFD_LFA_STEERING_CAMERA_SCC_CCNC_ALT_BUTTONS_TX_MSGS(false)
-      };
-
      if (hyundai_ccnc) {
-        if (hyundai_canfd_alt_buttons) {
-          SET_TX_MSGS(hyundai_canfd_lfa_steering_camera_scc_ccnc_alt_buttons_tx_msgs, ret);
-        } else {
-          SET_TX_MSGS(hyundai_canfd_lfa_steering_camera_scc_ccnc_tx_msgs, ret);
-        }
-      } else if (hyundai_canfd_alt_buttons) {
-        SET_TX_MSGS(hyundai_canfd_lfa_steering_camera_scc_alt_buttons_tx_msgs, ret);
+        SET_TX_MSGS(hyundai_canfd_lfa_steering_camera_scc_ccnc_tx_msgs, ret);
      } else {
        SET_TX_MSGS(hyundai_canfd_lfa_steering_camera_scc_tx_msgs, ret);
      }
@@ -60,9 +60,6 @@ bool hyundai_cancel_button_enable = false;
 extern bool hyundai_can_refresh_msgs;
 bool hyundai_can_refresh_msgs = false;

-extern bool hyundai_aol_main_lkas_sync;
-bool hyundai_aol_main_lkas_sync = false;
-
 static uint8_t hyundai_last_button_interaction;  // button messages since the user pressed an enable button
 static bool acc_main_on_prev;
 static bool acc_main_on_tx;
@@ -98,7 +95,6 @@ void hyundai_common_init(uint16_t param) {
  hyundai_non_scc = GET_FLAG(param, HYUNDAI_PARAM_NON_SCC);
  hyundai_cancel_button_enable = GET_FLAG(param, HYUNDAI_PARAM_CANCEL_BTN_ENABLE);
  hyundai_can_refresh_msgs = GET_FLAG(param, HYUNDAI_PARAM_CAN_REFRESH_MSGS);
-  hyundai_aol_main_lkas_sync = false;

  hyundai_last_button_interaction = HYUNDAI_PREV_BUTTON_SAMPLES;
  acc_main_on_prev = false;
@@ -164,9 +160,7 @@ void hyundai_common_cruise_buttons_check(const int cruise_button, const bool mai
  }

  if (main_button && !main_button_prev) {
-    if (!hyundai_aol_main_lkas_sync) {
-      acc_main_on = !acc_main_on;
-    }
+    acc_main_on = !acc_main_on;
  }
  main_button_prev = main_button;
 }
@@ -1103,7 +1103,6 @@ class SafetyTest(SafetyTestBase):
                                              'TestHyundaiSafetyFCEVLong', 'TestHyundaiLongitudinalAolLkasOnEngageSafety',
                                              'TestHyundaiSafetyCanRefreshLong', 'TestHyundaiSafetyCanRefreshLongCameraSCC',
                                              'TestHyundaiCanCanfdBlendedLongitudinalSafety',
-                                              'TestHyundaiLegacyLongitudinalSafety',
                                              'TestHyundaiLegacyLongitudinalSafetyHEV'}):
              continue
            volkswagen_shared = ('TestVolkswagenMqb', 'TestVolkswagenMlb', 'TestVolkswagenMeb')
@@ -1157,7 +1156,6 @@ class SafetyTest(SafetyTestBase):
            if attr.startswith('TestHyundaiLongitudinal') or attr in ('TestHyundaiSafetyFCEVLong',
                                                                      'TestHyundaiLongitudinalAolLkasOnEngageSafety',
                                                                      'TestHyundaiCanCanfdBlendedLongitudinalSafety',
-                                                                      'TestHyundaiLegacyLongitudinalSafety',
                                                                      'TestHyundaiLegacyLongitudinalSafetyHEV'):
              # exceptions for common msgs across different Hyundai CAN platforms
              tx = list(filter(lambda m: m[0] not in [0x420, 0x50A, 0x389, 0x4A2], tx))
@@ -61,7 +61,6 @@ class Buttons:


 # Ford safety has four different configurations tested here:
-#  * CAN with stock longitudinal
 #  * CAN with openpilot longitudinal
 #  * CAN FD with stock longitudinal
 #  * CAN FD with openpilot longitudinal
@@ -444,30 +443,6 @@ class TestFordCANFDStockSafety(TestFordSafetyBase):
    self.assertFalse(self._tx(self._lat_ctl_msg(True, 0.0, 0.01, 0.0, 0.0)))


-class TestFordStockSafety(TestFordSafetyBase):
-  STEER_MESSAGE = MSG_LateralMotionControl
-
-  TX_MSGS = [
-    [MSG_Steering_Data_FD1, 0], [MSG_Steering_Data_FD1, 2], [MSG_ACCDATA_3, 0], [MSG_Lane_Assist_Data1, 0],
-    [MSG_LateralMotionControl, 0], [MSG_IPMA_Data, 0],
-  ]
-  RELAY_MALFUNCTION_ADDRS = {0: (MSG_ACCDATA_3, MSG_Lane_Assist_Data1, MSG_LateralMotionControl,
-                                 MSG_IPMA_Data)}
-
-  FWD_BLACKLISTED_ADDRS = {2: [MSG_ACCDATA_3, MSG_Lane_Assist_Data1, MSG_LateralMotionControl,
-                               MSG_IPMA_Data]}
-
-  def setUp(self):
-    self.packer = CANPackerSafety("ford_lincoln_base_pt")
-    self.safety = libsafety_py.libsafety
-    self.safety.set_safety_hooks(CarParams.SafetyModel.ford, 0)
-    self.safety.init_tests()
-
-  def test_max_lateral_acceleration(self):
-    # CAN does not limit curvature from lateral acceleration
-    pass
-
-
 class TestFordLongitudinalSafetyBase(TestFordSafetyBase):
  MAX_ACCEL = 2.0  # accel is used for brakes, but openpilot can set positive values
  MIN_ACCEL = -3.5
@@ -534,7 +509,8 @@ class TestFordLongitudinalSafety(TestFordLongitudinalSafetyBase):
  def setUp(self):
    self.packer = CANPackerSafety("ford_lincoln_base_pt")
    self.safety = libsafety_py.libsafety
-    self.safety.set_safety_hooks(CarParams.SafetyModel.ford, FordSafetyFlags.LONG_CONTROL)
+    # Make sure we enforce long safety even without long flag for CAN
+    self.safety.set_safety_hooks(CarParams.SafetyModel.ford, 0)
    self.safety.init_tests()

  def test_max_lateral_acceleration(self):
@@ -548,7 +524,7 @@ class TestFordLKASteeringSafety(TestFordLongitudinalSafety):
  def setUp(self):
    self.packer = CANPackerSafety("ford_lincoln_base_pt")
    self.safety = libsafety_py.libsafety
-    self.safety.set_safety_hooks(CarParams.SafetyModel.ford, FordSafetyFlags.LONG_CONTROL | FordSafetyFlags.LKA_STEERING)
+    self.safety.set_safety_hooks(CarParams.SafetyModel.ford, FordSafetyFlags.LKA_STEERING)
    self.safety.init_tests()


@@ -4,7 +4,6 @@ import unittest

 from opendbc.car.hyundai.values import HyundaiSafetyFlags, HyundaiStarPilotSafetyFlags
 from opendbc.car.structs import CarParams
-from opendbc.safety import ALTERNATIVE_EXPERIENCE
 from opendbc.safety.tests.libsafety import libsafety_py
 import opendbc.safety.tests.common as common
 from opendbc.safety.tests.common import CANPackerSafety
@@ -597,14 +596,6 @@ class TestHyundaiSafetyFCEVLong(TestHyundaiLongitudinalSafety, TestHyundaiSafety
    self.safety.init_tests()


-class TestHyundaiLegacyLongitudinalSafety(TestHyundaiLongitudinalSafety, TestHyundaiLegacySafety):
-  def setUp(self):
-    self.packer = CANPackerSafety("hyundai_kia_generic")
-    self.safety = libsafety_py.libsafety
-    self.safety.set_safety_hooks(CarParams.SafetyModel.hyundaiLegacy, HyundaiSafetyFlags.LONG)
-    self.safety.init_tests()
-
-
 class TestHyundaiLegacyLongitudinalSafetyHEV(TestHyundaiLongitudinalSafety, TestHyundaiLegacySafetyHEV):
  def setUp(self):
    self.packer = CANPackerSafety("hyundai_kia_generic")
@@ -630,65 +621,5 @@ class TestHyundaiAolLkasOnEngageStockSafety(HyundaiAolLkasOnEngageStockBase, Tes
    self.safety.init_tests()


-class TestHyundaiAolMainLkasSyncSafety(TestHyundaiSafety):
-  def setUp(self):
-    self.packer = CANPackerSafety("hyundai_kia_generic")
-    self.safety = libsafety_py.libsafety
-    self.safety.set_safety_hooks(
-      CarParams.SafetyModel.hyundai,
-      HyundaiStarPilotSafetyFlags.HAS_LDA_BUTTON | HyundaiStarPilotSafetyFlags.AOL_MAIN_LKAS_SYNC,
-    )
-    self.safety.init_tests()
-
-  @staticmethod
-  def _lkas_button_msg(pressed):
-    dat = bytearray(8)
-    dat[0] = int(pressed) << 4
-    return libsafety_py.make_CANPacket(0x391, 0, bytes(dat))
-
-  def test_confirmed_main_state_rephases_lkas_button(self):
-    self.safety.set_alternative_experience(ALTERNATIVE_EXPERIENCE.ALWAYS_ON_LATERAL)
-    self.safety.set_controls_allowed(False)
-
-    self._rx(self._lkas_button_msg(True))
-    self._rx(self._lkas_button_msg(False))
-    self.assertTrue(self.safety.get_lkas_on())
-    self.assertTrue(self.safety.get_aol_allowed())
-    self._set_prev_torque(0)
-    self.assertTrue(self._tx(self._torque_cmd_msg(self.MAX_RATE_UP)))
-
-    self._rx(self._button_msg(Buttons.NONE, main_button=True))
-    self._rx(self._button_msg(Buttons.NONE, main_button=False))
-    self.assertFalse(self.safety.get_acc_main_on())
-    self.assertTrue(self.safety.get_lkas_on())
-    self.assertTrue(self.safety.get_aol_allowed())
-
-    self._rx(self._acc_state_msg(True))
-    self.assertFalse(self.safety.get_lkas_on())
-    self.assertTrue(self.safety.get_aol_allowed())
-    self._set_prev_torque(0)
-    self.assertTrue(self._tx(self._torque_cmd_msg(self.MAX_RATE_UP)))
-
-    self._rx(self._button_msg(Buttons.NONE, main_button=True))
-    self._rx(self._button_msg(Buttons.NONE, main_button=False))
-    self.assertTrue(self.safety.get_acc_main_on())
-    self.assertTrue(self.safety.get_aol_allowed())
-
-    self._rx(self._acc_state_msg(False))
-    self.assertFalse(self.safety.get_controls_allowed())
-    self.assertFalse(self.safety.get_acc_main_on())
-    self.assertFalse(self.safety.get_lkas_on())
-    self.assertFalse(self.safety.get_aol_allowed())
-    self._set_prev_torque(0)
-    self.assertFalse(self._tx(self._torque_cmd_msg(self.MAX_RATE_UP)))
-
-    self._rx(self._lkas_button_msg(True))
-    self._rx(self._lkas_button_msg(False))
-    self.assertTrue(self.safety.get_lkas_on())
-    self.assertTrue(self.safety.get_aol_allowed())
-    self._set_prev_torque(0)
-    self.assertTrue(self._tx(self._torque_cmd_msg(self.MAX_RATE_UP)))
-
-
 if __name__ == "__main__":
  unittest.main()
@@ -459,45 +459,12 @@ class TestHyundaiCanfdAltButtonFlagIsolation(unittest.TestCase):
    self.safety.safety_rx_hook(self._button_msg(lka=True))
    self.safety.safety_rx_hook(self._button_msg())
    self.assertTrue(self.safety.get_lkas_on())
+
    self.safety.safety_rx_hook(self._button_msg(main=True))
    self.safety.safety_rx_hook(self._button_msg())
    self.assertTrue(self.safety.get_lkas_on())


-class TestHyundaiCanfdCcncAltButtonResume(unittest.TestCase):
-  TX_MSGS = [[0x1AA, 2]]
-
-  def setUp(self):
-    self.packer = CANPackerSafety("hyundai_canfd_generated")
-    self.safety = libsafety_py.libsafety
-    self.safety.set_safety_hooks(
-      CarParams.SafetyModel.hyundaiCanfd,
-      HyundaiSafetyFlags.CCNC | HyundaiSafetyFlags.CAMERA_SCC | HyundaiSafetyFlags.CANFD_ALT_BUTTONS,
-    )
-    self.safety.init_tests()
-
-  def _resume_msg(self):
-    return self.packer.make_can_msg_safety(
-      "CRUISE_BUTTONS_ALT", 2, {"CRUISE_BUTTONS": Buttons.RESUME},
-    )
-
-  def test_resume_allowed_only_when_controls_are_allowed(self):
-    self.safety.set_controls_allowed(True)
-    self.assertTrue(self.safety.safety_tx_hook(self._resume_msg()))
-
-    self.safety.set_controls_allowed(False)
-    self.assertFalse(self.safety.safety_tx_hook(self._resume_msg()))
-
-  def test_alternate_button_frame_is_blocked_without_flag(self):
-    self.safety.set_safety_hooks(
-      CarParams.SafetyModel.hyundaiCanfd,
-      HyundaiSafetyFlags.CCNC | HyundaiSafetyFlags.CAMERA_SCC,
-    )
-    self.safety.init_tests()
-    self.safety.set_controls_allowed(True)
-    self.assertFalse(self.safety.safety_tx_hook(self._resume_msg()))
-
-
 class TestHyundaiCanfdCCNCSupportFrames(common.SafetyTestBase):
  TX_MSGS = [[0x161, 0], [0x162, 0], [0x7C4, 2], [0xEA, 2]]

@@ -826,19 +793,12 @@ class TestHyundaiCanfdLKASteeringAltAngleLongEV(HyundaiLongitudinalBase, TestHyu
      with self.subTest(address=address):
        self.assertFalse(self._tx(common.make_msg(1 if address != 0x51 else 0, address, length)))

-  def test_ccnc_angle_fallback_allows_lateral_only(self):
+  def test_ccnc_angle_fallback_allows_lfa_status_without_longitudinal_control(self):
    fallback_param = (self.SAFETY_PARAM & ~HyundaiSafetyFlags.LONG) | HyundaiSafetyFlags.CCNC
    self.safety.set_safety_hooks(CarParams.SafetyModel.hyundaiCanfd, fallback_param)
    self.safety.init_tests()

-    self._rx(self._gear_msg(5))
-    self._reset_speed_measurement(self.STANDSTILL_THRESHOLD + 1)
-    self._reset_angle_measurement(0)
-    self._set_prev_desired_angle(0)
-    self.safety.set_controls_allowed(True)
-
-    self.assertTrue(self._tx(self._angle_cmd_msg(0, enabled=True)))
-    self.assertFalse(self._tx(common.make_msg(1, 0x12A, 16)))
+    self.assertTrue(self._tx(common.make_msg(1, 0x12A, 16)))
    self.assertFalse(self._tx(common.make_msg(1, 0x1A0, 32)))

  def test_ccnc_angle_long_uses_second_mdps_angle(self):
@@ -1,2 +1,2 @@
 extern const uint8_t gitversion[19];
-const uint8_t gitversion[19] = "DEV-2ef545b9-DEBUG";
+const uint8_t gitversion[19] = "DEV-459d7c40-DEBUG";
--- a/Show More
+++ b/Show More