reset to pre-modification baseline; restart feature work from clean state

Restoring the working tree to the pristine pre-Claude baseline previously
preserved at /data/clearpilot (now /data/clearpilot-baseline). The prior
modified-but-broken tree is snapshotted at /data/openpilot-broken-2026-05-03
and tagged here as pre-reset-2026-05-03 for reference.

From here, features (UI changes, dashcam, telemetry, GPS, display modes,
speed logic, standstill power saving, etc.) will be re-introduced one at
a time with proper testing.

selfdrive/manager/build.py

@@ -1,6 +1,5 @@
 #!/usr/bin/env python3
 import os
-import sys
 import subprocess
 from pathlib import Path
 
@@ -55,14 +54,6 @@ def build(spinner: Spinner, dirty: bool = False, minimal: bool = False) -> None:
 
     if scons.returncode == 0:
       Path('/data/openpilot/prebuilt').touch()
-
-      # CLEARPILOT: update prebuilt spinner if the new build is newer
-      new_spinner = Path(BASEDIR) / "selfdrive/ui/_spinner"
-      old_spinner = Path(BASEDIR) / "selfdrive/ui/qt/spinner"
-      if new_spinner.exists() and (not old_spinner.exists() or new_spinner.stat().st_mtime > old_spinner.stat().st_mtime):
-        import shutil
-        shutil.copy2(str(new_spinner), str(old_spinner))
-
       break
 
   if scons.returncode != 0:
@@ -78,13 +69,8 @@ def build(spinner: Spinner, dirty: bool = False, minimal: bool = False) -> None:
     # Show TextWindow
     spinner.close()
     if not os.getenv("CI"):
-      # CLEARPILOT: BUILD_ONLY mode shows error on screen but doesn't block
-      t = TextWindow("openpilot failed to build\n \n" + error_s)
-      if os.getenv("BUILD_ONLY"):
-        print(error_s, file=sys.stderr)
-      else:
+      with TextWindow("openpilot failed to build\n \n" + error_s) as t:
         t.wait_for_exit()
-        t.close()
     exit(1)
 
   # enforce max cache size

selfdrive/manager/manager.py

@@ -16,7 +16,7 @@ from openpilot.common.text_window import TextWindow
 from openpilot.common.time import system_time_valid
 from openpilot.system.hardware import HARDWARE, PC
 from openpilot.selfdrive.manager.helpers import unblock_stdout, write_onroad_params, save_bootlog
-from openpilot.selfdrive.manager.process import ensure_running, init_log_dir, update_log_dir_timestamp, session_log
+from openpilot.selfdrive.manager.process import ensure_running
 from openpilot.selfdrive.manager.process_config import managed_processes
 from openpilot.selfdrive.athena.registration import register, UNREGISTERED_DONGLE_ID
 from openpilot.common.swaglog import cloudlog, add_file_handler
@@ -51,29 +51,7 @@ def frogpilot_boot_functions(frogpilot_functions):
   except Exception as e:
     print(f"An unexpected error occurred: {e}")
 
-def cleanup_old_logs(max_age_days=30):
-  """CLEARPILOT: delete session log directories older than max_age_days."""
-  import shutil
-  log_base = "/data/log2"
-  if not os.path.exists(log_base):
-    return
-  cutoff = time.time() - (max_age_days * 86400)
-  for entry in os.listdir(log_base):
-    if entry == "current":
-      continue
-    path = os.path.join(log_base, entry)
-    if os.path.isdir(path):
-      if os.path.getmtime(path) < cutoff:
-        try:
-          shutil.rmtree(path)
-        except OSError:
-          pass
-
-
 def manager_init(frogpilot_functions) -> None:
-  init_log_dir()
-  cleanup_old_logs()
-
   frogpilot_boot = threading.Thread(target=frogpilot_boot_functions, args=(frogpilot_functions,))
   frogpilot_boot.start()
 
@@ -82,27 +60,6 @@ def manager_init(frogpilot_functions) -> None:
   params = Params()
   params_storage = Params("/persist/params")
   params.clear_all(ParamKeyType.CLEAR_ON_MANAGER_START)
-
-  # CLEARPILOT: always start with telemetry disabled, VPN enabled (memory params)
-  params_memory = Params("/dev/shm/params")
-  params_memory.put("TelemetryEnabled", "0")
-  params_memory.put("VpnEnabled", "1")
-  params_memory.put("DashcamFrames", "0")
-  params_memory.put("DashcamState", "stopped")
-  params_memory.put("DashcamShutdown", "0")
-  params_memory.put("ModelFps", "20")
-  params_memory.put("ModelStandby", "0")
-  params_memory.put("ShutdownTouchReset", "0")
-  params_memory.put("ModelStandbyTs", "0")
-  params_memory.put("CarIsMetric", "0")
-  params_memory.put("ClearpilotSpeedDisplay", "")
-  params_memory.put("ClearpilotSpeedLimitDisplay", "0")
-  params_memory.put("ClearpilotHasSpeed", "0")
-  params_memory.put("ClearpilotIsMetric", "0")
-  params_memory.put("ClearpilotSpeedUnit", "mph")
-  params_memory.put("ClearpilotCruiseWarning", "")
-  params_memory.put("ClearpilotCruiseWarningSpeed", "")
-  params_memory.put("ClearpilotPlayDing", "0")
   params.clear_all(ParamKeyType.CLEAR_ON_ONROAD_TRANSITION)
   params.clear_all(ParamKeyType.CLEAR_ON_OFFROAD_TRANSITION)
   if is_release_branch():
@@ -178,7 +135,6 @@ def manager_init(frogpilot_functions) -> None:
     ("DisableOpenpilotLongitudinal", "0"),
     ("DisableVTSCSmoothing", "0"),
     ("DisengageVolume", "100"),
-    ("TelemetryEnabled", "0"),
     ("DragonPilotTune", "0"),
     ("DriverCamera", "0"),
     ("DynamicPathWidth", "0"),
@@ -273,7 +229,6 @@ def manager_init(frogpilot_functions) -> None:
     ("ScreenBrightnessOnroad", "101"),
     ("ScreenManagement", "1"),
     ("ScreenRecorder", "1"),
-    ("ScreenRecorderDebug", "1"),
     ("ScreenTimeout", "30"),
     ("ScreenTimeoutOnroad", "30"),
     ("SearchInput", "0"),
@@ -410,7 +365,6 @@ def manager_thread(frogpilot_functions) -> None:
   cloudlog.bind(daemon="manager")
   cloudlog.info("manager start")
   cloudlog.info({"environ": os.environ})
-  session_log.info("manager starting")
 
   params = Params()
   params_memory = Params("/dev/shm/params")
@@ -420,14 +374,6 @@ def manager_thread(frogpilot_functions) -> None:
     ignore += ["manage_athenad", "uploader"]
   if os.getenv("NOBOARD") is not None:
     ignore.append("pandad")
-  # CLEARPILOT: bench mode — disable real car processes, enable bench simulator
-  if os.getenv("BENCH_MODE") is not None:
-    ignore += ["pandad", "controlsd", "radard", "plannerd",
-               "calibrationd", "torqued", "paramsd", "locationd", "sensord",
-               "ubloxd", "pigeond", "dmonitoringmodeld", "dmonitoringd",
-               "modeld", "soundd", "loggerd", "micd",
-               "dashcamd"]
-    session_log.info("bench mode enabled")
   ignore += [x for x in os.getenv("BLOCK", "").split(",") if len(x) > 0]
 
   sm = messaging.SubMaster(['deviceState', 'carParams'], poll='deviceState')
@@ -449,7 +395,6 @@ def manager_thread(frogpilot_functions) -> None:
 
     if started and not started_prev:
       params.clear_all(ParamKeyType.CLEAR_ON_ONROAD_TRANSITION)
-      session_log.info("onroad transition")
 
       if openpilot_crashed:
         os.remove(os.path.join(sentry.CRASHES_DIR, 'error.txt'))
@@ -457,7 +402,6 @@ def manager_thread(frogpilot_functions) -> None:
     elif not started and started_prev:
       params.clear_all(ParamKeyType.CLEAR_ON_OFFROAD_TRANSITION)
       params_memory.clear_all(ParamKeyType.CLEAR_ON_OFFROAD_TRANSITION)
-      session_log.info("offroad transition")
 
     # update onroad params, which drives boardd's safety setter thread
     if started != started_prev:
@@ -467,9 +411,6 @@ def manager_thread(frogpilot_functions) -> None:
 
     ensure_running(managed_processes.values(), started, params=params, CP=sm['carParams'], not_run=ignore)
 
-    # CLEARPILOT: rename log directory once system time is valid
-    update_log_dir_timestamp()
-
     running = ' '.join("{}{}\u001b[0m".format("\u001b[32m" if p.proc.is_alive() else "\u001b[31m", p.name)
                        for p in managed_processes.values() if p.proc)
     print(running)
@@ -487,7 +428,6 @@ def manager_thread(frogpilot_functions) -> None:
         shutdown = True
         params.put("LastManagerExitReason", f"{param} {datetime.datetime.now()}")
         cloudlog.warning(f"Shutting down manager - {param} set")
-        session_log.info("manager shutting down: %s", param)
 
     if shutdown:
       break
@@ -539,7 +479,6 @@ if __name__ == "__main__":
   except Exception:
     add_file_handler(cloudlog)
     cloudlog.exception("Manager failed to start")
-    session_log.critical("manager failed to start: %s", traceback.format_exc())
 
     try:
       managed_processes['ui'].stop()

selfdrive/manager/process.py

@@ -2,7 +2,6 @@ import importlib
 import os
 import signal
 import struct
-import sys
 import datetime
 import time
 import subprocess
@@ -18,117 +17,17 @@ import openpilot.selfdrive.sentry as sentry
 from openpilot.common.basedir import BASEDIR
 from openpilot.common.params import Params
 from openpilot.common.swaglog import cloudlog
-from openpilot.common.time import system_time_valid
 
 WATCHDOG_FN = "/dev/shm/wd_"
 ENABLE_WATCHDOG = os.getenv("NO_WATCHDOG") is None
 
-# CLEARPILOT: logging directory and session log
-# init_log_dir() must be called once from manager_init() before any process starts.
-# Until then, _log_dir and session_log are usable but write to a NullHandler.
-import logging
-
-_log_dir = "/data/log2/current"
-_time_resolved = False
-_session_handler = None
-
-session_log = logging.getLogger("clearpilot.session")
-session_log.setLevel(logging.DEBUG)
-session_log.addHandler(logging.NullHandler())
-
-
-def init_log_dir():
-  """Create /data/log2/current as a real directory for this session.
-  Called once from manager_init(). Previous current (if a real dir) is
-  renamed to a timestamp or boot-monotonic name before we create a fresh one."""
-  global _log_dir, _time_resolved, _session_handler
-
-  log_base = "/data/log2"
-  current = os.path.join(log_base, "current")
-  os.makedirs(log_base, exist_ok=True)
-
-  # If 'current' is a symlink, just remove the symlink
-  if os.path.islink(current):
-    os.unlink(current)
-  # If 'current' is a real directory (leftover from previous session that
-  # never got time-resolved), rename it out of the way
-  elif os.path.isdir(current):
-    # Use mtime of session.log (or the dir itself) for the rename
-    session_file = os.path.join(current, "session.log")
-    mtime = os.path.getmtime(session_file) if os.path.exists(session_file) else os.path.getmtime(current)
-    ts = datetime.datetime.fromtimestamp(mtime).strftime('%Y-%m-%d-%H-%M-%S')
-    dest = os.path.join(log_base, ts)
-    # Avoid collision
-    if os.path.exists(dest):
-      dest = dest + f"-{int(time.monotonic())}"
-    try:
-      os.rename(current, dest)
-    except OSError:
-      pass
-
-  os.makedirs(current, exist_ok=True)
-  _log_dir = current
-  _time_resolved = False
-
-  # Set up session log file handler
-  _session_handler = logging.FileHandler(os.path.join(_log_dir, "session.log"))
-  _session_handler.setFormatter(logging.Formatter("%(asctime)s %(levelname)s %(message)s"))
-  # Remove NullHandler and add file handler
-  session_log.handlers.clear()
-  session_log.addHandler(_session_handler)
-
-  session_log.info("session started, log dir: %s", _log_dir)
-
-
-def update_log_dir_timestamp():
-  """Rename /data/log2/current to a real timestamp and replace with a symlink
-  once system time is valid."""
-  global _log_dir, _time_resolved, _session_handler
-  if _time_resolved:
-    return
-  if not system_time_valid():
-    return
-
-  log_base = "/data/log2"
-  current = os.path.join(log_base, "current")
-  ts_name = datetime.datetime.now().strftime('%Y-%m-%d-%H-%M-%S')
-  new_dir = os.path.join(log_base, ts_name)
-
-  try:
-    os.rename(current, new_dir)
-    # Create symlink: current -> YYYY-MM-DD-HH-MM-SS
-    os.symlink(ts_name, current)
-    _log_dir = new_dir
-    _time_resolved = True
-    # Re-point session log handler (open files follow the inode, but
-    # new opens should go through the symlink — update handler for clarity)
-    session_log.removeHandler(_session_handler)
-    _session_handler.close()
-    _session_handler = logging.FileHandler(os.path.join(_log_dir, "session.log"))
-    _session_handler.setFormatter(logging.Formatter("%(asctime)s %(levelname)s %(message)s"))
-    session_log.addHandler(_session_handler)
-    session_log.info("log directory renamed to %s", _log_dir)
-
-    # Signal via param that the directory has been time-resolved
-    try:
-      from openpilot.common.params import Params
-      Params().put("LogDirInitialized", "1")
-    except Exception:
-      pass
-  except OSError:
-    pass
+timestamp = datetime.datetime.now().strftime("%Y-%m-%d-%H-%M-%S")
+_log_dir = f"/data/log2/{timestamp}"
+os.makedirs(_log_dir, exist_ok=True)
 
 
 
-def launcher(proc: str, name: str, log_path: str) -> None:
-  # CLEARPILOT: redirect stderr to per-process log file
-  try:
-    log_file = open(log_path, 'a')
-    os.dup2(log_file.fileno(), sys.stderr.fileno())
-    os.dup2(log_file.fileno(), sys.stdout.fileno())
-  except Exception as e:
-    print(f"CLEARPILOT: stderr redirect failed for {name}: {e}", file=sys.stderr)
-
+def launcher(proc: str, name: str) -> None:
   try:
     # import the process
     mod = importlib.import_module(proc)
@@ -154,17 +53,9 @@ def launcher(proc: str, name: str, log_path: str) -> None:
     raise
 
 
-def nativelauncher(pargs: list[str], cwd: str, name: str, log_path: str) -> None:
+def nativelauncher(pargs: list[str], cwd: str, name: str) -> None:
   os.environ['MANAGER_DAEMON'] = name
 
-  # CLEARPILOT: redirect stderr and stdout to per-process log file
-  try:
-    log_file = open(log_path, 'a')
-    os.dup2(log_file.fileno(), sys.stderr.fileno())
-    os.dup2(log_file.fileno(), sys.stdout.fileno())
-  except Exception as e:
-    print(f"CLEARPILOT: stderr redirect failed for {name}: {e}", file=sys.stderr)
-
   # exec the process
   os.chdir(cwd)
   os.execvp(pargs[0], pargs)
@@ -219,7 +110,6 @@ class ManagerProcess(ABC):
     if dt > self.watchdog_max_dt:
       if (self.watchdog_seen or self.always_watchdog and self.proc.exitcode is not None) and ENABLE_WATCHDOG:
         cloudlog.error(f"Watchdog timeout for {self.name} (exitcode {self.proc.exitcode}) restarting ({started=})")
-        session_log.warning("watchdog timeout for %s (exitcode %s), restarting", self.name, self.proc.exitcode)
         self.restart()
     else:
       self.watchdog_seen = True
@@ -249,10 +139,6 @@ class ManagerProcess(ABC):
 
     ret = self.proc.exitcode
     cloudlog.info(f"{self.name} is dead with {ret}")
-    if ret is not None and ret != 0:
-      session_log.error("process %s died with exit code %s", self.name, ret)
-    elif ret == 0:
-      session_log.info("process %s stopped (exit 0)", self.name)
 
     if self.proc.exitcode is not None:
       self.shutting_down = False
@@ -312,13 +198,9 @@ class NativeProcess(ManagerProcess):
     global _log_dir
     log_path = _log_dir+"/"+self.name+".log"
 
-    # CLEARPILOT: ensure log file exists even if child redirect fails
-    open(log_path, 'a').close()
-
     cwd = os.path.join(BASEDIR, self.cwd)
     cloudlog.info(f"starting process {self.name}")
-    session_log.info("starting %s", self.name)
-    self.proc = Process(name=self.name, target=self.launcher, args=(self.cmdline, cwd, self.name, log_path))
+    self.proc = Process(name=self.name, target=self.launcher, args=(self.cmdline, cwd, self.name))
     self.proc.start()
     self.watchdog_seen = False
     self.shutting_down = False
@@ -349,12 +231,8 @@ class PythonProcess(ManagerProcess):
 
     global _log_dir
     log_path = _log_dir+"/"+self.name+".log"
-    # CLEARPILOT: ensure log file exists even if child redirect fails
-    open(log_path, 'a').close()
-
     cloudlog.info(f"starting python {self.module}")
-    session_log.info("starting %s", self.name)
-    self.proc = Process(name=self.name, target=self.launcher, args=(self.module, self.name, log_path))
+    self.proc = Process(name=self.name, target=self.launcher, args=(self.module, self.name))
     self.proc.start()
     self.watchdog_seen = False
     self.shutting_down = False
@@ -398,7 +276,6 @@ class DaemonProcess(ManagerProcess):
         pass
 
     cloudlog.info(f"starting daemon {self.name}")
-    session_log.info("starting daemon %s", self.name)
     proc = subprocess.Popen(['python', '-m', self.module],
                                stdin=open('/dev/null'),
                                stdout=open(log_path, 'a'),

selfdrive/manager/process_config.py

@@ -7,7 +7,6 @@ from openpilot.selfdrive.manager.process import PythonProcess, NativeProcess, Da
 
 
 WEBCAM = os.getenv("USE_WEBCAM") is not None
-BENCH_MODE = os.getenv("BENCH_MODE") is not None
 
 def driverview(started: bool, params: Params, CP: car.CarParams) -> bool:
   return started or params.get_bool("IsDriverViewEnabled")
@@ -52,14 +51,10 @@ def allow_uploads(started, params, CP: car.CarParams) -> bool:
   allow_uploads = not (params.get_bool("DeviceManagement") and params.get_bool("NoUploads"))
   return allow_uploads
 
-# ClearPilot functions
-def dashcam_should_run(started, params, CP: car.CarParams) -> bool:
-  return True  # CLEARPILOT: dashcamd manages its own trip lifecycle
-
 procs = [
   DaemonProcess("manage_athenad", "selfdrive.athena.manage_athenad", "AthenadPid"),
 
-  NativeProcess("camerad", "system/camerad", ["./camerad"], always_run),
+  NativeProcess("camerad", "system/camerad", ["./camerad"], driverview),
   NativeProcess("logcatd", "system/logcatd", ["./logcatd"], allow_logging),
   NativeProcess("proclogd", "system/proclogd", ["./proclogd"], allow_logging),
   PythonProcess("logmessaged", "system.logmessaged", allow_logging),
@@ -67,9 +62,8 @@ procs = [
   PythonProcess("timed", "system.timed", always_run, enabled=not PC),
 
   PythonProcess("dmonitoringmodeld", "selfdrive.modeld.dmonitoringmodeld", driverview, enabled=(not PC or WEBCAM)),
-  # CLEARPILOT: disabled video encoding (camera .hevc files) — CAN/sensor logs still recorded via loggerd
-  # NativeProcess("encoderd", "system/loggerd", ["./encoderd"], allow_logging),
-  # NativeProcess("stream_encoderd", "system/loggerd", ["./encoderd", "--stream"], notcar),
+  NativeProcess("encoderd", "system/loggerd", ["./encoderd"], allow_logging),
+  NativeProcess("stream_encoderd", "system/loggerd", ["./encoderd", "--stream"], notcar),
   NativeProcess("loggerd", "system/loggerd", ["./loggerd"], allow_logging),
   NativeProcess("modeld", "selfdrive/modeld", ["./modeld"], only_onroad),
   #NativeProcess("mapsd", "selfdrive/navd", ["./mapsd"], only_onroad),
@@ -84,8 +78,7 @@ procs = [
   PythonProcess("controlsd", "selfdrive.controls.controlsd", only_onroad),
   PythonProcess("deleter", "system.loggerd.deleter", always_run),
   PythonProcess("dmonitoringd", "selfdrive.monitoring.dmonitoringd", driverview, enabled=(not PC or WEBCAM)),
-  # PythonProcess("qcomgpsd", "system.qcomgpsd.qcomgpsd", qcomgps, enabled=TICI),
-  PythonProcess("gpsd", "system.clearpilot.gpsd", qcomgps, enabled=TICI),
+  # PythonProcess("qcomgpsd", "system.qcomgpsd.qcomgpsd", qcomgps, enabled=TICI),  # Fixme
   # PythonProcess("ugpsd", "system.ugpsd", only_onroad, enabled=TICI),
   #PythonProcess("navd", "selfdrive.navd.navd", only_onroad),
   PythonProcess("pandad", "selfdrive.boardd.pandad", always_run),
@@ -108,11 +101,6 @@ procs = [
   # FrogPilot processes
   PythonProcess("fleet_manager", "selfdrive.frogpilot.fleetmanager.fleet_manager", always_run),
   PythonProcess("frogpilot_process", "selfdrive.frogpilot.frogpilot_process", always_run),
-
-  # ClearPilot processes
-  NativeProcess("dashcamd", "selfdrive/clearpilot", ["./dashcamd"], dashcam_should_run),
-  PythonProcess("telemetryd", "selfdrive.clearpilot.telemetryd", always_run),
-  PythonProcess("bench_onroad", "selfdrive.clearpilot.bench_onroad", always_run, enabled=BENCH_MODE),
 ]
 
 managed_processes = {p.name: p for p in procs}