IQ.Pilot Release Commit @ bec7652

artifacts/iqpilot_alc_private/.source_sha

@@ -0,0 +1 @@
+0a3bb124deb8a9fdc8cea76764c690c7673a597f

artifacts/iqpilot_alc_private/manifest.json

@@ -0,0 +1,48 @@
+{
+  "python/_iqclosure/_vendored.json": {
+    "mode": 420,
+    "sha256": "37517e5f3dc66819f61f5a7bb8ace1921282415f10551d2defa5c3eb0985b570",
+    "size": 3
+  },
+  "python/iqpilot_private/__init__.py": {
+    "mode": 420,
+    "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
+    "size": 0
+  },
+  "python/iqpilot_private/konn3kt/__init__.py": {
+    "mode": 420,
+    "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
+    "size": 0
+  },
+  "python/iqpilot_private/konn3kt/iqlvbs/__init__.py": {
+    "mode": 420,
+    "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
+    "size": 0
+  },
+  "python/iqpilot_private/konn3kt/iqlvbs/alc.cpython-312-aarch64-linux-gnu.so": {
+    "mode": 493,
+    "sha256": "4d3eb2b63aa962bd764a9ee0086d3936846fb34a255321f7e95594412856f0fd",
+    "size": 402072
+  },
+  "python/iqpilot_private/konn3kt/iqlvbs/vehicle_state.cpython-312-aarch64-linux-gnu.so": {
+    "mode": 493,
+    "sha256": "8e6829e7d8828e76258eba191144d70ae5b42dec620608dcf65431db25c0670f",
+    "size": 69688
+  },
+  "runtime": {
+    "entries": {
+      "iqpilot_private.konn3kt.iqlvbs.alc": {
+        "path": "python/iqpilot_private/konn3kt/iqlvbs/alc.cpython-312-aarch64-linux-gnu.so",
+        "type": "python-module"
+      },
+      "iqpilot_private.konn3kt.iqlvbs.vehicle_state": {
+        "path": "python/iqpilot_private/konn3kt/iqlvbs/vehicle_state.cpython-312-aarch64-linux-gnu.so",
+        "type": "python-module"
+      }
+    }
+  },
+  "signatures": {
+    "python/iqpilot_private/konn3kt/iqlvbs/alc.cpython-312-aarch64-linux-gnu.so": "c/cZ53FdLJJLrMc8J40fW/CFkByPO0Dt2AMFIOY1AiT8/09piyULhhWAytgNaIejk8BP0aQhlk5xfaivI3bKCw==",
+    "python/iqpilot_private/konn3kt/iqlvbs/vehicle_state.cpython-312-aarch64-linux-gnu.so": "bbcjBEVBBQskXGTqTTQmLAdjcgtoL45mwGhRUwchrEkMNNeMJrvSCQ7ZXf8KpNUgFaiSU7L/5tnqHsrtKvU8Dw=="
+  }
+}

artifacts/iqpilot_alc_private/manifest.json.sig

@@ -0,0 +1 @@
+M1n62PoNdW9Odr9dhsZgHsKupcmVorFMp8QU14sERQn2XkFWjOGDfjUX018m7IWOdxtbciDzTzHYOIHkBxqVAg==

artifacts/iqpilot_alc_private/python/_iqclosure/_vendored.json

@@ -0,0 +1 @@
+[]

artifacts/iqpilot_commander_private/manifest.json

@@ -0,0 +1,38 @@
+{
+  "python/_iqclosure/_vendored.json": {
+    "mode": 420,
+    "sha256": "37517e5f3dc66819f61f5a7bb8ace1921282415f10551d2defa5c3eb0985b570",
+    "size": 3
+  },
+  "python/iqpilot_private/__init__.py": {
+    "mode": 420,
+    "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
+    "size": 0
+  },
+  "python/iqpilot_private/konn3kt/__init__.py": {
+    "mode": 420,
+    "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
+    "size": 0
+  },
+  "python/iqpilot_private/konn3kt/iqlvbs/__init__.py": {
+    "mode": 420,
+    "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
+    "size": 0
+  },
+  "python/iqpilot_private/konn3kt/iqlvbs/iqlvbs_commander.cpython-312-aarch64-linux-gnu.so": {
+    "mode": 493,
+    "sha256": "9b48803b46906943d7cb10b7e4b4f38c880f06a5c281f254a89e2254965b025f",
+    "size": 68080
+  },
+  "runtime": {
+    "entries": {
+      "iqpilot_private.konn3kt.iqlvbs.iqlvbs_commander": {
+        "path": "python/iqpilot_private/konn3kt/iqlvbs/iqlvbs_commander.cpython-312-aarch64-linux-gnu.so",
+        "type": "python-module"
+      }
+    }
+  },
+  "signatures": {
+    "python/iqpilot_private/konn3kt/iqlvbs/iqlvbs_commander.cpython-312-aarch64-linux-gnu.so": "RwstZkEGexV6fia/R9BRk+6CQ9Q6SGJopSJf04UpMpaw5fRtoPjLOrDFOt9kU8GPmCmW40gaXhJK+rimnBYnBw=="
+  }
+}

artifacts/iqpilot_commander_private/manifest.json.sig

@@ -0,0 +1 @@
+TV78NXdEYQiabAzLIqS2lsZbp5bO0y4EPGwLRUMyKeEH2BStZiFfpNPvlqSn5HGI+RjmTq+p5rRUDMNofbZGBw==

artifacts/iqpilot_commander_private/python/_iqclosure/_vendored.json

@@ -0,0 +1 @@
+[]

artifacts/iqpilot_hephaestusd_private/manifest.json

@@ -0,0 +1,534 @@
+{
+  "python/_iqclosure/_vendored.json": {
+    "mode": 420,
+    "sha256": "650f5873e58bb90fbe2429bb7e63eb7ac2145a39562b0780523835812b8baad3",
+    "size": 1805
+  },
+  "python/_iqclosure/iqpilot/__init__.py": {
+    "mode": 420,
+    "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
+    "size": 0
+  },
+  "python/_iqclosure/iqpilot/common/__init__.py": {
+    "mode": 420,
+    "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
+    "size": 0
+  },
+  "python/_iqclosure/iqpilot/common/api/__init__.py": {
+    "mode": 420,
+    "sha256": "97d6e0d8cbd3e47797d734322b42d04efea4d95a2dae5a56f1baef3fd847aa0d",
+    "size": 939
+  },
+  "python/_iqclosure/iqpilot/common/api/base.py": {
+    "mode": 420,
+    "sha256": "be55c83869bad911ee0204e8779b4673653f7d29ae4f524c978a280bd84c7777",
+    "size": 3187
+  },
+  "python/_iqclosure/iqpilot/common/api/comma_connect.py": {
+    "mode": 420,
+    "sha256": "e7c2dd0b56fb8533c2cbc614e728a9ffc5ce7360524cfa62a02f5235bc23b9a8",
+    "size": 267
+  },
+  "python/_iqclosure/iqpilot/common/atlas_alerts.py": {
+    "mode": 420,
+    "sha256": "ef0d867f6213bb67ed6b7fd6ef4e694eb1705d9dc694163a80c8dd9572932954",
+    "size": 9448
+  },
+  "python/_iqclosure/iqpilot/common/basedir.py": {
+    "mode": 420,
+    "sha256": "58cfa5d6405903ee1acecc4544463bb8f47a66921b120c382143aa80d8539b28",
+    "size": 106
+  },
+  "python/_iqclosure/iqpilot/common/constants.py": {
+    "mode": 420,
+    "sha256": "fc439d59c24b95ed349b84f1a5862df3ea50e0891dbec4ea3cf5e1e0ccff6513",
+    "size": 434
+  },
+  "python/_iqclosure/iqpilot/common/file_helpers.py": {
+    "mode": 420,
+    "sha256": "3c661d05dea697fae741b3e65a93385e4e0f5941eae8e8f4ea64da8da90e2f52",
+    "size": 67
+  },
+  "python/_iqclosure/iqpilot/common/git_creds.py": {
+    "mode": 420,
+    "sha256": "aab57b08d1907d0a761111e2a9a415af990475a55307c0ced6f2573664abbc49",
+    "size": 7327
+  },
+  "python/_iqclosure/iqpilot/common/gpio.py": {
+    "mode": 420,
+    "sha256": "01ba8cb32a644a2df545e764ba19bf1c7a320a217f983f8bac73b45d3a6891cf",
+    "size": 2408
+  },
+  "python/_iqclosure/iqpilot/common/i2c.py": {
+    "mode": 420,
+    "sha256": "4af8f9da7504a548d15f18b91d71c1379cb7c05c84be031448764cc49920ce68",
+    "size": 2449
+  },
+  "python/_iqclosure/iqpilot/common/issue_debug.py": {
+    "mode": 420,
+    "sha256": "73a10d846c735d4bcfda65f7828aa82192349b53920cb9d1b01cef8c211982fe",
+    "size": 1128
+  },
+  "python/_iqclosure/iqpilot/common/logging_extra.py": {
+    "mode": 420,
+    "sha256": "ce9b3b3d8498d76e1c4c0352a3e98e72759bb7f367ff8629c1329c46040595c3",
+    "size": 6628
+  },
+  "python/_iqclosure/iqpilot/common/realtime.py": {
+    "mode": 420,
+    "sha256": "95b2e4eb3d78b607945cc6fad29c97a2e133eff4c427620d5c04b044f78abe10",
+    "size": 3763
+  },
+  "python/_iqclosure/iqpilot/common/spinner.py": {
+    "mode": 420,
+    "sha256": "33a2eb2aa3148492414035c5dc7150b3a69467905d7a3e58c8f65cfe70d3552c",
+    "size": 1371
+  },
+  "python/_iqclosure/iqpilot/common/swaglog.py": {
+    "mode": 420,
+    "sha256": "0a133b4ef49f80b8890f115e81273f3f3e21351ae79f92dc02abc033e6d24027",
+    "size": 5274
+  },
+  "python/_iqclosure/iqpilot/common/time_helpers.py": {
+    "mode": 420,
+    "sha256": "c14cda1f84149d5ffa63a2adec5ca24126f77c1412a78412e5e3e68a6fd12bcf",
+    "size": 474
+  },
+  "python/_iqclosure/iqpilot/common/utils.py": {
+    "mode": 420,
+    "sha256": "6475ad94bc89252398c41e9eabf7929ba5eb8fa23a08ad7545e7a67b400af9f3",
+    "size": 8090
+  },
+  "python/_iqclosure/iqpilot/common/version.py": {
+    "mode": 420,
+    "sha256": "c04a243c77a170b750bad283da5e92bc6b1072bb674ece20dfa4eb9ec2d90309",
+    "size": 106
+  },
+  "python/_iqclosure/iqpilot/konn3kt/__init__.py": {
+    "mode": 420,
+    "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
+    "size": 0
+  },
+  "python/_iqclosure/iqpilot/konn3kt/cloud_client.py": {
+    "mode": 420,
+    "sha256": "4d58e62f8d628a8570881f2b87c82c801b46928fbb84f8dab8a81a9b55ba4e15",
+    "size": 493
+  },
+  "python/_iqclosure/iqpilot/konn3kt/registration.py": {
+    "mode": 420,
+    "sha256": "d8da8fa6373d54c3090b4466a975969317c9f5cd7c0ba20fd905e11ce9b95efd",
+    "size": 7948
+  },
+  "python/_iqclosure/iqpilot/konn3kt/service_health.py": {
+    "mode": 420,
+    "sha256": "10fa7d8490322275963308a1162ac5a0d0e3a96ac4a4771884eb2d3ec69fb480",
+    "size": 264
+  },
+  "python/_iqclosure/iqpilot/selfdrive/__init__.py": {
+    "mode": 420,
+    "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
+    "size": 0
+  },
+  "python/_iqclosure/iqpilot/selfdrive/car/__init__.py": {
+    "mode": 420,
+    "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
+    "size": 0
+  },
+  "python/_iqclosure/iqpilot/selfdrive/car/vehicle_catalog.py": {
+    "mode": 420,
+    "sha256": "8193cfcd9bda8651bf93f8d629996a22c760a42351c35a10c94329ab23fbf3f3",
+    "size": 2380
+  },
+  "python/_iqclosure/iqpilot/selfdrive/iqmodeld/__init__.py": {
+    "mode": 420,
+    "sha256": "1fe78b73b9f08b7081f28b80e01ca06b2ed423231459d30942184297ce1e50d7",
+    "size": 632
+  },
+  "python/_iqclosure/iqpilot/selfdrive/iqmodeld/config.py": {
+    "mode": 420,
+    "sha256": "056c744bbd9f1fe1053555d9b1fc1257d53093d69ddc94be3f05d840eb70781c",
+    "size": 3590
+  },
+  "python/_iqclosure/iqpilot/selfdrive/iqmodeld/models/__init__.py": {
+    "mode": 420,
+    "sha256": "e5ddcbc7b4dc348957c3d141c6bf8e7c321067f2ac56aecec24f6de107f9c2d3",
+    "size": 81
+  },
+  "python/_iqclosure/iqpilot/selfdrive/iqmodeld/models/fetcher.py": {
+    "mode": 420,
+    "sha256": "0487789aec270f9a712a19afafe0b686f825f06f57006c2346c052d3622ac5f8",
+    "size": 619
+  },
+  "python/_iqclosure/iqpilot/selfdrive/iqmodeld/models/helpers.py": {
+    "mode": 420,
+    "sha256": "5ddd486e47cdf811c0c293c460aba2d3b15bb30059ff6da8da775c5cd236465b",
+    "size": 10945
+  },
+  "python/_iqclosure/iqpilot/selfdrive/locationd/__init__.py": {
+    "mode": 420,
+    "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
+    "size": 0
+  },
+  "python/_iqclosure/iqpilot/selfdrive/locationd/calibrationd.py": {
+    "mode": 420,
+    "sha256": "6bceebb5a15895d2b6d20a28cbd14b9112f9422e0a0cf466314a7e8779da39dc",
+    "size": 15698
+  },
+  "python/_iqclosure/iqpilot/selfdrive/selfdrived/__init__.py": {
+    "mode": 420,
+    "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
+    "size": 0
+  },
+  "python/_iqclosure/iqpilot/selfdrive/selfdrived/alertmanager.py": {
+    "mode": 420,
+    "sha256": "c601bac30951a750d3ebf3d30f06c597bacd148210b1c405d5d3eca79bb7c4e3",
+    "size": 2045
+  },
+  "python/_iqclosure/iqpilot/selfdrive/selfdrived/events.py": {
+    "mode": 420,
+    "sha256": "7694cfb588e978a30c78a58039b087754e352215240b5e4bde953d848419122b",
+    "size": 36515
+  },
+  "python/_iqclosure/iqpilot/selfdrive/ui/__init__.py": {
+    "mode": 420,
+    "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
+    "size": 0
+  },
+  "python/_iqclosure/iqpilot/selfdrive/ui/feedback/__init__.py": {
+    "mode": 420,
+    "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
+    "size": 0
+  },
+  "python/_iqclosure/iqpilot/selfdrive/ui/feedback/feedbackd.py": {
+    "mode": 420,
+    "sha256": "7c1e6cb2c3c2c6aae91210f6cbc5c372f33c28cc3edb292ef71439b83844615d",
+    "size": 2615
+  },
+  "python/_iqclosure/iqpilot/system/__init__.py": {
+    "mode": 420,
+    "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
+    "size": 0
+  },
+  "python/_iqclosure/iqpilot/system/hardware/__init__.py": {
+    "mode": 420,
+    "sha256": "889391bffca493e74bfc108cae2976a53b644caca13ab600061fd29e9622c627",
+    "size": 695
+  },
+  "python/_iqclosure/iqpilot/system/hardware/base.py": {
+    "mode": 420,
+    "sha256": "a56293f7c23e503ff62d0d3ed39f1831b5544a65b37378165934361a5ddcd304",
+    "size": 4966
+  },
+  "python/_iqclosure/iqpilot/system/hardware/hw.py": {
+    "mode": 420,
+    "sha256": "c69185d8f6482c8b021f687b793246d2e2ede853e89a88748c64b85f60711b59",
+    "size": 3638
+  },
+  "python/_iqclosure/iqpilot/system/hardware/pc/__init__.py": {
+    "mode": 420,
+    "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
+    "size": 0
+  },
+  "python/_iqclosure/iqpilot/system/hardware/pc/hardware.py": {
+    "mode": 420,
+    "sha256": "2520895597c375ae570bd04d5f189e874c89d642f3f07bdbeb20388cb6691433",
+    "size": 258
+  },
+  "python/_iqclosure/iqpilot/system/hardware/tici/__init__.py": {
+    "mode": 420,
+    "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
+    "size": 0
+  },
+  "python/_iqclosure/iqpilot/system/hardware/tici/amplifier.py": {
+    "mode": 420,
+    "sha256": "98f46f8705259b00efae7274186b4e68201aad467a19de4f16d5f850d10ab0b5",
+    "size": 7585
+  },
+  "python/_iqclosure/iqpilot/system/hardware/tici/esim_manager.py": {
+    "mode": 420,
+    "sha256": "ac8d6d33286a021b0e1591329b779742d73993279d3f4c56e933cd7efd3114c8",
+    "size": 10930
+  },
+  "python/_iqclosure/iqpilot/system/hardware/tici/hardware.py": {
+    "mode": 420,
+    "sha256": "f1ddffa9bdb5071a49fd65eb4b49958b60b1873e1ec70e6f3f2e2b2501abce2f",
+    "size": 25584
+  },
+  "python/_iqclosure/iqpilot/system/hardware/tici/iwlist.py": {
+    "mode": 420,
+    "sha256": "d22858982705531732d5a20a45a73795496e5bbd9e23028c24609a7e58ac7aed",
+    "size": 890
+  },
+  "python/_iqclosure/iqpilot/system/hardware/tici/lpa.py": {
+    "mode": 420,
+    "sha256": "2bffb84aef35892c4788e80b6d937bf2eebd15e226b72a82c4f39217667c1ca0",
+    "size": 53692
+  },
+  "python/_iqclosure/iqpilot/system/hardware/tici/pins.py": {
+    "mode": 420,
+    "sha256": "b57ba4262e6a6a79f2db15c27356acf3e54f579a7edd13b483b2e16d140aca6d",
+    "size": 678
+  },
+  "python/_iqclosure/iqpilot/system/loggerd/__init__.py": {
+    "mode": 420,
+    "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
+    "size": 0
+  },
+  "python/_iqclosure/iqpilot/system/loggerd/xattr_cache.py": {
+    "mode": 420,
+    "sha256": "3aec77de0fe1ac5d32bef6cf59c4eeab3fcc37c86de42bdc1a9d730166225295",
+    "size": 991
+  },
+  "python/_iqclosure/iqpilot/system/manager/__init__.py": {
+    "mode": 420,
+    "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
+    "size": 0
+  },
+  "python/_iqclosure/iqpilot/system/manager/process.py": {
+    "mode": 420,
+    "sha256": "d036d82e2163a249186238375fb82f8dca250fae2272428ea47a46e4d6a8649d",
+    "size": 11519
+  },
+  "python/_iqclosure/iqpilot/system/manager/process_config.py": {
+    "mode": 420,
+    "sha256": "810bbd9bf9d211b1c54bfaaf56992b52e9a08a4cd0d1919d43a0a3b907401313",
+    "size": 11656
+  },
+  "python/_iqclosure/iqpilot/system/micd.py": {
+    "mode": 420,
+    "sha256": "1a59cbe6b72fcca5723ab56dc09f52039817299071a8d8da37f04acea58776bc",
+    "size": 5977
+  },
+  "python/_iqclosure/iqpilot/system/sentry.py": {
+    "mode": 420,
+    "sha256": "c3da338feb533937b6a5258ee450b6a3ff7a77b69cc9e48e31d16b875855caf3",
+    "size": 5229
+  },
+  "python/_iqclosure/iqpilot/system/ui/__init__.py": {
+    "mode": 420,
+    "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
+    "size": 0
+  },
+  "python/_iqclosure/iqpilot/system/ui/lib/__init__.py": {
+    "mode": 420,
+    "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
+    "size": 0
+  },
+  "python/_iqclosure/iqpilot/system/ui/lib/networkmanager.py": {
+    "mode": 420,
+    "sha256": "5d239320755efad6e88df237af763ed206ee37c0c8200db93bbdb0e0c884eb56",
+    "size": 1717
+  },
+  "python/_iqclosure/iqpilot/system/ui/lib/os_update.py": {
+    "mode": 420,
+    "sha256": "96760f2b5935a4429395628b64779efcfe80a7f50d98d57dda6c63855de1b2c6",
+    "size": 4236
+  },
+  "python/_iqclosure/iqpilot/system/ui/lib/wifi_manager.py": {
+    "mode": 420,
+    "sha256": "c9fe91484344f154726b0cab62a19f58a172e4f06dfd6341ca9b179c0c4646a8",
+    "size": 41618
+  },
+  "python/_iqclosure/iqpilot/system/version.py": {
+    "mode": 420,
+    "sha256": "b39a686854c9bfa3c6db9158f68734d7044760cf7ee79980102b7d23230836fd",
+    "size": 5909
+  },
+  "python/iqpilot_private/__init__.py": {
+    "mode": 420,
+    "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
+    "size": 0
+  },
+  "python/iqpilot_private/konn3kt/__init__.py": {
+    "mode": 420,
+    "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
+    "size": 0
+  },
+  "python/iqpilot_private/konn3kt/backups/__init__.py": {
+    "mode": 420,
+    "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
+    "size": 0
+  },
+  "python/iqpilot_private/konn3kt/backups/archive_codec.cpython-312-aarch64-linux-gnu.so": {
+    "mode": 493,
+    "sha256": "80cd58a10f6356fcad68063a474458653acbae17dfc8a66791256ec1fc109036",
+    "size": 135552
+  },
+  "python/iqpilot_private/konn3kt/backups/backup_keys.cpython-312-aarch64-linux-gnu.so": {
+    "mode": 493,
+    "sha256": "81e12476cedca56039fe9bf194cc9fd1a80b223c987e212a3208c64ff1390b26",
+    "size": 67664
+  },
+  "python/iqpilot_private/konn3kt/backups/backup_orchestrator.cpython-312-aarch64-linux-gnu.so": {
+    "mode": 493,
+    "sha256": "9d7e7fd9d1a3d2ff6ba8140fbe3743502151768f7d2c22625ffe2a78b3c8cd7b",
+    "size": 204640
+  },
+  "python/iqpilot_private/konn3kt/backups/cbc_vault.cpython-312-aarch64-linux-gnu.so": {
+    "mode": 493,
+    "sha256": "c39b482f192406ab8f3ec4733f2da8131ec1d9d5c791189035e42504d8e6132f",
+    "size": 69768
+  },
+  "python/iqpilot_private/konn3kt/backups/imahelper.cpython-312-aarch64-linux-gnu.so": {
+    "mode": 493,
+    "sha256": "5524a08ebc9918fabf6d8c7d2ccdb89ac67cbf8f017e4d00989bf88dc9720b12",
+    "size": 203088
+  },
+  "python/iqpilot_private/konn3kt/flockd/__init__.py": {
+    "mode": 420,
+    "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
+    "size": 0
+  },
+  "python/iqpilot_private/konn3kt/flockd/flockd.cpython-312-aarch64-linux-gnu.so": {
+    "mode": 493,
+    "sha256": "364a06ba9338c61fe904c6c93e3be7bc567b0881cffaaa62b7cba0d67a5f3c04",
+    "size": 202184
+  },
+  "python/iqpilot_private/konn3kt/flockd/signatures.cpython-312-aarch64-linux-gnu.so": {
+    "mode": 493,
+    "sha256": "08a7990bb84f88505eb5e58745b339b59ada3cc2b802c5f2396281cb03af1c84",
+    "size": 68080
+  },
+  "python/iqpilot_private/konn3kt/hephaestus/__init__.py": {
+    "mode": 420,
+    "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
+    "size": 0
+  },
+  "python/iqpilot_private/konn3kt/hephaestus/_vendor/localapi_runtime.zip": {
+    "mode": 420,
+    "sha256": "ec5e60ae7ebed56e6613216115b25e3f7388afd374619a656642118b0506642a",
+    "size": 2100238
+  },
+  "python/iqpilot_private/konn3kt/hephaestus/ble_auth.cpython-312-aarch64-linux-gnu.so": {
+    "mode": 493,
+    "sha256": "b9d5402b525987bc9939bf30113debde997d07a7ab0a5922bf1954cea7cb7757",
+    "size": 268080
+  },
+  "python/iqpilot_private/konn3kt/hephaestus/ble_gatt.cpython-312-aarch64-linux-gnu.so": {
+    "mode": 493,
+    "sha256": "68787d021840f0e1ee1babd3e4e781324c9b4e1bb8de38e78ac9fb57d967ba7c",
+    "size": 406176
+  },
+  "python/iqpilot_private/konn3kt/hephaestus/ble_rpc_dispatch.cpython-312-aarch64-linux-gnu.so": {
+    "mode": 493,
+    "sha256": "405fbafd6e385b7f6fa5f20b1ef1fa38cbd04952edef764efffbecbbebcd8f14",
+    "size": 68048
+  },
+  "python/iqpilot_private/konn3kt/hephaestus/ble_transportd.cpython-312-aarch64-linux-gnu.so": {
+    "mode": 493,
+    "sha256": "2449bf7779155e546ea14a5c10ee16be174da6993f6ab25e2aa59de007b5078b",
+    "size": 335776
+  },
+  "python/iqpilot_private/konn3kt/hephaestus/bt_gamepad.cpython-312-aarch64-linux-gnu.so": {
+    "mode": 493,
+    "sha256": "951fbff54e5fd1c667ca73359ea015e9cf79dcd55abb7f8b1bc857a38e11a54a",
+    "size": 271696
+  },
+  "python/iqpilot_private/konn3kt/hephaestus/cloud_routes.cpython-312-aarch64-linux-gnu.so": {
+    "mode": 493,
+    "sha256": "2fa9a1e9352721a03f2eaa4ecf3719787baafc35fb37d71e0b6372656cde6d5f",
+    "size": 134408
+  },
+  "python/iqpilot_private/konn3kt/hephaestus/hephaestusd.cpython-312-aarch64-linux-gnu.so": {
+    "mode": 493,
+    "sha256": "d342ef73b4fd9d60407c60d0c3768668e8bdbb0d9702f163aec4893f8d49af6c",
+    "size": 3715880
+  },
+  "python/iqpilot_private/konn3kt/hephaestus/kwp2000.cpython-312-aarch64-linux-gnu.so": {
+    "mode": 493,
+    "sha256": "cf6cc790e765adc5913c23ff32dea23588c1fb8608c6a8043fbc9b1bb2b662e8",
+    "size": 136472
+  },
+  "python/iqpilot_private/konn3kt/hephaestus/manage_hephaestusd.cpython-312-aarch64-linux-gnu.so": {
+    "mode": 493,
+    "sha256": "4d66dbd069d90ee956feac23130c5a14338f3d66492180dd3cd945f8a5c4ddad",
+    "size": 68208
+  },
+  "python/iqpilot_private/konn3kt/hephaestus/motd.cpython-312-aarch64-linux-gnu.so": {
+    "mode": 493,
+    "sha256": "d5227394abae38d2118d7e1df8a142ad2137a28e02679d29d2426c3ac8a60ba8",
+    "size": 67840
+  },
+  "python/iqpilot_private/konn3kt/hephaestus/tp20.cpython-312-aarch64-linux-gnu.so": {
+    "mode": 493,
+    "sha256": "59cba66846b23370b9c7b20d108db8bf6f1c7dbc8a49958621905e0cb322fbe9",
+    "size": 135664
+  },
+  "python/iqpilot_private/konn3kt/hephaestus/vw_pq_flasher.cpython-312-aarch64-linux-gnu.so": {
+    "mode": 493,
+    "sha256": "cc1be0247694a84b596e1333d53fa23a44fa2353b8b635f95b0329a5ffef5585",
+    "size": 269600
+  },
+  "python/iqpilot_private/konn3kt/uploaderd/__init__.py": {
+    "mode": 420,
+    "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
+    "size": 0
+  },
+  "python/iqpilot_private/konn3kt/uploaderd/iquploaderd.cpython-312-aarch64-linux-gnu.so": {
+    "mode": 493,
+    "sha256": "8a4926ba1d3bcf80326f699b1f9c775cd1fbe9d4c7981ba47d8232a8d4aedf79",
+    "size": 204296
+  },
+  "runtime": {
+    "entries": {
+      "iqpilot_private.konn3kt.backups.backup_orchestrator": {
+        "path": "python/iqpilot_private/konn3kt/backups/backup_orchestrator.cpython-312-aarch64-linux-gnu.so",
+        "type": "python-module"
+      },
+      "iqpilot_private.konn3kt.flockd.flockd": {
+        "path": "python/iqpilot_private/konn3kt/flockd/flockd.cpython-312-aarch64-linux-gnu.so",
+        "type": "python-module"
+      },
+      "iqpilot_private.konn3kt.hephaestus.ble_transportd": {
+        "path": "python/iqpilot_private/konn3kt/hephaestus/ble_transportd.cpython-312-aarch64-linux-gnu.so",
+        "type": "python-module"
+      },
+      "iqpilot_private.konn3kt.hephaestus.cloud_routes": {
+        "path": "python/iqpilot_private/konn3kt/hephaestus/cloud_routes.cpython-312-aarch64-linux-gnu.so",
+        "type": "python-module"
+      },
+      "iqpilot_private.konn3kt.hephaestus.hephaestusd": {
+        "path": "python/iqpilot_private/konn3kt/hephaestus/hephaestusd.cpython-312-aarch64-linux-gnu.so",
+        "type": "python-module"
+      },
+      "iqpilot_private.konn3kt.hephaestus.manage_hephaestusd": {
+        "path": "python/iqpilot_private/konn3kt/hephaestus/manage_hephaestusd.cpython-312-aarch64-linux-gnu.so",
+        "type": "python-module"
+      },
+      "iqpilot_private.konn3kt.hephaestus.motd": {
+        "path": "python/iqpilot_private/konn3kt/hephaestus/motd.cpython-312-aarch64-linux-gnu.so",
+        "type": "python-module"
+      },
+      "iqpilot_private.konn3kt.hephaestus.vw_pq_flasher": {
+        "path": "python/iqpilot_private/konn3kt/hephaestus/vw_pq_flasher.cpython-312-aarch64-linux-gnu.so",
+        "type": "python-module"
+      },
+      "iqpilot_private.konn3kt.uploaderd.iquploaderd": {
+        "path": "python/iqpilot_private/konn3kt/uploaderd/iquploaderd.cpython-312-aarch64-linux-gnu.so",
+        "type": "python-module"
+      }
+    }
+  },
+  "signatures": {
+    "python/iqpilot_private/konn3kt/backups/archive_codec.cpython-312-aarch64-linux-gnu.so": "tV3zvq8PZd4MgIU1hjzjpVxS8puOkVUUsJsSYb2fjeOqkBv6KG3oIlN+TPGiwwO7YX8dO8dFivZWGnktKWKPCg==",
+    "python/iqpilot_private/konn3kt/backups/backup_keys.cpython-312-aarch64-linux-gnu.so": "kG8Ifpx65b0dhdTdfFhLr65vGa1O5enjiCI9N3aGd5+aOE7DdKJPID4Q3vIIjMZqMdoKPTdBLj3MaPEYXL3pCg==",
+    "python/iqpilot_private/konn3kt/backups/backup_orchestrator.cpython-312-aarch64-linux-gnu.so": "1Dh3vRWc91DfHWg7pw9GhZ6O5eT335f4utjxSzHh8Y1wvwButYfsEO5DUZ2KNss5IAKDy7O4/CpnACD/64UYDg==",
+    "python/iqpilot_private/konn3kt/backups/cbc_vault.cpython-312-aarch64-linux-gnu.so": "6Fdo8Du4ZUMt8241uRDjLVoy1a2flzQNeXMfaVuRaMU8aYZZixqvaYPeanZDPOTvpy6PxaFVZYYnBR/cqokNCw==",
+    "python/iqpilot_private/konn3kt/backups/imahelper.cpython-312-aarch64-linux-gnu.so": "YTL4x/JaFnZCALPoyET84LvOcISGB5vrpTYn5b87kSDdcWPDwiTyEAXUuueOQGRQXVzZJj4UC+zal2DEA2QlAw==",
+    "python/iqpilot_private/konn3kt/flockd/flockd.cpython-312-aarch64-linux-gnu.so": "KHqjlPIClO9hg2LxyOzRismA38ysUPxci0KCiHrydE8W7Nbd3LMMR1/9/rUvPUfRYY/szpkfvkZTlMwo26R5BQ==",
+    "python/iqpilot_private/konn3kt/flockd/signatures.cpython-312-aarch64-linux-gnu.so": "Uas3ReVuTgjJxr1elZ/26R8/6StRaFrMPD16t7GWGj6PTG+CiUOPn4oiiJgfumevnrYw4xGGLRsfZQhFHaUHAA==",
+    "python/iqpilot_private/konn3kt/hephaestus/ble_auth.cpython-312-aarch64-linux-gnu.so": "39bSI5v9Mg9VQLo3PmfUBmfHE1hKjTD2Jfgak/W3m1FJ7eXROhUjts6bsY5pXsHDx6MTcEw35IUr7Q8v+3bQBg==",
+    "python/iqpilot_private/konn3kt/hephaestus/ble_gatt.cpython-312-aarch64-linux-gnu.so": "hB1aGUsLCYcFSLxGxg1nuRzbrA1Uv/StOQv0V/0L8v73Z7xakXYFW8h/C5xD2/hNIGFMaNc7GLOyc2GwN7tVAg==",
+    "python/iqpilot_private/konn3kt/hephaestus/ble_rpc_dispatch.cpython-312-aarch64-linux-gnu.so": "LlBVzMoPeK8ypvzgXXYkqmooV6V1lHtS6Ym5VPj/fNFn79hWfhbsjwY9A463hs3QzaxGh5OWwcc1pmFc6USODw==",
+    "python/iqpilot_private/konn3kt/hephaestus/ble_transportd.cpython-312-aarch64-linux-gnu.so": "nq7AH2XYZuAxhGfHfgc3haBGbu5bDwOI15mI++Be3VYsVah0P+Fqd0F5G6dZjIFo5fbuO0FH7/LHOlEnxRQcBw==",
+    "python/iqpilot_private/konn3kt/hephaestus/bt_gamepad.cpython-312-aarch64-linux-gnu.so": "m2y/Lozqs16IZsrpL+OOQ0MQCWEB+EuyacYa/TFch4KxwPHVrEnh+zKtGdeIhcd7pVkUd1IRkFVnWGGvBx+pCg==",
+    "python/iqpilot_private/konn3kt/hephaestus/cloud_routes.cpython-312-aarch64-linux-gnu.so": "+njDWbhjEsFL1WzGlL0fN5ygbqGbfwInwaAquDeC5aYgbrwvJOdnwonJgxV0fd0ABzIwfuUFzSMZg6F3qI84BA==",
+    "python/iqpilot_private/konn3kt/hephaestus/hephaestusd.cpython-312-aarch64-linux-gnu.so": "G8sfe52XB1m4Lc197oLD51bwbXOZXkpOtAsgiMHZHwbayEFsPeI2Ls/R4ZOcPYTjztXDKYt68Ig8QJblRanTCQ==",
+    "python/iqpilot_private/konn3kt/hephaestus/kwp2000.cpython-312-aarch64-linux-gnu.so": "jr8rsgKsxDYBuY58XqIqMkb9pW78Jb6rBGaEHLZRtWS6z58td37+PBesMzzg4J1GNov4RKcZfMbaANBui1OnAA==",
+    "python/iqpilot_private/konn3kt/hephaestus/manage_hephaestusd.cpython-312-aarch64-linux-gnu.so": "QbprGqwfKC9bo4xs8pNieYI/TOwLOUNv4YVHhXPS/2xVU5bS+aDr71aD/o4PF3UmkJrMW/94b8X22Dy19SYEDQ==",
+    "python/iqpilot_private/konn3kt/hephaestus/motd.cpython-312-aarch64-linux-gnu.so": "Iv9RL4rXHell9BfRp6PoWxD3TnT+WLugypT3aG4Ukf/iMqPVPizGtqfJY/axQY8jItBGTXcIyfZA9O6juGpfBg==",
+    "python/iqpilot_private/konn3kt/hephaestus/tp20.cpython-312-aarch64-linux-gnu.so": "KKD5TdLEDBtDy+YoUgglFkpHVJjvn9K4xlzUF7doWIAo1+n3ySTYQ4V7+iJ04H0Axs3Gsp0d0ytDui5qw09+Cw==",
+    "python/iqpilot_private/konn3kt/hephaestus/vw_pq_flasher.cpython-312-aarch64-linux-gnu.so": "C4po9GxTKUlww19PaUJUi+kUTBTTVYyUMjAvAhNYAVcOS6mpVNMIBX7UCt3XcTtlLU+q+goE0Mw68LvoMza4AQ==",
+    "python/iqpilot_private/konn3kt/uploaderd/iquploaderd.cpython-312-aarch64-linux-gnu.so": "l1lWA8GLEToT4GDa96aEt6TFO8RDP/WSHgXV+9mge8cHQ82UVrVJKX98andFvKDaNGPjZgR+gK5gslEMt2dVCg=="
+  }
+}

artifacts/iqpilot_hephaestusd_private/manifest.json.sig

@@ -0,0 +1 @@
+HlmJ/WkPaO0L0omQG7BWUtHYKzp2ZTFvaVu4BDpACrkluSoWeyX0suOZlU29fJvRI+nWhBEkRW7807toLyrNAQ==

artifacts/iqpilot_hephaestusd_private/python/_iqclosure/_vendored.json

@@ -0,0 +1,53 @@
+[
+  "iqpilot.common.api",
+  "iqpilot.common.api.base",
+  "iqpilot.common.api.comma_connect",
+  "iqpilot.common.atlas_alerts",
+  "iqpilot.common.basedir",
+  "iqpilot.common.constants",
+  "iqpilot.common.file_helpers",
+  "iqpilot.common.git_creds",
+  "iqpilot.common.gpio",
+  "iqpilot.common.i2c",
+  "iqpilot.common.issue_debug",
+  "iqpilot.common.logging_extra",
+  "iqpilot.common.realtime",
+  "iqpilot.common.spinner",
+  "iqpilot.common.swaglog",
+  "iqpilot.common.time_helpers",
+  "iqpilot.common.utils",
+  "iqpilot.common.version",
+  "iqpilot.konn3kt.cloud_client",
+  "iqpilot.konn3kt.registration",
+  "iqpilot.konn3kt.service_health",
+  "iqpilot.selfdrive.car.vehicle_catalog",
+  "iqpilot.selfdrive.iqmodeld",
+  "iqpilot.selfdrive.iqmodeld.config",
+  "iqpilot.selfdrive.iqmodeld.models",
+  "iqpilot.selfdrive.iqmodeld.models.fetcher",
+  "iqpilot.selfdrive.iqmodeld.models.helpers",
+  "iqpilot.selfdrive.locationd.calibrationd",
+  "iqpilot.selfdrive.selfdrived.alertmanager",
+  "iqpilot.selfdrive.selfdrived.events",
+  "iqpilot.selfdrive.ui.feedback.feedbackd",
+  "iqpilot.system.hardware",
+  "iqpilot.system.hardware.base",
+  "iqpilot.system.hardware.hw",
+  "iqpilot.system.hardware.pc.hardware",
+  "iqpilot.system.hardware.tici",
+  "iqpilot.system.hardware.tici.amplifier",
+  "iqpilot.system.hardware.tici.esim_manager",
+  "iqpilot.system.hardware.tici.hardware",
+  "iqpilot.system.hardware.tici.iwlist",
+  "iqpilot.system.hardware.tici.lpa",
+  "iqpilot.system.hardware.tici.pins",
+  "iqpilot.system.loggerd.xattr_cache",
+  "iqpilot.system.manager.process",
+  "iqpilot.system.manager.process_config",
+  "iqpilot.system.micd",
+  "iqpilot.system.sentry",
+  "iqpilot.system.ui.lib.networkmanager",
+  "iqpilot.system.ui.lib.os_update",
+  "iqpilot.system.ui.lib.wifi_manager",
+  "iqpilot.system.version"
+]

artifacts/iqpilot_hephaestusd_private/python/_iqclosure/iqpilot/common/api/__init__.py

@@ -0,0 +1,26 @@
+import iqpilot.common.api.comma_connect
+
+
+class Api:
+  def __init__(self, dongle_id):
+    self.service = iqpilot.common.api.comma_connect.CommaConnectApi(dongle_id)
+
+  def request(self, method, endpoint, **params):
+    return self.service.request(method, endpoint, **params)
+
+  def get(self, *args, **kwargs):
+    return self.service.get(*args, **kwargs)
+
+  def post(self, *args, **kwargs):
+    return self.service.post(*args, **kwargs)
+
+  def get_token(self, payload_extra=None, expiry_hours=1):
+    return self.service.get_token(payload_extra, expiry_hours)
+
+
+def api_get(endpoint, method='GET', timeout=None, access_token=None, session=None, **params):
+  return iqpilot.common.api.comma_connect.CommaConnectApi(None).api_get(endpoint, method, timeout, access_token, session, **params)
+
+
+def get_key_pair() -> tuple[str, str, str] | tuple[None, None, None]:
+  return iqpilot.common.api.comma_connect.CommaConnectApi(None).get_key_pair()

artifacts/iqpilot_hephaestusd_private/python/_iqclosure/iqpilot/common/api/base.py

@@ -0,0 +1,84 @@
+import jwt
+import os
+import requests
+import unicodedata
+from datetime import datetime, timedelta, UTC
+from functools import lru_cache
+from iqpilot.system.hardware.hw import Paths
+from iqpilot.system.version import get_version
+
+# name: jwt signature algorithm
+KEYS = {"id_rsa": "RS256",
+        "id_ecdsa": "ES256"}
+
+
+@lru_cache(maxsize=4)
+def load_signing_key(private_key: str):
+  # PyJWT re-parses a PEM string on every encode; an RSA parse is ~40ms, so cache the key object
+  try:
+    from cryptography.hazmat.primitives.serialization import load_pem_private_key
+    return load_pem_private_key(private_key.encode(), password=None)
+  except Exception:
+    return private_key
+
+
+class BaseApi:
+  def __init__(self, dongle_id, api_host, user_agent="openpilot-"):
+    self.dongle_id = dongle_id
+    self.api_host = api_host
+    self.user_agent = user_agent
+    self.jwt_algorithm, self.private_key, _ = self.get_key_pair()
+
+  def get(self, *args, **kwargs):
+    return self.request('GET', *args, **kwargs)
+
+  def post(self, *args, **kwargs):
+    return self.request('POST', *args, **kwargs)
+
+  def request(self, method, endpoint, timeout=None, access_token=None, **params):
+    return self.api_get(endpoint, method=method, timeout=timeout, access_token=access_token, **params)
+
+  def _get_token(self, payload_extra=None, expiry_hours=1, **extra_payload):
+    now = datetime.now(UTC).replace(tzinfo=None)
+    payload = {
+      'identity': self.dongle_id,
+      'nbf': now,
+      'iat': now,
+      'exp': now + timedelta(hours=expiry_hours),
+      **extra_payload
+    }
+    if payload_extra is not None:
+      payload.update(payload_extra)
+    key = load_signing_key(self.private_key) if self.private_key else self.private_key
+    token = jwt.encode(payload, key, algorithm=self.jwt_algorithm)
+    if isinstance(token, bytes):
+      token = token.decode('utf8')
+    return token
+
+  def get_token(self, payload_extra=None, expiry_hours=1):
+    return self._get_token(payload_extra, expiry_hours)
+
+  def remove_non_ascii_chars(self, text):
+    normalized_text = unicodedata.normalize('NFD', text)
+    ascii_encoded_text = normalized_text.encode('ascii', 'ignore')
+    return ascii_encoded_text.decode()
+
+  def api_get(self, endpoint, method='GET', timeout=None, access_token=None, session=None, json=None, **params):
+    headers = {}
+    if access_token is not None:
+      headers['Authorization'] = "JWT " + access_token
+
+    version = self.remove_non_ascii_chars(get_version())
+    headers['User-Agent'] = self.user_agent + version
+
+    # TODO: add session to Api
+    req = requests if session is None else session
+    return req.request(method, f"{self.api_host}/{endpoint}", timeout=timeout, headers=headers, json=json, params=params)
+
+  @staticmethod
+  def get_key_pair() -> tuple[str, str, str] | tuple[None, None, None]:
+    for key in KEYS:
+      if os.path.isfile(Paths.persist_root() + f'/comma/{key}') and os.path.isfile(Paths.persist_root() + f'/comma/{key}.pub'):
+        with open(Paths.persist_root() + f'/comma/{key}') as private, open(Paths.persist_root() + f'/comma/{key}.pub') as public:
+          return KEYS[key], private.read(), public.read()
+    return None, None, None

artifacts/iqpilot_hephaestusd_private/python/_iqclosure/iqpilot/common/api/comma_connect.py

@@ -0,0 +1,11 @@
+import os
+
+from iqpilot.common.api.base import BaseApi
+
+API_HOST = os.getenv('API_HOST', 'https://api-iqlabs.konn3kt.com')
+
+
+class CommaConnectApi(BaseApi):
+  def __init__(self, dongle_id):
+    super().__init__(dongle_id, API_HOST)
+    self.user_agent = "openpilot-"

artifacts/iqpilot_hephaestusd_private/python/_iqclosure/iqpilot/common/atlas_alerts.py

@@ -0,0 +1,281 @@
+from __future__ import annotations
+
+from abc import ABC, abstractmethod
+from bisect import insort
+from collections.abc import Callable, Iterable
+from dataclasses import dataclass, field
+from enum import IntEnum
+
+import iqpilot.cereal.messaging as messaging
+from iqpilot.cereal import car, log
+from iqpilot.common.realtime import DT_CTRL
+from iqpilot.system.hardware import HARDWARE
+
+AlertSize = log.SelfdriveState.AlertSize
+AlertStatus = log.SelfdriveState.AlertStatus
+VisualAlert = car.CarControl.HUDControl.VisualAlert
+AudibleAlert = car.CarControl.HUDControl.AudibleAlert
+
+
+def _frames_for(seconds: float) -> int:
+  return int(seconds / DT_CTRL)
+
+
+class Tier(IntEnum):
+  LOWEST = 0
+  LOWER = 1
+  LOW = 2
+  MID = 3
+  HIGH = 4
+  HIGHEST = 5
+
+
+class Tags:
+  ENABLE = "enable"
+  PRE_ENABLE = "preEnable"
+  OVERRIDE_LATERAL = "overrideLateral"
+  OVERRIDE_LONGITUDINAL = "overrideLongitudinal"
+  NO_ENTRY = "noEntry"
+  WARNING = "warning"
+  USER_DISABLE = "userDisable"
+  SOFT_DISABLE = "softDisable"
+  IMMEDIATE_DISABLE = "immediateDisable"
+  PERMANENT = "permanent"
+
+
+@dataclass(slots=True)
+class AlertCard:
+  alert_text_1: str
+  alert_text_2: str
+  alert_status: log.SelfdriveState.AlertStatus
+  alert_size: log.SelfdriveState.AlertSize
+  priority: Tier
+  visual_alert: car.CarControl.HUDControl.VisualAlert
+  audible_alert: car.CarControl.HUDControl.AudibleAlert
+  duration: int
+  creation_delay: float = 0.0
+  alert_type: str = field(default="", init=False)
+  event_type: str | None = field(default=None, init=False)
+
+  def __init__(self,
+               alert_text_1: str,
+               alert_text_2: str,
+               alert_status: log.SelfdriveState.AlertStatus,
+               alert_size: log.SelfdriveState.AlertSize,
+               priority: Tier,
+               visual_alert: car.CarControl.HUDControl.VisualAlert,
+               audible_alert: car.CarControl.HUDControl.AudibleAlert,
+               duration: float,
+               creation_delay: float = 0.0):
+    self.alert_text_1 = alert_text_1
+    self.alert_text_2 = alert_text_2
+    self.alert_status = alert_status
+    self.alert_size = alert_size
+    self.priority = priority
+    self.visual_alert = visual_alert
+    self.audible_alert = audible_alert
+    self.duration = _frames_for(duration)
+    self.creation_delay = creation_delay
+    self.alert_type = ""
+    self.event_type = None
+
+  def __str__(self) -> str:
+    return f"{self.alert_text_1}/{self.alert_text_2} {self.priority} {self.visual_alert} {self.audible_alert}"
+
+
+AlertFactory = Callable[[car.CarParams, car.CarState, messaging.SubMaster, bool, int, log.ControlsState], AlertCard]
+
+
+def car_mode_entry_alert(CP: car.CarParams, CS: car.CarState, sm: messaging.SubMaster, metric: bool, soft_disable_time: int, personality) -> AlertCard:
+  del CS, sm, metric, soft_disable_time, personality
+  headline = "Enable Adaptive Cruise to Engage"
+  if CP.brand == "honda":
+    headline = "Enable Main Switch to Engage"
+  return NoEntryCard(headline)
+
+
+class EventBook(ABC):
+  def __init__(self):
+    self._live_names: list[int] = []
+    self._latched_names: list[int] = []
+    self.event_counters: dict[int, int] = {}
+
+  @property
+  def events(self) -> list[int]:
+    return self._live_names
+
+  @events.setter
+  def events(self, values: list[int]) -> None:
+    self._live_names = values
+
+  @property
+  def static_events(self) -> list[int]:
+    return self._latched_names
+
+  @static_events.setter
+  def static_events(self, values: list[int]) -> None:
+    self._latched_names = values
+
+  @property
+  def names(self) -> list[int]:
+    return list(self._live_names)
+
+  def __len__(self) -> int:
+    return len(self._live_names)
+
+  def add(self, event_name: int, static: bool = False) -> None:
+    if static:
+      insort(self._latched_names, event_name)
+    insort(self._live_names, event_name)
+
+  def clear(self) -> None:
+    refreshed: dict[int, int] = {}
+    for event_name, frames_seen in self.event_counters.items():
+      refreshed[event_name] = frames_seen + 1 if event_name in self._live_names else 0
+    self.event_counters = refreshed
+    self._live_names = list(self._latched_names)
+
+  def contains(self, event_type: str) -> bool:
+    board = self.get_events_mapping()
+    return any(event_type in board.get(event_name, {}) for event_name in self._live_names)
+
+  def has(self, event_name: int) -> bool:
+    return event_name in self._live_names
+
+  def contains_in_list(self, events_list: list[int]) -> bool:
+    return any(event_name in self._live_names for event_name in events_list)
+
+  def remove(self, event_name: int, static: bool = False) -> None:
+    if static and event_name in self._latched_names:
+      self._latched_names.remove(event_name)
+
+    if event_name in self._live_names:
+      self.event_counters[event_name] = self.event_counters.get(event_name, 0) + 1
+      self._live_names.remove(event_name)
+
+  def add_from_msg(self, events: Iterable) -> None:
+    for event in events:
+      insort(self._live_names, event.name.raw)
+
+  def to_msg(self):
+    board = self.get_events_mapping()
+    outbound = []
+    for event_name in self._live_names:
+      msg = self.get_event_msg_type().new_message()
+      msg.name = event_name
+      for event_kind in board.get(event_name, {}):
+        setattr(msg, event_kind, True)
+      outbound.append(msg)
+    return outbound
+
+  def create_alerts(self, event_types: list[str], callback_args=None):
+    callback_args = [] if callback_args is None else callback_args
+    board = self.get_events_mapping()
+    spawned: list[AlertCard] = []
+    for event_name in self._live_names:
+      variants = board.get(event_name, {})
+      for event_type in event_types:
+        chosen = variants.get(event_type)
+        if chosen is None:
+          continue
+        alert = self._realize(chosen, callback_args)
+        age_frames = self.event_counters.get(event_name, 0) + 1
+        if age_frames * DT_CTRL < alert.creation_delay:
+          continue
+        alert.alert_type = f"{self.get_event_name(event_name)}/{event_type}"
+        alert.event_type = event_type
+        spawned.append(alert)
+    return spawned
+
+  @staticmethod
+  def _realize(candidate: AlertCard | AlertFactory, callback_args: list) -> AlertCard:
+    return candidate if isinstance(candidate, AlertCard) else candidate(*callback_args)
+
+  @abstractmethod
+  def get_events_mapping(self) -> dict[int, dict[str, AlertCard | AlertFactory]]:
+    raise NotImplementedError
+
+  @abstractmethod
+  def get_event_name(self, event: int) -> str:
+    raise NotImplementedError
+
+  @abstractmethod
+  def get_event_msg_type(self):
+    raise NotImplementedError
+
+
+def _mici_reframe(primary: str, secondary: str) -> tuple[str, str, log.SelfdriveState.AlertSize]:
+  if HARDWARE.get_device_type() == "mici":
+    return secondary, primary, AlertSize.small
+  return primary, secondary, AlertSize.mid
+
+
+class NoEntryCard(AlertCard):
+  def __init__(self,
+               alert_text_2: str,
+               alert_text_1: str = "IQ.Pilot Unavailable",
+               visual_alert: car.CarControl.HUDControl.VisualAlert = VisualAlert.none,
+               priority: Tier = Tier.LOW):
+    primary, secondary, size = _mici_reframe(alert_text_1, alert_text_2)
+    super().__init__(primary, secondary, AlertStatus.normal, size, priority, visual_alert, AudibleAlert.refuse, 3.0)
+
+
+class GentleDisableCard(AlertCard):
+  def __init__(self, alert_text_2: str):
+    super().__init__(
+      "TAKE CONTROL IMMEDIATELY",
+      alert_text_2,
+      AlertStatus.userPrompt,
+      AlertSize.full,
+      Tier.MID,
+      VisualAlert.steerRequired,
+      AudibleAlert.warningSoft,
+      2.0,
+    )
+
+
+class PendingDisableCard(GentleDisableCard):
+  def __init__(self, alert_text_2: str):
+    super().__init__(alert_text_2)
+    self.alert_text_1 = "IQ.Pilot will disengage"
+
+
+class HardDisableCard(AlertCard):
+  def __init__(self, alert_text_2: str):
+    super().__init__(
+      "TAKE CONTROL IMMEDIATELY",
+      alert_text_2,
+      AlertStatus.critical,
+      AlertSize.full,
+      Tier.HIGHEST,
+      VisualAlert.steerRequired,
+      AudibleAlert.warningImmediate,
+      4.0,
+    )
+
+
+class ChimeCard(AlertCard):
+  def __init__(self, audible_alert: car.CarControl.HUDControl.AudibleAlert):
+    super().__init__("", "", AlertStatus.normal, AlertSize.none, Tier.MID, VisualAlert.none, audible_alert, 0.2)
+
+
+class BannerCard(AlertCard):
+  def __init__(self, alert_text_1: str, alert_text_2: str = "", duration: float = 0.2, priority: Tier = Tier.LOWER, creation_delay: float = 0.0):
+    size = AlertSize.mid if alert_text_2 else AlertSize.small
+    super().__init__(alert_text_1, alert_text_2, AlertStatus.normal, size, priority, VisualAlert.none, AudibleAlert.none, duration, creation_delay)
+
+
+class BootCard(AlertCard):
+  def __init__(self, alert_text_1: str, alert_text_2: str = "Always keep hands on wheel and eyes on road", alert_status=AlertStatus.normal):
+    if HARDWARE.get_device_type() == "mici":
+      compact_secondary = "" if alert_text_2 == "Always keep hands on wheel and eyes on road" else alert_text_2
+      super().__init__(alert_text_1, compact_secondary, alert_status, AlertSize.small, Tier.LOWER, VisualAlert.none, AudibleAlert.none, 5.0)
+    else:
+      super().__init__(alert_text_1, alert_text_2, alert_status, AlertSize.mid, Tier.LOWER, VisualAlert.none, AudibleAlert.none, 5.0)
+
+
+class AlertBase(AlertCard):
+  pass
+
+
+NULL_ALERT = AlertCard("", "", AlertStatus.normal, AlertSize.none, Tier.LOWEST, VisualAlert.none, AudibleAlert.none, 0.0)

artifacts/iqpilot_hephaestusd_private/python/_iqclosure/iqpilot/common/basedir.py

@@ -0,0 +1,4 @@
+import os
+
+
+BASEDIR = os.path.abspath(os.path.join(os.path.dirname(os.path.realpath(__file__)), "../.."))

artifacts/iqpilot_hephaestusd_private/python/_iqclosure/iqpilot/common/constants.py

@@ -0,0 +1,23 @@
+import numpy as np
+
+# conversions
+class CV:
+  # Speed
+  MPH_TO_KPH = 1.609344
+  KPH_TO_MPH = 1. / MPH_TO_KPH
+  MS_TO_KPH = 3.6
+  KPH_TO_MS = 1. / MS_TO_KPH
+  MS_TO_MPH = MS_TO_KPH * KPH_TO_MPH
+  MPH_TO_MS = MPH_TO_KPH * KPH_TO_MS
+  MS_TO_KNOTS = 1.9438
+  KNOTS_TO_MS = 1. / MS_TO_KNOTS
+
+  # Angle
+  DEG_TO_RAD = np.pi / 180.
+  RAD_TO_DEG = 1. / DEG_TO_RAD
+
+  # Mass
+  LB_TO_KG = 0.453592
+
+
+ACCELERATION_DUE_TO_GRAVITY = 9.81  # m/s^2

artifacts/iqpilot_hephaestusd_private/python/_iqclosure/iqpilot/common/file_helpers.py

@@ -0,0 +1 @@
+from iqpilot.common.utils import CallbackReader, get_upload_stream

artifacts/iqpilot_hephaestusd_private/python/_iqclosure/iqpilot/common/git_creds.py

@@ -0,0 +1,250 @@
+import base64
+import json
+import os
+import subprocess
+
+from iqpilot.common.params import Params
+
+PARAM = "GitAuthBlob"
+PARAMS_DIR = os.environ.get("PARAMS_DIR", "/data/params/d")
+KEY_DIR = "/data/konn3kt"
+KEY_PATH = os.path.join(KEY_DIR, "git_auth.key")
+HELPER_PATH = os.path.join(KEY_DIR, "git_credential_helper.py")
+DEFAULT_REPO_DIR = "/data/openpilot"
+CREDENTIAL_HOSTS = ("git.konn3kt.com", "gitlvb.teallvbs.xyz")
+
+_HELPER_SCRIPT = '''#!/usr/bin/env python3
+import json
+import os
+import sys
+
+KEY_PATH = "{key_path}"
+
+
+def main() -> None:
+  if len(sys.argv) < 2 or sys.argv[1] != "get":
+    return
+  # drain git's request on stdin (terminated by a blank line)
+  for line in sys.stdin:
+    if not line.strip():
+      break
+  params_dir = os.environ.get("PARAMS_DIR", "/data/params/d")
+  blob_path = os.path.join(params_dir, "GitAuthBlob")
+  try:
+    with open(KEY_PATH, "rb") as f:
+      key = f.read().strip()
+    with open(blob_path, "rb") as f:
+      blob = f.read()
+    if not blob:
+      return
+    from cryptography.fernet import Fernet
+    data = json.loads(Fernet(key).decrypt(blob).decode())
+    username = data.get("u", "")
+    token = data.get("t", "")
+    if username and token:
+      sys.stdout.write("username=%s\\npassword=%s\\n" % (username, token))
+  except Exception:
+    return
+
+
+if __name__ == "__main__":
+  main()
+'''
+
+
+def _params_get(name: str) -> bytes | None:
+  # Params -> cereal -> iqdbc: that chain is unavailable mid-bootstrap (this module's
+  # callers install those very packages), so fall back to the params file directly,
+  # exactly like the embedded credential helper does.
+  try:
+    return Params().get(name)
+  except Exception:
+    try:
+      with open(os.path.join(PARAMS_DIR, name), "rb") as f:
+        return f.read()
+    except OSError:
+      return None
+
+
+def _params_put(name: str, value: bytes) -> None:
+  try:
+    Params().put(name, value)
+    return
+  except Exception:
+    pass
+  os.makedirs(PARAMS_DIR, exist_ok=True)
+  tmp = os.path.join(PARAMS_DIR, f".tmp_{name}")
+  fd = os.open(tmp, os.O_WRONLY | os.O_CREAT | os.O_TRUNC, 0o644)
+  with os.fdopen(fd, "wb") as f:
+    f.write(value)
+    f.flush()
+    os.fsync(f.fileno())
+  os.replace(tmp, os.path.join(PARAMS_DIR, name))
+
+
+def _params_remove(name: str) -> None:
+  try:
+    Params().remove(name)
+    return
+  except Exception:
+    pass
+  try:
+    os.unlink(os.path.join(PARAMS_DIR, name))
+  except OSError:
+    pass
+
+
+def _load_or_create_key() -> bytes:
+  from cryptography.fernet import Fernet
+  try:
+    with open(KEY_PATH, "rb") as f:
+      return f.read().strip()
+  except FileNotFoundError:
+    pass
+  key = Fernet.generate_key()
+  os.makedirs(KEY_DIR, exist_ok=True)
+  # write atomically with restrictive perms
+  tmp = KEY_PATH + ".tmp"
+  fd = os.open(tmp, os.O_WRONLY | os.O_CREAT | os.O_TRUNC, 0o600)
+  with os.fdopen(fd, "wb") as f:
+    f.write(key)
+  os.replace(tmp, KEY_PATH)
+  return key
+
+
+def set_credentials(username: str, token: str) -> None:
+  """Encrypt and store credentials. Empty username AND token clears them."""
+  username = (username or "").strip()
+  token = (token or "").strip()
+  if not username and not token:
+    clear_credentials()
+    return
+  from cryptography.fernet import Fernet
+  blob = Fernet(_load_or_create_key()).encrypt(
+    json.dumps({"u": username, "t": token}).encode()
+  )
+  _params_put(PARAM, blob)
+  try:
+    install_credential_helper(DEFAULT_REPO_DIR)
+  except Exception:
+    pass
+
+
+def get_credentials() -> tuple[str, str] | None:
+  """Return (username, token), or None if unset / unreadable."""
+  blob = _params_get(PARAM)
+  if not blob:
+    return None
+  try:
+    from cryptography.fernet import Fernet
+    data = json.loads(Fernet(_load_or_create_key()).decrypt(blob).decode())
+    return data.get("u", ""), data.get("t", "")
+  except Exception:
+    return None
+
+
+def clear_credentials() -> None:
+  _params_remove(PARAM)
+
+
+def has_credentials() -> bool:
+  return get_credentials() is not None
+
+
+def _auth_header(username: str, token: str) -> str:
+  return "Authorization: Basic " + base64.b64encode(f"{username}:{token}".encode()).decode()
+
+
+def ssh_to_https(url: str) -> str:
+  """Convert an SSH git URL to its HTTPS equivalent. Returns url unchanged if it
+  is not an SSH URL. A leading ssh. host label is dropped (ssh.host -> host)."""
+  url = url.strip()
+  host = path = ""
+  if url.startswith("ssh://"):
+    rest = url[len("ssh://"):]
+    rest = rest.split("@", 1)[-1]          # drop user@
+    hostport, _, path = rest.partition("/")
+    host = hostport.split(":", 1)[0]       # drop :port
+  elif url.startswith("git@") or ("@" in url and ":" in url.split("@", 1)[-1] and "://" not in url):
+    rest = url.split("@", 1)[-1]           # host:owner/repo.git
+    host, _, path = rest.partition(":")
+  else:
+    return url  # already https/http or unrecognised
+  if host.startswith("ssh."):
+    host = host[len("ssh."):]
+  return f"https://{host}/{path}"
+
+
+def install_credential_helper(repo_dir: str = DEFAULT_REPO_DIR) -> None:
+  if get_credentials() is None:
+    return
+
+  scopes = {f"https://{host}" for host in CREDENTIAL_HOSTS}
+  origin = subprocess.run(
+    ["git", "-C", repo_dir, "config", "--get", "remote.origin.url"],
+    capture_output=True, text=True, check=False,
+  ).stdout.strip()
+  https = ssh_to_https(origin)
+  if https.startswith("https://"):
+    from urllib.parse import urlsplit
+    parts = urlsplit(https)
+    if parts.hostname:
+      scopes.add(f"{parts.scheme}://{parts.hostname}")
+
+  try:
+    os.makedirs(KEY_DIR, exist_ok=True)
+    tmp = HELPER_PATH + ".tmp"
+    fd = os.open(tmp, os.O_WRONLY | os.O_CREAT | os.O_TRUNC, 0o755)
+    with os.fdopen(fd, "w") as f:
+      f.write(_HELPER_SCRIPT.format(key_path=KEY_PATH))
+    os.replace(tmp, HELPER_PATH)
+  except Exception:
+    return
+
+  helper_cmd = f"!/usr/bin/env python3 {HELPER_PATH}"
+  for scope in scopes:
+    subprocess.run(
+      ["git", "config", "--global", f"credential.{scope}.helper", helper_cmd],
+      check=False, capture_output=True,
+    )
+
+
+def configure(repo_dir: str) -> None:
+  """Apply on-device credentials to the git repo at repo_dir before a remote op.
+
+  No-op when no credentials are stored. If the origin is an SSH URL it is
+  rewritten in-place to the HTTPS equivalent so the Basic-auth header applies.
+  The header is injected via GIT_CONFIG_* env (never persisted to .git/config).
+  Idempotent."""
+  creds = get_credentials()
+  if creds is None:
+    return
+  username, token = creds
+
+  try:
+    install_credential_helper(repo_dir)
+  except Exception:
+    pass
+
+  origin = subprocess.run(
+    ["git", "-C", repo_dir, "config", "--get", "remote.origin.url"],
+    capture_output=True, text=True, check=False,
+  ).stdout.strip()
+  if not origin:
+    return
+
+  https = ssh_to_https(origin)
+  if https != origin and https.startswith("https://"):
+    subprocess.run(
+      ["git", "-C", repo_dir, "config", "remote.origin.url", https],
+      check=False, capture_output=True,
+    )
+
+  if not https.startswith("https://"):
+    return  # header auth only works over https
+
+  # scope to this exact repo URL prefix (trailing slash => component boundary)
+  key = https if https.endswith("/") else https + "/"
+  os.environ["GIT_CONFIG_COUNT"] = "1"
+  os.environ["GIT_CONFIG_KEY_0"] = f"http.{key}.extraHeader"
+  os.environ["GIT_CONFIG_VALUE_0"] = _auth_header(username, token)

artifacts/iqpilot_hephaestusd_private/python/_iqclosure/iqpilot/common/gpio.py

@@ -0,0 +1,89 @@
+import os
+import fcntl
+import ctypes
+from functools import cache
+
+def gpio_init(pin: int, output: bool) -> None:
+  try:
+    with open(f"/sys/class/gpio/gpio{pin}/direction", 'wb') as f:
+      f.write(b"out" if output else b"in")
+  except Exception as e:
+    print(f"Failed to set gpio {pin} direction: {e}")
+
+def gpio_set(pin: int, high: bool) -> None:
+  try:
+    with open(f"/sys/class/gpio/gpio{pin}/value", 'wb') as f:
+      f.write(b"1" if high else b"0")
+  except Exception as e:
+    print(f"Failed to set gpio {pin} value: {e}")
+
+def gpio_read(pin: int) -> bool | None:
+  val = None
+  try:
+    with open(f"/sys/class/gpio/gpio{pin}/value", 'rb') as f:
+      val = bool(int(f.read().strip()))
+  except Exception as e:
+    print(f"Failed to set gpio {pin} value: {e}")
+
+  return val
+
+def gpio_export(pin: int) -> None:
+  if os.path.isdir(f"/sys/class/gpio/gpio{pin}"):
+    return
+
+  try:
+    with open("/sys/class/gpio/export", 'w') as f:
+      f.write(str(pin))
+  except Exception:
+    print(f"Failed to export gpio {pin}")
+
+@cache
+def get_irq_action(irq: int) -> list[str]:
+  try:
+    with open(f"/sys/kernel/irq/{irq}/actions") as f:
+      actions = f.read().strip().split(',')
+      return actions
+  except FileNotFoundError:
+    return []
+
+def get_irqs_for_action(action: str) -> list[str]:
+  ret = []
+  with open("/proc/interrupts") as f:
+    for l in f.readlines():
+      irq = l.split(':')[0].strip()
+      if irq.isdigit() and action in get_irq_action(irq):
+        ret.append(irq)
+  return ret
+
+# *** gpiochip ***
+
+class gpioevent_data(ctypes.Structure):
+  _fields_ = [
+    ("timestamp", ctypes.c_uint64),
+    ("id", ctypes.c_uint32),
+  ]
+
+class gpioevent_request(ctypes.Structure):
+  _fields_ = [
+    ("lineoffset", ctypes.c_uint32),
+    ("handleflags", ctypes.c_uint32),
+    ("eventflags", ctypes.c_uint32),
+    ("label", ctypes.c_char * 32),
+    ("fd", ctypes.c_int)
+  ]
+
+def gpiochip_get_ro_value_fd(label: str, gpiochip_id: int, pin: int) -> int:
+  GPIOEVENT_REQUEST_BOTH_EDGES = 0x3
+  GPIOHANDLE_REQUEST_INPUT = 0x1
+  GPIO_GET_LINEEVENT_IOCTL = 0xc030b404
+
+  rq = gpioevent_request()
+  rq.lineoffset = pin
+  rq.handleflags = GPIOHANDLE_REQUEST_INPUT
+  rq.eventflags = GPIOEVENT_REQUEST_BOTH_EDGES
+  rq.label = label.encode('utf-8')[:31] + b'\0'
+
+  fd = os.open(f"/dev/gpiochip{gpiochip_id}", os.O_RDONLY)
+  fcntl.ioctl(fd, GPIO_GET_LINEEVENT_IOCTL, rq)
+  os.close(fd)
+  return int(rq.fd)

artifacts/iqpilot_hephaestusd_private/python/_iqclosure/iqpilot/common/i2c.py

@@ -0,0 +1,81 @@
+import os
+import fcntl
+import ctypes
+
+# I2C constants from /usr/include/linux/i2c-dev.h
+I2C_SLAVE = 0x0703
+I2C_SLAVE_FORCE = 0x0706
+I2C_SMBUS = 0x0720
+
+# SMBus transfer types
+I2C_SMBUS_READ = 1
+I2C_SMBUS_WRITE = 0
+I2C_SMBUS_BYTE_DATA = 2
+I2C_SMBUS_I2C_BLOCK_DATA = 8
+
+I2C_SMBUS_BLOCK_MAX = 32
+
+
+class _I2cSmbusData(ctypes.Union):
+  _fields_ = [
+    ("byte", ctypes.c_uint8),
+    ("word", ctypes.c_uint16),
+    ("block", ctypes.c_uint8 * (I2C_SMBUS_BLOCK_MAX + 2)),
+  ]
+
+
+class _I2cSmbusIoctlData(ctypes.Structure):
+  _fields_ = [
+    ("read_write", ctypes.c_uint8),
+    ("command", ctypes.c_uint8),
+    ("size", ctypes.c_uint32),
+    ("data", ctypes.POINTER(_I2cSmbusData)),
+  ]
+
+
+class SMBus:
+  def __init__(self, bus: int):
+    self._fd = os.open(f'/dev/i2c-{bus}', os.O_RDWR)
+
+  def __enter__(self) -> 'SMBus':
+    return self
+
+  def __exit__(self, *args) -> None:
+    self.close()
+
+  def close(self) -> None:
+    if hasattr(self, '_fd') and self._fd >= 0:
+      os.close(self._fd)
+      self._fd = -1
+
+  def _set_address(self, addr: int, force: bool = False) -> None:
+    ioctl_arg = I2C_SLAVE_FORCE if force else I2C_SLAVE
+    fcntl.ioctl(self._fd, ioctl_arg, addr)
+
+  def _smbus_access(self, read_write: int, command: int, size: int, data: _I2cSmbusData) -> None:
+    ioctl_data = _I2cSmbusIoctlData(read_write, command, size, ctypes.pointer(data))
+    fcntl.ioctl(self._fd, I2C_SMBUS, ioctl_data)
+
+  def read_byte_data(self, addr: int, register: int, force: bool = False) -> int:
+    self._set_address(addr, force)
+    data = _I2cSmbusData()
+    self._smbus_access(I2C_SMBUS_READ, register, I2C_SMBUS_BYTE_DATA, data)
+    return int(data.byte)
+
+  def write_byte_data(self, addr: int, register: int, value: int, force: bool = False) -> None:
+    self._set_address(addr, force)
+    data = _I2cSmbusData()
+    data.byte = value & 0xFF
+    self._smbus_access(I2C_SMBUS_WRITE, register, I2C_SMBUS_BYTE_DATA, data)
+
+  def read_i2c_block_data(self, addr: int, register: int, length: int, force: bool = False) -> list[int]:
+    self._set_address(addr, force)
+    if not (0 <= length <= I2C_SMBUS_BLOCK_MAX):
+      raise ValueError(f"length must be 0..{I2C_SMBUS_BLOCK_MAX}")
+
+    data = _I2cSmbusData()
+    data.block[0] = length
+    self._smbus_access(I2C_SMBUS_READ, register, I2C_SMBUS_I2C_BLOCK_DATA, data)
+    read_len = int(data.block[0]) or length
+    read_len = min(read_len, length)
+    return [int(b) for b in data.block[1 : read_len + 1]]

artifacts/iqpilot_hephaestusd_private/python/_iqclosure/iqpilot/common/issue_debug.py

@@ -0,0 +1,44 @@
+import os
+import threading
+import time
+from datetime import datetime
+from pathlib import Path
+
+from iqpilot.system.hardware import PC
+from iqpilot.system.hardware.hw import Paths
+
+
+DEBUG_FILENAME = "iqpilot_issue_debug.txt"
+DEBUG_PATH = Path(Paths.comma_home()) / "community" / DEBUG_FILENAME if PC else Path("/data/community") / DEBUG_FILENAME
+
+_lock = threading.Lock()
+_last_log_times: dict[str, float] = {}
+
+
+def log_issue(tag: str, message: str) -> None:
+  try:
+    DEBUG_PATH.parent.mkdir(parents=True, exist_ok=True)
+    with _lock:
+      with open(DEBUG_PATH, "a", encoding="utf-8") as f:
+        timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S.%f")[:-3]
+        f.write(f"[{timestamp}] [{tag}] {message}\n")
+  except OSError:
+    pass
+
+
+def log_issue_limited(key: str, tag: str, message: str, interval_sec: float = 1.0) -> None:
+  now = time.monotonic()
+  with _lock:
+    last = _last_log_times.get(key, 0.0)
+    if now - last < interval_sec:
+      return
+    _last_log_times[key] = now
+
+  log_issue(tag, message)
+
+
+def clear_issue_debug_log() -> None:
+  try:
+    os.remove(DEBUG_PATH)
+  except OSError:
+    pass

artifacts/iqpilot_hephaestusd_private/python/_iqclosure/iqpilot/common/logging_extra.py

@@ -0,0 +1,249 @@
+import io
+import os
+import sys
+import copy
+import json
+import time
+import uuid
+import socket
+import logging
+import traceback
+import numpy as np
+from threading import local
+from collections import OrderedDict
+from contextlib import contextmanager
+
+LOG_TIMESTAMPS = "LOG_TIMESTAMPS" in os.environ
+
+def json_handler(obj):
+  if isinstance(obj, np.bool_):
+    return bool(obj)
+  # if isinstance(obj, (datetime.date, datetime.time)):
+  #   return obj.isoformat()
+  return repr(obj)
+
+def json_robust_dumps(obj):
+  return json.dumps(obj, default=json_handler)
+
+class NiceOrderedDict(OrderedDict):
+  def __str__(self):
+    return json_robust_dumps(self)
+
+class SwagFormatter(logging.Formatter):
+  def __init__(self, swaglogger):
+    logging.Formatter.__init__(self, None, '%a %b %d %H:%M:%S %Z %Y')
+
+    self.swaglogger = swaglogger
+    self.host = socket.gethostname()
+
+  def format_dict(self, record):
+    record_dict = NiceOrderedDict()
+
+    if isinstance(record.msg, dict):
+      record_dict['msg'] = record.msg
+    else:
+      try:
+        record_dict['msg'] = record.getMessage()
+      except (ValueError, TypeError):
+        record_dict['msg'] = [record.msg]+record.args
+
+    record_dict['ctx'] = self.swaglogger.get_ctx()
+
+    if record.exc_info:
+      record_dict['exc_info'] = self.formatException(record.exc_info)
+
+    record_dict['level'] = record.levelname
+    record_dict['levelnum'] = record.levelno
+    record_dict['name'] = record.name
+    record_dict['filename'] = record.filename
+    record_dict['lineno'] = record.lineno
+    record_dict['pathname'] = record.pathname
+    record_dict['module'] = record.module
+    record_dict['funcName'] = record.funcName
+    record_dict['host'] = self.host
+    record_dict['process'] = record.process
+    record_dict['thread'] = record.thread
+    record_dict['threadName'] = record.threadName
+    record_dict['created'] = record.created
+
+    return record_dict
+
+  def format(self, record):
+    if self.swaglogger is None:
+      raise Exception("must set swaglogger before calling format()")
+    return json_robust_dumps(self.format_dict(record))
+
+class SwagLogFileFormatter(SwagFormatter):
+  def fix_kv(self, k, v):
+    # append type to names to preserve legacy naming in logs
+    # avoids overlapping key namespaces with different types
+    # e.g. log.info() creates 'msg' -> 'msg$s'
+    #      log.event() creates 'msg.health.logMonoTime' -> 'msg.health.logMonoTime$i'
+    #      because overlapping namespace 'msg' caused problems
+    if isinstance(v, (str, bytes)):
+      k += "$s"
+    elif isinstance(v, float):
+      k += "$f"
+    elif isinstance(v, bool):
+      k += "$b"
+    elif isinstance(v, int):
+      k += "$i"
+    elif isinstance(v, dict):
+      nv = {}
+      for ik, iv in v.items():
+        ik, iv = self.fix_kv(ik, iv)
+        nv[ik] = iv
+      v = nv
+    elif isinstance(v, list):
+      k += "$a"
+    return k, v
+
+  def format(self, record):
+    if isinstance(record, str):
+      v = json.loads(record)
+    else:
+      v = self.format_dict(record)
+
+    mk, mv = self.fix_kv('msg', v['msg'])
+    del v['msg']
+    v[mk] = mv
+    v['id'] = uuid.uuid4().hex
+
+    return json_robust_dumps(v)
+
+class SwagErrorFilter(logging.Filter):
+  def filter(self, record):
+    return record.levelno < logging.ERROR
+
+def _tmpfunc():
+  return 0
+
+def _srcfile():
+  return os.path.normcase(_tmpfunc.__code__.co_filename)
+
+class SwagLogger(logging.Logger):
+  def __init__(self):
+    logging.Logger.__init__(self, "swaglog")
+
+    self.global_ctx = {}
+
+    self.log_local = local()
+    self.log_local.ctx = {}
+
+  def local_ctx(self):
+    try:
+      return self.log_local.ctx
+    except AttributeError:
+      self.log_local.ctx = {}
+      return self.log_local.ctx
+
+  def get_ctx(self):
+    return dict(self.local_ctx(), **self.global_ctx)
+
+  @contextmanager
+  def ctx(self, **kwargs):
+    old_ctx = self.local_ctx()
+    self.log_local.ctx = copy.copy(old_ctx) or {}
+    self.log_local.ctx.update(kwargs)
+    try:
+      yield
+    finally:
+      self.log_local.ctx = old_ctx
+
+  def bind(self, **kwargs):
+    self.local_ctx().update(kwargs)
+
+  def bind_global(self, **kwargs):
+    self.global_ctx.update(kwargs)
+
+  def event(self, event, *args, **kwargs):
+    evt = NiceOrderedDict()
+    evt['event'] = event
+    if args:
+      evt['args'] = args
+    evt.update(kwargs)
+    if 'error' in kwargs:
+      self.error(evt)
+    elif 'debug' in kwargs:
+      self.debug(evt)
+    else:
+      self.info(evt)
+
+  def timestamp(self, event_name):
+    if LOG_TIMESTAMPS:
+      t = time.monotonic()
+      tstp = NiceOrderedDict()
+      tstp['timestamp'] = NiceOrderedDict()
+      tstp['timestamp']["event"] = event_name
+      tstp['timestamp']["time"] = t*1e9
+      self.debug(tstp)
+
+  def findCaller(self, stack_info=False, stacklevel=1):
+    """
+    Find the stack frame of the caller so that we can note the source
+    file name, line number and function name.
+    """
+    f = sys._getframe(3)
+    #On some versions of IronPython, currentframe() returns None if
+    #IronPython isn't run with -X:Frames.
+    if f is not None:
+      f = f.f_back
+    orig_f = f
+    while f and stacklevel > 1:
+      f = f.f_back
+      stacklevel -= 1
+    if not f:
+      f = orig_f
+    rv = "(unknown file)", 0, "(unknown function)", None
+    while hasattr(f, "f_code"):
+      co = f.f_code
+      filename = os.path.normcase(co.co_filename)
+
+      if filename == _srcfile:
+        f = f.f_back
+        continue
+      sinfo = None
+      if stack_info:
+        sio = io.StringIO()
+        sio.write('Stack (most recent call last):\n')
+        traceback.print_stack(f, file=sio)
+        sinfo = sio.getvalue()
+        if sinfo[-1] == '\n':
+          sinfo = sinfo[:-1]
+        sio.close()
+      rv = (co.co_filename, f.f_lineno, co.co_name, sinfo)
+      break
+    return rv
+
+if __name__ == "__main__":
+  log = SwagLogger()
+
+  stdout_handler = logging.StreamHandler(sys.stdout)
+  stdout_handler.setLevel(logging.INFO)
+  stdout_handler.addFilter(SwagErrorFilter())
+  log.addHandler(stdout_handler)
+
+  stderr_handler = logging.StreamHandler(sys.stderr)
+  stderr_handler.setLevel(logging.ERROR)
+  log.addHandler(stderr_handler)
+
+  log.info("asdasd %s", "a")
+  log.info({'wut': 1})
+  log.warning("warning")
+  log.error("error")
+  log.critical("critical")
+  log.event("test", x="y")
+
+  with log.ctx():
+    stdout_handler.setFormatter(SwagFormatter(log))
+    stderr_handler.setFormatter(SwagFormatter(log))
+    log.bind(user="some user")
+    log.info("in req")
+    print("")
+    log.warning("warning")
+    print("")
+    log.error("error")
+    print("")
+    log.critical("critical")
+    print("")
+    log.event("do_req", a=1, b="c")

artifacts/iqpilot_hephaestusd_private/python/_iqclosure/iqpilot/common/realtime.py

@@ -0,0 +1,128 @@
+"""Utilities for reading real time clocks and keeping soft real time constraints."""
+import gc
+import os
+import sys
+import time
+
+from setproctitle import getproctitle
+
+from iqpilot.common.utils import MovingAverage
+from iqpilot.system.hardware import PC
+
+
+# time step for each process
+DT_CTRL = 0.01  # controlsd
+DT_MDL = 0.05  # model
+DT_HW = 0.5  # hardwared and manager
+DT_DMON = 0.05  # driver monitoring
+
+
+class Priority:
+  # CORE 2
+  # - modeld = 55
+  # - camerad = 54
+  CTRL_LOW = 51 # plannerd & radard
+
+  # CORE 3
+  # - pandad = 55
+  CTRL_HIGH = 53
+
+
+def set_core_affinity(cores: list[int]) -> None:
+  if sys.platform == 'linux' and not PC:
+    os.sched_setaffinity(0, cores)
+
+
+def config_realtime_process(cores: int | list[int], priority: int) -> None:
+  gc.disable()
+  if sys.platform == 'linux' and not PC:
+    os.sched_setscheduler(0, os.SCHED_FIFO, os.sched_param(priority))
+  c = cores if isinstance(cores, list) else [cores, ]
+  set_core_affinity(c)
+
+
+def lock_memory() -> None:
+  """mlockall this process so memory reclaim/compaction can't stall it. RT control
+  procs only (locking ui/modeld would worsen pressure). Best-effort."""
+  if sys.platform != 'linux' or PC:
+    return
+  try:
+    import ctypes
+    import resource
+    resource.setrlimit(resource.RLIMIT_MEMLOCK, (resource.RLIM_INFINITY, resource.RLIM_INFINITY))
+    MCL_CURRENT, MCL_FUTURE = 0x1, 0x2
+    libc = ctypes.CDLL("libc.so.6", use_errno=True)
+    if libc.mlockall(MCL_CURRENT | MCL_FUTURE) != 0:
+      raise OSError(ctypes.get_errno(), os.strerror(ctypes.get_errno()))
+  except Exception as e:
+    try:
+      from iqpilot.common.swaglog import cloudlog
+      cloudlog.warning(f"lock_memory (mlockall) failed: {e}")
+    except Exception:
+      pass
+
+
+class Ratekeeper:
+  def __init__(self, rate: float, print_delay_threshold: float | None = 0.0) -> None:
+    """Rate in Hz for ratekeeping. print_delay_threshold must be nonnegative."""
+    self._interval = 1. / rate
+    self._print_delay_threshold = print_delay_threshold
+    self._frame = 0
+    self._remaining = 0.0
+    self._process_name = getproctitle()
+    self._last_monitor_time = -1.
+    self._next_frame_time = -1.
+
+    self.avg_dt = MovingAverage(100)
+    self.avg_dt.add_value(self._interval)
+
+  def reset(self) -> None:
+    self._remaining = 0.0
+    self._last_monitor_time = -1.
+    self._next_frame_time = -1.
+    self.avg_dt = MovingAverage(100)
+    self.avg_dt.add_value(self._interval)
+
+  @property
+  def frame(self) -> int:
+    return self._frame
+
+  @property
+  def remaining(self) -> float:
+    return self._remaining
+
+  @property
+  def lag(self) -> float:
+    return max(0., -self._remaining)
+
+  @property
+  def lagging(self) -> bool:
+    expected_dt = self._interval * (1 / 0.9)
+    return self.avg_dt.get_average() > expected_dt
+
+  # Maintain loop rate by calling this at the end of each loop
+  def keep_time(self) -> bool:
+    lagged = self.monitor_time()
+    if self._remaining > 0:
+      time.sleep(self._remaining)
+    return lagged
+
+  # Monitors the cumulative lag, but does not enforce a rate
+  def monitor_time(self) -> bool:
+    if self._last_monitor_time < 0:
+      self._next_frame_time = time.monotonic() + self._interval
+      self._last_monitor_time = time.monotonic()
+
+    prev = self._last_monitor_time
+    self._last_monitor_time = time.monotonic()
+    self.avg_dt.add_value(self._last_monitor_time - prev)
+
+    lagged = False
+    remaining = self._next_frame_time - time.monotonic()
+    self._next_frame_time += self._interval
+    if self._print_delay_threshold is not None and remaining < -self._print_delay_threshold:
+      print(f"{self._process_name} lagging by {-remaining * 1000:.2f} ms")
+      lagged = True
+    self._frame += 1
+    self._remaining = remaining
+    return lagged

artifacts/iqpilot_hephaestusd_private/python/_iqclosure/iqpilot/common/spinner.py

@@ -0,0 +1,52 @@
+import os
+import subprocess
+from iqpilot.common.basedir import BASEDIR
+
+
+class Spinner:
+  def __init__(self):
+    try:
+      self.spinner_proc = subprocess.Popen(["./spinner.py"],
+                                           stdin=subprocess.PIPE,
+                                           cwd=os.path.join(BASEDIR, "iqpilot", "system", "ui"),
+                                           close_fds=True)
+    except OSError:
+      self.spinner_proc = None
+
+  def __enter__(self):
+    return self
+
+  def update(self, spinner_text: str):
+    if self.spinner_proc is not None:
+      self.spinner_proc.stdin.write(spinner_text.encode('utf8') + b"\n")
+      try:
+        self.spinner_proc.stdin.flush()
+      except BrokenPipeError:
+        pass
+
+  def update_progress(self, cur: float, total: float):
+    self.update(str(round(100 * cur / total)))
+
+  def close(self):
+    if self.spinner_proc is not None:
+      self.spinner_proc.kill()
+      try:
+        self.spinner_proc.communicate(timeout=2.)
+      except subprocess.TimeoutExpired:
+        print("WARNING: failed to kill spinner")
+      self.spinner_proc = None
+
+  def __del__(self):
+    self.close()
+
+  def __exit__(self, exc_type, exc_value, traceback):
+    self.close()
+
+
+if __name__ == "__main__":
+  import time
+  with Spinner() as s:
+    s.update("Spinner text")
+    time.sleep(5.0)
+  print("gone")
+  time.sleep(5.0)

artifacts/iqpilot_hephaestusd_private/python/_iqclosure/iqpilot/common/swaglog.py

@@ -0,0 +1,165 @@
+import logging
+import os
+import sys
+import time
+import warnings
+from pathlib import Path
+from logging.handlers import BaseRotatingHandler
+
+import zmq
+
+from iqpilot.common.logging_extra import SwagLogger, SwagFormatter, SwagLogFileFormatter
+from iqpilot.system.hardware.hw import Paths
+
+
+def get_file_handler():
+  Path(Paths.swaglog_root()).mkdir(parents=True, exist_ok=True)
+  base_filename = os.path.join(Paths.swaglog_root(), "swaglog")
+  handler = SwaglogRotatingFileHandler(base_filename)
+  return handler
+
+class SwaglogRotatingFileHandler(BaseRotatingHandler):
+  def __init__(self, base_filename, interval=60, max_bytes=1024*256, backup_count=2500, encoding=None):
+    super().__init__(base_filename, mode="a", encoding=encoding, delay=True)
+    self.base_filename = base_filename
+    self.interval = interval # seconds
+    self.max_bytes = max_bytes
+    self.backup_count = backup_count
+    self.log_files = self.get_existing_logfiles()
+    log_indexes = [f.split(".")[-1] for f in self.log_files]
+    self.last_file_idx = max([int(i) for i in log_indexes if i.isdigit()] or [-1])
+    self.last_rollover = None
+    self.doRollover()
+
+  def _open(self):
+    self.last_rollover = time.monotonic()
+    self.last_file_idx += 1
+    next_filename = f"{self.base_filename}.{self.last_file_idx:010}"
+    stream = open(next_filename, self.mode, encoding=self.encoding)
+    self.log_files.insert(0, next_filename)
+    return stream
+
+  def get_existing_logfiles(self):
+    log_files = list()
+    base_dir = os.path.dirname(self.base_filename)
+    for fn in os.listdir(base_dir):
+      fp = os.path.join(base_dir, fn)
+      if fp.startswith(self.base_filename) and os.path.isfile(fp):
+        log_files.append(fp)
+    return sorted(log_files)
+
+  def shouldRollover(self, record):
+    size_exceeded = self.max_bytes > 0 and self.stream.tell() >= self.max_bytes
+    time_exceeded = self.interval > 0 and self.last_rollover + self.interval <= time.monotonic()
+    return size_exceeded or time_exceeded
+
+  def doRollover(self):
+    if self.stream:
+      self.stream.close()
+    self.stream = self._open()
+
+    if self.backup_count > 0:
+      while len(self.log_files) > self.backup_count:
+        to_delete = self.log_files.pop()
+        if os.path.exists(to_delete): # just being safe, should always exist
+          os.remove(to_delete)
+
+class UnixDomainSocketHandler(logging.Handler):
+  def __init__(self, formatter):
+    logging.Handler.__init__(self)
+    self.setFormatter(formatter)
+    self.pid = None
+
+    self.zctx = None
+    self.sock = None
+
+  def __del__(self):
+    self.close()
+
+  def close(self):
+    if self.sock is not None:
+      self.sock.close()
+    if self.zctx is not None:
+      self.zctx.term()
+
+  def connect(self):
+    self.zctx = zmq.Context()
+    self.sock = self.zctx.socket(zmq.PUSH)
+    self.sock.setsockopt(zmq.LINGER, 10)
+    self.sock.connect(Paths.swaglog_ipc())
+    self.pid = os.getpid()
+
+  def emit(self, record):
+    if os.getpid() != self.pid:
+      # TODO suppresses warning about forking proc with zmq socket, fix root cause
+      warnings.filterwarnings("ignore", category=ResourceWarning, message="unclosed.*<zmq.*>")
+      self.connect()
+
+    msg = self.format(record).rstrip('\n')
+    # print("SEND".format(repr(msg)))
+    try:
+      s = chr(record.levelno)+msg
+      self.sock.send(s.encode('utf8'), zmq.NOBLOCK)
+    except zmq.error.Again:
+      # drop :/
+      pass
+
+
+class ForwardingHandler(logging.Handler):
+  def __init__(self, target_logger):
+    super().__init__()
+    self.target_logger = target_logger
+
+  def emit(self, record):
+    self.target_logger.handle(record)
+
+
+def add_file_handler(log):
+  """
+  Function to add the file log handler to swaglog.
+  This can be used to store logs when logmessaged is not running.
+  """
+  handler = get_file_handler()
+  handler.setFormatter(SwagLogFileFormatter(log))
+  log.addHandler(handler)
+
+
+cloudlog = log = SwagLogger()
+log.setLevel(logging.DEBUG)
+
+
+class PrettyConsoleFormatter(logging.Formatter):
+  # StreamHandler writes to stderr, so tty-gate on that
+  _COLOR = sys.stderr.isatty() and os.environ.get('NO_COLOR') is None
+
+  def format(self, record):
+    msg = record.getMessage()
+    if not self._COLOR:
+      return f"{record.filename}: {msg}"
+    lvl = record.levelno
+    if   lvl >= 50: lc, ln = "\033[1;38;5;196m", "CRIT"
+    elif lvl >= 40: lc, ln = "\033[1;38;5;203m", " ERR"
+    elif lvl >= 30: lc, ln = "\033[38;5;214m", "WARN"
+    elif lvl >= 20: lc, ln = "\033[38;5;110m", "info"
+    else:           lc, ln = "\033[38;5;244m", " dbg"
+    body = f"\033[1;38;5;210m{msg}\033[0m" if lvl >= 40 else msg
+    src = "" if record.filename == "(unknown file)" else f"\033[2m{record.filename}\033[0m  "
+    return f"{lc}{ln:>4}\033[0m  {src}{body}"
+
+
+outhandler = logging.StreamHandler()
+outhandler.setFormatter(PrettyConsoleFormatter())
+
+print_level = os.environ.get('LOGPRINT', 'warning')
+if print_level == 'debug':
+  outhandler.setLevel(logging.DEBUG)
+elif print_level == 'info':
+  outhandler.setLevel(logging.INFO)
+elif print_level == 'warning':
+  outhandler.setLevel(logging.WARNING)
+
+ipchandler = UnixDomainSocketHandler(SwagFormatter(log))
+
+log.addHandler(outhandler)
+# logs are sent through IPC before writing to disk to prevent disk I/O blocking
+log.addHandler(ipchandler)

artifacts/iqpilot_hephaestusd_private/python/_iqclosure/iqpilot/common/time_helpers.py

@@ -0,0 +1,15 @@
+import datetime
+from pathlib import Path
+
+MIN_DATE = datetime.datetime(year=2025, month=2, day=21)
+
+def min_date():
+  # on systemd systems, the default time is the systemd build time
+  systemd_path = Path("/lib/systemd/systemd")
+  if systemd_path.exists():
+    d = datetime.datetime.fromtimestamp(systemd_path.stat().st_mtime)
+    return max(MIN_DATE, d + datetime.timedelta(days=1))
+  return MIN_DATE
+
+def system_time_valid():
+  return datetime.datetime.now() > min_date()

artifacts/iqpilot_hephaestusd_private/python/_iqclosure/iqpilot/common/utils.py

@@ -0,0 +1,271 @@
+import io
+import os
+import tempfile
+import contextlib
+import subprocess
+import time
+import functools
+from subprocess import Popen, PIPE, TimeoutExpired
+import zstandard as zstd
+
+LOG_COMPRESSION_LEVEL = 10  # little benefit up to level 15. level ~17 is a small step change
+
+class Timer:
+  """Simple lap timer for profiling sequential operations."""
+
+  def __init__(self):
+    self._start = self._lap = time.monotonic()
+    self._sections = {}
+
+  def lap(self, name):
+    now = time.monotonic()
+    self._sections[name] = now - self._lap
+    self._lap = now
+
+  @property
+  def total(self):
+    return time.monotonic() - self._start
+
+  def fmt(self, duration):
+    parts = ", ".join(f"{k}={v:.2f}s" + (f" ({duration/v:.0f}x)" if k == 'render' and v > 0 else "") for k, v in self._sections.items())
+    total = self.total
+    realtime = f"{duration/total:.1f}x realtime" if total > 0 else "N/A"
+    return f"{duration}s in {total:.1f}s ({realtime}) | {parts}"
+
+def sudo_write(val: str, path: str) -> None:
+  try:
+    with open(path, 'w') as f:
+      f.write(str(val))
+  except PermissionError:
+    os.system(f"sudo chmod a+w {path}")
+    try:
+      with open(path, 'w') as f:
+        f.write(str(val))
+    except PermissionError:
+      # fallback for debugfs files
+      os.system(f"sudo su -c 'echo {val} > {path}'")
+
+
+def sudo_read(path: str) -> str:
+  try:
+    return subprocess.check_output(f"sudo cat {path}", shell=True, encoding='utf8').strip()
+  except Exception:
+    return ""
+
+
+class MovingAverage:
+  def __init__(self, window_size: int):
+    self.window_size: int = window_size
+    self.buffer: list[float] = [0.0] * window_size
+    self.index: int = 0
+    self.count: int = 0
+    self.sum: float = 0.0
+
+  def add_value(self, new_value: float):
+    # Update the sum: subtract the value being replaced and add the new value
+    self.sum -= self.buffer[self.index]
+    self.buffer[self.index] = new_value
+    self.sum += new_value
+
+    # Update the index in a circular manner
+    self.index = (self.index + 1) % self.window_size
+
+    # Track the number of added values (for partial windows)
+    self.count = min(self.count + 1, self.window_size)
+
+  def get_average(self) -> float:
+    if self.count == 0:
+      return float('nan')
+    return self.sum / self.count
+
+
+class CallbackReader:
+  """Wraps a file, but overrides the read method to also
+  call a callback function with the number of bytes read so far."""
+
+  def __init__(self, f, callback, *args):
+    self.f = f
+    self.callback = callback
+    self.cb_args = args
+    self.total_read = 0
+
+  def __getattr__(self, attr):
+    return getattr(self.f, attr)
+
+  def read(self, *args, **kwargs):
+    chunk = self.f.read(*args, **kwargs)
+    self.total_read += len(chunk)
+    self.callback(*self.cb_args, self.total_read)
+    return chunk
+
+
+@contextlib.contextmanager
+def atomic_write(path: str, mode: str = 'w', buffering: int = -1, encoding: str | None = None, newline: str | None = None,
+                 overwrite: bool = False):
+  """Write to a file atomically using a temporary file in the same directory as the destination file."""
+  dir_name = os.path.dirname(path)
+
+  if not overwrite and os.path.exists(path):
+    raise FileExistsError(f"File '{path}' already exists. To overwrite it, set 'overwrite' to True.")
+
+  with tempfile.NamedTemporaryFile(mode=mode, buffering=buffering, encoding=encoding, newline=newline, dir=dir_name, delete=False) as tmp_file:
+    yield tmp_file
+    tmp_file_name = tmp_file.name
+  os.replace(tmp_file_name, path)
+
+
+def get_upload_stream(filepath: str, should_compress: bool) -> tuple[io.BufferedIOBase, int]:
+  if not should_compress:
+    file_size = os.path.getsize(filepath)
+    file_stream = open(filepath, "rb")
+    return file_stream, file_size
+
+  # Compress the file on the fly
+  compressed_stream = io.BytesIO()
+  compressor = zstd.ZstdCompressor(level=LOG_COMPRESSION_LEVEL)
+
+  with open(filepath, "rb") as f:
+    compressor.copy_stream(f, compressed_stream)
+    compressed_size = compressed_stream.tell()
+    compressed_stream.seek(0)
+    return compressed_stream, compressed_size
+
+
+# remove all keys that end in DEPRECATED
+def strip_deprecated_keys(d):
+  for k in list(d.keys()):
+    if isinstance(k, str):
+      if k.endswith('DEPRECATED'):
+        d.pop(k)
+      elif isinstance(d[k], dict):
+        strip_deprecated_keys(d[k])
+  return d
+
+
+def run_cmd(cmd: list[str], cwd=None, env=None) -> str:
+  return subprocess.check_output(cmd, encoding='utf8', cwd=cwd, env=env).strip()
+
+
+def run_cmd_default(cmd: list[str], default: str = "", cwd=None, env=None) -> str:
+  try:
+    return run_cmd(cmd, cwd=cwd, env=env)
+  except subprocess.CalledProcessError:
+    return default
+
+
+@contextlib.contextmanager
+def managed_proc(cmd: list[str], env: dict[str, str]):
+  proc = Popen(cmd, env=env, stdout=PIPE, stderr=PIPE)
+  try:
+    yield proc
+  finally:
+    if proc.poll() is None:
+      proc.terminate()
+    try:
+      proc.wait(timeout=5)
+    except TimeoutExpired:
+      proc.kill()
+
+
+def tabulate(tabular_data, headers=(), tablefmt="simple", floatfmt="g", stralign="left", numalign=None):
+  rows = [list(row) for row in tabular_data]
+
+  def fmt(val):
+    if isinstance(val, str):
+      return val
+    if isinstance(val, (bool, int)):
+      return str(val)
+    try:
+      return format(val, floatfmt)
+    except (TypeError, ValueError):
+      return str(val)
+
+  formatted = [[fmt(c) for c in row] for row in rows]
+  hdrs = [str(h) for h in headers] if headers else None
+
+  ncols = max((len(r) for r in formatted), default=0)
+  if hdrs:
+    ncols = max(ncols, len(hdrs))
+  if ncols == 0:
+    return ""
+
+  for r in formatted:
+    r.extend([""] * (ncols - len(r)))
+  if hdrs:
+    hdrs.extend([""] * (ncols - len(hdrs)))
+
+  widths = [0] * ncols
+  if hdrs:
+    for i in range(ncols):
+      widths[i] = len(hdrs[i])
+  for row in formatted:
+    for i in range(ncols):
+      widths[i] = max(widths[i], max(len(ln) for ln in row[i].split('\n')))
+
+  def _align(s, w):
+    if stralign == "center":
+      return s.center(w)
+    return s.ljust(w)
+
+  if tablefmt == "html":
+    parts = ["<table>"]
+    if hdrs:
+      parts.append("<thead>")
+      parts.append("<tr>" + "".join(f"<th>{h}</th>" for h in hdrs) + "</tr>")
+      parts.append("</thead>")
+    parts.append("<tbody>")
+    for row in formatted:
+      parts.append("<tr>" + "".join(f"<td>{c}</td>" for c in row) + "</tr>")
+    parts.append("</tbody>")
+    parts.append("</table>")
+    return "\n".join(parts)
+
+  if tablefmt == "simple_grid":
+    def _sep(left, mid, right):
+      return left + mid.join("─" * (w + 2) for w in widths) + right
+
+    top, mid_sep, bot = _sep("┌", "┬", "┐"), _sep("├", "┼", "┤"), _sep("└", "┴", "┘")
+
+    def _fmt_row(cells):
+      split = [c.split('\n') for c in cells]
+      nlines = max(len(s) for s in split)
+      for s in split:
+        s.extend([""] * (nlines - len(s)))
+      return ["│" + "│".join(f" {_align(split[i][li], widths[i])} " for i in range(ncols)) + "│" for li in range(nlines)]
+
+    lines = [top]
+    if hdrs:
+      lines.extend(_fmt_row(hdrs))
+      lines.append(mid_sep)
+    for ri, row in enumerate(formatted):
+      lines.extend(_fmt_row(row))
+      lines.append(mid_sep if ri < len(formatted) - 1 else bot)
+    return "\n".join(lines)
+
+  gap = "  "
+  lines = []
+  if hdrs:
+    lines.append(gap.join(h.ljust(w) for h, w in zip(hdrs, widths, strict=True)))
+    lines.append(gap.join("-" * w for w in widths))
+  for row in formatted:
+    lines.append(gap.join(_align(row[i], widths[i]) for i in range(ncols)))
+  return "\n".join(lines)
+
+
+def retry(attempts=3, delay=1.0, ignore_failure=False):
+  def decorator(func):
+    @functools.wraps(func)
+    def wrapper(*args, **kwargs):
+      for _ in range(attempts):
+        try:
+          return func(*args, **kwargs)
+        except Exception:
+          print(f"{func.__name__} failed, trying again")
+          time.sleep(delay)
+
+      if ignore_failure:
+        print(f"{func.__name__} failed after retry")
+      else:
+        raise Exception(f"{func.__name__} failed after retry")
+    return wrapper
+  return decorator

artifacts/iqpilot_hephaestusd_private/python/_iqclosure/iqpilot/common/version.py

@@ -0,0 +1,5 @@
+from iqpilot.common.git import get_normalized_origin
+
+
+def get_version() -> str:
+  return "IQ.Pilot 1.0c"

artifacts/iqpilot_hephaestusd_private/python/_iqclosure/iqpilot/konn3kt/cloud_client.py

@@ -0,0 +1,17 @@
+"""
+Copyright ©️ IQ.Lvbs, apart of Project Teal Lvbs, All Rights Reserved, licensed under https://konn3kt.com/tos
+"""
+
+
+import os
+from iqpilot.common.api.base import BaseApi
+API_HOST = os.getenv('KONN3KT_API_HOST', 'https://api-iqlabs.konn3kt.com')
+
+class Konn3ktApi(BaseApi):
+
+  def __init__(self, dongle_id):
+    super().__init__(dongle_id, API_HOST)
+    self.user_agent = "konn3kt-device-"
+
+  def get_token(self, expiry_hours=1):
+    return super()._get_token(expiry_hours=expiry_hours)

artifacts/iqpilot_hephaestusd_private/python/_iqclosure/iqpilot/konn3kt/registration.py

@@ -0,0 +1,226 @@
+#!/usr/bin/env python3
+import os
+import time
+import json
+import jwt
+import re
+import secrets
+from typing import cast
+from pathlib import Path
+
+from datetime import datetime, timedelta, UTC
+from iqpilot.common.api import api_get, get_key_pair
+from iqpilot.common.params import Params
+from iqpilot.common.spinner import Spinner
+from iqpilot.system.hardware import HARDWARE, PC
+from iqpilot.system.hardware.hw import Paths
+from iqpilot.common.swaglog import cloudlog
+
+
+UNREGISTERED_DONGLE_ID = "UnregisteredDevice"
+
+_DONGLE_ID_RE = re.compile(r"^[a-fA-F0-9]{16}$")
+IMEI_WAIT_TIMEOUT = 15.0
+
+
+def _read_persist_dongle_id() -> str | None:
+  p = Path(Paths.persist_root()) / "comma" / "dongle_id"
+  try:
+    if not p.is_file():
+      return None
+    s = p.read_text().strip()
+    return s or None
+  except Exception:
+    cloudlog.exception("failed to read persist dongle_id")
+    return None
+
+
+def get_cached_dongle_id(params: Params | None = None, prefer_readonly: bool = True) -> str | None:
+  ro = _read_persist_dongle_id()
+  if is_valid_dongle_id(ro):
+    ro = ro.lower()
+  if prefer_readonly and ro:
+    return ro
+  p = Params() if params is None else params
+  v = p.get("DongleId")
+  if v and v != UNREGISTERED_DONGLE_ID:
+    return v.lower() if is_valid_dongle_id(v) else v
+  return ro or None
+def is_valid_dongle_id(dongle_id: str | None) -> bool:
+  return bool(dongle_id and _DONGLE_ID_RE.fullmatch(dongle_id))
+def get_or_create_dongle_id(params: Params | None = None, prefer_readonly: bool = True) -> str:
+  p = Params() if params is None else params
+  dongle_id = get_cached_dongle_id(p, prefer_readonly=prefer_readonly)
+  if dongle_id and dongle_id != UNREGISTERED_DONGLE_ID:
+    return dongle_id
+  dongle_id = secrets.token_hex(8)
+  p.put("DongleId", dongle_id)
+  cloudlog.warning(f"generated new DongleId={dongle_id} (no readonly dongle_id found)")
+  return dongle_id
+def ensure_dev_pairing_identity(params: Params | None = None, force_reset: bool = False) -> dict[str, str]:
+  p = Params() if params is None else params
+
+  persist_dir = Path(Paths.persist_root()) / "comma"
+  persist_dir.mkdir(parents=True, exist_ok=True)
+
+  dongle_path = persist_dir / "dongle_id"
+  priv_path = persist_dir / "id_rsa"
+  pub_path = persist_dir / "id_rsa.pub"
+
+  if force_reset:
+    for fp in (dongle_path, priv_path, pub_path):
+      try:
+        fp.unlink(missing_ok=True)
+      except Exception:
+        cloudlog.exception(f"failed to remove {fp}")
+    try:
+      (persist_dir / "konn3kt_prime_type").unlink(missing_ok=True)
+    except Exception:
+      pass
+    try:
+      p.remove("PrimeType")
+    except Exception:
+      pass
+  forced_dongle = os.getenv("KONN3KT_DEV_DONGLE_ID")
+  dongle_id = forced_dongle.strip().lower() if forced_dongle else None
+  if dongle_id and not is_valid_dongle_id(dongle_id):
+    cloudlog.error("KONN3KT_DEV_DONGLE_ID must be 16 hex chars")
+    dongle_id = None
+  if dongle_id is None:
+    existing = None
+    try:
+      existing = dongle_path.read_text().strip().lower() if dongle_path.is_file() else None
+    except Exception:
+      cloudlog.exception("failed reading existing dev dongle_id")
+    dongle_id = existing if is_valid_dongle_id(existing) else secrets.token_hex(8)
+  try:
+    dongle_path.write_text(dongle_id)
+  except Exception:
+    cloudlog.exception("failed writing dev dongle_id")
+  p.put("DongleId", dongle_id)
+  p.put("HardwareSerial", p.get("HardwareSerial") or f"DEV-{dongle_id}")
+  if force_reset or (not priv_path.is_file()) or (not pub_path.is_file()):
+    try:
+      from cryptography.hazmat.primitives import serialization
+      from cryptography.hazmat.primitives.asymmetric import rsa
+      key = rsa.generate_private_key(public_exponent=65537, key_size=2048)
+      priv_bytes = key.private_bytes(
+        encoding=serialization.Encoding.PEM,
+        format=serialization.PrivateFormat.TraditionalOpenSSL,
+        encryption_algorithm=serialization.NoEncryption(),
+      )
+      pub_bytes = key.public_key().public_bytes(
+        encoding=serialization.Encoding.PEM,
+        format=serialization.PublicFormat.SubjectPublicKeyInfo,
+      )
+      priv_path.write_bytes(priv_bytes)
+      pub_path.write_bytes(pub_bytes)
+    except Exception:
+      cloudlog.exception("failed generating dev RSA keys")
+      raise
+  return {
+    "dongle_id": dongle_id,
+    "serial": p.get("HardwareSerial") or f"DEV-{dongle_id}",
+    "persist_dir": str(persist_dir),
+  }
+def is_registered_device() -> bool:
+  dongle = Params().get("DongleId")
+  return dongle not in (None, UNREGISTERED_DONGLE_ID)
+
+
+def _normalize_imei(value: str | None) -> str:
+  return value or ""
+
+
+def get_registration_identifiers(wait_timeout: float = IMEI_WAIT_TIMEOUT, show_spinner: bool = False) -> tuple[str, str, str]:
+  serial = HARDWARE.get_serial()
+  spinner = Spinner() if show_spinner else None
+  start_time = time.monotonic()
+  imei1: str | None = None
+  imei2: str | None = None
+
+  while time.monotonic() - start_time < wait_timeout:
+    try:
+      imei1, imei2 = HARDWARE.get_imei(0), HARDWARE.get_imei(1)
+      if imei1 or imei2:
+        break
+    except RuntimeError as e:
+      if "no modems" in str(e).lower():
+        cloudlog.warning("No cellular modem available, proceeding without IMEI")
+        break
+      cloudlog.exception("Error getting imei, trying again...")
+    except Exception:
+      cloudlog.exception("Error getting imei, trying again...")
+    time.sleep(1)
+
+  imei1 = _normalize_imei(imei1)
+  imei2 = _normalize_imei(imei2)
+
+  if not imei1 and not imei2:
+    cloudlog.warning(f"proceeding with serial-only registration for serial={serial}")
+  if spinner is not None:
+    spinner.update(f"registering device - serial: {serial}, IMEI: ({imei1 or None}, {imei2 or None})")
+    spinner.close()
+
+  return serial, imei1, imei2
+
+
+def register(show_spinner=False) -> str | None:
+  params = Params()
+
+  dongle_id: str | None = get_cached_dongle_id(params, prefer_readonly=True)
+  if dongle_id in ("", UNREGISTERED_DONGLE_ID):
+    dongle_id = None
+
+  jwt_algo, private_key, public_key = get_key_pair()
+
+  if not public_key:
+    dongle_id = UNREGISTERED_DONGLE_ID
+    cloudlog.warning("missing public key")
+  elif dongle_id is None:
+    if show_spinner:
+      spinner = Spinner()
+      spinner.update("registering device")
+
+    serial, imei1, imei2 = get_registration_identifiers(wait_timeout=IMEI_WAIT_TIMEOUT, show_spinner=False)
+
+    backoff = 0
+    start_time = time.monotonic()
+    while True:
+      try:
+        register_token = jwt.encode({'register': True, 'exp': datetime.now(UTC).replace(tzinfo=None) + timedelta(hours=1)},
+                                    cast(str, private_key), algorithm=jwt_algo)
+        cloudlog.info("getting pilotauth")
+        cloudlog.info("getting pilotauth")
+        resp = api_get("v2/pilotauth/", method='POST', timeout=15,
+                       imei=imei1, imei2=imei2, serial=serial, public_key=public_key, register_token=register_token)
+
+        if resp.status_code in (400, 402, 403):
+          cloudlog.info(f"Unable to register device, got {resp.status_code}")
+          dongle_id = UNREGISTERED_DONGLE_ID
+        else:
+          dongleauth = json.loads(resp.text)
+          dongle_id = dongleauth["dongle_id"]
+        break
+      except Exception:
+        cloudlog.exception("failed to authenticate")
+        backoff = min(backoff + 1, 15)
+        time.sleep(backoff)
+
+      if time.monotonic() - start_time > 60 and show_spinner:
+        spinner.update(f"registering device - serial: {serial}, IMEI: ({imei1}, {imei2})")
+        return UNREGISTERED_DONGLE_ID
+
+    if show_spinner:
+      spinner.update(f"registering device - serial: {serial}, IMEI: ({imei1 or None}, {imei2 or None})")
+      spinner.close()
+
+  if dongle_id:
+    params.put("DongleId", dongle_id)
+    from iqpilot.selfdrive.selfdrived.alertmanager import set_offroad_alert
+    set_offroad_alert("Offroad_UnregisteredHardware", False)
+  return dongle_id
+
+
+if __name__ == "__main__":
+  print(register())

artifacts/iqpilot_hephaestusd_private/python/_iqclosure/iqpilot/konn3kt/service_health.py

@@ -0,0 +1,11 @@
+#!/usr/bin/env python3
+"""
+Copyright ©️ IQ.Lvbs, apart of Project Teal Lvbs, All Rights Reserved, licensed under https://konn3kt.com/tos
+"""
+
+def hephaestus_ready(params=None) -> bool:
+    return True
+
+
+def hephaestus_ready_shim():
+    return hephaestus_ready()

artifacts/iqpilot_hephaestusd_private/python/_iqclosure/iqpilot/selfdrive/car/vehicle_catalog.py

@@ -0,0 +1,85 @@
+"""
+Copyright © IQ.Lvbs, apart of Project Teal Lvbs, All Rights Reserved, licensed under https://konn3kt.com/tos
+"""
+import json
+import os
+
+from iqpilot.common.basedir import BASEDIR
+
+SCHEMA = "iqlvbs/supported-vehicles"
+REV = 1
+
+CATALOG_FILENAME = "vehicle_catalog.json"
+_CANDIDATE_PARTS = (
+  ("iqpilot", "selfdrive", "car", CATALOG_FILENAME),
+)
+
+# in-memory (car-interface) field  ->  on-disk compact key
+_ATTR_TO_KEY = (
+  ("platform", "id"),
+  ("make", "mk"),
+  ("brand", "grp"),
+  ("model", "mdl"),
+  ("year", "yrs"),
+  ("package", "req"),
+)
+
+
+def _reference(platform: str, years: list[str], claimed: set[str]) -> str:
+  span = f"{years[0]}-{years[-1]}" if len(years) > 1 else (years[0] if years else "na")
+  stem = f"{platform}|{span}"
+  ref, bump = stem, 2
+  while ref in claimed:
+    ref = f"{stem}#{bump}"
+    bump += 1
+  claimed.add(ref)
+  return ref
+
+
+def encode(vehicles: dict[str, dict]) -> dict:
+  records: dict[str, dict] = {}
+  claimed: set[str] = set()
+  for label, attrs in vehicles.items():
+    years = list(attrs.get("year") or [])
+    ref = _reference(attrs.get("platform", ""), years, claimed)
+    record = {"label": label}
+    for attr, key in _ATTR_TO_KEY:
+      record[key] = attrs.get(attr)
+    records[ref] = record
+  return {"catalog": SCHEMA, "rev": REV, "vehicles": records}
+
+
+def decode(envelope: dict) -> dict[str, dict]:
+  vehicles: dict[str, dict] = {}
+  for record in (envelope.get("vehicles") or {}).values():
+    attrs = {attr: record.get(key) for attr, key in _ATTR_TO_KEY}
+    vehicles[record.get("label", "")] = attrs
+  return vehicles
+
+
+def catalog_path(basedir: str = BASEDIR) -> str | None:
+  for parts in _CANDIDATE_PARTS:
+    candidate = os.path.join(basedir, *parts)
+    if os.path.isfile(candidate):
+      return candidate
+  return None
+
+
+def load_catalog(basedir: str = BASEDIR) -> dict[str, dict]:
+  path = catalog_path(basedir)
+  if path is None:
+    return {}
+  with open(path) as handle:
+    return decode(json.load(handle))
+
+
+def _write(vehicles: dict[str, dict], basedir: str = BASEDIR) -> str:
+  out = os.path.join(basedir, "iqpilot", "selfdrive", "car", CATALOG_FILENAME)
+  with open(out, "w") as handle:
+    json.dump(encode(vehicles), handle, indent=2, ensure_ascii=False)
+  return out
+
+
+if __name__ == "__main__":
+  from iqdbc.lvbs.car.car_catalog import build_car_catalog
+  print("wrote", _write(build_car_catalog()))

artifacts/iqpilot_hephaestusd_private/python/_iqclosure/iqpilot/selfdrive/iqmodeld/__init__.py

@@ -0,0 +1,23 @@
+"""
+Copyright © IQ.Lvbs, apart of Project Teal Lvbs, All Rights Reserved, licensed under https://konn3kt.com/tos/
+"""
+from pathlib import Path
+
+
+def _models_dir() -> Path:
+  return Path(__file__).resolve().parent / "models"
+
+
+def _artifact_path(stem: str, suffix: str) -> Path:
+  return _models_dir() / f"{stem}{suffix}"
+
+
+MODEL_ASSETS = {
+  "onnx": _artifact_path("supercombo", ".onnx"),
+  "tinygrad": _artifact_path("supercombo", "_tinygrad.pkl"),
+  "metadata": _artifact_path("supercombo", "_metadata.pkl"),
+}
+
+MODEL_PATH = MODEL_ASSETS["onnx"]
+MODEL_PKL_PATH = MODEL_ASSETS["tinygrad"]
+METADATA_PATH = MODEL_ASSETS["metadata"]

artifacts/iqpilot_hephaestusd_private/python/_iqclosure/iqpilot/selfdrive/iqmodeld/config.py

@@ -0,0 +1,133 @@
+"""
+Copyright © IQ.Lvbs, apart of Project Teal Lvbs, All Rights Reserved, licensed under https://konn3kt.com/tos/
+"""
+from __future__ import annotations
+
+import numpy as np
+
+
+def index_function(index: int, max_val: float = 192, max_idx: int = 32) -> float:
+  return max_val * ((index / max_idx) ** 2)
+
+
+def _quadratic_series(limit: float, steps: int) -> list[float]:
+  return [index_function(index, max_val=limit, max_idx=steps - 1) for index in range(steps)]
+
+
+def _probability_window(*values: float) -> np.ndarray:
+  return np.asarray(values, dtype=np.float32)
+
+
+def _field_group(start: int, stop: int, stride: int) -> slice:
+  return slice(start, stop, stride)
+
+
+_IDX_COUNT = 33
+_T_AXIS = _quadratic_series(10.0, _IDX_COUNT)
+_X_AXIS = _quadratic_series(192.0, _IDX_COUNT)
+
+
+class ModelConstants:
+  IDX_N = _IDX_COUNT
+  T_IDXS = _T_AXIS
+  X_IDXS = _X_AXIS
+  LEAD_T_IDXS = [0.0, 2.0, 4.0, 6.0, 8.0, 10.0]
+  LEAD_T_OFFSETS = [0.0, 2.0, 4.0]
+  META_T_IDXS = [2.0, 4.0, 6.0, 8.0, 10.0]
+
+  MODEL_FREQ = 20
+  FEATURE_LEN = 512
+  FULL_HISTORY_BUFFER_LEN = 99
+  HISTORY_BUFFER_LEN = FULL_HISTORY_BUFFER_LEN
+  DESIRE_LEN = 8
+  TRAFFIC_CONVENTION_LEN = 2
+  NAV_FEATURE_LEN = 256
+  NAV_INSTRUCTION_LEN = 150
+  LAT_PLANNER_STATE_LEN = 4
+  LATERAL_CONTROL_PARAMS_LEN = 2
+  PREV_DESIRED_CURV_LEN = 1
+
+  FCW_THRESHOLDS_5MS2 = _probability_window(0.05, 0.05, 0.15, 0.15, 0.15)
+  FCW_THRESHOLDS_3MS2 = _probability_window(0.7, 0.7)
+  FCW_5MS2_PROBS_WIDTH = 5
+  FCW_3MS2_PROBS_WIDTH = 2
+
+  DISENGAGE_WIDTH = 5
+  POSE_WIDTH = 6
+  WIDE_FROM_DEVICE_WIDTH = 3
+  SIM_POSE_WIDTH = 6
+  LEAD_WIDTH = 4
+  LANE_LINES_WIDTH = 2
+  ROAD_EDGES_WIDTH = 2
+  PLAN_WIDTH = 15
+  DESIRE_PRED_WIDTH = 8
+  LAT_PLANNER_SOLUTION_WIDTH = 4
+  DESIRED_CURV_WIDTH = 1
+
+  NUM_LANE_LINES = 4
+  NUM_ROAD_EDGES = 2
+  LEAD_TRAJ_LEN = 6
+  DESIRE_PRED_LEN = 4
+
+  PLAN_MHP_N = 5
+  LEAD_MHP_N = 2
+  PLAN_MHP_SELECTION = 1
+  LEAD_MHP_SELECTION = 3
+
+  FCW_THRESHOLD_5MS2_HIGH = 0.15
+  FCW_THRESHOLD_5MS2_LOW = 0.05
+  FCW_THRESHOLD_3MS2 = 0.7
+
+  CONFIDENCE_BUFFER_LEN = 5
+  RYG_GREEN = 0.01165
+  RYG_YELLOW = 0.06157
+  POLY_PATH_DEGREE = 4
+
+
+class Plan:
+  POSITION = slice(0, 3)
+  VELOCITY = slice(3, 6)
+  ACCELERATION = slice(6, 9)
+  T_FROM_CURRENT_EULER = slice(9, 12)
+  ORIENTATION_RATE = slice(12, 15)
+
+
+class Meta:
+  ENGAGED = _field_group(0, 1, 1)
+  GAS_DISENGAGE = _field_group(1, 31, 6)
+  BRAKE_DISENGAGE = _field_group(2, 31, 6)
+  STEER_OVERRIDE = _field_group(3, 31, 6)
+  HARD_BRAKE_3 = _field_group(4, 31, 6)
+  HARD_BRAKE_4 = _field_group(5, 31, 6)
+  HARD_BRAKE_5 = _field_group(6, 31, 6)
+  GAS_PRESS = _field_group(31, 55, 4)
+  BRAKE_PRESS = _field_group(32, 55, 4)
+  LEFT_BLINKER = _field_group(33, 55, 4)
+  RIGHT_BLINKER = _field_group(34, 55, 4)
+
+
+class MetaTombRaider:
+  ENGAGED = _field_group(0, 1, 1)
+  GAS_DISENGAGE = _field_group(1, 41, 8)
+  BRAKE_DISENGAGE = _field_group(2, 41, 8)
+  STEER_OVERRIDE = _field_group(3, 41, 8)
+  HARD_BRAKE_3 = _field_group(4, 41, 8)
+  HARD_BRAKE_4 = _field_group(5, 41, 8)
+  HARD_BRAKE_5 = _field_group(6, 41, 8)
+  GAS_PRESS = _field_group(7, 41, 8)
+  BRAKE_PRESS = _field_group(8, 41, 8)
+  LEFT_BLINKER = _field_group(41, 53, 2)
+  RIGHT_BLINKER = _field_group(42, 53, 2)
+
+
+class MetaSimPose:
+  ENGAGED = _field_group(0, 1, 1)
+  GAS_DISENGAGE = _field_group(1, 36, 7)
+  BRAKE_DISENGAGE = _field_group(2, 36, 7)
+  STEER_OVERRIDE = _field_group(3, 36, 7)
+  HARD_BRAKE_3 = _field_group(4, 36, 7)
+  HARD_BRAKE_4 = _field_group(5, 36, 7)
+  HARD_BRAKE_5 = _field_group(6, 36, 7)
+  GAS_PRESS = _field_group(7, 36, 7)
+  LEFT_BLINKER = _field_group(36, 48, 2)
+  RIGHT_BLINKER = _field_group(37, 48, 2)

artifacts/iqpilot_hephaestusd_private/python/_iqclosure/iqpilot/selfdrive/iqmodeld/models/__init__.py

@@ -0,0 +1,3 @@
+"""
+IQ model selection and runner support that is actively used by iqmodeld.
+"""

artifacts/iqpilot_hephaestusd_private/python/_iqclosure/iqpilot/selfdrive/iqmodeld/models/fetcher.py

@@ -0,0 +1,14 @@
+#!/usr/bin/env python3
+"""
+Copyright (c) IQ.Lvbs, apart of Project Teal Lvbs, All Rights Reserved, licensed under https://konn3kt.com/tos
+
+Public entry point for the model-manifest fetcher: prefers the compiled private
+bundle, falling back to the in-tree source. The default-runner fallback lives in
+ManifestDecoder now, so no post-import patching is needed.
+"""
+from iqpilot._proprietary_loader import ProprietaryModuleMissing, load_private_module
+
+try:
+  load_private_module(__name__, "iqpilot_private.models.fetcher")
+except ProprietaryModuleMissing:
+  from iqpilot.models_private_src.fetcher import *  # noqa: F403

artifacts/iqpilot_hephaestusd_private/python/_iqclosure/iqpilot/selfdrive/iqmodeld/models/helpers.py

@@ -0,0 +1,309 @@
+#!/usr/bin/env python3
+"""
+Copyright (c) IQ.Lvbs, apart of Project Teal Lvbs, All Rights Reserved, licensed under https://konn3kt.com/tos
+"""
+import json
+import os
+import shutil
+from pathlib import Path
+
+from iqpilot.cereal import custom
+from iqpilot.common.params import Params
+from iqpilot.common.swaglog import cloudlog
+from iqpilot._proprietary_loader import ProprietaryModuleMissing, load_private_module
+from iqpilot.system.hardware.hw import Paths
+
+try:
+  load_private_module(__name__, "iqpilot_private.models.helpers")
+except ProprietaryModuleMissing:
+  try:
+    from iqpilot.models_private_src.helpers import *  # noqa: F403
+  except ImportError:
+    pass
+
+
+ModelBundle = custom.IQModelManager.ModelBundle
+Runner = custom.IQModelManager.Runner
+_MODEL_ROOT = Path(Paths.model_root())
+_ACTIVE_BUNDLE_KEY = "ModelManager_ActiveBundle"
+_MODELS_CACHE_KEY = "ModelManager_ModelsCache"
+_RUNNER_CACHE_KEY = "ModelRunnerTypeCache"
+_DOWNLOAD_INDEX_KEY = "ModelManager_DownloadIndex"
+_PENDING_MODEL_RESTORE_FILE = "/data/k3_pending_model_restore"
+_STOCK_RUNNER = int(Runner.stock)
+_TINYGRAD_RUNNER = int(Runner.tinygrad)
+_SNPE_RUNNER = int(Runner.snpe)
+
+_DEFAULT_MODEL_DIR = Path(__file__).resolve().parents[1] / "default_model"
+_DEFAULT_BUNDLE_JSON = _DEFAULT_MODEL_DIR / "bundle.json"
+_DEFAULT_BUNDLE_REF = "default"
+
+
+def get_default_model_bundle(_bundles):
+  """Legacy compatibility hook: stock default is preinstalled, not a manifest bundle."""
+  return None
+
+
+def _coerce_runner_value(value) -> int | None:
+  raw = getattr(value, "raw", value)
+  try:
+    return int(raw)
+  except (TypeError, ValueError):
+    return None
+
+
+def _bundle_models(bundle) -> list:
+  models = getattr(bundle, "models", None)
+  return list(models) if models is not None else []
+
+
+def _bundle_needs_runtime_upgrade(bundle) -> bool:
+  if bundle is None:
+    return False
+
+  if _coerce_runner_value(getattr(bundle, "runner", None)) == _SNPE_RUNNER:
+    return True
+
+  for model in _bundle_models(bundle):
+    file_name = getattr(getattr(model, "artifact", None), "fileName", "") or ""
+    if file_name.endswith(".thneed"):
+      return True
+
+  return False
+
+
+def _load_cached_manifest_bundles(params: Params):
+  cached = params.get(_MODELS_CACHE_KEY) or {}
+  bundles = []
+  for raw_bundle in cached.get("bundles", []):
+    try:
+      min_selector_version = int(raw_bundle.get("minimumSelectorVersion", raw_bundle.get("minimum_selector_version", 0)))
+      compatibility_view = dict(raw_bundle)
+      compatibility_view["minimumSelectorVersion"] = min_selector_version
+      is_compatible = globals().get("is_bundle_version_compatible")
+      if is_compatible is not None and not is_compatible(compatibility_view):
+        continue
+
+      if "short_name" in raw_bundle:
+        from iqpilot.selfdrive.iqmodeld.models.fetcher import ManifestDecoder
+        bundles.append(ManifestDecoder._decode_bundle(raw_bundle))
+        continue
+
+      if "internalName" in raw_bundle:
+        bundles.append(ModelBundle(**raw_bundle))
+        continue
+
+      bundle = ModelBundle()
+      bundle.index = int(raw_bundle["index"])
+      bundle.internalName = raw_bundle.get("short_name")
+      bundle.displayName = raw_bundle.get("display_name")
+      bundle.status = 0
+      bundle.generation = int(raw_bundle["generation"])
+      bundle.environment = raw_bundle["environment"]
+      bundle.runner = raw_bundle.get("runner", Runner.tinygrad)
+      bundle.is20hz = raw_bundle.get("is_20hz", False)
+      bundle.minimumSelectorVersion = int(min_selector_version)
+      bundle.ref = raw_bundle.get("ref")
+      bundle.overrides = []
+      for key, value in raw_bundle.get("overrides", {}).items():
+        override = custom.IQModelManager.Override()
+        override.key = key
+        override.value = value
+        bundle.overrides.append(override)
+
+      bundle.models = []
+      for raw_model in raw_bundle.get("models", []):
+        model = custom.IQModelManager.Model()
+        model.type = raw_model.get("type")
+        for attr_name in ("artifact", "metadata"):
+          raw_artifact = raw_model.get(attr_name)
+          if not raw_artifact:
+            continue
+          artifact = custom.IQModelManager.Artifact()
+          artifact.fileName = raw_artifact.get("file_name")
+          download_uri = custom.IQModelManager.DownloadUri()
+          download_uri.uri = raw_artifact.get("download_uri", {}).get("url")
+          download_uri.sha256 = raw_artifact.get("download_uri", {}).get("sha256")
+          artifact.downloadUri = download_uri
+          setattr(model, attr_name, artifact)
+        bundle.models.append(model)
+
+      bundles.append(bundle)
+    except Exception:
+      continue
+  return bundles
+
+
+def _bundle_match_key(bundle) -> tuple[str | None, str | None, str | None]:
+  return (
+    getattr(bundle, "ref", None),
+    getattr(bundle, "internalName", None),
+    getattr(bundle, "displayName", None),
+  )
+
+
+def _find_runtime_upgrade(bundle, params: Params, available_bundles=None):
+  if not _bundle_needs_runtime_upgrade(bundle):
+    return bundle
+
+  candidate_bundles = available_bundles if available_bundles is not None else _load_cached_manifest_bundles(params)
+  ref, internal_name, display_name = _bundle_match_key(bundle)
+
+  for candidate in candidate_bundles:
+    if getattr(candidate, "ref", None) and getattr(candidate, "ref", None) == ref:
+      return candidate
+
+  for candidate in candidate_bundles:
+    if getattr(candidate, "internalName", None) == internal_name:
+      return candidate
+
+  for candidate in candidate_bundles:
+    if getattr(candidate, "displayName", None) == display_name:
+      return candidate
+
+  return None
+
+
+def bundle_files_ready(bundle) -> bool:
+  if bundle is None:
+    return False
+
+  for model in _bundle_models(bundle):
+    artifact = getattr(model, "artifact", None)
+    metadata = getattr(model, "metadata", None)
+    for file_name in (getattr(metadata, "fileName", None), getattr(artifact, "fileName", None)):
+      if file_name and not (_MODEL_ROOT / file_name).is_file():
+        return False
+  return True
+
+
+def persist_active_bundle(params: Params, bundle) -> None:
+  params.put(_ACTIVE_BUNDLE_KEY, bundle.to_dict())
+  params.remove(_RUNNER_CACHE_KEY)
+
+
+def _load_default_bundle_dict() -> dict:
+  return json.loads(_DEFAULT_BUNDLE_JSON.read_text())
+
+
+def _default_bundle_filenames(bundle_dict: dict) -> list[str]:
+  names = []
+  for model in bundle_dict.get("models", []):
+    for artifact in (model.get("metadata"), model.get("artifact")):
+      file_name = artifact.get("fileName", "") if isinstance(artifact, dict) else ""
+      if file_name:
+        names.append(file_name)
+  return names
+
+
+def is_default_bundle(bundle) -> bool:
+  return bool(bundle is not None and getattr(bundle, "ref", None) == _DEFAULT_BUNDLE_REF)
+
+
+def ensure_default_model_files(bundle_dict: dict = None) -> None:
+  bundle_dict = bundle_dict if bundle_dict is not None else _load_default_bundle_dict()
+  try:
+    _MODEL_ROOT.mkdir(parents=True, exist_ok=True)
+  except OSError as e:
+    cloudlog.exception(f"default_model: cannot create model root: {e}")
+    return
+  for file_name in _default_bundle_filenames(bundle_dict):
+    src = _DEFAULT_MODEL_DIR / file_name
+    dst = _MODEL_ROOT / file_name
+    if not src.is_file():
+      cloudlog.error(f"default_model: shipped asset missing {src}")
+      continue
+    if dst.is_file() and dst.stat().st_size == src.stat().st_size:
+      continue
+    try:
+      shutil.copy2(src, dst)
+      cloudlog.warning(f"default_model: staged {file_name} into model root")
+    except OSError as e:
+      cloudlog.exception(f"default_model: failed staging {file_name}: {e}")
+
+
+def select_default_model(params: Params = None) -> None:
+  params = Params() if params is None else params
+  bundle_dict = _load_default_bundle_dict()
+  ensure_default_model_files(bundle_dict)
+  params.remove(_DOWNLOAD_INDEX_KEY)
+  params.put(_ACTIVE_BUNDLE_KEY, bundle_dict)
+  params.remove(_RUNNER_CACHE_KEY)
+  params.put(_RUNNER_CACHE_KEY, _TINYGRAD_RUNNER)
+  try:
+    if os.path.isfile(_PENDING_MODEL_RESTORE_FILE):
+      os.remove(_PENDING_MODEL_RESTORE_FILE)
+  except OSError:
+    pass
+
+
+def seed_default_bundle_if_unset(params: Params = None) -> None:
+  params = Params() if params is None else params
+  if params.get(_ACTIVE_BUNDLE_KEY) or params.get(_DOWNLOAD_INDEX_KEY) is not None:
+    return
+  try:
+    select_default_model(params)
+    cloudlog.warning("default_model: seeded Default (CD210) as active bundle")
+  except Exception as e:
+    cloudlog.exception(f"default_model: failed to seed default bundle: {e}")
+
+
+def get_runtime_bundle_upgrade(bundle, params: Params = None, available_bundles=None):
+  params = Params() if params is None else params
+  return _find_runtime_upgrade(bundle, params, available_bundles)
+
+
+def get_active_bundle(params: Params = None):
+  params = Params() if params is None else params
+
+  try:
+    active_bundle = params.get(_ACTIVE_BUNDLE_KEY) or {}
+    if not active_bundle:
+      return None
+    is_compatible = globals().get("is_bundle_version_compatible")
+    if is_compatible is not None and not is_compatible(active_bundle):
+      return None
+    bundle = ModelBundle(**active_bundle)
+  except Exception:
+    return None
+
+  replacement = _find_runtime_upgrade(bundle, params)
+  if replacement is not None and replacement is not bundle and bundle_files_ready(replacement):
+    persist_active_bundle(params, replacement)
+    return replacement
+
+  return bundle
+
+
+def get_active_model_runner(params: Params = None, force_check=False):
+  params = Params() if params is None else params
+
+  active_bundle = get_active_bundle(params)
+  if not active_bundle:
+    seed_default_bundle_if_unset(params)
+    active_bundle = get_active_bundle(params)
+    if not active_bundle:
+      if params.get(_RUNNER_CACHE_KEY) != str(_TINYGRAD_RUNNER):
+        params.put(_RUNNER_CACHE_KEY, _TINYGRAD_RUNNER)
+      return _TINYGRAD_RUNNER
+
+  cached_runner_type = params.get(_RUNNER_CACHE_KEY)
+  if cached_runner_type and not force_check and isinstance(cached_runner_type, str) and cached_runner_type.isdigit():
+    return int(cached_runner_type)
+
+  runner_type = _coerce_runner_value(active_bundle.runner)
+  if runner_type == _SNPE_RUNNER:
+    replacement = _find_runtime_upgrade(active_bundle, params)
+    if replacement is not None and replacement is not active_bundle and bundle_files_ready(replacement):
+      persist_active_bundle(params, replacement)
+      runner_type = _coerce_runner_value(replacement.runner)
+    else:
+      if replacement is not None and getattr(replacement, "index", None) is not None and params.get(_DOWNLOAD_INDEX_KEY) is None:
+        params.put(_DOWNLOAD_INDEX_KEY, int(replacement.index))
+        cloudlog.warning(f"Queued tinygrad migration for retired bundle {getattr(active_bundle, 'internalName', '<unknown>')}")
+      runner_type = _TINYGRAD_RUNNER
+
+  if cached_runner_type != runner_type:
+    params.put(_RUNNER_CACHE_KEY, int(runner_type))
+
+  return runner_type

artifacts/iqpilot_hephaestusd_private/python/_iqclosure/iqpilot/selfdrive/locationd/calibrationd.py

@@ -0,0 +1,367 @@
+#!/usr/bin/env python3
+'''
+This process finds calibration values. More info on what these calibration values
+are can be found here https://github.com/commaai/openpilot/tree/master/common/transformations
+While the roll calibration is a real value that can be estimated, here we assume it's zero,
+and the image input into the neural network is not corrected for roll.
+'''
+
+import os
+import capnp
+import numpy as np
+from typing import NoReturn
+
+from iqpilot.cereal import log, car
+import iqpilot.cereal.messaging as messaging
+from iqpilot.common.constants import CV
+from iqpilot.common.params import Params
+from iqpilot.common.issue_debug import log_issue_limited
+from iqpilot.common.realtime import config_realtime_process
+from iqpilot.common.transformations.orientation import rot_from_euler, euler_from_rot
+from iqpilot.common.swaglog import cloudlog
+from iqpilot.system.hardware import HARDWARE
+
+MIN_SPEED_FILTER = 15 * CV.MPH_TO_MS
+MAX_VEL_ANGLE_STD = np.radians(0.25)
+MAX_YAW_RATE_FILTER = np.radians(2)  # per second
+
+MAX_HEIGHT_STD = np.exp(-3.5)
+
+# This is at model frequency, blocks needed for efficiency
+SMOOTH_CYCLES = 10
+BLOCK_SIZE = 100
+INPUTS_NEEDED = 5   # Minimum blocks needed for valid calibration
+INPUTS_WANTED = 50   # We want a little bit more than we need for stability
+MAX_ALLOWED_YAW_SPREAD = np.radians(2)
+MAX_ALLOWED_PITCH_SPREAD = np.radians(4)
+TICI_FAMILY_PITCH_SPREAD_RESET = np.radians(3)
+RPY_INIT = np.array([0.0,0.0,0.0])
+WIDE_FROM_DEVICE_EULER_INIT = np.array([0.0, 0.0, 0.0])
+HEIGHT_INIT = np.array([1.22])
+HEIGHT_SANE_MIN, HEIGHT_SANE_MAX = 0.9, 2.0
+DEVICE_IS_TICI_FAMILY = HARDWARE.get_device_type() in ("tici", "tizi")
+
+# These values are needed to accommodate the model frame in the narrow cam
+if HARDWARE.get_device_type() == 'mici':
+  PITCH_LIMITS = np.array([-0.143101, 0.22235988])
+else:
+  PITCH_LIMITS = np.array([-0.09074112085129739, 0.17])
+YAW_LIMITS = np.array([-0.06912048084718224, 0.06912048084718235])
+DEBUG = os.getenv("DEBUG") is not None
+
+def is_calibration_valid(rpy: np.ndarray) -> bool:
+  return (PITCH_LIMITS[0] < rpy[1] < PITCH_LIMITS[1]) and (YAW_LIMITS[0] < rpy[2] < YAW_LIMITS[1])
+
+
+def sanity_clip(rpy: np.ndarray) -> np.ndarray:
+  if np.isnan(rpy).any():
+    rpy = RPY_INIT
+  return np.array([rpy[0],
+                   np.clip(rpy[1], PITCH_LIMITS[0] - .005, PITCH_LIMITS[1] + .005),
+                   np.clip(rpy[2], YAW_LIMITS[0] - .005, YAW_LIMITS[1] + .005)])
+
+def moving_avg_with_linear_decay(prev_mean: np.ndarray, new_val: np.ndarray, idx: int, block_size: float) -> np.ndarray:
+  return (idx*prev_mean + (block_size - idx) * new_val) / block_size
+
+class Calibrator:
+  def __init__(self, param_put: bool = False):
+    self.param_put = param_put
+
+    self.not_car = False
+    self.stable_rpy = RPY_INIT.copy()
+    self.stable_wide_from_device_euler = WIDE_FROM_DEVICE_EULER_INIT.copy()
+    self.stable_height = HEIGHT_INIT.copy()
+    self.has_stable_snapshot = False
+
+    # Read saved calibration
+    self.params = Params()
+    calibration_params = self.params.get("CalibrationParams")
+    rpy_init = RPY_INIT
+    wide_from_device_euler = WIDE_FROM_DEVICE_EULER_INIT
+    height = HEIGHT_INIT
+    valid_blocks = 0
+    self.cal_status = log.ExtrinsicsCalibration.Status.uncalibrated
+
+    if param_put and calibration_params:
+      try:
+        with log.Event.from_bytes(calibration_params) as msg:
+          rpy_init = np.array(msg.extrinsicsCalibration.rpyCalib)
+          valid_blocks = msg.extrinsicsCalibration.validBlocks
+          wide_from_device_euler = np.array(msg.extrinsicsCalibration.wideFromDeviceEuler)
+          height = np.array(msg.extrinsicsCalibration.height)
+      except Exception:
+        cloudlog.exception("Error reading cached CalibrationParams")
+
+    self.reset(rpy_init, valid_blocks, wide_from_device_euler, height)
+    self.update_status()
+
+    # If saved calibration is immediately invalid (e.g. bad params from a previous
+    # bootstrap bug or device remount), auto-clear it so we recalibrate from scratch
+    # instead of getting permanently stuck in the "Calibration Invalid" state.
+    if self.cal_status == log.ExtrinsicsCalibration.Status.invalid:
+      cloudlog.warning("calibrationd: saved CalibrationParams are invalid, clearing and starting fresh")
+      if param_put:
+        self.params.remove("CalibrationParams")
+      self.reset()
+      self.update_status()
+
+  def _remember_stable_solution(self) -> None:
+    self.stable_rpy = self.rpy.copy()
+    self.stable_wide_from_device_euler = self.wide_from_device_euler.copy()
+    self.stable_height = self.height.copy()
+    self.has_stable_snapshot = True
+
+  def reset(self, rpy_init: np.ndarray = RPY_INIT,
+                  valid_blocks: int = 0,
+                  wide_from_device_euler_init: np.ndarray = WIDE_FROM_DEVICE_EULER_INIT,
+                  height_init: np.ndarray = HEIGHT_INIT,
+                  smooth_from: np.ndarray | None = None) -> None:
+    if not np.isfinite(rpy_init).all():
+      self.rpy = RPY_INIT.copy()
+    else:
+      self.rpy = rpy_init.copy()
+
+    if not np.isfinite(height_init).all() or len(height_init) != 1:
+      self.height = HEIGHT_INIT.copy()
+    else:
+      self.height = height_init.copy()
+
+    if not np.isfinite(wide_from_device_euler_init).all() or len(wide_from_device_euler_init) != 3:
+      self.wide_from_device_euler = WIDE_FROM_DEVICE_EULER_INIT.copy()
+    else:
+      self.wide_from_device_euler = wide_from_device_euler_init.copy()
+
+    if not np.isfinite(valid_blocks) or valid_blocks < 0:
+      self.valid_blocks = 0
+    else:
+      self.valid_blocks = valid_blocks
+
+    self.rpys = np.tile(self.rpy, (INPUTS_WANTED, 1))
+    self.wide_from_device_eulers = np.tile(self.wide_from_device_euler, (INPUTS_WANTED, 1))
+    self.heights = np.tile(self.height, (INPUTS_WANTED, 1))
+
+    self.idx = 0
+    self.block_idx = 0
+    self.v_ego = 0.0
+
+    if smooth_from is None:
+      self.old_rpy = RPY_INIT
+      self.old_rpy_weight = 0.0
+    else:
+      self.old_rpy = smooth_from
+      self.old_rpy_weight = 1.0
+
+  def get_valid_idxs(self) -> list[int]:
+    # exclude current block_idx from validity window
+    before_current = list(range(self.block_idx))
+    after_current = list(range(min(self.valid_blocks, self.block_idx + 1), self.valid_blocks))
+    return before_current + after_current
+
+  def update_status(self) -> None:
+    valid_idxs = self.get_valid_idxs()
+    if valid_idxs:
+      self.wide_from_device_euler = np.mean(self.wide_from_device_eulers[valid_idxs], axis=0)
+      self.height = np.mean(self.heights[valid_idxs], axis=0)
+      rpys = self.rpys[valid_idxs]
+      self.rpy = np.mean(rpys, axis=0)
+      max_rpy_calib = np.array(np.max(rpys, axis=0))
+      min_rpy_calib = np.array(np.min(rpys, axis=0))
+      self.calib_spread = np.abs(max_rpy_calib - min_rpy_calib)
+    else:
+      self.calib_spread = np.zeros(3)
+
+    if self.valid_blocks < INPUTS_NEEDED:
+      if self.cal_status == log.ExtrinsicsCalibration.Status.recalibrating:
+        self.cal_status = log.ExtrinsicsCalibration.Status.recalibrating
+      else:
+        self.cal_status = log.ExtrinsicsCalibration.Status.uncalibrated
+    elif is_calibration_valid(self.rpy):
+      self.cal_status = log.ExtrinsicsCalibration.Status.calibrated
+    else:
+      self.cal_status = log.ExtrinsicsCalibration.Status.invalid
+
+    # If spread is too high, assume mounting was changed and reset to last block.
+    # Make the transition smooth. Abrupt transitions are not good for feedback loop through supercombo model.
+    # TODO: add height spread check with smooth transition too
+    pitch_spread_limit = TICI_FAMILY_PITCH_SPREAD_RESET if DEVICE_IS_TICI_FAMILY else MAX_ALLOWED_PITCH_SPREAD
+    spread_too_high = self.calib_spread[1] > pitch_spread_limit or self.calib_spread[2] > MAX_ALLOWED_YAW_SPREAD
+    if self.cal_status == log.ExtrinsicsCalibration.Status.calibrated and not spread_too_high:
+      self._remember_stable_solution()
+
+    if spread_too_high and self.cal_status == log.ExtrinsicsCalibration.Status.calibrated:
+      use_stable_snapshot = DEVICE_IS_TICI_FAMILY and self.has_stable_snapshot
+      if use_stable_snapshot:
+        reset_rpy = self.stable_rpy
+        reset_wide = self.stable_wide_from_device_euler
+        reset_height = self.stable_height
+      else:
+        reset_rpy = self.rpys[self.block_idx - 1]
+        reset_wide = self.wide_from_device_eulers[self.block_idx - 1]
+        reset_height = self.heights[self.block_idx - 1]
+
+      log_issue_limited(
+        "calibrationd_reset_spread",
+        "calibration",
+        f"calibrationd reset unstable solution pitchSpread={self.calib_spread[1]:.6f} "
+        f"yawSpread={self.calib_spread[2]:.6f} pitchLimit={pitch_spread_limit:.6f} "
+        f"use_stable_snapshot={use_stable_snapshot} rpy={self.rpy.tolist()}",
+        interval_sec=0.5,
+      )
+      self.reset(reset_rpy, valid_blocks=1, wide_from_device_euler_init=reset_wide,
+                 height_init=reset_height, smooth_from=self.stable_rpy if use_stable_snapshot else self.rpy)
+      self.cal_status = log.ExtrinsicsCalibration.Status.recalibrating
+
+    write_this_cycle = (self.idx == 0) and (self.block_idx % (INPUTS_WANTED//5) == 5)
+    if self.param_put and write_this_cycle:
+      self.params.put_nonblocking("CalibrationParams", self.get_msg(True).to_bytes())
+
+  def handle_v_ego(self, v_ego: float) -> None:
+    self.v_ego = v_ego
+
+  def get_smooth_rpy(self) -> np.ndarray:
+    if self.old_rpy_weight > 0:
+      return self.old_rpy_weight * self.old_rpy + (1.0 - self.old_rpy_weight) * self.rpy
+    else:
+      return self.rpy
+
+  def handle_cam_odom(self, trans: list[float],
+                            rot: list[float],
+                            wide_from_device_euler: list[float],
+                            trans_std: list[float],
+                            road_transform_trans: list[float],
+                            road_transform_trans_std: list[float]) -> np.ndarray | None:
+    self.old_rpy_weight = max(0.0, self.old_rpy_weight - 1/SMOOTH_CYCLES)
+
+    fast_enough = self.v_ego > MIN_SPEED_FILTER
+    motion_speed = max(float(self.v_ego), float(trans[0]))
+    cam_fast_enough = motion_speed > MIN_SPEED_FILTER
+    yaw_ok = abs(rot[2]) < MAX_YAW_RATE_FILTER
+    straight_and_fast = fast_enough and cam_fast_enough and yaw_ok
+    angle_std_threshold = MAX_VEL_ANGLE_STD
+    height_std_threshold = MAX_HEIGHT_STD
+    rpy_certain = np.arctan2(trans_std[1], motion_speed) < angle_std_threshold
+    if len(road_transform_trans_std) == 3:
+      height_certain = road_transform_trans_std[2] < height_std_threshold
+    else:
+      height_certain = True
+
+    certain_if_calib = rpy_certain
+    if not (straight_and_fast and certain_if_calib):
+      log_issue_limited(
+        "calibrationd_rejected_sample",
+        "calibration",
+        f"calibrationd rejected sample vEgo={self.v_ego:.2f} trans0={trans[0]:.2f} yawRate={rot[2]:.4f} "
+        f"fast_enough={fast_enough} cam_fast_enough={cam_fast_enough} motion_speed={motion_speed:.2f} yaw_ok={yaw_ok} "
+        f"rpy_certain={rpy_certain} height_certain={height_certain} valid_blocks={self.valid_blocks} idx={self.idx}",
+        interval_sec=1.0,
+      )
+      return None
+
+    observed_rpy = np.array([0,
+                             -np.arctan2(trans[2], trans[0]),
+                             np.arctan2(trans[1], trans[0])])
+    new_rpy = euler_from_rot(rot_from_euler(self.get_smooth_rpy()).dot(rot_from_euler(observed_rpy)))
+    new_rpy = sanity_clip(new_rpy)
+
+    if len(wide_from_device_euler) == 3:
+      new_wide_from_device_euler = np.array(wide_from_device_euler)
+    else:
+      new_wide_from_device_euler = WIDE_FROM_DEVICE_EULER_INIT
+
+    if len(road_transform_trans) == 3 and HEIGHT_SANE_MIN <= road_transform_trans[2] <= HEIGHT_SANE_MAX:
+      new_height = np.array([road_transform_trans[2]])
+    else:
+      new_height = HEIGHT_INIT
+
+    self.rpys[self.block_idx] = moving_avg_with_linear_decay(self.rpys[self.block_idx], new_rpy, self.idx, float(BLOCK_SIZE))
+    self.wide_from_device_eulers[self.block_idx] = moving_avg_with_linear_decay(self.wide_from_device_eulers[self.block_idx],
+                                                                                new_wide_from_device_euler, self.idx, float(BLOCK_SIZE))
+    self.heights[self.block_idx] = moving_avg_with_linear_decay(self.heights[self.block_idx], new_height, self.idx, float(BLOCK_SIZE))
+
+    self.idx = (self.idx + 1) % BLOCK_SIZE
+    if self.idx == 0:
+      self.block_idx += 1
+      self.valid_blocks = max(self.block_idx, self.valid_blocks)
+      self.block_idx = self.block_idx % INPUTS_WANTED
+
+    self.update_status()
+
+    if self.idx == 0:
+      log_issue_limited(
+        "calibrationd_progress_block",
+        "calibration",
+        f"calibrationd progress status={int(self.cal_status)} valid_blocks={self.valid_blocks} "
+        f"calPerc={min(100 * (self.valid_blocks * BLOCK_SIZE + self.idx) // (INPUTS_NEEDED * BLOCK_SIZE), 100)} "
+        f"rpy={self.rpy.tolist()} spread={self.calib_spread.tolist()}",
+        interval_sec=0.5,
+      )
+
+    return new_rpy
+
+  def get_msg(self, valid: bool) -> capnp.lib.capnp._DynamicStructBuilder:
+    smooth_rpy = self.get_smooth_rpy()
+
+    msg = messaging.new_message('extrinsicsCalibration')
+    msg.valid = valid
+
+    extrinsicsCalibration = msg.extrinsicsCalibration
+    extrinsicsCalibration.validBlocks = self.valid_blocks
+    extrinsicsCalibration.calStatus = self.cal_status
+    extrinsicsCalibration.calPerc = min(100 * (self.valid_blocks * BLOCK_SIZE + self.idx) // (INPUTS_NEEDED * BLOCK_SIZE), 100)
+    extrinsicsCalibration.rpyCalib = smooth_rpy.tolist()
+    extrinsicsCalibration.rpyCalibSpread = self.calib_spread.tolist()
+    extrinsicsCalibration.wideFromDeviceEuler = self.wide_from_device_euler.tolist()
+    extrinsicsCalibration.height = self.height.tolist()
+
+    return msg
+
+  def send_data(self, pm: messaging.PubMaster, valid: bool) -> None:
+    pm.send('extrinsicsCalibration', self.get_msg(valid))
+
+
+def main() -> NoReturn:
+  config_realtime_process([0, 1, 2, 3], 5)
+
+  pm = messaging.PubMaster(['extrinsicsCalibration'])
+  sm = messaging.SubMaster(['cameraOdometry', 'carState'], poll='cameraOdometry')
+
+  params_reader = Params()
+  CP = messaging.log_from_bytes(params_reader.get("CarParams", block=True), car.CarParams)
+
+  calibrator = Calibrator(param_put=True)
+  calibrator.not_car = CP.notCar
+
+  while 1:
+    timeout = 0 if sm.frame == -1 else 100
+    sm.update(timeout)
+
+    if sm.updated['cameraOdometry']:
+      calibrator.handle_v_ego(sm['carState'].vEgo)
+      new_rpy = calibrator.handle_cam_odom(sm['cameraOdometry'].trans,
+                                           sm['cameraOdometry'].rot,
+                                           sm['cameraOdometry'].wideFromDeviceEuler,
+                                           sm['cameraOdometry'].transStd,
+                                           sm['cameraOdometry'].roadTransformTrans,
+                                           sm['cameraOdometry'].roadTransformTransStd)
+
+      if DEBUG and new_rpy is not None:
+        print('got new rpy', new_rpy)
+
+    # 4Hz driven by cameraOdometry
+    if sm.frame % 5 == 0:
+      checks_ok = sm.all_checks()
+      if not checks_ok:
+        ft = sm.freq_tracker
+        recv_hz = {s: (round(1.0 / ft[s].avg_dt.get_average(), 2) if ft[s].avg_dt.count else None) for s in sm.services}
+        log_issue_limited(
+          "calibrationd_checks_failed",
+          "calibration",
+          f"calibrationd all_checks failed alive={sm.alive} freq_ok={sm.freq_ok} valid={sm.valid} "
+          f"seen={sm.seen} recv_hz={recv_hz}",
+          interval_sec=5.0,
+        )
+      calibrator.send_data(pm, checks_ok)
+
+
+if __name__ == "__main__":
+  main()

artifacts/iqpilot_hephaestusd_private/python/_iqclosure/iqpilot/selfdrive/selfdrived/alertmanager.py

@@ -0,0 +1,68 @@
+import copy
+import os
+import json
+from collections import defaultdict
+from dataclasses import dataclass
+
+from iqpilot.common.basedir import BASEDIR
+from iqpilot.common.params import Params
+from iqpilot.selfdrive.selfdrived.events import Alert
+from iqpilot.common.atlas_alerts import NULL_ALERT as EmptyAlert
+
+
+with open(os.path.join(BASEDIR, "iqpilot/selfdrive/selfdrived/alerts_offroad.json")) as f:
+  OFFROAD_ALERTS = json.load(f)
+
+
+def set_offroad_alert(alert: str, show_alert: bool, extra_text: str | None = None) -> None:
+  if show_alert:
+    a = copy.copy(OFFROAD_ALERTS[alert])
+    a['extra'] = extra_text or ''
+    Params().put(alert, a)
+  else:
+    Params().remove(alert)
+
+
+@dataclass
+class AlertEntry:
+  alert: Alert | None = None
+  start_frame: int = -1
+  end_frame: int = -1
+  added_frame: int = -1
+
+  def active(self, frame: int) -> bool:
+    return frame <= self.end_frame
+
+  def just_added(self, frame: int) -> bool:
+    return self.active(frame) and frame == (self.added_frame + 1)
+
+class AlertManager:
+  def __init__(self):
+    self.alerts: dict[str, AlertEntry] = defaultdict(AlertEntry)
+    self.current_alert = EmptyAlert
+
+  def add_many(self, frame: int, alerts: list[Alert]) -> None:
+    for alert in alerts:
+      entry = self.alerts[alert.alert_type]
+      entry.alert = alert
+      if not entry.just_added(frame):
+        entry.start_frame = frame
+      min_end_frame = entry.start_frame + alert.duration
+      entry.end_frame = max(frame + 1, min_end_frame)
+      entry.added_frame = frame
+
+  def process_alerts(self, frame: int, clear_event_types: set):
+    ae = AlertEntry()
+    for v in self.alerts.values():
+      if not v.alert:
+        continue
+
+      if v.alert.event_type in clear_event_types:
+        v.end_frame = -1
+
+      # sort by priority first and then by start_frame
+      greater = ae.alert is None or (v.alert.priority, v.start_frame) > (ae.alert.priority, ae.start_frame)
+      if v.active(frame) and greater:
+        ae = v
+
+    self.current_alert = ae.alert if ae.alert is not None else EmptyAlert

artifacts/iqpilot_hephaestusd_private/python/_iqclosure/iqpilot/selfdrive/selfdrived/events.py

@@ -0,0 +1,974 @@
+#!/usr/bin/env python3
+import math
+
+from iqpilot.cereal import log, car
+import iqpilot.cereal.messaging as messaging
+from iqpilot.common.constants import CV
+from iqpilot.common.realtime import DT_CTRL
+from iqpilot.selfdrive.locationd.calibrationd import MIN_SPEED_FILTER
+from iqpilot.system.micd import SAMPLE_RATE, SAMPLE_BUFFER
+from iqpilot.selfdrive.ui.feedback.feedbackd import FEEDBACK_MAX_DURATION
+from iqpilot.system.hardware import HARDWARE
+
+from iqpilot.common.atlas_alerts import EventBook as EventsBase, Tier as Priority, Tags as ET, AlertCard as Alert, \
+  NoEntryCard as NoEntryAlert, GentleDisableCard as SoftDisableAlert, PendingDisableCard as UserSoftDisableAlert, \
+  HardDisableCard as ImmediateDisableAlert, ChimeCard as EngagementAlert, BannerCard as NormalPermanentAlert, \
+  BootCard as StartupAlert, AlertFactory as AlertCallbackType, car_mode_entry_alert as wrong_car_mode_alert
+
+
+AlertSize = log.SelfdriveState.AlertSize
+AlertStatus = log.SelfdriveState.AlertStatus
+VisualAlert = car.CarControl.HUDControl.VisualAlert
+AudibleAlert = car.CarControl.HUDControl.AudibleAlert
+EventName = log.OnroadEvent.EventName
+
+
+# get event name from enum
+EVENT_NAME = {v: k for k, v in EventName.schema.enumerants.items()}
+
+
+class Events(EventsBase):
+  def __init__(self):
+    super().__init__()
+    self.event_counters = dict.fromkeys(EVENTS.keys(), 0)
+
+  def get_events_mapping(self) -> dict[int, dict[str, Alert | AlertCallbackType]]:
+    return EVENTS
+
+  def get_event_name(self, event: int):
+    return EVENT_NAME[event]
+
+  def get_event_msg_type(self):
+    return log.OnroadEvent
+
+
+
+# ********** helper functions **********
+def get_display_speed(speed_ms: float, metric: bool) -> str:
+  speed = int(round(speed_ms * (CV.MS_TO_KPH if metric else CV.MS_TO_MPH)))
+  unit = 'km/h' if metric else 'mph'
+  return f"{speed} {unit}"
+
+
+# ********** alert callback functions **********
+
+
+def soft_disable_alert(alert_text_2: str) -> AlertCallbackType:
+  def func(CP: car.CarParams, CS: car.CarState, sm: messaging.SubMaster, metric: bool, soft_disable_time: int, personality) -> Alert:
+    if soft_disable_time < int(0.5 / DT_CTRL):
+      return ImmediateDisableAlert(alert_text_2)
+    return SoftDisableAlert(alert_text_2)
+  return func
+
+def user_soft_disable_alert(alert_text_2: str) -> AlertCallbackType:
+  def func(CP: car.CarParams, CS: car.CarState, sm: messaging.SubMaster, metric: bool, soft_disable_time: int, personality) -> Alert:
+    if soft_disable_time < int(0.5 / DT_CTRL):
+      return ImmediateDisableAlert(alert_text_2)
+    return UserSoftDisableAlert(alert_text_2)
+  return func
+
+def below_engage_speed_alert(CP: car.CarParams, CS: car.CarState, sm: messaging.SubMaster, metric: bool, soft_disable_time: int, personality) -> Alert:
+  return NoEntryAlert(f"Drive above {get_display_speed(CP.minEnableSpeed, metric)} to engage")
+
+
+def below_steer_speed_alert(CP: car.CarParams, CS: car.CarState, sm: messaging.SubMaster, metric: bool, soft_disable_time: int, personality) -> Alert:
+  return Alert(
+    f"Steer Assist Unavailable Below {get_display_speed(CP.minSteerSpeed, metric)}",
+    "",
+    AlertStatus.userPrompt, AlertSize.small,
+    Priority.LOW, VisualAlert.none, AudibleAlert.prompt, 0.4)
+
+
+def calibration_incomplete_alert(CP: car.CarParams, CS: car.CarState, sm: messaging.SubMaster, metric: bool, soft_disable_time: int, personality) -> Alert:
+  first_word = 'Recalibrating' if sm['extrinsicsCalibration'].calStatus == log.ExtrinsicsCalibration.Status.recalibrating else 'Calibrating'
+  return Alert(
+    f"{first_word}: {sm['extrinsicsCalibration'].calPerc:.0f}%",
+    f"Drive Above {get_display_speed(MIN_SPEED_FILTER, metric)}",
+    AlertStatus.normal, AlertSize.mid,
+    Priority.LOWEST, VisualAlert.none, AudibleAlert.none, .2)
+
+
+def audio_feedback_alert(CP: car.CarParams, CS: car.CarState, sm: messaging.SubMaster, metric: bool, soft_disable_time: int, personality) -> Alert:
+  duration = FEEDBACK_MAX_DURATION - ((sm['audioFeedback'].blockNum + 1) * SAMPLE_BUFFER / SAMPLE_RATE)
+  return NormalPermanentAlert(
+    "Recording Audio Feedback",
+    f"{round(duration)} second{'s' if round(duration) != 1 else ''} remaining. Press again to save early.",
+    priority=Priority.LOW)
+
+
+# *** debug alerts ***
+
+def out_of_space_alert(CP: car.CarParams, CS: car.CarState, sm: messaging.SubMaster, metric: bool, soft_disable_time: int, personality) -> Alert:
+  full_perc = round(100. - sm['deviceState'].freeSpacePercent)
+  return NormalPermanentAlert("Out of Storage", f"{full_perc}% full")
+
+
+def posenet_invalid_alert(CP: car.CarParams, CS: car.CarState, sm: messaging.SubMaster, metric: bool, soft_disable_time: int, personality) -> Alert:
+  if sm.frame * DT_CTRL < 10.:
+    return NoEntryAlert("IQModel is starting up", alert_text_1="Please Wait")
+  mdl = sm['modelV2'].velocity.x[0] if len(sm['modelV2'].velocity.x) else math.nan
+  err = CS.vEgo - mdl
+  msg = f"Speed Error: {err:.1f} m/s"
+  return NoEntryAlert(msg, alert_text_1="Posenet Speed Invalid")
+
+
+def process_not_running_alert(CP: car.CarParams, CS: car.CarState, sm: messaging.SubMaster, metric: bool, soft_disable_time: int, personality) -> Alert:
+  not_running = [p.name for p in sm['managerState'].processes if not p.running and p.shouldBeRunning]
+  msg = ', '.join(not_running)
+  return NoEntryAlert(msg, alert_text_1="Process Not Running")
+
+
+def comm_issue_alert(CP: car.CarParams, CS: car.CarState, sm: messaging.SubMaster, metric: bool, soft_disable_time: int, personality) -> Alert:
+  bs = [s for s in sm.data.keys() if not sm.all_checks([s, ])]
+  msg = ', '.join(bs[:4])  # can't fit too many on one line
+  return NoEntryAlert(msg, alert_text_1="Communication Issue Between Processes")
+
+
+def camera_malfunction_alert(CP: car.CarParams, CS: car.CarState, sm: messaging.SubMaster, metric: bool, soft_disable_time: int, personality) -> Alert:
+  all_cams = ('roadCameraState', 'driverCameraState', 'wideRoadCameraState')
+  bad_cams = [s.replace('State', '') for s in all_cams if s in sm.data.keys() and not sm.all_checks([s, ])]
+  return NormalPermanentAlert("Camera Malfunction", ', '.join(bad_cams))
+
+
+def calibration_invalid_alert(CP: car.CarParams, CS: car.CarState, sm: messaging.SubMaster, metric: bool, soft_disable_time: int, personality) -> Alert:
+  rpy = sm['extrinsicsCalibration'].rpyCalib
+  yaw = math.degrees(rpy[2] if len(rpy) == 3 else math.nan)
+  pitch = math.degrees(rpy[1] if len(rpy) == 3 else math.nan)
+  angles = f"Remount Device (Pitch: {pitch:.1f}°, Yaw: {yaw:.1f}°)"
+  return NormalPermanentAlert("Calibration Invalid", angles)
+
+
+def paramsd_invalid_alert(CP: car.CarParams, CS: car.CarState, sm: messaging.SubMaster, metric: bool, soft_disable_time: int, personality) -> Alert:
+  if not sm['vehicleParameters'].angleOffsetValid:
+    angle_offset_deg = sm['vehicleParameters'].angleOffsetDeg
+    title = "Steering misalignment detected"
+    text = f"Angle offset too high (Offset: {angle_offset_deg:.1f}°)"
+  elif not sm['vehicleParameters'].steerRatioValid:
+    steer_ratio = sm['vehicleParameters'].steerRatio
+    title = "Steer ratio mismatch"
+    text = f"Steering rack geometry may be off (Ratio: {steer_ratio:.1f})"
+  elif not sm['vehicleParameters'].stiffnessFactorValid:
+    stiffness_factor = sm['vehicleParameters'].stiffnessFactor
+    title = "Abnormal tire stiffness"
+    text = f"Check tires, pressure, or alignment (Factor: {stiffness_factor:.1f})"
+  else:
+    return NoEntryAlert("paramsd Temporary Error")
+
+  return NoEntryAlert(alert_text_1=title, alert_text_2=text)
+
+def overheat_alert(CP: car.CarParams, CS: car.CarState, sm: messaging.SubMaster, metric: bool, soft_disable_time: int, personality) -> Alert:
+  cpu = max(sm['deviceState'].cpuTempC, default=0.)
+  gpu = max(sm['deviceState'].gpuTempC, default=0.)
+  temp = max((cpu, gpu, sm['deviceState'].memoryTempC))
+  return NormalPermanentAlert("System Overheated", f"{temp:.0f} °C")
+
+
+def low_memory_alert(CP: car.CarParams, CS: car.CarState, sm: messaging.SubMaster, metric: bool, soft_disable_time: int, personality) -> Alert:
+  return NormalPermanentAlert("Low Memory", f"{sm['deviceState'].memoryUsagePercent}% used")
+
+
+def high_cpu_usage_alert(CP: car.CarParams, CS: car.CarState, sm: messaging.SubMaster, metric: bool, soft_disable_time: int, personality) -> Alert:
+  x = max(sm['deviceState'].cpuUsagePercent, default=0.)
+  return NormalPermanentAlert("High CPU Usage", f"{x}% used")
+
+
+def modeld_lagging_alert(CP: car.CarParams, CS: car.CarState, sm: messaging.SubMaster, metric: bool, soft_disable_time: int, personality) -> Alert:
+  return NormalPermanentAlert("Driving Model Lagging", f"{sm['modelV2'].frameDropPerc:.1f}% frames dropped")
+
+
+def _joystick_axes(sm: messaging.SubMaster) -> tuple[float, float] | None:
+  if 'testJoystick' not in sm.data or sm.recv_frame['testJoystick'] == 0:
+    return None
+
+  axes = list(sm['testJoystick'].axes)
+  if len(axes) < 2:
+    return None
+
+  return float(axes[0]), float(axes[1])
+
+
+def joystick_alert(CP: car.CarParams, CS: car.CarState, sm: messaging.SubMaster, metric: bool, soft_disable_time: int, personality) -> Alert:
+  gb = sm['carControl'].actuators.accel / 4.
+  if CP.steerControlType in (car.CarParams.SteerControlType.angle, car.CarParams.SteerControlType.curvatureDEPRECATED):
+    steer = sm['carControl'].actuators.steeringAngleDeg
+    vals = f"Gas: {round(gb * 100.)}%, Angle: {round(steer, 1)}°"
+  else:
+    steer = sm['carControl'].actuators.torque
+    vals = f"Gas: {round(gb * 100.)}%, Steer: {round(steer * 100.)}%"
+  return NormalPermanentAlert("Joystick Mode", vals)
+
+
+def longitudinal_maneuver_alert(CP: car.CarParams, CS: car.CarState, sm: messaging.SubMaster, metric: bool, soft_disable_time: int, personality) -> Alert:
+  ad = sm['alertDebug']
+  audible_alert = AudibleAlert.prompt if 'Active' in ad.alertText1 else AudibleAlert.none
+  alert_status = AlertStatus.userPrompt if 'Active' in ad.alertText1 else AlertStatus.normal
+  alert_size = AlertSize.mid if ad.alertText2 else AlertSize.small
+  return Alert(ad.alertText1, ad.alertText2,
+               alert_status, alert_size,
+               Priority.LOW, VisualAlert.none, audible_alert, 0.2)
+
+
+def personality_changed_alert(CP: car.CarParams, CS: car.CarState, sm: messaging.SubMaster, metric: bool, soft_disable_time: int, personality) -> Alert:
+  personality = str(personality).title()
+  return NormalPermanentAlert(f"Driving Personality: {personality}", duration=1.5)
+
+
+def invalid_lkas_setting_alert(CP: car.CarParams, CS: car.CarState, sm: messaging.SubMaster, metric: bool, soft_disable_time: int, personality) -> Alert:
+  title = "Invalid LKAS setting"
+  text = "Toggle stock LKAS on or off to engage"
+  if CP.brand == "tesla":
+    title = "Dashcam Mode"
+    text = "FSD / Autosteer is active"
+  elif CP.brand == "mazda":
+    text = "Enable your car's LKAS to engage"
+  elif CP.brand == "nissan":
+    text = "Disable your car's stock LKAS to engage"
+  return NormalPermanentAlert(title, text)
+
+
+def invalid_lkas_setting_no_entry_alert(CP: car.CarParams, CS: car.CarState, sm: messaging.SubMaster,
+                                        metric: bool, soft_disable_time: int, personality) -> Alert:
+  if CP.brand == "tesla":
+    return NoEntryAlert("FSD / Autosteer is active", alert_text_1="Dashcam Mode")
+  return NoEntryAlert("Invalid LKAS setting")
+
+
+
+EVENTS: dict[int, dict[str, Alert | AlertCallbackType]] = {
+  # ********** events with no alerts **********
+
+  EventName.stockFcw: {},
+  EventName.actuatorsApiUnavailable: {},
+
+  # ********** events only containing alerts displayed in all states **********
+
+  EventName.joystickDebug: {
+    ET.WARNING: joystick_alert,
+    ET.PERMANENT: NormalPermanentAlert("Joystick Mode"),
+  },
+
+  EventName.longitudinalManeuver: {
+    ET.WARNING: longitudinal_maneuver_alert,
+    ET.PERMANENT: NormalPermanentAlert("Longitudinal Maneuver Mode",
+                                       "Ensure road ahead is clear"),
+  },
+
+  EventName.lateralManeuver: {
+    ET.WARNING: longitudinal_maneuver_alert,
+    ET.PERMANENT: NormalPermanentAlert("Lateral Maneuver Mode"),
+  },
+
+  EventName.selfdriveInitializing: {
+    ET.NO_ENTRY: NoEntryAlert("IQ.Pilot Initializing"),
+  },
+
+  EventName.startup: {
+    ET.PERMANENT: StartupAlert("Welcome to IQ.Pilot!")
+  },
+
+  EventName.startupMaster: {
+    ET.PERMANENT: StartupAlert("Welcome to IQ.Pilot!"),
+  },
+
+  EventName.startupNoControl: {
+    ET.PERMANENT: StartupAlert("Dashcam mode"),
+    ET.NO_ENTRY: NoEntryAlert("Dashcam mode"),
+  },
+
+  EventName.startupNoCar: {
+    ET.PERMANENT: StartupAlert("IQ.Pilot Dashcam mode: car unrecognized"),
+  },
+
+  EventName.startupNoSecOcKey: {
+    ET.PERMANENT: NormalPermanentAlert("Dashcam Mode",
+                                       "TSK Security Key Not Available",
+                                       priority=Priority.HIGH),
+  },
+
+  EventName.dashcamMode: {
+    ET.PERMANENT: NormalPermanentAlert("Dashcam Mode",
+                                       priority=Priority.LOWEST),
+  },
+
+  EventName.invalidLkasSetting: {
+    ET.PERMANENT: invalid_lkas_setting_alert,
+    ET.NO_ENTRY: invalid_lkas_setting_no_entry_alert,
+  },
+
+  EventName.cruiseMismatch: {
+    #ET.PERMANENT: ImmediateDisableAlert("openpilot failed to cancel cruise"),
+  },
+
+  # openpilot doesn't recognize the car. This switches openpilot into a
+  # read-only mode. This can be solved by adding your fingerprint.
+  # See https://github.com/commaai/openpilot/wiki/Fingerprinting for more information
+  EventName.carUnrecognized: {
+    ET.PERMANENT: NormalPermanentAlert("Dashcam Mode",
+                                       "Car Unrecognized",
+                                       priority=Priority.LOWEST),
+  },
+
+  EventName.aeb: {
+    ET.PERMANENT: Alert(
+      "BRAKE!",
+      "Emergency Braking: Risk of Collision",
+      AlertStatus.critical, AlertSize.full,
+      Priority.HIGHEST, VisualAlert.fcw, AudibleAlert.none, 2.),
+    ET.NO_ENTRY: NoEntryAlert("AEB: Risk of Collision"),
+  },
+
+  EventName.stockAeb: {
+    ET.PERMANENT: Alert(
+      "BRAKE!",
+      "Stock AEB: Risk of Collision",
+      AlertStatus.critical, AlertSize.full,
+      Priority.HIGHEST, VisualAlert.fcw, AudibleAlert.none, 2.),
+    ET.NO_ENTRY: NoEntryAlert("Stock AEB: Risk of Collision"),
+  },
+
+  EventName.stockLkas: {
+    ET.PERMANENT: Alert(
+      "Stock LKAS: Lane Departure Detected",
+      "",
+      AlertStatus.userPrompt, AlertSize.small,
+      Priority.LOW, VisualAlert.ldw, AudibleAlert.prompt, 3.),
+    ET.NO_ENTRY: NoEntryAlert("Stock LKAS: Lane Departure Detected"),
+  },
+
+  EventName.fcw: {
+    ET.PERMANENT: Alert(
+      "BRAKE!",
+      "Risk of Collision",
+      AlertStatus.critical, AlertSize.full,
+      Priority.HIGHEST, VisualAlert.fcw, AudibleAlert.warningSoft, 2.),
+  },
+
+  EventName.ldw: {
+    ET.PERMANENT: Alert(
+      "Lane Departure Detected",
+      "",
+      AlertStatus.userPrompt, AlertSize.small,
+      Priority.LOW, VisualAlert.ldw, AudibleAlert.prompt, 3.),
+  },
+
+  # ********** events only containing alerts that display while engaged **********
+
+  EventName.steerTempUnavailableSilent: {
+    ET.WARNING: Alert(
+      "Steering Assist Temporarily Unavailable",
+      "",
+      AlertStatus.userPrompt, AlertSize.small,
+      Priority.LOW, VisualAlert.steerRequired, AudibleAlert.prompt, 1.8),
+  },
+
+  EventName.preDriverDistracted: {
+    ET.PERMANENT: Alert(
+      "Pay Attention",
+      "",
+      AlertStatus.normal, AlertSize.small,
+      Priority.LOW, VisualAlert.none, AudibleAlert.none, .1),
+  },
+
+  EventName.promptDriverDistracted: {
+    ET.PERMANENT: Alert(
+      "Pay Attention",
+      "Driver Distracted",
+      AlertStatus.userPrompt, AlertSize.mid,
+      Priority.MID, VisualAlert.steerRequired, AudibleAlert.promptDistracted, .1),
+  },
+
+  EventName.driverDistracted: {
+    ET.PERMANENT: Alert(
+      "DISENGAGE IMMEDIATELY",
+      "Driver Distracted",
+      AlertStatus.critical, AlertSize.full,
+      Priority.HIGH, VisualAlert.steerRequired, AudibleAlert.warningImmediate, .1),
+  },
+
+  EventName.preDriverUnresponsive: {
+    ET.PERMANENT: Alert(
+      "Touch Steering Wheel: No Face Detected",
+      "",
+      AlertStatus.normal, AlertSize.small,
+      Priority.LOW, VisualAlert.steerRequired, AudibleAlert.none, .1),
+  },
+
+  EventName.promptDriverUnresponsive: {
+    ET.PERMANENT: Alert(
+      "Touch Steering Wheel",
+      "Driver Unresponsive",
+      AlertStatus.userPrompt, AlertSize.mid,
+      Priority.MID, VisualAlert.steerRequired, AudibleAlert.promptDistracted, .1),
+  },
+
+  EventName.driverUnresponsive: {
+    ET.PERMANENT: Alert(
+      "DISENGAGE IMMEDIATELY",
+      "Driver Unresponsive",
+      AlertStatus.critical, AlertSize.full,
+      Priority.HIGH, VisualAlert.steerRequired, AudibleAlert.warningImmediate, .1),
+  },
+
+  EventName.manualRestart: {
+    ET.WARNING: Alert(
+      "TAKE CONTROL",
+      "Resume Driving Manually",
+      AlertStatus.userPrompt, AlertSize.mid,
+      Priority.LOW, VisualAlert.none, AudibleAlert.none, .2),
+  },
+
+  EventName.resumeRequired: {
+    ET.WARNING: Alert(
+      "Press Resume to Exit Standstill",
+      "",
+      AlertStatus.userPrompt, AlertSize.small,
+      Priority.LOW, VisualAlert.none, AudibleAlert.none, .2),
+  },
+
+  EventName.belowSteerSpeed: {
+    ET.WARNING: below_steer_speed_alert,
+  },
+
+  EventName.preLaneChangeLeft: {
+    ET.WARNING: Alert(
+      "Steer Left to Start Lane Change Once Safe",
+      "",
+      AlertStatus.normal, AlertSize.small,
+      Priority.LOW, VisualAlert.none, AudibleAlert.none, .1),
+  },
+
+  EventName.preLaneChangeRight: {
+    ET.WARNING: Alert(
+      "Steer Right to Start Lane Change Once Safe",
+      "",
+      AlertStatus.normal, AlertSize.small,
+      Priority.LOW, VisualAlert.none, AudibleAlert.none, .1),
+  },
+
+  EventName.laneChangeBlocked: {
+    ET.WARNING: Alert(
+      "Car Detected in Blindspot",
+      "",
+      AlertStatus.userPrompt, AlertSize.small,
+      Priority.LOW, VisualAlert.none, AudibleAlert.prompt, .1),
+  },
+
+  EventName.laneChange: {
+    ET.WARNING: Alert(
+      "Changing Lanes",
+      "",
+      AlertStatus.normal, AlertSize.small,
+      Priority.LOW, VisualAlert.none, AudibleAlert.none, .1),
+  },
+
+  EventName.steerSaturated: {
+    ET.WARNING: Alert(
+      "Take Control",
+      "Turn Exceeds Steering Limit",
+      AlertStatus.userPrompt, AlertSize.mid,
+      Priority.LOW, VisualAlert.steerRequired, AudibleAlert.promptRepeat, 2.),
+  },
+
+  # Thrown when the fan is driven at >50% but is not rotating
+  EventName.fanMalfunction: {
+    ET.PERMANENT: NormalPermanentAlert("Fan Malfunction", "Likely Hardware Issue"),
+  },
+
+  # Camera is not outputting frames
+  EventName.cameraMalfunction: {
+    ET.PERMANENT: camera_malfunction_alert,
+    ET.SOFT_DISABLE: soft_disable_alert("Camera Malfunction"),
+    ET.NO_ENTRY: NoEntryAlert("Camera Malfunction: Reboot Your Device"),
+  },
+  # Camera framerate too low
+  EventName.cameraFrameRate: {
+    ET.PERMANENT: NormalPermanentAlert("Camera Frame Rate Low", "Reboot your Device"),
+    ET.SOFT_DISABLE: soft_disable_alert("Camera Frame Rate Low"),
+    ET.NO_ENTRY: NoEntryAlert("Camera Frame Rate Low: Reboot Your Device"),
+  },
+
+  # Unused
+
+  EventName.locationdTemporaryError: {
+    ET.NO_ENTRY: NoEntryAlert("locationd Temporary Error"),
+    ET.SOFT_DISABLE: soft_disable_alert("locationd Temporary Error"),
+  },
+
+  EventName.locationdPermanentError: {
+    ET.NO_ENTRY: NoEntryAlert("locationd Permanent Error"),
+    ET.IMMEDIATE_DISABLE: ImmediateDisableAlert("locationd Permanent Error"),
+    ET.PERMANENT: NormalPermanentAlert("locationd Permanent Error"),
+  },
+
+  # openpilot tries to learn certain parameters about your car by observing
+  # how the car behaves to steering inputs from both human and openpilot driving.
+  # This includes:
+  # - steer ratio: gear ratio of the steering rack. Steering angle divided by tire angle
+  # - tire stiffness: how much grip your tires have
+  # - angle offset: most steering angle sensors are offset and measure a non zero angle when driving straight
+  # This alert is thrown when any of these values exceed a sanity check. This can be caused by
+  # bad alignment or bad sensor data. If this happens consistently consider creating an issue on GitHub
+  EventName.paramsdTemporaryError: {
+    ET.NO_ENTRY: paramsd_invalid_alert,
+    ET.SOFT_DISABLE: soft_disable_alert("paramsd Temporary Error"),
+  },
+
+  EventName.paramsdPermanentError: {
+    ET.NO_ENTRY: NoEntryAlert("paramsd Permanent Error"),
+    ET.IMMEDIATE_DISABLE: ImmediateDisableAlert("paramsd Permanent Error"),
+    ET.PERMANENT: NormalPermanentAlert("paramsd Permanent Error"),
+  },
+
+  # ********** events that affect controls state transitions **********
+
+  EventName.pcmEnable: {
+    ET.ENABLE: EngagementAlert(AudibleAlert.engage),
+  },
+
+  EventName.buttonEnable: {
+    ET.ENABLE: EngagementAlert(AudibleAlert.engage),
+  },
+
+  EventName.pcmDisable: {
+    ET.USER_DISABLE: EngagementAlert(AudibleAlert.disengage),
+  },
+
+  EventName.buttonCancel: {
+    ET.USER_DISABLE: EngagementAlert(AudibleAlert.disengage),
+    ET.NO_ENTRY: NoEntryAlert("Cancel Pressed"),
+  },
+
+  EventName.brakeHold: {
+    ET.WARNING: Alert(
+      "Press Resume to Exit Brake Hold",
+      "",
+      AlertStatus.userPrompt, AlertSize.small,
+      Priority.LOW, VisualAlert.none, AudibleAlert.none, .2),
+  },
+
+  EventName.parkBrake: {
+    ET.USER_DISABLE: EngagementAlert(AudibleAlert.disengage),
+    ET.NO_ENTRY: NoEntryAlert("Parking Brake Engaged"),
+  },
+
+  EventName.pedalPressed: {
+    ET.USER_DISABLE: EngagementAlert(AudibleAlert.disengage),
+    ET.NO_ENTRY: NoEntryAlert("Pedal Pressed",
+                              visual_alert=VisualAlert.brakePressed),
+  },
+
+  EventName.steerDisengage: {
+    ET.USER_DISABLE: EngagementAlert(AudibleAlert.disengage),
+    ET.NO_ENTRY: NoEntryAlert("Steering Pressed"),
+  },
+
+  EventName.preEnableStandstill: {
+    ET.PRE_ENABLE: Alert(
+      "Release Brake to Engage",
+      "",
+      AlertStatus.normal, AlertSize.small,
+      Priority.LOWEST, VisualAlert.none, AudibleAlert.none, .1, creation_delay=1.),
+  },
+
+  EventName.gasPressedOverride: {
+    ET.OVERRIDE_LONGITUDINAL: Alert(
+      "",
+      "",
+      AlertStatus.normal, AlertSize.none,
+      Priority.LOWEST, VisualAlert.none, AudibleAlert.none, .1),
+  },
+
+  EventName.steerOverride: {
+    ET.OVERRIDE_LATERAL: Alert(
+      "",
+      "",
+      AlertStatus.normal, AlertSize.none,
+      Priority.LOWEST, VisualAlert.none, AudibleAlert.none, .1),
+  },
+
+  EventName.wrongCarMode: {
+    ET.USER_DISABLE: EngagementAlert(AudibleAlert.disengage),
+    ET.NO_ENTRY: wrong_car_mode_alert,
+  },
+
+  EventName.resumeBlocked: {
+    ET.NO_ENTRY: NoEntryAlert("Press Set to Engage"),
+  },
+
+  EventName.wrongCruiseMode: {
+    ET.USER_DISABLE: EngagementAlert(AudibleAlert.disengage),
+    ET.NO_ENTRY: NoEntryAlert("Adaptive Cruise Disabled"),
+  },
+
+  EventName.steerTempUnavailable: {
+    ET.SOFT_DISABLE: soft_disable_alert("Steering Assist Temporarily Unavailable"),
+    ET.NO_ENTRY: NoEntryAlert("Steering Temporarily Unavailable"),
+  },
+
+  EventName.steerTimeLimit: {
+    ET.SOFT_DISABLE: soft_disable_alert("Vehicle Steering Time Limit"),
+    ET.NO_ENTRY: NoEntryAlert("Vehicle Steering Time Limit"),
+  },
+
+  EventName.outOfSpace: {
+    ET.PERMANENT: out_of_space_alert,
+    ET.NO_ENTRY: NoEntryAlert("Out of Storage"),
+  },
+
+  EventName.belowEngageSpeed: {
+    ET.NO_ENTRY: below_engage_speed_alert,
+  },
+
+  EventName.sensorDataInvalid: {
+    ET.PERMANENT: Alert(
+      "Sensor Data Invalid",
+      "Possible Hardware Issue",
+      AlertStatus.normal, AlertSize.mid,
+      Priority.LOWER, VisualAlert.none, AudibleAlert.none, .2, creation_delay=1.),
+    ET.NO_ENTRY: NoEntryAlert("Sensor Data Invalid"),
+    ET.SOFT_DISABLE: soft_disable_alert("Sensor Data Invalid"),
+  },
+
+  EventName.noGps: {
+  },
+
+  EventName.tooDistracted: {
+    ET.NO_ENTRY: NoEntryAlert("Distraction Level Too High"),
+  },
+
+  EventName.excessiveActuation: {
+    ET.SOFT_DISABLE: soft_disable_alert("Excessive Actuation"),
+    ET.NO_ENTRY: NoEntryAlert("Excessive Actuation"),
+  },
+
+  EventName.overheat: {
+    ET.PERMANENT: overheat_alert,
+    ET.SOFT_DISABLE: soft_disable_alert("System Overheated"),
+    ET.NO_ENTRY: NoEntryAlert("System Overheated"),
+  },
+
+  EventName.wrongGear: {
+    ET.SOFT_DISABLE: user_soft_disable_alert("Gear not D"),
+    ET.NO_ENTRY: NoEntryAlert("Gear not D"),
+  },
+
+  # This alert is thrown when the calibration angles are outside of the acceptable range.
+  # For example if the device is pointed too much to the left or the right.
+  # Usually this can only be solved by removing the mount from the windshield completely,
+  # and attaching while making sure the device is pointed straight forward and is level.
+  # See https://comma.ai/setup for more information
+  EventName.calibrationInvalid: {
+    ET.PERMANENT: calibration_invalid_alert,
+    ET.SOFT_DISABLE: soft_disable_alert("Calibration Invalid: Remount Device & Recalibrate"),
+    ET.NO_ENTRY: NoEntryAlert("Calibration Invalid: Remount Device & Recalibrate"),
+  },
+
+  EventName.calibrationIncomplete: {
+    ET.PERMANENT: calibration_incomplete_alert,
+    ET.SOFT_DISABLE: soft_disable_alert("Calibration Incomplete"),
+    ET.NO_ENTRY: NoEntryAlert("Calibration in Progress"),
+  },
+
+  EventName.calibrationRecalibrating: {
+    ET.PERMANENT: calibration_incomplete_alert,
+    ET.SOFT_DISABLE: soft_disable_alert("Device Remount Detected: Recalibrating"),
+    ET.NO_ENTRY: NoEntryAlert("Remount Detected: Recalibrating"),
+  },
+
+  EventName.doorOpen: {
+    ET.SOFT_DISABLE: user_soft_disable_alert("Door Open"),
+    ET.NO_ENTRY: NoEntryAlert("Door Open"),
+  },
+
+  EventName.seatbeltNotLatched: {
+    ET.SOFT_DISABLE: user_soft_disable_alert("Seatbelt Unlatched"),
+    ET.NO_ENTRY: NoEntryAlert("Seatbelt Unlatched"),
+  },
+
+  EventName.espDisabled: {
+    ET.SOFT_DISABLE: soft_disable_alert("Electronic Stability Control Disabled"),
+    ET.NO_ENTRY: NoEntryAlert("Electronic Stability Control Disabled"),
+  },
+
+  EventName.lowBattery: {
+    ET.SOFT_DISABLE: soft_disable_alert("Low Battery"),
+    ET.NO_ENTRY: NoEntryAlert("Low Battery"),
+  },
+
+  # Different openpilot services communicate between each other at a certain
+  # interval. If communication does not follow the regular schedule this alert
+  # is thrown. This can mean a service crashed, did not broadcast a message for
+  # ten times the regular interval, or the average interval is more than 10% too high.
+  # Soft warnings — no disable, no entry block. UI shows a silent yellow triangle instead.
+  EventName.commIssue: {
+  },
+  EventName.commIssueAvgFreq: {
+  },
+
+  EventName.selfdrivedLagging: {
+  },
+
+  # Thrown when manager detects a service exited unexpectedly while driving
+  EventName.processNotRunning: {
+    ET.NO_ENTRY: process_not_running_alert,
+    ET.SOFT_DISABLE: soft_disable_alert("Process Not Running"),
+  },
+
+  EventName.radarFault: {
+    ET.SOFT_DISABLE: soft_disable_alert("Radar Error: Restart the Car"),
+    ET.NO_ENTRY: NoEntryAlert("Radar Error: Restart the Car"),
+  },
+
+  EventName.radarTempUnavailable: {
+    ET.SOFT_DISABLE: soft_disable_alert("Radar Temporarily Unavailable"),
+    ET.NO_ENTRY: NoEntryAlert("Radar Temporarily Unavailable"),
+  },
+
+  # Every frame from the camera should be processed by the model. If modeld
+  # is not processing frames fast enough they have to be dropped. This alert is
+  # thrown when over 20% of frames are dropped.
+  EventName.modeldLagging: {
+    ET.SOFT_DISABLE: soft_disable_alert("Driving Model Lagging"),
+    ET.NO_ENTRY: NoEntryAlert("Driving Model Lagging"),
+    ET.PERMANENT: modeld_lagging_alert,
+  },
+
+  # Besides predicting the path, lane lines and lead car data the model also
+  # predicts the current velocity and rotation speed of the car. If the model is
+  # very uncertain about the current velocity while the car is moving, this
+  # usually means the model has trouble understanding the scene. This is used
+  # as a heuristic to warn the driver.
+  EventName.posenetInvalid: {
+    ET.SOFT_DISABLE: soft_disable_alert("Posenet Speed Invalid"),
+    ET.NO_ENTRY: posenet_invalid_alert,
+  },
+
+  # When the localizer detects an acceleration of more than 40 m/s^2 (~4G) we
+  # alert the driver the device might have fallen from the windshield.
+  EventName.deviceFalling: {
+    ET.SOFT_DISABLE: soft_disable_alert("Device Fell Off Mount"),
+    ET.NO_ENTRY: NoEntryAlert("Device Fell Off Mount"),
+  },
+
+  EventName.lowMemory: {
+    ET.SOFT_DISABLE: soft_disable_alert("Low Memory: Reboot Your Device"),
+    ET.PERMANENT: low_memory_alert,
+    ET.NO_ENTRY: NoEntryAlert("Low Memory: Reboot Your Device"),
+  },
+
+  EventName.accFaulted: {
+    ET.IMMEDIATE_DISABLE: ImmediateDisableAlert("Cruise Fault: Restart the Car"),
+    ET.PERMANENT: NormalPermanentAlert("Cruise Fault: Restart the car to engage"),
+    ET.NO_ENTRY: NoEntryAlert("Cruise Fault: Restart the Car"),
+  },
+
+  EventName.cruiseFaultLateralAllowed: {
+    ET.PERMANENT: NormalPermanentAlert("Cruise Faulted", "Lane Assist will continue to work", priority=Priority.LOWEST),
+  },
+
+  EventName.espActive: {
+    ET.SOFT_DISABLE: soft_disable_alert("Electronic Stability Control Active"),
+    ET.NO_ENTRY: NoEntryAlert("Electronic Stability Control Active"),
+  },
+
+  EventName.controlsMismatch: {
+    ET.IMMEDIATE_DISABLE: ImmediateDisableAlert("Controls Mismatch"),
+    ET.NO_ENTRY: NoEntryAlert("Controls Mismatch"),
+  },
+
+  # Sometimes the USB stack on the device can get into a bad state
+  # causing the connection to the panda to be lost
+  EventName.usbError: {
+    ET.SOFT_DISABLE: soft_disable_alert("USB Error: Reboot Your Device"),
+    ET.PERMANENT: NormalPermanentAlert("USB Error: Reboot Your Device"),
+    ET.NO_ENTRY: NoEntryAlert("USB Error: Reboot Your Device"),
+  },
+
+  # This alert can be thrown for the following reasons:
+  # - No CAN data received at all
+  # - CAN data is received, but some message are not received at the right frequency
+  # If you're not writing a new car port, this is usually cause by faulty wiring
+  # Minor canError: low-priority silent HUD badge only — no disable, no entry block, no audible/visual alert
+  EventName.canError: {
+    ET.PERMANENT: Alert(
+      "CAN Error",
+      "",
+      AlertStatus.normal, AlertSize.small,
+      Priority.LOW, VisualAlert.none, AudibleAlert.none, 1., creation_delay=1.),
+  },
+
+  EventName.canBusMissing: {
+    ET.IMMEDIATE_DISABLE: ImmediateDisableAlert("CAN Bus Disconnected"),
+    ET.PERMANENT: Alert(
+      "CAN Bus Disconnected: Likely Faulty Cable",
+      "",
+      AlertStatus.normal, AlertSize.small,
+      Priority.LOW, VisualAlert.none, AudibleAlert.none, 1., creation_delay=1.),
+    ET.NO_ENTRY: NoEntryAlert("CAN Bus Disconnected: Check Connections"),
+  },
+
+  EventName.steerUnavailable: {
+    ET.IMMEDIATE_DISABLE: ImmediateDisableAlert("LKAS Fault: Restart the Car"),
+    ET.PERMANENT: NormalPermanentAlert("LKAS Fault: Restart the car to engage"),
+    ET.NO_ENTRY: NoEntryAlert("LKAS Fault: Restart the Car"),
+  },
+
+  EventName.reverseGear: {
+    ET.PERMANENT: Alert(
+      "Reverse\nGear",
+      "",
+      AlertStatus.normal, AlertSize.full,
+      Priority.LOWEST, VisualAlert.none, AudibleAlert.none, .2, creation_delay=0.5),
+    ET.USER_DISABLE: ImmediateDisableAlert("Reverse Gear"),
+    ET.NO_ENTRY: NoEntryAlert("Reverse Gear"),
+  },
+
+  # On cars that use stock ACC the car can decide to cancel ACC for various reasons.
+  # When this happens we can no long control the car so the user needs to be warned immediately.
+  EventName.cruiseDisabled: {
+    ET.IMMEDIATE_DISABLE: ImmediateDisableAlert("Cruise Is Off"),
+  },
+
+  # When the relay in the harness box opens the CAN bus between the LKAS camera
+  # and the rest of the car is separated. When messages from the LKAS camera
+  # are received on the car side this usually means the relay hasn't opened correctly
+  # and this alert is thrown.
+  EventName.relayMalfunction: {
+    ET.IMMEDIATE_DISABLE: ImmediateDisableAlert("Harness Relay Malfunction"),
+    ET.PERMANENT: NormalPermanentAlert("Harness Relay Malfunction", "Check Hardware"),
+    ET.NO_ENTRY: NoEntryAlert("Harness Relay Malfunction"),
+  },
+
+  EventName.speedTooLow: {
+    ET.IMMEDIATE_DISABLE: Alert(
+      "IQ.Pilot Canceled",
+      "Speed too low",
+      AlertStatus.normal, AlertSize.mid,
+      Priority.HIGH, VisualAlert.none, AudibleAlert.disengage, 3.),
+  },
+
+  # When the car is driving faster than most cars in the training data, the model outputs can be unpredictable.
+  EventName.speedTooHigh: {
+    ET.WARNING: Alert(
+      "Speed Too High",
+      "Model uncertain at this speed",
+      AlertStatus.userPrompt, AlertSize.mid,
+      Priority.HIGH, VisualAlert.steerRequired, AudibleAlert.promptRepeat, 4.),
+    ET.NO_ENTRY: NoEntryAlert("Slow down to engage"),
+  },
+
+  EventName.vehicleSensorsInvalid: {
+    ET.IMMEDIATE_DISABLE: ImmediateDisableAlert("Vehicle Sensors Invalid"),
+    ET.PERMANENT: NormalPermanentAlert("Vehicle Sensors Calibrating", "Drive to Calibrate"),
+    ET.NO_ENTRY: NoEntryAlert("Vehicle Sensors Calibrating"),
+  },
+
+  EventName.personalityChanged: {
+    ET.WARNING: personality_changed_alert,
+  },
+
+  EventName.userBookmark: {
+    ET.PERMANENT: NormalPermanentAlert("Bookmark Saved", duration=1.5),
+  },
+
+  EventName.audioFeedback: {
+    ET.PERMANENT: audio_feedback_alert,
+  },
+}
+
+
+if HARDWARE.get_device_type() == 'mici':
+  EVENTS.update({
+    EventName.preDriverDistracted: {
+      ET.PERMANENT: Alert(
+        "Pay Attention",
+        "",
+        AlertStatus.normal, AlertSize.small,
+        Priority.LOW, VisualAlert.none, AudibleAlert.none, 2),
+    },
+    EventName.promptDriverDistracted: {
+      ET.PERMANENT: Alert(
+        "Pay Attention",
+        "Driver Distracted",
+        AlertStatus.userPrompt, AlertSize.mid,
+        Priority.MID, VisualAlert.steerRequired, AudibleAlert.promptDistracted, 1),
+    },
+    EventName.resumeRequired: {
+      ET.WARNING: Alert(
+        "Press Resume",
+        "",
+        AlertStatus.userPrompt, AlertSize.small,
+        Priority.LOW, VisualAlert.none, AudibleAlert.none, .2),
+    },
+    EventName.preLaneChangeLeft: {
+      ET.WARNING: Alert(
+        "Steer Left",
+        "Confirm Lane Change",
+        AlertStatus.normal, AlertSize.mid,
+        Priority.LOW, VisualAlert.none, AudibleAlert.none, .1),
+    },
+    EventName.preLaneChangeRight: {
+      ET.WARNING: Alert(
+        "Steer Right",
+        "Confirm Lane Change",
+        AlertStatus.normal, AlertSize.mid,
+        Priority.LOW, VisualAlert.none, AudibleAlert.none, .1),
+    },
+    EventName.laneChangeBlocked: {
+      ET.WARNING: Alert(
+        "Car in Blindspot",
+        "",
+        AlertStatus.userPrompt, AlertSize.small,
+        Priority.LOW, VisualAlert.none, AudibleAlert.prompt, .1),
+    },
+    EventName.steerSaturated: {
+      ET.WARNING: Alert(
+        "take control",
+        "turn exceeds limit",
+        AlertStatus.userPrompt, AlertSize.mid,
+        Priority.LOW, VisualAlert.steerRequired, AudibleAlert.promptRepeat, 2.),
+    },
+    EventName.calibrationIncomplete: {
+      ET.PERMANENT: calibration_incomplete_alert,
+      ET.SOFT_DISABLE: soft_disable_alert("Calibration Incomplete"),
+      ET.NO_ENTRY: NoEntryAlert("Calibrating"),
+    },
+    EventName.reverseGear: {
+      ET.PERMANENT: Alert(
+        "Reverse",
+        "",
+        AlertStatus.normal, AlertSize.full,
+        Priority.LOWEST, VisualAlert.none, AudibleAlert.none, .2, creation_delay=0.5),
+      ET.USER_DISABLE: ImmediateDisableAlert("Reverse"),
+      ET.NO_ENTRY: NoEntryAlert("Reverse"),
+    },
+  })
+
+
+if __name__ == '__main__':
+  # print all alerts by type and priority
+  from iqpilot.cereal.services import SERVICE_LIST
+  from collections import defaultdict
+
+  event_names = {v: k for k, v in EventName.schema.enumerants.items()}
+  alerts_by_type: dict[str, dict[Priority, list[str]]] = defaultdict(lambda: defaultdict(list))
+
+  CP = car.CarParams.new_message()
+  CS = car.CarState.new_message()
+  sm = messaging.SubMaster(list(SERVICE_LIST.keys()))
+
+  for i, alerts in EVENTS.items():
+    for et, alert in alerts.items():
+      if callable(alert):
+        alert = alert(CP, CS, sm, False, 1, log.LongitudinalPersonality.standard)
+      alerts_by_type[et][alert.priority].append(event_names[i])
+
+  all_alerts: dict[str, list[tuple[Priority, list[str]]]] = {}
+  for et, priority_alerts in alerts_by_type.items():
+    all_alerts[et] = sorted(priority_alerts.items(), key=lambda x: x[0], reverse=True)
+
+  for status, evs in sorted(all_alerts.items(), key=lambda x: x[0]):
+    print(f"**** {status} ****")
+    for p, alert_list in evs:
+      print(f"  {repr(p)}:")
+      print("   ", ', '.join(alert_list), "\n")

artifacts/iqpilot_hephaestusd_private/python/_iqclosure/iqpilot/selfdrive/ui/feedback/feedbackd.py

@@ -0,0 +1,70 @@
+#!/usr/bin/env python3
+import iqpilot.cereal.messaging as messaging
+from iqpilot.common.params import Params
+from iqpilot.common.swaglog import cloudlog
+from iqpilot.cereal import car
+from iqpilot.system.micd import SAMPLE_RATE, SAMPLE_BUFFER
+
+FEEDBACK_MAX_DURATION = 10.0
+ButtonType = car.CarState.ButtonEvent.Type
+
+
+def main():
+  params = Params()
+  pm = messaging.PubMaster(['userBookmark', 'audioFeedback'])
+  sm = messaging.SubMaster(['rawAudioData', 'bookmarkButton'])
+  should_record_audio = False
+  block_num = 0
+  waiting_for_release = False
+  early_stop_triggered = False
+
+  while True:
+    sm.update()
+    should_send_bookmark = False
+
+    if False and sm.updated['carState'] and sm['carState'].canValid and not sm['iqState'].aol.available:
+      for be in sm['carState'].buttonEvents:
+        if be.type == ButtonType.lkas:
+          if be.pressed:
+            if not should_record_audio:
+              if params.get_bool("RecordAudioFeedback"):
+                should_record_audio = True
+                block_num = 0
+                waiting_for_release = False
+                early_stop_triggered = False
+                cloudlog.info("LKAS button pressed - starting 10-second audio feedback")
+              else:
+                should_send_bookmark = True
+                cloudlog.info("LKAS button pressed - bookmarking")
+            elif should_record_audio and not waiting_for_release:
+              waiting_for_release = True
+          elif waiting_for_release:
+            waiting_for_release = False
+            early_stop_triggered = True
+            cloudlog.info("LKAS button released - ending recording early")
+
+    if should_record_audio and sm.updated['rawAudioData']:
+      raw_audio = sm['rawAudioData']
+      msg = messaging.new_message('audioFeedback', valid=True)
+      msg.audioFeedback.audio.data = raw_audio.data
+      msg.audioFeedback.audio.sampleRate = raw_audio.sampleRate
+      msg.audioFeedback.blockNum = block_num
+      block_num += 1
+      if (block_num * SAMPLE_BUFFER / SAMPLE_RATE) >= FEEDBACK_MAX_DURATION or early_stop_triggered:
+        should_send_bookmark = True
+        should_record_audio = False
+        early_stop_triggered = False
+        cloudlog.info("10-second recording completed or second button press - stopping audio feedback")
+      pm.send('audioFeedback', msg)
+
+    if sm.updated['bookmarkButton']:
+      cloudlog.info("Bookmark button pressed!")
+      should_send_bookmark = True
+
+    if should_send_bookmark:
+      msg = messaging.new_message('userBookmark', valid=True)
+      pm.send('userBookmark', msg)
+
+
+if __name__ == '__main__':
+  main()

artifacts/iqpilot_hephaestusd_private/python/_iqclosure/iqpilot/system/hardware/__init__.py

@@ -0,0 +1,22 @@
+import os
+from typing import cast
+
+from iqpilot.system.hardware.base import HardwareBase
+from iqpilot.system.hardware.tici.hardware import Tici
+from iqpilot.system.hardware.pc.hardware import Pc
+
+TICI = os.path.isfile('/TICI')
+AGNOS = os.path.isfile('/AGNOS')
+PC = not TICI
+
+
+if TICI:
+  HARDWARE = cast(HardwareBase, Tici())
+else:
+  HARDWARE = cast(HardwareBase, Pc())
+
+# Only comma 3/3X expose the DMA-BUF EGL extensions used by the zero-copy
+# camera renderer and the direct EGL frame-pacing calls. /TICI is also present
+# on comma 4, so it identifies the AGNOS hardware family rather than this GPU
+# capability.
+EGL_DMA_BUF_SUPPORTED = TICI and HARDWARE.get_device_type() in ("tici", "tizi")

artifacts/iqpilot_hephaestusd_private/python/_iqclosure/iqpilot/system/hardware/base.py

@@ -0,0 +1,228 @@
+import os
+from abc import abstractmethod, ABC
+from dataclasses import dataclass, fields
+
+from iqpilot.cereal import log
+
+NetworkType = log.DeviceState.NetworkType
+NetworkStrength = log.DeviceState.NetworkStrength
+
+class LPAError(RuntimeError):
+  pass
+
+class LPAProfileNotFoundError(LPAError):
+  pass
+
+@dataclass
+class Profile:
+  iccid: str
+  nickname: str
+  enabled: bool
+  provider: str
+
+@dataclass
+class ThermalZone:
+  # a zone from /sys/class/thermal/thermal_zone*
+  name: str             # a.k.a type
+  scale: float = 1000.  # scale to get degrees in C
+  zone_number = -1
+
+  def read(self) -> float:
+    if self.zone_number < 0:
+      for n in os.listdir("/sys/devices/virtual/thermal"):
+        if not n.startswith("thermal_zone"):
+          continue
+        with open(os.path.join("/sys/devices/virtual/thermal", n, "type")) as f:
+          if f.read().strip() == self.name:
+            self.zone_number = int(n.removeprefix("thermal_zone"))
+            break
+
+    try:
+      with open(f"/sys/devices/virtual/thermal/thermal_zone{self.zone_number}/temp") as f:
+        return int(f.read()) / self.scale
+    except FileNotFoundError:
+      return 0
+
+@dataclass
+class ThermalConfig:
+  cpu: list[ThermalZone] | None = None
+  gpu: list[ThermalZone] | None = None
+  dsp: ThermalZone | None = None
+  pmic: list[ThermalZone] | None = None
+  memory: ThermalZone | None = None
+  intake: ThermalZone | None = None
+  exhaust: ThermalZone | None = None
+  case: ThermalZone | None = None
+
+  def get_msg(self):
+    ret = {}
+    for f in fields(ThermalConfig):
+      v = getattr(self, f.name)
+      if v is not None:
+        if isinstance(v, list):
+          ret[f.name + "TempC"] = [x.read() for x in v]
+        else:
+          ret[f.name + "TempC"] = v.read()
+    return ret
+
+class LPABase(ABC):
+  @abstractmethod
+  def list_profiles(self) -> list[Profile]:
+    pass
+
+  @abstractmethod
+  def get_active_profile(self) -> Profile | None:
+    pass
+
+  @abstractmethod
+  def delete_profile(self, iccid: str) -> None:
+    pass
+
+  @abstractmethod
+  def bootstrap(self) -> None:
+    pass
+
+  @abstractmethod
+  def download_profile(self, qr: str, nickname: str | None = None) -> None:
+    pass
+
+  @abstractmethod
+  def nickname_profile(self, iccid: str, nickname: str) -> None:
+    pass
+
+  @abstractmethod
+  def switch_profile(self, iccid: str) -> None:
+    pass
+
+  def is_comma_profile(self, iccid: str) -> bool:
+    return any(iccid.startswith(prefix) for prefix in ('8985235',))
+
+class HardwareBase(ABC):
+  @staticmethod
+  def get_cmdline() -> dict[str, str]:
+    with open('/proc/cmdline') as f:
+      cmdline = f.read()
+    return {kv[0]: kv[1] for kv in [s.split('=') for s in cmdline.split(' ')] if len(kv) == 2}
+
+  @staticmethod
+  def read_param_file(path, parser, default=0):
+    try:
+      with open(path) as f:
+        return parser(f.read())
+    except Exception:
+      return default
+
+  def booted(self) -> bool:
+    return True
+
+  def reboot(self, reason=None):
+    print("REBOOT!")
+
+  def uninstall(self):
+    print("uninstall")
+
+  def get_os_version(self):
+    return None
+
+  @abstractmethod
+  def get_device_type(self):
+    pass
+
+  def get_imei(self, slot) -> str:
+    return ""
+
+  def get_serial(self):
+    return ""
+
+  def get_network_info(self):
+    return None
+
+  def get_network_type(self):
+    return NetworkType.none
+
+  def get_sim_info(self):
+    return {
+      'sim_id': '',
+      'mcc_mnc': None,
+      'network_type': ["Unknown"],
+      'sim_state': ["ABSENT"],
+      'data_connected': False
+    }
+
+  def get_sim_lpa(self) -> LPABase:
+    raise NotImplementedError("SIM LPA not available")
+
+  def get_network_strength(self, network_type):
+    return NetworkStrength.unknown
+
+  def get_network_metered(self, network_type) -> bool:
+    return network_type not in (NetworkType.none, NetworkType.wifi, NetworkType.ethernet)
+
+  def get_current_power_draw(self):
+    return 0
+
+  def get_som_power_draw(self):
+    return 0
+
+  def shutdown(self):
+    print("SHUTDOWN!")
+
+  def get_thermal_config(self):
+    return ThermalConfig()
+
+  def set_display_power(self, on: bool):
+    pass
+
+  def set_screen_brightness(self, percentage):
+    pass
+
+  def get_screen_brightness(self):
+    return 0
+
+  def set_power_save(self, powersave_enabled):
+    pass
+
+  def get_gpu_usage_percent(self):
+    return 0
+
+  def get_modem_version(self):
+    return None
+
+  def get_modem_temperatures(self):
+    return []
+
+  def initialize_hardware(self):
+    pass
+
+  def configure_modem(self):
+    pass
+
+  def reboot_modem(self):
+    pass
+
+  def recover_sim_detection(self) -> bool:
+    return False
+
+  def get_networks(self):
+    return None
+
+  def has_internal_panda(self) -> bool:
+    return False
+
+  def reset_internal_panda(self):
+    pass
+
+  def recover_internal_panda(self):
+    pass
+
+  def get_modem_data_usage(self):
+    return -1, -1
+
+  def get_voltage(self) -> float:
+    return 0.
+
+  def get_current(self) -> float:
+    return 0.
+
+  def set_ir_power(self, percent: int):
+    pass

artifacts/iqpilot_hephaestusd_private/python/_iqclosure/iqpilot/system/hardware/hw.py

@@ -0,0 +1,137 @@
+import os
+import platform
+from pathlib import Path
+
+from iqpilot.system.hardware import PC
+
+DEFAULT_DOWNLOAD_CACHE_ROOT = "/tmp/comma_download_cache"
+
+class Paths:
+  _persist_root_cache: str | None = None
+
+  @staticmethod
+  def _is_writable_persist_root(path: str) -> bool:
+    try:
+      os.makedirs(path, exist_ok=True)
+      comma_dir = os.path.join(path, "comma")
+      os.makedirs(comma_dir, exist_ok=True)
+
+      probe_path = os.path.join(comma_dir, ".rw_probe")
+      with open(probe_path, "w") as f:
+        f.write("1")
+      os.remove(probe_path)
+      return True
+    except OSError:
+      return False
+
+  @staticmethod
+  def comma_home() -> str:
+    return os.path.join(str(Path.home()), ".comma" + os.environ.get("OPENPILOT_PREFIX", ""))
+
+  @staticmethod
+  def params() -> str:
+    if os.environ.get("PARAMS_ROOT"):
+      return os.environ["PARAMS_ROOT"]
+    return os.path.join(Paths.comma_home(), "params") if PC else "/data/params"
+
+  @staticmethod
+  def log_root() -> str:
+    if os.environ.get('LOG_ROOT', False):
+      return os.environ['LOG_ROOT']
+    elif PC:
+      return str(Path(Paths.comma_home()) / "media" / "0" / "realdata")
+    else:
+      return '/data/media/0/realdata/'
+
+  @staticmethod
+  def log_root_external() -> str:
+    return '/mnt/external_realdata/'
+
+  @staticmethod
+  def swaglog_root() -> str:
+    if PC:
+      return os.path.join(Paths.comma_home(), "log")
+    else:
+      return "/data/log/"
+
+  @staticmethod
+  def swaglog_ipc() -> str:
+    return "ipc:///tmp/logmessage" + os.environ.get("OPENPILOT_PREFIX", "")
+
+  @staticmethod
+  def download_cache_root() -> str:
+    if os.environ.get('COMMA_CACHE', False):
+      return os.environ['COMMA_CACHE'] + "/"
+    return DEFAULT_DOWNLOAD_CACHE_ROOT + os.environ.get("OPENPILOT_PREFIX", "") + "/"
+
+  @staticmethod
+  def persist_root() -> str:
+    if PC:
+      return os.path.join(Paths.comma_home(), "persist")
+
+    if Paths._persist_root_cache is not None:
+      return Paths._persist_root_cache
+
+    for candidate in ("/persist", "/data/persist"):
+      if Paths._is_writable_persist_root(candidate):
+        Paths._persist_root_cache = candidate
+        return candidate
+
+    # Keep previous behavior as a last resort.
+    Paths._persist_root_cache = "/persist"
+    return Paths._persist_root_cache
+
+  @staticmethod
+  def stats_root() -> str:
+    if PC:
+      return str(Path(Paths.comma_home()) / "stats")
+    else:
+      return "/data/stats/"
+
+  @staticmethod
+  def stats_iq_root() -> str:
+    if PC:
+      return str(Path(Paths.comma_home()) / "stats")
+    else:
+      return "/data/stats_iq/"
+
+  @staticmethod
+  def config_root() -> str:
+    if PC:
+      return Paths.comma_home()
+    else:
+      return "/tmp/.comma"
+
+  @staticmethod
+  def shm_path() -> str:
+    if PC and platform.system() == "Darwin":
+      return "/tmp"  # This is not really shared memory on macOS, but it's the closest we can get
+    return "/dev/shm"
+
+  @staticmethod
+  def model_root() -> str:
+    if PC:
+      return str(Path(Paths.comma_home()) / "media" / "0" / "models")
+    else:
+      return "/data/media/0/models"
+
+  @staticmethod
+  def crash_log_root() -> str:
+    if PC:
+      return str(Path(Paths.comma_home()) / "community" / "crashes")
+    else:
+      return "/data/community/crashes"
+
+  @staticmethod
+  def mapd_root() -> str:
+    if PC:
+      return str(Path(Paths.comma_home()) / "media" / "0" / "osm")
+    else:
+      return "/data/media/0/osm"
+
+  @staticmethod
+  def screen_recordings_root() -> str:
+    if PC:
+      return str(Path(Paths.comma_home()) / "media" / "0" / "screen_recordings")
+    else:
+      return "/data/media/0/screen_recordings"

artifacts/iqpilot_hephaestusd_private/python/_iqclosure/iqpilot/system/hardware/pc/hardware.py

@@ -0,0 +1,12 @@
+from iqpilot.cereal import log
+from iqpilot.system.hardware.base import HardwareBase
+
+NetworkType = log.DeviceState.NetworkType
+
+
+class Pc(HardwareBase):
+  def get_device_type(self):
+    return "pc"
+
+  def get_network_type(self):
+    return NetworkType.wifi

artifacts/iqpilot_hephaestusd_private/python/_iqclosure/iqpilot/system/hardware/tici/amplifier.py

@@ -0,0 +1,159 @@
+#!/usr/bin/env python3
+import time
+from collections import namedtuple
+
+from iqpilot.common.i2c import SMBus
+
+# https://datasheets.maximintegrated.com/en/ds/MAX98089.pdf
+
+AmpConfig = namedtuple('AmpConfig', ['name', 'value', 'register', 'offset', 'mask'])
+EQParams = namedtuple('EQParams', ['K', 'k1', 'k2', 'c1', 'c2'])
+
+
+def configs_from_eq_params(base, eq_params):
+  return [
+    AmpConfig("K (high)", (eq_params.K >> 8), base, 0, 0xFF),
+    AmpConfig("K (low)", (eq_params.K & 0xFF), base + 1, 0, 0xFF),
+    AmpConfig("k1 (high)", (eq_params.k1 >> 8), base + 2, 0, 0xFF),
+    AmpConfig("k1 (low)", (eq_params.k1 & 0xFF), base + 3, 0, 0xFF),
+    AmpConfig("k2 (high)", (eq_params.k2 >> 8), base + 4, 0, 0xFF),
+    AmpConfig("k2 (low)", (eq_params.k2 & 0xFF), base + 5, 0, 0xFF),
+    AmpConfig("c1 (high)", (eq_params.c1 >> 8), base + 6, 0, 0xFF),
+    AmpConfig("c1 (low)", (eq_params.c1 & 0xFF), base + 7, 0, 0xFF),
+    AmpConfig("c2 (high)", (eq_params.c2 >> 8), base + 8, 0, 0xFF),
+    AmpConfig("c2 (low)", (eq_params.c2 & 0xFF), base + 9, 0, 0xFF),
+  ]
+
+
+BASE_CONFIG = [
+  AmpConfig("MCLK prescaler", 0b01, 0x10, 4, 0b00110000),
+  AmpConfig("PM: enable speakers", 0b11, 0x4D, 4, 0b00110000),
+  AmpConfig("PM: enable DACs", 0b11, 0x4D, 0, 0b00000011),
+  AmpConfig("Enable PLL1", 0b1, 0x12, 7, 0b10000000),
+  AmpConfig("Enable PLL2", 0b1, 0x1A, 7, 0b10000000),
+  AmpConfig("DAI1: I2S mode", 0b00100, 0x14, 2, 0b01111100),
+  AmpConfig("DAI2: I2S mode", 0b00100, 0x1C, 2, 0b01111100),
+  AmpConfig("DAI1 Passband filtering: music mode", 0b1, 0x18, 7, 0b10000000),
+  AmpConfig("DAI1 voice mode gain (DV1G)", 0b00, 0x2F, 4, 0b00110000),
+  AmpConfig("DAI1 attenuation (DV1)", 0x0, 0x2F, 0, 0b00001111),
+  AmpConfig("DAI2 attenuation (DV2)", 0x0, 0x31, 0, 0b00001111),
+  AmpConfig("DAI2: DC blocking", 0b1, 0x20, 0, 0b00000001),
+  AmpConfig("DAI2: High sample rate", 0b0, 0x20, 3, 0b00001000),
+  AmpConfig("ALC enable", 0b1, 0x43, 7, 0b10000000),
+  AmpConfig("ALC/excursion limiter release time", 0b101, 0x43, 4, 0b01110000),
+  AmpConfig("ALC multiband enable", 0b1, 0x43, 3, 0b00001000),
+  AmpConfig("DAI1 EQ enable", 0b0, 0x49, 0, 0b00000001),
+  AmpConfig("DAI2 EQ clip detection disabled", 0b1, 0x32, 4, 0b00010000),
+  AmpConfig("DAI2 EQ attenuation", 0x5, 0x32, 0, 0b00001111),
+  AmpConfig("Excursion limiter upper corner freq", 0b100, 0x41, 4, 0b01110000),
+  AmpConfig("Excursion limiter lower corner freq", 0b00, 0x41, 0, 0b00000011),
+  AmpConfig("Excursion limiter threshold", 0b000, 0x42, 0, 0b00001111),
+  AmpConfig("Distortion limit (THDCLP)", 0x6, 0x46, 4, 0b11110000),
+  AmpConfig("Distortion limiter release time constant", 0b0, 0x46, 0, 0b00000001),
+  AmpConfig("Right DAC input mixer: DAI1 left", 0b0, 0x22, 3, 0b00001000),
+  AmpConfig("Right DAC input mixer: DAI1 right", 0b0, 0x22, 2, 0b00000100),
+  AmpConfig("Right DAC input mixer: DAI2 left", 0b1, 0x22, 1, 0b00000010),
+  AmpConfig("Right DAC input mixer: DAI2 right", 0b0, 0x22, 0, 0b00000001),
+  AmpConfig("DAI1 audio port selector", 0b10, 0x16, 6, 0b11000000),
+  AmpConfig("DAI2 audio port selector", 0b01, 0x1E, 6, 0b11000000),
+  AmpConfig("Enable left digital microphone", 0b1, 0x48, 5, 0b00100000),
+  AmpConfig("Enable right digital microphone", 0b1, 0x48, 4, 0b00010000),
+  AmpConfig("Enhanced volume smoothing disabled", 0b0, 0x49, 7, 0b10000000),
+  AmpConfig("Volume adjustment smoothing disabled", 0b0, 0x49, 6, 0b01000000),
+  AmpConfig("Zero-crossing detection disabled", 0b0, 0x49, 5, 0b00100000),
+]
+
+CONFIGS = {
+  "tici": [
+    AmpConfig("Right speaker output from right DAC", 0b1, 0x2C, 0, 0b11111111),
+    AmpConfig("Right Speaker Mixer Gain", 0b00, 0x2D, 2, 0b00001100),
+    AmpConfig("Right speaker output volume", 0x1c, 0x3E, 0, 0b00011111),
+    AmpConfig("DAI2 EQ enable", 0b1, 0x49, 1, 0b00000010),
+    *configs_from_eq_params(0x84, EQParams(0x274F, 0xC0FF, 0x3BF9, 0x0B3C, 0x1656)),
+    *configs_from_eq_params(0x8E, EQParams(0x1009, 0xC6BF, 0x2952, 0x1C97, 0x30DF)),
+    *configs_from_eq_params(0x98, EQParams(0x0F75, 0xCBE5, 0x0ED2, 0x2528, 0x3E42)),
+    *configs_from_eq_params(0xA2, EQParams(0x091F, 0x3D4C, 0xCE11, 0x1266, 0x2807)),
+    *configs_from_eq_params(0xAC, EQParams(0x0A9E, 0x3F20, 0xE573, 0x0A8B, 0x3A3B)),
+  ],
+  "tizi": [
+    AmpConfig("Left speaker output from left DAC", 0b1, 0x2B, 0, 0b11111111),
+    AmpConfig("Right speaker output from right DAC", 0b1, 0x2C, 0, 0b11111111),
+    AmpConfig("Left Speaker Mixer Gain", 0b00, 0x2D, 0, 0b00000011),
+    AmpConfig("Right Speaker Mixer Gain", 0b00, 0x2D, 2, 0b00001100),
+    AmpConfig("Left speaker output volume", 0x17, 0x3D, 0, 0b00011111),
+    AmpConfig("Right speaker output volume", 0x17, 0x3E, 0, 0b00011111),
+    AmpConfig("DAI2 EQ enable", 0b0, 0x49, 1, 0b00000010),
+    AmpConfig("DAI2: DC blocking", 0b0, 0x20, 0, 0b00000001),
+    AmpConfig("ALC enable", 0b0, 0x43, 7, 0b10000000),
+    AmpConfig("DAI2 EQ attenuation", 0x2, 0x32, 0, 0b00001111),
+    AmpConfig("Excursion limiter upper corner freq", 0b001, 0x41, 4, 0b01110000),
+    AmpConfig("Excursion limiter threshold", 0b100, 0x42, 0, 0b00001111),
+    AmpConfig("Distortion limit (THDCLP)", 0x0, 0x46, 4, 0b11110000),
+    AmpConfig("Distortion limiter release time constant", 0b1, 0x46, 0, 0b00000001),
+    AmpConfig("Left DAC input mixer: DAI1 left", 0b0, 0x22, 7, 0b10000000),
+    AmpConfig("Left DAC input mixer: DAI1 right", 0b0, 0x22, 6, 0b01000000),
+    AmpConfig("Left DAC input mixer: DAI2 left", 0b1, 0x22, 5, 0b00100000),
+    AmpConfig("Left DAC input mixer: DAI2 right", 0b0, 0x22, 4, 0b00010000),
+    AmpConfig("Right DAC input mixer: DAI2 left", 0b0, 0x22, 1, 0b00000010),
+    AmpConfig("Right DAC input mixer: DAI2 right", 0b1, 0x22, 0, 0b00000001),
+    AmpConfig("Volume adjustment smoothing disabled", 0b1, 0x49, 6, 0b01000000),
+  ],
+}
+
+
+class Amplifier:
+  AMP_I2C_BUS = 0
+  AMP_ADDRESS = 0x10
+
+  def __init__(self, debug=False):
+    self.debug = debug
+
+  def _get_shutdown_config(self, amp_disabled: bool) -> AmpConfig:
+    return AmpConfig("Global shutdown", 0b0 if amp_disabled else 0b1, 0x51, 7, 0b10000000)
+
+  def _set_configs(self, configs: list[AmpConfig]) -> None:
+    with SMBus(self.AMP_I2C_BUS) as bus:
+      for config in configs:
+        if self.debug:
+          print(f"Setting \"{config.name}\" to {config.value}:")
+
+        old_value = bus.read_byte_data(self.AMP_ADDRESS, config.register, force=True)
+        new_value = (old_value & (~config.mask)) | ((config.value << config.offset) & config.mask)
+        bus.write_byte_data(self.AMP_ADDRESS, config.register, new_value, force=True)
+
+        if self.debug:
+          print(f"  Changed {hex(config.register)}: {hex(old_value)} -> {hex(new_value)}")
+
+  def set_configs(self, configs: list[AmpConfig]) -> bool:
+    tries = 15
+    backoff = 0.
+    for i in range(tries):
+      try:
+        self._set_configs(configs)
+        return True
+      except OSError:
+        backoff += 0.1
+        time.sleep(backoff)
+        print(f"Failed to set amp config, {tries - i - 1} retries left")
+    return False
+
+  def set_global_shutdown(self, amp_disabled: bool) -> bool:
+    return self.set_configs([self._get_shutdown_config(amp_disabled), ])
+
+  def initialize_configuration(self, model: str) -> bool:
+    cfgs = [
+      self._get_shutdown_config(True),
+      *BASE_CONFIG,
+      *CONFIGS[model],
+      self._get_shutdown_config(False),
+    ]
+    return self.set_configs(cfgs)
+
+
+if __name__ == "__main__":
+  with open("/sys/firmware/devicetree/base/model") as f:
+    model = f.read().strip('\x00')
+  model = model.split('comma ')[-1]
+
+  amp = Amplifier()
+  amp.initialize_configuration(model)

artifacts/iqpilot_hephaestusd_private/python/_iqclosure/iqpilot/system/hardware/tici/esim_manager.py

@@ -0,0 +1,290 @@
+import threading
+import subprocess
+import time
+from dataclasses import dataclass
+from enum import Enum
+from queue import Queue, Empty
+from typing import Callable
+
+from iqpilot.common.params import Params
+from iqpilot.system.hardware import HARDWARE
+from iqpilot.system.hardware.base import LPAError, LPAProfileNotFoundError, Profile
+
+
+class EsimOperationState(Enum):
+  IDLE = "idle"
+  SCANNING = "scanning"
+  DOWNLOADING = "downloading"
+  SWITCHING = "switching"
+  RENAMING = "renaming"
+  DELETING = "deleting"
+  REBOOTING_MODEM = "rebooting modem"
+  COMPLETED = "completed"
+  FAILED = "failed"
+
+
+@dataclass
+class EsimUiState:
+  state: EsimOperationState = EsimOperationState.IDLE
+  message: str = ""
+  profiles: list[Profile] | None = None
+  busy: bool = False
+
+
+class EsimManager:
+  def __init__(self):
+    self._params = Params()
+    self._lock = threading.Lock()
+    self._callbacks: list[Callable[[EsimUiState], None]] = []
+    self._state = EsimUiState()
+    self._support_cache: bool | None = None
+    self._support_cache_ts = 0.0
+
+    self._ops: Queue[Callable[[], None]] = Queue()
+    self._worker = threading.Thread(target=self._worker_loop, daemon=True)
+    self._worker.start()
+
+  def is_supported(self) -> bool:
+    raw_flag = self._params.get("EnableEsimProvisioning")
+    enabled = True if raw_flag is None else self._params.get_bool("EnableEsimProvisioning")
+    if not enabled:
+      return False
+    if HARDWARE.get_device_type() not in ("tici", "tizi", "mici"):
+      return False
+    return self._has_euicc()
+
+  def _has_euicc(self, force_refresh: bool = False) -> bool:
+    now = time.monotonic()
+    if not force_refresh and self._support_cache is not None and now - self._support_cache_ts < 5.0:
+      return self._support_cache
+
+    supported = self._query_euicc_support()
+    self._support_cache = supported
+    self._support_cache_ts = now
+    return supported
+
+  @staticmethod
+  def _query_euicc_support() -> bool:
+    try:
+      res = subprocess.run(
+        ["sudo", "qmicli", "-p", "-d", "/dev/cdc-wdm0", "--uim-get-slot-status"],
+        capture_output=True, text=True, check=False, timeout=8,
+      )
+    except Exception:
+      return False
+
+    output = f"{res.stdout}\n{res.stderr}"
+    if "Is eUICC: yes" in output:
+      return True
+    if "Is eUICC: no" in output:
+      return False
+    return False
+
+  def add_callback(self, cb: Callable[[EsimUiState], None]) -> None:
+    with self._lock:
+      self._callbacks.append(cb)
+      state = self._copy_state_locked()
+    cb(state)
+
+  def remove_callback(self, cb: Callable[[EsimUiState], None]) -> None:
+    with self._lock:
+      self._callbacks = [c for c in self._callbacks if c is not cb]
+
+  def get_state(self) -> EsimUiState:
+    with self._lock:
+      return self._copy_state_locked()
+
+  def refresh_profiles(self) -> None:
+    if not self._is_supported_for_operation():
+      self._set_profiles([])
+      self._set_state(EsimOperationState.IDLE, self._unavailable_message(), busy=False)
+      return
+    self._enqueue(self._refresh_profiles)
+
+  def is_comma_profile(self, iccid: str) -> bool:
+    try:
+      return HARDWARE.get_sim_lpa().is_comma_profile(iccid)
+    except Exception:
+      return False
+
+  def add_profile(self, activation_code: str, nickname: str | None = None) -> None:
+    def _op() -> None:
+      self._set_state(EsimOperationState.DOWNLOADING, "Downloading profile...", busy=True)
+      lpa = HARDWARE.get_sim_lpa()
+      lpa.download_profile(activation_code, nickname=nickname)
+      self._set_state(EsimOperationState.REBOOTING_MODEM, "Reconnecting modem...", busy=True)
+      self._refresh_profiles()
+      self._set_state(EsimOperationState.COMPLETED, "Profile added", busy=False)
+    self._enqueue(_op)
+
+  def switch_profile(self, iccid: str) -> None:
+    def _op() -> None:
+      self._set_state(EsimOperationState.SWITCHING, "Switching profile...", busy=True)
+      lpa = HARDWARE.get_sim_lpa()
+      lpa.switch_profile(iccid)
+      self._set_state(EsimOperationState.REBOOTING_MODEM, "Reconnecting modem...", busy=True)
+      self._refresh_profiles()
+      self._set_state(EsimOperationState.COMPLETED, "Profile switched", busy=False)
+    self._enqueue(_op)
+
+  def rename_profile(self, iccid: str, nickname: str) -> None:
+    def _op() -> None:
+      self._set_state(EsimOperationState.RENAMING, "Renaming profile...", busy=True)
+      lpa = HARDWARE.get_sim_lpa()
+      lpa.nickname_profile(iccid, nickname)
+      self._refresh_profiles()
+      self._set_state(EsimOperationState.COMPLETED, "Profile renamed", busy=False)
+    self._enqueue(_op)
+
+  def delete_profile(self, iccid: str) -> None:
+    def _op() -> None:
+      self._set_state(EsimOperationState.DELETING, "Deleting profile...", busy=True)
+      lpa = HARDWARE.get_sim_lpa()
+      lpa.delete_profile(iccid)
+      self._set_state(EsimOperationState.REBOOTING_MODEM, "Reconnecting modem...", busy=True)
+      self._refresh_profiles()
+      self._set_state(EsimOperationState.COMPLETED, "Profile deleted", busy=False)
+    self._enqueue(_op)
+
+  def bootstrap(self) -> None:
+    def _op() -> None:
+      self._set_state(EsimOperationState.DELETING, "Removing Comma pSIM...", busy=True)
+      lpa = HARDWARE.get_sim_lpa()
+      lpa.bootstrap()
+      self._set_state(EsimOperationState.REBOOTING_MODEM, "Reconnecting modem...", busy=True)
+      self._refresh_profiles()
+      self._set_state(EsimOperationState.COMPLETED, "Comma pSIM removed", busy=False)
+    self._enqueue(_op)
+
+  def set_scanning_state(self, scanning: bool) -> None:
+    if scanning:
+      self._set_state(EsimOperationState.SCANNING, "Point camera at an eSIM QR code", busy=True)
+    else:
+      self._set_state(EsimOperationState.IDLE, "", busy=False)
+
+  def _enqueue(self, fn: Callable[[], None]) -> None:
+    if not self._is_supported_for_operation():
+      self._set_state(EsimOperationState.FAILED, self._unavailable_message(), busy=False)
+      return
+    self._ops.put(fn)
+
+  def _is_supported_for_operation(self) -> bool:
+    raw_flag = self._params.get("EnableEsimProvisioning")
+    enabled = True if raw_flag is None else self._params.get_bool("EnableEsimProvisioning")
+    if not enabled:
+      return False
+    if HARDWARE.get_device_type() not in ("tici", "tizi", "mici"):
+      return False
+    return self._has_euicc(force_refresh=True)
+
+  def _unavailable_message(self) -> str:
+    if HARDWARE.get_device_type() in ("tici", "tizi", "mici"):
+      return "Insert the original comma SIM card that came with the device to use eSIM"
+    return "eSIM provisioning is unavailable on this device"
+
+  def _worker_loop(self) -> None:
+    while True:
+      try:
+        op = self._ops.get(timeout=0.2)
+      except Empty:
+        continue
+      try:
+        op()
+      except Exception as e:
+        self._set_state(EsimOperationState.FAILED, self._map_error(e), busy=False)
+      finally:
+        self._ops.task_done()
+
+  def _refresh_profiles(self) -> None:
+    if not self._is_supported_for_operation():
+      self._set_profiles([])
+      return
+    profiles = HARDWARE.get_sim_lpa().list_profiles()
+    self._set_profiles(profiles)
+
+  def _set_profiles(self, profiles: list[Profile]) -> None:
+    with self._lock:
+      self._state.profiles = profiles
+      state = self._copy_state_locked()
+      callbacks = list(self._callbacks)
+    for cb in callbacks:
+      cb(state)
+
+  def _set_state(self, state: EsimOperationState, message: str, busy: bool) -> None:
+    with self._lock:
+      self._state.state = state
+      self._state.message = message
+      self._state.busy = busy
+      snapshot = self._copy_state_locked()
+      callbacks = list(self._callbacks)
+    for cb in callbacks:
+      cb(snapshot)
+
+  def _copy_state_locked(self) -> EsimUiState:
+    profiles = list(self._state.profiles) if self._state.profiles is not None else None
+    return EsimUiState(
+      state=self._state.state,
+      message=self._state.message,
+      profiles=profiles,
+      busy=self._state.busy,
+    )
+
+  @staticmethod
+  def _map_error(error: Exception) -> str:
+    if isinstance(error, LPAProfileNotFoundError):
+      return "Profile not found"
+    if isinstance(error, LPAError):
+      message = str(error)
+      lower = message.lower()
+      if "is euicc: no" in lower or "reports no euicc support" in lower:
+        return "Insert the original comma SIM to enable eSIM provisioning on this device"
+      if "certificate verify failed" in lower or "ssl" in lower or "tls" in lower:
+        return "TLS validation failed while contacting SM-DP+"
+      if "system time is not set" in lower:
+        return "Device time is invalid; connect to network and retry"
+      if "returned no modems" in lower or "object does not exist at path" in lower:
+        return "Modem is restarting; wait a moment and refresh profiles"
+      if "timed out" in lower or "timeout" in lower:
+        return "Modem timed out while provisioning eSIM"
+      if "delete the existing comma psim profile" in lower:
+        return "Delete the Comma pSIM profile before activating RedPocket"
+      if "not bootstrapped" in lower:
+        return "Delete the Comma pSIM profile before using user eSIM profiles"
+      if "cannot delete active profile" in lower:
+        return "Cannot delete active profile"
+      if "profile delete may have succeeded" in lower:
+        return "Profile may already be deleted; refresh profiles"
+      if "profile delete did not finish cleanly" in lower:
+        return "Profile delete did not complete; refresh profiles and retry"
+      if "profile switch may have succeeded" in lower:
+        return "Profile likely switched; refresh profiles"
+      if "profile switch did not finish cleanly" in lower:
+        return "Profile switch did not complete; refresh profiles and retry"
+      if "profile add may have succeeded" in lower:
+        return "Profile may already be added; refresh profiles"
+      if "profile add did not finish cleanly" in lower:
+        return "Profile add did not complete; refresh profiles and retry"
+      if "profile enable may have succeeded" in lower:
+        return "Profile may already be enabled; refresh profiles"
+      if "profile enable did not finish cleanly" in lower:
+        return "Profile enable did not complete; refresh profiles and retry"
+      if "profile disable may have succeeded" in lower:
+        return "Profile may already be disabled; refresh profiles"
+      if "profile disable did not finish cleanly" in lower:
+        return "Profile disable did not complete; refresh profiles and retry"
+      if "bf2800" in lower or "listnotification" in lower:
+        return "Modem notification cleanup failed; refresh profiles"
+      return message
+    return str(error)
+
+
+_ESIM_MANAGER: EsimManager | None = None
+_ESIM_MANAGER_LOCK = threading.Lock()
+
+
+def get_esim_manager() -> EsimManager:
+  global _ESIM_MANAGER
+  with _ESIM_MANAGER_LOCK:
+    if _ESIM_MANAGER is None:
+      _ESIM_MANAGER = EsimManager()
+    return _ESIM_MANAGER

artifacts/iqpilot_hephaestusd_private/python/_iqclosure/iqpilot/system/hardware/tici/hardware.py

@@ -0,0 +1,740 @@
+import math
+import os
+import sys
+import subprocess
+import time
+import tempfile
+from enum import IntEnum
+from functools import cached_property, lru_cache
+from pathlib import Path
+
+from iqpilot.cereal import log
+from iqpilot.common.utils import sudo_read, sudo_write
+from iqpilot.common.gpio import gpio_set, gpio_init, get_irqs_for_action
+from iqpilot.system.hardware.base import HardwareBase, LPABase, ThermalConfig, ThermalZone
+from iqpilot.system.hardware.tici import iwlist
+from iqpilot.system.hardware.tici.lpa import TiciLPA
+from iqpilot.system.hardware.tici.pins import GPIO
+from iqpilot.system.hardware.tici.amplifier import Amplifier
+
+NM = 'org.freedesktop.NetworkManager'
+NM_CON_ACT = NM + '.Connection.Active'
+NM_DEV = NM + '.Device'
+NM_DEV_WL = NM + '.Device.Wireless'
+NM_DEV_STATS = NM + '.Device.Statistics'
+NM_AP = NM + '.AccessPoint'
+DBUS_PROPS = 'org.freedesktop.DBus.Properties'
+
+MM = 'org.freedesktop.ModemManager1'
+MM_MODEM = MM + ".Modem"
+MM_MODEM_SIMPLE = MM + ".Modem.Simple"
+MM_SIM = MM + ".Sim"
+
+class MM_MODEM_STATE(IntEnum):
+  FAILED        = -1
+  UNKNOWN       = 0
+  INITIALIZING  = 1
+  LOCKED        = 2
+  DISABLED      = 3
+  DISABLING     = 4
+  ENABLING      = 5
+  ENABLED       = 6
+  SEARCHING     = 7
+  REGISTERED    = 8
+  DISCONNECTING = 9
+  CONNECTING    = 10
+  CONNECTED     = 11
+
+class NMActiveConnectionState(IntEnum):
+  UNKNOWN = 0
+  ACTIVATING = 1
+  ACTIVATED = 2
+  DEACTIVATING = 3
+  DEACTIVATED = 4
+
+class NMMetered(IntEnum):
+  NM_METERED_UNKNOWN = 0
+  NM_METERED_YES = 1
+  NM_METERED_NO = 2
+  NM_METERED_GUESS_YES = 3
+  NM_METERED_GUESS_NO = 4
+
+TIMEOUT = 0.1
+REFRESH_RATE_MS = 1000
+
+NetworkType = log.DeviceState.NetworkType
+NetworkStrength = log.DeviceState.NetworkStrength
+
+# https://developer.gnome.org/ModemManager/unstable/ModemManager-Flags-and-Enumerations.html#MMModemAccessTechnology
+MM_MODEM_ACCESS_TECHNOLOGY_UMTS = 1 << 5
+MM_MODEM_ACCESS_TECHNOLOGY_LTE = 1 << 14
+
+# MMModemStateFailedReason
+MM_MODEM_STATE_FAILED_REASON_SIM_MISSING = 2
+
+
+def affine_irq(val, action):
+  irqs = get_irqs_for_action(action)
+  if len(irqs) == 0:
+    return
+
+  for i in irqs:
+    sudo_write(str(val), f"/proc/irq/{i}/smp_affinity_list")
+
+@lru_cache
+def get_device_type():
+  # lru_cache and cache can cause memory leaks when used in classes
+  try:
+    with open("/sys/firmware/devicetree/base/model") as f:
+      model = f.read().strip('\x00')
+  except FileNotFoundError:
+    # off-device (e.g. the prebuilt build container fakes /TICI but has no
+    # devicetree); import must not crash. Not a real device type.
+    return "unknown"
+  return model.split('comma ')[-1]
+
+class Tici(HardwareBase):
+  @staticmethod
+  def _ensure_system_python_path() -> None:
+    system_site = "/usr/lib/python3/dist-packages"
+    if system_site not in sys.path and os.path.isdir(system_site):
+      sys.path.append(system_site)
+
+  @staticmethod
+  def _run_direct_modem_command(command: str) -> None:
+    import serial
+
+    last_error: Exception | None = None
+    for device in ("/dev/ttyUSB2", "/dev/ttyUSB3"):
+      if not os.path.exists(device):
+        continue
+
+      try:
+        with serial.Serial(device, baudrate=9600, timeout=2) as modem:
+          modem.reset_input_buffer()
+          modem.write((command + "\r").encode("ascii"))
+
+          deadline = time.monotonic() + 3.0
+          while time.monotonic() < deadline:
+            line = modem.readline().decode(errors="ignore").strip()
+            if not line:
+              continue
+            if line == "OK":
+              return
+            if line == "ERROR" or "ERROR" in line:
+              raise RuntimeError(f"{device}: {line}")
+          raise TimeoutError(f"{device}: timed out waiting for modem response")
+      except Exception as e:
+        last_error = e
+
+    if last_error is not None:
+      raise last_error
+    raise RuntimeError("No modem AT port available")
+
+  @cached_property
+  def bus(self):
+    try:
+      import dbus
+    except ModuleNotFoundError:
+      self._ensure_system_python_path()
+      import dbus
+    return dbus.SystemBus()
+
+  @cached_property
+  def nm(self):
+    return self.bus.get_object(NM, '/org/freedesktop/NetworkManager')
+
+  @property # this should not be cached, in case the modemmanager restarts
+  def mm(self):
+    return self.bus.get_object(MM, '/org/freedesktop/ModemManager1')
+
+  @cached_property
+  def amplifier(self):
+    if self.get_device_type() == "mici":
+      return None
+    if os.path.exists('/tmp/lite_hw') or os.environ.get('LITE') == '1':
+      return None
+    return Amplifier()
+
+  def get_os_version(self):
+    with open("/VERSION") as f:
+      return f.read().strip()
+
+  def get_device_type(self):
+    return get_device_type()
+
+  def reboot(self, reason=None):
+    subprocess.check_output(["sudo", "reboot"])
+
+  def uninstall(self):
+    Path("/data/__system_reset__").touch()
+    os.sync()
+    self.reboot()
+
+  def get_serial(self):
+    return self.get_cmdline()['androidboot.serialno']
+
+  def get_voltage(self):
+    with open("/sys/class/hwmon/hwmon1/in1_input") as f:
+      return int(f.read())
+
+  def get_current(self):
+    with open("/sys/class/hwmon/hwmon1/curr1_input") as f:
+      return int(f.read())
+
+  def set_ir_power(self, percent: int):
+    if self.get_device_type() in ("tici", "tizi"):
+      return
+
+    value = int((percent / 100) * 300)
+    with open("/sys/class/leds/led:switch_2/brightness", "w") as f:
+      f.write("0\n")
+    with open("/sys/class/leds/led:torch_2/brightness", "w") as f:
+      f.write(f"{value}\n")
+    with open("/sys/class/leds/led:switch_2/brightness", "w") as f:
+      f.write(f"{value}\n")
+
+  def get_network_type(self):
+    try:
+      primary_connection = self.nm.Get(NM, 'PrimaryConnection', dbus_interface=DBUS_PROPS, timeout=TIMEOUT)
+      primary_connection = self.bus.get_object(NM, primary_connection)
+      primary_type = primary_connection.Get(NM_CON_ACT, 'Type', dbus_interface=DBUS_PROPS, timeout=TIMEOUT)
+
+      if primary_type == '802-3-ethernet':
+        return NetworkType.ethernet
+      elif primary_type == '802-11-wireless':
+        return NetworkType.wifi
+      else:
+        active_connections = self.nm.Get(NM, 'ActiveConnections', dbus_interface=DBUS_PROPS, timeout=TIMEOUT)
+        for conn in active_connections:
+          c = self.bus.get_object(NM, conn)
+          tp = c.Get(NM_CON_ACT, 'Type', dbus_interface=DBUS_PROPS, timeout=TIMEOUT)
+          if tp == 'gsm':
+            modem = self.get_modem()
+            modem_state = modem.Get(MM_MODEM, 'State', dbus_interface=DBUS_PROPS, timeout=TIMEOUT)
+            if modem_state < MM_MODEM_STATE.REGISTERED:
+              return NetworkType.none
+            access_t = modem.Get(MM_MODEM, 'AccessTechnologies', dbus_interface=DBUS_PROPS, timeout=TIMEOUT)
+            if access_t >= MM_MODEM_ACCESS_TECHNOLOGY_LTE:
+              return NetworkType.cell4G
+            elif access_t >= MM_MODEM_ACCESS_TECHNOLOGY_UMTS:
+              return NetworkType.cell3G
+            else:
+              return NetworkType.cell2G
+    except Exception:
+      pass
+
+    return NetworkType.none
+
+  def get_modem(self):
+    objects = self.mm.GetManagedObjects(dbus_interface="org.freedesktop.DBus.ObjectManager", timeout=TIMEOUT)
+    if not objects:
+      raise RuntimeError("ModemManager returned no modems")
+    modem_path = next(iter(objects))
+    return self.bus.get_object(MM, modem_path)
+
+  def get_wlan(self):
+    wlan_path = self.nm.GetDeviceByIpIface('wlan0', dbus_interface=NM, timeout=TIMEOUT)
+    return self.bus.get_object(NM, wlan_path)
+
+  def get_wwan(self):
+    wwan_path = self.nm.GetDeviceByIpIface('wwan0', dbus_interface=NM, timeout=TIMEOUT)
+    return self.bus.get_object(NM, wwan_path)
+
+  def get_sim_info(self):
+    modem = self.get_modem()
+    sim_path = modem.Get(MM_MODEM, 'Sim', dbus_interface=DBUS_PROPS, timeout=TIMEOUT)
+
+    if sim_path == "/":
+      return {
+        'sim_id': '',
+        'mcc_mnc': None,
+        'network_type': ["Unknown"],
+        'sim_state': ["ABSENT"],
+        'data_connected': False
+      }
+    else:
+      sim = self.bus.get_object(MM, sim_path)
+      return {
+        'sim_id': str(sim.Get(MM_SIM, 'SimIdentifier', dbus_interface=DBUS_PROPS, timeout=TIMEOUT)),
+        'mcc_mnc': str(sim.Get(MM_SIM, 'OperatorIdentifier', dbus_interface=DBUS_PROPS, timeout=TIMEOUT)),
+        'network_type': ["Unknown"],
+        'sim_state': ["READY"],
+        'data_connected': modem.Get(MM_MODEM, 'State', dbus_interface=DBUS_PROPS, timeout=TIMEOUT) == MM_MODEM_STATE.CONNECTED,
+      }
+
+  def get_sim_lpa(self) -> LPABase:
+    return TiciLPA()
+
+  def get_imei(self, slot):
+    if slot != 0:
+      return ""
+
+    return str(self.get_modem().Get(MM_MODEM, 'EquipmentIdentifier', dbus_interface=DBUS_PROPS, timeout=TIMEOUT))
+
+  def get_network_info(self):
+    if self.get_device_type() == "mici":
+      return None
+    try:
+      modem = self.get_modem()
+      info = modem.Command("AT+QNWINFO", math.ceil(TIMEOUT), dbus_interface=MM_MODEM, timeout=TIMEOUT)
+      extra = modem.Command('AT+QENG="servingcell"', math.ceil(TIMEOUT), dbus_interface=MM_MODEM, timeout=TIMEOUT)
+      state = modem.Get(MM_MODEM, 'State', dbus_interface=DBUS_PROPS, timeout=TIMEOUT)
+    except Exception:
+      return None
+
+    if info and info.startswith('+QNWINFO: '):
+      info = info.replace('+QNWINFO: ', '').replace('"', '').split(',')
+      extra = "" if extra is None else extra.replace('+QENG: "servingcell",', '').replace('"', '')
+      state = "" if state is None else MM_MODEM_STATE(state).name
+
+      if len(info) != 4:
+        return None
+
+      technology, operator, band, channel = info
+
+      return({
+        'technology': technology,
+        'operator': operator,
+        'band': band,
+        'channel': int(channel),
+        'extra': extra,
+        'state': state,
+      })
+    else:
+      return None
+
+  def parse_strength(self, percentage):
+    if percentage < 25:
+      return NetworkStrength.poor
+    elif percentage < 50:
+      return NetworkStrength.moderate
+    elif percentage < 75:
+      return NetworkStrength.good
+    else:
+      return NetworkStrength.great
+
+  def get_network_strength(self, network_type):
+    network_strength = NetworkStrength.unknown
+
+    try:
+      if network_type == NetworkType.none:
+        pass
+      elif network_type == NetworkType.wifi:
+        wlan = self.get_wlan()
+        active_ap_path = wlan.Get(NM_DEV_WL, 'ActiveAccessPoint', dbus_interface=DBUS_PROPS, timeout=TIMEOUT)
+        if active_ap_path != "/":
+          active_ap = self.bus.get_object(NM, active_ap_path)
+          strength = int(active_ap.Get(NM_AP, 'Strength', dbus_interface=DBUS_PROPS, timeout=TIMEOUT))
+          network_strength = self.parse_strength(strength)
+      else:  # Cellular
+        modem = self.get_modem()
+        strength = int(modem.Get(MM_MODEM, 'SignalQuality', dbus_interface=DBUS_PROPS, timeout=TIMEOUT)[0])
+        network_strength = self.parse_strength(strength)
+    except Exception:
+      pass
+
+    return network_strength
+
+  def get_network_metered(self, network_type) -> bool:
+    try:
+      primary_connection = self.nm.Get(NM, 'PrimaryConnection', dbus_interface=DBUS_PROPS, timeout=TIMEOUT)
+      primary_connection = self.bus.get_object(NM, primary_connection)
+      primary_devices = primary_connection.Get(NM_CON_ACT, 'Devices', dbus_interface=DBUS_PROPS, timeout=TIMEOUT)
+
+      for dev in primary_devices:
+        dev_obj = self.bus.get_object(NM, str(dev))
+        metered_prop = dev_obj.Get(NM_DEV, 'Metered', dbus_interface=DBUS_PROPS, timeout=TIMEOUT)
+
+        if network_type == NetworkType.wifi:
+          if metered_prop in [NMMetered.NM_METERED_YES, NMMetered.NM_METERED_GUESS_YES]:
+            return True
+        elif network_type in [NetworkType.cell2G, NetworkType.cell3G, NetworkType.cell4G, NetworkType.cell5G]:
+          if metered_prop == NMMetered.NM_METERED_NO:
+            return False
+    except Exception:
+      pass
+
+    return super().get_network_metered(network_type)
+
+  def get_modem_version(self):
+    try:
+      modem = self.get_modem()
+      return modem.Get(MM_MODEM, 'Revision', dbus_interface=DBUS_PROPS, timeout=TIMEOUT)
+    except Exception:
+      return None
+
+  def get_modem_temperatures(self):
+    timeout = 0.2  # Default timeout is too short
+    try:
+      modem = self.get_modem()
+      temps = modem.Command("AT+QTEMP", math.ceil(timeout), dbus_interface=MM_MODEM, timeout=timeout)
+      return list(filter(lambda t: t != 255, map(int, temps.split(' ')[1].split(','))))
+    except Exception:
+      return []
+
+
+  def get_current_power_draw(self):
+    return (self.read_param_file("/sys/class/hwmon/hwmon1/power1_input", int) / 1e6)
+
+  def get_som_power_draw(self):
+    return (self.read_param_file("/sys/class/power_supply/bms/voltage_now", int) * self.read_param_file("/sys/class/power_supply/bms/current_now", int) / 1e12)
+
+  def shutdown(self):
+    os.system("sudo poweroff")
+
+  def get_thermal_config(self):
+    intake, exhaust, case = None, None, None
+    if self.get_device_type() == "mici":
+      case = ThermalZone("case")
+      intake = ThermalZone("intake")
+      exhaust = ThermalZone("exhaust")
+    return ThermalConfig(cpu=[ThermalZone(f"cpu{i}-silver-usr") for i in range(4)] +
+                             [ThermalZone(f"cpu{i}-gold-usr") for i in range(4)],
+                         gpu=[ThermalZone("gpu0-usr"), ThermalZone("gpu1-usr")],
+                         dsp=ThermalZone("compute-hvx-usr"),
+                         memory=ThermalZone("ddr-usr"),
+                         pmic=[ThermalZone("pm8998_tz"), ThermalZone("pm8005_tz")],
+                         intake=intake,
+                         exhaust=exhaust,
+                         case=case)
+
+  def set_display_power(self, on):
+    try:
+      with open("/sys/class/backlight/panel0-backlight/bl_power", "w") as f:
+        f.write("0" if on else "4")
+    except Exception:
+      pass
+
+  def set_screen_brightness(self, percentage):
+    try:
+      with open("/sys/class/backlight/panel0-backlight/max_brightness") as f:
+        max_brightness = float(f.read().strip())
+
+      val = int(percentage * (max_brightness / 100.))
+      with open("/sys/class/backlight/panel0-backlight/brightness", "w") as f:
+        f.write(str(val))
+    except Exception:
+      pass
+
+  def get_screen_brightness(self):
+    try:
+      with open("/sys/class/backlight/panel0-backlight/max_brightness") as f:
+        max_brightness = float(f.read().strip())
+
+      with open("/sys/class/backlight/panel0-backlight/brightness") as f:
+        return int(float(f.read()) / (max_brightness / 100.))
+    except Exception:
+      return 0
+
+  def set_power_save(self, powersave_enabled):
+    # amplifier, 100mW at idle
+    if self.amplifier is not None:
+      self.amplifier.set_global_shutdown(amp_disabled=powersave_enabled)
+      if not powersave_enabled:
+        self.amplifier.initialize_configuration(self.get_device_type())
+
+    # *** CPU config ***
+
+    # offline big cluster
+    for i in range(4, 8):
+      val = '0' if powersave_enabled else '1'
+      sudo_write(val, f'/sys/devices/system/cpu/cpu{i}/online')
+
+    for n in ('0', '4'):
+      if powersave_enabled and n == '4':
+        continue
+      gov = 'ondemand' if powersave_enabled else 'performance'
+      sudo_write(gov, f'/sys/devices/system/cpu/cpufreq/policy{n}/scaling_governor')
+
+    # *** IRQ config ***
+
+    # GPU, modeld core
+    affine_irq(7, "kgsl-3d0")
+
+    # camerad core
+    camera_irqs = ("a5", "cci", "cpas_camnoc", "cpas-cdm", "csid", "ife", "csid-lite", "ife-lite")
+    for n in camera_irqs:
+      affine_irq(6, n)
+
+  def get_gpu_usage_percent(self):
+    try:
+      with open('/sys/class/kgsl/kgsl-3d0/gpubusy') as f:
+        used, total = f.read().strip().split()
+      return 100.0 * int(used) / int(total)
+    except Exception:
+      return 0
+
+  def initialize_hardware(self):
+    if self.amplifier is not None:
+      self.amplifier.initialize_configuration(self.get_device_type())
+
+    # Allow hardwared to write engagement status to kmsg
+    os.system("sudo chmod a+w /dev/kmsg")
+
+    # Ensure fan gpio is enabled so fan runs until shutdown, also turned on at boot by the ABL
+    gpio_init(GPIO.SOM_ST_IO, True)
+    gpio_set(GPIO.SOM_ST_IO, 1)
+
+    # *** IRQ config ***
+
+    # mask off big cluster from default affinity
+    sudo_write("f", "/proc/irq/default_smp_affinity")
+
+    # move these off the default core
+    affine_irq(1, "msm_vidc")  # encoders
+    affine_irq(1, "i2c_geni")  # sensors
+
+    # *** GPU config ***
+    # https://github.com/commaai/agnos-kernel-sdm845/blob/master/arch/arm64/boot/dts/qcom/sdm845-gpu.dtsi#L216
+    affine_irq(5, "fts_ts")    # touch
+    affine_irq(5, "msm_drm")   # display
+    sudo_write("1", "/sys/class/kgsl/kgsl-3d0/min_pwrlevel")
+    sudo_write("1", "/sys/class/kgsl/kgsl-3d0/max_pwrlevel")
+    sudo_write("1", "/sys/class/kgsl/kgsl-3d0/force_bus_on")
+    sudo_write("1", "/sys/class/kgsl/kgsl-3d0/force_clk_on")
+    sudo_write("1", "/sys/class/kgsl/kgsl-3d0/force_rail_on")
+    sudo_write("1000", "/sys/class/kgsl/kgsl-3d0/idle_timer")
+    sudo_write("performance", "/sys/class/kgsl/kgsl-3d0/devfreq/governor")
+    sudo_write("710", "/sys/class/kgsl/kgsl-3d0/max_clock_mhz")
+
+    # setup governors
+    sudo_write("performance", "/sys/class/devfreq/soc:qcom,cpubw/governor")
+    sudo_write("performance", "/sys/class/devfreq/soc:qcom,memlat-cpu0/governor")
+    sudo_write("performance", "/sys/class/devfreq/soc:qcom,memlat-cpu4/governor")
+
+    # *** VIDC (encoder) config ***
+    sudo_write("N", "/sys/kernel/debug/msm_vidc/clock_scaling")
+    sudo_write("Y", "/sys/kernel/debug/msm_vidc/disable_thermal_mitigation")
+
+    # pandad core
+    affine_irq(3, "spi_geni")         # SPI
+    if "tici" in self.get_device_type():
+      affine_irq(3, "xhci-hcd:usb3")
+      affine_irq(3, "xhci-hcd:usb1")
+    try:
+      pid = subprocess.check_output(["pgrep", "-f", "spi0"], encoding='utf8').strip()
+      subprocess.call(["sudo", "chrt", "-f", "-p", "1", pid])
+      subprocess.call(["sudo", "taskset", "-pc", "3", pid], stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
+    except subprocess.CalledProcessException as e:
+      print(str(e))
+
+  def configure_modem(self):
+    from iqpilot.common.params import Params
+
+    sim_info = self.get_sim_info()
+    sim_id = sim_info.get('sim_id', '')
+    params = Params()
+    manual_apn = params.get("GsmApn", encoding="utf-8") or ""
+    metered_enabled = params.get_bool("GsmMetered")
+
+    modem = self.get_modem()
+    try:
+      manufacturer = str(modem.Get(MM_MODEM, 'Manufacturer', dbus_interface=DBUS_PROPS, timeout=TIMEOUT))
+    except Exception:
+      manufacturer = None
+
+    cmds = []
+    is_comma_profile = self.get_sim_lpa().is_comma_profile(sim_id)
+    roaming_enabled = params.get_bool("GsmRoaming")
+    initial_eps_apn = "" if is_comma_profile else manual_apn
+
+    if not is_comma_profile and params.get("GsmRoaming") is None:
+      params.put_bool("GsmRoaming", True)
+      roaming_enabled = True
+
+    subprocess.call([
+      "nmcli", "connection", "modify", "lte",
+      "gsm.auto-config", "no" if manual_apn else "yes",
+      "gsm.apn", manual_apn,
+      "gsm.home-only", "no" if roaming_enabled else "yes",
+      "gsm.network-id", "",
+      "gsm.initial-eps-bearer-configure", "yes" if initial_eps_apn else "no",
+      "gsm.initial-eps-bearer-apn", initial_eps_apn,
+      "connection.metered", "unknown" if metered_enabled else "no",
+    ], stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
+
+    if self.get_device_type() in ("tici", "tizi"):
+      if initial_eps_apn:
+        subprocess.call(["mmcli", "-m", "any", f'--3gpp-set-initial-eps-bearer-settings=apn={initial_eps_apn}'])
+      else:
+        subprocess.call(["mmcli", "-m", "any", '--3gpp-set-initial-eps-bearer-settings=apn='])
+
+      cmds += [
+        # configure modem as data-centric
+        'AT+QNVW=5280,0,"0102000000000000"',
+        'AT+QNVFW="/nv/item_files/ims/IMS_enable",00',
+        'AT+QNVFW="/nv/item_files/modem/mmode/ue_usage_setting",01',
+      ]
+      if self.get_device_type() == "tizi":
+        cmds += [
+          'AT+QSIMDET=1,0',
+          'AT+QSIMSTAT=1',
+        ]
+    elif manufacturer == 'Cavli Inc.':
+      cmds += [
+        'AT^SIMSWAP=1',     # use SIM slot, instead of internal eSIM
+        'AT$QCSIMSLEEP=0',  # disable SIM sleep
+        'AT$QCSIMCFG=SimPowerSave,0',  # more sleep disable
+
+        # ethernet config
+        'AT$QCPCFG=usbNet,0',
+        'AT$QCNETDEVCTL=3,1',
+      ]
+    else:
+      # this modem gets upset with too many AT commands
+      if sim_id is None or len(sim_id) == 0:
+        cmds += [
+          # SIM sleep disable
+          'AT$QCSIMSLEEP=0',
+          'AT$QCSIMCFG=SimPowerSave,0',
+
+          # ethernet config
+          'AT$QCPCFG=usbNet,1',
+        ]
+
+    for cmd in cmds:
+      try:
+        modem.Command(cmd, math.ceil(TIMEOUT), dbus_interface=MM_MODEM, timeout=TIMEOUT)
+      except Exception:
+        pass
+
+    # eSIM prime
+    dest = "/etc/NetworkManager/system-connections/esim.nmconnection"
+    if self.get_sim_lpa().is_comma_profile(sim_id) and not os.path.exists(dest):
+      with open(Path(__file__).parent/'esim.nmconnection') as f, tempfile.NamedTemporaryFile(mode='w') as tf:
+        dat = f.read()
+        dat = dat.replace("sim-id=", f"sim-id={sim_id}")
+        tf.write(dat)
+        tf.flush()
+
+        # needs to be root
+        os.system(f"sudo cp {tf.name} {dest}")
+      os.system(f"sudo nmcli con load {dest}")
+
+  def recover_sim_detection(self) -> bool:
+    # A worn SIM-tray presence switch can read "removed" while the SIM pads still make
+    # contact; with hot-swap detect armed (AT+QSIMDET=1) the modem never powers the SIM
+    # and lands in failed/sim-missing. Disabling detect and rebooting the modem makes it
+    # probe the SIM electrically. Safe to retry on failure: firing disarms the QSIMDET
+    # gate, so a genuinely SIM-less device gets at most one extra modem reboot per boot.
+    if self.get_device_type() not in ("tici", "tizi"):
+      return False
+
+    try:
+      modem = self.get_modem()
+      state = modem.Get(MM_MODEM, 'State', dbus_interface=DBUS_PROPS, timeout=TIMEOUT)
+      if state != MM_MODEM_STATE.FAILED:
+        return False
+      reason = modem.Get(MM_MODEM, 'StateFailedReason', dbus_interface=DBUS_PROPS, timeout=TIMEOUT)
+      if reason != MM_MODEM_STATE_FAILED_REASON_SIM_MISSING:
+        return False
+      detect = str(modem.Command('AT+QSIMDET?', math.ceil(TIMEOUT), dbus_interface=MM_MODEM, timeout=TIMEOUT)).strip()
+      if not detect.startswith('+QSIMDET: 1'):
+        return False
+      modem.Command('AT+QSIMDET=0,0', math.ceil(TIMEOUT), dbus_interface=MM_MODEM, timeout=TIMEOUT)
+      modem.Command('AT+CFUN=1,1', math.ceil(TIMEOUT), dbus_interface=MM_MODEM, timeout=TIMEOUT)
+      return True
+    except Exception:
+      return False
+
+  def reboot_modem(self):
+    modem = None
+    try:
+      modem = self.get_modem()
+    except Exception:
+      pass
+
+    if modem is not None:
+      for state in (0, 1):
+        try:
+          modem.Command(f'AT+CFUN={state}', math.ceil(TIMEOUT), dbus_interface=MM_MODEM, timeout=TIMEOUT)
+        except Exception:
+          pass
+      return
+
+    for state in (0, 1):
+      try:
+        self._run_direct_modem_command(f"AT+CFUN={state}")
+      except Exception:
+        pass
+
+  def get_networks(self):
+    r = {}
+
+    wlan = iwlist.scan()
+    if wlan is not None:
+      r['wlan'] = wlan
+
+    lte_info = self.get_network_info()
+    if lte_info is not None:
+      extra = lte_info['extra']
+
+      # <state>,"LTE",<is_tdd>,<mcc>,<mnc>,<cellid>,<pcid>,<earfcn>,<freq_band_ind>,
+      # <ul_bandwidth>,<dl_bandwidth>,<tac>,<rsrp>,<rsrq>,<rssi>,<sinr>,<srxlev>
+      if 'LTE' in extra:
+        extra = extra.split(',')
+        try:
+          r['lte'] = [{
+            "mcc": int(extra[3]),
+            "mnc": int(extra[4]),
+            "cid": int(extra[5], 16),
+            "nmr": [{"pci": int(extra[6]), "earfcn": int(extra[7])}],
+          }]
+        except (ValueError, IndexError):
+          pass
+
+    return r
+
+  def get_modem_data_usage(self):
+    try:
+      wwan = self.get_wwan()
+
+      # Ensure refresh rate is set so values don't go stale
+      refresh_rate = wwan.Get(NM_DEV_STATS, 'RefreshRateMs', dbus_interface=DBUS_PROPS, timeout=TIMEOUT)
+      if refresh_rate != REFRESH_RATE_MS:
+        u = type(refresh_rate)
+        wwan.Set(NM_DEV_STATS, 'RefreshRateMs', u(REFRESH_RATE_MS), dbus_interface=DBUS_PROPS, timeout=TIMEOUT)
+
+      tx = wwan.Get(NM_DEV_STATS, 'TxBytes', dbus_interface=DBUS_PROPS, timeout=TIMEOUT)
+      rx = wwan.Get(NM_DEV_STATS, 'RxBytes', dbus_interface=DBUS_PROPS, timeout=TIMEOUT)
+      return int(tx), int(rx)
+    except Exception:
+      return -1, -1
+
+  def has_internal_panda(self):
+    return True
+
+  def reset_internal_panda(self):
+    gpio_init(GPIO.STM_RST_N, True)
+    gpio_init(GPIO.STM_BOOT0, True)
+
+    gpio_set(GPIO.STM_RST_N, 1)
+    gpio_set(GPIO.STM_BOOT0, 0)
+    time.sleep(1)
+    gpio_set(GPIO.STM_RST_N, 0)
+
+  def recover_internal_panda(self):
+    gpio_init(GPIO.STM_RST_N, True)
+    gpio_init(GPIO.STM_BOOT0, True)
+
+    gpio_set(GPIO.STM_RST_N, 1)
+    gpio_set(GPIO.STM_BOOT0, 1)
+    time.sleep(0.5)
+    gpio_set(GPIO.STM_RST_N, 0)
+    time.sleep(0.5)
+    gpio_set(GPIO.STM_BOOT0, 0)
+
+  def booted(self):
+    # this normally boots within 8s, but on rare occasions takes 30+s
+    encoder_state = sudo_read("/sys/kernel/debug/msm_vidc/core0/info")
+    if "Core state: 0" in encoder_state and (time.monotonic() < 60*2):
+      return False
+    return True
+
+if __name__ == "__main__":
+  t = Tici()
+  t.configure_modem()
+  t.initialize_hardware()
+  t.set_power_save(False)
+  print(t.get_sim_info())

artifacts/iqpilot_hephaestusd_private/python/_iqclosure/iqpilot/system/hardware/tici/iwlist.py

@@ -0,0 +1,35 @@
+import subprocess
+
+
+def scan(interface="wlan0"):
+  result = []
+  try:
+    r = subprocess.check_output(["iwlist", interface, "scan"], encoding='utf8')
+
+    mac = None
+    for line in r.split('\n'):
+      if "Address" in line:
+        # Based on the adapter eithere a percentage or dBm is returned
+        # Add previous network in case no dBm signal level was seen
+        if mac is not None:
+          result.append({"mac": mac})
+          mac = None
+
+        mac = line.split(' ')[-1]
+      elif "dBm" in line:
+        try:
+          level = line.split('Signal level=')[1]
+          rss = int(level.split(' ')[0])
+          result.append({"mac": mac, "rss": rss})
+          mac = None
+        except ValueError:
+          continue
+
+    # Add last network if no dBm was found
+    if mac is not None:
+      result.append({"mac": mac})
+
+    return result
+
+  except Exception:
+    return None

artifacts/iqpilot_hephaestusd_private/python/_iqclosure/iqpilot/system/hardware/tici/pins.py

@@ -0,0 +1,30 @@
+# GPIO pin definitions
+class GPIO:
+  # both GPIO_STM_RST_N and GPIO_LTE_RST_N are misnamed, they are high to reset
+  HUB_RST_N = 30
+  UBLOX_RST_N = 32
+  UBLOX_SAFEBOOT_N = 33
+  GNSS_PWR_EN = 34 # SCHEMATIC LABEL: GPIO_UBLOX_PWR_EN
+
+  STM_RST_N = 124
+  STM_BOOT0 = 134
+  STM_PWR_EN_N = 41 # because STM32H7 RST doesn't generate a full power-on-reset
+
+  SIREN = 42
+  SOM_ST_IO = 49
+
+  LTE_RST_N = 50
+  LTE_PWRKEY = 116
+  LTE_BOOT = 52
+
+  # GPIO_CAM0_DVDD_EN = /sys/kernel/debug/regulator/camera_rear_ldo
+  CAM0_AVDD_EN = 8
+  CAM0_RSTN = 9
+  CAM1_RSTN = 7
+  CAM2_RSTN = 12
+
+  # Sensor interrupts
+  BMX055_ACCEL_INT = 21
+  BMX055_GYRO_INT = 23
+  BMX055_MAGN_INT = 87
+  LSM_INT = 84

artifacts/iqpilot_hephaestusd_private/python/_iqclosure/iqpilot/system/loggerd/xattr_cache.py

@@ -0,0 +1,28 @@
+import errno
+import os
+
+import xattr
+
+_cached_attributes: dict[tuple[str, str], tuple[tuple[int, int, int], bytes | None]] = {}
+
+def getxattr(path: str, attr_name: str) -> bytes | None:
+  key = (path, attr_name)
+  st = os.stat(path)
+  identity = (st.st_dev, st.st_ino, st.st_ctime_ns)
+  cached = _cached_attributes.get(key)
+  if cached is None or cached[0] != identity:
+    try:
+      response = xattr.getxattr(path, attr_name)
+    except OSError as e:
+      # ENODATA (Linux) or ENOATTR (macOS) means attribute hasn't been set
+      if e.errno == errno.ENODATA or (hasattr(errno, 'ENOATTR') and e.errno == errno.ENOATTR):
+        response = None
+      else:
+        raise
+    _cached_attributes[key] = (identity, response)
+  return _cached_attributes[key][1]
+
+def setxattr(path: str, attr_name: str, attr_value: bytes) -> None:
+  xattr.setxattr(path, attr_name, attr_value)
+  st = os.stat(path)
+  _cached_attributes[(path, attr_name)] = ((st.st_dev, st.st_ino, st.st_ctime_ns), attr_value)

artifacts/iqpilot_hephaestusd_private/python/_iqclosure/iqpilot/system/manager/process.py

@@ -0,0 +1,365 @@
+import importlib
+import os
+import signal
+import time
+import subprocess
+from pathlib import Path
+from collections.abc import Callable, ValuesView
+from abc import ABC, abstractmethod
+from multiprocessing import Process
+
+from setproctitle import setproctitle
+
+from iqpilot.cereal import car, log
+import iqpilot.cereal.messaging as messaging
+import iqpilot.system.sentry as sentry
+from iqpilot.common.basedir import BASEDIR
+from iqpilot.common.params import Params
+from iqpilot.common.swaglog import cloudlog
+
+MAX_CRASH_BACKOFF = 300.0
+CRASH_RESET_TIME = 60.0
+CRASH_LOOP_THRESHOLD = 6
+
+try:
+  from iqpilot.system.proprietary_runtime.runtime_paths import preferred_runner_path
+except ModuleNotFoundError:
+  _VERIFIED_RUNNER_PATH = Path("/usr/libexec/iqpilot/iqpilot_bundle_runner")
+  _FALLBACK_RUNNER_PATH = Path("/data/openpilot/iqpilot/system/proprietary_runtime/iqpilot_bundle_runner")
+
+  def preferred_runner_path() -> Path:
+    if _VERIFIED_RUNNER_PATH.is_file() and os.access(_VERIFIED_RUNNER_PATH, os.X_OK):
+      return _VERIFIED_RUNNER_PATH
+    if os.getenv("IQPILOT_ALLOW_DEV_FALLBACKS") == "1" and _FALLBACK_RUNNER_PATH.is_file():
+      return _FALLBACK_RUNNER_PATH
+    return _VERIFIED_RUNNER_PATH
+
+
+def launcher(proc: str, name: str) -> None:
+  try:
+    # import the process
+    mod = importlib.import_module(proc)
+
+    # rename the process
+    setproctitle(proc)
+
+    # create new context since we forked
+    messaging.reset_context()
+
+    # add daemon name tag to logs
+    cloudlog.bind(daemon=name)
+    sentry.set_tag("daemon", name)
+
+    # exec the process
+    mod.main()
+  except KeyboardInterrupt:
+    cloudlog.warning(f"child {proc} got SIGINT")
+  except Exception:
+    # can't install the crash handler because sys.excepthook doesn't play nice
+    # with threads, so catch it here.
+    sentry.capture_exception()
+    raise
+
+
+def nativelauncher(pargs: list[str], cwd: str, name: str) -> None:
+  os.environ['MANAGER_DAEMON'] = name
+
+  # exec the process
+  os.chdir(cwd)
+  os.environ['PWD'] = cwd
+  os.execvp(pargs[0], pargs)
+
+
+def join_process(process: Process, timeout: float) -> None:
+  # Process().join(timeout) will hang due to a python 3 bug: https://bugs.python.org/issue28382
+  # We have to poll the exitcode instead
+  t = time.monotonic()
+  while time.monotonic() - t < timeout and process.exitcode is None:
+    time.sleep(0.001)
+
+
+class ManagerProcess(ABC):
+  daemon = False
+  sigkill = False
+  should_run: Callable[[bool, Params, car.CarParams], bool]
+  proc: Process | None = None
+  enabled = True
+  name = ""
+  shutting_down = False
+  restart_if_crash = False
+  crash_count = 0
+  last_restart_time = 0.0
+  last_alive_time = 0.0
+  crash_loop_logged = False
+
+  @abstractmethod
+  def prepare(self) -> None:
+    pass
+
+  @abstractmethod
+  def start(self) -> None:
+    pass
+
+  def restart(self) -> None:
+    self.stop(sig=signal.SIGKILL)
+    self.start()
+
+  def stop(self, retry: bool = True, block: bool = True, sig: signal.Signals | None = None, timeout: float = 5) -> int | None:
+    if self.proc is None:
+      return None
+
+    if self.proc.exitcode is None:
+      if not self.shutting_down:
+        cloudlog.info(f"killing {self.name}")
+        if sig is None:
+          sig = signal.SIGKILL if self.sigkill else signal.SIGINT
+        self.signal(sig)
+        self.shutting_down = True
+
+        if not block:
+          return None
+
+      join_process(self.proc, timeout)
+
+      # If process failed to die send SIGKILL
+      if self.proc.exitcode is None and retry:
+        cloudlog.info(f"killing {self.name} with SIGKILL")
+        self.signal(signal.SIGKILL)
+        self.proc.join()
+
+    ret = self.proc.exitcode
+    cloudlog.info(f"{self.name} is dead with {ret}")
+
+    if self.proc.exitcode is not None:
+      self.shutting_down = False
+      self.proc = None
+
+    return ret
+
+  def signal(self, sig: int) -> None:
+    if self.proc is None:
+      return
+
+    # Don't signal if already exited
+    if self.proc.exitcode is not None and self.proc.pid is not None:
+      return
+
+    # Can't signal if we don't have a pid
+    if self.proc.pid is None:
+      return
+
+    cloudlog.info(f"sending signal {sig} to {self.name}")
+    os.kill(self.proc.pid, sig)
+
+  def get_process_state_msg(self):
+    state = log.ManagerState.ProcessState.new_message()
+    state.name = self.name
+    if self.proc:
+      state.running = self.proc.is_alive()
+      state.shouldBeRunning = self.proc is not None and not self.shutting_down
+      state.pid = self.proc.pid or 0
+      state.exitCode = self.proc.exitcode or 0
+    return state
+
+
+class NativeProcess(ManagerProcess):
+  def __init__(self, name, cwd, cmdline, should_run, enabled=True, sigkill=False, restart_if_crash=False):
+    self.name = name
+    self.cwd = cwd
+    self.cmdline = cmdline
+    self.should_run = should_run
+    self.enabled = enabled
+    self.sigkill = sigkill
+    self.launcher = nativelauncher
+    self.restart_if_crash = restart_if_crash
+
+  def prepare(self) -> None:
+    pass
+
+  def start(self) -> None:
+    # In case we only tried a non blocking stop we need to stop it before restarting
+    if self.shutting_down:
+      self.stop()
+
+    if self.proc is not None:
+      return
+
+    cwd = os.path.join(BASEDIR, self.cwd)
+    cloudlog.info(f"starting process {self.name}")
+    self.proc = Process(name=self.name, target=self.launcher, args=(self.cmdline, cwd, self.name))
+    self.proc.start()
+    self.shutting_down = False
+
+
+def _normalize_bundle_modes(bundle: str) -> None:
+  import json
+  candidates = []
+  if env_root := os.environ.get("IQPILOT_PROPRIETARY_ROOT"):
+    candidates += [os.path.join(env_root, bundle), env_root]
+  candidates += [
+    os.path.join(BASEDIR, ".iqpilot", "bundles", bundle),
+    os.path.join(os.path.dirname(BASEDIR), ".iqpilot", "bundles", bundle),
+    os.path.join(BASEDIR, "artifacts", bundle),
+  ]
+  root = next((c for c in candidates if os.path.isfile(os.path.join(c, "manifest.json"))), None)
+  if root is None:
+    return
+  try:
+    with open(os.path.join(root, "manifest.json")) as f:
+      manifest = json.load(f)
+    for rel, meta in manifest.items():
+      if not (isinstance(meta, dict) and "mode" in meta and "sha256" in meta):
+        continue
+      path = os.path.join(root, rel)
+      if os.path.isfile(path) and (os.stat(path).st_mode & 0o777) != meta["mode"]:
+        os.chmod(path, meta["mode"])
+  except Exception:
+    cloudlog.exception(f"failed to normalize bundle modes for {bundle}")
+
+
+class BundleProcess(NativeProcess):
+  def __init__(self, name, bundle, entry, should_run, enabled=True, sigkill=False, restart_if_crash=False):
+    self.bundle = bundle
+    self.entry = entry
+    self.restart_if_crash = restart_if_crash
+    runner_path = preferred_runner_path()
+    runner_cmd = str(runner_path) if runner_path.is_absolute() else "./iqpilot_bundle_runner"
+    runner_cwd = ".iqpilot/runtime_root" if runner_path.is_absolute() else "system/proprietary_runtime"
+    super().__init__(
+      name=name,
+      cwd=runner_cwd,
+      cmdline=[
+        runner_cmd,
+        "--bundle", bundle,
+        "--mode", "python-module",
+        "--entry", entry,
+        "--daemon-name", name,
+      ],
+      should_run=should_run,
+      enabled=enabled,
+      sigkill=sigkill,
+    )
+
+  def start(self) -> None:
+    if self.proc is None:
+      _normalize_bundle_modes(self.bundle)
+    super().start()
+
+  def stop(self, retry: bool = True, block: bool = True, sig: signal.Signals | None = None, timeout: float = 5) -> int | None:
+    return super().stop(retry=retry, block=block, sig=signal.SIGTERM if sig is None else sig, timeout=timeout)
+
+
+class PythonProcess(ManagerProcess):
+  def __init__(self, name, module, should_run, enabled=True, sigkill=False, restart_if_crash=False):
+    self.name = name
+    self.module = module
+    self.should_run = should_run
+    self.enabled = enabled
+    self.sigkill = sigkill
+    self.launcher = launcher
+    self.restart_if_crash = restart_if_crash
+
+  def prepare(self) -> None:
+    if self.enabled:
+      cloudlog.info(f"preimporting {self.module}")
+      importlib.import_module(self.module)
+
+  def start(self) -> None:
+    # In case we only tried a non blocking stop we need to stop it before restarting
+    if self.shutting_down:
+      self.stop()
+
+    if self.proc is not None:
+      return
+
+    cloudlog.info(f"starting python {self.module}")
+    self.proc = Process(name=self.name, target=self.launcher, args=(self.module, self.name))
+    self.proc.start()
+    self.shutting_down = False
+
+
+class DaemonProcess(ManagerProcess):
+  """Python process that has to stay running across manager restart.
+  This is used for athena so you don't lose SSH access when restarting manager."""
+  def __init__(self, name, module, param_name, enabled=True):
+    self.name = name
+    self.module = module
+    self.param_name = param_name
+    self.enabled = enabled
+    self.params = None
+
+  @staticmethod
+  def should_run(started, params, CP):
+    return True
+
+  def prepare(self) -> None:
+    pass
+
+  def start(self) -> None:
+    if self.params is None:
+      self.params = Params()
+
+    pid = self.params.get(self.param_name)
+    if pid is not None:
+      try:
+        os.kill(int(pid), 0)
+        with open(f'/proc/{pid}/cmdline') as f:
+          if self.module in f.read():
+            # daemon is running
+            return
+      except (OSError, FileNotFoundError):
+        # process is dead
+        pass
+
+    cloudlog.info(f"starting daemon {self.name}")
+    proc = subprocess.Popen(['python', '-m', self.module],
+                               stdin=open('/dev/null'),
+                               stdout=open('/dev/null', 'w'),
+                               stderr=open('/dev/null', 'w'),
+                               preexec_fn=os.setpgrp)
+
+    self.params.put(self.param_name, proc.pid)
+
+  def stop(self, retry=True, block=True, sig=None) -> None:
+    pass
+
+
+def ensure_running(procs: ValuesView[ManagerProcess], started: bool, params=None, CP: car.CarParams=None,
+                   not_run: list[str] | None=None) -> list[ManagerProcess]:
+  if not_run is None:
+    not_run = []
+
+  running = []
+  now = time.monotonic()
+  for p in procs:
+    if p.enabled and p.name not in not_run and p.should_run(started, params, CP):
+      if p.restart_if_crash and p.proc is not None and p.proc.is_alive():
+        p.last_alive_time = now
+      elif p.restart_if_crash and p.proc is not None:
+        # uptime, not time-since-restart: the latter also counts the backoff wait,
+        # which would reset the counter as soon as backoff exceeds CRASH_RESET_TIME
+        if p.last_alive_time - p.last_restart_time > CRASH_RESET_TIME:
+          p.crash_count = 0
+          p.crash_loop_logged = False
+
+        backoff = 0.0 if not p.crash_count else min(MAX_CRASH_BACKOFF, 2.0 ** (p.crash_count - 1))
+        if now - p.last_restart_time >= backoff:
+          p.crash_count += 1
+          p.last_restart_time = now
+          cloudlog.error(f'Restarting {p.name} (exitcode {p.proc.exitcode}) [crash {p.crash_count}]')
+          if p.crash_count >= CRASH_LOOP_THRESHOLD and not p.crash_loop_logged:
+            # never stop retrying: giving up on hardwared or ui is worse than restarting slowly
+            cloudlog.error(f'{p.name} is in a crash loop, backing off to {MAX_CRASH_BACKOFF}s between restarts')
+            p.crash_loop_logged = True
+          p.restart()
+      running.append(p)
+    else:
+      p.crash_count = 0
+      p.crash_loop_logged = False
+      p.last_alive_time = 0.0
+      p.stop(block=False)
+
+  for p in running:
+    p.start()
+
+  return running

artifacts/iqpilot_hephaestusd_private/python/_iqclosure/iqpilot/system/manager/process_config.py

@@ -0,0 +1,221 @@
+import os
+import platform
+from pathlib import Path
+
+from iqpilot.cereal import car, custom
+from iqpilot.common.params import Params
+from iqpilot.system.hardware import HARDWARE, PC, TICI
+from iqpilot.system.hardware.hw import Paths
+from iqpilot.system.manager.process import PythonProcess, NativeProcess, BundleProcess
+
+from iqpilot.selfdrive.iqmodeld.models.helpers import get_active_model_runner
+from iqpilot.konn3kt.service_health import hephaestus_ready
+
+def driverview(started: bool, params: Params, CP: car.CarParams) -> bool:
+  return started or params.get_bool("IsDriverViewEnabled")
+
+def driver_monitoring(started: bool, params: Params, CP: car.CarParams) -> bool:
+  if os.path.exists('/tmp/lite_hw'):
+    return False
+  return driverview(started, params, CP)
+
+def notcar(started: bool, params: Params, CP: car.CarParams) -> bool:
+  return started and CP.notCar
+
+def iscar(started: bool, params: Params, CP: car.CarParams) -> bool:
+  return started and not CP.notCar
+
+def logging(started: bool, params: Params, CP: car.CarParams) -> bool:
+  run = (not CP.notCar) or not params.get_bool("DisableLogging")
+  return started and run and params.get_bool("DashcamEnabled")
+
+def ublox_available() -> bool:
+  if HARDWARE.get_device_type() == "tizi" or os.path.exists('/tmp/lite_hw'):
+    return False
+
+  quectel_override = Path(Paths.persist_root()) / "comma" / "use-quectel-gps"
+  return os.path.exists('/dev/ttyHS0') and not quectel_override.exists()
+
+def ublox(started: bool, params: Params, CP: car.CarParams) -> bool:
+  use_ublox = ublox_available()
+  if use_ublox != params.get_bool("UbloxAvailable"):
+    params.put_bool("UbloxAvailable", use_ublox)
+  return started and use_ublox
+
+def joystick(started: bool, params: Params, CP: car.CarParams) -> bool:
+  return started and params.get_bool("JoystickDebugMode")
+
+def not_joystick(started: bool, params: Params, CP: car.CarParams) -> bool:
+  return started and not params.get_bool("JoystickDebugMode")
+
+def long_maneuver(started: bool, params: Params, CP: car.CarParams) -> bool:
+  return started and params.get_bool("LongitudinalManeuverMode")
+
+def not_long_maneuver(started: bool, params: Params, CP: car.CarParams) -> bool:
+  return started and not params.get_bool("LongitudinalManeuverMode")
+
+def lat_maneuver(started: bool, params: Params, CP: car.CarParams) -> bool:
+  return started and params.get_bool("LateralManeuverMode")
+
+def not_lat_maneuver(started: bool, params: Params, CP: car.CarParams) -> bool:
+  return started and not params.get_bool("LateralManeuverMode")
+
+def qcomgps(started: bool, params: Params, CP: car.CarParams) -> bool:
+  return started and not ublox_available()
+
+def always_run(started: bool, params: Params, CP: car.CarParams) -> bool:
+  return True
+
+def only_onroad(started: bool, params: Params, CP: car.CarParams) -> bool:
+  return started
+
+def navd_onroad(started: bool, params: Params, CP: car.CarParams) -> bool:
+  return started and params.get_bool("NavigationEnabled")
+
+def navrenderd_onroad(started: bool, params: Params, CP: car.CarParams) -> bool:
+  return started and params.get_bool("NavigationEnabled") and params.get_bool("OnScreenNavigation")
+
+def navincidentd_onroad(started: bool, params: Params, CP: car.CarParams) -> bool:
+  return started and params.get_bool("NavigationEnabled") and bool(params.get("WazePoliceApiKey")) and (
+    params.get_int("WazePoliceAlertMode") > 0 or params.get_bool("WazePoliceShadow")
+  )
+
+def iqmapd_needed(params: Params) -> bool:
+  return (
+    params.get_bool("IQRoadNameOverlay")
+    or params.get_bool("ShowSpeedLimits")
+    or params.get_bool("SpeedLimitController")
+    or params.get_bool("EnableSpeedLimitControl")
+    or params.get_bool("EnableSpeedLimitPredicative")
+    or params.get_bool("MapCurveSpeedController")
+    or params.get_bool("VisionCurveSpeedController")
+  )
+
+def iqmapd_onroad(started: bool, params: Params, CP: car.CarParams) -> bool:
+  return started and params.get_bool("NavigationEnabled") and iqmapd_needed(params)
+
+def mapd_onroad(started: bool, params: Params, CP: car.CarParams) -> bool:
+  return started and iqmapd_needed(params)
+
+def constructiond_onroad(started: bool, params: Params, CP: car.CarParams) -> bool:
+  return started and params.get_bool("ConstructionZoneAssist")
+
+def iqvd_onroad(started: bool, params: Params, CP: car.CarParams) -> bool:
+  # held for 1.0d: iqvd runs a detector per frame and the added load is not
+  # something 1.0c needs to carry. re-enable by restoring the param check.
+  return False
+
+def only_offroad(started: bool, params: Params, CP: car.CarParams) -> bool:
+  return not started
+
+def livestream(started: bool, params: Params, CP: car.CarParams) -> bool:
+  # Konn3kt Live View: hephaestusd sets IsLiveStreaming when a viewer connects, so the
+  # manager brings up the stream encoder (and camerad/webrtcd when offroad) and tears them
+  # down cleanly when the session ends — no subprocess management inside hephaestusd.
+  return params.get_bool("IsLiveStreaming")
+
+def canlive(started: bool, params: Params, CP: car.CarParams) -> bool:
+  # Remote live CAN debugging via konn3kt. hephaestusd sets CanLiveStreaming when a viewer
+  # connects (startCanLive) and clears it when the last one leaves (stopCanLive), so canlived
+  # runs only during an active debug session — no idle connection or battery cost otherwise.
+  return params.get_bool("CanLiveStreaming")
+
+def is_tinygrad_model(started, params, CP: car.CarParams) -> bool:
+  """Check if the active model runner is tinygrad."""
+  return bool(get_active_model_runner(params, not started) == custom.IQModelManager.Runner.tinygrad)
+
+def hephaestus_ready_shim(started, params, CP: car.CarParams) -> bool:
+  return hephaestus_ready(params)
+
+def not_low_power(started: bool, params: Params, CP: car.CarParams) -> bool:
+  # FastSleep deep standby: heavy processes are shed offroad while DevicePowerState is low_power
+  return started or params.get("DevicePowerState") != "low_power"
+
+def iquploaderd_ready(started: bool, params: Params, CP: car.CarParams) -> bool:
+  if not params.get_bool("OnroadUploads"):
+    return only_offroad(started, params, CP)
+
+  return always_run(started, params, CP)
+
+def or_(*fns):
+  return lambda *args: any(fn(*args) for fn in fns)
+
+def and_(*fns):
+  return lambda *args: all(fn(*args) for fn in fns)
+
+procs = [
+  NativeProcess("loggerd", "iqpilot/system/loggerd", ["./loggerd"], logging),
+  NativeProcess("encoderd", "iqpilot/system/loggerd", ["./encoderd"], only_onroad),
+  NativeProcess("stream_encoderd", "iqpilot/system/loggerd", ["./encoderd", "--stream"], or_(notcar, livestream)),
+  PythonProcess("logmessaged", "iqpilot.system.logmessaged", always_run, restart_if_crash=True),
+
+  NativeProcess("camerad", "iqpilot/system/camerad", ["./camerad"], or_(driverview, livestream), restart_if_crash=True),
+  PythonProcess("proclogd", "iqpilot.system.proclogd", only_onroad, enabled=platform.system() != "Darwin"),
+  PythonProcess("journald", "iqpilot.system.journald", only_onroad, platform.system() != "Darwin"),
+  PythonProcess("micd", "iqpilot.system.micd", or_(iscar, livestream)),
+  PythonProcess("timed", "iqpilot.system.timed", always_run, enabled=not PC),
+
+  PythonProcess("dmonitoringmodeld", "iqpilot.selfdrive.dmonitoringmodeld.dmonitoringmodeld", driver_monitoring, enabled=not PC),
+
+  PythonProcess("sensord", "iqpilot.system.sensord.sensord", only_onroad, enabled=not PC),
+  PythonProcess("ui", "iqpilot.selfdrive.ui.ui", not_low_power, restart_if_crash=True),
+  PythonProcess("soundd", "iqpilot.selfdrive.ui.soundd", driverview),
+  PythonProcess("locationd", "iqpilot.selfdrive.locationd.locationd", only_onroad),
+  NativeProcess("_pandad", "iqpilot/selfdrive/pandad", ["./pandad"], always_run, enabled=False),
+  PythonProcess("calibrationd", "iqpilot.selfdrive.locationd.calibrationd", only_onroad),
+  PythonProcess("controlsd", "iqpilot.selfdrive.controls.controlsd", and_(not_joystick, iscar)),
+  PythonProcess("joystickd", "iqpilot.tools.joystick.joystickd", or_(joystick, notcar)),
+  PythonProcess("selfdrived", "iqpilot.selfdrive.selfdrived.selfdrived", only_onroad),
+  PythonProcess("card", "iqpilot.selfdrive.car.card", only_onroad),
+  PythonProcess("deleter", "iqpilot.system.loggerd.deleter", always_run),
+  PythonProcess("dmonitoringd", "iqpilot.selfdrive.monitoring.dmonitoringd", driver_monitoring, enabled=not PC),
+  PythonProcess("qcomgpsd", "iqpilot.system.qcomgpsd.qcomgpsd", qcomgps, enabled=TICI),
+  PythonProcess("pandad", "iqpilot.selfdrive.pandad.pandad", always_run),
+  PythonProcess("estimatord", "iqpilot.selfdrive.locationd.estimatord", only_onroad),
+  PythonProcess("ubloxd", "iqpilot.system.ubloxd.ubloxd", ublox, enabled=TICI),
+  PythonProcess("pigeond", "iqpilot.system.ubloxd.pigeond", ublox, enabled=TICI),
+  PythonProcess("plannerd", "iqpilot.selfdrive.controls.plannerd", not_long_maneuver),
+  PythonProcess("maneuversd", "iqpilot.tools.maneuvers.longitudinal_maneuversd", long_maneuver),
+  PythonProcess("lateral_maneuversd", "iqpilot.tools.maneuvers.lateral_maneuversd", lat_maneuver),
+  PythonProcess("radard", "iqpilot.selfdrive.controls.radard", only_onroad),
+  PythonProcess("hardwared", "iqpilot.system.hardware.hardwared", always_run, restart_if_crash=True),
+  PythonProcess("tombstoned", "iqpilot.system.tombstoned", always_run, enabled=not PC),
+  PythonProcess("updated", "iqpilot.system.updated.updated", and_(only_offroad, not_low_power), enabled=not PC),
+  BundleProcess("iquploaderd", "iqpilot_hephaestusd_private", "iqpilot_private.konn3kt.uploaderd.iquploaderd",
+                and_(iquploaderd_ready, not_low_power), restart_if_crash=True),
+  PythonProcess("feedbackd", "iqpilot.selfdrive.ui.feedback.feedbackd", and_(only_onroad, not_lat_maneuver)),
+
+  # debug procs
+  NativeProcess("bridge", "iqpilot/cereal/messaging", ["./bridge"], notcar),
+  PythonProcess("webrtcd", "iqpilot.system.webrtc.webrtcd", or_(iscar, livestream)),
+  PythonProcess("canlived", "iqpilot.konn3kt.canlive.canlived", canlive),
+]
+
+# iqpilot
+procs += [
+  # Models
+  BundleProcess("models_manager", "iqpilot_model_selector_private", "iqpilot_private.models.manager", and_(only_offroad, not_low_power)),
+  NativeProcess("iqmodeld", "iqpilot/selfdrive/iqmodeld", ["./iqmodeld"], and_(only_onroad, is_tinygrad_model)),
+
+  BundleProcess("backup_manager_k3", "iqpilot_hephaestusd_private", "iqpilot_private.konn3kt.backups.backup_orchestrator",
+                and_(only_offroad, hephaestus_ready_shim, not_low_power)),
+  BundleProcess("navd", "iqpilot_navd_private", "iqpilot_private.navd.navd", navd_onroad, restart_if_crash=True),
+  BundleProcess("navincidentd", "iqpilot_navd_private", "iqpilot_private.navd.navincidentd", navincidentd_onroad, restart_if_crash=True),
+  BundleProcess("navrenderd", "iqpilot_navd_private", "iqpilot_private.navd.navrenderd", navrenderd_onroad, restart_if_crash=True),
+  BundleProcess("iqmapd", "iqpilot_navd_private", "iqpilot_private.navd.iqmapd", iqmapd_onroad, restart_if_crash=True),
+
+  # work-zone detector for Speed Limit Assist
+  PythonProcess("constructiond", "iqpilot.selfdrive.constructiond", constructiond_onroad, restart_if_crash=True),
+
+  # iqvd: vision vehicle detector for UI ambient track dots
+  BundleProcess("iqvd", "iqpilot_iqvd_private", "iqpilot_private.iqvd.iqvd", iqvd_onroad, restart_if_crash=True),
+
+  # mapd
+  NativeProcess("mapd", "iqpilot/third_party/mapd_pfeiferj", ["./mapd"], mapd_onroad, restart_if_crash=True),
+  PythonProcess("mapd_manager", "iqpilot.iq_maps.orchestrator", and_(only_offroad, not_low_power)),
+
+  # locationd
+  NativeProcess("iqlocd", "iqpilot/selfdrive/iqlocd", ["./iqlocd"], only_onroad),
+]
+
+managed_processes = {p.name: p for p in procs}

artifacts/iqpilot_hephaestusd_private/python/_iqclosure/iqpilot/system/micd.py

@@ -0,0 +1,160 @@
+#!/usr/bin/env python3
+import numpy as np
+import os
+import time
+from functools import cache
+import threading
+
+from iqpilot.cereal import messaging
+from iqpilot.common.params import Params
+from iqpilot.common.realtime import Ratekeeper
+from iqpilot.common.utils import retry
+from iqpilot.common.swaglog import cloudlog
+
+RATE = 10
+FFT_SAMPLES = 1600 # 100ms
+REFERENCE_SPL = 2e-5  # newtons/m^2
+SAMPLE_RATE = 16000
+SAMPLE_BUFFER = 800  # 50ms
+
+
+@cache
+def get_a_weighting_filter():
+  # Calculate the A-weighting filter
+  # https://en.wikipedia.org/wiki/A-weighting
+  freqs = np.fft.fftfreq(FFT_SAMPLES, d=1 / SAMPLE_RATE)
+  A = 12194 ** 2 * freqs ** 4 / ((freqs ** 2 + 20.6 ** 2) * (freqs ** 2 + 12194 ** 2) * np.sqrt((freqs ** 2 + 107.7 ** 2) * (freqs ** 2 + 737.9 ** 2)))
+  return A / np.max(A)
+
+
+def calculate_spl(measurements):
+  # https://www.engineeringtoolbox.com/sound-pressure-d_711.html
+  sound_pressure = np.sqrt(np.mean(measurements ** 2))  # RMS of amplitudes
+  if sound_pressure > 0:
+    sound_pressure_level = 20 * np.log10(sound_pressure / REFERENCE_SPL)  # dB
+  else:
+    sound_pressure_level = 0
+  return sound_pressure, sound_pressure_level
+
+
+def apply_a_weighting(measurements: np.ndarray) -> np.ndarray:
+  # Generate a Hanning window of the same length as the audio measurements
+  measurements_windowed = measurements * np.hanning(len(measurements))
+
+  # Apply the A-weighting filter to the signal
+  return np.abs(np.fft.ifft(np.fft.fft(measurements_windowed) * get_a_weighting_filter()))
+
+
+class Mic:
+  def __init__(self):
+    self.rk = Ratekeeper(RATE)
+    self.pm = messaging.PubMaster(['soundPressure', 'rawAudioData'])
+    self.params = Params()
+
+    self.measurements = np.empty(0)
+
+    self.sound_pressure = 0
+    self.sound_pressure_weighted = 0
+    self.sound_pressure_level_weighted = 0
+
+    self.lock = threading.Lock()
+    self.callback_count = 0
+    self.last_audio_rms = 0.0
+    self.last_audio_peak = 0.0
+    self.last_device = None
+    self.last_status = None
+
+  def update(self):
+    with self.lock:
+      sound_pressure = self.sound_pressure
+      sound_pressure_weighted = self.sound_pressure_weighted
+      sound_pressure_level_weighted = self.sound_pressure_level_weighted
+      callback_count = self.callback_count
+      audio_rms = self.last_audio_rms
+      audio_peak = self.last_audio_peak
+      device_name = self.last_device
+      status = self.last_status
+
+    msg = messaging.new_message('soundPressure', valid=True)
+    msg.soundPressure.soundPressure = float(sound_pressure)
+    msg.soundPressure.soundPressureWeighted = float(sound_pressure_weighted)
+    msg.soundPressure.soundPressureWeightedDb = float(sound_pressure_level_weighted)
+
+    self.pm.send('soundPressure', msg)
+    if callback_count % RATE == 0:
+      cloudlog.info(
+        f"micd health: callbacks={callback_count} rms={audio_rms:.6f} peak={audio_peak:.6f} "
+        f"device={device_name} status={status!r} livestream={self.params.get_bool('IsLiveStreaming')}"
+      )
+    self.rk.keep_time()
+
+  def callback(self, indata, frames, time, status):
+    """
+    Using amplitude measurements, calculate an uncalibrated sound pressure and sound pressure level.
+    Then apply A-weighting to the raw amplitudes and run the same calculations again.
+
+    Logged A-weighted equivalents are rough approximations of the human-perceived loudness.
+    """
+    msg = messaging.new_message('rawAudioData', valid=True)
+    audio_data_int_16 = (indata[:, 0] * 32767).astype(np.int16)
+    msg.rawAudioData.data = audio_data_int_16.tobytes()
+    msg.rawAudioData.sampleRate = SAMPLE_RATE
+    self.pm.send('rawAudioData', msg)
+
+    with self.lock:
+      self.callback_count += 1
+      self.last_audio_rms = float(np.sqrt(np.mean(np.square(indata[:, 0]))))
+      self.last_audio_peak = float(np.max(np.abs(indata[:, 0])))
+      self.last_status = str(status) if status else None
+      self.measurements = np.concatenate((self.measurements, indata[:, 0]))
+
+      while self.measurements.size >= FFT_SAMPLES:
+        measurements = self.measurements[:FFT_SAMPLES]
+
+        self.sound_pressure, _ = calculate_spl(measurements)
+        measurements_weighted = apply_a_weighting(measurements)
+        self.sound_pressure_weighted, self.sound_pressure_level_weighted = calculate_spl(measurements_weighted)
+
+        self.measurements = self.measurements[FFT_SAMPLES:]
+
+  @retry(attempts=10, delay=3)
+  def get_stream(self, sd):
+    # reload sounddevice to reinitialize portaudio
+    sd._terminate()
+    sd._initialize()
+    requested_device = os.environ.get("MICD_DEVICE")
+    device = int(requested_device) if requested_device is not None else None
+    return sd.InputStream(channels=1, samplerate=SAMPLE_RATE, callback=self.callback, blocksize=SAMPLE_BUFFER, device=device)
+
+  def micd_thread(self):
+    # sounddevice must be imported after forking processes
+    import sounddevice as sd
+
+    device = sd.default.device
+    if os.environ.get("MICD_DEVICE") is not None:
+      device = int(os.environ["MICD_DEVICE"])
+      sd.default.device = (device, device)
+    self.last_device = f"{device}: {sd.query_devices(device)['name']}" if isinstance(device, int) else str(device)
+    cloudlog.info(f"micd selecting input device {self.last_device}")
+
+    while True:
+      try:
+        with self.get_stream(sd) as stream:
+          cloudlog.info(f"micd stream started: {stream.samplerate=} {stream.channels=} {stream.dtype=} {stream.device=}, {stream.blocksize=}")
+          while True:
+            self.update()
+      except Exception:
+        # Some A1s wedge the audio DSP (ALSA EINVAL / ADSP_EFAILED until reboot). Dying here
+        # crash-loops the process and selfdrived raises a takeover alert mid-drive over a
+        # microphone - stay alive and keep retrying instead; recovers if the DSP comes back.
+        cloudlog.exception("micd: audio stream unavailable, retrying")
+        time.sleep(10)
+
+
+def main():
+  mic = Mic()
+  mic.micd_thread()
+
+
+if __name__ == "__main__":
+  main()

artifacts/iqpilot_hephaestusd_private/python/_iqclosure/iqpilot/system/sentry.py

@@ -0,0 +1,171 @@
+"""Install exception handler for process crash."""
+import os
+import shutil
+import traceback
+from datetime import datetime
+import sentry_sdk
+from enum import Enum
+from sentry_sdk.integrations.threading import ThreadingIntegration
+
+from iqpilot.common.params import Params
+from iqpilot.konn3kt.registration import UNREGISTERED_DONGLE_ID
+from iqpilot.system.hardware import HARDWARE
+from iqpilot.system.hardware.hw import Paths
+from iqpilot.common.swaglog import cloudlog
+from iqpilot.system.version import get_build_metadata, get_version
+
+CRASHES_DIR = Paths.crash_log_root()
+CRASH_UPLOADS_DIR = os.path.join(Paths.log_root(), "crash")
+
+
+class SentryProject(Enum):
+  # python project
+  SELFDRIVE = "https://186a6736b7927e5ae9b92c869ba81b6b@o1138119.ingest.us.sentry.io/4508660076052480"
+  # native project
+  SELFDRIVE_NATIVE = SELFDRIVE
+
+
+def _sentry_enabled() -> bool:
+  return os.getenv("IQPILOT_ENABLE_SENTRY", "0") == "1"
+
+
+def _ensure_dir(path: str) -> None:
+  os.makedirs(path, exist_ok=True)
+
+
+def _queue_crash_upload(src: str, name: str | None = None) -> None:
+  try:
+    _ensure_dir(CRASH_UPLOADS_DIR)
+    dest_name = name or os.path.basename(src)
+    shutil.copyfile(src, os.path.join(CRASH_UPLOADS_DIR, dest_name))
+  except Exception:
+    cloudlog.exception("error when attempting to queue crash upload")
+
+
+def report_tombstone(fn: str, message: str, contents: str) -> None:
+  cloudlog.error({'tombstone': message})
+
+  if not _sentry_enabled():
+    return
+
+  with sentry_sdk.configure_scope() as scope:
+    set_user()
+    scope.set_extra("tombstone_fn", fn)
+    scope.set_extra("tombstone", contents)
+    sentry_sdk.capture_message(message=message)
+    sentry_sdk.flush()
+
+
+def capture_exception(*args, **kwargs) -> None:
+  cloudlog.error("crash", exc_info=kwargs.get('exc_info', 1))
+
+  try:
+    save_exception(traceback.format_exc())
+
+    if not _sentry_enabled():
+      return
+
+    set_user()
+    sentry_sdk.capture_exception(*args, **kwargs)
+    sentry_sdk.flush()  # https://github.com/getsentry/sentry-python/issues/291
+  except Exception:
+    cloudlog.exception("sentry exception")
+
+
+def save_exception(content: str) -> None:
+  try:
+    _ensure_dir(CRASHES_DIR)
+    commit = (get_build_metadata().openpilot.git_commit or "nocommit")[:8]
+
+    dated_fn = os.path.join(CRASHES_DIR, datetime.now().strftime("%Y-%m-%d--%H-%M-%S.log"))
+    files = [
+      dated_fn,
+      os.path.join(CRASHES_DIR, "error.log")
+    ]
+
+    for fn in files:
+      with open(fn, 'w') as f:
+        if os.path.basename(fn) == "error.log":
+          lines = content.splitlines()[-3:]
+          f.write("\n".join(lines))
+        else:
+          f.write(content)
+
+    upload_name = f"{os.path.splitext(os.path.basename(dated_fn))[0]}_{commit}_python.log"
+    _queue_crash_upload(dated_fn, upload_name)
+    cloudlog.error(f"logged crash to {files}")
+  except Exception:
+    cloudlog.exception("error when attempting to save exception")
+
+
+def capture_fingerprint_mock() -> None:
+  try:
+    set_user()
+    message = "car doesn't match any fingerprints"
+    sentry_sdk.capture_message(message=message, level="error")
+    sentry_sdk.flush()
+  except Exception as e:
+    cloudlog.exception(f"sentry fingerprint MOCK exception: {e}")
+
+
+def capture_fingerprint(candidate: str, car_name: str) -> None:
+  try:
+    set_user()
+    sentry_sdk.set_tag("carFingerprint", candidate)
+    sentry_sdk.set_tag("carName", car_name)
+
+    message = f"Fingerprinted {candidate}"
+    sentry_sdk.capture_message(message=message, level="info")
+    sentry_sdk.flush()
+  except Exception as e:
+    cloudlog.exception(f"sentry fingerprint exception: {e}")
+
+
+def set_tag(key: str, value: str) -> None:
+  sentry_sdk.set_tag(key, value)
+
+
+def set_user() -> None:
+  dongle_id, git_username = get_properties()
+  sentry_sdk.set_user({"id": dongle_id, "name": git_username})
+
+
+def get_properties() -> tuple[str, str]:
+  params = Params()
+  hardware_serial: str = params.get("HardwareSerial") or ""
+  git_username: str = params.get("GithubUsername") or ""
+  dongle_id: str = params.get("DongleId") or f"{UNREGISTERED_DONGLE_ID}-{hardware_serial}"
+
+  return dongle_id, git_username
+
+
+def init(project: SentryProject) -> bool:
+  if not _sentry_enabled():
+    cloudlog.info("Sentry disabled, using local crash logging + konn3kt uploader")
+    return False
+
+  build_metadata = get_build_metadata()
+
+  env = build_metadata.channel_type
+  dongle_id, git_username = get_properties()
+
+  integrations = []
+  if project == SentryProject.SELFDRIVE:
+    integrations.append(ThreadingIntegration(propagate_hub=True))
+
+  sentry_sdk.init(project.value,
+                  default_integrations=False,
+                  release=get_version(),
+                  integrations=integrations,
+                  traces_sample_rate=1.0,
+                  max_value_length=8192,
+                  environment=env)
+
+  sentry_sdk.set_user({"id": dongle_id, "name": git_username})
+  sentry_sdk.set_tag("dirty", build_metadata.openpilot.is_dirty)
+  sentry_sdk.set_tag("origin", build_metadata.openpilot.git_origin)
+  sentry_sdk.set_tag("branch", build_metadata.channel)
+  sentry_sdk.set_tag("commit", build_metadata.openpilot.git_commit)
+  sentry_sdk.set_tag("device", HARDWARE.get_device_type())
+
+  return True

artifacts/iqpilot_hephaestusd_private/python/_iqclosure/iqpilot/system/ui/lib/networkmanager.py

@@ -0,0 +1,47 @@
+from enum import IntEnum
+
+
+# NetworkManager device states
+class NMDeviceState(IntEnum):
+  UNKNOWN = 0
+  DISCONNECTED = 30
+  PREPARE = 40
+  STATE_CONFIG = 50
+  NEED_AUTH = 60
+  IP_CONFIG = 70
+  ACTIVATED = 100
+  DEACTIVATING = 110
+
+
+# NetworkManager constants
+NM = "org.freedesktop.NetworkManager"
+NM_PATH = '/org/freedesktop/NetworkManager'
+NM_IFACE = 'org.freedesktop.NetworkManager'
+NM_ACCESS_POINT_IFACE = 'org.freedesktop.NetworkManager.AccessPoint'
+NM_SETTINGS_PATH = '/org/freedesktop/NetworkManager/Settings'
+NM_SETTINGS_IFACE = 'org.freedesktop.NetworkManager.Settings'
+NM_CONNECTION_IFACE = 'org.freedesktop.NetworkManager.Settings.Connection'
+NM_ACTIVE_CONNECTION_IFACE = 'org.freedesktop.NetworkManager.Connection.Active'
+NM_WIRELESS_IFACE = 'org.freedesktop.NetworkManager.Device.Wireless'
+NM_PROPERTIES_IFACE = 'org.freedesktop.DBus.Properties'
+NM_DEVICE_IFACE = 'org.freedesktop.NetworkManager.Device'
+NM_IP4_CONFIG_IFACE = 'org.freedesktop.NetworkManager.IP4Config'
+
+NM_DEVICE_TYPE_WIFI = 2
+NM_DEVICE_TYPE_MODEM = 8
+NM_DEVICE_STATE_REASON_SUPPLICANT_DISCONNECT = 8
+NM_DEVICE_STATE_REASON_NEW_ACTIVATION = 60
+
+# https://developer.gnome.org/NetworkManager/1.26/nm-dbus-types.html#NM80211ApFlags
+NM_802_11_AP_FLAGS_NONE = 0x0
+NM_802_11_AP_FLAGS_PRIVACY = 0x1
+NM_802_11_AP_FLAGS_WPS = 0x2
+
+# https://developer.gnome.org/NetworkManager/1.26/nm-dbus-types.html#NM80211ApSecurityFlags
+NM_802_11_AP_SEC_PAIR_WEP40 = 0x00000001
+NM_802_11_AP_SEC_PAIR_WEP104 = 0x00000002
+NM_802_11_AP_SEC_GROUP_WEP40 = 0x00000010
+NM_802_11_AP_SEC_GROUP_WEP104 = 0x00000020
+NM_802_11_AP_SEC_KEY_MGMT_PSK = 0x00000100
+NM_802_11_AP_SEC_KEY_MGMT_802_1X = 0x00000200
+NM_802_11_AP_SEC_KEY_MGMT_SAE = 0x00000400   # WPA3-Personal (SAE)

artifacts/iqpilot_hephaestusd_private/python/_iqclosure/iqpilot/system/ui/lib/os_update.py

@@ -0,0 +1,132 @@
+#!/usr/bin/env python3
+"""
+IQ.OS compatibility check + in-place AGNOS update for the setup flow.
+
+A chosen IQ.Pilot channel may target a newer IQ.OS than the device is running
+(its cloned tree pins the required version in launch_env.sh AGNOS_VERSION). When
+that differs from the running /VERSION, the setup flow flashes the target IQ.OS
+via comma's own agnos.py BEFORE writing continue.sh, so the single reboot lands
+on a compatible OS. The risky flashing is delegated entirely to agnos.py; this
+module only reads versions, picks the right manifest, and streams coarse
+progress.
+"""
+import json
+import os
+import re
+import subprocess
+import threading
+from typing import Callable
+
+VERSION_PATH = "/VERSION"
+
+
+def current_os_version() -> str:
+  try:
+    with open(VERSION_PATH) as f:
+      return f.read().strip()
+  except Exception:
+    return ""
+
+
+def required_agnos_version(install_path: str) -> str:
+  """Read the target OS version the cloned fork pins in launch_env.sh."""
+  path = os.path.join(install_path, "launch_env.sh")
+  try:
+    with open(path) as f:
+      for line in f:
+        m = re.search(r'AGNOS_VERSION\s*=\s*"([^"]+)"', line)
+        if m:
+          return m.group(1).strip()
+  except Exception:
+    pass
+  return ""
+
+
+def agnos_manifest_path(install_path: str, device_type: str) -> str:
+  # comma 3 (tici) uses a different AGNOS manifest than comma 3x (tizi) / comma 4 (mici).
+  fname = "agnos_tici_15_1.json" if device_type == "tici" else "agnos.json"
+  return os.path.join(install_path, "system", "hardware", "tici", fname)
+
+
+def os_update_needed(install_path: str) -> tuple[bool, str, str]:
+  """Returns (needed, current, required)."""
+  current = current_os_version()
+  required = required_agnos_version(install_path)
+  needed = bool(required and current and required != current)
+  return needed, current, required
+
+
+ProgressCb = Callable[[int, str], None]
+
+
+def run_agnos_update(install_path: str, device_type: str, progress_cb: ProgressCb) -> bool:
+  """Flash + swap to the target IQ.OS. Streams coarse partition-level progress
+  via progress_cb(percent, note). Returns True on success. The device must be
+  rebooted by the caller afterward for the new slot to take effect."""
+  manifest = agnos_manifest_path(install_path, device_type)
+  agnos_py = os.path.join(install_path, "system", "hardware", "tici", "agnos.py")
+  if not os.path.isfile(manifest) or not os.path.isfile(agnos_py):
+    progress_cb(0, "manifest_missing")
+    return False
+
+  try:
+    total_partitions = max(1, len(json.load(open(manifest))))
+  except Exception:
+    total_partitions = 1
+
+  progress_cb(1, "starting")
+  try:
+    proc = subprocess.Popen(
+      ["python3", agnos_py, "--swap", manifest],
+      cwd=install_path,
+      stdout=subprocess.PIPE,
+      stderr=subprocess.STDOUT,
+      text=True,
+      env={**os.environ, "PYTHONPATH": install_path},
+    )
+  except Exception:
+    progress_cb(0, "launch_failed")
+    return False
+
+  completed = 0
+  swapping = False
+  assert proc.stdout is not None
+  for line in proc.stdout:
+    line = line.strip()
+    if "Downloading and writing" in line or "Already flashed" in line:
+      completed += 1
+      pct = min(94, int((completed / total_partitions) * 90) + 2)
+      progress_cb(pct, "flashing")
+    elif "Swapping to slot" in line or "AGNOS ready" in line:
+      swapping = True
+      progress_cb(96, "swapping")
+  proc.wait()
+  if proc.returncode == 0:
+    progress_cb(100, "done")
+    return True
+  progress_cb(0, "failed" if not swapping else "swap_failed")
+  return False
+
+
+class OsUpdateCoordinator:
+  """Bridges the setup UI's install thread and the BLE confirmation from the app.
+  The install thread posts a required-update, waits for the phone's confirm, then
+  runs the flash. On-screen setup can confirm locally too."""
+
+  def __init__(self):
+    self.confirmed = threading.Event()
+    self.needed = False
+    self.current = ""
+    self.required = ""
+
+  def request(self, current: str, required: str) -> None:
+    self.needed = True
+    self.current = current
+    self.required = required
+    self.confirmed.clear()
+
+  def confirm(self) -> None:
+    self.confirmed.set()
+
+  def wait_for_confirm(self, timeout: float) -> bool:
+    return self.confirmed.wait(timeout=timeout)

artifacts/iqpilot_hephaestusd_private/python/_iqclosure/iqpilot/system/version.py

@@ -0,0 +1,195 @@
+#!/usr/bin/env python3
+from dataclasses import dataclass
+from functools import cache
+import json
+import os
+import pathlib
+import subprocess
+
+from iqpilot.common.basedir import BASEDIR
+from iqpilot.common.swaglog import cloudlog
+from iqpilot.common.git import get_commit, get_origin, get_branch, get_short_branch, get_commit_date
+
+RELEASE_IQ_BRANCHES = ['release', 'release-tici', 'release-new']
+TESTED_BRANCHES = RELEASE_IQ_BRANCHES
+IQ_BRANCH_MIGRATIONS: dict[tuple[str, str], str] = {}
+
+BUILD_METADATA_FILENAME = "build.json"
+
+training_version: str = "0.2.0"
+terms_version: str = "2"
+
+
+UNKNOWN_VERSION = "0.0.0"
+
+
+@cache
+def get_version(path: str = BASEDIR) -> str:
+  try:
+    with open(os.path.join(path, "iqpilot", "common", "version.h")) as _versionf:
+      return _versionf.read().split('"')[1]
+  except (OSError, IndexError):
+    return UNKNOWN_VERSION
+
+
+def get_release_notes(path: str = BASEDIR) -> str:
+  with open(os.path.join(path, "docs", "CHANGELOG.md")) as f:
+    return f.read().split('\n\n', 1)[0]
+
+
+@cache
+def is_prebuilt(path: str = BASEDIR) -> bool:
+  return os.path.exists(os.path.join(path, 'prebuilt'))
+
+
+@cache
+def is_dirty(cwd: str = BASEDIR) -> bool:
+  if not get_origin() or not get_short_branch():
+    return True
+
+  dirty = False
+  try:
+    # Actually check dirty files
+    if not is_prebuilt(cwd):
+      # This is needed otherwise touched files might show up as modified
+      try:
+        subprocess.check_call(["git", "update-index", "--refresh"], cwd=cwd)
+      except subprocess.CalledProcessError:
+        pass
+
+      branch = get_branch()
+      if not branch:
+        return True
+      dirty = (subprocess.call(["git", "diff-index", "--quiet", branch, "--"], cwd=cwd)) != 0
+  except subprocess.CalledProcessError:
+    cloudlog.exception("git subprocess failed while checking dirty")
+    dirty = True
+
+  return dirty
+
+
+@dataclass
+class OpenpilotMetadata:
+  version: str
+  release_notes: str
+  git_commit: str
+  git_origin: str
+  git_commit_date: str
+  build_style: str
+  is_dirty: bool  # whether there are local changes
+
+  @property
+  def short_version(self) -> str:
+    return self.version.split('-')[0]
+
+  @property
+  def comma_remote(self) -> bool:
+    # note to fork maintainers, this is used for release metrics. please do not
+    # touch this to get rid of the orange startup alert. there's better ways to do that
+    return self.git_normalized_origin == "github.com/commaai/openpilot"
+
+  @property
+  def iqpilot_remote(self) -> bool:
+    return self.git_normalized_origin in ("github.com/iqpilot/iqpilot",
+                                          "github.com/iqpilot/openpilot")
+
+  @property
+  def git_normalized_origin(self) -> str:
+    return self.git_origin \
+      .replace("git@", "", 1) \
+      .replace(".git", "", 1) \
+      .replace("https://", "", 1) \
+      .replace(":", "/", 1)
+
+
+@dataclass
+class BuildMetadata:
+  channel: str
+  openpilot: OpenpilotMetadata
+
+  @property
+  def tested_channel(self) -> bool:
+    return self.channel in TESTED_BRANCHES
+
+  @property
+  def release_channel(self) -> bool:
+    return self.channel in RELEASE_IQ_BRANCHES
+
+  @property
+  def canonical(self) -> str:
+    return f"{self.openpilot.version}-{self.openpilot.git_commit}-{self.openpilot.build_style}"
+
+  @property
+  def ui_description(self) -> str:
+    return f"{self.openpilot.version} / {self.openpilot.git_commit[:6]} / {self.channel}"
+
+  @property
+  def master_channel(self) -> bool:
+    return self.channel in RELEASE_IQ_BRANCHES
+
+  @property
+  def development_channel(self) -> bool:
+    return self.channel == "dev" or self.channel.startswith("dev-") or self.channel.endswith("-prebuilt")
+
+  @property
+  def channel_type(self) -> str:
+    if "-tici" in self.channel or self.channel in ("release-new" or "master-mici"):
+      return "tici"
+    elif self.development_channel:
+      return "development"
+    elif self.tested_channel:
+      return "staging"
+    elif self.master_channel:
+      return "master"
+    elif self.release_channel:
+      return "release"
+    else:
+      return "feature"
+
+
+def build_metadata_from_dict(build_metadata: dict) -> BuildMetadata:
+  channel = build_metadata.get("channel", "unknown")
+  openpilot_metadata = build_metadata.get("openpilot", {})
+  version = openpilot_metadata.get("version", "unknown")
+  release_notes = openpilot_metadata.get("release_notes", "unknown")
+  git_commit = openpilot_metadata.get("git_commit", "unknown")
+  git_origin = openpilot_metadata.get("git_origin", "unknown")
+  git_commit_date = openpilot_metadata.get("git_commit_date", "unknown")
+  build_style = openpilot_metadata.get("build_style", "unknown")
+  return BuildMetadata(channel,
+            OpenpilotMetadata(
+              version=version,
+              release_notes=release_notes,
+              git_commit=git_commit,
+              git_origin=git_origin,
+              git_commit_date=git_commit_date,
+              build_style=build_style,
+              is_dirty=False))
+
+
+def get_build_metadata(path: str = BASEDIR) -> BuildMetadata:
+  build_metadata_path = pathlib.Path(path) / BUILD_METADATA_FILENAME
+
+  if build_metadata_path.exists():
+    build_metadata = json.loads(build_metadata_path.read_text())
+    return build_metadata_from_dict(build_metadata)
+
+  git_folder = pathlib.Path(path) / ".git"
+
+  if git_folder.exists():
+    return BuildMetadata(get_short_branch(path),
+                    OpenpilotMetadata(
+                      version=get_version(path),
+                      release_notes=get_release_notes(path),
+                      git_commit=get_commit(path),
+                      git_origin=get_origin(path),
+                      git_commit_date=get_commit_date(path),
+                      build_style="unknown",
+                      is_dirty=is_dirty(path)))
+
+  cloudlog.exception("unable to get build metadata")
+  raise Exception("invalid build metadata")
+
+
+if __name__ == "__main__":
+  print(get_build_metadata())